From 243002e5f3e491b91f017e3ac1371ed45a716f3b Mon Sep 17 00:00:00 2001 From: chriseth Date: Mon, 3 Apr 2017 19:17:17 +0200 Subject: Describe Julia. --- docs/assembly.rst | 125 +++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 114 insertions(+), 11 deletions(-) diff --git a/docs/assembly.rst b/docs/assembly.rst index f5abcdc8..ce45c55c 100644 --- a/docs/assembly.rst +++ b/docs/assembly.rst @@ -1,18 +1,116 @@ -################# -Solidity Assembly -################# +################################################# +Joyfully Universal Language for (Inline) Assembly +################################################# + +.. _julia: .. index:: ! assembly, ! asm, ! evmasm -Solidity defines an assembly language that can also be used without Solidity. -This assembly language can also be used as "inline assembly" inside Solidity -source code. We start with describing how to use inline assembly and how it -differs from standalone assembly and then specify assembly itself. +Julia is an intermediate language that can compile to various different backends +(EVM 1.0, EVM 1.5 and eWASM are planned). +Because of that, it is designed to be as featureless as possible. +It can already be used for "inline assembly" inside Solidity and +future versions of the Solidity compiler will even use Julia as intermediate +language. It should also be easy to build high-level optimizer stages for Julia. -.. note:: - TODO: Write about how scoping rules of inline assembly are a bit different - and the complications that arise when for example using internal functions - of libraries. Furthermore, write about the symbols defined by the compiler. +The core components of Julia are functions, blocks, variables, literals, +for-loops, switch-statements, expressions and assignments to variables. + +Julia in itself does not even provide operators. If the EVM is targeted, +opcodes will be available as built-in functions, but they can be reimplemented +if the backend changes. + +The following example program assumes that the EVM opcodes ``mul``, ``div`` +and ``mod`` are available either natively or as functions and computes exponentiation. + +.. code:: + { + function power(base, exponent) -> (result) + { + switch exponent + 0: { result := 1 } + 1: { result := base } + default: + { + result := power(mul(base, base), div(exponent, 2)) + switch mod(exponent, 2) + 1: { result := mul(base, result) } + } + } + } + +It is also possible to implement the same function using a for-loop +instead of recursion. Here, we need the EVM opcodes ``lt`` (less-than) +and ``add`` to be available. + +.. code:: + { + function power(base, exponent) -> (result) + { + result := 1 + for { let i := 0 } lt(i, exponent) { i := add(i, 1) } + { + result := mul(result, base) + } + } + } + +Specification of Julia +====================== + +Grammar:: + + Block = '{' Statement* '}' + Statement = + Block | + FunctionDefinition | + VariableDeclaration | + Assignment | + Expression | + Switch | + ForLoop | + 'break' | 'continue' + SubAssembly + FunctionDefinition = + 'function' Identifier '(' IdentifierList? ')' + ( '->' '(' IdentifierList ')' )? Block + VariableDeclaration = + 'let' IdentifierOrList ':=' Expression + Assignment = + IdentifierOrList ':=' Expression + Expression = + Identifier | Literal | FunctionCall + Switch = + 'switch' Expression Case* ( 'default' ':' Block )? + Case = + 'case' Expression ':' Block + ForLoop = + 'for' Block Expression Block Block + SubAssembly = + 'assembly' Identifier Block + FunctionCall = + Identifier '(' ( AssemblyItem ( ',' AssemblyItem )* )? ')' + IdentifierOrList = Identifier | '(' IdentifierList ')' + Identifier = [a-zA-Z_$] [a-zA-Z_0-9]* + IdentifierList = Identifier ( ',' Identifier)* + Literal = + NumberLiteral | StringLiteral | HexLiteral + NumberLiteral = HexNumber | DecimalNumber + HexLiteral = 'hex' ('"' ([0-9a-fA-F]{2})* '"' | '\'' ([0-9a-fA-F]{2})* '\'') + StringLiteral = '"' ([^"\r\n\\] | '\\' .)* '"' + HexNumber = '0x' [0-9a-fA-F]+ + DecimalNumber = [0-9]+ + + + + | 'dataSize' '(' Identifier ')' | + LinkerSymbol | + 'bytecodeSize' | + +Restriction for Expression: Functions can only return single item, +top level has to return nothing. +Restriction for VariableDeclaration and Assignment: Number of elements left and right needs to be the same +continue and break only in for loop .. _inline-assembly: @@ -41,6 +139,11 @@ We now want to describe the inline assembly language in detail. at a low level. This discards several important safety features of Solidity. +.. note:: + TODO: Write about how scoping rules of inline assembly are a bit different + and the complications that arise when for example using internal functions + of libraries. Furthermore, write about the symbols defined by the compiler. + Example ------- -- cgit v1.2.3 From f73660423ab2a2ff340624fcbbb67f891ace95a2 Mon Sep 17 00:00:00 2001 From: chriseth Date: Tue, 4 Apr 2017 14:20:43 +0200 Subject: First take in formal specification. --- docs/assembly.rst | 107 +++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 94 insertions(+), 13 deletions(-) diff --git a/docs/assembly.rst b/docs/assembly.rst index ce45c55c..a06c616d 100644 --- a/docs/assembly.rst +++ b/docs/assembly.rst @@ -6,17 +6,17 @@ Joyfully Universal Language for (Inline) Assembly .. index:: ! assembly, ! asm, ! evmasm -Julia is an intermediate language that can compile to various different backends +JULIA is an intermediate language that can compile to various different backends (EVM 1.0, EVM 1.5 and eWASM are planned). Because of that, it is designed to be as featureless as possible. It can already be used for "inline assembly" inside Solidity and -future versions of the Solidity compiler will even use Julia as intermediate -language. It should also be easy to build high-level optimizer stages for Julia. +future versions of the Solidity compiler will even use JULIA as intermediate +language. It should also be easy to build high-level optimizer stages for JULIA. -The core components of Julia are functions, blocks, variables, literals, +The core components of JULIA are functions, blocks, variables, literals, for-loops, switch-statements, expressions and assignments to variables. -Julia in itself does not even provide operators. If the EVM is targeted, +JULIA in itself does not even provide operators. If the EVM is targeted, opcodes will be available as built-in functions, but they can be reimplemented if the backend changes. @@ -55,7 +55,7 @@ and ``add`` to be available. } } -Specification of Julia +Specification of JULIA ====================== Grammar:: @@ -69,7 +69,7 @@ Grammar:: Expression | Switch | ForLoop | - 'break' | 'continue' + BreakContinue | SubAssembly FunctionDefinition = 'function' Identifier '(' IdentifierList? ')' @@ -79,17 +79,19 @@ Grammar:: Assignment = IdentifierOrList ':=' Expression Expression = - Identifier | Literal | FunctionCall + FunctionCall | Identifier | Literal Switch = 'switch' Expression Case* ( 'default' ':' Block )? Case = 'case' Expression ':' Block ForLoop = 'for' Block Expression Block Block + BreakContinue = + 'break' | 'continue' SubAssembly = 'assembly' Identifier Block FunctionCall = - Identifier '(' ( AssemblyItem ( ',' AssemblyItem )* )? ')' + Identifier '(' ( Expression ( ',' Expression )* )? ')' IdentifierOrList = Identifier | '(' IdentifierList ')' Identifier = [a-zA-Z_$] [a-zA-Z_0-9]* IdentifierList = Identifier ( ',' Identifier)* @@ -101,16 +103,95 @@ Grammar:: HexNumber = '0x' [0-9a-fA-F]+ DecimalNumber = [0-9]+ +Restrictions on the Grammar +--------------------------- + +Scopes in JULIA are tied to Blocks and all declarations +(``FunctionDefinition``, ``VariableDeclaration`` and ``SubAssembly``) +introduce new identifiers into these scopes. Shadowing is disallowed + +Talk about identifiers across functions etc + + +Restriction for Expression: Statements have to return empty tuple +Function arguments have to be single item + +Restriction for VariableDeclaration and Assignment: Number of elements left and right needs to be the same +continue and break only in for loop + +Literals have to fit 32 bytes + | 'dataSize' '(' Identifier ')' | LinkerSymbol | 'bytecodeSize' | -Restriction for Expression: Functions can only return single item, -top level has to return nothing. -Restriction for VariableDeclaration and Assignment: Number of elements left and right needs to be the same -continue and break only in for loop + +Formal Specification +-------------------- + +We formally specify JULIA by providing an evaluation function E overloaded +on the various nodes of the AST. Any functions can have side effects, so +E takes a state objects and the actual argument and also returns new +state objects and new arguments. There is a global state object +(which in the context of the EVM is the memory, storage and state of the +blockchain) and a local state object (the state of local variables, i.e. a +segment of the stack in the EVM). + +The the evaluation function E takes a global state, a local state and +a node of the AST and returns a new global state, a new local state +and a value (if the AST node is an expression). + +We use sequence numbers as a shorthand for the order of evaluation +and how state is forwarded. For example, ``E2(x), E1(y)`` is a shorthand +for + +For ``(S1, z) = E(S, y)`` let ``(S2, w) = E(S1, x)``. TODO + +.. code:: + E(G, L, <{St1, ..., Stn}>: Block) = + let L' be a copy of L that adds a new inner scope which contains + all functions and variables declared in the block (but not its sub-blocks) + variables are marked inactive for now + TODO: more formal + G1, L'1 = E(G, L', St1) + G2, L'2 = E(G1, L'1, St2) + ... + Gn, L'n = E(G(n-1), L'(n-1), Stn) + let L'' be a copy of L'n where the innermost scope is removed + Gn, L'' + E(G, L, (ret1, ..., retm) block>: FunctionDefinition) = + G, L + E(G, L, : VariableDeclaration) = + E(G, L, <(var1, ..., varn) := value>: Assignment) + E(G, L, <(var1, ..., varn) := value>: Assignment) = + let G', L', v1, ..., vn = E(G, L, value) + let L'' be a copy of L' where L'[vi] = vi for i = 1, ..., n + G, L'' + E(G, L, name: Identifier) = + G, L, L[name] + E(G, L, fname(arg1, ..., argn): FunctionCall) = + G1, L1, vn = E(G, L, argn) + ... + G(n-1), L(n-1), v2 = E(G(n-2), L(n-2), arg2) + Gn, Ln, v1 = E(G(n-1), L(n-1), arg1) + Let (ret1, ..., retm) block> + be the function L[fname]. + Let L' be a copy of L that does not contain any variables in any scope, + but which has a new innermost scope such that + L'[parami] = vi and L'[reti] = 0 + Let G'', L'', rv1, ..., rvm = E(Gn, L', block) + G'', Ln, rv1, ..., rvm + E(G, L, l: HexLiteral) = G, L, hexString(l), + where hexString decodes l from hex and left-aligns in into 32 bytes + E(G, L, l: StringLiteral) = G, L, utf8EncodeLeftAligned(l), + where utf8EncodeLeftAligned performs a utf8 encoding of l + and aligns it left into 32 bytes + E(G, L, n: HexNumber) = G, L, hex(n) + where hex is the hexadecimal decoding function + E(G, L, n: DecimalNumber) = G, L, dec(n), + where dec is the decimal decoding function .. _inline-assembly: -- cgit v1.2.3 From 2a91eb953850b83b121867d95ba1cf6541b4ce7c Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Tue, 18 Apr 2017 13:12:04 +0100 Subject: Move Julia documentation to its own file --- docs/assembly.rst | 198 ++---------------------------------------------------- docs/julia.rst | 189 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 196 insertions(+), 191 deletions(-) create mode 100644 docs/julia.rst diff --git a/docs/assembly.rst b/docs/assembly.rst index a06c616d..00bfb388 100644 --- a/docs/assembly.rst +++ b/docs/assembly.rst @@ -1,197 +1,13 @@ -################################################# -Joyfully Universal Language for (Inline) Assembly -################################################# - -.. _julia: +################# +Solidity Assembly +################# .. index:: ! assembly, ! asm, ! evmasm -JULIA is an intermediate language that can compile to various different backends -(EVM 1.0, EVM 1.5 and eWASM are planned). -Because of that, it is designed to be as featureless as possible. -It can already be used for "inline assembly" inside Solidity and -future versions of the Solidity compiler will even use JULIA as intermediate -language. It should also be easy to build high-level optimizer stages for JULIA. - -The core components of JULIA are functions, blocks, variables, literals, -for-loops, switch-statements, expressions and assignments to variables. - -JULIA in itself does not even provide operators. If the EVM is targeted, -opcodes will be available as built-in functions, but they can be reimplemented -if the backend changes. - -The following example program assumes that the EVM opcodes ``mul``, ``div`` -and ``mod`` are available either natively or as functions and computes exponentiation. - -.. code:: - { - function power(base, exponent) -> (result) - { - switch exponent - 0: { result := 1 } - 1: { result := base } - default: - { - result := power(mul(base, base), div(exponent, 2)) - switch mod(exponent, 2) - 1: { result := mul(base, result) } - } - } - } - -It is also possible to implement the same function using a for-loop -instead of recursion. Here, we need the EVM opcodes ``lt`` (less-than) -and ``add`` to be available. - -.. code:: - { - function power(base, exponent) -> (result) - { - result := 1 - for { let i := 0 } lt(i, exponent) { i := add(i, 1) } - { - result := mul(result, base) - } - } - } - -Specification of JULIA -====================== - -Grammar:: - - Block = '{' Statement* '}' - Statement = - Block | - FunctionDefinition | - VariableDeclaration | - Assignment | - Expression | - Switch | - ForLoop | - BreakContinue | - SubAssembly - FunctionDefinition = - 'function' Identifier '(' IdentifierList? ')' - ( '->' '(' IdentifierList ')' )? Block - VariableDeclaration = - 'let' IdentifierOrList ':=' Expression - Assignment = - IdentifierOrList ':=' Expression - Expression = - FunctionCall | Identifier | Literal - Switch = - 'switch' Expression Case* ( 'default' ':' Block )? - Case = - 'case' Expression ':' Block - ForLoop = - 'for' Block Expression Block Block - BreakContinue = - 'break' | 'continue' - SubAssembly = - 'assembly' Identifier Block - FunctionCall = - Identifier '(' ( Expression ( ',' Expression )* )? ')' - IdentifierOrList = Identifier | '(' IdentifierList ')' - Identifier = [a-zA-Z_$] [a-zA-Z_0-9]* - IdentifierList = Identifier ( ',' Identifier)* - Literal = - NumberLiteral | StringLiteral | HexLiteral - NumberLiteral = HexNumber | DecimalNumber - HexLiteral = 'hex' ('"' ([0-9a-fA-F]{2})* '"' | '\'' ([0-9a-fA-F]{2})* '\'') - StringLiteral = '"' ([^"\r\n\\] | '\\' .)* '"' - HexNumber = '0x' [0-9a-fA-F]+ - DecimalNumber = [0-9]+ - -Restrictions on the Grammar ---------------------------- - -Scopes in JULIA are tied to Blocks and all declarations -(``FunctionDefinition``, ``VariableDeclaration`` and ``SubAssembly``) -introduce new identifiers into these scopes. Shadowing is disallowed - -Talk about identifiers across functions etc - - -Restriction for Expression: Statements have to return empty tuple -Function arguments have to be single item - -Restriction for VariableDeclaration and Assignment: Number of elements left and right needs to be the same -continue and break only in for loop - -Literals have to fit 32 bytes - - - - | 'dataSize' '(' Identifier ')' | - LinkerSymbol | - 'bytecodeSize' | - - -Formal Specification --------------------- - -We formally specify JULIA by providing an evaluation function E overloaded -on the various nodes of the AST. Any functions can have side effects, so -E takes a state objects and the actual argument and also returns new -state objects and new arguments. There is a global state object -(which in the context of the EVM is the memory, storage and state of the -blockchain) and a local state object (the state of local variables, i.e. a -segment of the stack in the EVM). - -The the evaluation function E takes a global state, a local state and -a node of the AST and returns a new global state, a new local state -and a value (if the AST node is an expression). - -We use sequence numbers as a shorthand for the order of evaluation -and how state is forwarded. For example, ``E2(x), E1(y)`` is a shorthand -for - -For ``(S1, z) = E(S, y)`` let ``(S2, w) = E(S1, x)``. TODO - -.. code:: - E(G, L, <{St1, ..., Stn}>: Block) = - let L' be a copy of L that adds a new inner scope which contains - all functions and variables declared in the block (but not its sub-blocks) - variables are marked inactive for now - TODO: more formal - G1, L'1 = E(G, L', St1) - G2, L'2 = E(G1, L'1, St2) - ... - Gn, L'n = E(G(n-1), L'(n-1), Stn) - let L'' be a copy of L'n where the innermost scope is removed - Gn, L'' - E(G, L, (ret1, ..., retm) block>: FunctionDefinition) = - G, L - E(G, L, : VariableDeclaration) = - E(G, L, <(var1, ..., varn) := value>: Assignment) - E(G, L, <(var1, ..., varn) := value>: Assignment) = - let G', L', v1, ..., vn = E(G, L, value) - let L'' be a copy of L' where L'[vi] = vi for i = 1, ..., n - G, L'' - E(G, L, name: Identifier) = - G, L, L[name] - E(G, L, fname(arg1, ..., argn): FunctionCall) = - G1, L1, vn = E(G, L, argn) - ... - G(n-1), L(n-1), v2 = E(G(n-2), L(n-2), arg2) - Gn, Ln, v1 = E(G(n-1), L(n-1), arg1) - Let (ret1, ..., retm) block> - be the function L[fname]. - Let L' be a copy of L that does not contain any variables in any scope, - but which has a new innermost scope such that - L'[parami] = vi and L'[reti] = 0 - Let G'', L'', rv1, ..., rvm = E(Gn, L', block) - G'', Ln, rv1, ..., rvm - E(G, L, l: HexLiteral) = G, L, hexString(l), - where hexString decodes l from hex and left-aligns in into 32 bytes - E(G, L, l: StringLiteral) = G, L, utf8EncodeLeftAligned(l), - where utf8EncodeLeftAligned performs a utf8 encoding of l - and aligns it left into 32 bytes - E(G, L, n: HexNumber) = G, L, hex(n) - where hex is the hexadecimal decoding function - E(G, L, n: DecimalNumber) = G, L, dec(n), - where dec is the decimal decoding function +Solidity defines an assembly language that can also be used without Solidity. +This assembly language can also be used as "inline assembly" inside Solidity +source code. We start with describing how to use inline assembly and how it +differs from standalone assembly and then specify assembly itself. .. _inline-assembly: diff --git a/docs/julia.rst b/docs/julia.rst new file mode 100644 index 00000000..1343f706 --- /dev/null +++ b/docs/julia.rst @@ -0,0 +1,189 @@ +################################################# +Joyfully Universal Language for (Inline) Assembly +################################################# + +.. _julia: + +.. index:: ! assembly, ! asm, ! evmasm, ! julia + +JULIA is an intermediate language that can compile to various different backends +(EVM 1.0, EVM 1.5 and eWASM are planned). +Because of that, it is designed to be as featureless as possible. +It can already be used for "inline assembly" inside Solidity and +future versions of the Solidity compiler will even use JULIA as intermediate +language. It should also be easy to build high-level optimizer stages for JULIA. + +The core components of JULIA are functions, blocks, variables, literals, +for-loops, switch-statements, expressions and assignments to variables. + +JULIA in itself does not even provide operators. If the EVM is targeted, +opcodes will be available as built-in functions, but they can be reimplemented +if the backend changes. + +The following example program assumes that the EVM opcodes ``mul``, ``div`` +and ``mod`` are available either natively or as functions and computes exponentiation. + +.. code:: + + { + function power(base, exponent) -> (result) + { + switch exponent + 0: { result := 1 } + 1: { result := base } + default: + { + result := power(mul(base, base), div(exponent, 2)) + switch mod(exponent, 2) + 1: { result := mul(base, result) } + } + } + } + +It is also possible to implement the same function using a for-loop +instead of recursion. Here, we need the EVM opcodes ``lt`` (less-than) +and ``add`` to be available. + +.. code:: + + { + function power(base, exponent) -> (result) + { + result := 1 + for { let i := 0 } lt(i, exponent) { i := add(i, 1) } + { + result := mul(result, base) + } + } + } + +Specification of JULIA +====================== + +Grammar:: + + Block = '{' Statement* '}' + Statement = + Block | + FunctionDefinition | + VariableDeclaration | + Assignment | + Expression | + Switch | + ForLoop | + BreakContinue | + SubAssembly + FunctionDefinition = + 'function' Identifier '(' IdentifierList? ')' + ( '->' '(' IdentifierList ')' )? Block + VariableDeclaration = + 'let' IdentifierOrList ':=' Expression + Assignment = + IdentifierOrList ':=' Expression + Expression = + FunctionCall | Identifier | Literal + Switch = + 'switch' Expression Case* ( 'default' ':' Block )? + Case = + 'case' Expression ':' Block + ForLoop = + 'for' Block Expression Block Block + BreakContinue = + 'break' | 'continue' + SubAssembly = + 'assembly' Identifier Block + FunctionCall = + Identifier '(' ( Expression ( ',' Expression )* )? ')' + IdentifierOrList = Identifier | '(' IdentifierList ')' + Identifier = [a-zA-Z_$] [a-zA-Z_0-9]* + IdentifierList = Identifier ( ',' Identifier)* + Literal = + NumberLiteral | StringLiteral | HexLiteral + NumberLiteral = HexNumber | DecimalNumber + HexLiteral = 'hex' ('"' ([0-9a-fA-F]{2})* '"' | '\'' ([0-9a-fA-F]{2})* '\'') + StringLiteral = '"' ([^"\r\n\\] | '\\' .)* '"' + HexNumber = '0x' [0-9a-fA-F]+ + DecimalNumber = [0-9]+ + +Restrictions on the Grammar +--------------------------- + +Scopes in JULIA are tied to Blocks and all declarations +(``FunctionDefinition``, ``VariableDeclaration`` and ``SubAssembly``) +introduce new identifiers into these scopes. Shadowing is disallowed + +Talk about identifiers across functions etc + +Restriction for Expression: Statements have to return empty tuple +Function arguments have to be single item + +Restriction for VariableDeclaration and Assignment: Number of elements left and right needs to be the same +continue and break only in for loop + +Literals have to fit 32 bytes + +Formal Specification +-------------------- + +We formally specify JULIA by providing an evaluation function E overloaded +on the various nodes of the AST. Any functions can have side effects, so +E takes a state objects and the actual argument and also returns new +state objects and new arguments. There is a global state object +(which in the context of the EVM is the memory, storage and state of the +blockchain) and a local state object (the state of local variables, i.e. a +segment of the stack in the EVM). + +The the evaluation function E takes a global state, a local state and +a node of the AST and returns a new global state, a new local state +and a value (if the AST node is an expression). + +We use sequence numbers as a shorthand for the order of evaluation +and how state is forwarded. For example, ``E2(x), E1(y)`` is a shorthand +for + +For ``(S1, z) = E(S, y)`` let ``(S2, w) = E(S1, x)``. TODO + +.. code:: + + E(G, L, <{St1, ..., Stn}>: Block) = + let L' be a copy of L that adds a new inner scope which contains + all functions and variables declared in the block (but not its sub-blocks) + variables are marked inactive for now + TODO: more formal + G1, L'1 = E(G, L', St1) + G2, L'2 = E(G1, L'1, St2) + ... + Gn, L'n = E(G(n-1), L'(n-1), Stn) + let L'' be a copy of L'n where the innermost scope is removed + Gn, L'' + E(G, L, (ret1, ..., retm) block>: FunctionDefinition) = + G, L + E(G, L, : VariableDeclaration) = + E(G, L, <(var1, ..., varn) := value>: Assignment) + E(G, L, <(var1, ..., varn) := value>: Assignment) = + let G', L', v1, ..., vn = E(G, L, value) + let L'' be a copy of L' where L'[vi] = vi for i = 1, ..., n + G, L'' + E(G, L, name: Identifier) = + G, L, L[name] + E(G, L, fname(arg1, ..., argn): FunctionCall) = + G1, L1, vn = E(G, L, argn) + ... + G(n-1), L(n-1), v2 = E(G(n-2), L(n-2), arg2) + Gn, Ln, v1 = E(G(n-1), L(n-1), arg1) + Let (ret1, ..., retm) block> + be the function L[fname]. + Let L' be a copy of L that does not contain any variables in any scope, + but which has a new innermost scope such that + L'[parami] = vi and L'[reti] = 0 + Let G'', L'', rv1, ..., rvm = E(Gn, L', block) + G'', Ln, rv1, ..., rvm + E(G, L, l: HexLiteral) = G, L, hexString(l), + where hexString decodes l from hex and left-aligns in into 32 bytes + E(G, L, l: StringLiteral) = G, L, utf8EncodeLeftAligned(l), + where utf8EncodeLeftAligned performs a utf8 encoding of l + and aligns it left into 32 bytes + E(G, L, n: HexNumber) = G, L, hex(n) + where hex is the hexadecimal decoding function + E(G, L, n: DecimalNumber) = G, L, dec(n), + where dec is the decimal decoding function -- cgit v1.2.3 From c3a6db725606f14183b3af1f4954f196857afe33 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Tue, 18 Apr 2017 13:41:16 +0100 Subject: Describe built-in Julia functions --- docs/julia.rst | 164 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 163 insertions(+), 1 deletion(-) diff --git a/docs/julia.rst b/docs/julia.rst index 1343f706..5203b522 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -18,7 +18,7 @@ for-loops, switch-statements, expressions and assignments to variables. JULIA in itself does not even provide operators. If the EVM is targeted, opcodes will be available as built-in functions, but they can be reimplemented -if the backend changes. +if the backend changes. For a list of mandatory built-in functions, see the section below. The following example program assumes that the EVM opcodes ``mul``, ``div`` and ``mod`` are available either natively or as functions and computes exponentiation. @@ -187,3 +187,165 @@ For ``(S1, z) = E(S, y)`` let ``(S2, w) = E(S1, x)``. TODO where hex is the hexadecimal decoding function E(G, L, n: DecimalNumber) = G, L, dec(n), where dec is the decimal decoding function + +Low-level Functions +------------------- + +The following functions must be available: + ++---------------------------------------------------------------------------------------------------------------+ +| *Arithmetics* | ++---------------------------------------------------------------------------------------------------------------+ +| add256(x:256, y:256) -> z:256 | x + y | ++---------------------------------------------------------------------------------------------------------------+ +| sub256(x:256, y:256) -> z:256 | x - y | ++---------------------------------------------------------------------------------------------------------------+ +| mul256(x:256, y:256) -> z:256 | x * y | ++---------------------------------------------------------------------------------------------------------------+ +| div256(x:256, y:256) -> z:256 | x / y | ++---------------------------------------------------------------------------------------------------------------+ +| sdiv256(x:256, y:256) -> z:256 | x / y, for signed numbers in two's complement | ++---------------------------------------------------------------------------------------------------------------+ +| mod256(x:256, y:256) -> z:256 | x % y | ++---------------------------------------------------------------------------------------------------------------+ +| smod256(x:256, y:256) -> z:256 | x % y, for signed numbers in two's complement | ++---------------------------------------------------------------------------------------------------------------+ +| signextend256(i:256, x:256) -> z:256 | sign extend from (i*8+7)th bit counting from least significant | ++---------------------------------------------------------------------------------------------------------------+ +| exp256(x:256, y:256) -> z:256 | x to the power of y | ++---------------------------------------------------------------------------------------------------------------+ +| addmod256(x:256, y:256, m:256) -> z:256 | (x + y) % m with arbitrary precision arithmetics | ++---------------------------------------------------------------------------------------------------------------+ +| mulmod256(x:256, y:256, m:256) -> z:256 | (x * y) % m with arbitrary precision arithmetics | ++---------------------------------------------------------------------------------------------------------------+ +| lt256(x:256, y:256) -> z:bool | 1 if x < y, 0 otherwise | ++---------------------------------------------------------------------------------------------------------------+ +| gt256(x:256, y:256) -> z:bool | 1 if x > y, 0 otherwise | ++---------------------------------------------------------------------------------------------------------------+ +| slt256(x:256, y:256) -> z:bool | 1 if x < y, 0 otherwise, for signed numbers in two's complement | ++---------------------------------------------------------------------------------------------------------------+ +| sgt256(x:256, y:256) -> z:bool | 1 if x > y, 0 otherwise, for signed numbers in two's complement | ++---------------------------------------------------------------------------------------------------------------+ +| eq256(x:256, y:256) -> z:bool | 1 if x == y, 0 otherwise | ++---------------------------------------------------------------------------------------------------------------+ +| not256(x:256) -> z:256 | ~x, every bit of x is negated | ++---------------------------------------------------------------------------------------------------------------+ +| and256(x:256, y:256) -> z:256 | bitwise and of x and y | ++---------------------------------------------------------------------------------------------------------------+ +| or256(x:256, y:256) -> z:256 | bitwise or of x and y | ++---------------------------------------------------------------------------------------------------------------+ +| xor256(x:256, y:256) -> z:256 | bitwise xor of x and y | ++---------------------------------------------------------------------------------------------------------------+ +| shl256(x:256, y:256) -> z:256 | logical left shift of x by y | ++---------------------------------------------------------------------------------------------------------------+ +| shr256(x:256, y:256) -> z:256 | logical right shift of x by y | ++---------------------------------------------------------------------------------------------------------------+ +| sar256(x:256, y:256) -> z:256 | arithmetic right shift of x by y | ++---------------------------------------------------------------------------------------------------------------+ +| byte(n:256, x:256) -> v:256 | nth byte of x, where the most significant byte is the 0th byte | +| Cannot this be just replaced by and256(shr256(n, x), 0xff) and let it be optimised out by the EVM backend? | ++---------------------------------------------------------------------------------------------------------------+ +| *Memory and storage* | ++---------------------------------------------------------------------------------------------------------------+ +| mload(p:256) -> v:256 | mem[p..(p+32)) | ++---------------------------------------------------------------------------------------------------------------+ +| mstore(p:256, v:256) | mem[p..(p+32)) := v | ++---------------------------------------------------------------------------------------------------------------+ +| mstore8(p:256, v:256) | mem[p] := v & 0xff - only modifies a single byte | ++---------------------------------------------------------------------------------------------------------------+ +| sload(p:256) -> v:256 | storage[p] | ++---------------------------------------------------------------------------------------------------------------+ +| sstore(p:256, v:256) | storage[p] := v | ++---------------------------------------------------------------------------------------------------------------+ +| msize() -> size:256 | size of memory, i.e. largest accessed memory index, albeit due | +| | due to the memory extension function, which extends by words, | +| | this will always be a multiple of 32 bytes | ++---------------------------------------------------------------------------------------------------------------+ +| *Execution control* | ++---------------------------------------------------------------------------------------------------------------+ +| create(v:256, p:256, s:256) | create new contract with code mem[p..(p+s)) and send v wei | +| | and return the new address | ++---------------------------------------------------------------------------------------------------------------+ +| call(g:256, a:256, v:256, in:256, | call contract at address a with input mem[in..(in+insize)) | +| insize:256, out:256, outsize:256) -> r:256 | providing g gas and v wei and output area | +| | mem[out..(out+outsize)) returning 0 on error (eg. out of gas) | +| | and 1 on success | ++---------------------------------------------------------------------------------------------------------------+ +| callcode(g:256, a:256, v:256, in:256, | identical to `call` but only use the code from a and stay | +| insize:256, out:256, outsize:256) -> r:256 | in the context of the current contract otherwise | ++---------------------------------------------------------------------------------------------------------------+ +| delegatecall(g:256, a:256, in:256, | identical to `callcode` but also keep ``caller`` | +| insize:256, out:256, outsize:256) -> r:256 | and ``callvalue`` | ++---------------------------------------------------------------------------------------------------------------+ +| stop() | stop execution, identical to return(0,0) | +| Perhaps it would make sense retiring this as it equals to return(0,0). It can be an optimisation by the EVM | +| backend. | ++---------------------------------------------------------------------------------------------------------------+ +| abort() | abort (equals to invalid instruction on EVM) | ++---------------------------------------------------------------------------------------------------------------+ +| return(p:256, s:256) | end execution, return data mem[p..(p+s)) | ++---------------------------------------------------------------------------------------------------------------+ +| revert(p:256, s:256) | end execution, revert state changes, return data mem[p..(p+s)) | ++---------------------------------------------------------------------------------------------------------------+ +| selfdestruct(a:256) | end execution, destroy current contract and send funds to a | ++---------------------------------------------------------------------------------------------------------------+ +| log0(p:256, s:256) | log without topics and data mem[p..(p+s)) | ++---------------------------------------------------------------------------------------------------------------+ +| log1(p:256, s:256, t1:256) | log with topic t1 and data mem[p..(p+s)) | ++---------------------------------------------------------------------------------------------------------------+ +| log2(p:256, s:256, t1:256, t2:256) | log with topics t1, t2 and data mem[p..(p+s)) | ++---------------------------------------------------------------------------------------------------------------+ +| log3(p:256, s:256, t1:256, t2:256, | log with topics t, t2, t3 and data mem[p..(p+s)) | +| t3:256) | | ++---------------------------------------------------------------------------------------------------------------+ +| log4(p:256, s:256, t1:256, t2:256, | log with topics t1, t2, t3, t4 and data mem[p..(p+s)) | +| t3:256, t4:256) | | ++---------------------------------------------------------------------------------------------------------------+ +| *State queries* | ++---------------------------------------------------------------------------------------------------------------+ +| blockcoinbase() -> address:256 | current mining beneficiary | ++---------------------------------------------------------------------------------------------------------------+ +| blockdifficulty() -> difficulty:256 | difficulty of the current block | ++---------------------------------------------------------------------------------------------------------------+ +| blockgaslimit() -> limit:256 | block gas limit of the current block | ++---------------------------------------------------------------------------------------------------------------+ +| blockhash(b:256) -> hash:256 | hash of block nr b - only for last 256 blocks excluding current | ++---------------------------------------------------------------------------------------------------------------+ +| blocknumber() -> block:256 | current block number | ++---------------------------------------------------------------------------------------------------------------+ +| blocktimestamp() -> timestamp:256 | timestamp of the current block in seconds since the epoch | ++---------------------------------------------------------------------------------------------------------------+ +| txorigin() -> address:256 | transaction sender | ++---------------------------------------------------------------------------------------------------------------+ +| txgasprice() -> price:256 | gas price of the transaction | ++---------------------------------------------------------------------------------------------------------------+ +| gasleft() -> gas:256 | gas still available to execution | ++---------------------------------------------------------------------------------------------------------------+ +| balance(a:256) -> v:256 | wei balance at address a | ++---------------------------------------------------------------------------------------------------------------+ +| this() -> address:256 | address of the current contract / execution context | ++---------------------------------------------------------------------------------------------------------------+ +| caller() -> address:256 | call sender (excluding delegatecall) | ++---------------------------------------------------------------------------------------------------------------+ +| callvalue() -> v:256 | wei sent together with the current call | ++---------------------------------------------------------------------------------------------------------------+ +| calldataload(p:256) -> v:256 | call data starting from position p (32 bytes) | ++---------------------------------------------------------------------------------------------------------------+ +| calldatasize() -> v:256 | size of call data in bytes | ++---------------------------------------------------------------------------------------------------------------+ +| calldatacopy(t:256, f:256, s:256) | copy s bytes from calldata at position f to mem at position t | ++---------------------------------------------------------------------------------------------------------------+ +| codesize() -> size:256 | size of the code of the current contract / execution context | ++---------------------------------------------------------------------------------------------------------------+ +| codecopy(t:256, f:256, s:256) | copy s bytes from code at position f to mem at position t | ++---------------------------------------------------------------------------------------------------------------+ +| extcodesize(a:256) -> size:256 | size of the code at address a | ++---------------------------------------------------------------------------------------------------------------+ +| extcodecopy(a:256, t:256, f:256, s:256) | like codecopy(t, f, s) but take code at address a | ++---------------------------------------------------------------------------------------------------------------+ +| *Others* | ++---------------------------------------------------------------------------------------------------------------+ +| discard256(unused:256) | discard value | ++---------------------------------------------------------------------------------------------------------------+ +| sha3(p:256, s:256) -> v:256 | keccak(mem[p...(p+s))) | ++---------------------------------------------------------------------------------------------------------------+ -- cgit v1.2.3 From 173bdb0df6ce338d2b6fff80877224a9cfdb3d68 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Tue, 18 Apr 2017 16:40:31 +0100 Subject: Define types in Julia --- docs/julia.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/julia.rst b/docs/julia.rst index 5203b522..f1a6d8f8 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -16,6 +16,10 @@ language. It should also be easy to build high-level optimizer stages for JULIA. The core components of JULIA are functions, blocks, variables, literals, for-loops, switch-statements, expressions and assignments to variables. +JULIA is typed, both variables and literals must specify the type with postfix +notation. The supported types are ``bool``, ``u8``, ``s8``, ``u32``, ``s32``, +``u64``, ``s64``, ``u128``, ``s128``, ``u256`` and ``s256``. + JULIA in itself does not even provide operators. If the EVM is targeted, opcodes will be available as built-in functions, but they can be reimplemented if the backend changes. For a list of mandatory built-in functions, see the section below. -- cgit v1.2.3 From 3d99e8279575c686bd48801c3c3bad2fde8a30c6 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Tue, 18 Apr 2017 16:53:13 +0100 Subject: Add types to the examples --- docs/julia.rst | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index f1a6d8f8..42c8047e 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -30,16 +30,16 @@ and ``mod`` are available either natively or as functions and computes exponenti .. code:: { - function power(base, exponent) -> (result) + function power(base:u256, exponent:u256) -> (result:u256) { switch exponent - 0: { result := 1 } - 1: { result := base } + 0:u256: { result := 1:u256 } + 1:u256: { result := base } default: { - result := power(mul(base, base), div(exponent, 2)) - switch mod(exponent, 2) - 1: { result := mul(base, result) } + result := power(mul(base, base), div(exponent, 2:u256)) + switch mod(exponent, 2:u256) + 1:u256: { result := mul(base, result) } } } } @@ -51,10 +51,10 @@ and ``add`` to be available. .. code:: { - function power(base, exponent) -> (result) + function power(base:u256, exponent:u256) -> (result:u256) { - result := 1 - for { let i := 0 } lt(i, exponent) { i := add(i, 1) } + result := 1:u256 + for { let i := 0:u256 } lt(i, exponent) { i := add(i, 1:u256) } { result := mul(result, base) } -- cgit v1.2.3 From 0339cc1bb1dd84455237ffa4b3235ad4deb44f0f Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Tue, 18 Apr 2017 23:23:37 +0100 Subject: Case is missing from switch statements --- docs/julia.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index 42c8047e..58c3c557 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -33,13 +33,13 @@ and ``mod`` are available either natively or as functions and computes exponenti function power(base:u256, exponent:u256) -> (result:u256) { switch exponent - 0:u256: { result := 1:u256 } - 1:u256: { result := base } + case 0:u256: { result := 1:u256 } + case 1:u256: { result := base } default: { result := power(mul(base, base), div(exponent, 2:u256)) switch mod(exponent, 2:u256) - 1:u256: { result := mul(base, result) } + case 1:u256: { result := mul(base, result) } } } } -- cgit v1.2.3 From 183f70262a59d10b264cb71ba82d31d37c65dd63 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Wed, 19 Apr 2017 13:40:56 +0100 Subject: Document backends --- docs/julia.rst | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/docs/julia.rst b/docs/julia.rst index 58c3c557..f0622dc9 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -353,3 +353,24 @@ The following functions must be available: +---------------------------------------------------------------------------------------------------------------+ | sha3(p:256, s:256) -> v:256 | keccak(mem[p...(p+s))) | +---------------------------------------------------------------------------------------------------------------+ + +Backends +-------- + +Backends or targets are the translators from JULIA to a specific bytecode. Each of the backends can expose functions +prefixed with the name of the backend. We reserve ``evm_`` and ``ewasm_`` prefixes for the two proposed backends. + +Backend: EVM +------------ + +The EVM target will have all the underlying EVM opcodes exposed with the `evm_` prefix. + +Backend: "EVM 1.5" +------------------ + +TBD + +Backend: eWASM +-------------- + +TBD -- cgit v1.2.3 From 0e4d236558f516bb39426ff38452006923d4494a Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Thu, 20 Apr 2017 12:48:49 +0100 Subject: Include implicit type conversions --- docs/julia.rst | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/docs/julia.rst b/docs/julia.rst index f0622dc9..bd8e35a9 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -192,6 +192,19 @@ For ``(S1, z) = E(S, y)`` let ``(S2, w) = E(S1, x)``. TODO E(G, L, n: DecimalNumber) = G, L, dec(n), where dec is the decimal decoding function +Type Conversion Functions +------------------------- + +JULIA has no support for implicit type conversion and therefore functions exists to provide explicit conversion. +When converting a larger type to a shorter type a runtime exception can occur in case of an overflow. + +The following type conversion functions must be available: +- ``u32tobool(x:u32) -> (y:bool)`` +- ``booltou32(x:bool) -> (y:u32)`` +- ``u32tou64(x:u32) -> (y:u64)`` +- ``u64tou32(x:u64) -> (y:u32)`` +- etc. (TBD) + Low-level Functions ------------------- -- cgit v1.2.3 From aa6f33db2c20a55c72cbef834b255d029c7adc44 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Thu, 20 Apr 2017 12:57:02 +0100 Subject: Use signed/unsigned types in low-level functions --- docs/julia.rst | 144 +++++++++++++++++++++++++++++---------------------------- 1 file changed, 73 insertions(+), 71 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index bd8e35a9..98b19662 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -213,86 +213,88 @@ The following functions must be available: +---------------------------------------------------------------------------------------------------------------+ | *Arithmetics* | +---------------------------------------------------------------------------------------------------------------+ -| add256(x:256, y:256) -> z:256 | x + y | +| addu256(x:u256, y:u256) -> z:u256 | x + y | +---------------------------------------------------------------------------------------------------------------+ -| sub256(x:256, y:256) -> z:256 | x - y | +| subu256(x:u256, y:u256) -> z:u256 | x - y | +---------------------------------------------------------------------------------------------------------------+ -| mul256(x:256, y:256) -> z:256 | x * y | +| mulu256(x:u256, y:u256) -> z:u256 | x * y | +---------------------------------------------------------------------------------------------------------------+ -| div256(x:256, y:256) -> z:256 | x / y | +| divu256(x:u256, y:u256) -> z:u256 | x / y | +---------------------------------------------------------------------------------------------------------------+ -| sdiv256(x:256, y:256) -> z:256 | x / y, for signed numbers in two's complement | +| divs256(x:s256, y:s256) -> z:s256 | x / y, for signed numbers in two's complement | +---------------------------------------------------------------------------------------------------------------+ -| mod256(x:256, y:256) -> z:256 | x % y | +| modu256(x:u256, y:u256) -> z:u256 | x % y | +---------------------------------------------------------------------------------------------------------------+ -| smod256(x:256, y:256) -> z:256 | x % y, for signed numbers in two's complement | +| mods256(x:s256, y:s256) -> z:s256 | x % y, for signed numbers in two's complement | +---------------------------------------------------------------------------------------------------------------+ -| signextend256(i:256, x:256) -> z:256 | sign extend from (i*8+7)th bit counting from least significant | +| signextendu256(i:u256, x:u256) -> z:u256 | sign extend from (i*8+7)th bit counting from least significant | +---------------------------------------------------------------------------------------------------------------+ -| exp256(x:256, y:256) -> z:256 | x to the power of y | +| expu256(x:u256, y:u256) -> z:u256 | x to the power of y | +---------------------------------------------------------------------------------------------------------------+ -| addmod256(x:256, y:256, m:256) -> z:256 | (x + y) % m with arbitrary precision arithmetics | +| addmodu256(x:u256, y:u256, m:u256) -> z:u256| (x + y) % m with arbitrary precision arithmetics | +---------------------------------------------------------------------------------------------------------------+ -| mulmod256(x:256, y:256, m:256) -> z:256 | (x * y) % m with arbitrary precision arithmetics | +| mulmodu256(x:u256, y:u256, m:u256) -> z:u256| (x * y) % m with arbitrary precision arithmetics | +---------------------------------------------------------------------------------------------------------------+ -| lt256(x:256, y:256) -> z:bool | 1 if x < y, 0 otherwise | +| ltu256(x:u256, y:u256) -> z:bool | 1 if x < y, 0 otherwise | +---------------------------------------------------------------------------------------------------------------+ -| gt256(x:256, y:256) -> z:bool | 1 if x > y, 0 otherwise | +| gtu256(x:u256, y:u256) -> z:bool | 1 if x > y, 0 otherwise | +---------------------------------------------------------------------------------------------------------------+ -| slt256(x:256, y:256) -> z:bool | 1 if x < y, 0 otherwise, for signed numbers in two's complement | +| sltu256(x:s256, y:s256) -> z:bool | 1 if x < y, 0 otherwise, for signed numbers in two's complement | +---------------------------------------------------------------------------------------------------------------+ -| sgt256(x:256, y:256) -> z:bool | 1 if x > y, 0 otherwise, for signed numbers in two's complement | +| sgtu256(x:s256, y:s256) -> z:bool | 1 if x > y, 0 otherwise, for signed numbers in two's complement | +---------------------------------------------------------------------------------------------------------------+ -| eq256(x:256, y:256) -> z:bool | 1 if x == y, 0 otherwise | +| equ256(x:u256, y:u256) -> z:bool | 1 if x == y, 0 otherwise | +---------------------------------------------------------------------------------------------------------------+ -| not256(x:256) -> z:256 | ~x, every bit of x is negated | +| notu256(x:u256) -> z:u256 | ~x, every bit of x is negated | +---------------------------------------------------------------------------------------------------------------+ -| and256(x:256, y:256) -> z:256 | bitwise and of x and y | +| andu256(x:u256, y:u256) -> z:u256 | bitwise and of x and y | +---------------------------------------------------------------------------------------------------------------+ -| or256(x:256, y:256) -> z:256 | bitwise or of x and y | +| oru256(x:u256, y:u256) -> z:u256 | bitwise or of x and y | +---------------------------------------------------------------------------------------------------------------+ -| xor256(x:256, y:256) -> z:256 | bitwise xor of x and y | +| xoru256(x:u256, y:u256) -> z:u256 | bitwise xor of x and y | +---------------------------------------------------------------------------------------------------------------+ -| shl256(x:256, y:256) -> z:256 | logical left shift of x by y | +| shlu256(x:u256, y:u256) -> z:u256 | logical left shift of x by y | +---------------------------------------------------------------------------------------------------------------+ -| shr256(x:256, y:256) -> z:256 | logical right shift of x by y | +| shru256(x:u256, y:u256) -> z:u256 | logical right shift of x by y | +---------------------------------------------------------------------------------------------------------------+ -| sar256(x:256, y:256) -> z:256 | arithmetic right shift of x by y | +| saru256(x:u256, y:u256) -> z:u256 | arithmetic right shift of x by y | +---------------------------------------------------------------------------------------------------------------+ -| byte(n:256, x:256) -> v:256 | nth byte of x, where the most significant byte is the 0th byte | +| byte(n:u256, x:u256) -> v:u256 | nth byte of x, where the most significant byte is the 0th byte | | Cannot this be just replaced by and256(shr256(n, x), 0xff) and let it be optimised out by the EVM backend? | +---------------------------------------------------------------------------------------------------------------+ | *Memory and storage* | +---------------------------------------------------------------------------------------------------------------+ -| mload(p:256) -> v:256 | mem[p..(p+32)) | +| mload(p:u256) -> v:u256 | mem[p..(p+32)) | +---------------------------------------------------------------------------------------------------------------+ -| mstore(p:256, v:256) | mem[p..(p+32)) := v | +| mstore(p:u256, v:u256) | mem[p..(p+32)) := v | +---------------------------------------------------------------------------------------------------------------+ -| mstore8(p:256, v:256) | mem[p] := v & 0xff - only modifies a single byte | +| mstore8(p:u256, v:u256) | mem[p] := v & 0xff - only modifies a single byte | +---------------------------------------------------------------------------------------------------------------+ -| sload(p:256) -> v:256 | storage[p] | +| sload(p:u256) -> v:u256 | storage[p] | +---------------------------------------------------------------------------------------------------------------+ -| sstore(p:256, v:256) | storage[p] := v | +| sstore(p:u256, v:u256) | storage[p] := v | +---------------------------------------------------------------------------------------------------------------+ -| msize() -> size:256 | size of memory, i.e. largest accessed memory index, albeit due | +| msize() -> size:u256 | size of memory, i.e. largest accessed memory index, albeit due | | | due to the memory extension function, which extends by words, | | | this will always be a multiple of 32 bytes | +---------------------------------------------------------------------------------------------------------------+ | *Execution control* | +---------------------------------------------------------------------------------------------------------------+ -| create(v:256, p:256, s:256) | create new contract with code mem[p..(p+s)) and send v wei | +| create(v:u256, p:u256, s:u256) | create new contract with code mem[p..(p+s)) and send v wei | | | and return the new address | +---------------------------------------------------------------------------------------------------------------+ -| call(g:256, a:256, v:256, in:256, | call contract at address a with input mem[in..(in+insize)) | -| insize:256, out:256, outsize:256) -> r:256 | providing g gas and v wei and output area | -| | mem[out..(out+outsize)) returning 0 on error (eg. out of gas) | -| | and 1 on success | +| call(g:u256, a:u256, v:u256, in:u256, | call contract at address a with input mem[in..(in+insize)) | +| insize:u256, out:u256, | providing g gas and v wei and output area | +| outsize:u256) | mem[out..(out+outsize)) returning 0 on error (eg. out of gas) | +| -> r:u256 | and 1 on success | +---------------------------------------------------------------------------------------------------------------+ -| callcode(g:256, a:256, v:256, in:256, | identical to `call` but only use the code from a and stay | -| insize:256, out:256, outsize:256) -> r:256 | in the context of the current contract otherwise | +| callcode(g:u256, a:u256, v:u256, in:u256, | identical to ``call`` but only use the code from a | +| insize:u256, out:u256, | and stay in the context of the | +| outsize:u256) -> r:u256 | current contract otherwise | +---------------------------------------------------------------------------------------------------------------+ -| delegatecall(g:256, a:256, in:256, | identical to `callcode` but also keep ``caller`` | -| insize:256, out:256, outsize:256) -> r:256 | and ``callvalue`` | +| delegatecall(g:u256, a:u256, in:u256, | identical to ``callcode``, | +| insize:u256, out:u256, | but also keep ``caller`` | +| outsize:u256) -> r:u256 | and ``callvalue`` | +---------------------------------------------------------------------------------------------------------------+ | stop() | stop execution, identical to return(0,0) | | Perhaps it would make sense retiring this as it equals to return(0,0). It can be an optimisation by the EVM | @@ -300,71 +302,71 @@ The following functions must be available: +---------------------------------------------------------------------------------------------------------------+ | abort() | abort (equals to invalid instruction on EVM) | +---------------------------------------------------------------------------------------------------------------+ -| return(p:256, s:256) | end execution, return data mem[p..(p+s)) | +| return(p:u256, s:u256) | end execution, return data mem[p..(p+s)) | +---------------------------------------------------------------------------------------------------------------+ -| revert(p:256, s:256) | end execution, revert state changes, return data mem[p..(p+s)) | +| revert(p:u256, s:u256) | end execution, revert state changes, return data mem[p..(p+s)) | +---------------------------------------------------------------------------------------------------------------+ -| selfdestruct(a:256) | end execution, destroy current contract and send funds to a | +| selfdestruct(a:u256) | end execution, destroy current contract and send funds to a | +---------------------------------------------------------------------------------------------------------------+ -| log0(p:256, s:256) | log without topics and data mem[p..(p+s)) | +| log0(p:u256, s:u256) | log without topics and data mem[p..(p+s)) | +---------------------------------------------------------------------------------------------------------------+ -| log1(p:256, s:256, t1:256) | log with topic t1 and data mem[p..(p+s)) | +| log1(p:u256, s:u256, t1:u256) | log with topic t1 and data mem[p..(p+s)) | +---------------------------------------------------------------------------------------------------------------+ -| log2(p:256, s:256, t1:256, t2:256) | log with topics t1, t2 and data mem[p..(p+s)) | +| log2(p:u256, s:u256, t1:u256, t2:u256) | log with topics t1, t2 and data mem[p..(p+s)) | +---------------------------------------------------------------------------------------------------------------+ -| log3(p:256, s:256, t1:256, t2:256, | log with topics t, t2, t3 and data mem[p..(p+s)) | -| t3:256) | | +| log3(p:u256, s:u256, t1:u256, t2:u256, | log with topics t, t2, t3 and data mem[p..(p+s)) | +| t3:u256) | | +---------------------------------------------------------------------------------------------------------------+ -| log4(p:256, s:256, t1:256, t2:256, | log with topics t1, t2, t3, t4 and data mem[p..(p+s)) | -| t3:256, t4:256) | | +| log4(p:u256, s:u256, t1:u256, t2:u256, | log with topics t1, t2, t3, t4 and data mem[p..(p+s)) | +| t3:u256, t4:u256) | | +---------------------------------------------------------------------------------------------------------------+ | *State queries* | +---------------------------------------------------------------------------------------------------------------+ -| blockcoinbase() -> address:256 | current mining beneficiary | +| blockcoinbase() -> address:u256 | current mining beneficiary | +---------------------------------------------------------------------------------------------------------------+ -| blockdifficulty() -> difficulty:256 | difficulty of the current block | +| blockdifficulty() -> difficulty:u256 | difficulty of the current block | +---------------------------------------------------------------------------------------------------------------+ -| blockgaslimit() -> limit:256 | block gas limit of the current block | +| blockgaslimit() -> limit:u256 | block gas limit of the current block | +---------------------------------------------------------------------------------------------------------------+ -| blockhash(b:256) -> hash:256 | hash of block nr b - only for last 256 blocks excluding current | +| blockhash(b:u256) -> hash:u256 | hash of block nr b - only for last 256 blocks excluding current | +---------------------------------------------------------------------------------------------------------------+ -| blocknumber() -> block:256 | current block number | +| blocknumber() -> block:u256 | current block number | +---------------------------------------------------------------------------------------------------------------+ -| blocktimestamp() -> timestamp:256 | timestamp of the current block in seconds since the epoch | +| blocktimestamp() -> timestamp:u256 | timestamp of the current block in seconds since the epoch | +---------------------------------------------------------------------------------------------------------------+ -| txorigin() -> address:256 | transaction sender | +| txorigin() -> address:u256 | transaction sender | +---------------------------------------------------------------------------------------------------------------+ -| txgasprice() -> price:256 | gas price of the transaction | +| txgasprice() -> price:u256 | gas price of the transaction | +---------------------------------------------------------------------------------------------------------------+ -| gasleft() -> gas:256 | gas still available to execution | +| gasleft() -> gas:u256 | gas still available to execution | +---------------------------------------------------------------------------------------------------------------+ -| balance(a:256) -> v:256 | wei balance at address a | +| balance(a:u256) -> v:u256 | wei balance at address a | +---------------------------------------------------------------------------------------------------------------+ -| this() -> address:256 | address of the current contract / execution context | +| this() -> address:u256 | address of the current contract / execution context | +---------------------------------------------------------------------------------------------------------------+ -| caller() -> address:256 | call sender (excluding delegatecall) | +| caller() -> address:u256 | call sender (excluding delegatecall) | +---------------------------------------------------------------------------------------------------------------+ -| callvalue() -> v:256 | wei sent together with the current call | +| callvalue() -> v:u256 | wei sent together with the current call | +---------------------------------------------------------------------------------------------------------------+ -| calldataload(p:256) -> v:256 | call data starting from position p (32 bytes) | +| calldataload(p:u256) -> v:u256 | call data starting from position p (32 bytes) | +---------------------------------------------------------------------------------------------------------------+ -| calldatasize() -> v:256 | size of call data in bytes | +| calldatasize() -> v:u256 | size of call data in bytes | +---------------------------------------------------------------------------------------------------------------+ -| calldatacopy(t:256, f:256, s:256) | copy s bytes from calldata at position f to mem at position t | +| calldatacopy(t:u256, f:u256, s:u256) | copy s bytes from calldata at position f to mem at position t | +---------------------------------------------------------------------------------------------------------------+ -| codesize() -> size:256 | size of the code of the current contract / execution context | +| codesize() -> size:u256 | size of the code of the current contract / execution context | +---------------------------------------------------------------------------------------------------------------+ -| codecopy(t:256, f:256, s:256) | copy s bytes from code at position f to mem at position t | +| codecopy(t:u256, f:u256, s:u256) | copy s bytes from code at position f to mem at position t | +---------------------------------------------------------------------------------------------------------------+ -| extcodesize(a:256) -> size:256 | size of the code at address a | +| extcodesize(a:u256) -> size:u256 | size of the code at address a | +---------------------------------------------------------------------------------------------------------------+ -| extcodecopy(a:256, t:256, f:256, s:256) | like codecopy(t, f, s) but take code at address a | +| extcodecopy(a:u256, t:u256, f:u256, s:u256) | like codecopy(t, f, s) but take code at address a | +---------------------------------------------------------------------------------------------------------------+ | *Others* | +---------------------------------------------------------------------------------------------------------------+ -| discard256(unused:256) | discard value | +| discardu256(unused:u256) | discard value | +---------------------------------------------------------------------------------------------------------------+ -| sha3(p:256, s:256) -> v:256 | keccak(mem[p...(p+s))) | +| sha3(p:u256, s:u256) -> v:u256 | keccak(mem[p...(p+s))) | +---------------------------------------------------------------------------------------------------------------+ Backends -- cgit v1.2.3 From e33a9b43ad1d11e7f6877d73032bf5f59ba1be95 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Thu, 20 Apr 2017 12:57:28 +0100 Subject: Include split/combine256 --- docs/julia.rst | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/docs/julia.rst b/docs/julia.rst index 98b19662..d9b92b24 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -366,6 +366,12 @@ The following functions must be available: +---------------------------------------------------------------------------------------------------------------+ | discardu256(unused:u256) | discard value | +---------------------------------------------------------------------------------------------------------------+ +| splitu256tou64(x:u256) -> (x1:u64, x2:u64, | split u256 to four u64's | +| x3:u64, x4:u64) | | ++---------------------------------------------------------------------------------------------------------------+ +| combineu64tou256(x1:u64, x2:u64, x3:u64, | combine four u64's into a single u256 | +| x4:u64) -> (x:u256) | | ++---------------------------------------------------------------------------------------------------------------+ | sha3(p:u256, s:u256) -> v:u256 | keccak(mem[p...(p+s))) | +---------------------------------------------------------------------------------------------------------------+ -- cgit v1.2.3 From f17bdaabda4f94c7160b662b2b40cdb638c326c4 Mon Sep 17 00:00:00 2001 From: chriseth Date: Fri, 21 Apr 2017 12:22:58 +0200 Subject: Improve semantics description. --- docs/julia.rst | 37 ++++++++++++++++++------------------- 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index d9b92b24..f360da0a 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -139,32 +139,32 @@ segment of the stack in the EVM). The the evaluation function E takes a global state, a local state and a node of the AST and returns a new global state, a new local state -and a value (if the AST node is an expression). +and a variable number of values. The number of values is equal to the +number of values of the expresison if the AST node is an expresison and +zero otherwise. -We use sequence numbers as a shorthand for the order of evaluation -and how state is forwarded. For example, ``E2(x), E1(y)`` is a shorthand -for - -For ``(S1, z) = E(S, y)`` let ``(S2, w) = E(S1, x)``. TODO +The exact nature of the global state is unspecified for this high level +description. The local state `L` is a mapping of identifiers `i` to values `v`, +denoted as `L[i] = v`. +The special value `⊥` is used to signify that a variable cannot be +used yet. .. code:: E(G, L, <{St1, ..., Stn}>: Block) = - let L' be a copy of L that adds a new inner scope which contains - all functions and variables declared in the block (but not its sub-blocks) - variables are marked inactive for now - TODO: more formal + let L' be an extension of L to all variables v declared in Block + (but not in its sub-blocks), such that L'[v] = ⊥. G1, L'1 = E(G, L', St1) G2, L'2 = E(G1, L'1, St2) ... Gn, L'n = E(G(n-1), L'(n-1), Stn) - let L'' be a copy of L'n where the innermost scope is removed + let L'' be a restriction of L'n to the identifiers of L' Gn, L'' E(G, L, (ret1, ..., retm) block>: FunctionDefinition) = G, L - E(G, L, : VariableDeclaration) = - E(G, L, <(var1, ..., varn) := value>: Assignment) - E(G, L, <(var1, ..., varn) := value>: Assignment) = + E(G, L, : VariableDeclaration) = + E(G, L, : Assignment) + E(G, L, : Assignment) = let G', L', v1, ..., vn = E(G, L, value) let L'' be a copy of L' where L'[vi] = vi for i = 1, ..., n G, L'' @@ -175,11 +175,10 @@ For ``(S1, z) = E(S, y)`` let ``(S2, w) = E(S1, x)``. TODO ... G(n-1), L(n-1), v2 = E(G(n-2), L(n-2), arg2) Gn, Ln, v1 = E(G(n-1), L(n-1), arg1) - Let (ret1, ..., retm) block> - be the function L[fname]. - Let L' be a copy of L that does not contain any variables in any scope, - but which has a new innermost scope such that - L'[parami] = vi and L'[reti] = 0 + Let ret1, ..., retm block> + be the function of name fname visible at the point of the call. + Let L' be a new local state such that + L'[parami] = vi and L'[reti] = 0 for all i. Let G'', L'', rv1, ..., rvm = E(Gn, L', block) G'', Ln, rv1, ..., rvm E(G, L, l: HexLiteral) = G, L, hexString(l), -- cgit v1.2.3 From ad5cd215712d6baea82805a46ba17a6f063564df Mon Sep 17 00:00:00 2001 From: chriseth Date: Fri, 21 Apr 2017 14:56:19 +0200 Subject: More specification. --- docs/julia.rst | 108 ++++++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 80 insertions(+), 28 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index f360da0a..c0e0c97a 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -81,7 +81,7 @@ Grammar:: 'function' Identifier '(' IdentifierList? ')' ( '->' '(' IdentifierList ')' )? Block VariableDeclaration = - 'let' IdentifierOrList ':=' Expression + 'let' IdentifierOrList ( ':=' Expression )? Assignment = IdentifierOrList ':=' Expression Expression = @@ -113,18 +113,37 @@ Restrictions on the Grammar --------------------------- Scopes in JULIA are tied to Blocks and all declarations -(``FunctionDefinition``, ``VariableDeclaration`` and ``SubAssembly``) -introduce new identifiers into these scopes. Shadowing is disallowed +(``FunctionDefinition``, ``VariableDeclaration``) +introduce new identifiers into these scopes. Identifiers are visible in +the block they are defined in (including all sub-nodes and sub-blocks). +Shadowing is disallowed, i.e. you cannot declare an identifier at a point +where another identifier with the same name is also visible. -Talk about identifiers across functions etc +In for-loops, identifiers declared in the first block (the init block) +are visible in all other parts of the for loop (but not outside of the loop). +Identifiers declared in the other parts of the for loop respect the regular +syntatical scoping rules. -Restriction for Expression: Statements have to return empty tuple -Function arguments have to be single item +Inside functions, it is not possible to access a variable that was declared +outside of that function. -Restriction for VariableDeclaration and Assignment: Number of elements left and right needs to be the same -continue and break only in for loop +Every expression evaluates to zero or more values. Literals evaluate to exactly +one value and function calls evaluate to a number of values equal to the +number of return values of the function called. An expression that is also +a statement is invalid if it evaluates to more than one value, i.e. at the +block-level, only expressions evaluating to zero values are allowed. -Literals have to fit 32 bytes +For variable declarations and assignments, the right-hand-side expression +(if present) has to evaluate to a number of values equal to the number of +variables on the left-hand-side. + +An expression used as an argument to a function call has to evaluate to exactly +one value. + +The ``continue`` and ``break`` statements can only be used inside loop bodies. +The condition part of the for-loop has to evaluate to exactly one value. + +Literals cannot be larger than 32 bytes. Formal Specification -------------------- @@ -139,9 +158,7 @@ segment of the stack in the EVM). The the evaluation function E takes a global state, a local state and a node of the AST and returns a new global state, a new local state -and a variable number of values. The number of values is equal to the -number of values of the expresison if the AST node is an expresison and -zero otherwise. +and a variable number of values. The exact nature of the global state is unspecified for this high level description. The local state `L` is a mapping of identifiers `i` to values `v`, @@ -154,30 +171,65 @@ used yet. E(G, L, <{St1, ..., Stn}>: Block) = let L' be an extension of L to all variables v declared in Block (but not in its sub-blocks), such that L'[v] = ⊥. - G1, L'1 = E(G, L', St1) - G2, L'2 = E(G1, L'1, St2) - ... - Gn, L'n = E(G(n-1), L'(n-1), Stn) - let L'' be a restriction of L'n to the identifiers of L' - Gn, L'' + let Gi, Li, mode = E(G, L', St1, ..., Stn) + let L'' be a restriction of Li to the identifiers of L + Gi, L'', mode + E(G, L, St1, ..., Stn: Statement) = + if n is zero: + G, L + else: + let G', L', mode = E(G, L, St1) + if mode is regular then + E(G', L', St2, ..., Stn) + otherwise + G', L', mode E(G, L, (ret1, ..., retm) block>: FunctionDefinition) = - G, L - E(G, L, : VariableDeclaration) = - E(G, L, : Assignment) - E(G, L, : Assignment) = - let G', L', v1, ..., vn = E(G, L, value) + G, L, regular + E(G, L, : VariableDeclaration) = + E(G, L, : Assignment) + E(G, L, : VariableDeclaration) = + let L' be a copy of L where L'[vi] = 0 for i = 1, ..., n + G, L', regular + E(G, L, : Assignment) = + let G', L', v1, ..., vn = E(G, L, rhs) let L'' be a copy of L' where L'[vi] = vi for i = 1, ..., n - G, L'' - E(G, L, name: Identifier) = - G, L, L[name] - E(G, L, fname(arg1, ..., argn): FunctionCall) = + G, L'', regular + E(G, L, : ForLoop) = + if n >= 1: + let L' be an extension of L to all variables v declared in i1, ..., in + (but not in sub-blocks), such that L'[v] = ⊥. + let G'', L'', mode = E(G, L', i1, ..., in) + explode if mode is not regular + let G''', L''', mode = E(G'', L'', for {} condition post body) + explode if mode is not regular + let Lend be the restriction of L''' to only variables of L + G''', Lend + else: + let G', L', v = E(G, L, condition) + if v is false: + G', L', regular + else: + let G'', L'', mode = E(G, L, body) + if mode is break: + G'', L'', regular + else: + G''', L''', mode = E(G'', L'', post) + E(G''', L''', for {} condition post body) + E(G, L, break: BreakContinue) = + G, L, break + E(G, L, continue: BreakContinue) = + G, L, continue + + E(G, L, : Identifier) = + G, L, regular, L[name] + E(G, L, : FunctionCall) = G1, L1, vn = E(G, L, argn) ... G(n-1), L(n-1), v2 = E(G(n-2), L(n-2), arg2) Gn, Ln, v1 = E(G(n-1), L(n-1), arg1) Let ret1, ..., retm block> be the function of name fname visible at the point of the call. - Let L' be a new local state such that + Let L' be a new local state such that L'[parami] = vi and L'[reti] = 0 for all i. Let G'', L'', rv1, ..., rvm = E(Gn, L', block) G'', Ln, rv1, ..., rvm -- cgit v1.2.3 From 29da069bf02e669c019d6fa136df994bc8ef6d72 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Fri, 21 Apr 2017 16:53:20 +0100 Subject: Do not require parentheses on function return values --- docs/julia.rst | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index c0e0c97a..29970bd6 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -30,7 +30,7 @@ and ``mod`` are available either natively or as functions and computes exponenti .. code:: { - function power(base:u256, exponent:u256) -> (result:u256) + function power(base:u256, exponent:u256) -> result:u256 { switch exponent case 0:u256: { result := 1:u256 } @@ -51,7 +51,7 @@ and ``add`` to be available. .. code:: { - function power(base:u256, exponent:u256) -> (result:u256) + function power(base:u256, exponent:u256) -> result:u256 { result := 1:u256 for { let i := 0:u256 } lt(i, exponent) { i := add(i, 1:u256) } @@ -79,7 +79,7 @@ Grammar:: SubAssembly FunctionDefinition = 'function' Identifier '(' IdentifierList? ')' - ( '->' '(' IdentifierList ')' )? Block + ( '->' IdentifierList )? Block VariableDeclaration = 'let' IdentifierOrList ( ':=' Expression )? Assignment = @@ -250,10 +250,10 @@ JULIA has no support for implicit type conversion and therefore functions exists When converting a larger type to a shorter type a runtime exception can occur in case of an overflow. The following type conversion functions must be available: -- ``u32tobool(x:u32) -> (y:bool)`` -- ``booltou32(x:bool) -> (y:u32)`` -- ``u32tou64(x:u32) -> (y:u64)`` -- ``u64tou32(x:u64) -> (y:u32)`` +- ``u32tobool(x:u32) -> y:bool`` +- ``booltou32(x:bool) -> y:u32`` +- ``u32tou64(x:u32) -> y:u64`` +- ``u64tou32(x:u64) -> y:u32`` - etc. (TBD) Low-level Functions -- cgit v1.2.3 From 0493828916546d6fb19918c81e44eec402f7b56a Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Fri, 21 Apr 2017 16:58:55 +0100 Subject: Clarify literals --- docs/julia.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/julia.rst b/docs/julia.rst index 29970bd6..a1b1e678 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -143,7 +143,7 @@ one value. The ``continue`` and ``break`` statements can only be used inside loop bodies. The condition part of the for-loop has to evaluate to exactly one value. -Literals cannot be larger than 32 bytes. +Literals cannot be larger than the their type. The largest type defined is 256-bit wide. Formal Specification -------------------- -- cgit v1.2.3 From be470f107eac284ff599dd5b0632f396d86dd025 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Fri, 21 Apr 2017 17:04:27 +0100 Subject: Support types in grammar --- docs/julia.rst | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index a1b1e678..988f1980 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -78,12 +78,12 @@ Grammar:: BreakContinue | SubAssembly FunctionDefinition = - 'function' Identifier '(' IdentifierList? ')' - ( '->' IdentifierList )? Block + 'function' Identifier '(' TypedIdentifierList? ')' + ( '->' TypedIdentifierList )? Block VariableDeclaration = - 'let' IdentifierOrList ( ':=' Expression )? + 'let' TypedIdentifierList ( ':=' Expression )? Assignment = - IdentifierOrList ':=' Expression + IdentifierList ':=' Expression Expression = FunctionCall | Identifier | Literal Switch = @@ -98,11 +98,11 @@ Grammar:: 'assembly' Identifier Block FunctionCall = Identifier '(' ( Expression ( ',' Expression )* )? ')' - IdentifierOrList = Identifier | '(' IdentifierList ')' Identifier = [a-zA-Z_$] [a-zA-Z_0-9]* IdentifierList = Identifier ( ',' Identifier)* + TypedIdentifierList = Identifier ':' Identifier ( ',' Identifier ':' Identifier )* Literal = - NumberLiteral | StringLiteral | HexLiteral + (NumberLiteral | StringLiteral | HexLiteral) ':' Identifier NumberLiteral = HexNumber | DecimalNumber HexLiteral = 'hex' ('"' ([0-9a-fA-F]{2})* '"' | '\'' ([0-9a-fA-F]{2})* '\'') StringLiteral = '"' ([^"\r\n\\] | '\\' .)* '"' -- cgit v1.2.3 From b2f2b36b7c77859860a68aa6991a3768a680ad5f Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Fri, 21 Apr 2017 17:35:15 +0100 Subject: Remove subassembly --- docs/julia.rst | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index 988f1980..054f8627 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -75,8 +75,7 @@ Grammar:: Expression | Switch | ForLoop | - BreakContinue | - SubAssembly + BreakContinue FunctionDefinition = 'function' Identifier '(' TypedIdentifierList? ')' ( '->' TypedIdentifierList )? Block @@ -94,8 +93,6 @@ Grammar:: 'for' Block Expression Block Block BreakContinue = 'break' | 'continue' - SubAssembly = - 'assembly' Identifier Block FunctionCall = Identifier '(' ( Expression ( ',' Expression )* )? ')' Identifier = [a-zA-Z_$] [a-zA-Z_0-9]* -- cgit v1.2.3 From 29502f9d4476dc8c8b9ee66bfb9309cf209acbce Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Fri, 21 Apr 2017 17:35:44 +0100 Subject: Include type names in grammar --- docs/julia.rst | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index 054f8627..a441b38b 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -97,9 +97,11 @@ Grammar:: Identifier '(' ( Expression ( ',' Expression )* )? ')' Identifier = [a-zA-Z_$] [a-zA-Z_0-9]* IdentifierList = Identifier ( ',' Identifier)* - TypedIdentifierList = Identifier ':' Identifier ( ',' Identifier ':' Identifier )* + TypeName = Identifier | BuiltinTypeName + BuiltinTypeName = 'bool' | [us] ( '8' | '32' | '64' | '128' | '256' ) + TypedIdentifierList = Identifier ':' TypeName ( ',' Identifier ':' TypeName )* Literal = - (NumberLiteral | StringLiteral | HexLiteral) ':' Identifier + (NumberLiteral | StringLiteral | HexLiteral) ':' TypeName NumberLiteral = HexNumber | DecimalNumber HexLiteral = 'hex' ('"' ([0-9a-fA-F]{2})* '"' | '\'' ([0-9a-fA-F]{2})* '\'') StringLiteral = '"' ([^"\r\n\\] | '\\' .)* '"' -- cgit v1.2.3 From 15ca9870481e51f1923c0f41cbae449c14f4fc4d Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Fri, 21 Apr 2017 17:35:56 +0100 Subject: Include section for Julia objects --- docs/julia.rst | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/docs/julia.rst b/docs/julia.rst index a441b38b..5d6b8497 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -64,6 +64,8 @@ and ``add`` to be available. Specification of JULIA ====================== +JULIA code is described in this chapter. JULIA code is usually placed into a JULIA object, which is described in the following chapter. + Grammar:: Block = '{' Statement* '}' @@ -445,3 +447,69 @@ Backend: eWASM -------------- TBD + +Specification of JULIA Object +============================= + +Grammar:: + + TopLevelObject = 'object' '{' Code? ( Object | Data )* '}' + Object = 'object' StringLiteral '{' Code? ( Object | Data )* '}' + Code = 'code' Block + Data = 'data' StringLiteral HexLiteral + HexLiteral = 'hex' ('"' ([0-9a-fA-F]{2})* '"' | '\'' ([0-9a-fA-F]{2})* '\'') + StringLiteral = '"' ([^"\r\n\\] | '\\' .)* '"' + +Above, ``Block`` refers to ``Block`` in the JULIA code grammar explained in the previous chapter. + +An example JULIA Object is shown below: + +..code:: + + // Code consists of a single object. A single "code" node is the code of the object. + // Every (other) named object or data section is serialized and + // made accessible to the special built-in functions datacopy / dataoffset / datasize + object { + code { + let size = datasize("runtime") + let offset = allocate(size) + // This will turn into a memory->memory copy for eWASM and + // a codecopy for EVM + datacopy(dataoffset("runtime"), offset, size) + // this is a constructor and the runtime code is returned + return(offset, size) + } + + data "Table2" hex"4123" + + object "runtime" { + code { + // runtime code + + let size = datasize("Contract2") + let offset = allocate(size) + // This will turn into a memory->memory copy for eWASM and + // a codecopy for EVM + datacopy(dataoffset("Contract2"), offset, size) + // constructor parameter is a single number 0x1234 + mstore(add(offset, size), 0x1234) + create(offset, add(size, 32)) + } + + // Embedded object. Use case is that the outside is a factory contract, + // and Contract2 is the code to be created by the factory + object "Contract2" { + code { + // code here ... + } + + object "runtime" { + code { + // code here ... + } + } + + data "Table1" hex"4123" + } + } + } -- cgit v1.2.3 From e9b08e029eb48fff9cd3b3287a88e1282395bfb4 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Fri, 21 Apr 2017 17:49:04 +0100 Subject: Restriction of switch --- docs/julia.rst | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/docs/julia.rst b/docs/julia.rst index 5d6b8497..7740bc70 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -90,7 +90,7 @@ Grammar:: Switch = 'switch' Expression Case* ( 'default' ':' Block )? Case = - 'case' Expression ':' Block + 'case' Literal ':' Block ForLoop = 'for' Block Expression Block Block BreakContinue = @@ -120,6 +120,11 @@ the block they are defined in (including all sub-nodes and sub-blocks). Shadowing is disallowed, i.e. you cannot declare an identifier at a point where another identifier with the same name is also visible. +Switches must have at least one (or the default) and at most one default case. +If all possible values of the expression is covered, the default case should +not be allowed (i.e. a switch with a ``bool`` expression and having both a +true and false case should not allow a default case). + In for-loops, identifiers declared in the first block (the init block) are visible in all other parts of the for loop (but not outside of the loop). Identifiers declared in the other parts of the for loop respect the regular -- cgit v1.2.3 From d9abe7b712a80aab26366f772cea15221184bcbf Mon Sep 17 00:00:00 2001 From: chriseth Date: Fri, 19 May 2017 19:07:30 +0200 Subject: Require at least one case in switch --- docs/julia.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/julia.rst b/docs/julia.rst index 7740bc70..42a3b663 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -88,7 +88,7 @@ Grammar:: Expression = FunctionCall | Identifier | Literal Switch = - 'switch' Expression Case* ( 'default' ':' Block )? + 'switch' Expression Case+ ( 'default' ':' Block )? Case = 'case' Literal ':' Block ForLoop = -- cgit v1.2.3 From 0e0de7b7fdd83c0a458e51a4bf12b6444025c0f8 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Fri, 19 May 2017 23:15:07 +0100 Subject: Switch cases do not require colon --- docs/julia.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index 42a3b663..f67b3384 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -88,9 +88,9 @@ Grammar:: Expression = FunctionCall | Identifier | Literal Switch = - 'switch' Expression Case+ ( 'default' ':' Block )? + 'switch' Expression Case+ ( 'default' Block )? Case = - 'case' Literal ':' Block + 'case' Literal Block ForLoop = 'for' Block Expression Block Block BreakContinue = -- cgit v1.2.3 From 980ba42faf825a1e66fb4689fc1a7553e7b9ef87 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Fri, 19 May 2017 23:16:01 +0100 Subject: Remove from examples --- docs/julia.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index f67b3384..f97fb4b0 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -33,13 +33,13 @@ and ``mod`` are available either natively or as functions and computes exponenti function power(base:u256, exponent:u256) -> result:u256 { switch exponent - case 0:u256: { result := 1:u256 } - case 1:u256: { result := base } + case 0:u256 { result := 1:u256 } + case 1:u256 { result := base } default: { result := power(mul(base, base), div(exponent, 2:u256)) switch mod(exponent, 2:u256) - case 1:u256: { result := mul(base, result) } + case 1:u256 { result := mul(base, result) } } } } -- cgit v1.2.3 From 72f9e45b1a6d4a5163610a96869c8716bbfda74b Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Sat, 20 May 2017 00:05:14 +0100 Subject: Add true/false literals --- docs/julia.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/julia.rst b/docs/julia.rst index f97fb4b0..1bd67670 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -103,10 +103,12 @@ Grammar:: BuiltinTypeName = 'bool' | [us] ( '8' | '32' | '64' | '128' | '256' ) TypedIdentifierList = Identifier ':' TypeName ( ',' Identifier ':' TypeName )* Literal = - (NumberLiteral | StringLiteral | HexLiteral) ':' TypeName + (NumberLiteral | StringLiteral | HexLiteral | TrueLiteral | FalseLiteral) ':' TypeName NumberLiteral = HexNumber | DecimalNumber HexLiteral = 'hex' ('"' ([0-9a-fA-F]{2})* '"' | '\'' ([0-9a-fA-F]{2})* '\'') StringLiteral = '"' ([^"\r\n\\] | '\\' .)* '"' + TrueLiteral = 'true' + FalseLiteral = 'false' HexNumber = '0x' [0-9a-fA-F]+ DecimalNumber = [0-9]+ -- cgit v1.2.3 From a67bd2fb6a68976710595ad2a1548ae266d84de4 Mon Sep 17 00:00:00 2001 From: chriseth Date: Wed, 12 Jul 2017 16:52:26 +0200 Subject: Include JULIA section in the TOC. --- docs/index.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/index.rst b/docs/index.rst index 67fc87c2..afdab81f 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -156,6 +156,7 @@ Contents using-the-compiler.rst metadata.rst abi-spec.rst + julia.rst style-guide.rst common-patterns.rst bugs.rst -- cgit v1.2.3 From 5eaef9e87ef14f0a22d192ebf1efd552ab97bbc7 Mon Sep 17 00:00:00 2001 From: chriseth Date: Wed, 12 Jul 2017 18:07:02 +0200 Subject: Typos and clarifications. --- docs/julia.rst | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index 1bd67670..8812bab2 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -8,7 +8,8 @@ Joyfully Universal Language for (Inline) Assembly JULIA is an intermediate language that can compile to various different backends (EVM 1.0, EVM 1.5 and eWASM are planned). -Because of that, it is designed to be as featureless as possible. +Because of that, it is designed to be a usable common denominator of all three +platforms. It can already be used for "inline assembly" inside Solidity and future versions of the Solidity compiler will even use JULIA as intermediate language. It should also be easy to build high-level optimizer stages for JULIA. @@ -45,7 +46,7 @@ and ``mod`` are available either natively or as functions and computes exponenti } It is also possible to implement the same function using a for-loop -instead of recursion. Here, we need the EVM opcodes ``lt`` (less-than) +instead of with recursion. Here, we need the EVM opcodes ``lt`` (less-than) and ``add`` to be available. .. code:: @@ -115,7 +116,7 @@ Grammar:: Restrictions on the Grammar --------------------------- -Scopes in JULIA are tied to Blocks and all declarations +Scopes in JULIA are tied to Blocks (exceptions are functions and the for loop) and all declarations (``FunctionDefinition``, ``VariableDeclaration``) introduce new identifiers into these scopes. Identifiers are visible in the block they are defined in (including all sub-nodes and sub-blocks). @@ -164,7 +165,7 @@ state objects and new arguments. There is a global state object blockchain) and a local state object (the state of local variables, i.e. a segment of the stack in the EVM). -The the evaluation function E takes a global state, a local state and +The evaluation function E takes a global state, a local state and a node of the AST and returns a new global state, a new local state and a variable number of values. -- cgit v1.2.3 From c2f2b25064dd6710532e2246ae46c91bd8c24108 Mon Sep 17 00:00:00 2001 From: chriseth Date: Wed, 12 Jul 2017 20:09:13 +0200 Subject: Some clarifications. --- docs/julia.rst | 154 ++++++++++++++++++++++++++++++++------------------------- 1 file changed, 87 insertions(+), 67 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index 8812bab2..9f098880 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -89,7 +89,7 @@ Grammar:: Expression = FunctionCall | Identifier | Literal Switch = - 'switch' Expression Case+ ( 'default' Block )? + 'switch' Expression Case* ( 'default' Block )? Case = 'case' Literal Block ForLoop = @@ -116,134 +116,154 @@ Grammar:: Restrictions on the Grammar --------------------------- -Scopes in JULIA are tied to Blocks (exceptions are functions and the for loop) and all declarations -(``FunctionDefinition``, ``VariableDeclaration``) -introduce new identifiers into these scopes. Identifiers are visible in -the block they are defined in (including all sub-nodes and sub-blocks). -Shadowing is disallowed, i.e. you cannot declare an identifier at a point -where another identifier with the same name is also visible. - -Switches must have at least one (or the default) and at most one default case. +Switches must have at least one case (including the default case). If all possible values of the expression is covered, the default case should not be allowed (i.e. a switch with a ``bool`` expression and having both a true and false case should not allow a default case). -In for-loops, identifiers declared in the first block (the init block) -are visible in all other parts of the for loop (but not outside of the loop). -Identifiers declared in the other parts of the for loop respect the regular -syntatical scoping rules. - -Inside functions, it is not possible to access a variable that was declared -outside of that function. - -Every expression evaluates to zero or more values. Literals evaluate to exactly +Every expression evaluates to zero or more values. Identifiers and Literals +evaluate to exactly one value and function calls evaluate to a number of values equal to the -number of return values of the function called. An expression that is also -a statement is invalid if it evaluates to more than one value, i.e. at the -block-level, only expressions evaluating to zero values are allowed. +number of return values of the function called. -For variable declarations and assignments, the right-hand-side expression +In variable declarations and assignments, the right-hand-side expression (if present) has to evaluate to a number of values equal to the number of variables on the left-hand-side. +This is the only situation where an expression evaluating +to more than one value is allowed. -An expression used as an argument to a function call has to evaluate to exactly -one value. +Expressions that are also statements (i.e. at the block level) have to +evaluate to zero values. -The ``continue`` and ``break`` statements can only be used inside loop bodies. +In all other situations, expressions have to evaluate to exactly one value. + +The ``continue`` and ``break`` statements can only be used inside loop bodies +and have to be in the same function as the loop (or both have to be at the +top level). The condition part of the for-loop has to evaluate to exactly one value. Literals cannot be larger than the their type. The largest type defined is 256-bit wide. +Scoping Rules +------------- + +Scopes in JULIA are tied to Blocks (exceptions are functions and the for loop +as explained below) and all declarations +(``FunctionDefinition``, ``VariableDeclaration``) +introduce new identifiers into these scopes. + +Identifiers are visible in +the block they are defined in (including all sub-nodes and sub-blocks). +As an exception, identifiers defined in the "init" part of the for-loop +(the first block) are visible in all other parts of the for-loop +(but not outside of the loop). +Identifiers declared in the other parts of the for loop respect the regular +syntatical scoping rules. +The parameters and return parameters of functions are visible in the +function body and their names cannot overlap. + +Variables can only be referenced after their declaration. In particular, +variables cannot be referenced in the right hand side of their own variable +declaration. +Functions can be referenced already before their declaration (if they are visible). + +Shadowing is disallowed, i.e. you cannot declare an identifier at a point +where another identifier with the same name is also visible, even if it is +not accessible. + +Inside functions, it is not possible to access a variable that was declared +outside of that function. + Formal Specification -------------------- We formally specify JULIA by providing an evaluation function E overloaded on the various nodes of the AST. Any functions can have side effects, so -E takes a state objects and the actual argument and also returns new -state objects and new arguments. There is a global state object +E takes two state objects and the AST node and returns two new +state objects and a variable number of other values. +The two state objects are the global state object (which in the context of the EVM is the memory, storage and state of the -blockchain) and a local state object (the state of local variables, i.e. a +blockchain) and the local state object (the state of local variables, i.e. a segment of the stack in the EVM). +If the AST node is a statement, E returns the two state objects and a "mode", +which is used for the ``break`` and ``continue`` statements. +If the AST node is an expression, E returns the two state objects and +as many values as the expression evaluates to. -The evaluation function E takes a global state, a local state and -a node of the AST and returns a new global state, a new local state -and a variable number of values. The exact nature of the global state is unspecified for this high level -description. The local state `L` is a mapping of identifiers `i` to values `v`, -denoted as `L[i] = v`. -The special value `⊥` is used to signify that a variable cannot be -used yet. +description. The local state ``L`` is a mapping of identifiers ``i`` to values ``v``, +denoted as ``L[i] = v``. + +For an identifier ``v``, let ``$v`` be the name of the identifier. + +We will use a destructuring notation for the AST nodes. .. code:: E(G, L, <{St1, ..., Stn}>: Block) = - let L' be an extension of L to all variables v declared in Block - (but not in its sub-blocks), such that L'[v] = ⊥. - let Gi, Li, mode = E(G, L', St1, ..., Stn) - let L'' be a restriction of Li to the identifiers of L - Gi, L'', mode + let G1, L1, mode = E(G, L, St1, ..., Stn) + let L2 be a restriction of L1 to the identifiers of L + G1, L2, mode E(G, L, St1, ..., Stn: Statement) = if n is zero: G, L else: - let G', L', mode = E(G, L, St1) + let G1, L1, mode = E(G, L, St1) if mode is regular then - E(G', L', St2, ..., Stn) + E(G1, L1, St2, ..., Stn) otherwise - G', L', mode - E(G, L, (ret1, ..., retm) block>: FunctionDefinition) = + G1, L1, mode + E(G, L, FunctionDefinition) = G, L, regular E(G, L, : VariableDeclaration) = E(G, L, : Assignment) E(G, L, : VariableDeclaration) = - let L' be a copy of L where L'[vi] = 0 for i = 1, ..., n - G, L', regular + let L1 be a copy of L where L1[$vari] = 0 for i = 1, ..., n + G, L1, regular E(G, L, : Assignment) = - let G', L', v1, ..., vn = E(G, L, rhs) - let L'' be a copy of L' where L'[vi] = vi for i = 1, ..., n - G, L'', regular + let G1, L1, v1, ..., vn = E(G, L, rhs) + let L2 be a copy of L1 where L2[$vari] = vi for i = 1, ..., n + G, L2, regular E(G, L, : ForLoop) = if n >= 1: - let L' be an extension of L to all variables v declared in i1, ..., in - (but not in sub-blocks), such that L'[v] = ⊥. - let G'', L'', mode = E(G, L', i1, ..., in) - explode if mode is not regular - let G''', L''', mode = E(G'', L'', for {} condition post body) - explode if mode is not regular - let Lend be the restriction of L''' to only variables of L - G''', Lend + let G1, L1, mode = E(G, L, i1, ..., in) + // mode has to be regular due to the syntactic restrictions + let G2, L2, mode = E(G1, L1, for {} condition post body) + // mode has to be regular due to the syntactic restrictions + let L3 be the restriction of L2 to only variables of L + G2, L3 else: - let G', L', v = E(G, L, condition) + let G1, L1, v = E(G, L, condition) if v is false: - G', L', regular + G1, L1, regular else: - let G'', L'', mode = E(G, L, body) + let G2, L2, mode = E(G1, L, body) if mode is break: - G'', L'', regular + G2, L2, regular else: - G''', L''', mode = E(G'', L'', post) - E(G''', L''', for {} condition post body) + G3, L3, mode = E(G2, L2, post) + E(G3, L3, for {} condition post body) E(G, L, break: BreakContinue) = G, L, break E(G, L, continue: BreakContinue) = G, L, continue E(G, L, : Identifier) = - G, L, regular, L[name] + G, L, regular, L[$name] E(G, L, : FunctionCall) = G1, L1, vn = E(G, L, argn) ... G(n-1), L(n-1), v2 = E(G(n-2), L(n-2), arg2) Gn, Ln, v1 = E(G(n-1), L(n-1), arg1) Let ret1, ..., retm block> - be the function of name fname visible at the point of the call. + be the function of name $fname visible at the point of the call. Let L' be a new local state such that - L'[parami] = vi and L'[reti] = 0 for all i. + L'[$parami] = vi and L'[$reti] = 0 for all i. Let G'', L'', rv1, ..., rvm = E(Gn, L', block) G'', Ln, rv1, ..., rvm E(G, L, l: HexLiteral) = G, L, hexString(l), - where hexString decodes l from hex and left-aligns in into 32 bytes + where hexString decodes l from hex and left-aligns it into 32 bytes E(G, L, l: StringLiteral) = G, L, utf8EncodeLeftAligned(l), where utf8EncodeLeftAligned performs a utf8 encoding of l and aligns it left into 32 bytes -- cgit v1.2.3 From d4452d8c1fc5b3a564329097fa72e66798946a9b Mon Sep 17 00:00:00 2001 From: chriseth Date: Mon, 7 Aug 2017 16:28:10 +0200 Subject: Small fixes suggested by @mrsmkl --- docs/julia.rst | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index 9f098880..2f0b7d28 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -207,7 +207,7 @@ We will use a destructuring notation for the AST nodes. G1, L2, mode E(G, L, St1, ..., Stn: Statement) = if n is zero: - G, L + G, L, regular else: let G1, L1, mode = E(G, L, St1) if mode is regular then @@ -232,7 +232,7 @@ We will use a destructuring notation for the AST nodes. let G2, L2, mode = E(G1, L1, for {} condition post body) // mode has to be regular due to the syntactic restrictions let L3 be the restriction of L2 to only variables of L - G2, L3 + G2, L3, regular else: let G1, L1, v = E(G, L, condition) if v is false: @@ -250,7 +250,7 @@ We will use a destructuring notation for the AST nodes. G, L, continue E(G, L, : Identifier) = - G, L, regular, L[$name] + G, L, L[$name] E(G, L, : FunctionCall) = G1, L1, vn = E(G, L, argn) ... @@ -260,8 +260,8 @@ We will use a destructuring notation for the AST nodes. be the function of name $fname visible at the point of the call. Let L' be a new local state such that L'[$parami] = vi and L'[$reti] = 0 for all i. - Let G'', L'', rv1, ..., rvm = E(Gn, L', block) - G'', Ln, rv1, ..., rvm + Let G'', L'', mode = E(Gn, L', block) + G'', Ln, L''[$ret1], ..., L''[$retm] E(G, L, l: HexLiteral) = G, L, hexString(l), where hexString decodes l from hex and left-aligns it into 32 bytes E(G, L, l: StringLiteral) = G, L, utf8EncodeLeftAligned(l), -- cgit v1.2.3 From 16f81871669f205e11d7965a989b6f467f80c5d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sami=20M=C3=A4kel=C3=A4?= Date: Tue, 15 Aug 2017 22:15:43 +0300 Subject: added Switch specification --- docs/julia.rst | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/docs/julia.rst b/docs/julia.rst index 2f0b7d28..c10e3d29 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -248,6 +248,19 @@ We will use a destructuring notation for the AST nodes. G, L, break E(G, L, continue: BreakContinue) = G, L, continue + E(G, L, : Switch) = + E(G, L, switch condition case l1:t1 st1 ... case ln:tn stn default {}) = + E(G, L, : Switch) = + let G0, L0, v = E(G, L, condition) + // i = 1 .. n + // Evaluate literals, context doesn't matter + let G0, L0, v1 = E(G0, L0, l1) + ... + let G0, L0, vn = E(G0, L0, ln) + if there exists smallest i such that vi = v: + E(G0, L0, sti) + else: + E(G0, L0, st') E(G, L, : Identifier) = G, L, L[$name] -- cgit v1.2.3 From a4310fec55fa522eef6eee3bc27fad15bfafbc53 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sami=20M=C3=A4kel=C3=A4?= Date: Wed, 16 Aug 2017 13:29:12 +0300 Subject: avoid reassigning variables --- docs/julia.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/julia.rst b/docs/julia.rst index c10e3d29..cf798363 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -254,9 +254,9 @@ We will use a destructuring notation for the AST nodes. let G0, L0, v = E(G, L, condition) // i = 1 .. n // Evaluate literals, context doesn't matter - let G0, L0, v1 = E(G0, L0, l1) + let _, _, v1 = E(G0, L0, l1) ... - let G0, L0, vn = E(G0, L0, ln) + let _, _, vn = E(G0, L0, ln) if there exists smallest i such that vi = v: E(G0, L0, sti) else: -- cgit v1.2.3