Enable running properties as Eunit tests

Update model to address serialization

Update eunit test wrapper

Update tests

Add tests for serialize_type

.circleci/config.yml

@@ -22,13 +22,13 @@ jobs:
           command: rebar3 compile
       - run:
           name: Static Analysis
-          command: rebar3 dialyzer
+          command: make dialyzer
       - run:
           name: Eunit
-          command: rebar3 eunit
+          command: make eunit
       - run:
           name: Common Tests
-          command: rebar3 ct
+          command: make test
       - save_cache:
           key: dialyzer-cache-v1-{{ .Branch }}-{{ .Revision }}
           paths:

.gitignore

@@ -9,4 +9,20 @@ rel/example_project
 .concrete/DEV_MODE
 .rebar
 aeb_asm_scan.erl
+aeb_fate_asm_scan.erl
+aeb_fate_asm_scan.xrl
 _build/
+aefateasm
+include/aeb_fate_opcodes.hrl
+src/aeb_fate_code.erl
+src/aeb_fate_opcodes.erl
+src/aeb_fate_pp.erl
+*.erl~
+*.hrl~
+*.aes~
+doc
+cover
+aefate
+current_counterexample.eqc
+.rebar3
+ebin

Makefile

@@ -0,0 +1,36 @@
+GENERATED_SRC = src/aeb_fate_opcodes.erl src/aeb_fate_code.erl include/aeb_fate_opcodes.hrl src/aeb_fate_asm_scan.xrl src/aeb_fate_pp.erl
+GENERATOR_DEPS = ebin/aeb_fate_generate_ops.beam src/aeb_fate_asm_scan.template
+REBAR ?= rebar3
+
+all: local
+
+sources: $(GENERATED_SRC)
+
+local: $(GENERATED_SRC)
+	@$(REBAR) as local release
+
+console: local
+	@$(REBAR) as local shell
+
+clean:
+	@$(REBAR) clean
+	rm -f $(GENERATED_SRC)
+	rm -f ebin/*
+
+dialyzer: local
+	@$(REBAR) as local dialyzer
+
+distclean: clean
+	@rm -rf _build/
+
+eunit: local
+	@$(REBAR) as local eunit
+
+test: local
+	@$(REBAR) as local eunit
+
+ebin/%.beam: src/%.erl
+	erlc -o $(dir $@) $<
+
+$(GENERATED_SRC): $(GENERATOR_DEPS)
+	erl -pa ebin/ -noshell -s aeb_fate_generate_ops gen_and_halt src/ include/

README.md

@@ -1,9 +1,134 @@
-aebytecode
-=====
+# aebytecode
+An library and stand alone assembler for aeternity bytecode.
 
-An OTP library
+This version supports Aevm bytecode and Fate bytecode.
 
-Build
------
+## Build
+
+    $ make
+
+## Fate Code
+
+Fate code exists in 3 formats:
+
+1. Fate byte code. This format is under consensus.
+2. Fate assembler. This is a text represenation of fate code.
+                     This is not under consensus and other
+                     implemenation and toolchains could have
+                     their own format.
+3. Internal. This is an Erlang representation of fate code
+               Used by this particular engin implementation.
+
+This library handles all tree representations.
+The byte code format is described in a separate document.
+The internal format is described in a separate document.
+The text representation is described below.
+
+### Fate Assembler Code
+
+Assembler code can be read from a file.
+The assembler has the following format:
+
+Comments start with 2 semicolons and runs till end of line
+`;; This is a comment`
+
+Opcode mnemonics start with an upper case letter.
+`DUP`
+
+Identifiers start with a lower case letter
+`an_identifier`
+
+References to function arguments start with arg followed by an integer
+`arg0`
+
+References to variables/registers start with var followed by an integer
+`var0`
+
+References to stack postions is either a (for stack 0)
+or start with stack followed by an integer
+`stack1`
+`a`
+
+Immediate values can be of 11 types:
+
+1. Integers as decimals: {Digits} or -{Digits}
+ `42`
+ `-2374683271468723648732648736498712634876147`
+  And integers as Hexadecimals::  0x{Hexdigits}
+ `0x0deadbeef0`
+
+2. Chain Objects. These are all addresses to different types of chain objects.
+   Each address is a 256 bits number encoded in base58 with checksum
+   with a prefix of "@" plus a type prefix followed by "_".
+
+2a. Account Address: a base58c encoded number starting with @ak_ followed by a number of base58chars
+ '@ak_nv5B93FPzRHrGNmMdTDfGdd5xGZvep3MVSpJqzcQmMp59bBCv`
+
+2b. Contract address: @ct_{base58char}+
+ `@ct_nv5B93FPzRHrGNmMdTDfGdd5xGZvep3MVSpJqzcQmMp59bBCv`
+
+2c. Oracle address: @ok_{base58char}+
+ `@ok_nv5B93FPzRHrGNmMdTDfGdd5xGZvep3MVSpJqzcQmMp59bBCv`
+
+2d. Name address: @nm_{base58char}+
+ `@nm_nv5B93FPzRHrGNmMdTDfGdd5xGZvep3MVSpJqzcQmMp59bBCv`
+
+2e. Channel address: @ch_{base58char}+
+ `@ch_nv5B93FPzRHrGNmMdTDfGdd5xGZvep3MVSpJqzcQmMp59bBCv`
+
+3. Boolean  true or false
+ `true`
+ `false`
+
+4. Strings  "{Characters}"
+ `"Hello"`
+
+5. Map  { Key => Value }
+ `{}`
+ `{ 1 => { "foo" => true, "bar" => false}`
+
+6. Lists [ Elements ]
+ `[]`
+ `[1, 2]`
+
+7. Bit field < Bits > or !< Bits >
+ `<000>`
+ `<1010 1010>`
+ `<>`
+ `!<>`
+
+8. Tuples ( Elements )
+ `()`
+ `(1, "foo")`
+
+9. Variants: (| [Arities] | Tag | ( Elements ) |)
+ `(| [1,3,5,2]  | 3 | ( "foo", 12) |)`
+
+10. Hashes: #{base64char}+
+ `#AQIDCioLFQ==`
+
+11. Signatures: $sg_{base58char}+
+
+
+Where
+
+Digits: [0123456789]
+
+Hexdigits:  [0123456789abcdef]
+
+base58char:  [123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]
+
+base64char:  [ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxy0123456789+/=]
+
+Characters: any printable ascii character 0..255 (except " no quoting yet)
+
+Key: any value except for a map
+
+Bits: 01 or space
+
+Elements: Nothing or Value , Elements
+
+Size: Digits (0 < Size < 256)
+
+Tag: Digits (0 =< Tag < Size)
 
-    $ rebar3 compile

include/aeb_fate_data.hrl

@@ -0,0 +1,80 @@
+-define(FATE_INTEGER_T,   integer()).
+-define(FATE_BYTE_T,      0..255).
+-define(FATE_BOOLEAN_T,   true | false).
+-define(FATE_NIL_T,       []).
+-define(FATE_LIST_T,      list()).
+-define(FATE_UNIT_T,      {tuple, {}}).
+-define(FATE_MAP_T,       #{ fate_type() => fate_type() }).
+-define(FATE_STRING_T,    binary()).
+-define(FATE_ADDRESS_T,   {address, <<_:256>>}).
+-define(FATE_HASH_T,      {hash, binary()}).
+-define(FATE_SIGNATURE_T, {signature, binary()}).
+-define(FATE_CONTRACT_T,  {contract, <<_:256>>}).
+-define(FATE_ORACLE_T,    {oracle, <<_:256>>}).
+-define(FATE_NAME_T,      {name, <<_:256>>}).
+-define(FATE_CHANNEL_T,   {channel, <<_:256>>}).
+-define(FATE_VARIANT_T,   {variant, [byte()], ?FATE_BYTE_T, tuple()}).
+-define(FATE_VOID_T,      void).
+-define(FATE_TUPLE_T,     {tuple, tuple()}).
+-define(FATE_BITS_T,      {bits, integer()}).
+
+-define(IS_FATE_INTEGER(X), (is_integer(X))).
+-define(IS_FATE_LIST(X),    (is_list(X))).
+-define(IS_FATE_STRING(X),  (is_binary(X))).
+-define(IS_FATE_MAP(X),     (is_map(X))).
+-define(IS_FATE_TUPLE(X),   (is_tuple(X) andalso (tuple == element(1, X) andalso is_tuple(element(2, X))))).
+-define(IS_FATE_ADDRESS(X), (is_tuple(X) andalso (address == element(1, X) andalso is_binary(element(2, X))))).
+-define(IS_FATE_HASH(X),    (is_tuple(X) andalso (hash == element(1, X) andalso is_binary(element(2, X))))).
+-define(IS_FATE_SIGNATURE(X), (is_tuple(X) andalso (signature == element(1, X) andalso is_binary(element(2, X))))).
+-define(IS_FATE_CONTRACT(X), (is_tuple(X) andalso (contract == element(1, X) andalso is_binary(element(2, X))))).
+-define(IS_FATE_ORACLE(X), (is_tuple(X) andalso (oracle == element(1, X) andalso is_binary(element(2, X))))).
+-define(IS_FATE_NAME(X), (is_tuple(X) andalso (name == element(1, X) andalso is_binary(element(2, X))))).
+-define(IS_FATE_CHANNEL(X), (is_tuple(X) andalso (channel == element(1, X) andalso is_binary(element(2, X))))).
+-define(IS_FATE_BITS(X), (is_tuple(X) andalso (bits == element(1, X) andalso is_integer(element(2, X))))).
+-define(IS_FATE_VARIANT(X), (is_tuple(X)
+                             andalso
+                               (variant == element(1, X)
+                                andalso is_list(element(2, X))
+                                andalso is_integer(element(3, X))
+                                andalso is_tuple(element(4, X))
+                               ))).
+-define(IS_FATE_BOOLEAN(X), is_boolean(X)).
+
+-define(FATE_UNIT,         {tuple, {}}).
+-define(FATE_TUPLE(T),     {tuple, T}).
+-define(FATE_ADDRESS(A),   {address, A}).
+-define(FATE_HASH(X),      {hash, X}).
+-define(FATE_SIGNATURE(S), {signature, S}).
+-define(FATE_CONTRACT(X),  {contract, X}).
+-define(FATE_ORACLE(X),    {oracle, X}).
+-define(FATE_NAME(X),      {name, X}).
+-define(FATE_CHANNEL(X),   {channel, X}).
+-define(FATE_BITS(B),      {bits, B}).
+
+
+-define(FATE_INTEGER_VALUE(X), (X)).
+-define(FATE_LIST_VALUE(X), (X)).
+-define(FATE_TUPLE_ELEMENTS(X), (tuple_to_list(element(2, X)))).
+-define(FATE_STRING_VALUE(X), (X)).
+-define(FATE_ADDRESS_VALUE(X), (element(2, X))).
+-define(FATE_HASH_VALUE(X), (element(2, X))).
+-define(FATE_SIGNATURE_VALUE(X), (element(2, X))).
+-define(FATE_CONTRACT_VALUE(X), (element(2, X))).
+-define(FATE_ORACLE_VALUE(X), (element(2, X))).
+-define(FATE_NAME_VALUE(X), (element(2, X))).
+-define(FATE_CHANNEL_VALUE(X), (element(2, X))).
+-define(FATE_MAP_VALUE(X), (X)).
+-define(FATE_MAP_SIZE(X), (map_size(X))).
+-define(FATE_STRING_SIZE(X), (byte_size(X))).
+-define(FATE_TRUE,  true).
+-define(FATE_FALSE, false).
+-define(FATE_NIL,   []).
+-define(FATE_VOID,  void).
+-define(FATE_EMPTY_STRING, <<>>).
+-define(FATE_STRING(S), S).
+-define(FATE_VARIANT(Arity, Tag,T), {variant, Arity, Tag, T}).
+
+-define(MAKE_FATE_INTEGER(X), X).
+-define(MAKE_FATE_LIST(X), X).
+-define(MAKE_FATE_MAP(X),  X).
+-define(MAKE_FATE_STRING(X),  X).

include/aeb_heap.hrl

@@ -0,0 +1,15 @@
+
+-record(pmap, {key_t  :: aeb_aevm_data:type(),
+               val_t  :: aeb_aevm_data:type(),
+               parent :: none | non_neg_integer(),
+               size   = 0 :: non_neg_integer(),
+               data   :: #{aeb_heap:binary_value() => aeb_heap:binary_value() | tombstone}
+                       | stored}).
+
+-record(maps, { maps    = #{} :: #{ non_neg_integer() => #pmap{} }
+              , next_id = 0   :: non_neg_integer() }).
+
+-record(heap, { maps   :: #maps{},
+                offset :: aeb_heap:offset(),
+                heap   :: binary() | #{non_neg_integer() => non_neg_integer()} }).
+

include/aeb_opcodes.hrl

@@ -183,9 +183,13 @@
 -define(PRIM_CALL_MAP_TOLIST, 305).
 
 -define(PRIM_CALL_IN_CRYPTO_RANGE(__TTYPE__), (((__TTYPE__) > 399) andalso ((__TTYPE__) < 500))).
--define(PRIM_CALL_CRYPTO_ECVERIFY,       400).
--define(PRIM_CALL_CRYPTO_SHA3,           401).
--define(PRIM_CALL_CRYPTO_SHA256,         402).
--define(PRIM_CALL_CRYPTO_BLAKE2B,        403).
--define(PRIM_CALL_CRYPTO_SHA256_STRING,  404).
--define(PRIM_CALL_CRYPTO_BLAKE2B_STRING, 405).
+-define(PRIM_CALL_CRYPTO_ECVERIFY,           400).
+-define(PRIM_CALL_CRYPTO_SHA3,               401).
+-define(PRIM_CALL_CRYPTO_SHA256,             402).
+-define(PRIM_CALL_CRYPTO_BLAKE2B,            403).
+-define(PRIM_CALL_CRYPTO_SHA256_STRING,      404).
+-define(PRIM_CALL_CRYPTO_BLAKE2B_STRING,     405).
+-define(PRIM_CALL_CRYPTO_ECVERIFY_SECP256K1, 410).
+
+-define(PRIM_CALL_IN_AUTH_RANGE(__TTYPE__), (((__TTYPE__) > 499) andalso ((__TTYPE__) < 600))).
+-define(PRIM_CALL_AUTH_TX_HASH, 500).

include/aeb_typerep_def.hrl

@@ -0,0 +1,11 @@
+
+-define(Type(), aeb_aevm_data:type()).
+
+-define(TYPEREP_WORD_TAG,   0).
+-define(TYPEREP_STRING_TAG, 1).
+-define(TYPEREP_LIST_TAG,   2).
+-define(TYPEREP_TUPLE_TAG,  3).
+-define(TYPEREP_VARIANT_TAG, 4).
+-define(TYPEREP_TYPEREP_TAG, 5).
+-define(TYPEREP_MAP_TAG,     6).
+-define(TYPEREP_FUN_TAG,     7).

quickcheck/aeb_fate_data_tests.erl

@@ -0,0 +1,25 @@
+%%% @author Thomas Arts
+%%% @doc Allow to run QuickCheck tests as eunit tests
+%%%      `rebar3 as eqc eunit --cover`
+%%%      or `rebar3 as eqc eunit --module=aeb_fate_data`
+%%%      Note that for obtainign cover file, one needs `rebar3 as eqc cover
+%%%
+%%%
+%%% @end
+%%% Created : 13 Dec 2018 by Thomas Arts <thomas@SpaceGrey.lan>
+
+-module(aeb_fate_data_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+
+-compile([export_all, nowarn_export_all]).
+
+-define(EQC_EUNIT(Module, PropName, Ms),
+        { atom_to_list(PropName),
+          {timeout, (Ms * 3) / 1000, ?_assert(eqc:quickcheck(eqc:testing_time(Ms / 1000, Module:PropName())))}}).
+
+quickcheck_test_() ->
+    {setup, fun() -> eqc:start() end,
+     [ ?EQC_EUNIT(aefate_eqc, prop_roundtrip, 500),
+       ?EQC_EUNIT(aefate_eqc, prop_format_scan, 2000)
+     ]}.

quickcheck/aeb_fate_encoding_tests.erl

@@ -0,0 +1,25 @@
+%%% @author Thomas Arts
+%%% @doc Allow to run QuickCheck tests as eunit tests
+%%%      `rebar3 as eqc eunit --cover`
+%%%      or `rebar3 as eqc eunit --module=aeb_fate_encoding`
+%%%      Note that for obtaining cover file, one needs `rebar3 as eqc cover
+%%%
+%%%
+%%% @end
+%%% Created : 13 Dec 2018 by Thomas Arts
+
+-module(aeb_fate_encoding_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+
+-compile([export_all, nowarn_export_all]).
+
+-define(EQC_EUNIT(Module, PropName, Ms),
+        { atom_to_list(PropName),
+          {timeout, (Ms * 3) / 1000, ?_assert(eqc:quickcheck(eqc:testing_time(Ms / 1000, Module:PropName())))}}).
+
+quickcheck_test_() ->
+    {setup, fun() -> eqc:start() end,
+     [ ?EQC_EUNIT(aefate_type_eqc, prop_roundtrip, 1000),
+       ?EQC_EUNIT(aefate_eqc, prop_serializes, 1000)
+     ]}.

quickcheck/aefate_eqc.erl

@@ -0,0 +1,122 @@
+%%% @author Thomas Arts
+%%% @doc Use `rebar3 as eqc shell` to run properties in the shell
+%%%
+%%% We need to be able to generate data that serializes with ?LONG_LIST, ?LONG_TUPLE etc.
+%%% In other words make some rather broad terms as well as some deep terms
+%%%
+%%% @end
+%%% Created : 13 Dec 2018 by Thomas Arts <thomas@SpaceGrey.lan>
+
+-module(aefate_eqc).
+
+-include_lib("eqc/include/eqc.hrl").
+
+-compile([export_all, nowarn_export_all]).
+
+prop_roundtrip() ->
+    ?FORALL(FateData, fate_data(),
+            measure(bytes, size(term_to_binary(FateData)),
+                    begin
+                        Serialized = aeb_fate_encoding:serialize(FateData),
+                        ?WHENFAIL(eqc:format("Serialized ~p to ~p~n", [FateData, Serialized]),
+                                  equals(aeb_fate_encoding:deserialize(Serialized), FateData))
+                    end)).
+
+prop_format_scan() ->
+    ?FORALL(FateData, fate_data(),
+            ?WHENFAIL(eqc:format("Trying to format ~p failed~n", [FateData]),
+                      begin
+                          String = aeb_fate_data:format(FateData),
+                          {ok, _Scanned, _} = aeb_fate_asm_scan:scan(unicode:characters_to_list(String)),
+                          true
+                      end)).
+
+prop_serializes() ->
+    ?FORALL(FateDatas, non_empty(?SIZED(Size, resize(Size div 2, list(fate_data())))),
+            ?WHENFAIL(eqc:format("Trying to serialize/deserialize ~p failed~n", [FateDatas]),
+                      begin
+                          {T1, Binary} =
+                              timer:tc( fun() ->
+                                                << begin B = aeb_fate_encoding:serialize(Data),
+                                                         <<B/binary>> end || Data <- FateDatas >>
+                                        end),
+                          {T2, {FateData, _}} =
+                              timer:tc(fun() -> aeb_fate_encoding:deserialize_one(Binary) end),
+                          measure(binary_size, size(Binary),
+                          measure(encode, T1,
+                          measure(decode, T2,
+                                  conjunction([{equal, equals(hd(FateDatas), FateData)},
+                                               {size, size(Binary) < 500000}]))))
+                      end)).
+
+fate_data() ->
+    ?SIZED(Size, ?LET(Data, fate_data(Size, [map]), eqc_symbolic:eval(Data))).
+
+fate_data(0, _Options) ->
+    ?LAZY(
+       oneof([fate_integer(),
+              fate_boolean(),
+              fate_nil(),
+              fate_unit(),
+              fate_string(),
+              fate_address(),
+              fate_hash(),
+              fate_signature(),
+              fate_contract(),
+              fate_oracle(),
+              fate_name(),
+              fate_bits(),
+              fate_channel()]));
+fate_data(Size, Options) ->
+    oneof([?LAZY(fate_data(Size - 1, Options)),
+           ?LAZY(fate_list( fate_data(Size div 5, Options) )),
+           ?LAZY(fate_tuple( list(fate_data(Size div 5, Options)) )),
+           ?LAZY(fate_variant( list(fate_data(Size div 5, Options)))) ] ++
+              [
+               ?LAZY(fate_map( fate_data(Size div 8, Options -- [map]),
+                               fate_data(Size div 5, Options)))
+              || lists:member(map, Options)
+              ]).
+
+
+fate_integer()    -> {call, aeb_fate_data, make_integer, [oneof([int(), largeint()])]}.
+fate_bits()       -> {call, aeb_fate_data, make_bits, [oneof([int(), largeint()])]}.
+fate_boolean()    -> {call, aeb_fate_data, make_boolean, [elements([true, false])]}.
+fate_nil()        -> {call, aeb_fate_data, make_list, [[]]}.
+fate_unit()       -> {call, aeb_fate_data, make_unit, []}.
+fate_string()     -> {call, aeb_fate_data, make_string,
+                      [frequency([{10, non_quote_string()}, {2, list(non_quote_string())},
+                                  {1, ?LET(N, choose(64-3, 64+3), vector(N, $a))}])]}.
+fate_address()    -> {call, aeb_fate_data, make_address, [non_zero_binary(256 div 8)]}.
+fate_hash()       -> {call, aeb_fate_data, make_hash, [non_zero_binary(32)]}.
+fate_signature()  -> {call, aeb_fate_data, make_signature, [non_zero_binary(64)]}.
+fate_contract()   -> {call, aeb_fate_data, make_contract, [non_zero_binary(256 div 8)]}.
+fate_oracle()     -> {call, aeb_fate_data, make_oracle, [non_zero_binary(256 div 8)]}.
+fate_name()       -> {call, aeb_fate_data, make_name, [non_zero_binary(256 div 8)]}.
+fate_channel()    -> {call, aeb_fate_data, make_channel, [non_zero_binary(256 div 8)]}.
+
+%% May shrink to fate_unit
+fate_tuple(ListGen) ->
+    {call, aeb_fate_data, make_tuple, [?LET(Elements, ListGen, list_to_tuple(Elements))]}.
+
+fate_variant(ListGen) ->
+    ?LET({L1, L2, TupleAsList}, {list(choose(0, 255)), list(choose(0,255)), ListGen},
+         {call, aeb_fate_data, make_variant,
+          [L1 ++ [length(TupleAsList)] ++ L2, length(L1), list_to_tuple(TupleAsList)]}).
+
+fate_list(Gen) ->
+    {call, aeb_fate_data, make_list, [frequency([{20, list(Gen)}, {1, ?LET(N, choose(64-3, 64+3), vector(N, Gen))}])]}.
+
+fate_map(KeyGen, ValGen) ->
+    {call, aeb_fate_data, make_map, [map(KeyGen, ValGen)]}.
+
+
+non_zero_binary(N) ->
+    Bits = N*8,
+    ?SUCHTHAT(Bin, binary(N), begin <<V:Bits>> = Bin, V =/= 0 end).
+
+non_quote_string() ->
+    ?SUCHTHAT(S, utf8(), [ quote || <<34>> <= S ] == []).
+
+char() ->
+    choose(1, 255).

quickcheck/aefate_type_eqc.erl

@@ -0,0 +1,49 @@
+%%% @author Thomas Arts
+%%% @doc Use `rebar3 as eqc shell` to run properties in the shell
+%%%      Properties for testing Fate type representations
+%%%
+%%% @end
+%%% Created : 13 Dec 2018 by Thomas Arts <thomas@SpaceGrey.lan>
+
+-module(aefate_type_eqc).
+
+-include_lib("eqc/include/eqc.hrl").
+
+-compile([export_all, nowarn_export_all]).
+
+prop_roundtrip() ->
+    ?FORALL(FateType, fate_type(),
+            collect(FateType,
+            begin
+                Serialized = aeb_fate_encoding:serialize_type(FateType),
+                BinSerialized = list_to_binary(Serialized),
+                ?WHENFAIL(eqc:format("Serialized ~p to ~p (~p)~n", [FateType, Serialized, BinSerialized]),
+                          begin
+                              {Type, <<>>} = aeb_fate_encoding:deserialize_type(BinSerialized),
+                              equals(Type, FateType)
+                          end)
+            end)).
+
+
+fate_type() ->
+    ?SIZED(Size, fate_type(Size)).
+
+fate_type(0) ->
+    oneof([integer,
+           boolean,
+           address,
+           hash,
+           signature,
+           contract,
+           oracle,
+           name,
+           channel,
+           bits,
+           string]);
+fate_type(Size) ->
+    oneof([?LAZY(fate_type(Size div 2)),
+           {list, ?LAZY(fate_type(Size div 2))},
+           {tuple, list(?LAZY(fate_type(Size div 2)))},
+           {variant, list(?LAZY(fate_type(Size div 2)))},
+           ?LETSHRINK([T1, T2], [?LAZY(fate_type(Size div 2)), ?LAZY(fate_type(Size div 2))],
+                      {map, T1, T2})]).

rebar.config

@@ -1,11 +1,59 @@
+%% -*- mode: erlang; indent-tabs-mode: nil -*-
+
 {minimum_otp_vsn, "20.1"}.
 
 {erl_opts, [debug_info]}.
 
-{deps, []}.  
+{deps, [ {eblake2, "1.0.0"}
+       , {aeserialization, {git, "https://github.com/aeternity/aeserialization.git",
+                            {ref, "6dce265"}}}
+       , {getopt, "1.0.1"}
+       ]}.
+
+{escript_incl_apps, [aebytecode, eblake2, aeserialization, getopt]}.
+{escript_main_app, aebytecode}.
+{escript_name, aefateasm}.
+{escript_emu_args, "%%!"}.
+
+{pre_hooks,
+  [{"(linux|darwin|solaris|win32)", compile, "make sources"},
+   {"(freebsd)", compile, "gmake sources"}]}.
+
+{provider_hooks, [{post, [{compile, escriptize}]}]}.
+
 
 {dialyzer, [
             {warnings, [unknown]},
             {plt_apps, all_deps},
-            {base_plt_apps, [erts, kernel, stdlib]}
+            {base_plt_apps, [erts, kernel, stdlib, crypto, getopt]}
            ]}.
+
+
+{relx, [{release, {aebytecode, "2.0.1"},
+         [aebytecode, eblake2, getopt]},
+
+        {dev_mode, true},
+        {include_erts, false},
+
+        {extended_start_script, true}]}.
+
+{profiles, [{binary, [
+                      {deps, [ {eblake2, "1.0.0"}
+                             , {aeserialization, {git, "https://github.com/aeternity/aeserialization.git",
+                                                  {ref, "b55c372"}}}
+                             , {getopt, "1.0.1"}
+                             ]},
+
+                      {post_hooks, [{"(linux|darwin|solaris|freebsd|netbsd|openbsd)",
+                                     escriptize,
+                                     "cp \"$REBAR_BUILD_DIR/bin/aefateasm\" ./aefateasm"},
+                                    {"win32",
+                                     escriptize,
+                                     "robocopy \"%REBAR_BUILD_DIR%/bin/\" ./ aefateasm* "
+                                     "/njs /njh /nfl /ndl & exit /b 0"} % silence things
+                                   ]}
+                     ]},
+             {eqc, [{erl_opts, [{parse_transform, eqc_cover}]},
+                    {extra_src_dirs, ["quickcheck"]}    %% May not be called eqc!
+                   ]}
+            ]}.

rebar.lock

@@ -1 +1,16 @@
-[].
+{"1.1.0",
+[{<<"aeserialization">>,
+  {git,"https://github.com/aeternity/aeserialization.git",
+       {ref,"6dce265753af4e651f77746e77ea125145c85dd3"}},
+  0},
+ {<<"base58">>,
+  {git,"https://github.com/aeternity/erl-base58.git",
+       {ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
+  1},
+ {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},0},
+ {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0}]}.
+[
+{pkg_hash,[
+ {<<"eblake2">>, <<"EC8AD20E438AAB3F2E8D5D118C366A0754219195F8A0F536587440F8F9BCF2EF">>},
+ {<<"getopt">>, <<"C73A9FA687B217F2FF79F68A3B637711BB1936E712B521D8CE466B29CBF7808A">>}]}
+].

src/aeb_abi.erl

@@ -0,0 +1,150 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2017, Aeternity Anstalt
+%%% @doc
+%%%     Encode and decode data and function calls according to
+%%%     Sophia-AEVM-ABI.
+%%% @end
+%%% Created : 25 Jan 2018
+%%%
+%%%-------------------------------------------------------------------
+-module(aeb_abi).
+-define(HASH_SIZE, 32).
+
+-export([ create_calldata/4
+        , check_calldata/2
+        , function_type_info/3
+        , function_type_hash/3
+        , arg_typerep_from_function/2
+        , type_hash_from_function_name/2
+        , typereps_from_type_hash/2
+        , function_name_from_type_hash/2
+        , get_function_hash_from_calldata/1
+        ]).
+
+-type hash() :: <<_:256>>. %% 256 = ?HASH_SIZE * 8.
+-type function_name() :: binary(). %% String
+-type typerep() :: aeb_aevm_data:type().
+-type function_type_info() :: { FunctionHash :: hash()
+                              , FunctionName :: function_name()
+                              , ArgType      :: binary() %% binary typerep
+                              , OutType      :: binary() %% binary typerep
+                              }.
+-type type_info() :: [function_type_info()].
+
+%%%===================================================================
+%%% API
+%%%===================================================================
+
+%%%===================================================================
+%%% Handle calldata
+
+create_calldata(FunName, Args, ArgTypes0, RetType) ->
+    ArgTypes = {tuple, ArgTypes0},
+    <<TypeHashInt:?HASH_SIZE/unit:8>> =
+        function_type_hash(list_to_binary(FunName), ArgTypes, RetType),
+    Data = aeb_heap:to_binary({TypeHashInt, list_to_tuple(Args)}),
+    {ok, Data, {tuple, [word, ArgTypes]}, RetType}.
+
+-spec check_calldata(binary(), type_info()) ->
+                        {'ok', typerep(), typerep()} | {'error', atom()}.
+check_calldata(CallData, TypeInfo) ->
+    %% The first element of the CallData should be the function name
+    case get_function_hash_from_calldata(CallData) of
+        {ok, Hash} ->
+            case typereps_from_type_hash(Hash, TypeInfo) of
+                {ok, ArgType, OutType} ->
+                    try aeb_heap:from_binary({tuple, [word, ArgType]}, CallData) of
+                        {ok, _Something} ->
+                            {ok, {tuple, [word, ArgType]}, OutType};
+                        {error, _} ->
+                            {error, bad_call_data}
+                    catch
+                        _T:_E ->
+                            {error, bad_call_data}
+                    end;
+                {error, _} ->
+                    {error, unknown_function}
+            end;
+        {error, _What} ->
+            {error, bad_call_data}
+    end.
+
+-spec get_function_hash_from_calldata(CallData::binary()) ->
+                                             {ok, binary()} | {error, term()}.
+get_function_hash_from_calldata(CallData) ->
+    case aeb_heap:from_binary({tuple, [word]}, CallData) of
+        {ok, {HashInt}} -> {ok, <<HashInt:?HASH_SIZE/unit:8>>};
+        {error, _} = Error -> Error
+    end.
+
+%%%===================================================================
+%%% Handle type info from contract meta data
+
+-spec function_type_info(function_name(), [typerep()], typerep()) ->
+                            function_type_info().
+function_type_info(Name, ArgTypes, OutType) ->
+    ArgType = {tuple, ArgTypes},
+    { function_type_hash(Name, ArgType, OutType)
+    , Name
+    , aeb_heap:to_binary(ArgType)
+    , aeb_heap:to_binary(OutType)
+    }.
+
+-spec function_type_hash(function_name(), typerep(), typerep()) -> hash().
+function_type_hash(Name, ArgType, OutType) when is_binary(Name) ->
+    Bin =  iolist_to_binary([ Name
+                            , aeb_heap:to_binary(ArgType)
+                            , aeb_heap:to_binary(OutType)
+                            ]),
+    %% Calculate a 256 bit digest BLAKE2b hash value of a binary
+    {ok, Hash} = eblake2:blake2b(?HASH_SIZE, Bin),
+    Hash.
+
+-spec arg_typerep_from_function(function_name(), type_info()) ->
+           {'ok', typerep()} | {'error', 'bad_type_data' | 'unknown_function'}.
+arg_typerep_from_function(Function, TypeInfo) ->
+    case lists:keyfind(Function, 2, TypeInfo) of
+        {_TypeHash, Function, ArgTypeBin,_OutTypeBin} ->
+            case aeb_heap:from_binary(typerep, ArgTypeBin) of
+                {ok, ArgType} -> {ok, ArgType};
+                {error,_} -> {error, bad_type_data}
+            end;
+        false ->
+            {error, unknown_function}
+    end.
+
+-spec typereps_from_type_hash(hash(), type_info()) ->
+           {'ok', typerep(), typerep()} | {'error', 'bad_type_data' | 'unknown_function'}.
+typereps_from_type_hash(TypeHash, TypeInfo) ->
+    case lists:keyfind(TypeHash, 1, TypeInfo) of
+        {TypeHash,_Function, ArgTypeBin, OutTypeBin} ->
+            case {aeb_heap:from_binary(typerep, ArgTypeBin),
+                  aeb_heap:from_binary(typerep, OutTypeBin)} of
+                {{ok, ArgType}, {ok, OutType}} -> {ok, ArgType, OutType};
+                {_, _} -> {error, bad_type_data}
+            end;
+        false ->
+            {error, unknown_function}
+    end.
+
+-spec function_name_from_type_hash(hash(), type_info()) ->
+                                          {'ok', function_name()}
+                                        | {'error', 'unknown_function'}.
+function_name_from_type_hash(TypeHash, TypeInfo) ->
+    case lists:keyfind(TypeHash, 1, TypeInfo) of
+        {TypeHash, Function,_ArgTypeBin,_OutTypeBin} ->
+            {ok, Function};
+        false ->
+            {error, unknown_function}
+    end.
+
+-spec type_hash_from_function_name(function_name(), type_info()) ->
+                                          {'ok', hash()}
+                                        | {'error', 'unknown_function'}.
+type_hash_from_function_name(Name, TypeInfo) ->
+    case lists:keyfind(Name, 2, TypeInfo) of
+        {TypeHash, Name,_ArgTypeBin,_OutTypeBin} ->
+            {ok, TypeHash};
+        false ->
+            {error, unknown_function}
+    end.

src/aeb_aevm_data.erl

@@ -0,0 +1,30 @@
+-module(aeb_aevm_data).
+
+-export_type([data/0,
+              type/0,
+              heap/0]).
+
+-type type() :: word | signed_word | string | typerep | function
+              | {list,   type()}
+              | {option, type()}
+              | {tuple, [type()]}
+              | {variant, [[type()]]}.
+
+
+-type data() :: none
+              | {some,   data()}
+              | {option, data()}
+              | word
+              | string
+              | {list,   data()}
+              | {tuple, [data()]}
+              | {variant, integer(), [data()]}
+              | integer()
+              | binary()
+              | [data()]
+              | {}
+              | {data()}
+              | {data(), data()}.
+
+-type heap() :: binary().
+

src/aeb_fate_asm_scan.template

@@ -0,0 +1,142 @@
+%%% -*- erlang-indent-level:4; indent-tabs-mode: nil -*-
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2019, aeternity Anstalt
+%%% @doc
+%%%     Handling FATE code.
+%%% @end
+%%% ###REPLACEWITHNOTE###
+%%%-------------------------------------------------------------------
+
+Definitions.
+DIGIT    = [0-9]
+HEXDIGIT = [0-9a-fA-F]
+LOWER    = [a-z_]
+UPPER    = [A-Z]
+BASE58   = [123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]
+BASE64   = [A-Za-z0-9+/=]
+INT      = {DIGIT}+
+HEX      = 0x{HEXDIGIT}+
+OBJECT   = @[a-z][a-z]_{BASE58}+
+HASH     = #{BASE64}+
+SIG      = \$sg_{BASE58}+
+WS       = [\000-\s]
+ID       = {LOWER}[a-zA-Z0-9_]*
+STRING   = "[^"]*"
+BITS     = (\!)?\<[\s01]*\>
+
+Rules.
+arg{INT}       : {token, {arg, TokenLine, parse_arg(TokenChars)}}.
+var{INT}       : {token, {var, TokenLine, parse_var(TokenChars)}}.
+a              : {token, {stack, TokenLine, 0}}.
+a{INT}         : {token, {stack, TokenLine, parse_acc(TokenChars)}}.
+
+true           : {token, {boolean, TokenLine, true}}.
+false          : {token, {boolean, TokenLine, false}}.
+
+%% ###REPLACEWITHOPTOKENS###
+
+FUNCTION       : {token, {function, TokenLine, 'FUNCTION' }}.
+
+{HASH} :
+ {token, {hash, TokenLine, parse_hash(TokenChars)}}.
+{SIG} :
+ {token, {signature, TokenLine, parse_object(TokenChars)}}.
+{OBJECT} :
+ {token, {object, TokenLine, parse_object(TokenChars)}}.
+{ID} :
+ {token, {id, TokenLine, TokenChars}}.
+{HEX} :
+ {token, {int, TokenLine, parse_hex(TokenChars)}}.
+{INT} :
+ {token, {int, TokenLine, parse_int(TokenChars)}}.
+-{INT} :
+ {token, {int, TokenLine, parse_int(TokenChars)}}.
+
+%% Due to the definition of STRING the tokens start and end with a quote ".
+{STRING} :
+ {token, {string, TokenLine, unicode:characters_to_binary(
+                lists:sublist(TokenChars, 2, length(TokenChars) - 2))}}.
+{BITS} :
+ {token, {bits, TokenLine, bits(TokenChars)}}.
+
+
+%% Symbols
+\-\>  : {token, {to, TokenLine}}.
+\:    : {token, {to, TokenLine}}.
+
+\=\>  : {token, {arrow, TokenLine}}.
+\(\|  : {token, {start_variant, TokenLine}}.
+\|\)  : {token, {end_variant, TokenLine}}.
+
+,   : {token, {',', TokenLine}}.
+\(  : {token, {'(', TokenLine}}.
+\)  : {token, {')', TokenLine}}.
+\[  : {token, {'[', TokenLine}}.
+\]  : {token, {']', TokenLine}}.
+\{  : {token, {'{', TokenLine}}.
+\}  : {token, {'}', TokenLine}}.
+\|  : {token, {'|', TokenLine}}.
+
+;;.* :
+ {token, {comment, TokenLine, drop_prefix($;, TokenChars)}}.
+
+\.  : skip_token.
+
+
+%% Whitespace ignore
+{WS} : skip_token.
+
+%% Comments (TODO: nested comments)
+
+
+. : {error, "Unexpected token: " ++ TokenChars}.
+
+Erlang code.
+
+-export([scan/1]).
+
+-dialyzer({nowarn_function, yyrev/2}).
+
+-ignore_xref([format_error/1, string/2, token/2, token/3, tokens/2, tokens/3]).
+
+-include_lib("aebytecode/include/aeb_fate_opcodes.hrl").
+
+
+parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
+
+parse_int(Chars) -> list_to_integer(Chars).
+
+parse_arg("arg" ++ N) -> list_to_integer(N).
+parse_var("var" ++ N) -> list_to_integer(N).
+parse_acc("a" ++ N) -> list_to_integer(N).
+
+
+parse_hash("#" ++ Chars) ->
+    base64:decode(Chars).
+
+parse_object([_|Chars]) ->
+    case aeser_api_encoder:decode(unicode:characters_to_binary(Chars)) of
+       {account_pubkey, Bin}  -> {address, Bin};
+       {contract_pubkey, Bin} -> {contract, Bin};
+       {oracle_pubkey, Bin}   -> {oracle, Bin};
+       {name, Bin}            -> {name, Bin};
+       {channel, Bin}         -> {channel, Bin};
+       {signature, Bin}       -> {signature, Bin}
+    end.
+
+scan(S) ->
+    string(S).
+
+drop_prefix(C, [C|Rest]) ->
+    drop_prefix(C, Rest);
+drop_prefix(_, Tail) -> Tail.
+
+bits([$!, $< | Rest]) ->
+    bits(Rest, -1);
+bits([$< | Rest]) ->
+    bits(Rest, 0).
+
+bits([$> |_Rest], Acc) -> Acc;
+bits([$0 | Rest], Acc) -> bits(Rest, Acc bsl 1);
+bits([$1 | Rest], Acc) -> bits(Rest, (Acc bsl 1) bor 1);
+bits([$  | Rest], Acc) -> bits(Rest, Acc).

src/aeb_fate_data.erl

@@ -0,0 +1,195 @@
+%% FATE data representation.
+%%
+-include("aeb_fate_data.hrl").
+
+-module(aeb_fate_data).
+
+-type fate_integer()   :: ?FATE_INTEGER_T.
+-type fate_boolean()   :: ?FATE_BOOLEAN_T.
+-type fate_nil()       :: ?FATE_NIL_T.
+-type fate_list()      :: ?FATE_LIST_T.
+-type fate_unit()      :: ?FATE_UNIT_T.
+-type fate_map()       :: ?FATE_MAP_T.
+-type fate_string()    :: ?FATE_STRING_T.
+-type fate_address()   :: ?FATE_ADDRESS_T.
+-type fate_hash()      :: ?FATE_HASH_T.
+-type fate_contract()  :: ?FATE_CONTRACT_T.
+-type fate_oracle()    :: ?FATE_ORACLE_T.
+-type fate_name()      :: ?FATE_NAME_T.
+-type fate_channel()   :: ?FATE_CHANNEL_T.
+-type fate_signature() :: ?FATE_SIGNATURE_T.
+-type fate_variant()   :: ?FATE_VARIANT_T.
+-type fate_tuple()     :: ?FATE_TUPLE_T.
+-type fate_bits()      :: ?FATE_BITS_T.
+
+-type fate_type_type() :: integer
+                        | boolean
+                        | {list, fate_type_type()}
+                        | {map, fate_type_type(), fate_type_type()}
+                        | {tuple, [fate_type_type()]}
+                        | address
+                        | hash
+                        | signature
+                        | contract
+                        | oracle
+                        | name
+                        | channel
+                        | bits
+                        | string
+                        | {variant, [fate_type_type()]}.
+
+
+-type fate_type() ::
+        fate_boolean()
+      | fate_integer()
+      | fate_nil()
+      | fate_list()
+      | fate_unit()
+      | fate_tuple()
+      | fate_string()
+      | fate_address()
+      | fate_hash()
+      | fate_signature()
+      | fate_contract()
+      | fate_oracle()
+      | fate_name()
+      | fate_channel()
+      | fate_variant()
+      | fate_map()
+      | fate_bits().
+
+-export_type([fate_type/0
+             , fate_boolean/0
+             , fate_integer/0
+             , fate_nil/0
+             , fate_list/0
+             , fate_unit/0
+             , fate_tuple/0
+             , fate_string/0
+             , fate_address/0
+             , fate_hash/0
+             , fate_signature/0
+             , fate_contract/0
+             , fate_oracle/0
+             , fate_name/0
+             , fate_channel/0
+             , fate_variant/0
+             , fate_map/0
+             , fate_bits/0
+             , fate_type_type/0
+             ]).
+
+-export([ make_integer/1
+        , make_boolean/1
+        , make_list/1
+        , make_variant/3
+        , make_tuple/1
+        , make_string/1
+        , make_map/1
+        , make_address/1
+        , make_hash/1
+        , make_signature/1
+        , make_contract/1
+        , make_oracle/1
+        , make_name/1
+        , make_channel/1
+        , make_bits/1
+        , make_unit/0
+        ]).
+-export([format/1]).
+
+
+make_boolean(true)  -> ?FATE_TRUE;
+make_boolean(false) -> ?FATE_FALSE.
+make_list([]) ->       ?FATE_NIL;
+make_list(L) ->        ?MAKE_FATE_LIST(L).
+make_unit() ->         ?FATE_UNIT.
+make_tuple(T) ->       ?FATE_TUPLE(T).
+make_map(M) ->         ?MAKE_FATE_MAP(M).
+make_address(X) ->     ?FATE_ADDRESS(X).
+make_hash(X) ->        ?FATE_HASH(X).
+make_signature(X) ->   ?FATE_SIGNATURE(X).
+make_contract(X) ->    ?FATE_CONTRACT(X).
+make_oracle(X) ->      ?FATE_ORACLE(X).
+make_name(X) ->        ?FATE_NAME(X).
+make_channel(X) ->     ?FATE_CHANNEL(X).
+make_integer(I) when is_integer(I) -> ?MAKE_FATE_INTEGER(I).
+make_bits(I)    when is_integer(I) -> ?FATE_BITS(I).
+make_string(S)  when is_list(S) ->
+    ?FATE_STRING(iolist_to_binary(S));
+make_string(S)  when is_binary(S) -> ?FATE_STRING(S).
+
+%% Tag points to the selected variant (zero based)
+%% The arity of this variant is read from the list of provided arities
+%% and should match the size of the given tuple.
+make_variant(Arities, Tag, Values) ->
+    Arities = [A || A <- Arities, is_integer(A), A < 256],
+    Size = length(Arities),
+    if is_integer(Tag)
+       , 0 =< Tag
+       , Tag < Size
+       , is_tuple(Values) ->
+            Arity = lists:nth(Tag+1, Arities),
+            if size(Values) =:= Arity ->
+                    ?FATE_VARIANT(Arities, Tag, Values)
+            end
+    end.
+
+
+
+-spec format(fate_type()) -> iolist().
+format(I) when ?IS_FATE_INTEGER(I) -> integer_to_list(?MAKE_FATE_INTEGER(I));
+format(?FATE_TRUE) -> "true";
+format(?FATE_FALSE) -> "false";
+format(?FATE_NIL) -> "[]";
+format(L) when ?IS_FATE_LIST(L) -> format_list(?FATE_LIST_VALUE(L));
+format(?FATE_UNIT) -> "()";
+format(?FATE_TUPLE(T)) ->
+    ["( ", lists:join(", ", [ format(E) || E <- erlang:tuple_to_list(T)]), " )"];
+format(S) when ?IS_FATE_STRING(S) -> ["\"", S, "\""];
+format(?FATE_BITS(B)) when B >= 0 ->
+    ["<", format_bits(B, "") , ">"];
+format(?FATE_BITS(B)) when B < 0 ->
+    ["!< ", format_nbits(-B-1, "") , " >"];
+format(?FATE_VARIANT(Arities, Tag, T)) ->
+    ["(| ",
+      lists:join("| ",
+                 [format_arities(Arities),
+                  integer_to_list(Tag) |
+                  [format(make_tuple(T))]]),
+     " |)"];
+format(M) when ?IS_FATE_MAP(M) ->
+    ["{ ", format_kvs(maps:to_list(?FATE_MAP_VALUE(M))), " }"];
+format(?FATE_HASH(X))       -> ["#", base64:encode(X)];
+format(?FATE_ADDRESS(X))    ->
+    ["@", aeser_api_encoder:encode(account_pubkey, X)];
+format(?FATE_SIGNATURE(X))  ->
+    ["$", aeser_api_encoder:encode(signature, X)];
+format(?FATE_CONTRACT(X))   ->
+    ["@", aeser_api_encoder:encode(contract_pubkey, X)];
+format(?FATE_ORACLE(X))     ->
+    ["@", aeser_api_encoder:encode(oracle_pubkey, X)];
+format(?FATE_NAME(X))       ->
+    ["@", aeser_api_encoder:encode(name, X)];
+format(?FATE_CHANNEL(X))    ->
+    ["@", aeser_api_encoder:encode(channel, X)];
+format(V) -> exit({not_a_fate_type, V}).
+
+format_bits(0, Acc) -> Acc;
+format_bits(N, Acc) ->
+    Bit = $0 + (N band 1),
+    format_bits(N bsr 1, [Bit|Acc]).
+
+format_nbits(0, Acc) -> Acc;
+format_nbits(N, Acc) ->
+    Bit = $1 - (N band 1),
+    format_nbits(N bsr 1, [Bit|Acc]).
+
+format_arities(Arities) ->
+    ["[ ", lists:join(", ", [integer_to_list(E) || E <- Arities]), " ]"].
+
+format_list(List) ->
+    ["[ ", lists:join(", ", [format(E) || E <- List]), " ]"].
+
+format_kvs(List) ->
+    lists:join(", ", [ [format(K), " => ",  format(V)] || {K, V} <- List]).

src/aeb_fate_encoding.erl

@@ -0,0 +1,401 @@
+%% Fate data (and instruction) serialization.
+%%
+%% The FATE serialization has to fullfill the following properties:
+%% * There has to be 1 and only 1 byte sequence
+%%     representing each unique value in FATE.
+%% * A valid byte sequence has to be deserializable to a FATE value.
+%% * A valid byte sequence must not contain any trailing bytes.
+%% * A serialization is a sequence of 8-bit bytes.
+%%
+%% The serialization function should fullfill the following:
+%% * A valid FATE value should be serialized to a byte sequence.
+%% * Any other argument, not representing a valid FATE value should
+%%     throw an exception
+%%
+%% The deserialization function should fullfill the following:
+%% * A valid byte sequence should be deserialized to a valid FATE value.
+%% * Any other argument, not representing a valid byte sequence should
+%%     throw an exception
+%%
+%% History
+%% * First draft of FATE serialization encoding/decoding.
+%%   Initial experiment with tags
+%% * Second draft
+%%  * FATE data is now defined in aefa_data.erl
+%% * Third draft
+%%  * Added Bit strings
+%%
+%% TODO:
+%%   * Make the code production ready.
+%%       (add tests, document exported functions).
+%%   * Handle instructions.
+%%
+%% ------------------------------------------------------------------------
+-module(aeb_fate_encoding).
+
+-export([ deserialize/1
+        , deserialize_one/1
+        , deserialize_type/1
+        , serialize/1
+        , serialize_type/1
+        ]).
+
+-include("aeb_fate_data.hrl").
+
+%% Definition of tag scheme.
+%% This has to follow the protocol specification.
+
+-define(SMALL_INT    ,        2#0). %% sxxxxxx 0 - 6 bit integer with sign bit
+%%                                             1 Set below
+-define(LONG_STRING  , 2#00000001). %% 000000 01 | RLP encoded array - when size >= 64
+-define(SHORT_STRING ,       2#01). %% xxxxxx 01 | [bytes] - when 0 < xxxxxx:size < 64
+%%                                            11  Set below
+-define(SHORT_LIST   ,     2#0011). %% xxxx 0011 | [encoded elements] when  0 < length < 16
+%%                                     xxxx 0111
+-define(TYPE_INTEGER , 2#00000111). %% 0000 0111 - Integer typedef
+-define(TYPE_BOOLEAN , 2#00010111). %% 0001 0111 - Boolean typedef
+-define(TYPE_LIST    , 2#00100111). %% 0010 0111 | Type
+-define(TYPE_TUPLE   , 2#00110111). %% 0011 0111 | Size | [Element Types]
+-define(TYPE_OBJECT  , 2#01000111). %% 0100 0111 | ObjectType
+-define(TYPE_BITS    , 2#01010111). %% 0101 0111 - Bits typedef
+-define(TYPE_MAP     , 2#01100111). %% 0110 0111 | Type | Type
+-define(TYPE_STRING  , 2#01110111). %% 0111 0111 - string typedef
+-define(TYPE_VARIANT , 2#10000111). %% 1000 0111 | [Arities] | [Type]
+                                    %% 1001 0111
+                                    %% 1010 0111
+                                    %% 1011 0111
+                                    %% 1100 0111
+                                    %% 1101 0111
+                                    %% 1110 0111
+                                    %% 1111 0111
+-define(LONG_TUPLE   , 2#00001011). %% 0000 1011 | RLP encoded (size - 16) | [encoded elements],
+-define(SHORT_TUPLE  ,     2#1011). %% xxxx 1011 | [encoded elements] when 0  <  size < 16
+%%                                          1111 Set below
+-define(LONG_LIST    , 2#00011111). %% 0001 1111 | RLP encoded (length - 16) | [encoded lements]
+-define(MAP          , 2#00101111). %% 0010 1111 | RLP encoded size | [encoded key, encoded value]
+-define(EMPTY_TUPLE  , 2#00111111). %% 0011 1111
+-define(POS_BITS     , 2#01001111). %% 0100 1111 | RLP encoded integer (to be interpreted as bitfield)
+-define(EMPTY_STRING , 2#01011111). %% 0101 1111
+-define(POS_BIG_INT  , 2#01101111). %% 0110 1111 | RLP encoded (integer - 64)
+-define(FALSE        , 2#01111111). %% 0111 1111
+%%                                  %% 1000 1111 - FREE (Possibly for bytecode in the future.)
+-define(OBJECT       , 2#10011111). %% 1001 1111 | ObjectType | RLP encoded Array
+-define(VARIANT      , 2#10101111). %% 1010 1111 | [encoded arities] | encoded tag | [encoded values]
+-define(NIL          , 2#10111111). %% 1011 1111 - Empty list
+-define(NEG_BITS     , 2#11001111). %% 1100 1111 | RLP encoded integer (infinite 1:s bitfield)
+-define(EMPTY_MAP    , 2#11011111). %% 1101 1111
+-define(NEG_BIG_INT  , 2#11101111). %% 1110 1111 | RLP encoded (integer - 64)
+-define(TRUE         , 2#11111111). %% 1111 1111
+
+-define(SHORT_TUPLE_SIZE,  16).
+-define(SHORT_LIST_SIZE,   16).
+-define(SMALL_INT_SIZE,    64).
+-define(SHORT_STRING_SIZE, 64).
+
+-define(POS_SIGN, 0).
+-define(NEG_SIGN, 1).
+
+%% Object types
+-define(OTYPE_ADDRESS,   0).
+-define(OTYPE_HASH,      1).
+-define(OTYPE_SIGNATURE, 2).
+-define(OTYPE_CONTRACT,  3).
+-define(OTYPE_ORACLE,    4).
+-define(OTYPE_NAME,      5).
+-define(OTYPE_CHANNEL,   6).
+
+%% --------------------------------------------------
+%% Serialize
+%% Serialized a Fate data value into a sequence of bytes
+%% according to the Fate serialization specification.
+%% TODO: The type Fate Data is not final yet.
+-spec serialize(aeb_fate_data:fate_type()) -> binary().
+serialize(?FATE_TRUE)        -> <<?TRUE>>;
+serialize(?FATE_FALSE)       -> <<?FALSE>>;
+serialize(?FATE_NIL)         -> <<?NIL>>;     %% ! Untyped
+serialize(?FATE_UNIT)        -> <<?EMPTY_TUPLE>>;  %% ! Untyped
+serialize(M) when ?IS_FATE_MAP(M), ?FATE_MAP_SIZE(M) =:= 0 -> <<?EMPTY_MAP>>;  %% ! Untyped
+serialize(?FATE_EMPTY_STRING) -> <<?EMPTY_STRING>>;
+serialize(I) when ?IS_FATE_INTEGER(I) -> serialize_integer(I);
+serialize(?FATE_BITS(Bits)) when is_integer(Bits) -> serialize_bits(Bits);
+serialize(String) when ?IS_FATE_STRING(String),
+                       ?FATE_STRING_SIZE(String) > 0,
+                       ?FATE_STRING_SIZE(String) < ?SHORT_STRING_SIZE ->
+    Size = ?FATE_STRING_SIZE(String),
+    Bytes = ?FATE_STRING_VALUE(String),
+    <<Size:6, ?SHORT_STRING:2, Bytes/binary>>;
+serialize(String) when ?IS_FATE_STRING(String),
+                       ?FATE_STRING_SIZE(String) > 0,
+                       ?FATE_STRING_SIZE(String) >= ?SHORT_STRING_SIZE ->
+    Bytes = ?FATE_STRING_VALUE(String),
+    <<?LONG_STRING, (aeser_rlp:encode(Bytes))/binary>>;
+serialize(?FATE_ADDRESS(Address)) when is_binary(Address) ->
+    <<?OBJECT, ?OTYPE_ADDRESS, (aeser_rlp:encode(Address))/binary>>;
+serialize(?FATE_HASH(Address)) when is_binary(Address) ->
+    <<?OBJECT, ?OTYPE_HASH, (aeser_rlp:encode(Address))/binary>>;
+serialize(?FATE_SIGNATURE(Address)) when is_binary(Address) ->
+    <<?OBJECT, ?OTYPE_SIGNATURE, (aeser_rlp:encode(Address))/binary>>;
+serialize(?FATE_CONTRACT(Address)) when is_binary(Address) ->
+    <<?OBJECT, ?OTYPE_CONTRACT, (aeser_rlp:encode(Address))/binary>>;
+serialize(?FATE_ORACLE(Address)) when is_binary(Address) ->
+    <<?OBJECT, ?OTYPE_ORACLE, (aeser_rlp:encode(Address))/binary>>;
+serialize(?FATE_NAME(Address)) when is_binary(Address) ->
+    <<?OBJECT, ?OTYPE_NAME, (aeser_rlp:encode(Address))/binary>>;
+serialize(?FATE_CHANNEL(Address)) when is_binary(Address) ->
+    <<?OBJECT, ?OTYPE_CHANNEL, (aeser_rlp:encode(Address))/binary>>;
+serialize(?FATE_TUPLE(T)) when size(T) > 0 ->
+    S = size(T),
+    L = tuple_to_list(T),
+    Rest = << <<(serialize(E))/binary>> || E <- L >>,
+    if S < ?SHORT_TUPLE_SIZE ->
+            <<S:4, ?SHORT_TUPLE:4, Rest/binary>>;
+       true ->
+            Size = rlp_integer(S - ?SHORT_TUPLE_SIZE),
+            <<?LONG_TUPLE:8, Size/binary, Rest/binary>>
+    end;
+serialize(L) when ?IS_FATE_LIST(L) ->
+    [_E|_] = List = ?FATE_LIST_VALUE(L),
+    S = length(List),
+    Rest = << <<(serialize(El))/binary>> || El <- List >>,
+    if S < ?SHORT_LIST_SIZE ->
+            <<S:4, ?SHORT_LIST:4, Rest/binary>>;
+       true ->
+            Val = rlp_integer(S - ?SHORT_LIST_SIZE),
+            <<?LONG_LIST, Val/binary, Rest/binary>>
+    end;
+serialize(Map) when ?IS_FATE_MAP(Map) ->
+    L = [{_K,_V}|_] = lists:sort(maps:to_list(?FATE_MAP_VALUE(Map))),
+    Size = length(L),
+    %% TODO:  check all K same type, and all V same type
+    %%        check K =/= map
+    Elements = << <<(serialize(K1))/binary, (serialize(V1))/binary>> || {K1,V1} <- L >>,
+    <<?MAP,
+      (rlp_integer(Size))/binary,
+      (Elements)/binary>>;
+serialize(?FATE_VARIANT(Arities, Tag, Values)) ->
+    Arities = [A || A <- Arities, is_integer(A), A < 256],
+    Size = length(Arities),
+    if is_integer(Tag)
+       , 0 =< Tag
+       , Tag < Size
+       , is_tuple(Values) ->
+            Arity  =  lists:nth(Tag+1, Arities),
+            if size(Values) =:= Arity ->
+                    EncodedArities = aeser_rlp:encode(list_to_binary(Arities)),
+                    <<?VARIANT,
+                      EncodedArities/binary,
+                      Tag:8,
+                      (serialize(?FATE_TUPLE(Values)))/binary
+                    >>
+            end
+    end.
+
+
+%% -----------------------------------------------------
+
+-spec serialize_type(aeb_fate_data:fate_type_type()) -> [byte()].
+serialize_type(integer)     -> [?TYPE_INTEGER];
+serialize_type(boolean)     -> [?TYPE_BOOLEAN];
+serialize_type({list, T})   -> [?TYPE_LIST | serialize_type(T)];
+serialize_type({tuple, Ts}) ->
+    case length(Ts) of
+        N when N =< 255 ->
+            [?TYPE_TUPLE, N | [serialize_type(T) || T <- Ts]]
+    end;
+serialize_type(address)     -> [?TYPE_OBJECT, ?OTYPE_ADDRESS];
+serialize_type(hash)        -> [?TYPE_OBJECT, ?OTYPE_HASH];
+serialize_type(signature)   -> [?TYPE_OBJECT, ?OTYPE_SIGNATURE];
+serialize_type(contract)    -> [?TYPE_OBJECT, ?OTYPE_CONTRACT];
+serialize_type(oracle)      -> [?TYPE_OBJECT, ?OTYPE_ORACLE];
+serialize_type(name)        -> [?TYPE_OBJECT, ?OTYPE_NAME];
+serialize_type(channel)     -> [?TYPE_OBJECT, ?OTYPE_CHANNEL];
+serialize_type(bits)        -> [?TYPE_BITS];
+serialize_type({map, K, V}) -> [?TYPE_MAP
+                                | serialize_type(K) ++ serialize_type(V)];
+serialize_type(string)      -> [?TYPE_STRING];
+serialize_type({variant, ListOfVariants}) ->
+    Size = length(ListOfVariants),
+    if Size < 256 ->
+            [?TYPE_VARIANT, Size | [serialize_type(T) || T <- ListOfVariants]]
+    end.
+
+
+-spec deserialize_type(binary()) -> {aeb_fate_data:fate_type_type(), binary()}.
+deserialize_type(<<?TYPE_INTEGER, Rest/binary>>) -> {integer, Rest};
+deserialize_type(<<?TYPE_BOOLEAN, Rest/binary>>) -> {boolean, Rest};
+deserialize_type(<<?TYPE_LIST, Rest/binary>>) ->
+    {T, Rest2} = deserialize_type(Rest),
+    {{list, T}, Rest2};
+deserialize_type(<<?TYPE_TUPLE, N, Rest/binary>>) ->
+    {Ts, Rest2} = deserialize_types(N, Rest, []),
+    {{tuple, Ts}, Rest2};
+deserialize_type(<<?TYPE_OBJECT, ObjectType, Rest/binary>>) ->
+    case ObjectType of
+        ?OTYPE_ADDRESS   -> {address, Rest};
+        ?OTYPE_HASH      -> {hash, Rest};
+        ?OTYPE_SIGNATURE -> {signature, Rest};
+        ?OTYPE_CONTRACT  -> {contract, Rest};
+        ?OTYPE_ORACLE    -> {oracle, Rest};
+        ?OTYPE_NAME      -> {name, Rest};
+        ?OTYPE_CHANNEL   -> {channel, Rest}
+    end;
+deserialize_type(<<?TYPE_BITS, Rest/binary>>) -> {bits, Rest};
+deserialize_type(<<?TYPE_MAP, Rest/binary>>) ->
+    {K, Rest2} = deserialize_type(Rest),
+    {V, Rest3} = deserialize_type(Rest2),
+    {{map, K, V}, Rest3};
+deserialize_type(<<?TYPE_STRING, Rest/binary>>) ->
+    {string, Rest};
+deserialize_type(<<?TYPE_VARIANT, Size, Rest/binary>>) ->
+    {Variants, Rest2} = deserialize_variants(Size, Rest, []),
+    {{variant, Variants}, Rest2}.
+
+deserialize_variants(0, Rest, Variants) ->
+    {lists:reverse(Variants), Rest};
+deserialize_variants(N, Rest, Variants) ->
+    {T, Rest2} = deserialize_type(Rest),
+    deserialize_variants(N-1, Rest2, [T|Variants]).
+
+
+
+deserialize_types(0, Binary, Acc) ->
+    {lists:reverse(Acc), Binary};
+deserialize_types(N, Binary, Acc) ->
+    {T, Rest} = deserialize_type(Binary),
+    deserialize_types(N-1, Rest, [T | Acc]).
+
+
+%% -----------------------------------------------------
+
+rlp_integer(S) when S >= 0 ->
+    aeser_rlp:encode(binary:encode_unsigned(S)).
+
+serialize_integer(I) when ?IS_FATE_INTEGER(I) ->
+    V = ?FATE_INTEGER_VALUE(I),
+    Abs = abs(V),
+    Sign = case V < 0 of
+               true  -> ?NEG_SIGN;
+               false -> ?POS_SIGN
+           end,
+    if Abs < ?SMALL_INT_SIZE -> <<Sign:1, Abs:6, ?SMALL_INT:1>>;
+       Sign =:= ?NEG_SIGN -> <<?NEG_BIG_INT,
+                               (rlp_integer(Abs - ?SMALL_INT_SIZE))/binary>>;
+       Sign =:= ?POS_SIGN -> <<?POS_BIG_INT,
+                               (rlp_integer(Abs - ?SMALL_INT_SIZE))/binary>>
+    end.
+
+serialize_bits(B) when is_integer(B) ->
+    Abs = abs(B),
+    Sign = case B < 0 of
+               true  -> ?NEG_SIGN;
+               false -> ?POS_SIGN
+           end,
+    if
+        Sign =:= ?NEG_SIGN -> <<?NEG_BITS, (rlp_integer(Abs))/binary>>;
+        Sign =:= ?POS_SIGN -> <<?POS_BITS, (rlp_integer(Abs))/binary>>
+    end.
+
+-spec deserialize(binary()) -> aeb_fate_data:fate_type().
+deserialize(B) ->
+    {T, <<>>} = deserialize2(B),
+    T.
+
+deserialize_one(B) -> deserialize2(B).
+
+deserialize2(<<?POS_SIGN:1, I:6, ?SMALL_INT:1, Rest/binary>>) ->
+    {?MAKE_FATE_INTEGER(I), Rest};
+deserialize2(<<?NEG_SIGN:1, I:6, ?SMALL_INT:1, Rest/binary>>) ->
+    {?MAKE_FATE_INTEGER(-I), Rest};
+deserialize2(<<?NEG_BIG_INT, Rest/binary>>) ->
+    {Bint, Rest2} = aeser_rlp:decode_one(Rest),
+    {?MAKE_FATE_INTEGER(-binary:decode_unsigned(Bint) - ?SMALL_INT_SIZE),
+     Rest2};
+deserialize2(<<?POS_BIG_INT, Rest/binary>>) ->
+    {Bint, Rest2} = aeser_rlp:decode_one(Rest),
+    {?MAKE_FATE_INTEGER(binary:decode_unsigned(Bint) + ?SMALL_INT_SIZE),
+     Rest2};
+deserialize2(<<?NEG_BITS, Rest/binary>>) ->
+    {Bint, Rest2} = aeser_rlp:decode_one(Rest),
+    {?FATE_BITS(-binary:decode_unsigned(Bint)), Rest2};
+deserialize2(<<?POS_BITS, Rest/binary>>) ->
+    {Bint, Rest2} = aeser_rlp:decode_one(Rest),
+    {?FATE_BITS(binary:decode_unsigned(Bint)), Rest2};
+deserialize2(<<?LONG_STRING, Rest/binary>>) ->
+    {String, Rest2} = aeser_rlp:decode_one(Rest),
+    {?MAKE_FATE_STRING(String), Rest2};
+deserialize2(<<S:6, ?SHORT_STRING:2, Rest/binary>>) ->
+    String = binary:part(Rest, 0, S),
+    Rest2 = binary:part(Rest, byte_size(Rest), - (byte_size(Rest) - S)),
+    {?MAKE_FATE_STRING(String), Rest2};
+deserialize2(<<?OBJECT, ObjectType, Rest/binary>>) ->
+    {A, Rest2} = aeser_rlp:decode_one(Rest),
+    Val =
+        case ObjectType of
+            ?OTYPE_ADDRESS   -> ?FATE_ADDRESS(A);
+            ?OTYPE_HASH      -> ?FATE_HASH(A);
+            ?OTYPE_SIGNATURE -> ?FATE_SIGNATURE(A);
+            ?OTYPE_CONTRACT  -> ?FATE_CONTRACT(A);
+            ?OTYPE_ORACLE    -> ?FATE_ORACLE(A);
+            ?OTYPE_NAME      -> ?FATE_NAME(A);
+            ?OTYPE_CHANNEL   -> ?FATE_CHANNEL(A)
+        end,
+    {Val, Rest2};
+deserialize2(<<?TRUE, Rest/binary>>) ->
+    {?FATE_TRUE, Rest};
+deserialize2(<<?FALSE, Rest/binary>>) ->
+    {?FATE_FALSE, Rest};
+deserialize2(<<?NIL, Rest/binary>>) ->
+    {?FATE_NIL, Rest};
+deserialize2(<<?EMPTY_TUPLE, Rest/binary>>) ->
+    {?FATE_UNIT, Rest};
+deserialize2(<<?EMPTY_MAP, Rest/binary>>) ->
+    {?MAKE_FATE_MAP(#{}), Rest};
+deserialize2(<<?EMPTY_STRING, Rest/binary>>) ->
+    {?FATE_EMPTY_STRING, Rest};
+deserialize2(<<?LONG_TUPLE, Rest/binary>>) ->
+    {BSize, Rest1} = aeser_rlp:decode_one(Rest),
+    N = binary:decode_unsigned(BSize) + ?SHORT_TUPLE_SIZE,
+    {List, Rest2} = deserialize_elements(N, Rest1),
+    {?FATE_TUPLE(list_to_tuple(List)), Rest2};
+deserialize2(<<S:4, ?SHORT_TUPLE:4, Rest/binary>>) ->
+    {List, Rest1} = deserialize_elements(S, Rest),
+    {?FATE_TUPLE(list_to_tuple(List)), Rest1};
+deserialize2(<<?LONG_LIST, Rest/binary>>) ->
+    {BLength, Rest1} = aeser_rlp:decode_one(Rest),
+    Length = binary:decode_unsigned(BLength) + ?SHORT_LIST_SIZE,
+    {List, Rest2} = deserialize_elements(Length, Rest1),
+    {?MAKE_FATE_LIST(List), Rest2};
+deserialize2(<<S:4, ?SHORT_LIST:4, Rest/binary>>) ->
+    {List, Rest1} = deserialize_elements(S, Rest),
+    {?MAKE_FATE_LIST(List), Rest1};
+deserialize2(<<?MAP, Rest/binary>>) ->
+    {BSize, Rest1} = aeser_rlp:decode_one(Rest),
+    Size = binary:decode_unsigned(BSize),
+    {List, Rest2} = deserialize_elements(2*Size, Rest1),
+    Map = insert_kv(List, #{}),
+    {?MAKE_FATE_MAP(Map), Rest2};
+deserialize2(<<?VARIANT, Rest/binary>>) ->
+    {AritiesBin, <<Tag:8, Rest2/binary>>} = aeser_rlp:decode_one(Rest),
+    Arities = binary_to_list(AritiesBin),
+    Size = length(Arities),
+    if Tag > Size -> exit({too_large_tag_in_variant, Tag, Size});
+       true ->
+            {?FATE_TUPLE(T), Rest3} = deserialize2(Rest2),
+            Arity = lists:nth(Tag+1, Arities),
+            NumElements = size(T),
+            if NumElements =/= Arity ->
+                    exit({tag_does_not_match_type_in_variant, Tag, Arity});
+               true ->
+                    {?FATE_VARIANT(Arities, Tag, T), Rest3}
+            end
+    end.
+
+insert_kv([], M) -> M;
+insert_kv([K,V|R], M) -> insert_kv(R, maps:put(K, V, M)).
+
+deserialize_elements(0, Rest) ->
+    {[], Rest};
+deserialize_elements(N, Es) ->
+    {E, Rest} = deserialize2(Es),
+    {Tail, Rest2} = deserialize_elements(N-1, Rest),
+    {[E|Tail], Rest2}.

src/aeb_fate_generate_ops.erl

@@ -0,0 +1,689 @@
+-module(aeb_fate_generate_ops).
+
+-export([ gen_and_halt/1
+        , generate/0
+        , generate_documentation/1
+        , get_ops/0
+        , test_asm_generator/1]).
+
+gen_and_halt([SrcDirArg, IncludeDirArg]) ->
+    generate(atom_to_list(SrcDirArg),
+             atom_to_list(IncludeDirArg)),
+    halt().
+
+generate() -> generate("src/", "include/").
+
+get_ops()  -> gen(ops_defs()).
+
+generate(Src, Include) ->
+    Ops = get_ops(),
+    %% io:format("ops: ~p\n", [Ops]),
+    HrlFile = Include ++ "aeb_fate_opcodes.hrl",
+    generate_header_file(HrlFile, Ops),
+    generate_opcodes_ops(aeb_fate_opcodes, HrlFile, Src, Ops),
+    generate_code_ops(aeb_fate_code, Src, Ops),
+    generate_scanner("aeb_fate_asm_scan.template", "aeb_fate_asm_scan.xrl", Src, Ops),
+    gen_asm_pp(aeb_fate_pp, Src, Ops).
+
+%% TODO: Some real gas numbers...
+ops_defs() ->
+    %%  Opname,        Opcode, args, end_bb, gas, format,      Constructor, Documentation
+    [ { 'RETURN',       16#00,    0,   true,   2, atomic,           return, "Return from function call pop stack to arg0. The type of the retun value has to match the return type of the function."}
+    , { 'RETURNR',      16#01,    1,   true,   2, [a],             returnr, "Return from function call copy Arg0 to arg0. The type of the retun value has to match the return type of the function."}
+    , { 'CALL',         16#02,    1,   true,   4, [is],               call, "Call given function with args on stack. The types of the arguments has to match the argument typs of the function."}
+    , { 'CALL_R',       16#03,    2,   true,   8, [a,is],           call_r, "Remote call to given contract and function.  The types of the arguments has to match the argument typs of the function."}
+    , { 'CALL_T',       16#04,    1,   true,   4, [is],             call_t, "Tail call to given function. The types of the arguments has to match the argument typs of the function. And the return type of the called function has to match the type of the current function."}
+    , { 'CALL_TR',      16#05,    2,   true,   8, [a,is],          call_tr, "Remote tail call to given contract and function. The types of the arguments has to match the argument typs of the function. And the return type of the called function has to match the type of the current function."}
+    , { 'JUMP',         16#06,    1,   true,   3, [ii],               jump, "Jump to a basic block. The basic block has to exist in the current function."}
+    , { 'JUMPIF',       16#07,    2,   true,   4, [a,ii],           jumpif, "Conditional jump to a basic block. If Arg0 then jump to Arg1."}
+    , { 'SWITCH_V2',    16#08,    3,   true,   4, [a,ii,ii],        switch, "Conditional jump to a basic block on variant tag."}
+    , { 'SWITCH_V3',    16#09,    4,   true,   4, [a,ii,ii,ii],     switch, "Conditional jump to a basic block on variant tag."}
+    , { 'SWITCH_VN',    16#0a,    2,   true,   4, [a, li],           switch, "Conditional jump to a basic block on variant tag."}
+    , { 'PUSH',         16#0b,    1,  false,   2, [a],                push, "Push argument to stack."}
+    , { 'DUPA',         16#0c,    0,  false,   3, atomic,              dup, "push copy of accumulator on stack."}
+    , { 'DUP',          16#0d,    1,  false,   3, [a],                 dup, "push Arg0 stack pos on top of stack."}
+    , { 'POP',          16#0e,    1,  false,   3, [a],                 pop, "Arg0 := top of stack."}
+    , { 'STORE',        16#0f,    2,  false,   3, [a,a],             store, "Arg0 := Arg1."}
+    , { 'INCA',         16#10,    0,  false,   2, atomic,              inc, "Increment accumulator."}
+    , { 'INC',          16#11,    1,  false,   2, [a],                 inc, "Increment argument."}
+    , { 'DECA',         16#12,    0,  false,   2, atomic,              dec, "Decrement accumulator."}
+    , { 'DEC',          16#13,    1,  false,   2, [a],                 dec, "Decrement argument."}
+    , { 'ADD',          16#14,    3,  false,   3, [a,a,a],             add, "Arg0 := Arg1 + Arg2."}
+    , { 'SUB',          16#15,    3,  false,   3, [a,a,a],             sub, "Arg0 := Arg1 - Arg2."}
+    , { 'MUL',          16#16,    3,  false,   3, [a,a,a],             mul, "Arg0 := Arg1 * Arg2."}
+    , { 'DIV',          16#17,    3,  false,   3, [a,a,a],          divide, "Arg0 := Arg1 / Arg2."}
+    , { 'MOD',          16#18,    3,  false,   3, [a,a,a],          modulo, "Arg0 := Arg1 mod Arg2."}
+    , { 'POW',          16#19,    3,  false,   3, [a,a,a],             pow, "Arg0 := Arg1  ^ Arg2."}
+    , { 'LT',           16#20,    3,  false,   3, [a,a,a],              lt, "Arg0 := Arg1  < Arg2."}
+    , { 'GT',           16#21,    3,  false,   3, [a,a,a],              gt, "Arg0 := Arg1  > Arg2."}
+    , { 'EQ',           16#22,    3,  false,   3, [a,a,a],              eq, "Arg0 := Arg1  = Arg2."}
+    , { 'ELT',          16#23,    3,  false,   3, [a,a,a],             elt, "Arg0 := Arg1 =< Arg2."}
+    , { 'EGT',          16#24,    3,  false,   3, [a,a,a],             egt, "Arg0 := Arg1 >= Arg2."}
+    , { 'NEQ',          16#25,    3,  false,   3, [a,a,a],             neq, "Arg0 := Arg1 /= Arg2."}
+    , { 'AND',          16#26,    3,  false,   3, [a,a,a],          and_op, "Arg0 := Arg1 and Arg2."}
+    , { 'OR',           16#27,    3,  false,   3, [a,a,a],           or_op, "Arg0 := Arg1  or Arg2."}
+    , { 'NOT',          16#28,    2,  false,   3, [a,a],            not_op, "Arg0 := not Arg1."}
+    , { 'TUPLE',        16#29,    1,  false,   3, [ii],              tuple, "Create a tuple of size = Arg0. Elements on stack."}
+    , { 'ELEMENT',      16#2a,    3,  false,   3, [a,a,a],      element_op, "Arg1 := element(Arg2, Arg3)."}
+    , { 'MAP_EMPTY',    16#2b,    1,  false,   3, [a],           map_empty, "Arg0 := #{}."}
+    , { 'MAP_LOOKUP',   16#2c,    3,  false,   3, [a,a,a],      map_lookup, "Arg0 := lookup key Arg2 in map Arg1."}
+    , { 'MAP_LOOKUPD',  16#2d,    4,  false,   3, [a,a,a,a],    map_lookup, "Arg0 := lookup key Arg2 in map Arg1 if key exists in map otherwise Arg0 := Arg3."}
+    , { 'MAP_UPDATE',   16#2e,    4,  false,   3, [a,a,a,a],    map_update, "Arg0 := update key Arg2 in map Arg1 with value Arg3."}
+    , { 'MAP_DELETE',   16#2f,    3,  false,   3, [a,a,a],      map_delete, "Arg0 := delete key Arg2 from map Arg1."}
+    , { 'MAP_MEMBER',   16#30,    3,  false,   3, [a,a,a],      map_member, "Arg0 := true if key Arg2 is in map Arg1."}
+    , { 'MAP_FROM_LIST',16#31,    2,  false,   3, [a,a],     map_from_list, "Arg0 := make a map from (key, value) list in Arg1."}
+    , { 'NIL',          16#32,    1,  false,   3, [a],                 nil, "Arg0 := []."}
+    , { 'IS_NIL',       16#33,    2,  false,   3, [a,a],            is_nil, "Arg0 := true if Arg1 == []."}
+    , { 'CONS',         16#34,    3,  false,   3, [a,a,a],            cons, "Arg0 := [Arg1|Arg2]."}
+    , { 'HD',           16#35,    2,  false,   3, [a,a],                hd, "Arg0 := head of list Arg1."}
+    , { 'TL',           16#36,    2,  false,   3, [a,a],                tl, "Arg0 := tail of list Arg1."}
+    , { 'LENGTH',       16#37,    2,  false,   3, [a,a],            length, "Arg0 := length of list Arg1."}
+    , { 'STR_EQ',       16#38,    3,  false,   3, [a,a,a],          str_eq, "Arg0 := true iff the strings Arg1 and Arg2 are the same."}
+    , { 'STR_JOIN',     16#39,    3,  false,   3, [a,a,a],        str_join, "Arg0 := string Arg1 followed by string Arg2."}
+    , { 'INT_TO_STR',   16#40,    2,  false,   3, [a,a],        int_to_str, "Arg0 := turn integer Arg1 into a string."}
+    , { 'ADDR_TO_STR',  16#41,    2,  false,   3, [a,a],       addr_to_str, "Arg0 := turn address Arg1 into a string."}
+    , { 'STR_REVERSE',  16#42,    2,  false,   3, [a,a],       str_reverse, "Arg0 := the reverse of string Arg1."}
+    , { 'INT_TO_ADDR',  16#43,    2,  false,   3, [a,a],       int_to_addr, "Arg0 := turn integer Arg1 into an address."}
+    , { 'VARIANT',      16#44,    4,  false,   3, [a,a,a,a],       variant, "Arg0 := create a variant of size Arg1 with the tag Arg2 (Arg2 < Arg1) and take Arg3 elements from the stack."}
+    , { 'VARIANT_TEST', 16#45,    3,  false,   3, [a,a,a],    variant_test, "Arg0 := true if variant Arg1 has the tag Arg2."}
+    , { 'VARIANT_ELEMENT',16#46,  3,  false,   3, [a,a,a], variant_element, "Arg0 := element number Arg2 from variant Arg1."}
+    , { 'BITS_NONEA',   16#47,    0,  false,   3, atomic,        bits_none, "accumulator := empty bitmap."}
+    , { 'BITS_NONE',    16#48,    1,  false,   3, [a],           bits_none, "Arg0 := empty bitmap."}
+    , { 'BITS_ALLA',    16#49,    0,  false,   3, atomic,         bits_all, "accumulator := full bitmap."}
+    , { 'BITS_ALL',     16#50,    1,  false,   3, [a],            bits_all, "Arg0 := full bitmap."}
+    , { 'BITS_ALL_N',   16#51,    2,  false,   3, [a,a],        bits_all_n, "Arg0 := bitmap with Arg1 bits set."}
+    , { 'BITS_SET',     16#52,    3,  false,   3, [a,a,a],        bits_set, "Arg0 := set bit Arg2 of bitmap Arg1."}
+    , { 'BITS_CLEAR',   16#53,    3,  false,   3, [a,a,a],      bits_clear, "Arg0 := clear bit Arg2 of bitmap Arg1."}
+    , { 'BITS_TEST',    16#54,    3,  false,   3, [a,a,a],       bits_test, "Arg0 := true if bit Arg2 of bitmap Arg1 is set."}
+    , { 'BITS_SUM',     16#55,    2,  false,   3, [a,a],          bits_sum, "Arg0 := sum of set bits in bitmap Arg1. Exception if infinit bitmap."}
+    , { 'BITS_OR',      16#56,    3,  false,   3, [a,a,a],         bits_or, "Arg0 := Arg1 v Arg2."}
+    , { 'BITS_AND',     16#57,    3,  false,   3, [a,a,a],        bits_and, "Arg0 := Arg1 ^ Arg2."}
+    , { 'BITS_DIFF',    16#58,    3,  false,   3, [a,a,a],       bits_diff, "Arg0 := Arg1 - Arg2."}
+    , { 'ADDRESS',      16#59,    1,  false,   3, [a],             address, "Arg0 := The current contract address."}
+    , { 'BALANCE',      16#5a,    1,  false,   3, [a],             balance, "Arg0 := The current contract balance."}
+    , { 'ORIGIN',       16#5b,    1,  false,   3, [a],              origin, "Arg0 := Address of contract called by the call transaction."}
+    , { 'CALLER',       16#5c,    1,  false,   3, [a],              caller, "Arg0 := The address that signed the call transaction."}
+    , { 'GASPRICE',     16#5d,    1,  false,   3, [a],            gasprice, "Arg0 := The current gas price."}
+    , { 'BLOCKHASH',    16#5e,    2,  false,   3, [a, a],        blockhash, "Arg0 := The blockhash at height."}
+    , { 'BENEFICIARY',  16#5f,    1,  false,   3, [a],         beneficiary, "Arg0 := The address of the current beneficiary."}
+    , { 'TIMESTAMP',    16#60,    1,  false,   3, [a],           timestamp, "Arg0 := The current timestamp. Unrelaiable, don't use for anything."}
+    , { 'GENERATION',   16#61,    1,  false,   3, [a],          generation, "Arg0 := The block height of the cureent generation."}
+    , { 'MICROBLOCK',   16#62,    1,  false,   3, [a],          microblock, "Arg0 := The current micro block number."}
+    , { 'DIFFICULTY',   16#63,    1,  false,   3, [a],          difficulty, "Arg0 := The current difficulty."}
+    , { 'GASLIMIT',     16#64,    1,  false,   3, [a],            gaslimit, "Arg0 := The current gaslimit."}
+    , { 'GAS',          16#65,    1,  false,   3, [a],                 gas, "Arg0 := The amount of gas left."}
+
+    , { 'LOG0',         16#66,    2,  false,   3, [a,a],               log, "Create a log message in the call object."}
+    , { 'LOG1',         16#67,    3,  false,   3, [a,a,a],             log, "Create a log message with one topic in the call object."}
+    , { 'LOG2',         16#68,    4,  false,   3, [a,a,a,a],           log, "Create a log message with two topics in the call object."}
+    , { 'LOG3',         16#69,    5,  false,   3, [a,a,a,a,a],         log, "Create a log message with three topics in the call object."}
+    , { 'LOG4',         16#6a,    6,  false,   3, [a,a,a,a,a,a],       log, "Create a log message with four topics in the call object."}
+    , { 'DEACTIVATE',   16#6b,    0,  false,   3, atomic,       deactivate, "Mark the current contract for deactication."}
+      %% Transaction ops
+    , { 'SPEND',               16#6c, 2, false,3, [a,a],                       spend, "Transfer Arg0 tokens to account Arg1. (If the contract account has at least that many tokens."}
+    , { 'ORACLE_REGISTER',     16#6d, 6, false,3, [a,a,a,a,a,a],     oracle_register, "Mark the current contract for deactication."}
+      %% TODO:
+    , { 'ORACLE_QUERY',        16#6e, 0, false,3, atomic,       oracle_query, ""}
+    , { 'ORACLE_RESPOND',      16#6f, 0, false,3, atomic,     oracle_respond, ""}
+    , { 'ORACLE_EXTEND',       16#70, 0, false,3, atomic,      oracle_extend, ""}
+    , { 'ORACLE_GET_ANSWER',   16#71, 0, false,3, atomic,  oracle_get_answer, ""}
+    , { 'ORACLE_GET_QUESTION', 16#72, 0, false,3, atomic,oracle_get_question, ""}
+    , { 'ORACLE_QUERY_FEE',    16#73, 0, false,3, atomic,   oracle_query_fee, ""}
+    , { 'AENS_RESOLVE',        16#74, 0, false,3, atomic,       aens_resolve, ""}
+    , { 'AENS_PRECLAIM',       16#75, 0, false,3, atomic,      aens_preclaim, ""}
+    , { 'AENS_CLAIM',          16#76, 0, false,3, atomic,         aens_claim, ""}
+    , { 'AENS_UPDATE',         16#77, 0, false,3, atomic,        aend_update, ""}
+    , { 'AENS_TRANSFER',       16#78, 0, false,3, atomic,      aens_transfer, ""}
+    , { 'AENS_REVOKE',         16#79, 0, false,3, atomic,        aens_revoke, ""}
+    , { 'ECVERIFY',            16#7a, 0, false,3, atomic,           ecverify, ""}
+    , { 'SHA3',                16#7b, 0, false,3, atomic,               sha3, ""}
+    , { 'SHA256',              16#7c, 0, false,3, atomic,             sha256, ""}
+    , { 'BLAKE2B',             16#7d, 0, false,3, atomic,            blake2b, ""}
+    , { 'BALANCE_OTHER',       16#7e, 2, false,3, [a,a],       balance_other, "Arg0 := The balance of address Arg1."}
+    , { 'SETELEMENT',          16#7f, 4, false,3, [a,a,a,a],      setelement, "Arg0 := a new tuple similar to Arg2, but with element number Arg1 replaced by Arg3."}
+
+
+    , { 'DUMMY7ARG',           16#f9, 7, false,3, [a,a,a,a,a,a,a],  dummyarg, "Temporary dummy instruction to test 7 args."}
+    , { 'DUMMY8ARG',           16#fa, 8, false,3, [a,a,a,a,a,a,a,a],dummyarg, "Temporary dummy instruction to test 8 args."}
+    , { 'ABORT',         16#fb,    1,  false,   3, [a],               abort, "Abort execution (dont use all gas) with error message in Arg0."}
+    , { 'EXIT',          16#fc,    1,  false,   3, [a],                exit, "Abort execution (use upp all gas) with error message in Arg0."}
+    , { 'NOP',          16#fd,    0,  false,   1, atomic,              nop, "The no op. does nothing."}
+    %% FUNCTION         16#fe                                               "Function declaration and entrypoint."
+    %% EXTEND           16#ff                                               "Reserved for future extensions beyond one byte opcodes."
+    ].
+
+
+generate_header_file(Filename, Ops) ->
+    {ok, File} = file:open(Filename, [write]),
+    Defines = lists:flatten([gen_defines(Op) || Op <- Ops]),
+    io:format(File, "~s", [prelude("Provides opcode defines.\n")]),
+    io:format(File, "%% FATE opcodes\n~s", [Defines]),
+    io:format(File, "~s",
+              ["-define('FUNCTION'                , 16#fe).\n"
+               "-define('EXTEND'                  , 16#ff).\n\n"]),
+    file:close(File).
+
+generate_opcodes_ops(Modulename, HrlFile, SrcDir, Ops) ->
+    Filename = SrcDir ++ atom_to_list(Modulename) ++ ".erl",
+
+    {ok, File} = file:open(Filename, [write]),
+    Mnemonic = lists:flatten([gen_mnemonic(Op) || Op <- Ops]),
+    ToOp = lists:flatten([gen_m_to_op(Op) || Op <- Ops]),
+    Args = lists:flatten([gen_args(Op) || Op <- Ops]),
+    EndBB = lists:flatten([gen_bb(Op) || Op <- Ops]),
+
+    io:format(File, "~s", [prelude("Provides opcode primitives.\n")]),
+    io:format(File, "~s", [ops_exports(Modulename, HrlFile,
+                                       ["args/1\n"
+                                        "        , end_bb/1\n"
+                                        "        , mnemonic/1\n"
+                                        "        , m_to_op/1\n"
+                                       ])]),
+
+    io:format(File, "%% FATE mnemonics\n~s", [Mnemonic]),
+    io:format(File, "mnemonic(Op) -> exit({bad_opcode, Op}).\n\n", []),
+
+    io:format(File, "%% FATE opcodes\n~s", [ToOp]),
+    io:format(File, "m_to_op(M) -> exit({bad_mnemonic, M}).\n\n", []),
+
+    io:format(File, "%% FATE numbers of args to op.\n~s", [Args]),
+    io:format(File, "args(Op) -> exit({bad_opcode, Op}).\n\n", []),
+
+    io:format(File, "%% Does FATE Op end a Basic Block?\n~s", [EndBB]),
+    io:format(File, "end_bb(_) -> false.\n\n", []),
+
+    file:close(File).
+
+generate_code_ops(Modulename, SrcDir, Ops) ->
+    Filename = SrcDir ++ atom_to_list(Modulename) ++ ".erl",
+
+    {ok, File} = file:open(Filename, [write]),
+    Types = lists:flatten([gen_type(Op) || Op <- Ops]),
+    TypeExports = lists:flatten([gen_type_exports(Op) || Op <- Ops]),
+    [#{type_name := FirstType} | RestOfOps] = Ops,
+    FateTypes = lists:flatten([gen_fate_code_type(Op) || Op <- RestOfOps]),
+    ConstructorExports = lists:flatten([gen_constructor_exports(Op) || Op <- Ops]),
+    Constructors = lists:flatten([gen_constructors(Op) || Op <- Ops]),
+
+    io:format(File, "~s", [prelude(" Provide constructor functuions for "
+                                   "Fate instructions.\n%%% Provide types"
+                                   " and documentation for Fate "
+                                   "instructions.\n")]),
+    io:format(File, "-module(~w).\n\n", [Modulename]),
+    io:format(File, "-include_lib(\"aebytecode/include/aeb_fate_data.hrl\").\n\n"
+              "-define(i(__X__), {immediate, __X__ }).\n\n"
+              "-type fate_arg_immediate(T) :: {immediate, T}.\n"
+              "-type fate_arg_var()        :: {var, integer()}.\n"
+              "-type fate_arg_arg()        :: {arg, integer()}.\n"
+              "-type fate_arg_stack()      :: {stack, integer()}.\n"
+              "-type fate_arg() :: fate_arg_immediate()\n"
+              "                  | fate_arg_var()\n"
+              "                  | fate_arg_arg()\n"
+              "                  | fate_arg_stack().\n\n"
+              "-type fate_arg_immediate() :: {immediate, aeb_fate_data:fate_type()}.\n"
+             , []),
+    io:format(File, "~s", [Types]),
+    io:format(File, "-type fate_code() :: ~s\n~s                   .\n\n",
+              [FirstType, FateTypes]),
+    io:format(File, "-export_type([ fate_code/0\n~s            ]).\n\n", [TypeExports]),
+    io:format(File, "-export([ foo/0\n~s       ]).\n\n", [ConstructorExports]),
+    io:format(File, "~s\n", [Constructors]),
+
+    io:format(File, "foo() -> \"A temp hack.\".\n", []),
+
+    file:close(File).
+
+gen_type(#{type_name := TypeName, type := Type}) ->
+    lists:flatten(io_lib:format("-type ~-26s :: ~s.\n",
+                                [TypeName, Type])).
+
+gen_fate_code_type(#{type_name := TypeName}) ->
+    lists:flatten(io_lib:format("                   | ~s\n", [TypeName])).
+
+gen_type_exports(#{type_name := TypeName}) ->
+    lists:flatten(io_lib:format("             , ~s/0\n", [TypeName--"()"])).
+
+gen_constructor_exports(#{constructor_type := Function}) ->
+    lists:flatten(io_lib:format("        , ~s\n", [Function])).
+
+gen_constructors(#{constructor := Function, format := atomic,
+                   type_name := Type, opname := Name}) ->
+    lists:flatten(io_lib:format("-spec ~s() -> ~s.\n"
+                                "~s() ->\n"
+                                "    ~w.\n\n",
+                                [Function, Type, Function, Name]));
+gen_constructors(#{constructor := Function, format := ArgSpec,
+                   type_name := Type, opname := Name}) ->
+    ArgTypeSpecs = gen_arg_type_specs(ArgSpec),
+    Args = gen_arg_names(0, ArgSpec),
+    UseArgs = gen_arg_uses(0, ArgSpec),
+    lists:flatten(io_lib:format("-spec ~s(~s) -> ~s.\n"
+                                "~s(~s) ->\n"
+                                "    {~w, ~s}.\n\n",
+                                [Function, ArgTypeSpecs, Type,
+                                 Function, Args, Name, UseArgs])).
+
+gen_arg_type_specs([]) -> [];
+gen_arg_type_specs([a]) -> "fate_arg()";
+gen_arg_type_specs([is]) -> "aeb_fate_data:fate_string()";
+gen_arg_type_specs([ii]) -> "aeb_fate_data:fate_integer()";
+gen_arg_type_specs([li]) -> "[aeb_fate_data:fate_integer()]";
+gen_arg_type_specs([t]) -> "aeb_fate_data:fate_type_type()";
+gen_arg_type_specs([a | Args]) -> "fate_arg(), " ++ gen_arg_type_specs(Args);
+gen_arg_type_specs([is | Args]) -> "aeb_fate_data:fate_string(), " ++ gen_arg_type_specs(Args);
+gen_arg_type_specs([ii | Args]) -> "aeb_fate_data:fate_integer(), " ++ gen_arg_type_specs(Args);
+gen_arg_type_specs([li | Args]) -> "[aeb_fate_data:fate_integer()], " ++ gen_arg_type_specs(Args);
+gen_arg_type_specs([t | Args]) -> "aeb_fate_data:fate_type_type(), " ++ gen_arg_type_specs(Args).
+
+
+gen_arg_names(_, []) ->
+    [];
+gen_arg_names(N, [_]) -> io_lib:format("Arg~w", [N]);
+gen_arg_names(N, [_|Args]) ->
+    io_lib:format("Arg~w, ", [N]) ++ gen_arg_names(N+1, Args).
+
+gen_arg_uses(_, []) ->
+    [];
+gen_arg_uses(N, [a]) -> io_lib:format("Arg~w", [N]);
+gen_arg_uses(N, [is]) -> io_lib:format("{immediate, Arg~w}", [N]);
+gen_arg_uses(N, [ii]) -> io_lib:format("{immediate, Arg~w}", [N]);
+gen_arg_uses(N, [li]) -> io_lib:format("[{immediate, I} || I <- Arg~w]", [N]);
+gen_arg_uses(N, [t]) -> io_lib:format("Arg~w", [N]);
+gen_arg_uses(N, [a | Args]) ->
+    io_lib:format("Arg~w, ", [N]) ++ gen_arg_uses(N+1, Args);
+gen_arg_uses(N, [is | Args]) ->
+    io_lib:format("{immediate, Arg~w}, ", [N]) ++ gen_arg_uses(N+1, Args);
+gen_arg_uses(N, [ii | Args]) ->
+    io_lib:format("{immediate, Arg~w}, ", [N]) ++ gen_arg_uses(N+1, Args);
+gen_arg_uses(N, [li | Args]) ->
+    io_lib:format("[{immediate, I} || I <- Arg~w], ", [N]) ++ gen_arg_uses(N+1, Args);
+gen_arg_uses(N, [t | Args]) ->
+    io_lib:format("Arg~w, ", [N]) ++ gen_arg_uses(N+1, Args).
+
+
+ops_exports(Module, HrlFile, Exports) ->
+    lists:flatten(io_lib:format(
+                    "-module(~w).\n\n"
+                    "-export([ ~s         ]).\n\n"
+                    "-include_lib(\"aebytecode/" ++ HrlFile ++"\").\n\n"
+                    "%%====================================================================\n"
+                    "%% API\n"
+                    "%%====================================================================\n",
+                    [Module, Exports])).
+
+gen_mnemonic(#{opname := Name, macro := Macro}) ->
+    lists:flatten(io_lib:format("mnemonic(~21s) -> ~21w ;\n",
+                                [Macro, Name])).
+
+
+gen_m_to_op(#{opname := Name, macro := Macro}) ->
+    lists:flatten(io_lib:format("m_to_op(~21w) -> ~21s ;\n",
+                                [Name, Macro])).
+
+gen_args(#{macro := Macro, args := Args}) ->
+    lists:flatten(io_lib:format("args(~21s) -> ~2w ;\n",
+                                [Macro, Args])).
+
+gen_bb(#{macro := Macro, end_bb := EndBB}) ->
+    lists:flatten(io_lib:format("end_bb(~21s) -> ~w ;\n",
+                                [Macro, EndBB])).
+
+
+prelude(Doc) ->
+    "%%%-------------------------------------------------------------------\n"
+        "%%% @copyright (C) 2019, Aeternity Anstalt\n"
+        "%%%\n"
+        "%%%   === ===  N O T E :   This file is generated do not edit. === ===\n"
+        "%%%\n"
+        "%%% Source is in aeb_fate_generate_ops.erl\n"
+        "%%% @doc\n"
+        "%%%     "++Doc++
+        "%%% @end\n"
+        "%%%-------------------------------------------------------------------\n\n".
+
+
+gen_defines(#{opname := Name, opcode := OpCode}) ->
+    lists:flatten(io_lib:format("-define(~-26w, 16#~2.16.0b).\n", [Name, OpCode])).
+
+gen([]) ->
+    [];
+gen([{OpName, OpCode, Args, EndBB, Gas, FateFormat, Constructor, Doc} | Rest]) ->
+    Name = atom_to_list(OpName),
+    LowerName = string:to_lower(Name),
+    TypeName = "fate_" ++ LowerName ++ "()",
+    Macro = "?" ++ Name,
+    Type = case FateFormat of
+               atomic -> io_lib:format("~w", [OpName]);
+               ArgTypes  ->
+                    io_lib:format("{~w, ~s}", [OpName, expand_types(ArgTypes)])
+           end,
+    ConstructorType = atom_to_list(Constructor) ++ "/" ++ io_lib:format("~w", [Args]),
+
+    [#{ opname            => OpName
+      , opcode            => OpCode
+      , args              => Args
+      , end_bb            => EndBB
+      , format            => FateFormat
+      , macro             => Macro
+      , type_name         => TypeName
+      , doc               => Doc
+      , gas               => Gas
+      , type              => Type
+      , constructor       => Constructor
+      , constructor_type  => ConstructorType
+      }| gen(Rest)].
+
+
+expand_types([]) -> "";
+expand_types([T]) -> expand_type(T);
+expand_types([T|Ts]) ->expand_type(T) ++ ", " ++ expand_types(Ts).
+
+expand_type(a)  -> "fate_arg()";
+expand_type(is) -> "fate_arg_immediate(aeb_fate_data:fate_string())";
+expand_type(ii) -> "fate_arg_immediate(aeb_fate_data:fate_integer())";
+expand_type(li) -> "[fate_arg_immediate(aeb_fate_data:fate_integer())]";
+expand_type(t)  -> "aeb_fate_data:fate_type_type()".
+
+generate_scanner(TemplateFile, Outfile, Path, Ops) ->
+    {ok, Template} = file:read_file(filename:join(Path,TemplateFile)),
+    Tokens = lists:flatten([gen_token(Op) || Op <- Ops]),
+    NewFile = insert_tokens_in_template(Template, Tokens),
+    file:write_file(filename:join(Path, Outfile), NewFile).
+
+gen_token(#{opname := OpName}) ->
+    Name = atom_to_list(OpName),
+    io_lib:format("~-28s: {token, {mnemonic, TokenLine, ~w}}.\n",
+                  [Name, OpName]).
+
+insert_tokens_in_template(<<"%% ###REPLACEWITHOPTOKENS###", Rest/binary >>, Tokens) ->
+    [Tokens, Rest];
+insert_tokens_in_template(<<"%%% ###REPLACEWITHNOTE###", Rest/binary >>, Tokens) ->
+    [
+     "%%%\n"
+     "%%%   === ===  N O T E :   This file is generated do not edit. === ===\n"
+     "%%%\n"
+     "%%% Source is in aeb_fate_generate_ops.erl\n"
+     "%%%          and aeb_fate_asm_scan.template"
+     | insert_tokens_in_template(Rest, Tokens)];
+insert_tokens_in_template(<<B,Rest/binary>>, Tokens) ->
+    [B|insert_tokens_in_template(Rest, Tokens)].
+
+gen_asm_pp(Module, Path, Ops) ->
+    Filename = filename:join(Path, atom_to_list(Module)) ++ ".erl",
+    {ok, File} = file:open(Filename, [write]),
+    Formats = lists:flatten([gen_format(Op)++"\n" || Op <- Ops]),
+
+    io:format(File, "~s", [prelude(" Provide pretty printing functuions for "
+                                   "Fate instructions.\n")]),
+    io:format(File, "-module(~w).\n\n", [Module]),
+    io:format(File,
+              "-export([format_op/2]).\n\n"
+              "format_arg(li, {immediate, LI}) ->\n"
+              "    aeb_fate_data:format(LI);\n"
+              "format_arg(_, {immediate, I}) ->\n"
+              "    aeb_fate_data:format(I);\n"
+              "format_arg(a, {arg, N}) -> io_lib:format(\"arg~~p\", [N]);\n"
+              "format_arg(a, {var, N}) -> io_lib:format(\"var~~p\", [N]);\n"
+              "format_arg(a, {stack, 0}) -> \"a\";\n"
+              "format_arg(a, {stack, N}) -> io_lib:format(\"a~~p\", [N]).\n\n"
+              "lookup(Name, Symbols) ->\n"
+              "    maps:get(Name, Symbols, io_lib:format(\"~~w\",[Name])).\n\n"
+              "~s"
+             , [Formats]),
+
+    io:format(File, "format_op(Op, _Symbols) -> io_lib:format(\";; Bad Op: ~~w\\n\", [Op]).\n", []),
+    file:close(File).
+
+gen_format(#{opname := Name}) when ('CALL' =:= Name) or (Name =:= 'CALL_T') ->
+    io_lib:format("format_op({~w, {immediate, Function}}, Symbols) ->\n"
+                  "[\"~s \", lookup(Function, Symbols)];",
+                  [Name, atom_to_list(Name)]);
+gen_format(#{opname := Name}) when (Name =:= 'CALL_R') or (Name =:= 'CALL_TR') ->
+    io_lib:format("format_op({~w, {immediate, Contract}, {immediate, Function}}, Symbols) ->\n"
+                  "[\"~s \", lookup(Contract, Symbols), \".\", lookup(Function, Symbols)];\n"
+                  "format_op({~w, Contract, {immediate, Function}}, Symbols) ->\n"
+                  "[\"~s \", format_arg(a, Contract), \".\", lookup(Function, Symbols)];",
+                  [Name, atom_to_list(Name), Name, atom_to_list(Name)]);
+gen_format(#{opname := Name, format := atomic}) ->
+    io_lib:format("format_op(~w, _) -> [\"~s\"];", [Name, atom_to_list(Name)]);
+gen_format(#{opname := Name, format := Args}) ->
+    NameAsString = atom_to_list(Name),
+    case Args of
+        [T0] ->
+            io_lib:format(
+              "format_op({~w, Arg0}, _) ->\n"
+              "    [\"~s \", format_arg(~w, Arg0)];",
+              [Name, NameAsString, T0]);
+        [T0, T1] ->
+            io_lib:format(
+              "format_op({~w, Arg0, Arg1}, _) ->\n"
+              "    [\"~s \", format_arg(~w, Arg0), "
+              "\" \",  format_arg(~w, Arg1)];",
+              [Name, NameAsString, T0, T1]);
+        [T0, T1, T2] ->
+            io_lib:format(
+              "format_op({~w, Arg0, Arg1, Arg2}, _) ->\n"
+              "    [\"~s \", format_arg(~w, Arg0), "
+              "\" \",  format_arg(~w, Arg1),"
+              "\" \",  format_arg(~w, Arg2)];",
+              [Name, NameAsString, T0, T1, T2]);
+        [T0, T1, T2, T3] ->
+            io_lib:format(
+              "format_op({~w, Arg0, Arg1, Arg2, Arg3}, _) ->\n"
+              "    [\"~s \", format_arg(~w, Arg0), "
+              "\" \",  format_arg(~w, Arg1),"
+              "\" \",  format_arg(~w, Arg2),"
+              "\" \",  format_arg(~w, Arg3)];",
+              [Name, NameAsString, T0, T1, T2, T3]);
+        [T0, T1, T2, T3, T4] ->
+            io_lib:format(
+              "format_op({~w, Arg0, Arg1, Arg2, Arg3, Arg4}, _) ->\n"
+              "    [\"~s \", format_arg(~w, Arg0), "
+              "\" \",  format_arg(~w, Arg1),"
+              "\" \",  format_arg(~w, Arg2),"
+              "\" \",  format_arg(~w, Arg3),"
+              "\" \",  format_arg(~w, Arg4)];",
+              [Name, NameAsString, T0, T1, T2, T3, T4]);
+        [T0, T1, T2, T3, T4, T5] ->
+            io_lib:format(
+              "format_op({~w, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5}, _) ->\n"
+              "    [\"~s \", format_arg(~w, Arg0), "
+              "\" \",  format_arg(~w, Arg1),"
+              "\" \",  format_arg(~w, Arg2),"
+              "\" \",  format_arg(~w, Arg3),"
+              "\" \",  format_arg(~w, Arg4),"
+              "\" \",  format_arg(~w, Arg5)];",
+              [Name, NameAsString, T0, T1, T2, T3, T4, T5]);
+        [T0, T1, T2, T3, T4, T5, T6] ->
+            io_lib:format(
+              "format_op({~w, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6}, _) ->\n"
+              "    [\"~s \", format_arg(~w, Arg0), "
+              "\" \",  format_arg(~w, Arg1),"
+              "\" \",  format_arg(~w, Arg2),"
+              "\" \",  format_arg(~w, Arg3),"
+              "\" \",  format_arg(~w, Arg4),"
+              "\" \",  format_arg(~w, Arg5),"
+              "\" \",  format_arg(~w, Arg6)];",
+              [Name, NameAsString, T0, T1, T2, T3, T4, T5, T6]);
+        [T0, T1, T2, T3, T4, T5, T6, T7] ->
+            io_lib:format(
+              "format_op({~w, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7}, _) ->\n"
+              "    [\"~s \", format_arg(~w, Arg0), "
+              "\" \",  format_arg(~w, Arg1),"
+              "\" \",  format_arg(~w, Arg2),"
+              "\" \",  format_arg(~w, Arg3),"
+              "\" \",  format_arg(~w, Arg4),"
+              "\" \",  format_arg(~w, Arg5),"
+              "\" \",  format_arg(~w, Arg6),"
+              "\" \",  format_arg(~w, Arg7)];",
+              [Name, NameAsString, T0, T1, T2, T3, T4, T5, T6, T7])
+    end.
+
+test_asm_generator(Filename) ->
+    {ok, File} = file:open(Filename, [write]),
+    Instructions = lists:flatten([gen_instruction(Op)++"\n" || Op <- get_ops()]),
+    io:format(File,
+              ";; CONTRACT all_instructions\n\n"
+              ";; Dont expect this contract to typecheck or run.\n"
+              ";; Just used to check assembler rountrip of all instruction.\n\n"
+              "FUNCTION foo () : {tuple, []}\n"
+              "~s"
+             , [Instructions]),
+    io:format(File, "  RETURNR ()\n", []),
+    file:close(File).
+
+
+gen_instruction(#{opname := Name, format := atomic}) ->
+    io_lib:format("  ~s\n", [Name]);
+gen_instruction(#{opname := Name, format := ArgTypes}) ->
+    Args = lists:flatten(lists:join(" ", [gen_arg(A) || A <- ArgTypes])),
+    I = io_lib:format("  ~s ~s\n", [Name, Args]),
+    I.
+
+%% This should be done with a Quick Check generator...
+gen_arg(a) -> any_arg();
+gen_arg(is) -> "foo";
+gen_arg(ii) -> gen_int();
+gen_arg(li) -> "[1, 2, 3]";
+gen_arg(t) -> "integer".
+
+any_arg() ->
+    element(rand:uniform(5), {"a", stack_arg(), var_arg(), arg_arg(), imm_arg()}).
+stack_arg() -> "a" ++ integer_to_list(rand:uniform(255)-1).
+arg_arg() ->  "arg" ++ integer_to_list(rand:uniform(256)-1).
+var_arg() ->  "var" ++ integer_to_list(rand:uniform(256)-1).
+imm_arg() ->
+    case rand:uniform(15) of
+        1 -> gen_int();
+        2 -> gen_int();
+        3 -> gen_int();
+        4 -> gen_int();
+        5 -> gen_int();
+        6 -> gen_int();
+        7 -> gen_int();
+        8 -> gen_address();
+        9 -> gen_boolean();
+        10 -> gen_string();
+        11 -> gen_map();
+        12 -> gen_list();
+        13 -> gen_bits();
+        14 -> gen_tuple();
+        15 -> gen_variant()
+    end.
+
+gen_key() ->
+    case rand:uniform(15) of
+        1 -> gen_int();
+        2 -> gen_int();
+        3 -> gen_int();
+        4 -> gen_int();
+        5 -> gen_int();
+        6 -> gen_int();
+        7 -> gen_int();
+        8 -> gen_address();
+        9 -> gen_boolean();
+        10 -> gen_string();
+        11 -> gen_string();
+        12 -> gen_list();
+        13 -> gen_bits();
+        14 -> gen_tuple();
+        15 -> gen_variant()
+    end.
+
+gen_boolean() ->
+    element(rand:uniform(2), {"true", "false"}).
+
+gen_int() ->
+    element(rand:uniform(4),
+            { integer_to_list(rand:uniform(round(math:pow(10,40))))
+            , integer_to_list(rand:uniform(10))
+            , integer_to_list(rand:uniform(100))
+            , io_lib:format("0x~.16b",[rand:uniform(round(math:pow(10,10)))])}).
+
+gen_address() -> "#nv5B93FPzRHrGNmMdTDfGdd5xGZvep3MVSpJqzcQmMp59bBCv".
+gen_string() -> "\"foo\"".
+gen_map() -> "{ " ++ gen_key() ++ " => " ++ imm_arg() ++ "}".
+gen_list() ->
+    case rand:uniform(4) of
+        1 -> "[]";
+        2 -> "[" ++ lists:join(", ", gen_list_elements()) ++ " ]";
+        3 -> "[ " ++ imm_arg() ++ " ]";
+        4 -> "[ " ++ imm_arg() ++ ", " ++ imm_arg() ++ " ]"
+    end.
+
+%% Not type correct.
+gen_list_elements() ->
+    case rand:uniform(3) of
+        1 -> [imm_arg() |  gen_list_elements()];
+        2 -> [];
+        3 -> [imm_arg()]
+    end.
+
+gen_bits() ->
+    element(rand:uniform(3),
+            {"<>"
+            ,"!<>"
+            , "101010"}).
+
+gen_tuple() ->
+    case rand:uniform(3) of
+        1 -> "()";
+        2 -> "(42)";
+        3 -> "(" ++ imm_arg() ++ ")"
+    end.
+
+gen_variant() ->
+    case rand:uniform(3) of
+        1 -> "(| 5 | 2 | (1, \"foo\", ()) |)";
+        2 -> "(| 2 | 1 | ( " ++ imm_arg() ++ " ) |)";
+        3 -> "(| 2 | 0 | ( " ++ imm_arg() ++ ", " ++ imm_arg() ++ " ) |)"
+    end.
+
+
+%% TODO: add gas cost.
+generate_documentation(Filename) ->
+    {ok, File} = file:open(Filename, [write]),
+    Instructions = lists:flatten([gen_doc(Op)++"\n" || Op <- get_ops()]),
+    io:format(File,
+              "### Operations\n\n"
+              "| OpCode | Name | Args | Description |\n"
+              "| ---    | ---  | ---  |        ---  |\n"
+              "~s"
+             , [Instructions]),
+    io:format(File, "\n", []),
+    file:close(File).
+
+gen_doc(#{ opname            := Name
+         , opcode            := OpCode
+         , args              := _Args
+         , end_bb            := _EndBB
+         , format            := FateFormat
+         , macro             := _Macro
+         , type_name         := _TypeName
+         , doc               := Doc
+         , gas               := _Gas
+         , type              := _Type
+         , constructor       := _Constructor
+         , constructor_type  := _ConstructorType
+         }) ->
+    Arguments =
+        case FateFormat of
+            atomic -> "";
+            _ ->  lists:join(" ",
+                             [format_arg_doc(A) ||
+                                 A <-
+                                     lists:zip(FateFormat,
+                                               lists:seq(0,length(FateFormat)-1))])
+        end,
+    io_lib:format("| 0x~.16b | ~w | ~s | ~s |\n",
+                  [ OpCode
+                  , Name
+                  , Arguments
+                  , Doc]).
+
+format_arg_doc({a, N}) -> io_lib:format("Arg~w", [N]);
+format_arg_doc({is,_N}) -> "Identifier";
+format_arg_doc({ii,_N}) -> "Integer";
+format_arg_doc({li,_N}) -> "[Integers]";
+format_arg_doc({t,_N}) -> "Type".
+

src/aeb_heap.erl

@@ -0,0 +1,301 @@
+-module(aeb_heap).
+
+-export([ to_binary/1
+        , to_binary/2
+        , from_heap/3
+        , from_binary/2
+        , from_binary/3
+        , maps_with_next_id/1
+        , set_next_id/2
+        , heap_fragment/3
+        , heap_value/3
+        , heap_value/4
+        , heap_value_pointer/1
+        , heap_value_maps/1
+        , heap_value_offset/1
+        , heap_value_heap/1
+        , heap_fragment_maps/1
+        , heap_fragment_offset/1
+        , heap_fragment_heap/1
+        ]).
+
+-export_type([binary_value/0, heap_value/0, offset/0, heap_fragment/0]).
+
+-include_lib("aebytecode/include/aeb_typerep_def.hrl").
+-include_lib("aebytecode/include/aeb_heap.hrl").
+
+-type word()            :: non_neg_integer().
+-type pointer()         :: word().
+-opaque heap_fragment() :: #heap{}.
+-type offset()          :: non_neg_integer().
+-type binary_value()    :: binary().
+-type heap_value()      :: {pointer(), heap_fragment()}.
+
+
+-spec maps_with_next_id(heap_fragment()) -> #maps{}.
+%% Create just a maps value, don't keep rest of Heap
+maps_with_next_id(#heap{maps = #maps{next_id = N}}) ->
+    #maps{ next_id = N }.
+
+-spec set_next_id(heap_fragment(), non_neg_integer()) -> heap_fragment().
+set_next_id(Heap, N) ->
+    Heap#heap{ maps = Heap#heap.maps#maps{ next_id = N } }.
+
+%% -- data type heap_fragment
+
+-spec heap_fragment(binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_fragment().
+heap_fragment(Heap) ->
+    heap_fragment(#maps{ next_id = 0 }, 0, Heap).
+
+-spec heap_fragment(#maps{}, offset(),
+                    binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_fragment().
+heap_fragment(Maps, Offset, Heap) ->
+    #heap{maps = Maps, offset = Offset, heap = Heap}.
+
+-spec heap_fragment_maps(heap_fragment()) -> #maps{}.
+heap_fragment_maps(#heap{maps = Maps}) ->
+    Maps.
+
+-spec heap_fragment_offset(heap_fragment()) -> offset().
+heap_fragment_offset(#heap{offset = Offs}) ->
+    Offs.
+
+-spec heap_fragment_heap(heap_fragment()) -> binary() | #{non_neg_integer() => non_neg_integer()}.
+heap_fragment_heap(#heap{heap = Heap}) ->
+    Heap.
+
+
+%% -- data type heap_value
+
+-spec heap_value(#maps{}, pointer(),
+                 binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_value().
+heap_value(Maps, Ptr, Heap) ->
+    heap_value(Maps, Ptr, Heap, 0).
+
+-spec heap_value(#maps{}, pointer(),
+                 binary() | #{non_neg_integer() => non_neg_integer()}, offset()) -> heap_value().
+heap_value(Maps, Ptr, Heap, Offs) ->
+    {Ptr, heap_fragment(Maps, Offs, Heap)}.
+
+-spec heap_value_pointer(heap_value()) -> pointer().
+heap_value_pointer({Ptr, _}) -> Ptr.
+
+-spec heap_value_maps(heap_value()) -> #maps{}.
+heap_value_maps({_, Heap}) -> Heap#heap.maps.
+
+-spec heap_value_offset(heap_value()) -> offset().
+heap_value_offset({_, Heap}) -> Heap#heap.offset.
+
+-spec heap_value_heap(heap_value()) ->
+                             binary() | #{non_neg_integer() => non_neg_integer()}.
+heap_value_heap({_, Heap}) -> Heap#heap.heap.
+
+%% -- Value to binary --------------------------------------------------------
+
+-spec to_binary(aeb_aevm_data:data()) -> aeb_aevm_data:heap().
+%% Encode the data as a heap where the first word is the value (for unboxed
+%% types) or a pointer to the value (for boxed types).
+to_binary(Data) ->
+    to_binary(Data, 0).
+
+to_binary(Data, BaseAddress) ->
+    {Address, Memory} = to_binary1(Data, BaseAddress + 32),
+    R = <<Address:256, Memory/binary>>,
+    R.
+
+
+%% Allocate the data in memory, from the given address.  Return a pair
+%% of memory contents from that address and the value representing the
+%% data.
+to_binary1(Data,_Address) when is_integer(Data) ->
+    {Data,<<>>};
+to_binary1(Data, Address) when is_binary(Data) ->
+    %% a string
+    Words = aeb_memory:binary_to_words(Data),
+    {Address,<<(size(Data)):256, << <<W:256>> || W <- Words>>/binary>>};
+to_binary1(none, Address)            -> to_binary1({variant, 0, []}, Address);
+to_binary1({some, Value}, Address)   -> to_binary1({variant, 1, [Value]}, Address);
+to_binary1(word, Address)            -> to_binary1({?TYPEREP_WORD_TAG}, Address);
+to_binary1(string, Address)          -> to_binary1({?TYPEREP_STRING_TAG}, Address);
+to_binary1(typerep, Address)         -> to_binary1({?TYPEREP_TYPEREP_TAG}, Address);
+to_binary1(function, Address)        -> to_binary1({?TYPEREP_FUN_TAG}, Address);
+to_binary1({list, T}, Address)       -> to_binary1({?TYPEREP_LIST_TAG, T}, Address);
+to_binary1({option, T}, Address)     -> to_binary1({variant, [[], [T]]}, Address);
+to_binary1({tuple, Ts}, Address)     -> to_binary1({?TYPEREP_TUPLE_TAG, Ts}, Address);
+to_binary1({variant, Cons}, Address) -> to_binary1({?TYPEREP_VARIANT_TAG, Cons}, Address);
+to_binary1({map, K, V}, Address)     -> to_binary1({?TYPEREP_MAP_TAG, K, V}, Address);
+to_binary1({variant, Tag, Args}, Address) ->
+    to_binary1(list_to_tuple([Tag | Args]), Address);
+to_binary1(Map, Address) when is_map(Map) ->
+    Size = maps:size(Map),
+    %% Sort according to binary ordering
+    KVs = lists:sort([ {to_binary(K), to_binary(V)} || {K, V} <- maps:to_list(Map) ]),
+    {Address, <<Size:256, << <<(byte_size(K)):256, K/binary,
+                               (byte_size(V)):256, V/binary>> || {K, V} <- KVs >>/binary >>};
+to_binary1({}, _Address) ->
+    {0, <<>>};
+to_binary1(Data, Address) when is_tuple(Data) ->
+    {Elems,Memory} = to_binaries(tuple_to_list(Data),Address+32*size(Data)),
+    ElemsBin = << <<W:256>> || W <- Elems>>,
+    {Address,<< ElemsBin/binary, Memory/binary >>};
+to_binary1([],_Address) ->
+    <<Nil:256>> = <<(-1):256>>,
+    {Nil,<<>>};
+to_binary1([H|T],Address) ->
+    to_binary1({H,T},Address).
+
+
+to_binaries([],_Address) ->
+    {[],<<>>};
+to_binaries([H|T],Address) ->
+    {HRep,HMem} = to_binary1(H,Address),
+    {TRep,TMem} = to_binaries(T,Address+size(HMem)),
+    {[HRep|TRep],<<HMem/binary, TMem/binary>>}.
+
+%% Interpret a return value (a binary) using a type rep.
+
+-spec from_heap(Type :: ?Type(), Heap :: binary(), Ptr :: integer()) ->
+        {ok, term()} | {error, term()}.
+from_heap(Type, Heap, Ptr) ->
+    try {ok, from_binary(#{}, Type, Heap, Ptr)}
+    catch _:Err ->
+        %% io:format("** Error: from_heap failed with ~p\n  ~p\n", [Err, erlang:get_stacktrace()]),
+        {error, Err}
+    end.
+
+%% Base address is the address of the first word of the given heap.
+-spec from_binary(T :: ?Type(),
+                  Heap :: binary(),
+                  BaseAddr :: non_neg_integer()) ->
+        {ok, term()} | {error, term()}.
+from_binary(T, Heap = <<V:256, _/binary>>, BaseAddr) ->
+    from_heap(T, <<0:BaseAddr/unit:8, Heap/binary>>, V);
+from_binary(_, Bin, _BaseAddr) ->
+    {error, {binary_too_short, Bin}}.
+
+-spec from_binary(?Type(), binary()) -> {ok, term()} | {error, term()}.
+from_binary(T, Heap) ->
+    from_binary(T, Heap, 0).
+
+from_binary(_, word, _, V) ->
+    V;
+from_binary(_, signed_word, _, V) ->
+    <<N:256/signed>> = <<V:256>>,
+    N;
+from_binary(_, bool, _, V) ->
+    case V of
+        0 -> false;
+        1 -> true
+    end;
+from_binary(_, string, Heap, V) ->
+    StringSize = heap_word(Heap,V),
+    BitAddr = 8*(V+32),
+    <<_:BitAddr,Bytes:StringSize/binary,_/binary>> = Heap,
+    Bytes;
+from_binary(_, {tuple, []}, _, _) ->
+    {};
+from_binary(Visited, {tuple,Cpts}, Heap, V) ->
+    check_circular_refs(Visited, V),
+    NewVisited = Visited#{V => true},
+    ElementNums = lists:seq(0, length(Cpts)-1),
+    TypesAndPointers = lists:zip(Cpts, ElementNums),
+    ElementAddress = fun(Index) -> V + 32 * Index end,
+    Element = fun(Index) ->
+                      heap_word(Heap, ElementAddress(Index))
+              end,
+    Convert = fun(Type, Index) ->
+                from_binary(NewVisited, Type, Heap, Element(Index))
+              end,
+    Elements = [Convert(T, I) || {T,I} <- TypesAndPointers],
+    list_to_tuple(Elements);
+from_binary(Visited, {list, Elem}, Heap, V) ->
+    <<Nil:256>> = <<(-1):256>>,
+    if V==Nil ->
+          [];
+       true ->
+          {H,T} = from_binary(Visited, {tuple,[Elem,{list,Elem}]},Heap,V),
+          [H|T]
+    end;
+from_binary(Visited, {option, A}, Heap, V) ->
+    from_binary(Visited, {variant_t, [{none, []}, {some, [A]}]}, Heap, V);
+from_binary(Visited, {variant, Cons}, Heap, V) ->
+    Tag      = heap_word(Heap, V),
+    Args     = lists:nth(Tag + 1, Cons),
+    Visited1 = Visited#{V => true},
+    {variant, Tag, tuple_to_list(from_binary(Visited1, {tuple, Args}, Heap, V + 32))};
+from_binary(Visited, {variant_t, TCons}, Heap, V) ->   %% Tagged variants
+    {Tags, Cons} = lists:unzip(TCons),
+    {variant, I, Args} = from_binary(Visited, {variant, Cons}, Heap, V),
+    Tag = lists:nth(I + 1, Tags),
+    case Args of
+        []  -> Tag;
+        _   -> list_to_tuple([Tag | Args])
+    end;
+from_binary(_Visited, {map, A, B}, Heap, Ptr) ->
+    %% FORMAT: [Size] [KeySize] Key [ValSize] Val .. [KeySize] Key [ValSize] Val
+    Size = heap_word(Heap, Ptr),
+    map_binary_to_value(A, B, Size, Heap, Ptr + 32);
+from_binary(Visited, typerep, Heap, V) ->
+    check_circular_refs(Visited, V),
+    Tag = heap_word(Heap, V),
+    Arg1 = fun(T, I) -> from_binary(Visited#{V => true}, T, Heap, heap_word(Heap, V + 32 * I)) end,
+    Arg  = fun(T) -> Arg1(T, 1) end,
+    case Tag of
+        ?TYPEREP_WORD_TAG    -> word;
+        ?TYPEREP_STRING_TAG  -> string;
+        ?TYPEREP_TYPEREP_TAG -> typerep;
+        ?TYPEREP_LIST_TAG    -> {list,    Arg(typerep)};
+        ?TYPEREP_TUPLE_TAG   -> {tuple,   Arg({list, typerep})};
+        ?TYPEREP_VARIANT_TAG -> {variant, Arg({list, {list, typerep}})};
+        ?TYPEREP_MAP_TAG     -> {map,     Arg(typerep), Arg1(typerep, 2)};
+        ?TYPEREP_FUN_TAG     -> function
+    end.
+
+map_binary_to_value(KeyType, ValType, N, Bin, Ptr) ->
+    %% Avoid looping on bogus sizes
+    MaxN = byte_size(Bin) div 64,
+    Heap = heap_fragment(Bin),
+    map_from_binary({value, KeyType, ValType}, min(N, MaxN), Heap, Ptr, #{}).
+
+map_from_binary(_, 0, _, _, Map) -> Map;
+map_from_binary({value, KeyType, ValType} = Output, I, Heap, Ptr, Map) ->
+    KeySize = get_word(Heap, Ptr),
+    KeyPtr  = Ptr + 32,
+    KeyBin  = get_chunk(Heap, KeyPtr, KeySize),
+    ValSize = get_word(Heap, KeyPtr + KeySize),
+    ValPtr  = KeyPtr + KeySize + 32,
+    ValBin  = get_chunk(Heap, ValPtr, ValSize),
+    %% Keys and values are self contained binaries
+    {ok, Key} = from_binary(KeyType, KeyBin),
+    {ok, Val} = from_binary(ValType, ValBin),
+    map_from_binary(Output, I - 1, Heap, ValPtr + ValSize,  Map#{Key => Val}).
+
+check_circular_refs(Visited, V) ->
+    case maps:is_key(V, Visited) of
+        true ->  exit(circular_references);
+        false -> ok
+    end.
+
+heap_word(Heap, Addr) when is_binary(Heap) ->
+    BitSize = 8*Addr,
+    <<_:BitSize,W:256,_/binary>> = Heap,
+    W;
+heap_word(Heap, Addr) when is_map(Heap) ->
+    0 = Addr rem 32, %% Check that it's word aligned.
+    maps:get(Addr, Heap, 0).
+
+get_word(#heap{offset = Offs, heap = Mem}, Addr) when Addr >= Offs ->
+    get_word(Mem, Addr - Offs);
+get_word(Mem, Addr) when is_binary(Mem) ->
+    <<_:Addr/unit:8, Word:256, _/binary>> = Mem,
+    Word.
+
+get_chunk(#heap{offset = Offs, heap = Mem}, Addr, Bytes) when Addr >= Offs ->
+    get_chunk(Mem, Addr - Offs, Bytes);
+get_chunk(Mem, Addr, Bytes) when is_binary(Mem) ->
+    <<_:Addr/unit:8, Chunk:Bytes/binary, _/binary>> = Mem,
+    Chunk.
+
+
+
+

src/aeb_memory.erl

@@ -0,0 +1,19 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2018, Aeternity Anstalt
+%%% @doc
+%%%      Memory speifics that compiler and VM need to agree upon
+%%% @end
+%%% Created : 19 Dec 2018
+%%%-------------------------------------------------------------------
+
+-module(aeb_memory).
+
+-export([binary_to_words/1]).
+
+binary_to_words(<<>>) ->
+    [];
+binary_to_words(<<N:256,Bin/binary>>) ->
+    [N|binary_to_words(Bin)];
+binary_to_words(Bin) ->
+    binary_to_words(<<Bin/binary,0>>).
+

src/aebytecode.app.src

@@ -1,10 +1,13 @@
 {application, aebytecode,
- [{description, "Bytecode definitions for AEthernity VM shared with compiler."},
-  {vsn, "1.0.0"},
+ [{description, "Bytecode definitions, serialization and deserialization for aeternity."},
+  {vsn, "2.1.0"},
   {registered, []},
   {applications,
    [kernel,
-    stdlib
+    stdlib,
+    eblake2,
+    aeserialization,
+    getopt
    ]},
   {env,[]},
   {modules, []},

src/aefateasm.erl

@@ -0,0 +1,57 @@
+-module(aefateasm).
+
+-export([main/1]).
+
+-define(OPT_SPEC,
+    [ {src_file, undefined, undefined, string, "Fate assembler code file"}
+    , {verbose, $v, "verbose", undefined, "Verbose output"}
+    , {help, $h, "help", undefined, "Show this message"}
+    , {outfile, $o, "out", string, "Output file (experimental)"} ]).
+
+usage() ->
+    getopt:usage(?OPT_SPEC, "aefateasm").
+
+main(Args) ->
+    case getopt:parse(?OPT_SPEC, Args) of
+        {ok, {Opts, []}} ->
+            case proplists:get_value(help, Opts, false) of
+                false ->
+                    assemble(Opts);
+                true ->
+                    usage()
+            end;
+
+        {ok, {_, NonOpts}} ->
+            io:format("Can't understand ~p\n\n", [NonOpts]),
+            usage();
+
+        {error, {Reason, Data}} ->
+            io:format("Error: ~s ~p\n\n", [Reason, Data]),
+            usage()
+    end.
+
+assemble(Opts) ->
+    case proplists:get_value(src_file, Opts, undefined) of
+        undefined ->
+            io:format("Error: no input source file\n\n"),
+            usage();
+        File ->
+            assemble(File, Opts)
+    end.
+
+assemble(File, Opts) ->
+    Verbose = proplists:get_value(verbose, Opts, false),
+    case proplists:get_value(outfile, Opts, undefined) of
+        undefined ->
+            Asm = aeb_fate_asm:read_file(File),
+            {Env, BC} = aeb_fate_asm:asm_to_bytecode(Asm, Opts),
+            case Verbose of
+                true ->
+                    io:format("Env: ~0p~n", [Env]);
+                false -> ok
+            end,
+            io:format("Code: ~0p~n", [BC]);
+        OutFile ->
+            aeb_fate_asm:assemble_file(File, OutFile, Opts)
+    end.
+

test/aeb_data_test.erl

@@ -0,0 +1,12 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2018, Aeternity Anstalt
+%%% @doc Basic tests for Fate data
+%%% @end
+%%%-------------------------------------------------------------------
+
+-module(aeb_data_test).
+
+-include_lib("eunit/include/eunit.hrl").
+
+format_integer_test() ->
+    "0" = aeb_fate_data:format(0).

test/aeb_fate_asm_test.erl

@@ -0,0 +1,69 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2018, Aeternity Anstalt
+%%% @doc Basic tests for Fate serialization
+%%%
+%%% To run:
+%%%  TEST=aeb_fate_asm_test rebar3 eunit
+%%%
+%%% @end
+%%%-------------------------------------------------------------------
+
+-module(aeb_fate_asm_test).
+
+-include_lib("eunit/include/eunit.hrl").
+
+asm_path() ->
+    filename:join(code:lib_dir(aebytecode, test), "asm_code").
+
+
+file_path(File) ->
+   filename:join(asm_path(), File) ++ ".fate".
+
+read_file(File) ->
+    FilePath = file_path(File),
+    Asm = aeb_fate_asm:read_file(FilePath),
+    Asm.
+
+assemble(Asm) ->
+    {Env, BC} = aeb_fate_asm:asm_to_bytecode(Asm, []),
+    {Env, BC}.
+
+disassemble(BC) ->
+    aeb_fate_asm:bytecode_to_fate_code(BC, []).
+
+
+asm_disasm_idenity_test() ->
+    check_roundtrip(identity).
+
+asm_disasm_files_test_() ->
+    [{lists:flatten(io_lib:format("~p", [X])),
+      fun() -> check_roundtrip(X) end}
+     || X <- sources()].
+
+sources() ->
+    [ "arith"
+    , "bool"
+    , "comp"
+    , "jumpif"
+    , "map"
+    , "memory"
+    , "remote"
+    , "test"
+    , "tuple"
+    , "mapofmap"
+    , "immediates"
+    , "all_instructions"
+    ].
+
+check_roundtrip(File) ->
+    AssemblerCode = read_file(File),
+    {_Env, ByteCode} = assemble(AssemblerCode),
+    FateCode = disassemble(ByteCode),
+    DissasmCode = aeb_fate_asm:to_asm(FateCode),
+    io:format("~s~n", [AssemblerCode]),
+    io:format("~s~n", [DissasmCode]),
+    {_Env2, ByteCode2} = assemble(DissasmCode),
+    Code1 = aeb_fate_asm:strip(ByteCode),
+    Code2 = aeb_fate_asm:strip(ByteCode2),
+    io:format("~s~n", [aeb_fate_asm:to_asm(disassemble(ByteCode2))]),
+    ?assertEqual(Code1, Code2).

test/aeb_serialize_test.erl

@@ -0,0 +1,89 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2018, Aeternity Anstalt
+%%% @doc Basic tests for Fate serialization
+%%%
+%%% To run:
+%%%  TEST=aeb_serialize_test rebar3 eunit
+%%%
+%%% @end
+%%%-------------------------------------------------------------------
+
+-module(aeb_serialize_test).
+
+-include_lib("eunit/include/eunit.hrl").
+
+serialize_integer_test() ->
+    <<0>> = aeb_fate_encoding:serialize(aeb_fate_data:make_integer(0)),
+    <<2>> = aeb_fate_encoding:serialize(aeb_fate_data:make_integer(1)),
+    <<126>> = aeb_fate_encoding:serialize(aeb_fate_data:make_integer(63)),
+    <<111, 0>> = aeb_fate_encoding:serialize(aeb_fate_data:make_integer(64)),
+    <<111,130,255,255>> = aeb_fate_encoding:serialize(aeb_fate_data:make_integer(65535 + 64)),
+    <<111,184,129,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>> =
+        aeb_fate_encoding:serialize(aeb_fate_data:make_integer(1 bsl 1024 + 64)).
+
+serialize_deserialize_test_() ->
+    [{lists:flatten(io_lib:format("~p", [X])),
+      fun() ->
+          ?assertEqual(X,
+                       aeb_fate_encoding:deserialize(aeb_fate_encoding:serialize(X)))
+      end}
+     || X <- sources()].
+
+make_int_list(N) -> [aeb_fate_data:make_integer(I) || I <- lists:seq(1, N)].
+
+sources() ->
+    FortyTwo = aeb_fate_data:make_integer(42),
+    Unit = aeb_fate_data:make_unit(),
+    True = aeb_fate_data:make_boolean(true),
+    False = aeb_fate_data:make_boolean(false),
+    Nil = aeb_fate_data:make_list([]),
+    EmptyString = aeb_fate_data:make_string(""),
+    EmptyMap = aeb_fate_data:make_map(#{}),
+    [aeb_fate_data:make_integer(0),
+     aeb_fate_data:make_integer(1),
+     True, False, Unit, Nil, EmptyString, EmptyMap,
+     aeb_fate_data:make_hash(<<1,2,3,4,5>>),
+     aeb_fate_data:make_signature(<<1,2,3,4,5>>),
+     aeb_fate_data:make_contract(<<1,2,3,4,5>>),
+     aeb_fate_data:make_name(<<1,2,3,4,5>>),
+     aeb_fate_data:make_channel(<<1,2,3,4,5>>),
+     aeb_fate_data:make_list([True]),
+     aeb_fate_data:make_address(
+       <<0,1,2,3,4,5,6,7,8,9,
+         0,1,2,3,4,5,6,7,8,9,
+         0,1,2,3,4,5,6,7,8,9,
+         1,2>>),
+     aeb_fate_data:make_string(<<"Hello">>),
+     aeb_fate_data:make_string(
+       <<"0123456789012345678901234567890123456789"
+         "0123456789012345678901234567890123456789"
+         "0123456789012345678901234567890123456789"
+         "0123456789012345678901234567890123456789">>), %% Magic concat 80 char string.
+     aeb_fate_data:make_tuple({True, FortyTwo}),
+     aeb_fate_data:make_tuple(list_to_tuple(make_int_list(65))),
+     aeb_fate_data:make_tuple(list_to_tuple(make_int_list(16))),
+     aeb_fate_data:make_map(#{ aeb_fate_data:make_integer(1) => True, aeb_fate_data:make_integer(2) => False}),
+     aeb_fate_data:make_map(#{ aeb_fate_data:make_string(<<"foo">>) => aeb_fate_data:make_tuple({FortyTwo, True})}),
+     aeb_fate_data:make_list(make_int_list(3)),
+     aeb_fate_data:make_integer(-65),
+     aeb_fate_data:make_integer(65),
+     aeb_fate_data:make_integer(-32432847932847928374983),
+     aeb_fate_data:make_bits(0),
+     aeb_fate_data:make_bits(1),
+     aeb_fate_data:make_bits(-1),
+     aeb_fate_data:make_list(make_int_list(65)),
+     aeb_fate_data:make_variant([1,2,3], 0, {FortyTwo}),
+     aeb_fate_data:make_variant([2,0], 1, {}),
+     aeb_fate_data:make_list([aeb_fate_data:make_variant([0,0,0], 0, {})]),
+     aeb_fate_data:make_variant([0|| _<-lists:seq(1,255)], 254, {}),
+     aeb_fate_data:make_variant([0,1,2,3,4,5],
+                                3, {aeb_fate_data:make_boolean(true),
+                                    aeb_fate_data:make_list(make_int_list(3)),
+                                    aeb_fate_data:make_string(<<"foo">>)})
+
+    ].

test/asm_code/all_instructions.fate

@@ -0,0 +1,237 @@
+;; CONTRACT all_instructions
+
+;; Dont expect this contract to typecheck or run.
+;; Just used to check assembler rountrip of all instruction.
+
+FUNCTION foo () : {tuple, []}
+  RETURN
+
+  RETURNR a13
+
+  CALL foo
+
+  CALL_R arg125 foo
+
+  CALL_T foo
+
+  CALL_TR arg245 foo
+
+  JUMP 5514251025295783441695716053282666408426
+
+  JUMPIF arg196 0x12c651665
+
+  SWITCH_V2 a27 63 33
+
+  SWITCH_V3 var4 0x1d61723dd 79 7
+
+  SWITCH_VN arg0 [1, 2, 3]
+
+  PUSH var80
+
+  DUPA
+
+  DUP a
+
+  POP a107
+
+  STORE arg183 var225
+
+  INCA
+
+  INC a25
+
+  DECA
+
+  DEC a
+
+  ADD a217 a a
+
+  SUB arg35 arg165 var74
+
+  MUL 44 35 "foo"
+
+  DIV 263838340369912686645632650718169038811 a24 a
+
+  MOD var113 arg80 arg207
+
+  POW a176 a a123
+
+  LT a 78 var81
+
+  GT arg19 4729414120208894485838100532547810615352 var175
+
+  EQ 85 a arg164
+
+  ELT a161 arg226 a168
+
+  EGT a131 1 var250
+
+  NEQ a85 a a83
+
+  AND var255 0x294a24f6 var189
+
+  OR (| [2,0] | 0 | ( (), (42) ) |) arg168 var107
+
+  NOT arg124 a
+
+  TUPLE 5019186157739257888756115213149493826410
+
+  ELEMENT arg148 var25 a219
+
+  MAP_EMPTY a135
+
+  MAP_LOOKUP a82 a a143
+
+  MAP_LOOKUPD var112 arg35 a163 var112
+
+  MAP_UPDATE false a0 a56 a
+
+  MAP_DELETE arg180 a var1
+
+  MAP_MEMBER a { true => 4} 94
+
+  MAP_FROM_LIST () a159
+
+  NIL arg91
+
+  IS_NIL a121 var6
+
+  CONS arg185 "foo" a114
+
+  HD a150 var124
+
+  TL arg223 a
+
+  LENGTH var216 a143
+
+  STR_EQ { 203961992615221001243597889146034217896 => 0x1f53a1843} 281217554184165828643225535776787296845 a177
+
+  STR_JOIN a a 7144184027126178769820155907121270843348
+
+  INT_TO_STR var238 a
+
+  ADDR_TO_STR a arg216
+
+  STR_REVERSE a174  @ak_nv5B93FPzRHrGNmMdTDfGdd5xGZvep3MVSpJqzcQmMp59bBCv
+
+  INT_TO_ADDR arg127 var207
+
+  VARIANT a a 0x1f7b72200 a
+
+  VARIANT_TEST a26 arg217 a
+
+  VARIANT_ELEMENT a86 arg103 arg108
+
+  BITS_NONEA
+
+  BITS_NONE a
+
+  BITS_ALLA
+
+  BITS_ALL a164
+
+  BITS_ALL_N a221 arg135
+
+  BITS_SET arg150 a48 { 0x1a715e2a6 => 3}
+
+  BITS_CLEAR arg98 a arg164
+
+  BITS_TEST a a242 (| [0,0,3] | 2 | (1, "foo", ()) |)
+
+  BITS_SUM a244 a71
+
+  BITS_OR var20 var186 a
+
+  BITS_AND a187 4 arg203
+
+  BITS_DIFF var200 arg247 var20
+
+  ADDRESS a237
+
+  BALANCE a231
+
+  ORIGIN arg216
+
+  CALLER a27
+
+  GASPRICE arg119
+
+  BLOCKHASH a arg110
+
+  BENEFICIARY var163
+
+  TIMESTAMP a
+
+  GENERATION 242795038229506961431398379342231049652
+
+  MICROBLOCK arg43
+
+  DIFFICULTY var24
+
+  GASLIMIT arg220
+
+  GAS var35
+
+  LOG0 a a85
+
+  LOG1 arg94 arg86 arg208
+
+  LOG2 a113 (| [0,1,3] | 2 | (1, "foo", ()) |) arg238 var108
+
+  LOG3 arg255 arg15 arg211 var139 arg44
+
+  LOG4 @ak_nv5B93FPzRHrGNmMdTDfGdd5xGZvep3MVSpJqzcQmMp59bBCv a247 a 9 a38 a
+
+  DEACTIVATE
+
+  SPEND @ak_nv5B93FPzRHrGNmMdTDfGdd5xGZvep3MVSpJqzcQmMp59bBCv var136
+
+  ORACLE_REGISTER arg29 48 ((| [0,1,3] | 2 | (1, "foo", ()) |)) arg65 { <> => false} <>
+
+  ORACLE_QUERY
+
+  ORACLE_RESPOND
+
+  ORACLE_EXTEND
+
+  ORACLE_GET_ANSWER
+
+  ORACLE_GET_QUESTION
+
+  ORACLE_QUERY_FEE
+
+  AENS_RESOLVE
+
+  AENS_PRECLAIM
+
+  AENS_CLAIM
+
+  AENS_UPDATE
+
+  AENS_TRANSFER
+
+  AENS_REVOKE
+
+  ECVERIFY
+
+  SHA3
+
+  SHA256
+
+  BLAKE2B
+
+  DUMMY7ARG a a 7607708484837907159893701471377343595877 (| [2,1] | 0 | ( [], [ 45, { 1 => 3441201581501946066216994494994943246334} ] ) |) a0 var56 "foo"
+
+  DUMMY8ARG 3673679924816289365509492271980889822579 a69 arg242 var237 a175 arg106 () var255
+
+  ABORT a
+
+  EXIT var120
+
+  NOP
+
+  RETURNR ()
+
+  BALANCE_OTHER a arg0
+
+  SETELEMENT a 2 (1, "two", 3) 2

test/asm_code/arith.fate

@@ -0,0 +1,26 @@
+;; CONTRACT arith
+
+FUNCTION add (integer, integer) : integer
+  ADD a arg0 arg1
+  RETURN
+
+FUNCTION sub (integer, integer) : integer
+  SUB a arg0 arg1
+  RETURN
+
+FUNCTION mul (integer, integer) : integer
+  MUL a arg0 arg1
+  RETURN
+
+FUNCTION div (integer, integer) : integer
+  DIV a arg0 arg1
+  RETURN
+
+FUNCTION mod (integer, integer) : integer
+  MOD a arg0 arg1
+  RETURN
+
+FUNCTION pow (integer, integer) : integer
+  POW a arg0 arg1
+  RETURN
+

test/asm_code/bool.fate

@@ -0,0 +1,14 @@
+;; CONTRACT bool
+
+FUNCTION and(boolean, boolean) : boolean
+         AND a arg0 arg1
+         RETURN
+
+FUNCTION or(boolean, boolean) : boolean
+         OR a arg0 arg1
+         RETURN
+
+FUNCTION not(boolean) : boolean
+         NOT a arg0
+         RETURN
+

test/asm_code/comp.fate

@@ -0,0 +1,26 @@
+;; CONTRACT comp
+
+FUNCTION lt(integer, integer) : boolean
+  LT a arg0 arg1
+  RETURN
+
+FUNCTION gt(integer, integer) : boolean
+  GT a arg0 arg1
+  RETURN
+
+FUNCTION egt(integer, integer) : boolean
+  EGT a arg0 arg1
+  RETURN
+
+FUNCTION elt(integer, integer) : boolean
+  ELT a arg0 arg1
+  RETURN
+
+FUNCTION eq(integer, integer) : boolean
+  EQ a arg0 arg1
+  RETURN
+
+FUNCTION neq(integer, integer) : boolean
+  NEQ a arg0 arg1
+  RETURN
+

test/asm_code/identity.fate

@@ -0,0 +1,8 @@
+;; CONTRACT: Identity
+FUNCTION id(integer) ->  integer
+  RETURN
+
+;; Test the code from the shell
+;; _build/default/rel/aessembler/bin/aessembler console
+
+;; aeb_aefa:file("../../../../test/asm_code/identity.fate", []).

test/asm_code/immediates.fate

@@ -0,0 +1,77 @@
+;; CONTRACT immediates
+
+FUNCTION integer() : integer
+         RETURNR 42
+
+FUNCTION neg_integer() : integer
+         RETURNR -2374683271468723648732648736498712634876147
+
+FUNCTION hex_integer() : integer
+         RETURNR 0x0deadbeef0
+
+FUNCTION bool() : boolean
+         RETURNR true
+
+FUNCTION bool_f() : boolean
+         RETURNR false
+
+FUNCTION string() : string
+         RETURNR "Hello"
+
+FUNCTION map() : {map, integer, boolean}
+         RETURNR {}
+
+FUNCTION map2() : {map, integer, boolean}
+         RETURNR {1 => true}
+
+FUNCTION map3() : {map, integer, boolean}
+         RETURNR {1 => true,
+                  2 => false}
+
+FUNCTION map4() : {map, integer, {map, string, boolean}}
+         RETURNR {1 => { "foo" => true, "bar" => false},
+                  2 => {},
+                  3 => { "foo" => false}}
+
+FUNCTION nil() : {list, integer}
+         RETURNR []
+
+FUNCTION list1() : {list, integer}
+         RETURNR [1]
+
+FUNCTION list2() : {list, integer}
+         RETURNR [1, 2]
+
+
+FUNCTION no_bits() : bits
+         RETURNR <>
+
+FUNCTION all_bits() : bits
+         RETURNR !<>
+
+FUNCTION some_bits() : bits
+         RETURNR <101010>
+
+FUNCTION many_bits() : bits
+         RETURNR !<010101>
+
+FUNCTION group_bits() : bits
+         RETURNR <1010 1010 0011 1001>
+
+FUNCTION unit() : {tuple, []}
+         RETURNR ()
+
+FUNCTION tuple() : {tuple, [integer, boolean, string, {tuple, [integer, integer]}]}
+         RETURNR (42, true, "FooBar", (1, 2))
+
+
+FUNCTION address() : address
+         RETURNR @ak_nv5B93FPzRHrGNmMdTDfGdd5xGZvep3MVSpJqzcQmMp59bBCv
+
+;; Option(integer) = NONE | SOME(integer)
+FUNCTION variant_none() : {variant, [{tuple, []}, {tuple, [integer]}]}
+         RETURNR (| [0,1] | 0 | () |)
+
+;; Option(integer) = NONE | SOME(integer)
+FUNCTION variant_some() : {variant, [{tuple, []}, {tuple, [integer]}]}
+         RETURNR (| [0,1] | 1 | (42) |)

test/asm_code/jumpif.fate

@@ -0,0 +1,11 @@
+;; CONTRACT jumpif
+FUNCTION skip(integer, integer) : integer
+;; BB : 0
+  PUSH arg1
+  PUSH 0
+  EQ a a arg0
+  JUMPIF a 2
+;; BB : 1
+  INCA
+  JUMP 2
+  RETURN

test/asm_code/map.fate

@@ -0,0 +1,33 @@
+;; CONTRACT map
+FUNCTION make_empty_map():{map, integer, boolean}
+  MAP_EMPTY a
+  RETURN
+
+FUNCTION map_update({map, integer, boolean}, integer, boolean):{map, integer, boolean}
+  MAP_UPDATE a arg0 arg1 arg2
+  RETURN
+
+FUNCTION map_lookup({map, integer, boolean}, integer):boolean
+  MAP_LOOKUP a arg0 arg1
+  RETURN
+
+FUNCTION map_lookup_default({map, integer, boolean}, integer): boolean
+  MAP_LOOKUPD a arg0 arg1 false
+  RETURN
+
+FUNCTION map_member({map, integer, boolean}, integer):boolean
+  MAP_MEMBER a arg0 arg1
+  RETURN
+
+FUNCTION map_delete({map, integer, boolean}, integer):{map, integer, boolean}
+  MAP_DELETE a arg0 arg1
+  RETURN
+
+FUNCTION map_member({map, integer, boolean}, integer) : boolean
+        MAP_MEMBER a arg0 arg1
+        RETURN
+
+FUNCTION map_from_list({list, {tuple, [integer, boolean]}}) : {map, integer, boolean}
+        MAP_FROM_LIST a arg0
+        RETURN
+

test/asm_code/mapofmap.fate

@@ -0,0 +1,7 @@
+;; CONTRACT mapofmap
+FUNCTION map() : {map, integer, {map, string, boolean}}
+         RETURNR {1 => { "foo" => true, "bar" => false},
+                  2 => {},
+                  3 => { "foo" => false}}
+
+

test/asm_code/memory.fate

@@ -0,0 +1,31 @@
+;; CONTRACT memory
+FUNCTION call(integer):integer
+  STORE var1 arg0
+  PUSH  0
+  CALL  write
+  PUSH  var1
+  RETURN
+
+FUNCTION write(integer):integer
+  STORE    var1 arg0
+  RETURNR  var1
+
+FUNCTION dest_add(integer, integer): integer
+  STORE var1 arg0
+  STORE var2 arg1
+  ADD   var3 var1 var2
+  PUSH  var3
+  RETURN
+
+FUNCTION dest_add_imm(integer):integer
+  STORE var1 arg0
+  ADD   var3 var1 2
+  PUSH  var3
+  RETURN
+
+FUNCTION dest_add_stack(integer, integer): integer
+  STORE var1 arg0
+  PUSH  arg1
+  ADD   var3 var1 a
+  PUSH  var3
+  RETURN

test/asm_code/remote.fate

@@ -0,0 +1,4 @@
+;; CONTRACT remote
+FUNCTION add_five(integer):integer
+ ADD a 5 arg0
+ RETURN

test/asm_code/test.fate

@@ -0,0 +1,45 @@
+;; CONTRACT: Test
+FUNCTION id(integer) -> integer
+  RETURN
+
+FUNCTION jumps() -> integer
+  PUSH 0
+  JUMP 3
+  NOP
+  JUMP 2
+  NOP
+  RETURN
+  NOP
+  JUMP 1
+
+FUNCTION inc(integer) -> integer
+  INCA
+  INCA
+  RETURN
+
+FUNCTION call(integer) -> integer
+  INCA
+  CALL inc
+  INCA
+  RETURN
+
+
+FUNCTION tailcall(integer) -> integer
+  INCA
+  CALL_T inc
+
+FUNCTION remote_call(integer) : integer
+  PUSH arg0
+  CALL_R remote.add_five
+  INCA
+  RETURN
+
+FUNCTION remote_tailcall(integer) : integer
+  PUSH  arg0
+  CALL_TR remote add_five
+
+;; Test the code from the shell
+;; _build/default/rel/aessembler/bin/aessembler console
+
+;; aeb_aefa:file("../../../../test/asm_code/test.fate", []).
+;; f(Asm), f(Env), f(BC), Asm = aefa_asm:read_file("../../../../test/asm_code/test.fate"), {Env, BC} = aefa_asm:asm_to_bytecode(Asm, []), aefa_asm:bytecode_to_fate_code(BC, []).

test/asm_code/tuple.fate

@@ -0,0 +1,35 @@
+FUNCTION make_0tuple():{tuple, []}
+;; BB : 0
+  TUPLE   0
+  RETURN
+
+FUNCTION make_2tuple(integer, integer):{tuple, [integer, integer]}
+;; BB : 0
+  PUSH       arg0
+  PUSH       arg1
+  TUPLE         2
+  RETURN
+
+FUNCTION make_5tuple(integer, integer, integer, integer, integer):
+                {tuple, [integer, integer, integer, integer, integer]}
+;; BB : 0
+  PUSH       arg0
+  PUSH       arg1
+  PUSH       arg2
+  PUSH       arg3
+  PUSH       arg4
+  TUPLE         5
+  RETURN
+
+FUNCTION element1(integer, integer): integer
+;; BB : 0
+  PUSH            arg0
+  PUSH            arg1
+  TUPLE              2
+  ELEMENT        a 1 a
+  RETURN
+
+FUNCTION element({tuple, [integer, integer]}, integer): integer
+;; BB : 0
+  ELEMENT  a arg1 arg0
+  RETURN