QPQ-AG/sophia
10
0
Fork 0
Code Issues 41 Pull Requests 5 Actions Packages Projects Releases 16 Wiki Activity

Refactor internal code and more add statements, definitely WIP

Browse Source
This commit is contained in:
Robert Virding 2019-04-25 11:55:28 +02:00
parent 70a0f77793
commit 2d3e6ab6e0
2 changed files with 274 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
docs/aeso_aci.md
View File

@ -147,10 +147,44 @@ Take a JSON encoding of a contract interface and generate and generate a contrac
#### encode_type(TypeAST) -> JSONstring. #### encode_type(TypeAST) -> JSONstring.
Types
``` erlang
JSONstring = json_string()
```
Generate the JSON encoding of a type from the AST of the type.
#### encode_arg(ArgAST) -> JSONstring.
Types
``` erlang
JSONstring = json_string()
```
Generate the JSON encoding of a function argument from the AST of the argument.
#### encode_stmt(StmtAST) -> JSONstring. #### encode_stmt(StmtAST) -> JSONstring.
Types
``` erlang
JSONstring = json_string()
```
Generate the JSON encoding of a statement from the AST of the statement.
#### encode_expr(ExprAST) -> JSONstring. #### encode_expr(ExprAST) -> JSONstring.
Types
``` erlang
JSONstring = json_string()
```
Generate the JSON encoding of an expression from the AST of the expression.
### Example run ### Example run
This is an example of using the ACI generator from an Erlang shell. The file called `aci_test.aes` contains the contract in the description from which we want to generate files `aci_test.json` which is the JSON encoding of the contract interface and `aci_test.include` which is the contract definition to be included inside another contract. This is an example of using the ACI generator from an Erlang shell. The file called `aci_test.aes` contains the contract in the description from which we want to generate files `aci_test.json` which is the JSON encoding of the contract interface and `aci_test.include` which is the contract definition to be included inside another contract.

416
src/aeso_aci.erl
View File

