Official Go implementation of the Ethereum protocol
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 
go-ethereum/vendor/github.com/robertkrimen/otto/inline.pl

1086 lines
26 KiB

#!/usr/bin/env perl
my $_fmt;
$_fmt = "gofmt";
$_fmt = "cat -n" if "cat" eq ($ARGV[0] || "");
use strict;
use warnings;
use IO::File;
my $self = __PACKAGE__;
sub functionLabel ($) {
return "$_[0]_function";
}
sub trim ($) {
local $_ = shift;
s/^\s*//, s/\s*$// for $_;
return $_;
}
open my $fmt, "|-", "$_fmt" or die $!;
$fmt->print(<<_END_);
package otto
import (
"math"
)
func _newContext(runtime *_runtime) {
@{[ join "\n", $self->newContext() ]}
}
func newConsoleObject(runtime *_runtime) *_object {
@{[ join "\n", $self->newConsoleObject() ]}
}
_END_
for (qw/int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 float32 float64/) {
$fmt->print(<<_END_);
func toValue_$_(value $_) Value {
return Value{
kind: valueNumber,
value: value,
}
}
_END_
}
$fmt->print(<<_END_);
func toValue_string(value string) Value {
return Value{
kind: valueString,
value: value,
}
}
func toValue_string16(value []uint16) Value {
return Value{
kind: valueString,
value: value,
}
}
func toValue_bool(value bool) Value {
return Value{
kind: valueBoolean,
value: value,
}
}
func toValue_object(value *_object) Value {
return Value{
kind: valueObject,
value: value,
}
}
_END_
close $fmt;
sub newConsoleObject {
my $self = shift;
return
$self->block(sub {
my $class = "Console";
my @got = $self->functionDeclare(
$class,
"log", 0,
"debug:log", 0,
"info:log", 0,
"error", 0,
"warn:error", 0,
"dir", 0,
"time", 0,
"timeEnd", 0,
"trace", 0,
"assert", 0,
);
return
"return @{[ $self->newObject(@got) ]}"
}),
;
}
sub newContext {
my $self = shift;
return
# ObjectPrototype
$self->block(sub {
my $class = "Object";
return
".${class}Prototype =",
$self->globalPrototype(
$class,
"_classObject",
undef,
"prototypeValueObject",
),
}),
# FunctionPrototype
$self->block(sub {
my $class = "Function";
return
".${class}Prototype =",
$self->globalPrototype(
$class,
"_classObject",
".ObjectPrototype",
"prototypeValueFunction",
),
}),
# ObjectPrototype
$self->block(sub {
my $class = "Object";
my @got = $self->functionDeclare(
$class,
"valueOf", 0,
"toString", 0,
"toLocaleString", 0,
"hasOwnProperty", 1,
"isPrototypeOf", 1,
"propertyIsEnumerable", 1,
);
my @propertyMap = $self->propertyMap(
@got,
$self->property("constructor", undef),
);
my $propertyOrder = $self->propertyOrder(@propertyMap);
$propertyOrder =~ s/^propertyOrder: //;
return
".${class}Prototype.property =", @propertyMap,
".${class}Prototype.propertyOrder =", $propertyOrder,
}),
# FunctionPrototype
$self->block(sub {
my $class = "Function";
my @got = $self->functionDeclare(
$class,
"toString", 0,
"apply", 2,
"call", 1,
"bind", 1,
);
my @propertyMap = $self->propertyMap(
@got,
$self->property("constructor", undef),
$self->property("length", $self->numberValue(0), "0"),
);
my $propertyOrder = $self->propertyOrder(@propertyMap);
$propertyOrder =~ s/^propertyOrder: //;
return
".${class}Prototype.property =", @propertyMap,
".${class}Prototype.propertyOrder =", $propertyOrder,
}),
# Object
$self->block(sub {
my $class = "Object";
return
".$class =",
$self->globalFunction(
$class,
1,
$self->functionDeclare(
$class,
"getPrototypeOf", 1,
"getOwnPropertyDescriptor", 2,
"defineProperty", 3,
"defineProperties", 2,
"create", 2,
"isExtensible", 1,
"preventExtensions", 1,
"isSealed", 1,
"seal", 1,
"isFrozen", 1,
"freeze", 1,
"keys", 1,
"getOwnPropertyNames", 1,
),
),
}),
# Function
$self->block(sub {
my $class = "Function";
return
"Function :=",
$self->globalFunction(
$class,
1,
),
".$class = Function",
}),
# Array
$self->block(sub {
my $class = "Array";
my @got = $self->functionDeclare(
$class,
"toString", 0,
"toLocaleString", 0,
"concat", 1,
"join", 1,
"splice", 2,
"shift", 0,
"pop", 0,
"push", 1,
"slice", 2,
"unshift", 1,
"reverse", 0,
"sort", 1,
"indexOf", 1,
"lastIndexOf", 1,
"every", 1,
"some", 1,
"forEach", 1,
"map", 1,
"filter", 1,
"reduce", 1,
"reduceRight", 1,
);
return
".${class}Prototype =",
$self->globalPrototype(
$class,
"_classArray",
".ObjectPrototype",
undef,
$self->property("length", $self->numberValue("uint32(0)"), "0100"),
@got,
),
".$class =",
$self->globalFunction(
$class,
1,
$self->functionDeclare(
$class,
"isArray", 1,
),
),
}),
# String
$self->block(sub {
my $class = "String";
my @got = $self->functionDeclare(
$class,
"toString", 0,
"valueOf", 0,
"charAt", 1,
"charCodeAt", 1,
"concat", 1,
"indexOf", 1,
"lastIndexOf", 1,
"match", 1,
"replace", 2,
"search", 1,
"split", 2,
"slice", 2,
"substring", 2,
"toLowerCase", 0,
"toUpperCase", 0,
"substr", 2,
"trim", 0,
"trimLeft", 0,
"trimRight", 0,
"localeCompare", 1,
"toLocaleLowerCase", 0,
"toLocaleUpperCase", 0,
);
return
".${class}Prototype =",
$self->globalPrototype(
$class,
"_classString",
".ObjectPrototype",
"prototypeValueString",
$self->property("length", $self->numberValue("int(0)"), "0"),
@got,
),
".$class =",
$self->globalFunction(
$class,
1,
$self->functionDeclare(
$class,
"fromCharCode", 1,
),
),
}),
# Boolean
$self->block(sub {
my $class = "Boolean";
my @got = $self->functionDeclare(
$class,
"toString", 0,
"valueOf", 0,
);
return
".${class}Prototype =",
$self->globalPrototype(
$class,
"_classObject",
".ObjectPrototype",
"prototypeValueBoolean",
@got,
),
".$class =",
$self->globalFunction(
$class,
1,
$self->functionDeclare(
$class,
),
),
}),
# Number
$self->block(sub {
my $class = "Number";
my @got = $self->functionDeclare(
$class,
"toString", 0,
"valueOf", 0,
"toFixed", 1,
"toExponential", 1,
"toPrecision", 1,
"toLocaleString", 1,
);
return
".${class}Prototype =",
$self->globalPrototype(
$class,
"_classObject",
".ObjectPrototype",
"prototypeValueNumber",
@got,
),
".$class =",
$self->globalFunction(
$class,
1,
$self->functionDeclare(
$class,
),
$self->numberConstantDeclare(
"MAX_VALUE", "math.MaxFloat64",
"MIN_VALUE", "math.SmallestNonzeroFloat64",
"NaN", "math.NaN()",
"NEGATIVE_INFINITY", "math.Inf(-1)",
"POSITIVE_INFINITY", "math.Inf(+1)",
),
),
}),
# Math
$self->block(sub {
my $class = "Math";
return
".$class =",
$self->globalObject(
$class,
$self->functionDeclare(
$class,
"abs", 1,
"acos", 1,
"asin", 1,
"atan", 1,
"atan2", 1,
"ceil", 1,
"cos", 1,
"exp", 1,
"floor", 1,
"log", 1,
"max", 2,
"min", 2,
"pow", 2,
"random", 0,
"round", 1,
"sin", 1,
"sqrt", 1,
"tan", 1,
),
$self->numberConstantDeclare(
"E", "math.E",
"LN10", "math.Ln10",
"LN2", "math.Ln2",
"LOG2E", "math.Log2E",
"LOG10E", "math.Log10E",
"PI", "math.Pi",
"SQRT1_2", "sqrt1_2",
"SQRT2", "math.Sqrt2",
)
),
}),
# Date
$self->block(sub {
my $class = "Date";
my @got = $self->functionDeclare(
$class,
"toString", 0,
"toDateString", 0,
"toTimeString", 0,
"toUTCString", 0,
"toISOString", 0,
"toJSON", 1,
"toGMTString", 0,
"toLocaleString", 0,
"toLocaleDateString", 0,
"toLocaleTimeString", 0,
"valueOf", 0,
"getTime", 0,
"getYear", 0,
"getFullYear", 0,
"getUTCFullYear", 0,
"getMonth", 0,
"getUTCMonth", 0,
"getDate", 0,
"getUTCDate", 0,
"getDay", 0,
"getUTCDay", 0,
"getHours", 0,
"getUTCHours", 0,
"getMinutes", 0,
"getUTCMinutes", 0,
"getSeconds", 0,
"getUTCSeconds", 0,
"getMilliseconds", 0,
"getUTCMilliseconds", 0,
"getTimezoneOffset", 0,
"setTime", 1,
"setMilliseconds", 1,
"setUTCMilliseconds", 1,
"setSeconds", 2,
"setUTCSeconds", 2,
"setMinutes", 3,
"setUTCMinutes", 3,
"setHours", 4,
"setUTCHours", 4,
"setDate", 1,
"setUTCDate", 1,
"setMonth", 2,
"setUTCMonth", 2,
"setYear", 1,
"setFullYear", 3,
"setUTCFullYear", 3,
);
return
".${class}Prototype =",
$self->globalPrototype(
$class,
"_classObject",
".ObjectPrototype",
"prototypeValueDate",
@got,
),
".$class =",
$self->globalFunction(
$class,
7,
$self->functionDeclare(
$class,
"parse", 1,
"UTC", 7,
"now", 0,
),
),
}),
# RegExp
$self->block(sub {
my $class = "RegExp";
my @got = $self->functionDeclare(
$class,
"toString", 0,
"exec", 1,
"test", 1,
"compile", 1,
);
return
".${class}Prototype =",
$self->globalPrototype(
$class,
"_classObject",
".ObjectPrototype",
"prototypeValueRegExp",
@got,
),
".$class =",
$self->globalFunction(
$class,
2,
$self->functionDeclare(
$class,
),
),
}),
# Error
$self->block(sub {
my $class = "Error";
my @got = $self->functionDeclare(
$class,
"toString", 0,
);
return
".${class}Prototype =",
$self->globalPrototype(
$class,
"_classObject",
".ObjectPrototype",
undef,
@got,
$self->property("name", $self->stringValue("Error")),
$self->property("message", $self->stringValue("")),
),
".$class =",
$self->globalFunction(
$class,
1,
$self->functionDeclare(
$class,
),
),
}),
(map {
my $class = "${_}Error";
$self->block(sub {
my @got = $self->functionDeclare(
$class,
);
return
".${class}Prototype =",
$self->globalPrototype(
$class,
"_classObject",
".ErrorPrototype",
undef,
@got,
$self->property("name", $self->stringValue($class)),
),
".$class =",
$self->globalFunction(
$class,
1,
$self->functionDeclare(
$class,
),
),
});
} qw/Eval Type Range Reference Syntax URI/),
# JSON
$self->block(sub {
my $class = "JSON";
return
".$class =",
$self->globalObject(
$class,
$self->functionDeclare(
$class,
"parse", 2,
"stringify", 3,
),
),
}),
# Global
$self->block(sub {
my $class = "Global";
my @got = $self->functionDeclare(
$class,
"eval", 1,
"parseInt", 2,
"parseFloat", 1,
"isNaN", 1,
"isFinite", 1,
"decodeURI", 1,
"decodeURIComponent", 1,
"encodeURI", 1,
"encodeURIComponent", 1,
"escape", 1,
"unescape", 1,
);
my @propertyMap = $self->propertyMap(
@got,
$self->globalDeclare(
"Object",
"Function",
"Array",
"String",
"Boolean",
"Number",
"Math",
"Date",
"RegExp",
"Error",
"EvalError",
"TypeError",
"RangeError",
"ReferenceError",
"SyntaxError",
"URIError",
"JSON",
),
$self->property("undefined", $self->undefinedValue(), "0"),
$self->property("NaN", $self->numberValue("math.NaN()"), "0"),
$self->property("Infinity", $self->numberValue("math.Inf(+1)"), "0"),
);
my $propertyOrder = $self->propertyOrder(@propertyMap);
$propertyOrder =~ s/^propertyOrder: //;
return
"runtime.globalObject.property =",
@propertyMap,
"runtime.globalObject.propertyOrder =",
$propertyOrder,
;
}),
;
}
sub propertyMap {
my $self = shift;
return "map[string]_property{", (join ",\n", @_, ""), "}",
}
our (@preblock, @postblock);
sub block {
my $self = shift;
local @preblock = ();
local @postblock = ();
my @input = $_[0]->();
my @output;
while (@input) {
local $_ = shift @input;
if (m/^\./) {
$_ = "runtime.global$_";
}
if (m/ :?=$/) {
$_ .= shift @input;
}
push @output, $_;
}
return
"{",
@preblock,
@output,
@postblock,
"}",
;
}
sub numberConstantDeclare {
my $self = shift;
my @got;
while (@_) {
my $name = shift;
my $value = shift;
push @got, $self->property($name, $self->numberValue($value), "0"),
}
return @got;
}
sub functionDeclare {
my $self = shift;
my $class = shift;
my $builtin = "builtin${class}";
my @got;
while (@_) {
my $name = shift;
my $length = shift;
$name = $self->newFunction($name, "${builtin}_", $length);
push @got, $self->functionProperty($name),
}
return @got;
}
sub globalDeclare {
my $self = shift;
my @got;
while (@_) {
my $name = shift;
push @got, $self->property($name, $self->objectValue("runtime.global.$name"), "0101"),
}
return @got;
}
sub propertyOrder {
my $self = shift;
my $propertyMap = join "", @_;
my (@keys) = $propertyMap =~ m/("\w+"):/g;
my $propertyOrder =
join "\n", "propertyOrder: []string{", (join ",\n", @keys, ""), "}";
return $propertyOrder;
}
sub globalObject {
my $self = shift;
my $name = shift;
my $propertyMap = "";
if (@_) {
$propertyMap = join "\n", $self->propertyMap(@_);
my $propertyOrder = $self->propertyOrder($propertyMap);
$propertyMap = "property: $propertyMap,\n$propertyOrder,";
}
return trim <<_END_;
&_object{
runtime: runtime,
class: "$name",
objectClass: _classObject,
prototype: runtime.global.ObjectPrototype,
extensible: true,
$propertyMap
}
_END_
}
sub globalFunction {
my $self = shift;
my $name = shift;
my $length = shift;
my $builtin = "builtin${name}";
my $builtinNew = "builtinNew${name}";
my $prototype = "runtime.global.${name}Prototype";
my $propertyMap = "";
unshift @_,
$self->property("length", $self->numberValue($length), "0"),
$self->property("prototype", $self->objectValue($prototype), "0"),
;
if (@_) {
$propertyMap = join "\n", $self->propertyMap(@_);
my $propertyOrder = $self->propertyOrder($propertyMap);
$propertyMap = "property: $propertyMap,\n$propertyOrder,";
}
push @postblock, $self->statement(
"$prototype.property[\"constructor\"] =",
$self->property(undef, $self->objectValue("runtime.global.${name}"), "0101"),
);
return trim <<_END_;
&_object{
runtime: runtime,
class: "Function",
objectClass: _classObject,
prototype: runtime.global.FunctionPrototype,
extensible: true,
value: @{[ $self->nativeFunctionOf($name, $builtin, $builtinNew) ]},
$propertyMap
}
_END_
}
sub nativeCallFunction {
my $self = shift;
my $name = shift;
my $func = shift;
return trim <<_END_;
_nativeCallFunction{ "$name", $func }
_END_
}
sub globalPrototype {
my $self = shift;
my $class = shift;
my $classObject = shift;
my $prototype = shift;
my $value = shift;
if (!defined $prototype) {
$prototype = "nil";
}
if (!defined $value) {
$value = "nil";
}
if ($prototype =~ m/^\./) {
$prototype = "runtime.global$prototype";
}
my $propertyMap = "";
if (@_) {
$propertyMap = join "\n", $self->propertyMap(@_);
my $propertyOrder = $self->propertyOrder($propertyMap);
$propertyMap = "property: $propertyMap,\n$propertyOrder,";
}
return trim <<_END_;
&_object{
runtime: runtime,
class: "$class",
objectClass: $classObject,
prototype: $prototype,
extensible: true,
value: $value,
$propertyMap
}
_END_
}
sub newFunction {
my $self = shift;
my $name = shift;
my $func = shift;
my $length = shift;
my @name = ($name, $name);
if ($name =~ m/^(\w+):(\w+)$/) {
@name = ($1, $2);
$name = $name[0];
}
if ($func =~ m/^builtin\w+_$/) {
$func = "$func$name[1]";
}
my $propertyOrder = "";
my @propertyMap = (
$self->property("length", $self->numberValue($length), "0"),
);
if (@propertyMap) {
$propertyOrder = $self->propertyOrder(@propertyMap);
$propertyOrder = "$propertyOrder,";
}
my $label = functionLabel($name);
push @preblock, $self->statement(
"$label := @{[ trim <<_END_ ]}",
&_object{
runtime: runtime,
class: "Function",
objectClass: _classObject,
prototype: runtime.global.FunctionPrototype,
extensible: true,
property: @{[ join "\n", $self->propertyMap(@propertyMap) ]},
$propertyOrder
value: @{[ $self->nativeFunctionOf($name, $func) ]},
}
_END_
);
return $name;
}
sub newObject {
my $self = shift;
my $propertyMap = join "\n", $self->propertyMap(@_);
my $propertyOrder = $self->propertyOrder($propertyMap);
return trim <<_END_;
&_object{
runtime: runtime,
class: "Object",
objectClass: _classObject,
prototype: runtime.global.ObjectPrototype,
extensible: true,
property: $propertyMap,
$propertyOrder,
}
_END_
}
sub newPrototypeObject {
my $self = shift;
my $class = shift;
my $objectClass = shift;
my $value = shift;
if (defined $value) {
$value = "value: $value,";
}
my $propertyMap = join "\n", $self->propertyMap(@_);
my $propertyOrder = $self->propertyOrder($propertyMap);
return trim <<_END_;
&_object{
runtime: runtime,
class: "$class",
objectClass: $objectClass,
prototype: runtime.global.ObjectPrototype,
extensible: true,
property: $propertyMap,
$propertyOrder,
$value
}
_END_
}
sub functionProperty {
my $self = shift;
my $name = shift;
return $self->property(
$name,
$self->objectValue(functionLabel($name))
);
}
sub statement {
my $self = shift;
return join "\n", @_;
}
sub functionOf {
my $self = shift;
my $call = shift;
my $construct = shift;
if ($construct) {
$construct = "construct: $construct,";
} else {
$construct = "";
}
return trim <<_END_
_functionObject{
call: $call,
$construct
}
_END_
}
sub nativeFunctionOf {
my $self = shift;
my $name = shift;
my $call = shift;
my $construct = shift;
if ($construct) {
$construct = "construct: $construct,";
} else {
$construct = "";
}
return trim <<_END_
_nativeFunctionObject{
name: "$name",
call: $call,
$construct
}
_END_
}
sub nameProperty {
my $self = shift;
my $name = shift;
my $value = shift;
return trim <<_END_;
"$name": _property{
mode: 0101,
value: $value,
}
_END_
}
sub numberValue {
my $self = shift;
my $value = shift;
return trim <<_END_;
Value{
kind: valueNumber,
value: $value,
}
_END_
}
sub property {
my $self = shift;
my $name = shift;
my $value = shift;
my $mode = shift;
$mode = "0101" unless defined $mode;
if (! defined $value) {
$value = "Value{}";
}
if (defined $name) {
return trim <<_END_;
"$name": _property{
mode: $mode,
value: $value,
}
_END_
} else {
return trim <<_END_;
_property{
mode: $mode,
value: $value,
}
_END_
}
}
sub objectProperty {
my $self = shift;
my $name = shift;
my $value = shift;
return trim <<_END_;
"$name": _property{
mode: 0101,
value: @{[ $self->objectValue($value)]},
}
_END_
}
sub objectValue {
my $self = shift;
my $value = shift;
return trim <<_END_
Value{
kind: valueObject,
value: $value,
}
_END_
}
sub stringValue {
my $self = shift;
my $value = shift;
return trim <<_END_
Value{
kind: valueString,
value: "$value",
}
_END_
}
sub booleanValue {
my $self = shift;
my $value = shift;
return trim <<_END_
Value{
kind: valueBoolean,
value: $value,
}
_END_
}
sub undefinedValue {
my $self = shift;
return trim <<_END_
Value{
kind: valueUndefined,
}
_END_
}