Fix builtin function formatting in julia

1 files changed, 77 insertions, 76 deletions

diff --git a/docs/julia.rst b/docs/julia.rst
index 9e961a9d..078bc55b 100644
--- a/docs/julia.rst
+++ b/docs/julia.rst
@@ -320,168 +320,169 @@ The following functions must be available:
 
 +---------------------------------------------------------------------------------------------------------------+
 | *Arithmetics*                                                                                                 |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | addu256(x:u256, y:u256) -> z:u256           | x + y                                                           |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | subu256(x:u256, y:u256) -> z:u256           | x - y                                                           |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | mulu256(x:u256, y:u256) -> z:u256           | x * y                                                           |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | divu256(x:u256, y:u256) -> z:u256           | x / y                                                           |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | divs256(x:s256, y:s256) -> z:s256           | x / y, for signed numbers in two's complement                   |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | modu256(x:u256, y:u256) -> z:u256           | x % y                                                           |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | mods256(x:s256, y:s256) -> z:s256           | x % y, for signed numbers in two's complement                   |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | signextendu256(i:u256, x:u256) -> z:u256    | sign extend from (i*8+7)th bit counting from least significant  |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | expu256(x:u256, y:u256) -> z:u256           | x to the power of y                                             |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | addmodu256(x:u256, y:u256, m:u256) -> z:u256| (x + y) % m with arbitrary precision arithmetics                |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | mulmodu256(x:u256, y:u256, m:u256) -> z:u256| (x * y) % m with arbitrary precision arithmetics                |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | ltu256(x:u256, y:u256) -> z:bool            | 1 if x < y, 0 otherwise                                         |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | gtu256(x:u256, y:u256) -> z:bool            | 1 if x > y, 0 otherwise                                         |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | sltu256(x:s256, y:s256) -> 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 |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | equ256(x:u256, y:u256) -> z:bool            | 1 if x == y, 0 otherwise                                        |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | notu256(x:u256) -> z:u256                   | ~x, every bit of x is negated                                   |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | andu256(x:u256, y:u256) -> z:u256           | bitwise and of x and y                                          |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | oru256(x:u256, y:u256) -> z:u256            | bitwise or of x and y                                           |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | xoru256(x:u256, y:u256) -> z:u256           | bitwise xor of x and y                                          |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | shlu256(x:u256, y:u256) -> z:u256           | logical left shift of x by y                                    |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | shru256(x:u256, y:u256) -> z:u256           | logical right shift of x by y                                   |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | saru256(x:u256, y:u256) -> z:u256           | arithmetic right shift of x by y                                |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | 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?    |
-+---------------------------------------------------------------------------------------------------------------+
+|                                             | 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:u256) -> v:u256                     | mem[p..(p+32))                                                  |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | mstore(p:u256, v:u256)                      | mem[p..(p+32)) := v                                             |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | mstore8(p:u256, v:u256)                     | mem[p] := v & 0xff    - only modifies a single byte             |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | sload(p:u256) -> v:u256                     | storage[p]                                                      |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | sstore(p:u256, v:u256)                      | storage[p] := v                                                 |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | 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: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: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: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: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   |
-| backend.                                                                                                      |
-+---------------------------------------------------------------------------------------------------------------+
+|                                             | 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:u256, s:u256)                      | end execution, return data mem[p..(p+s))                        |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | revert(p:u256, s:u256)                      | end execution, revert state changes, return data mem[p..(p+s))  |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | selfdestruct(a:u256)                        | end execution, destroy current contract and send funds to a     |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | log0(p:u256, s:u256)                        | log without topics 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:u256, s:u256, t1:u256, t2:u256)      | log with topics t1, t2 and data mem[p..(p+s))                   |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | 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: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:u256             | current mining beneficiary                                      |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | blockdifficulty() -> difficulty:u256        | difficulty of the current block                                 |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | blockgaslimit() -> limit:u256               | block gas limit of the current block                            |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | blockhash(b:u256) -> hash:u256              | hash of block nr b - only for last 256 blocks excluding current |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | blocknumber() -> block:u256                 | current block number                                            |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | blocktimestamp() -> timestamp:u256          | timestamp of the current block in seconds since the epoch       |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | txorigin() -> address:u256                  | transaction sender                                              |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | txgasprice() -> price:u256                  | gas price of the transaction                                    |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | gasleft() -> gas:u256                       | gas still available to execution                                |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | balance(a:u256) -> v:u256                   | wei balance at address a                                        |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | this() -> address:u256                      | address of the current contract / execution context             |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | caller() -> address:u256                    | call sender (excluding delegatecall)                            |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | callvalue() -> v:u256                       | wei sent together with the current call                         |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | calldataload(p:u256) -> v:u256              | call data starting from position p (32 bytes)                   |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | calldatasize() -> v:u256                    | size of call data in bytes                                      |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | calldatacopy(t:u256, f:u256, s:u256)        | copy s bytes from calldata at position f to mem at position t   |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | codesize() -> size:u256                     | size of the code of the current contract / execution context    |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | codecopy(t:u256, f:u256, s:u256)            | copy s bytes from code at position f to mem at position t       |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | extcodesize(a:u256) -> size:u256            | size of the 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*                                                                                                      |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 | 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)))                                          |
-+---------------------------------------------------------------------------------------------------------------+
++---------------------------------------------+-----------------------------------------------------------------+
 
 Backends
 --------