@ -10,9 +10,10 @@
-module(aeso_aci). -module(aeso_aci).
-export([encode/1,encode/2,decode/1]). -export([encode/1,encode/2,decode/1]).
-export([encode_contract/1,encode_contract/2,decode_contract/1]). -export([encode_contract/1,encode_contract/2,decode_contract/1]).
-export([encode_type/1,encode_types/1, -export([encode_func/1,encode_type/1,encode_arg/1,
encode_stmt/1,encode_expr/1,encode_exprs/1]). encode_stmt/1,encode_expr/1]).
%% Define records for the various typed syntactic forms. These make %% Define records for the various typed syntactic forms. These make
%% the code easier but don't seem to exist elsewhere. %% the code easier but don't seem to exist elsewhere.
@ -43,7 +44,11 @@
-record(tvar, {ann,name}). -record(tvar, {ann,name}).
%% Statements %% Statements
-record('if', {ann,test,true,false}). -record(block, {ann,body}).
-record('if', {ann,test,then,else}). %Both statement and expression
-record(letval, {ann,pat,type,exp}).
-record(switch, {ann,arg,cases}).
-record('case', {ann,pat,body}).
%% Expressions %% Expressions
-record(bool, {ann,bool}). -record(bool, {ann,bool}).
@ -56,20 +61,23 @@
-record(field, {ann,name,value}). %A record field -record(field, {ann,name,value}). %A record field
-record(proj, {ann,value}). %? -record(proj, {ann,value}). %?
-record(map, {ann,fields}). -record(map, {ann,fields}).
-record(lam, {ann,args,body}).
-record(app, {ann,func,args}). -record(app, {ann,func,args}).
-record(typed, {ann,expr,type}). -record(typed, {ann,expr,type}).
%% The old deprecated interface.
encode(C) -> encode_contract(C).
encode(C, Os) -> encode_contract(C, Os).
decode(J) -> decode_contract(J).
%% encode_contract(ContractString) -> {ok,JSON} | {error,String}. %% encode_contract(ContractString) -> {ok,JSON} | {error,String}.
%% encode_contract(ContractString, Options) -> {ok,JSON} | {error,String}. %% encode_contract(ContractString, Options) -> {ok,JSON} | {error,String}.
%% Build a JSON structure with lists and tuples, not maps, as this %% Build a JSON structure with lists and tuples, not maps, as this
%% allows us to order the fields in the contructed JSON string. %% allows us to order the fields in the contructed JSON string.
encode(C) -> encode_contract(C).
encode(C, Os) -> encode_contract(C, Os).
encode_contract(ContractString) -> encode_contract(ContractString) ->
encode_contract(ContractString, []). encode_contract(ContractString, []).
encode_contract(ContractString, Options) when is_binary(ContractString) -> encode_contract(ContractString, Options) when is_binary(ContractString) ->
encode_contract(binary_to_list(ContractString), Options); encode_contract(binary_to_list(ContractString), Options);
encode_contract(ContractString, Options) -> encode_contract(ContractString, Options) ->
@ -83,11 +91,11 @@ encode_contract(ContractString, Options) ->
%% We find and look at the last contract. %% We find and look at the last contract.
Contract = lists:last(TypedAst), Contract = lists:last(TypedAst),
Cname = contract_name(Contract), Cname = contract_name(Contract),
Tdefs = [ encode_typedef(T) || Tdefs = [ do_encode_typedef(T) ||
T <- sort_decls(contract_types(Contract)) ], T <- sort_decls(contract_types(Contract)) ],
Fdefs = [ encode_func(F) || F <- sort_decls(contract_funcs(Contract)), Fdefs = [ do_encode_func(F) || F <- sort_decls(contract_funcs(Contract)),
not is_private_func(F) ], not is_private_func(F) ],
Jmap = [{<<"contract">>, [{<<"name">>, encode_name(Cname)}, Jmap = [{<<"contract">>, [{<<"name">>, do_encode_name(Cname)},
{<<"type_defs">>, Tdefs}, {<<"type_defs">>, Tdefs},
{<<"functions">>, Fdefs}]}], {<<"functions">>, Fdefs}]}],
%% io:format("~p\n", [Jmap]), %% io:format("~p\n", [Jmap]),
@ -108,280 +116,336 @@ join_errors(Prefix, Errors, Pfun) ->
Ess = [ Pfun(E) || E <- Errors ], Ess = [ Pfun(E) || E <- Errors ],
list_to_binary(string:join([Prefix|Ess], "\n")). list_to_binary(string:join([Prefix|Ess], "\n")).
%% encode_func(Function) -> JSON %% encode_func(TypedAST) -> JSON.
%% Encode a function AST into a JSON structure.
encode_func(AST) ->
jsx:encode(do_encode_func(AST)).
%% do_encode_func(Function) -> JSONmap
%% Encode a function definition. Currently we are only interested in %% Encode a function definition. Currently we are only interested in
%% the interface and type. %% the interface and type.
encode_func(Fdef) -> do_encode_func(Fdef) ->
Name = function_name(Fdef), Name = function_name(Fdef),
Args = function_args(Fdef), Args = function_args(Fdef),
Type = function_type(Fdef), Type = function_type(Fdef),
[{<<"name">>, encode_name(Name)}, [{<<"name">>, do_encode_name(Name)},
{<<"arguments">>, encode_args(Args)}, {<<"arguments">>, do_encode_args(Args)},
{<<"returns">>, encode_type(Type)}, {<<"returns">>, do_encode_type(Type)},
{<<"stateful">>, is_stateful_func(Fdef)}]. {<<"stateful">>, is_stateful_func(Fdef)}].
%% encode_args(ArgASTs) -> [JSON]. %% encode_arg(TypedAST) -> JSON.
%% encode_arg(ArgAST) -> JSON. %% Encode an argument AST into a JSON structure.
encode_args(Args) -> encode_arg(AST) ->
[ encode_arg(A) || A <- Args ]. jsx:encode(do_encode_arg(AST)).
encode_arg(#arg{id=Id,type=T}) -> %% do_encode_args(ArgASTs) -> [JSONmap].
[{<<"name">>,encode_type(Id)}, %% do_encode_arg(ArgAST) -> JSONmap.
{<<"type">>,[encode_type(T)]}].
%% encode_types(TypeASTs) -> [JSON]. do_encode_args(Args) ->
%% encode_type(TypeAST) -> JSON. [ do_encode_arg(A) || A <- Args ].
encode_types(Types) -> do_encode_arg(#arg{id=Id,type=T}) ->
[ encode_type(T) || T <- Types ]. [{<<"name">>,do_encode_type(Id)},
{<<"type">>,do_encode_type(T)}].
encode_type(#tvar{name=N}) -> encode_name(N); %% encode_type(TypedAST) -> JSON.
encode_type(#id{name=N}) -> encode_name(N); %% Encode a type AST into a JSON structure.
encode_type(#con{name=N}) -> encode_name(N);
encode_type(#qid{names=Ns}) -> encode_type(AST) ->
encode_name(lists:join(".", Ns)); jsx:encode(do_encode_type(AST)).
encode_type(#qcon{names=Ns}) ->
encode_name(lists:join(".", Ns)); %? %% do_encode_types([TypeAST]) -> [JSONmap].
encode_type(#tuple_t{args=As}) -> %% do_encode_type(TypeAST) -> JsonMap.
Eas = encode_types(As),
do_encode_types(Types) ->
[ do_encode_type(T) || T <- Types ].
do_encode_type(#tvar{name=N}) -> do_encode_name(N);
do_encode_type(#id{name=N}) -> do_encode_name(N);
do_encode_type(#con{name=N}) -> do_encode_name(N);
do_encode_type(#qid{names=Ns}) ->
do_encode_name(lists:join(".", Ns));
do_encode_type(#qcon{names=Ns}) ->
do_encode_name(lists:join(".", Ns)); %?
do_encode_type(#tuple_t{args=As}) ->
Eas = do_encode_types(As),
[{<<"tuple">>,Eas}]; [{<<"tuple">>,Eas}];
encode_type(#bytes_t{len=Len}) -> do_encode_type(#bytes_t{len=Len}) ->
{<<"bytes">>,Len}; {<<"bytes">>,Len};
encode_type(#record_t{fields=Fs}) -> do_encode_type(#record_t{fields=Fs}) ->
Efs = encode_rec_field_types(Fs), Efs = do_encode_type_rec_fields(Fs),
[{<<"record">>,Efs}]; [{<<"record">>,Efs}];
%% Special case lists and maps as they are built-in types. %% Special case lists and maps as they are built-in types.
encode_type(#app_t{id=#id{name="list"},fields=[F]}) -> do_encode_type(#app_t{id=#id{name="list"},fields=[F]}) ->
Ef = encode_type(F), Ef = do_encode_type(F),
[{<<"list">>,Ef}]; [{<<"list">>,Ef}];
encode_type(#app_t{id=#id{name="map"},fields=Fs}) -> do_encode_type(#app_t{id=#id{name="map"},fields=Fs}) ->
Ef = encode_map_field_type(Fs), Ef = do_encode_type_mapo_field(Fs),
[{<<"map">>,Ef}]; [{<<"map">>,Ef}];
%% Other applications. %% Other applications.
encode_type(#app_t{id=Id,fields=Fs}) -> do_encode_type(#app_t{id=Id,fields=Fs}) ->
Name = encode_type(Id), Name = do_encode_type(Id),
Efs = encode_types(Fs), Efs = do_encode_types(Fs),
[{Name,Efs}]; [{Name,Efs}];
encode_type(#variant_t{cons=Cs}) -> do_encode_type(#variant_t{cons=Cs}) ->
Ecs = encode_types(Cs), Ecs = do_encode_types(Cs),
[{<<"variant">>,Ecs}]; [{<<"variant">>,Ecs}];
encode_type(#constr_t{con=C,args=As}) -> do_encode_type(#constr_t{con=C,args=As}) ->
Ec = encode_type(C), Ec = do_encode_type(C),
Eas = encode_types(As), Eas = do_encode_types(As),
[{Ec,Eas}]; [{Ec,Eas}];
encode_type(#fun_t{args=As,type=T}) -> do_encode_type(#fun_t{args=As,type=T}) ->
Eas = encode_types(As), Eas = do_encode_types(As),
Et = encode_type(T), Et = do_encode_type(T),
[{<<"function">>,[{<<"arguments">>,Eas},{<<"returns">>,Et}]}]. [{<<"function">>,[{<<"arguments">>,Eas},{<<"returns">>,Et}]}].
encode_name(Name) -> do_encode_name(Name) ->
list_to_binary(Name). list_to_binary(Name).
%% encode_rec_field_types(Fields) -> [JSON]. %% do_encode_type_rec_fields(Fields) -> [JSONmap].
%% encode_rec_field_type(Field) -> JSON. %% do_encode_type_rec_field(Field) -> JSONmap.
%% Encode a record field type. %% Encode a record field type.
encode_rec_field_types(Fs) -> do_encode_type_rec_fields(Fs) ->
[ encode_rec_field_type(F) || F <- Fs ]. [ do_encode_type_rec_field(F) || F <- Fs ].
encode_rec_field_type(#field_t{id=Id,type=T}) -> do_encode_type_rec_field(#field_t{id=Id,type=T}) ->
[{<<"name">>,encode_type(Id)}, [{<<"name">>,do_encode_type(Id)},
{<<"type">>,encode_type(T)}]. {<<"type">>,do_encode_type(T)}].
%% encode_map_field_type(Field) -> JSON. %% do_encode_type_mapo_field(Field) -> JSONmap.
%% Two fields for one map type. %% Two fields for one map type.
encode_map_field_type([K,V]) -> do_encode_type_mapo_field([K,V]) ->
[{<<"key">>,encode_type(K)}, [{<<"key">>,do_encode_type(K)},
{<<"value">>,encode_type(V)}]. {<<"value">>,do_encode_type(V)}].
%% encode_typedef(TypeDefAST) -> JSON. %% do_encode_typedef(TypeDefAST) -> JSON.
encode_typedef(Type) -> do_encode_typedef(Type) ->
Name = typedef_name(Type), Name = typedef_name(Type),
Vars = typedef_vars(Type), Vars = typedef_vars(Type),
Def = typedef_def(Type), Def = typedef_def(Type),
[{<<"name">>, encode_name(Name)}, [{<<"name">>, do_encode_name(Name)},
{<<"vars">>, encode_tvars(Vars)}, {<<"vars">>, do_encode_tvars(Vars)},
{<<"typedef">>, encode_alias(Def)}]. {<<"typedef">>, do_encode_alias(Def)}].
encode_tvars(Vars) -> do_encode_tvars(Vars) ->
[ encode_tvar(V) || V <- Vars ]. [ do_encode_tvar(V) || V <- Vars ].
encode_tvar(#tvar{name=N}) -> do_encode_tvar(#tvar{name=N}) ->
[{<<"name">>, encode_name(N)}]. [{<<"name">>, do_encode_name(N)}].
encode_alias(#alias_t{type=T}) -> do_encode_alias(#alias_t{type=T}) ->
encode_type(T); do_encode_type(T);
encode_alias(A) -> encode_type(A). do_encode_alias(A) -> do_encode_type(A).
%% encode_stmt(StmtAST) -> JSON. %% encode_stmt(StmtAST) -> JSON.
%% Encode a statement AST into a JSON structure.
encode_stmt(#typed{expr=E}) -> %Ignore the type encode_stmt(AST) ->
encode_stmt(E); jsx:encode(do_encode_stmt(AST)).
encode_stmt(#'if'{test=Test,true=True,false=False}) ->
Etest = encode_expr(Test), %% do_encode_stmt(StmtAST) -> JSONmap.
Etrue = encode_stmt(True),
Efalse = encode_stmt(False), do_encode_stmt(#typed{expr=E}) -> %Ignore the type
[{<<"if">>,[{<<"test">>,Etest},{<<"true">>,Etrue},{<<"false">>,Efalse}]}]; do_encode_stmt(E);
encode_stmt(E) -> do_encode_stmt(#block{body=Body}) ->
encode_expr(E). Eblock = [ do_encode_stmt(B) || B <- Body ],
[{<<"block">>,Eblock}];
do_encode_stmt(#'if'{test=Test,then=Then,else=Else}) ->
%% This is both a statement and en expression.
Etest = do_encode_expr(Test),
Ethen = do_encode_stmt(Then),
Eelse = do_encode_stmt(Else),
[{<<"if">>,[{<<"test">>,Etest},{<<"then">>,Ethen},{<<"else">>,Eelse}]}];
do_encode_stmt(#letval{pat=Pat,exp=Exp}) ->
Epat = do_encode_expr(Pat),
Eexp = do_encode_expr(Exp),
[{<<"let">>,[{<<"pattern">>,Epat},{<<"expression">>,Eexp}]}];
do_encode_stmt(#switch{arg=Arg,cases=Cases}) ->
Earg = do_encode_expr(Arg),
Ecases = [ do_encode_stmt_case(Case) || Case <- Cases ],
[{<<"switch">>,[{<<"arg">>,Earg},{<<"cases">>,Ecases}]}];
do_encode_stmt(E) ->
do_encode_expr(E).
do_encode_stmt_case(#'case'{pat=Pat,body=Body}) ->
Epat = do_encode_expr(Pat), %Patterns are expessions
Ebody = do_encode_stmt(Body),
[{<<"pattern">>,Epat},{<<"body">>,Ebody}].
%% encode_exprs(ExprASTs) -> [JSON].
%% encode_expr(ExprAST) -> JSON. %% encode_expr(ExprAST) -> JSON.
%% Encode an expression AST into a JSON structure.
encode_exprs(Es) -> encode_expr(AST) ->
[ encode_expr(E) || E <- Es ]. jsx:encode(do_encode_expr(AST)).
encode_expr(#typed{expr=E}) -> %Ignore the type %% do_encode_exprs(ExprASTs) -> [JSONmap].
encode_expr(E); %% do_encode_expr(ExprAST) -> JSONmap.
encode_expr(#id{name=N}) -> encode_name(N);
encode_expr(#con{name=N}) -> encode_name(N); do_encode_exprs(Es) ->
encode_expr(#qid{names=Ns}) -> [ do_encode_expr(E) || E <- Es ].
encode_name(lists:join(".", Ns));
encode_expr(#qcon{names=Ns}) -> do_encode_expr(#typed{expr=E}) -> %Ignore the type
encode_name(lists:join(".", Ns)); %? do_encode_expr(E);
encode_expr(#bool{bool=B}) -> B; do_encode_expr(#id{name=N}) -> do_encode_name(N);
encode_expr(#int{value=V}) -> V; do_encode_expr(#con{name=N}) -> do_encode_name(N);
encode_expr(#string{bin=B}) -> B; do_encode_expr(#qid{names=Ns}) ->
encode_expr(#bytes{bin=B}) -> B; do_encode_name(lists:join(".", Ns));
encode_expr(#tuple{args=As}) -> do_encode_expr(#qcon{names=Ns}) ->
Eas = encode_exprs(As), do_encode_name(lists:join(".", Ns)); %?
do_encode_expr(#bool{bool=B}) -> B;
do_encode_expr(#int{value=V}) -> V;
do_encode_expr(#string{bin=B}) ->
[{<<"string">>,B}];
do_encode_expr(#bytes{bin=B}) -> B;
do_encode_expr(#tuple{args=As}) ->
Eas = do_encode_exprs(As),
[{<<"tuple">>,Eas}]; [{<<"tuple">>,Eas}];
encode_expr(#list{args=As}) -> do_encode_expr(#list{args=As}) ->
Eas = encode_exprs(As), Eas = do_encode_exprs(As),
[{<<"list">>,Eas}]; [{<<"list">>,Eas}];
encode_expr(#record{fields=Fs}) -> do_encode_expr(#record{fields=Fs}) ->
Efs = encode_rec_field_exprs(Fs), Efs = do_encode_expr_rec_fields(Fs),
[{<<"record">>,Efs}]; [{<<"record">>,Efs}];
encode_expr(#map{fields=Fs}) -> do_encode_expr(#lam{args=As,body=B}) ->
Efs = encode_map_field_exprs(Fs), Eas = do_encode_args(As),
Eb = do_encode_stmt(B),
[{<<"function">>,[{<<"arguments">>,Eas},{<<"body">>,Eb}]}];
do_encode_expr(#map{fields=Fs}) ->
Efs = do_encode_expr_map_fields(Fs),
[{<<"map">>,Efs}]; [{<<"map">>,Efs}];
encode_expr(#proj{value=V}) -> do_encode_expr(#proj{value=V}) ->
encode_expr(V); do_encode_expr(V);
encode_expr(#app{func=F,args=As}) -> do_encode_expr(#app{func=F,args=As}) ->
Ef = encode_expr(F), Ef = do_encode_expr(F),
Eas = encode_exprs(As), Eas = do_encode_exprs(As),
[{<<"apply">>,[{<<"function">>,Ef}, [{<<"apply">>,[{<<"function">>,Ef},
{<<"arguments">>,Eas}]}]; {<<"arguments">>,Eas}]}];
encode_expr({Op,_Ann}) -> do_encode_expr(#'if'{test=Test,then=Then,else=Else}) ->
%% This is both a statement and en expression.
Etest = do_encode_expr(Test),
Ethen = do_encode_expr(Then),
Eelse = do_encode_expr(Else),
[{<<"if">>,[{<<"test">>,Etest},{<<"then">>,Ethen},{<<"else">>,Eelse}]}];
do_encode_expr({Op,_Ann}) ->
list_to_binary(atom_to_list(Op)). list_to_binary(atom_to_list(Op)).
%% encode_rec_field_exprs(Fields) -> [JSON]. %% do_encode_expr_rec_fields(Fields) -> [JSON].
%% encode_rec_field_expr(Field) -> JSON. %% do_encode_expr_rec_field(Field) -> JSON.
%% Encode a record field expression. %% Encode a record field expression.
encode_rec_field_exprs(Fs) -> do_encode_expr_rec_fields(Fs) ->
[ encode_rec_field_expr(F) || F <- Fs ]. [ do_encode_expr_rec_field(F) || F <- Fs ].
encode_rec_field_expr(#field{name=[N],value=V}) -> do_encode_expr_rec_field(#field{name=[N],value=V}) ->
[{<<"name">>,encode_expr(N)}, [{<<"name">>,do_encode_expr(N)},
{<<"value">>,encode_expr(V)}]. {<<"value">>,do_encode_expr(V)}].
%% encode_map_field_exprs(Fields) -> [JSON]. %% do_encode_expr_map_fields(Fields) -> [JSON].
%% encode_map_field_expr(Field) -> JSON. %% do_encode_expr_map_field(Field) -> JSON.
%% Encode a map field expression. %% Encode a map field expression.
encode_map_field_exprs(Fs) -> do_encode_expr_map_fields(Fs) ->
[ encode_map_field_expr(F) || F <- Fs ]. [ do_encode_expr_map_field(F) || F <- Fs ].
encode_map_field_expr({K,V}) -> do_encode_expr_map_field({K,V}) ->
[{<<"key">>,encode_expr(K)}, [{<<"key">>,do_encode_expr(K)},
{<<"value">>,encode_expr(V)}]. {<<"value">>,do_encode_expr(V)}].
%% decode_contract(JSON) -> ContractString. %% decode_contract(JSON) -> ContractString.
%% Decode a JSON string and generate a suitable contract string which %% Decode a JSON string and generate a suitable contract string which
%% can be included in a contract definition. We decode into a map %% can be included in a contract definition. We decode into a map
%% here as this is easier to work with and order is not important. %% here as this is easier to work with and order is not important.
decode(J) -> decode_contract(J).
decode_contract(Json) -> decode_contract(Json) ->
Map = jsx:decode(Json, [return_maps]), Map = jsx:decode(Json, [return_maps]),
%% io:format("~p\n", [Map]), %% io:format("~p\n", [Map]),
#{<<"contract">> := C} = Map, #{<<"contract">> := C} = Map,
#{<<"name">> := Name, <<"type_defs">> := Ts, <<"functions">> := Fs} = C, #{<<"name">> := Name, <<"type_defs">> := Ts, <<"functions">> := Fs} = C,
CS = ["contract"," ",io_lib:format("~s", [Name])," =\n", CS = ["contract"," ",io_lib:format("~s", [Name])," =\n",
decode_tdefs(Ts), do_decode_tdefs(Ts),
decode_funcs(Fs)], do_decode_funcs(Fs)],
list_to_binary(CS). list_to_binary(CS).
decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ]. do_decode_funcs(Fs) -> [ do_decode_func(F) || F <- Fs ].
decode_func(#{<<"name">> := <<"init">>}) -> []; do_decode_func(#{<<"name">> := <<"init">>}) -> [];
decode_func(#{<<"name">> := Name,<<"arguments">> := As,<<"returns">> := T}) -> do_decode_func(#{<<"name">> := Name,<<"arguments">> := As,<<"returns">> := T}) ->
[" function"," ",io_lib:format("~s", [Name])," : ", [" function"," ",io_lib:format("~s", [Name])," : ",
decode_args(As)," => ",decode_type(T),$\n]. do_decode_args(As)," => ",do_decode_type(T),$\n].
decode_args(As) -> do_decode_args(As) ->
Das = [ decode_arg(A) || A <- As ], Das = [ do_decode_arg(A) || A <- As ],
[$(,lists:join(", ", Das),$)]. [$(,lists:join(", ", Das),$)].
decode_arg(#{<<"type">> := [T]}) -> decode_type(T). do_decode_arg(#{<<"type">> := [T]}) -> do_decode_type(T).
decode_types(Ets) -> do_decode_types(Ets) ->
[ decode_type(Et) || Et <- Ets ]. [ do_decode_type(Et) || Et <- Ets ].
decode_type(#{<<"tuple">> := Ets}) -> do_decode_type(#{<<"tuple">> := Ets}) ->
Ts = decode_types(Ets), Ts = do_decode_types(Ets),
[$(,lists:join(", ", Ts),$)]; [$(,lists:join(", ", Ts),$)];
decode_type(#{<<"record">> := Efs}) -> do_decode_type(#{<<"record">> := Efs}) ->
Fs = decode_rec_field_types(Efs), Fs = do_decode_type_rec_fields(Efs),
[${,lists:join(", ", Fs),$}]; [${,lists:join(", ", Fs),$}];
decode_type(#{<<"list">> := Et}) -> do_decode_type(#{<<"list">> := Et}) ->
T = decode_type(Et), T = do_decode_type(Et),
["list",$(,T,$)]; ["list",$(,T,$)];
decode_type(#{<<"map">> := Et}) -> do_decode_type(#{<<"map">> := Et}) ->
T = decode_map_type(Et), T = do_decode_type_map(Et),
["map",$(,T,$)]; ["map",$(,T,$)];
decode_type(#{<<"variant">> := Ets}) -> do_decode_type(#{<<"variant">> := Ets}) ->
Ts = decode_types(Ets), Ts = do_decode_types(Ets),
lists:join(" | ", Ts); lists:join(" | ", Ts);
decode_type(Econs) when is_map(Econs) -> %General constructor do_decode_type(Econs) when is_map(Econs) -> %General constructor
%% io:format("~p\n", [Econs]), %% io:format("~p\n", [Econs]),
[{Ec,Ets}] = maps:to_list(Econs), [{Ec,Ets}] = maps:to_list(Econs),
C = decode_name(Ec), C = do_decode_name(Ec),
Ts = decode_types(Ets), Ts = do_decode_types(Ets),
[C,$(,lists:join(", ", Ts),$)]; [C,$(,lists:join(", ", Ts),$)];
decode_type(T) -> %Just raw names. do_decode_type(T) -> %Just raw names.
decode_name(T). do_decode_name(T).
decode_name(En) -> do_decode_name(En) ->
binary_to_list(En). binary_to_list(En).
decode_rec_field_types(Efs) -> do_decode_type_rec_fields(Efs) ->
[ decode_rec_field_type(Ef) || Ef <- Efs ]. [ do_decode_type_rec_field(Ef) || Ef <- Efs ].
decode_rec_field_type(#{<<"name">> := En,<<"type">> := Et}) -> do_decode_type_rec_field(#{<<"name">> := En,<<"type">> := Et}) ->
Name = decode_name(En), Name = do_decode_name(En),
Type = decode_type(Et), Type = do_decode_type(Et),
[Name," : ",Type]. [Name," : ",Type].
decode_map_type(#{<<"key">> := Ek,<<"value">> := Ev}) -> do_decode_type_map(#{<<"key">> := Ek,<<"value">> := Ev}) ->
Key = decode_type(Ek), Key = do_decode_type(Ek),
Value = decode_type(Ev), Value = do_decode_type(Ev),
[Key,", ",Value]. [Key,", ",Value].
%% decode_tdefs(Json) -> [TypeString]. %% do_decode_tdefs(Json) -> [TypeString].
%% Here we are only interested in the type definitions and ignore the %% Here we are only interested in the type definitions and ignore the
%% aliases. We find them as they always have variants. %% aliases. We find them as they always have variants.
decode_tdefs(Ts) -> [ decode_tdef(T) || do_decode_tdefs(Ts) -> [ do_decode_tdef(T) ||
#{<<"typedef">> := #{<<"variant">> := _}} = T <- Ts #{<<"typedef">> := #{<<"variant">> := _}} = T <- Ts
]. ].
decode_tdef(#{<<"name">> := Name,<<"vars">> := Vs,<<"typedef">> := T}) -> do_decode_tdef(#{<<"name">> := Name,<<"vars">> := Vs,<<"typedef">> := T}) ->
[" datatype"," ",decode_name(Name),decode_tvars(Vs), [" datatype"," ",do_decode_name(Name),do_decode_tvars(Vs),
" = ",decode_type(T),$\n]. " = ",do_decode_type(T),$\n].
decode_tvars([]) -> []; %No tvars, no parentheses do_decode_tvars([]) -> []; %No tvars, no parentheses
decode_tvars(Vs) -> do_decode_tvars(Vs) ->
Dvs = [ decode_tvar(V) || V <- Vs ], Dvs = [ do_decode_tvar(V) || V <- Vs ],
[$(,lists:join(", ", Dvs),$)]. [$(,lists:join(", ", Dvs),$)].
decode_tvar(#{<<"name">> := N}) -> io_lib:format("~s", [N]). do_decode_tvar(#{<<"name">> := N}) -> io_lib:format("~s", [N]).
%% #contract{Ann, Con, [Declarations]}. %% #contract{Ann, Con, [Declarations]}.