Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Thomas Arts
|
be9935cd7e | ||
|
Thomas Arts
|
aa2e6aa218 |
@@ -19,16 +19,16 @@ jobs:
|
||||
- dialyzer-cache-v2-
|
||||
- run:
|
||||
name: Build
|
||||
command: ./rebar3 compile
|
||||
command: rebar3 compile
|
||||
- run:
|
||||
name: Static Analysis
|
||||
command: ./rebar3 dialyzer
|
||||
command: rebar3 dialyzer
|
||||
- run:
|
||||
name: Eunit
|
||||
command: ./rebar3 eunit
|
||||
command: rebar3 eunit
|
||||
- run:
|
||||
name: Common Tests
|
||||
command: ./rebar3 ct
|
||||
command: rebar3 ct
|
||||
- save_cache:
|
||||
key: dialyzer-cache-v2-{{ .Branch }}-{{ .Revision }}
|
||||
paths:
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
{build, "rebar3 as eqc compile"}.
|
||||
{test_root, "."}.
|
||||
{test_path, "_build/eqc/lib/aesophia/quickcheck"}. %% here are the properties
|
||||
+3
-1
@@ -16,6 +16,8 @@ _build
|
||||
.idea
|
||||
*.iml
|
||||
rebar3.crashdump
|
||||
current_counterexample.eqc
|
||||
.qcci
|
||||
*.erl~
|
||||
*.aes~
|
||||
aesophia
|
||||
|
||||
|
||||
@@ -1,61 +0,0 @@
|
||||
# Changelog
|
||||
All notable changes to this project will be documented in this file.
|
||||
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## [Unreleased]
|
||||
### Added
|
||||
### Changed
|
||||
### Removed
|
||||
|
||||
## [3.0.0] - 2019-05-21
|
||||
### Added
|
||||
- `stateful` annotations are now properly enforced. Functions must be marked stateful
|
||||
in order to update the state or spend tokens.
|
||||
- Primitives `Contract.creator`, `Address.is_contract`, `Address.is_oracle`,
|
||||
`Oracle.check` and `Oracle.check_query` has been added to Sophia.
|
||||
- A byte array type `bytes(N)` has been added to generalize `hash (== bytes(32))` and
|
||||
`signature (== bytes(64))` and allow for byte arrays of arbitrary fixed length.
|
||||
- `Crypto.ecverify_secp256k1` has been added.
|
||||
### Changed
|
||||
- Address literals (+ Oracle, Oracle query and remote contracts) have been changed
|
||||
from `#<hex>` to address as `ak_<base58check>`, oracle `ok_<base58check>`,
|
||||
oracle query `oq_<base58check>` and remote contract `ct_<base58check>`.
|
||||
- The compilation and typechecking of `letfun` (e.g. `let m(f, xs) = map(f, xs)`) was
|
||||
not working properly and has been fixed.
|
||||
### Removed
|
||||
- `let rec` has been removed from the language, it has never worked.
|
||||
- The standalone CLI compiler is served in the repo `aeternity/aesophia_cli` and has
|
||||
been completely removed from `aesophia`.
|
||||
|
||||
## [2.1.0] - 2019-04-11
|
||||
### Added
|
||||
- Stubs (not yet wired up) for compilation to FATE
|
||||
- Add functions specific for Calldata decoding
|
||||
- Support for `Auth.tx_hash`, not available in AEVM until Fortuna release
|
||||
|
||||
### Changed
|
||||
- Improvements to the ACI generator
|
||||
|
||||
## [2.0.0] - 2019-03-11
|
||||
### Added
|
||||
- Add `Crypto.ecverify` to the compiler.
|
||||
- Add `Crypto.sha3`, `Crypto.blake2`, `Crypto.sha256`, `String.blake2` and
|
||||
`String.sha256` to the compiler.
|
||||
- Add the `bits` type for working with bit fields in Sophia.
|
||||
- Add Namespaces to Sophia in order to simplify using library contracts, etc.
|
||||
- Add a missig type check on the `init` function - detects programmer errors earlier.
|
||||
- Add the ACI (Aeternity Contract Interface) generator.
|
||||
|
||||
### Changed
|
||||
- Use native bit shift operations in builtin functions, reducing gas cost.
|
||||
- Improve type checking of `record` fields - generates more understandable error messages.
|
||||
- Improved, more coherent, error messages.
|
||||
- Simplify calldata creation - instead of passing a compiled contract, simply
|
||||
pass a (stubbed) contract string.
|
||||
|
||||
[Unreleased]: https://github.com/aeternity/aesophia/compare/v3.0.0...HEAD
|
||||
[3.0.0]: https://github.com/aeternity/aesophia/compare/v2.1.0...v3.0.0
|
||||
[2.1.0]: https://github.com/aeternity/aesophia/compare/v2.0.0...v2.1.0
|
||||
[2.0.0]: https://github.com/aeternity/aesophia/tag/v2.0.0
|
||||
@@ -9,17 +9,8 @@ It is an OTP application written in Erlang and is by default included in
|
||||
also be included in other systems to compile contracts coded in sophia which
|
||||
can then be loaded into the æternity system.
|
||||
|
||||
## Versioning
|
||||
|
||||
`aesophia` has a version that is only loosely connected to the version of the
|
||||
Aeternity node - in principle they will share the major version but not
|
||||
minor/patch version. The `aesophia` compiler version MUST be bumped whenever
|
||||
there is a change in how byte code is generated, but it MAY also be bumped upon
|
||||
API changes etc.
|
||||
|
||||
## Interface Modules
|
||||
|
||||
The basic modules for interfacing the compiler:
|
||||
|
||||
* [aeso_compiler: the Sophia compiler](./docs/aeso_compiler.md)
|
||||
* [aeso_aci: the ACI interface](./docs/aeso_aci.md)
|
||||
|
||||
@@ -1,135 +0,0 @@
|
||||
# aeso_aci
|
||||
|
||||
### Module
|
||||
|
||||
### aeso_aci
|
||||
|
||||
The ACI interface encoder and decoder.
|
||||
|
||||
### Description
|
||||
|
||||
This module provides an interface to generate and convert between
|
||||
Sophia contracts and a suitable JSON encoding of contract
|
||||
interface. As yet the interface is very basic.
|
||||
|
||||
Encoding this contract:
|
||||
|
||||
```
|
||||
contract Answers =
|
||||
record state = { a : answers }
|
||||
type answers() = map(string, int)
|
||||
|
||||
stateful function init() = { a = {} }
|
||||
private function the_answer() = 42
|
||||
function new_answer(q : string, a : int) : answers() = { [q] = a }
|
||||
```
|
||||
|
||||
generates the following JSON structure representing the contract interface:
|
||||
|
||||
|
||||
``` json
|
||||
{
|
||||
"contract": {
|
||||
"name": "Answers",
|
||||
"type_defs": [
|
||||
{
|
||||
"name": "state",
|
||||
"vars": [],
|
||||
"typedef": "{a : map(string,int)}"
|
||||
},
|
||||
{
|
||||
"name": "answers",
|
||||
"vars": [],
|
||||
"typedef": "map(string,int)"
|
||||
}
|
||||
],
|
||||
"functions": [
|
||||
{
|
||||
"name": "init",
|
||||
"arguments": [],
|
||||
"type": "{a : map(string,int)}",
|
||||
"stateful": true
|
||||
},
|
||||
{
|
||||
"name": "new_answer",
|
||||
"arguments": [
|
||||
{
|
||||
"name": "q",
|
||||
"type": "string"
|
||||
},
|
||||
{
|
||||
"name": "a",
|
||||
"type": "int"
|
||||
}
|
||||
],
|
||||
"type": "map(string,int)",
|
||||
"stateful": false
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
When that encoding is decoded the following include definition is generated:
|
||||
|
||||
```
|
||||
contract Answers =
|
||||
function new_answer : (string, int) => map(string,int)
|
||||
```
|
||||
|
||||
### Types
|
||||
``` erlang
|
||||
contract_string() = string() | binary()
|
||||
json_string() = binary()
|
||||
```
|
||||
|
||||
### Exports
|
||||
|
||||
#### encode(ContractString) -> {ok,JSONstring} | {error,ErrorString}
|
||||
|
||||
Types
|
||||
|
||||
``` erlang
|
||||
ConstractString = contract_string()
|
||||
JSONstring = json_string()
|
||||
```
|
||||
|
||||
Generate the JSON encoding of the interface to a contract. The type definitions and non-private functions are included in the JSON string.
|
||||
|
||||
#### decode(JSONstring) -> ConstractString.
|
||||
|
||||
Types
|
||||
|
||||
``` erlang
|
||||
ConstractString = contract_string()
|
||||
JSONstring = json_string()
|
||||
```
|
||||
|
||||
Take a JSON encoding of a contract interface and generate and generate a contract definition which can be included in another contract.
|
||||
|
||||
### 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.
|
||||
|
||||
``` erlang
|
||||
1> {ok,Contract} = file:read_file("aci_test.aes").
|
||||
{ok,<<"contract Answers =\n record state = { a : answers }\n type answers() = map(string, int)\n\n stateful function"...>>}
|
||||
2> {ok,Encoding} = aeso_aci:encode(Contract).
|
||||
<<"{\"contract\":{\"name\":\"Answers\",\"type_defs\":[{\"name\":\"state\",\"vars\":[],\"typedef\":\"{a : map(string,int)}\"},{\"name\":\"ans"...>>
|
||||
3> file:write_file("aci_test.aci", Encoding).
|
||||
ok
|
||||
4> Decoded = aeso_aci:decode(Encoding).
|
||||
<<"contract Answers =\n function new_answer : (string, int) => map(string,int)\n">>
|
||||
5> file:write_file("aci_test.include", Decoded).
|
||||
ok
|
||||
6> jsx:prettify(Encoding).
|
||||
<<"{\n \"contract\": {\n \"name\": \"Answers\",\n \"type_defs\": [\n {\n \"name\": \"state\",\n \"vars\": [],\n "...>>
|
||||
```
|
||||
|
||||
The final call to `jsx:prettify(Encoding)` returns the encoding in a
|
||||
more easily readable form. This is what is shown in the description
|
||||
above.
|
||||
|
||||
### Notes
|
||||
|
||||
The ACI generator currently cannot properly handle types defined using `datatype`.
|
||||
@@ -15,7 +15,7 @@ returns the compiled module in a map which can then be loaded.
|
||||
``` erlang
|
||||
contract_string() = string() | binary()
|
||||
contract_map() = #{bytecode => binary(),
|
||||
compiler_version => binary(),
|
||||
compiler_version => string(),
|
||||
contract_souce => string(),
|
||||
type_info => type_info()}
|
||||
type_info()
|
||||
@@ -75,12 +75,12 @@ Types
|
||||
|
||||
Get the type representation of a type declaration.
|
||||
|
||||
#### version() -> {ok, Version} | {error, term()}
|
||||
#### version() -> Version
|
||||
|
||||
Types
|
||||
|
||||
``` erlang
|
||||
Version = binary()
|
||||
Version = integer()
|
||||
```
|
||||
|
||||
Get the current version of the Sophia compiler.
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
|
||||
-record(pmap, {key_t :: aeso_sophia:type(),
|
||||
val_t :: aeso_sophia:type(),
|
||||
parent :: none | non_neg_integer(),
|
||||
size = 0 :: non_neg_integer(),
|
||||
data :: #{aeso_heap:binary_value() => aeso_heap:binary_value() | tombstone}
|
||||
| stored}).
|
||||
|
||||
-record(maps, { maps = #{} :: #{ non_neg_integer() => #pmap{} }
|
||||
, next_id = 0 :: non_neg_integer() }).
|
||||
|
||||
-record(heap, { maps :: #maps{},
|
||||
offset :: aeso_heap:offset(),
|
||||
heap :: binary() | #{non_neg_integer() => non_neg_integer()} }).
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
%%% File : aeso_heap_eqc.erl
|
||||
%%% Author : Ulf Norell
|
||||
%%% Description :
|
||||
%%% Created : 28 May 2018 by Ulf Norell
|
||||
-module(aeso_heap_eqc).
|
||||
|
||||
-compile([export_all, nowarn_export_all]).
|
||||
-include_lib("eqc/include/eqc.hrl").
|
||||
|
||||
-define(SANDBOX(Code), sandbox(fun() -> Code end)).
|
||||
|
||||
sandbox(Code) ->
|
||||
Parent = self(),
|
||||
Tag = make_ref(),
|
||||
{Pid, Ref} = spawn_monitor(fun() -> Parent ! {Tag, Code()} end),
|
||||
receive
|
||||
{Tag, Res} -> erlang:demonitor(Ref, [flush]), {ok, Res};
|
||||
{'DOWN', Ref, process, Pid, Reason} -> {error, Reason}
|
||||
after 100 ->
|
||||
exit(Pid, kill),
|
||||
{error, loop}
|
||||
end.
|
||||
|
||||
prop_from_binary() ->
|
||||
?FORALL({T, Bin}, {type(), blob()},
|
||||
begin
|
||||
Tag = fun(X) when is_atom(X) -> X; (X) when is_tuple(X) -> element(1, X) end,
|
||||
case ?SANDBOX(aeso_heap:from_binary(T, Bin)) of
|
||||
{ok, Res} -> collect({Tag(T), element(1, Res)}, true);
|
||||
Err -> equals(Err, {ok, '_'})
|
||||
end end).
|
||||
|
||||
type() -> ?LET(Depth, choose(0, 2), type(Depth, true)).
|
||||
type(Depth, TypeRep) ->
|
||||
oneof(
|
||||
[ elements([word, string] ++ [typerep || TypeRep]) ] ++
|
||||
[ ?LETSHRINK([T], [type(Depth - 1, TypeRep)], {list, T}) || Depth > 0 ] ++
|
||||
[ ?LETSHRINK([T], [type(Depth - 1, TypeRep)], {option, T}) || Depth > 0 ] ++
|
||||
[ ?LETSHRINK(Ts, list(type(Depth - 1, TypeRep)), {tuple, Ts}) || Depth > 0 ] ++
|
||||
[ ?LETSHRINK([K, V], vector(2, type(Depth - 1, TypeRep)), {map, K, V}) || Depth > 0 ] ++
|
||||
[]
|
||||
).
|
||||
|
||||
blob() ->
|
||||
?LET(Blobs, list(oneof([ ?LET(Ws, words(), return(from_words(Ws)))
|
||||
, binary() ])),
|
||||
return(list_to_binary(Blobs))).
|
||||
|
||||
words() -> list(word()).
|
||||
word() ->
|
||||
frequency(
|
||||
[ {4, ?LET(N, nat(), 32 * N)}
|
||||
, {1, choose(0, 320)}
|
||||
, {2, -1}
|
||||
, {2, elements(["foo", "zzzzz"])} ]).
|
||||
|
||||
from_words(Ws) ->
|
||||
<< <<(from_word(W))/binary>> || W <- Ws >>.
|
||||
|
||||
from_word(W) when is_integer(W) ->
|
||||
<<W:256>>;
|
||||
from_word(S) when is_list(S) ->
|
||||
Len = length(S),
|
||||
Bin = <<(list_to_binary(S))/binary, 0:(32 - Len)/unit:8>>,
|
||||
<<Len:256, Bin/binary>>.
|
||||
|
||||
typerep() -> ?LET(Depth, choose(0, 2),
|
||||
?LET(T, type(Depth, true), return(typerep(T)))).
|
||||
|
||||
typerep(word) -> word;
|
||||
typerep(string) -> string;
|
||||
typerep(typerep) -> typerep;
|
||||
typerep({tuple, Ts}) -> {tuple, typerep(Ts)};
|
||||
typerep({list, T}) -> {list, typerep(T)};
|
||||
typerep({variant, Cs}) -> {variant, typerep(Cs)};
|
||||
typerep({option, T}) -> {variant, [[], [typerep(T)]]};
|
||||
typerep({map, K, V}) -> {list, typerep({tuple, [K, V]})};
|
||||
typerep([]) -> [];
|
||||
typerep([T | Ts]) -> [typerep(T) | typerep(Ts)].
|
||||
|
||||
value(word) ->
|
||||
<<N:256>> = <<(-1):256>>,
|
||||
choose(0, N);
|
||||
value(string) ->
|
||||
?LET(N, choose(0, 128), binary(N));
|
||||
value(typerep) ->
|
||||
typerep();
|
||||
value({list, T}) ->
|
||||
list(value(T));
|
||||
value({option, T}) ->
|
||||
weighted_default({1, none}, {3, {some, value(T)}});
|
||||
value({tuple, Ts}) ->
|
||||
?LET(Vs, [ value(T) || T <- Ts ], list_to_tuple(Vs));
|
||||
value({map, K, V}) ->
|
||||
map(value(K), value(V));
|
||||
value({variant, Cs}) ->
|
||||
?LET(I, choose(0, length(Cs) - 1),
|
||||
{variant, I, [ value(T) || T <- lists:nth(I + 1, Cs) ]}).
|
||||
|
||||
typed_val() ->
|
||||
?LET(T, type(), ?LET(V, value(T), return({T, V}))).
|
||||
|
||||
prop_roundtrip() ->
|
||||
?FORALL(T, type(),
|
||||
?FORALL(V, value(T),
|
||||
?FORALL(B, choose(0, 4),
|
||||
equals(aeso_heap:from_binary(T, aeso_heap:to_binary(V, B * 32), B * 32),
|
||||
{ok, V})))).
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
%%% File : aeso_utils_eqc.erl
|
||||
%%% Author : Ulf Norell
|
||||
%%% Description :
|
||||
%%% Created : 2 Jul 2018 by Ulf Norell
|
||||
-module(aeso_utils_eqc).
|
||||
|
||||
-compile([export_all, nowarn_export_all]).
|
||||
|
||||
-include_lib("eqc/include/eqc.hrl").
|
||||
|
||||
%% QuickCheck property
|
||||
|
||||
graph() ->
|
||||
?LET(M, map(choose(0, 10), list(choose(0, 10))),
|
||||
return(complete(M))).
|
||||
|
||||
complete(G) ->
|
||||
Is = lists:usort(lists:concat(maps:values(G))),
|
||||
maps:merge(maps:from_list([ {I, []} || I <- Is ]), G).
|
||||
|
||||
prop_scc() ->
|
||||
?FORALL(G, graph(),
|
||||
begin
|
||||
SCCs = aeso_utils:scc(G),
|
||||
BadSCC = fun({acyclic, I}) -> reachable_from(G, I, I);
|
||||
({cyclic, Is}) -> [] /= [ {I, J} || I <- Is, J <- Is, not reachable_from(G, I, J) ]
|
||||
end,
|
||||
ToList = fun({acyclic, I}) -> [I];
|
||||
({cyclic, Is}) -> Is end,
|
||||
?WHENFAIL(eqc:format("SCCs = ~p\n", [SCCs]),
|
||||
conjunction(
|
||||
[ {elems, equals(lists:sort(lists:flatmap(ToList, SCCs)), lists:sort(maps:keys(G)))}
|
||||
, {sorted, equals([], [ {I, J} || {I, Js} <- maps:to_list(G),
|
||||
J <- Js,
|
||||
find_component(I, SCCs) < find_component(J, SCCs) ])}
|
||||
, {precise, equals([], [ SCC || SCC <- SCCs, BadSCC(SCC) ])}
|
||||
]))
|
||||
end).
|
||||
|
||||
reachable_from(Graph, I, J) ->
|
||||
reachable_from1(Graph, maps:get(I, Graph, []), J).
|
||||
|
||||
reachable_from1(_, [], _) -> false;
|
||||
reachable_from1(_, [I | _], I) -> true;
|
||||
reachable_from1(Graph, [I | Is], J) ->
|
||||
case maps:get(I, Graph, undefined) of
|
||||
undefined -> reachable_from1(Graph, Is, J);
|
||||
Js -> reachable_from1(maps:remove(I, Graph), Js ++ Is, J)
|
||||
end.
|
||||
|
||||
find_component(X, SCCs) ->
|
||||
ISCCs = lists:zip(SCCs, lists:seq(1, length(SCCs))),
|
||||
HasX = fun({acyclic, Y}) -> X == Y;
|
||||
({cyclic, Ys}) -> lists:member(X, Ys) end,
|
||||
case [ I || {SCC, I} <- ISCCs, HasX(SCC) ] of
|
||||
[I | _] -> I;
|
||||
[] -> false
|
||||
end.
|
||||
|
||||
+23
-13
@@ -1,24 +1,34 @@
|
||||
%% -*- mode: erlang; indent-tabs-mode: nil -*-
|
||||
|
||||
{erl_opts, [debug_info]}.
|
||||
|
||||
{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git",
|
||||
{ref, "2f4e188"}}}
|
||||
{ref,"720510a"}}}
|
||||
, {getopt, "1.0.1"}
|
||||
, {jsx, {git, "https://github.com/talentdeficit/jsx.git",
|
||||
{tag, "2.8.0"}}}
|
||||
]}.
|
||||
|
||||
|
||||
{profiles, [ {eqc, [{erl_opts, [{parse_transform, eqc_cover}]},
|
||||
{deps, [{eqc_ci, "1.0.0"}]},
|
||||
{extra_src_dirs, ["quickcheck"]} %% May not be called eqc!
|
||||
]}
|
||||
]}.
|
||||
|
||||
{escript_incl_apps, [aesophia, aebytecode, getopt]}.
|
||||
{escript_main_app, aesophia}.
|
||||
{escript_name, aesophia}.
|
||||
{escript_emu_args, "%%! +sbtu +A0\n"}.
|
||||
{provider_hooks, [{post, [{compile, escriptize}]}]}.
|
||||
|
||||
{post_hooks, [{"(linux|darwin|solaris|freebsd|netbsd|openbsd)",
|
||||
escriptize,
|
||||
"cp \"$REBAR_BUILD_DIR/bin/aesophia\" ./aesophia"},
|
||||
{"win32",
|
||||
escriptize,
|
||||
"robocopy \"%REBAR_BUILD_DIR%/bin/\" ./ aesophia* "
|
||||
"/njs /njh /nfl /ndl & exit /b 0"} % silence things
|
||||
]}.
|
||||
|
||||
{dialyzer, [
|
||||
{warnings, [unknown]},
|
||||
{plt_apps, all_deps},
|
||||
{base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
|
||||
]}.
|
||||
|
||||
{relx, [{release, {aesophia, "3.0.0"},
|
||||
[aesophia, aebytecode, getopt]},
|
||||
|
||||
{dev_mode, true},
|
||||
{include_erts, false},
|
||||
|
||||
{extended_start_script, true}]}.
|
||||
|
||||
+2
-16
@@ -1,24 +1,10 @@
|
||||
{"1.1.0",
|
||||
[{<<"aebytecode">>,
|
||||
{git,"https://github.com/aeternity/aebytecode.git",
|
||||
{ref,"2f4e1888c241a7347ffec855ab6761c2c2972f37"}},
|
||||
{ref,"720510a24de32c9bad6486f34ca7babde124bf1e"}},
|
||||
0},
|
||||
{<<"aeserialization">>,
|
||||
{git,"https://github.com/aeternity/aeserialization.git",
|
||||
{ref,"816bf994ffb5cee218c3f22dc5fea296c9e0882e"}},
|
||||
1},
|
||||
{<<"base58">>,
|
||||
{git,"https://github.com/aeternity/erl-base58.git",
|
||||
{ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
|
||||
2},
|
||||
{<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},1},
|
||||
{<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
|
||||
{<<"jsx">>,
|
||||
{git,"https://github.com/talentdeficit/jsx.git",
|
||||
{ref,"3074d4865b3385a050badf7828ad31490d860df5"}},
|
||||
0}]}.
|
||||
{<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0}]}.
|
||||
[
|
||||
{pkg_hash,[
|
||||
{<<"eblake2">>, <<"EC8AD20E438AAB3F2E8D5D118C366A0754219195F8A0F536587440F8F9BCF2EF">>},
|
||||
{<<"getopt">>, <<"C73A9FA687B217F2FF79F68A3B637711BB1936E712B521D8CE466B29CBF7808A">>}]}
|
||||
].
|
||||
|
||||
@@ -0,0 +1,239 @@
|
||||
%%%-------------------------------------------------------------------
|
||||
%%% @copyright (C) 2017, Aeternity Anstalt
|
||||
%%% @doc
|
||||
%%% Encode and decode data and function calls according to
|
||||
%%% Sophia-AEVM-ABI.
|
||||
%%% @end
|
||||
%%% Created : 25 Jan 2018
|
||||
%%%
|
||||
%%%-------------------------------------------------------------------
|
||||
-module(aeso_abi).
|
||||
-define(HASH_SIZE, 32).
|
||||
|
||||
-export([ old_create_calldata/3
|
||||
, create_calldata/5
|
||||
, 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() :: aeso_sophia: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(Contract, FunName, Args, ArgTypes, RetType) ->
|
||||
case get_type_info_and_hash(Contract, FunName) of
|
||||
{ok, TypeInfo, TypeHashInt} ->
|
||||
Data = aeso_heap:to_binary({TypeHashInt, list_to_tuple(Args)}),
|
||||
case check_calldata(Data, TypeInfo) of
|
||||
{ok, CallDataType, OutType} ->
|
||||
case check_given_type(FunName, ArgTypes, RetType, CallDataType, OutType) of
|
||||
ok ->
|
||||
{ok, Data, CallDataType, OutType};
|
||||
{error, _} = Err ->
|
||||
Err
|
||||
end;
|
||||
{error,_What} = Err -> Err
|
||||
end;
|
||||
{error, _} = Err -> Err
|
||||
end.
|
||||
|
||||
get_type_info_and_hash(#{type_info := TypeInfo}, FunName) ->
|
||||
FunBin = list_to_binary(FunName),
|
||||
case type_hash_from_function_name(FunBin, TypeInfo) of
|
||||
{ok, <<TypeHashInt:?HASH_SIZE/unit:8>>} -> {ok, TypeInfo, TypeHashInt};
|
||||
{ok, _} -> {error, bad_type_hash};
|
||||
{error, _} = Err -> Err
|
||||
end.
|
||||
|
||||
%% Check that the given type matches the type from the metadata.
|
||||
check_given_type(FunName, GivenArgs, GivenRet, CalldataType, ExpectRet) ->
|
||||
{tuple, [word, {tuple, ExpectArgs}]} = CalldataType,
|
||||
ReturnOk = if FunName == "init" -> true;
|
||||
GivenRet == any -> true;
|
||||
true -> GivenRet == ExpectRet
|
||||
end,
|
||||
ArgsOk = ExpectArgs == GivenArgs,
|
||||
case ReturnOk andalso ArgsOk of
|
||||
true -> ok;
|
||||
false when FunName == "init" ->
|
||||
{error, {init_args_mismatch,
|
||||
{given, GivenArgs},
|
||||
{expected, ExpectArgs}}};
|
||||
false ->
|
||||
{error, {call_type_mismatch,
|
||||
{given, GivenArgs, '=>', GivenRet},
|
||||
{expected, ExpectArgs, '=>', ExpectRet}}}
|
||||
end.
|
||||
|
||||
-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 aeso_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 aeso_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, Args, OutType) ->
|
||||
ArgType = {tuple, [T || {_, T} <- Args]},
|
||||
{ function_type_hash(Name, ArgType, OutType)
|
||||
, Name
|
||||
, aeso_heap:to_binary(ArgType)
|
||||
, aeso_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
|
||||
, aeso_heap:to_binary(ArgType)
|
||||
, aeso_heap:to_binary(OutType)
|
||||
]),
|
||||
%% Calculate a 256 bit digest BLAKE2b hash value of a binary
|
||||
{ok, Hash} = aeso_blake2: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 aeso_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 {aeso_heap:from_binary(typerep, ArgTypeBin),
|
||||
aeso_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.
|
||||
|
||||
%% -- Old calldata creation. Kept for backwards compatibility. ---------------
|
||||
|
||||
old_create_calldata(Contract, Function, Argument) when is_map(Contract) ->
|
||||
case aeso_constants:string(Argument) of
|
||||
{ok, {tuple, _, _} = Tuple} ->
|
||||
old_encode_call(Contract, Function, Tuple);
|
||||
{ok, {unit, _} = Tuple} ->
|
||||
old_encode_call(Contract, Function, Tuple);
|
||||
{ok, ParsedArgument} ->
|
||||
%% The Sophia compiler does not parse a singleton tuple (42) as a tuple,
|
||||
%% Wrap it in a tuple.
|
||||
old_encode_call(Contract, Function, {tuple, [], [ParsedArgument]});
|
||||
{error, _} ->
|
||||
{error, argument_syntax_error}
|
||||
end.
|
||||
|
||||
%% Call takes one arument.
|
||||
%% Use a tuple to pass multiple arguments.
|
||||
old_encode_call(Contract, Function, ArgumentAst) ->
|
||||
Argument = old_ast_to_erlang(ArgumentAst),
|
||||
case get_type_info_and_hash(Contract, Function) of
|
||||
{ok, TypeInfo, TypeHashInt} ->
|
||||
Data = aeso_heap:to_binary({TypeHashInt, Argument}),
|
||||
case check_calldata(Data, TypeInfo) of
|
||||
{ok, CallDataType, OutType} ->
|
||||
{ok, Data, CallDataType, OutType};
|
||||
{error, _} = Err ->
|
||||
Err
|
||||
end;
|
||||
{error, _} = Err -> Err
|
||||
end.
|
||||
|
||||
old_ast_to_erlang({int, _, N}) -> N;
|
||||
old_ast_to_erlang({hash, _, <<N:?HASH_SIZE/unit:8>>}) -> N;
|
||||
old_ast_to_erlang({hash, _, <<Hi:256, Lo:256>>}) -> {Hi, Lo}; %% signature
|
||||
old_ast_to_erlang({bool, _, true}) -> 1;
|
||||
old_ast_to_erlang({bool, _, false}) -> 0;
|
||||
old_ast_to_erlang({string, _, Bin}) -> Bin;
|
||||
old_ast_to_erlang({unit, _}) -> {};
|
||||
old_ast_to_erlang({con, _, "None"}) -> none;
|
||||
old_ast_to_erlang({app, _, {con, _, "Some"}, [A]}) -> {some, old_ast_to_erlang(A)};
|
||||
old_ast_to_erlang({tuple, _, Elems}) ->
|
||||
list_to_tuple(lists:map(fun old_ast_to_erlang/1, Elems));
|
||||
old_ast_to_erlang({list, _, Elems}) ->
|
||||
lists:map(fun old_ast_to_erlang/1, Elems);
|
||||
old_ast_to_erlang({map, _, Elems}) ->
|
||||
maps:from_list([ {old_ast_to_erlang(element(1, Elem)), old_ast_to_erlang(element(2, Elem))}
|
||||
|| Elem <- Elems ]).
|
||||
|
||||
@@ -1,396 +0,0 @@
|
||||
%%%-------------------------------------------------------------------
|
||||
%%% @author Robert Virding
|
||||
%%% @copyright (C) 2019, Aeternity Anstalt
|
||||
%%% @doc
|
||||
%%% ACI interface
|
||||
%%% @end
|
||||
%%% Created : 12 Jan 2019
|
||||
%%%-------------------------------------------------------------------
|
||||
|
||||
-module(aeso_aci).
|
||||
|
||||
-export([encode/1,encode/2,decode/1]).
|
||||
-export([encode_type/1,encode_stmt/1,encode_expr/1]).
|
||||
|
||||
%% Define records for the various typed syntactic forms. These make
|
||||
%% the code easier but don't seem to exist elsewhere.
|
||||
|
||||
%% Top-level
|
||||
-record(contract, {ann,con,decls}).
|
||||
%% -record(namespace, {ann,con,decls}).
|
||||
-record(letfun, {ann,id,args,type,body}).
|
||||
-record(type_def, {ann,id,vars,typedef}).
|
||||
|
||||
%% Types
|
||||
-record(app_t, {ann,id,fields}).
|
||||
-record(tuple_t, {ann,args}).
|
||||
-record(bytes_t, {ann,len}).
|
||||
-record(record_t, {fields}).
|
||||
-record(field_t, {ann,id,type}).
|
||||
-record(alias_t, {type}).
|
||||
-record(variant_t, {cons}).
|
||||
-record(constr_t, {ann,con,args}).
|
||||
-record(fun_t, {ann,named,args,type}).
|
||||
|
||||
%% Tokens
|
||||
-record(arg, {ann,id,type}).
|
||||
-record(id, {ann,name}).
|
||||
-record(con, {ann,name}).
|
||||
-record(qid, {ann,names}).
|
||||
-record(qcon, {ann,names}).
|
||||
-record(tvar, {ann,name}).
|
||||
|
||||
%% Expressions
|
||||
-record(bool, {ann,bool}).
|
||||
-record(int, {ann,value}).
|
||||
-record(string, {ann,bin}).
|
||||
-record(bytes, {ann,bin}).
|
||||
-record(tuple, {ann,args}).
|
||||
-record(list, {ann,args}).
|
||||
-record(app, {ann,func,args}).
|
||||
-record(typed, {ann,expr,type}).
|
||||
|
||||
%% encode(ContractString) -> {ok,JSON} | {error,String}.
|
||||
%% encode(ContractString, Options) -> {ok,JSON} | {error,String}.
|
||||
%% Build a JSON structure with lists and tuples, not maps, as this
|
||||
%% allows us to order the fields in the contructed JSON string.
|
||||
|
||||
encode(ContractString) -> encode(ContractString, []).
|
||||
|
||||
encode(ContractString, Options) when is_binary(ContractString) ->
|
||||
encode(binary_to_list(ContractString), Options);
|
||||
encode(ContractString, Options) ->
|
||||
try
|
||||
Ast = parse(ContractString, Options),
|
||||
%% io:format("~p\n", [Ast]),
|
||||
%% aeso_ast:pp(Ast),
|
||||
TypedAst = aeso_ast_infer_types:infer(Ast, Options),
|
||||
%% io:format("~p\n", [TypedAst]),
|
||||
%% aeso_ast:pp_typed(TypedAst),
|
||||
%% We find and look at the last contract.
|
||||
Contract = lists:last(TypedAst),
|
||||
Cname = contract_name(Contract),
|
||||
Tdefs = [ encode_typedef(T) ||
|
||||
T <- sort_decls(contract_types(Contract)) ],
|
||||
Fdefs = [ encode_func(F) || F <- sort_decls(contract_funcs(Contract)),
|
||||
not is_private_func(F) ],
|
||||
Jmap = [{<<"contract">>, [{<<"name">>, encode_name(Cname)},
|
||||
{<<"type_defs">>, Tdefs},
|
||||
{<<"functions">>, Fdefs}]}],
|
||||
%% io:format("~p\n", [Jmap]),
|
||||
{ok,jsx:encode(Jmap)}
|
||||
catch
|
||||
%% The compiler errors.
|
||||
error:{parse_errors, Errors} ->
|
||||
{error, join_errors("Parse errors", Errors, fun(E) -> E end)};
|
||||
error:{type_errors, Errors} ->
|
||||
{error, join_errors("Type errors", Errors, fun(E) -> E end)};
|
||||
error:{code_errors, Errors} ->
|
||||
{error, join_errors("Code errors", Errors,
|
||||
fun (E) -> io_lib:format("~p", [E]) end)}
|
||||
%% General programming errors in the compiler just signal error.
|
||||
end.
|
||||
|
||||
join_errors(Prefix, Errors, Pfun) ->
|
||||
Ess = [ Pfun(E) || E <- Errors ],
|
||||
list_to_binary(string:join([Prefix|Ess], "\n")).
|
||||
|
||||
%% encode_func(Function) -> JSON
|
||||
%% Encode a function definition. Currently we are only interested in
|
||||
%% the interface and type.
|
||||
|
||||
encode_func(Fdef) ->
|
||||
Name = function_name(Fdef),
|
||||
Args = function_args(Fdef),
|
||||
Type = function_type(Fdef),
|
||||
[{<<"name">>, encode_name(Name)},
|
||||
{<<"arguments">>, encode_args(Args)},
|
||||
{<<"returns">>, encode_type(Type)},
|
||||
{<<"stateful">>, is_stateful_func(Fdef)}].
|
||||
|
||||
%% encode_args(Args) -> [JSON].
|
||||
%% encode_arg(Args) -> JSON.
|
||||
|
||||
encode_args(Args) ->
|
||||
[ encode_arg(A) || A <- Args ].
|
||||
|
||||
encode_arg(#arg{id=Id,type=T}) ->
|
||||
[{<<"name">>,encode_type(Id)},
|
||||
{<<"type">>,[encode_type(T)]}].
|
||||
|
||||
%% encode_types(Types) -> [JSON].
|
||||
%% encode_type(Type) -> JSON.
|
||||
|
||||
encode_types(Types) ->
|
||||
[ encode_type(T) || T <- Types ].
|
||||
|
||||
encode_type(#tvar{name=N}) -> encode_name(N);
|
||||
encode_type(#id{name=N}) -> encode_name(N);
|
||||
encode_type(#con{name=N}) -> encode_name(N);
|
||||
encode_type(#qid{names=Ns}) ->
|
||||
encode_name(lists:join(".", Ns));
|
||||
encode_type(#qcon{names=Ns}) ->
|
||||
encode_name(lists:join(".", Ns)); %?
|
||||
encode_type(#tuple_t{args=As}) ->
|
||||
Eas = encode_types(As),
|
||||
[{<<"tuple">>,Eas}];
|
||||
encode_type(#bytes_t{len=Len}) ->
|
||||
{<<"bytes">>, Len};
|
||||
encode_type(#record_t{fields=Fs}) ->
|
||||
Efs = encode_fields(Fs),
|
||||
[{<<"record">>,Efs}];
|
||||
encode_type(#app_t{id=Id,fields=Fs}) ->
|
||||
Name = encode_type(Id),
|
||||
Efs = encode_types(Fs),
|
||||
[{Name,Efs}];
|
||||
encode_type(#variant_t{cons=Cs}) ->
|
||||
Ecs = encode_types(Cs),
|
||||
[{<<"variant">>,Ecs}];
|
||||
encode_type(#constr_t{con=C,args=As}) ->
|
||||
Ec = encode_type(C),
|
||||
Eas = encode_types(As),
|
||||
[{Ec,Eas}];
|
||||
encode_type(#fun_t{args=As,type=T}) ->
|
||||
Eas = encode_types(As),
|
||||
Et = encode_type(T),
|
||||
[{<<"function">>,[{<<"arguments">>,Eas},{<<"returns">>,Et}]}].
|
||||
|
||||
encode_name(Name) ->
|
||||
list_to_binary(Name).
|
||||
|
||||
%% encode_fields(Fields) -> [JSON].
|
||||
%% encode_field(Field) -> JSON.
|
||||
%% Encode a record field.
|
||||
|
||||
encode_fields(Fs) ->
|
||||
[ encode_field(F) || F <- Fs ].
|
||||
|
||||
encode_field(#field_t{id=Id,type=T}) ->
|
||||
[{<<"name">>,encode_type(Id)},
|
||||
{<<"type">>,[encode_type(T)]}].
|
||||
|
||||
%% encode_typedef(TypeDef) -> JSON.
|
||||
|
||||
encode_typedef(Type) ->
|
||||
Name = typedef_name(Type),
|
||||
Vars = typedef_vars(Type),
|
||||
Def = typedef_def(Type),
|
||||
[{<<"name">>, encode_name(Name)},
|
||||
{<<"vars">>, encode_tvars(Vars)},
|
||||
{<<"typedef">>, encode_alias(Def)}].
|
||||
|
||||
encode_tvars(Vars) ->
|
||||
[ encode_tvar(V) || V <- Vars ].
|
||||
|
||||
encode_tvar(#tvar{name=N}) ->
|
||||
[{<<"name">>, encode_name(N)}].
|
||||
|
||||
encode_alias(#alias_t{type=T}) ->
|
||||
encode_type(T);
|
||||
encode_alias(A) -> encode_type(A).
|
||||
|
||||
%% encode_stmt(Stmt) -> JSON.
|
||||
|
||||
encode_stmt(E) ->
|
||||
encode_expr(E).
|
||||
|
||||
%% encode_exprs(Exprs) -> [JSON].
|
||||
%% encode_expr(Expr) -> JSON.
|
||||
|
||||
encode_exprs(Es) ->
|
||||
[ encode_expr(E) || E <- Es ].
|
||||
|
||||
encode_expr(#id{name=N}) -> encode_name(N);
|
||||
encode_expr(#con{name=N}) -> encode_name(N);
|
||||
encode_expr(#qid{names=Ns}) ->
|
||||
encode_name(lists:join(".", Ns));
|
||||
encode_expr(#qcon{names=Ns}) ->
|
||||
encode_name(lists:join(".", Ns)); %?
|
||||
encode_expr(#typed{expr=E}) ->
|
||||
encode_expr(E);
|
||||
encode_expr(#bool{bool=B}) -> B;
|
||||
encode_expr(#int{value=V}) -> V;
|
||||
encode_expr(#string{bin=B}) -> B;
|
||||
encode_expr(#bytes{bin=B}) -> B;
|
||||
encode_expr(#tuple{args=As}) ->
|
||||
Eas = encode_exprs(As),
|
||||
[{<<"tuple">>,Eas}];
|
||||
encode_expr(#list{args=As}) ->
|
||||
Eas = encode_exprs(As),
|
||||
[{<<"list">>,Eas}];
|
||||
encode_expr(#app{func=F,args=As}) ->
|
||||
Ef = encode_expr(F),
|
||||
Eas = encode_exprs(As),
|
||||
[{<<"apply">>,[{<<"function">>,Ef},
|
||||
{<<"arguments">>,Eas}]}];
|
||||
encode_expr({Op,_Ann}) ->
|
||||
list_to_binary(atom_to_list(Op)).
|
||||
|
||||
%% decode(JSON) -> ContractString.
|
||||
%% Decode a JSON string and generate a suitable contract string which
|
||||
%% 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.
|
||||
|
||||
decode(Json) ->
|
||||
Map = jsx:decode(Json, [return_maps]),
|
||||
%% io:format("~p\n", [Map]),
|
||||
#{<<"contract">> := C} = Map,
|
||||
list_to_binary(decode_contract(C)).
|
||||
|
||||
decode_contract(#{<<"name">> := Name,
|
||||
<<"type_defs">> := Ts,
|
||||
<<"functions">> := Fs}) ->
|
||||
["contract"," ",io_lib:format("~s", [Name])," =\n",
|
||||
decode_tdefs(Ts),
|
||||
decode_funcs(Fs)].
|
||||
|
||||
decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
|
||||
|
||||
decode_func(#{<<"name">> := <<"init">>}) -> [];
|
||||
decode_func(#{<<"name">> := Name,<<"arguments">> := As,<<"returns">> := T}) ->
|
||||
[" function"," ",io_lib:format("~s", [Name])," : ",
|
||||
decode_args(As)," => ",decode_type(T),$\n].
|
||||
|
||||
decode_args(As) ->
|
||||
Das = [ decode_arg(A) || A <- As ],
|
||||
[$(,lists:join(", ", Das),$)].
|
||||
|
||||
decode_arg(#{<<"type">> := [T]}) -> decode_type(T).
|
||||
|
||||
decode_types(Ets) ->
|
||||
[ decode_type(Et) || Et <- Ets ].
|
||||
|
||||
decode_type(#{<<"tuple">> := Ets}) ->
|
||||
Ts = decode_types(Ets),
|
||||
[$(,lists:join(",", Ts),$)];
|
||||
decode_type(#{<<"record">> := Efs}) ->
|
||||
Fs = decode_fields(Efs),
|
||||
[${,lists:join(",", Fs),$}];
|
||||
decode_type(#{<<"list">> := [Et]}) ->
|
||||
T = decode_type(Et),
|
||||
["list",$(,T,$)];
|
||||
decode_type(#{<<"map">> := Ets}) ->
|
||||
Ts = decode_types(Ets),
|
||||
["map",$(,lists:join(",", Ts),$)];
|
||||
decode_type(#{<<"variant">> := Ets}) ->
|
||||
Ts = decode_types(Ets),
|
||||
lists:join(" | ", Ts);
|
||||
decode_type(Econs) when is_map(Econs) -> %General constructor
|
||||
[{Ec,Ets}] = maps:to_list(Econs),
|
||||
C = decode_name(Ec),
|
||||
Ts = decode_types(Ets),
|
||||
[C,$(,lists:join(",", Ts),$)];
|
||||
decode_type(T) -> %Just raw names.
|
||||
decode_name(T).
|
||||
|
||||
decode_name(En) ->
|
||||
binary_to_list(En).
|
||||
|
||||
decode_fields(Efs) ->
|
||||
[ decode_field(Ef) || Ef <- Efs ].
|
||||
|
||||
decode_field(#{<<"name">> := En,<<"type">> := [Et]}) ->
|
||||
Name = decode_name(En),
|
||||
Type = decode_type(Et),
|
||||
[Name," : ",Type].
|
||||
|
||||
%% decode_tdefs(Json) -> [TypeString].
|
||||
%% Here we are only interested in the type definitions and ignore the
|
||||
%% aliases. We find them as they always have variants.
|
||||
|
||||
decode_tdefs(Ts) -> [ decode_tdef(T) ||
|
||||
#{<<"typedef">> := #{<<"variant">> := _}} = T <- Ts
|
||||
].
|
||||
|
||||
decode_tdef(#{<<"name">> := Name,<<"vars">> := Vs,<<"typedef">> := T}) ->
|
||||
[" datatype"," ",decode_name(Name),decode_tvars(Vs),
|
||||
" = ",decode_type(T),$\n].
|
||||
|
||||
decode_tvars([]) -> []; %No tvars, no parentheses
|
||||
decode_tvars(Vs) ->
|
||||
Dvs = [ decode_tvar(V) || V <- Vs ],
|
||||
[$(,lists:join(", ", Dvs),$)].
|
||||
|
||||
decode_tvar(#{<<"name">> := N}) -> io_lib:format("~s", [N]).
|
||||
|
||||
%% #contract{Ann, Con, [Declarations]}.
|
||||
|
||||
contract_name(#contract{con=#con{name=N}}) -> N.
|
||||
|
||||
contract_funcs(#contract{decls=Decls}) ->
|
||||
[ D || D <- Decls, is_record(D, letfun) ].
|
||||
|
||||
contract_types(#contract{decls=Decls}) ->
|
||||
[ D || D <- Decls, is_record(D, type_def) ].
|
||||
|
||||
%% To keep dialyzer happy and quiet.
|
||||
%% namespace_name(#namespace{con=#con{name=N}}) -> N.
|
||||
%%
|
||||
%% namespace_funcs(#namespace{decls=Decls}) ->
|
||||
%% [ D || D <- Decls, is_record(D, letfun) ].
|
||||
%%
|
||||
%% namespace_types(#namespace{decls=Decls}) ->
|
||||
%% [ D || D <- Decls, is_record(D, type_def) ].
|
||||
|
||||
sort_decls(Ds) ->
|
||||
Sort = fun (D1, D2) ->
|
||||
aeso_syntax:get_ann(line, D1, 0) =<
|
||||
aeso_syntax:get_ann(line, D2, 0)
|
||||
end,
|
||||
lists:sort(Sort, Ds).
|
||||
|
||||
%% #letfun{Ann, Id, [Arg], Type, Typedef}.
|
||||
|
||||
function_name(#letfun{id=#id{name=N}}) -> N.
|
||||
|
||||
function_args(#letfun{args=Args}) -> Args.
|
||||
|
||||
function_type(#letfun{type=Type}) -> Type.
|
||||
|
||||
is_private_func(#letfun{ann=A}) -> aeso_syntax:get_ann(private, A, false).
|
||||
|
||||
is_stateful_func(#letfun{ann=A}) -> aeso_syntax:get_ann(stateful, A, false).
|
||||
|
||||
%% #type_def{Ann, Id, [Var], Typedef}.
|
||||
|
||||
typedef_name(#type_def{id=#id{name=N}}) -> N.
|
||||
|
||||
typedef_vars(#type_def{vars=Vars}) -> Vars.
|
||||
|
||||
typedef_def(#type_def{typedef=Def}) -> Def.
|
||||
|
||||
%% parse(ContractString, Options) -> {ok,AST}.
|
||||
%% Signal errors, the sophia compiler way. Sigh!
|
||||
|
||||
parse(Text, Options) ->
|
||||
%% Try and return something sensible here!
|
||||
case aeso_parser:string(Text, Options) of
|
||||
%% Yay, it worked!
|
||||
{ok, Contract} -> Contract;
|
||||
%% Scan errors.
|
||||
{error, {Pos, scan_error}} ->
|
||||
parse_error(Pos, "scan error");
|
||||
{error, {Pos, scan_error_no_state}} ->
|
||||
parse_error(Pos, "scan error");
|
||||
%% Parse errors.
|
||||
{error, {Pos, parse_error, Error}} ->
|
||||
parse_error(Pos, Error);
|
||||
{error, {Pos, ambiguous_parse, As}} ->
|
||||
ErrorString = io_lib:format("Ambiguous ~p", [As]),
|
||||
parse_error(Pos, ErrorString);
|
||||
%% Include error
|
||||
{error, {Pos, include_error, File}} ->
|
||||
parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
|
||||
end.
|
||||
|
||||
parse_error(Pos, ErrorString) ->
|
||||
%% io:format("Error ~p ~p\n", [Pos,ErrorString]),
|
||||
Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
|
||||
error({parse_errors, [Error]}).
|
||||
|
||||
pos_error({Line, Pos}) ->
|
||||
io_lib:format("line ~p, column ~p", [Line, Pos]);
|
||||
pos_error({no_file, Line, Pos}) ->
|
||||
pos_error({Line, Pos});
|
||||
pos_error({File, Line, Pos}) ->
|
||||
io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).
|
||||
@@ -17,6 +17,7 @@ line({symbol, Line, _}) -> Line.
|
||||
symbol_name({symbol, _, Name}) -> Name.
|
||||
|
||||
pp(Ast) ->
|
||||
%% io:format("Tree:\n~p\n",[Ast]),
|
||||
String = prettypr:format(aeso_pretty:decls(Ast, [])),
|
||||
io:format("Ast:\n~s\n", [String]).
|
||||
|
||||
|
||||
+534
-1059
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
+47
-161
@@ -17,19 +17,11 @@
|
||||
|
||||
-spec convert_typed(aeso_syntax:ast(), list()) -> aeso_icode:icode().
|
||||
convert_typed(TypedTree, Options) ->
|
||||
Name = case lists:last(TypedTree) of
|
||||
{contract, _, {con, _, Con}, _} -> Con;
|
||||
_ -> gen_error(last_declaration_must_be_contract)
|
||||
end,
|
||||
Icode = code(TypedTree, aeso_icode:set_name(Name, aeso_icode:new(Options))),
|
||||
deadcode_elimination(Icode).
|
||||
code(TypedTree, aeso_icode:new(Options)).
|
||||
|
||||
code([{contract, _Attribs, Con, Code}|Rest], Icode) ->
|
||||
NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Con, Icode)),
|
||||
code(Rest, NewIcode);
|
||||
code([{namespace, _Ann, Name, Code}|Rest], Icode) ->
|
||||
%% TODO: nested namespaces
|
||||
NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Name, Icode)),
|
||||
code([{contract, _Attribs, {con, _, Name}, Code}|Rest], Icode) ->
|
||||
NewIcode = contract_to_icode(Code,
|
||||
aeso_icode:set_name(Name, Icode)),
|
||||
code(Rest, NewIcode);
|
||||
code([], Icode) ->
|
||||
add_default_init_function(add_builtins(Icode)).
|
||||
@@ -41,38 +33,30 @@ gen_error(Error) ->
|
||||
|
||||
%% Create default init function (only if state is unit).
|
||||
add_default_init_function(Icode = #{functions := Funs, state_type := State}) ->
|
||||
{_, _, QInit} = aeso_icode:qualify({id, [], "init"}, Icode),
|
||||
case lists:keymember(QInit, 1, Funs) of
|
||||
case lists:keymember("init", 1, Funs) of
|
||||
true -> Icode;
|
||||
false when State /= {tuple, []} ->
|
||||
gen_error(missing_init_function);
|
||||
false when State /= {tuple, []} -> gen_error(missing_init_function);
|
||||
false ->
|
||||
Type = {tuple, [typerep, {tuple, []}]},
|
||||
Value = #tuple{ cpts = [type_value({tuple, []}), {tuple, []}] },
|
||||
DefaultInit = {QInit, [], [], Value, Type},
|
||||
DefaultInit = {"init", [], [], Value, Type},
|
||||
Icode#{ functions => [DefaultInit | Funs] }
|
||||
end.
|
||||
|
||||
-spec contract_to_icode(aeso_syntax:ast(), aeso_icode:icode()) ->
|
||||
aeso_icode:icode().
|
||||
contract_to_icode([{namespace, _, Name, Defs} | Rest], Icode) ->
|
||||
NS = aeso_icode:get_namespace(Icode),
|
||||
Icode1 = contract_to_icode(Defs, aeso_icode:enter_namespace(Name, Icode)),
|
||||
contract_to_icode(Rest, aeso_icode:set_namespace(NS, Icode1));
|
||||
contract_to_icode([{type_def, _Attrib, Id = {id, _, Name}, Args, Def} | Rest],
|
||||
contract_to_icode([{type_def, _Attrib, {id, _, Name}, Args, Def} | Rest],
|
||||
Icode = #{ types := Types, constructors := Constructors }) ->
|
||||
TypeDef = make_type_def(Args, Def, Icode),
|
||||
NewConstructors =
|
||||
case Def of
|
||||
{variant_t, Cons} ->
|
||||
Tags = lists:seq(0, length(Cons) - 1),
|
||||
GetName = fun({constr_t, _, C, _}) -> C end,
|
||||
QName = fun(Con) -> {_, _, Xs} = aeso_icode:qualify(GetName(Con), Icode), Xs end,
|
||||
maps:from_list([ {QName(Con), Tag} || {Tag, Con} <- lists:zip(Tags, Cons) ]);
|
||||
GetName = fun({constr_t, _, {con, _, C}, _}) -> C end,
|
||||
maps:from_list([ {GetName(Con), Tag} || {Tag, Con} <- lists:zip(Tags, Cons) ]);
|
||||
_ -> #{}
|
||||
end,
|
||||
{_, _, TName} = aeso_icode:qualify(Id, Icode),
|
||||
Icode1 = Icode#{ types := Types#{ TName => TypeDef },
|
||||
Icode1 = Icode#{ types := Types#{ Name => TypeDef },
|
||||
constructors := maps:merge(Constructors, NewConstructors) },
|
||||
Icode2 = case Name of
|
||||
"state" when Args == [] -> Icode1#{ state_type => ast_typerep(Def, Icode) };
|
||||
@@ -84,7 +68,8 @@ contract_to_icode([{type_def, _Attrib, Id = {id, _, Name}, Args, Def} | Rest],
|
||||
contract_to_icode(Rest, Icode2);
|
||||
contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest], Icode) ->
|
||||
FunAttrs = [ stateful || proplists:get_value(stateful, Attrib, false) ] ++
|
||||
[ private || is_private(Attrib, Icode) ],
|
||||
[ private || proplists:get_value(private, Attrib, false) orelse
|
||||
proplists:get_value(internal, Attrib, false) ],
|
||||
%% TODO: Handle types
|
||||
FunName = ast_id(Name),
|
||||
%% TODO: push funname to env
|
||||
@@ -99,18 +84,21 @@ contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest]
|
||||
{tuple, [typerep, ast_typerep(T, Icode)]}};
|
||||
_ -> {ast_body(Body, Icode), ast_typerep(T, Icode)}
|
||||
end,
|
||||
QName = aeso_icode:qualify(Name, Icode),
|
||||
NewIcode = ast_fun_to_icode(ast_id(QName), FunAttrs, FunArgs, FunBody, TypeRep, Icode),
|
||||
NewIcode = ast_fun_to_icode(FunName, FunAttrs, FunArgs, FunBody, TypeRep, Icode),
|
||||
contract_to_icode(Rest, NewIcode);
|
||||
contract_to_icode([{letrec,_,Defs}|Rest], Icode) ->
|
||||
%% OBS! This code ignores the letrec structure of the source,
|
||||
%% because the back end treats ALL declarations as recursive! We
|
||||
%% need to decide whether to (a) modify the back end to respect
|
||||
%% the letrec structure, or (b) (preferably) modify the front end
|
||||
%% just to parse a list of (mutually recursive) definitions.
|
||||
contract_to_icode(Defs++Rest, Icode);
|
||||
contract_to_icode([], Icode) -> Icode;
|
||||
contract_to_icode([{fun_decl, _, _, _} | Code], Icode) ->
|
||||
contract_to_icode(Code, Icode);
|
||||
contract_to_icode([Decl | Code], Icode) ->
|
||||
io:format("Unhandled declaration: ~p\n", [Decl]),
|
||||
contract_to_icode(Code, Icode).
|
||||
contract_to_icode(_Code, Icode) ->
|
||||
%% TODO debug output for debug("Unhandled code ~p~n",[Code]),
|
||||
Icode.
|
||||
|
||||
ast_id({id, _, Id}) -> Id;
|
||||
ast_id({qid, _, Id}) -> Id.
|
||||
ast_id({id, _, Id}) -> Id.
|
||||
|
||||
ast_args([{arg, _, Name, Type}|Rest], Acc, Icode) ->
|
||||
ast_args(Rest, [{ast_id(Name), ast_type(Type, Icode)}| Acc], Icode);
|
||||
@@ -133,7 +121,7 @@ ast_type(T, Icode) ->
|
||||
ast_body(?qid_app(["Chain","spend"], [To, Amount], _, _), Icode) ->
|
||||
prim_call(?PRIM_CALL_SPEND, ast_body(Amount, Icode), [ast_body(To, Icode)], [word], {tuple, []});
|
||||
|
||||
ast_body(?qid_app([Con, "Chain", "event"], [Event], _, _), Icode = #{ contract_name := Con }) ->
|
||||
ast_body(?qid_app(["Chain","event"], [Event], _, _), Icode) ->
|
||||
aeso_builtins:check_event_type(Icode),
|
||||
builtin_call({event, maps:get(event_type, Icode)}, [ast_body(Event, Icode)]);
|
||||
|
||||
@@ -145,7 +133,6 @@ ast_body(?qid_app(["Chain", "block_hash"], [Height], _, _), Icode) ->
|
||||
ast_body(?qid_app(["Call", "gas_left"], [], _, _), _Icode) ->
|
||||
prim_gas_left;
|
||||
ast_body({qid, _, ["Contract", "address"]}, _Icode) -> prim_contract_address;
|
||||
ast_body({qid, _, ["Contract", "creator"]}, _Icode) -> prim_contract_creator;
|
||||
ast_body({qid, _, ["Contract", "balance"]}, _Icode) -> #prim_balance{ address = prim_contract_address };
|
||||
ast_body({qid, _, ["Call", "origin"]}, _Icode) -> prim_call_origin;
|
||||
ast_body({qid, _, ["Call", "caller"]}, _Icode) -> prim_caller;
|
||||
@@ -165,10 +152,10 @@ ast_body({qid, _, ["Chain", "spend"]}, _Icode) ->
|
||||
gen_error({underapplied_primitive, 'Chain.spend'});
|
||||
|
||||
%% State
|
||||
ast_body({qid, _, [Con, "state"]}, #{ contract_name := Con }) -> prim_state;
|
||||
ast_body(?qid_app([Con, "put"], [NewState], _, _), Icode = #{ contract_name := Con }) ->
|
||||
ast_body({id, _, "state"}, _Icode) -> prim_state;
|
||||
ast_body(?id_app("put", [NewState], _, _), Icode) ->
|
||||
#prim_put{ state = ast_body(NewState, Icode) };
|
||||
ast_body({qid, _, [Con, "put"]}, #{ contract_name := Con }) ->
|
||||
ast_body({id, _, "put"}, _Icode) ->
|
||||
gen_error({underapplied_primitive, put}); %% TODO: eta
|
||||
|
||||
%% Abort
|
||||
@@ -176,11 +163,6 @@ ast_body(?id_app("abort", [String], _, _), Icode) ->
|
||||
#funcall{ function = #var_ref{ name = {builtin, abort} },
|
||||
args = [ast_body(String, Icode)] };
|
||||
|
||||
%% Authentication
|
||||
ast_body({qid, _, ["Auth", "tx_hash"]}, _Icode) ->
|
||||
prim_call(?PRIM_CALL_AUTH_TX_HASH, #integer{value = 0},
|
||||
[], [], aeso_icode:option_typerep(word));
|
||||
|
||||
%% Oracles
|
||||
ast_body(?qid_app(["Oracle", "register"], Args, _, ?oracle_t(QType, RType)), Icode) ->
|
||||
{Sign, [Acct, QFee, TTL]} = get_signature_arg(Args),
|
||||
@@ -218,17 +200,6 @@ ast_body(?qid_app(["Oracle", "get_answer"], [Oracle, Q], [_, ?query_t(_, RType)]
|
||||
prim_call(?PRIM_CALL_ORACLE_GET_ANSWER, #integer{value = 0},
|
||||
[ast_body(Oracle, Icode), ast_body(Q, Icode)], [word, word], aeso_icode:option_typerep(ast_type(RType, Icode)));
|
||||
|
||||
ast_body(?qid_app(["Oracle", "check"], [Oracle], [?oracle_t(Q, R)], _), Icode) ->
|
||||
prim_call(?PRIM_CALL_ORACLE_CHECK, #integer{value = 0},
|
||||
[ast_body(Oracle, Icode), ast_type_value(Q, Icode), ast_type_value(R, Icode)],
|
||||
[word, typerep, typerep], word);
|
||||
|
||||
ast_body(?qid_app(["Oracle", "check_query"], [Oracle, Query], [_, ?query_t(Q, R)], _), Icode) ->
|
||||
prim_call(?PRIM_CALL_ORACLE_CHECK_QUERY, #integer{value = 0},
|
||||
[ast_body(Oracle, Icode), ast_body(Query, Icode),
|
||||
ast_type_value(Q, Icode), ast_type_value(R, Icode)],
|
||||
[word, typerep, typerep], word);
|
||||
|
||||
ast_body({qid, _, ["Oracle", "register"]}, _Icode) -> gen_error({underapplied_primitive, 'Oracle.register'});
|
||||
ast_body({qid, _, ["Oracle", "query"]}, _Icode) -> gen_error({underapplied_primitive, 'Oracle.query'});
|
||||
ast_body({qid, _, ["Oracle", "extend"]}, _Icode) -> gen_error({underapplied_primitive, 'Oracle.extend'});
|
||||
@@ -351,11 +322,6 @@ ast_body(?qid_app(["Crypto", "ecverify"], [Msg, PK, Sig], _, _), Icode) ->
|
||||
[ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
|
||||
[word, word, sign_t()], word);
|
||||
|
||||
ast_body(?qid_app(["Crypto", "ecverify_secp256k1"], [Msg, PK, Sig], _, _), Icode) ->
|
||||
prim_call(?PRIM_CALL_CRYPTO_ECVERIFY_SECP256K1, #integer{value = 0},
|
||||
[ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
|
||||
[bytes_t(32), bytes_t(64), bytes_t(64)], word);
|
||||
|
||||
ast_body(?qid_app(["Crypto", "sha3"], [Term], [Type], _), Icode) ->
|
||||
generic_hash_primop(?PRIM_CALL_CRYPTO_SHA3, Term, Type, Icode);
|
||||
ast_body(?qid_app(["Crypto", "sha256"], [Term], [Type], _), Icode) ->
|
||||
@@ -415,36 +381,26 @@ ast_body(?qid_app(["Int", "to_str"], [Int], _, _), Icode) ->
|
||||
|
||||
ast_body(?qid_app(["Address", "to_str"], [Addr], _, _), Icode) ->
|
||||
builtin_call(addr_to_str, [ast_body(Addr, Icode)]);
|
||||
ast_body(?qid_app(["Address", "is_oracle"], [Addr], _, _), Icode) ->
|
||||
prim_call(?PRIM_CALL_ADDR_IS_ORACLE, #integer{value = 0},
|
||||
[ast_body(Addr, Icode)], [word], word);
|
||||
ast_body(?qid_app(["Address", "is_contract"], [Addr], _, _), Icode) ->
|
||||
prim_call(?PRIM_CALL_ADDR_IS_CONTRACT, #integer{value = 0},
|
||||
[ast_body(Addr, Icode)], [word], word);
|
||||
|
||||
%% Other terms
|
||||
ast_body({id, _, Name}, _Icode) ->
|
||||
#var_ref{name = Name};
|
||||
ast_body({qid, _, Name}, _Icode) ->
|
||||
%% TODO Look up id in env
|
||||
#var_ref{name = Name};
|
||||
ast_body({bool, _, Bool}, _Icode) -> %BOOL as ints
|
||||
Value = if Bool -> 1 ; true -> 0 end,
|
||||
#integer{value = Value};
|
||||
ast_body({int, _, Value}, _Icode) ->
|
||||
#integer{value = Value};
|
||||
ast_body({bytes, _, Bin}, _Icode) ->
|
||||
case aeb_memory:binary_to_words(Bin) of
|
||||
[Word] -> #integer{value = Word};
|
||||
Words -> #tuple{cpts = [#integer{value = W} || W <- Words]}
|
||||
ast_body({hash, _, Hash}, _Icode) ->
|
||||
case Hash of
|
||||
<<Value:32/unit:8>> -> %% address
|
||||
#integer{value = Value};
|
||||
<<Hi:32/unit:8, Lo:32/unit:8>> -> %% signature
|
||||
#tuple{cpts = [#integer{value = Hi},
|
||||
#integer{value = Lo}]}
|
||||
end;
|
||||
ast_body({Key, _, Bin}, _Icode) when Key == account_pubkey;
|
||||
Key == contract_pubkey;
|
||||
Key == oracle_pubkey;
|
||||
Key == oracle_query_id ->
|
||||
<<Value:32/unit:8>> = Bin,
|
||||
#integer{value = Value};
|
||||
ast_body({string,_,Bin}, _Icode) ->
|
||||
Cpts = [size(Bin) | aeb_memory:binary_to_words(Bin)],
|
||||
Cpts = [size(Bin) | aeso_memory:binary_to_words(Bin)],
|
||||
#tuple{cpts = [#integer{value=X} || X <- Cpts]};
|
||||
ast_body({tuple,_,Args}, Icode) ->
|
||||
#tuple{cpts = [ast_body(A, Icode) || A <- Args]};
|
||||
@@ -468,7 +424,7 @@ ast_body({app, _, {typed, _, {proj, _, {typed, _, Addr, {con, _, Contract}}, {id
|
||||
Gas = proplists:get_value("gas", ArgOpts ++ Defaults),
|
||||
Value = proplists:get_value("value", ArgOpts ++ Defaults),
|
||||
OutType = ast_typerep(OutT, Icode),
|
||||
<<TypeHash:256>> = aeb_abi:function_type_hash(list_to_binary(FunName), ArgType, OutType),
|
||||
<<TypeHash:256>> = aeso_abi:function_type_hash(list_to_binary(FunName), ArgType, OutType),
|
||||
%% The function is represented by its type hash (which includes the name)
|
||||
Fun = #integer{value = TypeHash},
|
||||
#prim_call_contract{
|
||||
@@ -485,15 +441,9 @@ ast_body({proj, _, {typed, _, _, {con, _, Contract}}, {id, _, FunName}}, _Icode)
|
||||
string:join([Contract, FunName], ".")});
|
||||
|
||||
ast_body({con, _, Name}, Icode) ->
|
||||
Tag = aeso_icode:get_constructor_tag([Name], Icode),
|
||||
#tuple{cpts = [#integer{value = Tag}]};
|
||||
ast_body({qcon, _, Name}, Icode) ->
|
||||
Tag = aeso_icode:get_constructor_tag(Name, Icode),
|
||||
#tuple{cpts = [#integer{value = Tag}]};
|
||||
ast_body({app, _, {typed, _, {con, _, Name}, _}, Args}, Icode) ->
|
||||
Tag = aeso_icode:get_constructor_tag([Name], Icode),
|
||||
#tuple{cpts = [#integer{value = Tag} | [ ast_body(Arg, Icode) || Arg <- Args ]]};
|
||||
ast_body({app, _, {typed, _, {qcon, _, Name}, _}, Args}, Icode) ->
|
||||
Tag = aeso_icode:get_constructor_tag(Name, Icode),
|
||||
#tuple{cpts = [#integer{value = Tag} | [ ast_body(Arg, Icode) || Arg <- Args ]]};
|
||||
ast_body({app,As,Fun,Args}, Icode) ->
|
||||
@@ -523,8 +473,6 @@ ast_body({switch,_,A,Cases}, Icode) ->
|
||||
ast_body({block,As,[{letval,_,Pat,_,E}|Rest]}, Icode) ->
|
||||
#switch{expr=ast_body(E, Icode),
|
||||
cases=[{ast_body(Pat, Icode),ast_body({block,As,Rest}, Icode)}]};
|
||||
ast_body({block, As, [{letfun, Ann, F, Args, _Type, Expr} | Rest]}, Icode) ->
|
||||
ast_body({block, As, [{letval, Ann, F, unused, {lam, Ann, Args, Expr}} | Rest]}, Icode);
|
||||
ast_body({block,_,[]}, _Icode) ->
|
||||
#tuple{cpts=[]};
|
||||
ast_body({block,_,[E]}, Icode) ->
|
||||
@@ -592,29 +540,15 @@ ast_binop(Op, Ann, {typed, _, A, Type}, B, Icode)
|
||||
_ when not Monomorphic ->
|
||||
gen_error({cant_compare_polymorphic_type, Ann, Op, Type});
|
||||
word -> #binop{op = Op, left = ast_body(A, Icode), right = ast_body(B, Icode)};
|
||||
OtherType ->
|
||||
string ->
|
||||
Neg = case Op of
|
||||
'==' -> fun(X) -> X end;
|
||||
'!=' -> fun(X) -> #unop{ op = '!', rand = X } end;
|
||||
_ -> gen_error({cant_compare, Ann, Op, Type})
|
||||
end,
|
||||
Args = [ast_body(A, Icode), ast_body(B, Icode)],
|
||||
Builtin =
|
||||
case OtherType of
|
||||
string ->
|
||||
#funcall{ function = #var_ref{name = {builtin, str_equal}},
|
||||
args = Args };
|
||||
{tuple, Types} ->
|
||||
case lists:usort(Types) of
|
||||
[word] ->
|
||||
#funcall{ function = #var_ref{name = {builtin, str_equal_p}},
|
||||
args = [ #integer{value = 32 * length(Types)} | Args] };
|
||||
_ -> gen_error({cant_compare, Ann, Op, Type})
|
||||
end;
|
||||
_ ->
|
||||
gen_error({cant_compare, Ann, Op, Type})
|
||||
end,
|
||||
Neg(Builtin)
|
||||
Neg(#funcall{ function = #var_ref{name = {builtin, str_equal}},
|
||||
args = [ast_body(A, Icode), ast_body(B, Icode)] });
|
||||
_ -> gen_error({cant_compare, Ann, Op, Type})
|
||||
end;
|
||||
ast_binop('++', _, A, B, Icode) ->
|
||||
#funcall{ function = #var_ref{ name = {builtin, list_concat} },
|
||||
@@ -685,7 +619,7 @@ prim_call(Prim, Amount, Args, ArgTypes, OutType) ->
|
||||
true ->
|
||||
PrimBin = binary:encode_unsigned(Prim),
|
||||
ArgType = {tuple, ArgTypes},
|
||||
<<TH:256>> = aeb_abi:function_type_hash(PrimBin, ArgType, OutType),
|
||||
<<TH:256>> = aeso_abi:function_type_hash(PrimBin, ArgType, OutType),
|
||||
TH;
|
||||
false ->
|
||||
0
|
||||
@@ -714,7 +648,7 @@ make_type_def(Args, Def, Icode = #{ type_vars := TypeEnv }) ->
|
||||
ast_typerep(Def, Icode#{ type_vars := maps:merge(TypeEnv, TypeEnv1) })
|
||||
end.
|
||||
|
||||
-spec ast_typerep(aeso_syntax:type()) -> aeb_aevm_data:type().
|
||||
-spec ast_typerep(aeso_syntax:type()) -> aeso_sophia:type().
|
||||
ast_typerep(Type) -> ast_typerep(Type, aeso_icode:new([])).
|
||||
|
||||
ast_typerep({id, _, Name}, Icode) ->
|
||||
@@ -723,8 +657,6 @@ ast_typerep({qid, _, Name}, Icode) ->
|
||||
lookup_type_id(Name, [], Icode);
|
||||
ast_typerep({con, _, _}, _) ->
|
||||
word; %% Contract type
|
||||
ast_typerep({bytes_t, _, Len}, _) ->
|
||||
bytes_t(Len);
|
||||
ast_typerep({app_t, _, {id, _, Name}, Args}, Icode) ->
|
||||
ArgReps = [ ast_typerep(Arg, Icode) || Arg <- Args ],
|
||||
lookup_type_id(Name, ArgReps, Icode);
|
||||
@@ -752,9 +684,8 @@ ast_typerep({variant_t, Cons}, Icode) ->
|
||||
ttl_t(Icode) ->
|
||||
ast_typerep({qid, [], ["Chain", "ttl"]}, Icode).
|
||||
|
||||
sign_t() -> bytes_t(64).
|
||||
bytes_t(Len) when Len =< 32 -> word;
|
||||
bytes_t(Len) -> {tuple, lists:duplicate((31 + Len) div 32, word)}.
|
||||
sign_t() ->
|
||||
{tuple, [word, word]}.
|
||||
|
||||
get_signature_arg(Args0) ->
|
||||
NamedArgs = [Arg || Arg = {named_arg, _, _, _} <- Args0],
|
||||
@@ -814,15 +745,6 @@ has_maps({list, T}) -> has_maps(T);
|
||||
has_maps({tuple, Ts}) -> lists:any(fun has_maps/1, Ts);
|
||||
has_maps({variant, Cs}) -> lists:any(fun has_maps/1, lists:append(Cs)).
|
||||
|
||||
%% A function is private if marked 'private' or 'internal', or if it's not
|
||||
%% defined in the main contract name space. (NOTE: changes when we introduce
|
||||
%% inheritance).
|
||||
is_private(Ann, #{ contract_name := MainContract } = Icode) ->
|
||||
{_, _, CurrentNamespace} = aeso_icode:get_namespace(Icode),
|
||||
proplists:get_value(private, Ann, false) orelse
|
||||
proplists:get_value(internal, Ann, false) orelse
|
||||
MainContract /= CurrentNamespace.
|
||||
|
||||
%% -------------------------------------------------------------------
|
||||
%% Builtins
|
||||
%% -------------------------------------------------------------------
|
||||
@@ -834,39 +756,3 @@ builtin_call(Builtin, Args) ->
|
||||
add_builtins(Icode = #{functions := Funs}) ->
|
||||
Builtins = aeso_builtins:used_builtins(Funs),
|
||||
Icode#{functions := [ aeso_builtins:builtin_function(B) || B <- Builtins ] ++ Funs}.
|
||||
|
||||
|
||||
%% -------------------------------------------------------------------
|
||||
%% Deadcode elimination
|
||||
%% -------------------------------------------------------------------
|
||||
|
||||
deadcode_elimination(Icode = #{ functions := Funs }) ->
|
||||
PublicNames = [ Name || {Name, Ann, _, _, _} <- Funs, not lists:member(private, Ann) ],
|
||||
ArgsToPat = fun(Args) -> [ #var_ref{ name = X } || {X, _} <- Args ] end,
|
||||
Defs = maps:from_list([ {Name, {binder, ArgsToPat(Args), Body}} || {Name, _, Args, Body, _} <- Funs ]),
|
||||
UsedNames = chase_names(Defs, PublicNames, #{}),
|
||||
UsedFuns = [ Def || Def = {Name, _, _, _, _} <- Funs, maps:is_key(Name, UsedNames) ],
|
||||
Icode#{ functions := UsedFuns }.
|
||||
|
||||
chase_names(_Defs, [], Used) -> Used;
|
||||
chase_names(Defs, [X | Xs], Used) ->
|
||||
%% can happen when compiling __call contracts
|
||||
case maps:is_key(X, Used) orelse not maps:is_key(X, Defs) of
|
||||
true -> chase_names(Defs, Xs, Used); %% already chased
|
||||
false ->
|
||||
Def = maps:get(X, Defs),
|
||||
Vars = maps:keys(free_vars(Def)),
|
||||
chase_names(Defs, Vars ++ Xs, Used#{ X => true })
|
||||
end.
|
||||
|
||||
free_vars(#var_ref{ name = X }) -> #{ X => true };
|
||||
free_vars(#arg{ name = X }) -> #{ X => true };
|
||||
free_vars({binder, Pat, Body}) ->
|
||||
maps:without(maps:keys(free_vars(Pat)), free_vars(Body));
|
||||
free_vars(#switch{ expr = E, cases = Cases }) ->
|
||||
free_vars([E | [{binder, P, B} || {P, B} <- Cases]]);
|
||||
free_vars(#lambda{ args = Xs, body = E }) ->
|
||||
free_vars({binder, Xs, E});
|
||||
free_vars(T) when is_tuple(T) -> free_vars(tuple_to_list(T));
|
||||
free_vars([H | T]) -> maps:merge(free_vars(H), free_vars(T));
|
||||
free_vars(_) -> #{}.
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
%%%=============================================================================
|
||||
%%% @copyright (C) 2019, Aeternity Anstalt
|
||||
%%% @doc
|
||||
%%% BLAKE2b implementation in Erlang - for details see: https://blake2.net
|
||||
%%% @end
|
||||
%%%=============================================================================
|
||||
|
||||
-module(aeso_blake2).
|
||||
|
||||
-export([ blake2b/2
|
||||
, blake2b/3
|
||||
]).
|
||||
|
||||
-define(MAX_64BIT, 16#ffffffffffffffff).
|
||||
|
||||
-spec blake2b(HashLen :: integer(), Msg :: binary()) -> {ok, binary()}.
|
||||
blake2b(HashLen, Msg) ->
|
||||
blake2b(HashLen, Msg, <<>>).
|
||||
|
||||
-spec blake2b(HashLen :: integer(), Msg :: binary(), Key :: binary()) -> {ok, binary()}.
|
||||
blake2b(HashLen, Msg0, Key) ->
|
||||
%% If message should be keyed, prepend message with padded key.
|
||||
Msg = <<(pad(128, Key))/binary, Msg0/binary>>,
|
||||
|
||||
%% Set up the initial state
|
||||
Init = (16#01010000 + (byte_size(Key) bsl 8) + HashLen),
|
||||
<<H0:64, H1_7/binary>> = blake_iv(),
|
||||
H = <<(H0 bxor Init):64, H1_7/binary>>,
|
||||
|
||||
%% Perform the compression - message will be chopped into 128-byte chunks.
|
||||
State = blake2b_compress(H, Msg, 0),
|
||||
|
||||
%% Just return the requested part of the hash
|
||||
{ok, binary_part(to_little_endian(State), {0, HashLen})}.
|
||||
|
||||
blake2b_compress(H, <<Chunk:(128*8), Rest/binary>>, BCompr) when Rest /= <<>> ->
|
||||
H1 = blake2b_compress(H, <<Chunk:(128*8)>>, BCompr + 128, false),
|
||||
blake2b_compress(H1, Rest, BCompr + 128);
|
||||
blake2b_compress(H, SmallChunk, BCompr) ->
|
||||
Size = byte_size(SmallChunk),
|
||||
FillSize = (128 - Size) * 8,
|
||||
blake2b_compress(H, <<SmallChunk/binary, 0:FillSize>>, BCompr + Size, true).
|
||||
|
||||
blake2b_compress(H, Chunk0, BCompr, Last) ->
|
||||
Chunk = to_big_endian(Chunk0),
|
||||
<<V0_11:(12*64), V12:64, V13:64, V14:64, V15:64>> = <<H/binary, (blake_iv())/binary>>,
|
||||
V12_ = V12 bxor (BCompr band ?MAX_64BIT),
|
||||
V13_ = V13 bxor ((BCompr bsr 64) band ?MAX_64BIT),
|
||||
V14_ = case Last of
|
||||
false -> V14;
|
||||
true -> V14 bxor ?MAX_64BIT
|
||||
end,
|
||||
V = <<V0_11:(12*64), V12_:64, V13_:64, V14_:64, V15:64>>,
|
||||
|
||||
<<VLow:(8*64), VHigh:(8*64)>> =
|
||||
lists:foldl(fun(Round, Vx) -> blake2b_mix(Round, Chunk, Vx) end, V, lists:seq(0, 11)),
|
||||
|
||||
<<HInt:(8*64)>> = H,
|
||||
<<((HInt bxor VLow) bxor VHigh):(8*64)>>.
|
||||
|
||||
blake2b_mix(Rnd, Chunk, V) ->
|
||||
<<V0:64, V1:64, V2:64, V3:64, V4:64, V5:64, V6:64, V7:64, V8:64,
|
||||
V9:64, V10:64, V11:64, V12:64, V13:64, V14:64, V15:64>> = V,
|
||||
<<M0:64, M1:64, M2:64, M3:64, M4:64, M5:64, M6:64, M7:64, M8:64,
|
||||
M9:64, M10:64, M11:64, M12:64, M13:64, M14:64, M15:64>> = Chunk,
|
||||
Ms = {M0, M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15},
|
||||
M = fun(Ix) -> element(Ix+1, Ms) end,
|
||||
|
||||
[S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15] = sigma(Rnd rem 10),
|
||||
|
||||
{Vx0, Vx4, Vx8, Vx12} = blake2b_mix(V0, V4, V8, V12, M(S0), M(S1)),
|
||||
{Vx1, Vx5, Vx9, Vx13} = blake2b_mix(V1, V5, V9, V13, M(S2), M(S3)),
|
||||
{Vx2, Vx6, Vx10, Vx14} = blake2b_mix(V2, V6, V10, V14, M(S4), M(S5)),
|
||||
{Vx3, Vx7, Vx11, Vx15} = blake2b_mix(V3, V7, V11, V15, M(S6), M(S7)),
|
||||
|
||||
{Vy0, Vy5, Vy10, Vy15} = blake2b_mix(Vx0, Vx5, Vx10, Vx15, M(S8), M(S9)),
|
||||
{Vy1, Vy6, Vy11, Vy12} = blake2b_mix(Vx1, Vx6, Vx11, Vx12, M(S10), M(S11)),
|
||||
{Vy2, Vy7, Vy8, Vy13} = blake2b_mix(Vx2, Vx7, Vx8, Vx13, M(S12), M(S13)),
|
||||
{Vy3, Vy4, Vy9, Vy14} = blake2b_mix(Vx3, Vx4, Vx9, Vx14, M(S14), M(S15)),
|
||||
|
||||
<<Vy0:64, Vy1:64, Vy2:64, Vy3:64, Vy4:64, Vy5:64, Vy6:64, Vy7:64, Vy8:64,
|
||||
Vy9:64, Vy10:64, Vy11:64, Vy12:64, Vy13:64, Vy14:64, Vy15:64>>.
|
||||
|
||||
blake2b_mix(Va, Vb, Vc, Vd, X, Y) ->
|
||||
Va1 = (Va + Vb + X) band ?MAX_64BIT,
|
||||
Vd1 = rotr64(32, Vd bxor Va1),
|
||||
|
||||
Vc1 = (Vc + Vd1) band ?MAX_64BIT,
|
||||
Vb1 = rotr64(24, Vb bxor Vc1),
|
||||
|
||||
Va2 = (Va1 + Vb1 + Y) band ?MAX_64BIT,
|
||||
Vd2 = rotr64(16, Va2 bxor Vd1),
|
||||
|
||||
Vc2 = (Vc1 + Vd2) band ?MAX_64BIT,
|
||||
Vb2 = rotr64(63, Vb1 bxor Vc2),
|
||||
|
||||
{Va2, Vb2, Vc2, Vd2}.
|
||||
|
||||
blake_iv() ->
|
||||
IV0 = 16#6A09E667F3BCC908,
|
||||
IV1 = 16#BB67AE8584CAA73B,
|
||||
IV2 = 16#3C6EF372FE94F82B,
|
||||
IV3 = 16#A54FF53A5F1D36F1,
|
||||
IV4 = 16#510E527FADE682D1,
|
||||
IV5 = 16#9B05688C2B3E6C1F,
|
||||
IV6 = 16#1F83D9ABFB41BD6B,
|
||||
IV7 = 16#5BE0CD19137E2179,
|
||||
<<IV0:64, IV1:64, IV2:64, IV3:64, IV4:64, IV5:64, IV6:64, IV7:64>>.
|
||||
|
||||
sigma(N) ->
|
||||
{_, Row} = lists:keyfind(N, 1, sigma()), Row.
|
||||
|
||||
sigma() ->
|
||||
[{0, [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]},
|
||||
{1, [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3]},
|
||||
{2, [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4]},
|
||||
{3, [ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8]},
|
||||
{4, [ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13]},
|
||||
{5, [ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9]},
|
||||
{6, [12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11]},
|
||||
{7, [13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10]},
|
||||
{8, [ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5]},
|
||||
{9, [10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0]}].
|
||||
|
||||
rotr64(N, I64) ->
|
||||
<<I64rot:64>> = rotr641(N, <<I64:64>>),
|
||||
I64rot.
|
||||
|
||||
rotr641(16, <<X:(64-16), Y:16>>) -> <<Y:16, X:(64-16)>>;
|
||||
rotr641(24, <<X:(64-24), Y:24>>) -> <<Y:24, X:(64-24)>>;
|
||||
rotr641(32, <<X:(64-32), Y:32>>) -> <<Y:32, X:(64-32)>>;
|
||||
rotr641(63, <<X:(64-63), Y:63>>) -> <<Y:63, X:(64-63)>>.
|
||||
|
||||
pad(N, Bin) ->
|
||||
case (N - (byte_size(Bin) rem N)) rem N of
|
||||
0 -> Bin;
|
||||
Pad -> <<Bin/binary, 0:(Pad *8)>>
|
||||
end.
|
||||
|
||||
to_big_endian(Bin) -> to_big_endian(Bin, <<>>).
|
||||
to_big_endian(<<>>, Acc) -> Acc;
|
||||
to_big_endian(<<UInt64:1/little-unsigned-integer-unit:64, Rest/binary>>, Acc) ->
|
||||
to_big_endian(Rest, <<Acc/binary, UInt64:1/big-unsigned-integer-unit:64>>).
|
||||
|
||||
to_little_endian(Bin) -> to_little_endian(Bin, <<>>).
|
||||
to_little_endian(<<>>, Acc) -> Acc;
|
||||
to_little_endian(<<UInt64:1/big-unsigned-integer-unit:64, Rest/binary>>, Acc) ->
|
||||
to_little_endian(Rest, <<Acc/binary, UInt64:1/little-unsigned-integer-unit:64>>).
|
||||
|
||||
+15
-15
@@ -94,7 +94,7 @@ operand(T) -> T.
|
||||
str_to_icode(String) when is_list(String) ->
|
||||
str_to_icode(list_to_binary(String));
|
||||
str_to_icode(BinStr) ->
|
||||
Cpts = [size(BinStr) | aeb_memory:binary_to_words(BinStr)],
|
||||
Cpts = [size(BinStr) | aeso_memory:binary_to_words(BinStr)],
|
||||
#tuple{ cpts = [ #integer{value = X} || X <- Cpts ] }.
|
||||
|
||||
check_event_type(Icode) ->
|
||||
@@ -106,22 +106,21 @@ check_event_type(Icode) ->
|
||||
end.
|
||||
|
||||
check_event_type(Evts, Icode) ->
|
||||
[ check_event_type(Name, Ix, T, Icode)
|
||||
|| {constr_t, Ann, {con, _, Name}, Types} <- Evts,
|
||||
{Ix, T} <- lists:zip(aeso_syntax:get_ann(indices, Ann), Types) ].
|
||||
[ check_event_type(Name, T, Icode)
|
||||
|| {constr_t, _, {con, _, Name}, Types} <- Evts, T <- Types ].
|
||||
|
||||
check_event_type(EvtName, Ix, Type, Icode) ->
|
||||
check_event_type(EvtName, Type, Icode) ->
|
||||
VMType =
|
||||
try
|
||||
aeso_ast_to_icode:ast_typerep(Type, Icode)
|
||||
catch _:_ ->
|
||||
error({EvtName, could_not_resolve_type, Type})
|
||||
end,
|
||||
case {Ix, VMType} of
|
||||
{indexed, word} -> ok;
|
||||
{notindexed, string} -> ok;
|
||||
{indexed, _} -> error({EvtName, indexed_field_should_be_word, is, VMType});
|
||||
{notindexed, _} -> error({EvtName, payload_should_be_string, is, VMType})
|
||||
case aeso_syntax:get_ann(indexed, Type, false) of
|
||||
true when VMType == word -> ok;
|
||||
false when VMType == string -> ok;
|
||||
true -> error({EvtName, indexed_field_should_be_word, is, VMType});
|
||||
false -> error({EvtName, payload_should_be_string, is, VMType})
|
||||
end.
|
||||
|
||||
bfun(B, {IArgs, IExpr, IRet}) ->
|
||||
@@ -170,15 +169,16 @@ builtin_event(EventT) ->
|
||||
A = fun(X) -> aeb_opcodes:mnemonic(X) end,
|
||||
VIx = fun(Ix) -> v(lists:concat(["v", Ix])) end,
|
||||
ArgPats = fun(Ts) -> [ VIx(Ix) || Ix <- lists:seq(0, length(Ts) - 1) ] end,
|
||||
IsIndexed = fun(T) -> aeso_syntax:get_ann(indexed, T, false) end,
|
||||
Payload = %% Should put data ptr, length on stack.
|
||||
fun([]) -> {inline_asm, [A(?PUSH1), 0, A(?PUSH1), 0]};
|
||||
([V]) -> {seq, [V, {inline_asm, [A(?DUP1), A(?MLOAD), %% length, ptr
|
||||
A(?SWAP1), A(?PUSH1), 32, A(?ADD)]}]} %% ptr+32, length
|
||||
end,
|
||||
Clause =
|
||||
fun(_Tag, {con, _, Con}, IxTypes) ->
|
||||
Types = [ T || {_Ix, T} <- IxTypes ],
|
||||
Indexed = [ Var || {Var, {indexed, _Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
|
||||
fun(_Tag, {con, _, Con}, Types) ->
|
||||
Indexed = [ Var || {Var, Type} <- lists:zip(ArgPats(Types), Types),
|
||||
IsIndexed(Type) ],
|
||||
EvtIndex = {unop, 'sha3', str_to_icode(Con)},
|
||||
{event, lists:reverse(Indexed) ++ [EvtIndex], Payload(ArgPats(Types) -- Indexed)}
|
||||
end,
|
||||
@@ -189,8 +189,8 @@ builtin_event(EventT) ->
|
||||
|
||||
{[{"e", event}],
|
||||
{switch, v(e),
|
||||
[{Pat(Tag, Types), Clause(Tag, Con, lists:zip(aeso_syntax:get_ann(indices, Ann), Types))}
|
||||
|| {Tag, {constr_t, Ann, Con, Types}} <- lists:zip(Tags, Cons) ]},
|
||||
[{Pat(Tag, Types), Clause(Tag, Con, Types)}
|
||||
|| {Tag, {constr_t, _, Con, Types}} <- lists:zip(Tags, Cons) ]},
|
||||
{tuple, []}}.
|
||||
|
||||
%% Abort primitive.
|
||||
|
||||
+75
-305
@@ -11,64 +11,41 @@
|
||||
-export([ file/1
|
||||
, file/2
|
||||
, from_string/2
|
||||
, check_call/4
|
||||
, check_call/2
|
||||
, create_calldata/3
|
||||
, version/0
|
||||
, sophia_type_to_typerep/1
|
||||
, to_sophia_value/4
|
||||
, to_sophia_value/5
|
||||
, decode_calldata/3
|
||||
]).
|
||||
|
||||
-include_lib("aebytecode/include/aeb_opcodes.hrl").
|
||||
-include("aeso_icode.hrl").
|
||||
|
||||
|
||||
-type option() :: pp_sophia_code
|
||||
| pp_ast
|
||||
| pp_types
|
||||
| pp_typed_ast
|
||||
| pp_icode
|
||||
| pp_assembler
|
||||
| pp_bytecode
|
||||
| {include, {file_system, [string()]} |
|
||||
{explicit_files, #{string() => binary()}}}
|
||||
| {src_file, string()}.
|
||||
-type option() :: pp_sophia_code | pp_ast | pp_types | pp_typed_ast |
|
||||
pp_icode| pp_assembler | pp_bytecode.
|
||||
-type options() :: [option()].
|
||||
|
||||
-export_type([ option/0
|
||||
, options/0
|
||||
]).
|
||||
|
||||
-spec version() -> {ok, binary()} | {error, term()}.
|
||||
-define(COMPILER_VERSION_1, 1).
|
||||
-define(COMPILER_VERSION_2, 2).
|
||||
|
||||
-define(COMPILER_VERSION, ?COMPILER_VERSION_2).
|
||||
|
||||
-spec version() -> pos_integer().
|
||||
version() ->
|
||||
case lists:keyfind(aesophia, 1, application:loaded_applications()) of
|
||||
false ->
|
||||
case application:load(aesophia) of
|
||||
ok ->
|
||||
case application:get_key(aesophia, vsn) of
|
||||
{ok, VsnString} ->
|
||||
{ok, list_to_binary(VsnString)};
|
||||
undefined ->
|
||||
{error, failed_to_load_aesophia}
|
||||
end;
|
||||
Err = {error, _} ->
|
||||
Err
|
||||
end;
|
||||
{_App, _Des, VsnString} ->
|
||||
{ok, list_to_binary(VsnString)}
|
||||
end.
|
||||
?COMPILER_VERSION.
|
||||
|
||||
-spec file(string()) -> {ok, map()} | {error, binary()}.
|
||||
file(Filename) ->
|
||||
Dir = filename:dirname(Filename),
|
||||
{ok, Cwd} = file:get_cwd(),
|
||||
file(Filename, [{include, {file_system, [Cwd, Dir]}}]).
|
||||
file(Filename, []).
|
||||
|
||||
-spec file(string(), options()) -> {ok, map()} | {error, binary()}.
|
||||
file(File, Options) ->
|
||||
case read_contract(File) of
|
||||
{ok, Bin} -> from_string(Bin, [{src_file, File} | Options]);
|
||||
{ok, Bin} -> from_string(Bin, Options);
|
||||
{error, Error} ->
|
||||
ErrorString = [File,": ",file:format_error(Error)],
|
||||
{error, join_errors("File errors", [ErrorString], fun(E) -> E end)}
|
||||
@@ -79,16 +56,22 @@ from_string(ContractBin, Options) when is_binary(ContractBin) ->
|
||||
from_string(binary_to_list(ContractBin), Options);
|
||||
from_string(ContractString, Options) ->
|
||||
try
|
||||
#{icode := Icode} = string_to_icode(ContractString, Options),
|
||||
TypeInfo = extract_type_info(Icode),
|
||||
Assembler = assemble(Icode, Options),
|
||||
pp_assembler(Assembler, Options),
|
||||
Ast = parse(ContractString, Options),
|
||||
ok = pp_sophia_code(Ast, Options),
|
||||
ok = pp_ast(Ast, Options),
|
||||
TypedAst = aeso_ast_infer_types:infer(Ast, Options),
|
||||
%% pp_types is handled inside aeso_ast_infer_types.
|
||||
ok = pp_typed_ast(TypedAst, Options),
|
||||
ICode = to_icode(TypedAst, Options),
|
||||
TypeInfo = extract_type_info(ICode),
|
||||
ok = pp_icode(ICode, Options),
|
||||
Assembler = assemble(ICode, Options),
|
||||
ok = pp_assembler(Assembler, Options),
|
||||
ByteCodeList = to_bytecode(Assembler, Options),
|
||||
ByteCode = << << B:8 >> || B <- ByteCodeList >>,
|
||||
pp_bytecode(ByteCode, Options),
|
||||
{ok, Version} = version(),
|
||||
ok = pp_bytecode(ByteCode, Options),
|
||||
{ok, #{byte_code => ByteCode,
|
||||
compiler_version => Version,
|
||||
compiler_version => version(),
|
||||
contract_source => ContractString,
|
||||
type_info => TypeInfo
|
||||
}}
|
||||
@@ -104,68 +87,38 @@ from_string(ContractString, Options) ->
|
||||
%% General programming errors in the compiler just signal error.
|
||||
end.
|
||||
|
||||
-spec string_to_icode(string(), [option()]) -> map().
|
||||
string_to_icode(ContractString, Options) ->
|
||||
Ast = parse(ContractString, Options),
|
||||
pp_sophia_code(Ast, Options),
|
||||
pp_ast(Ast, Options),
|
||||
{TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env]),
|
||||
pp_typed_ast(TypedAst, Options),
|
||||
Icode = ast_to_icode(TypedAst, Options),
|
||||
pp_icode(Icode, Options),
|
||||
#{ typed_ast => TypedAst,
|
||||
type_env => TypeEnv,
|
||||
icode => Icode }.
|
||||
|
||||
join_errors(Prefix, Errors, Pfun) ->
|
||||
Ess = [ Pfun(E) || E <- Errors ],
|
||||
list_to_binary(string:join([Prefix|Ess], "\n")).
|
||||
|
||||
-define(CALL_NAME, "__call").
|
||||
-define(DECODE_NAME, "__decode").
|
||||
-define(CALL_NAME, "__call").
|
||||
|
||||
%% Takes a string containing a contract with a declaration/prototype of a
|
||||
%% function (foo, say) and adds function __call() = foo(args) calling this
|
||||
%% function (foo, say) and a function __call() = foo(args) calling this
|
||||
%% function. Returns the name of the called functions, typereps and Erlang
|
||||
%% terms for the arguments.
|
||||
%% NOTE: Special treatment for "init" since it might be implicit and has
|
||||
%% a special return type (typerep, T)
|
||||
-spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]} | {error, term()}
|
||||
-spec check_call(string(), options()) -> {ok, string(), {[Type], Type | any}, [term()]} | {error, term()}
|
||||
when Type :: term().
|
||||
check_call(Source, "init" = FunName, Args, Options) ->
|
||||
PatchFun = fun(T) -> {tuple, [typerep, T]} end,
|
||||
case check_call(Source, FunName, Args, Options, PatchFun) of
|
||||
Err = {error, _} when Args == [] ->
|
||||
%% Try with default init-function
|
||||
case check_call(insert_init_function(Source, Options), FunName, Args, Options, PatchFun) of
|
||||
{error, _} -> Err; %% The first error is most likely better...
|
||||
Res -> Res
|
||||
end;
|
||||
Res ->
|
||||
Res
|
||||
end;
|
||||
check_call(Source, FunName, Args, Options) ->
|
||||
PatchFun = fun(T) -> T end,
|
||||
check_call(Source, FunName, Args, Options, PatchFun).
|
||||
|
||||
check_call(ContractString0, FunName, Args, Options, PatchFun) ->
|
||||
check_call(ContractString, Options) ->
|
||||
try
|
||||
%% First check the contract without the __call function
|
||||
#{} = string_to_icode(ContractString0, Options),
|
||||
ContractString = insert_call_function(ContractString0, FunName, Args, Options),
|
||||
#{typed_ast := TypedAst,
|
||||
icode := Icode} = string_to_icode(ContractString, Options),
|
||||
Ast = parse(ContractString, Options),
|
||||
ok = pp_sophia_code(Ast, Options),
|
||||
ok = pp_ast(Ast, Options),
|
||||
TypedAst = aeso_ast_infer_types:infer(Ast, [permissive_address_literals]),
|
||||
{ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
|
||||
ok = pp_typed_ast(TypedAst, Options),
|
||||
Icode = to_icode(TypedAst, Options),
|
||||
ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
|
||||
RetVMType = case RetType of
|
||||
{id, _, "_"} -> any;
|
||||
_ -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
|
||||
end,
|
||||
ok = pp_icode(Icode, Options),
|
||||
#{ functions := Funs } = Icode,
|
||||
ArgIcode = get_arg_icode(Funs),
|
||||
ArgTerms = [ icode_to_term(T, Arg) ||
|
||||
{T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
|
||||
{ok, FunName, {ArgVMTypes, PatchFun(RetVMType)}, ArgTerms}
|
||||
{ok, FunName, {ArgVMTypes, RetVMType}, ArgTerms}
|
||||
catch
|
||||
error:{parse_errors, Errors} ->
|
||||
{error, join_errors("Parse errors", Errors, fun (E) -> E end)};
|
||||
@@ -179,205 +132,44 @@ check_call(ContractString0, FunName, Args, Options, PatchFun) ->
|
||||
fun (E) -> io_lib:format("~p", [E]) end)}
|
||||
end.
|
||||
|
||||
%% Add the __call function to a contract.
|
||||
-spec insert_call_function(string(), string(), [string()], options()) -> string().
|
||||
insert_call_function(Code, FunName, Args, Options) ->
|
||||
Ast = parse(Code, Options),
|
||||
Ind = last_contract_indent(Ast),
|
||||
lists:flatten(
|
||||
[ Code,
|
||||
"\n\n",
|
||||
lists:duplicate(Ind, " "),
|
||||
"stateful function __call() = ", FunName, "(", string:join(Args, ","), ")\n"
|
||||
]).
|
||||
|
||||
-spec insert_init_function(string(), options()) -> string().
|
||||
insert_init_function(Code, Options) ->
|
||||
Ast = parse(Code, Options),
|
||||
Ind = last_contract_indent(Ast),
|
||||
lists:flatten(
|
||||
[ Code,
|
||||
"\n\n",
|
||||
lists:duplicate(Ind, " "), "function init() = ()\n"
|
||||
]).
|
||||
|
||||
last_contract_indent(Decls) ->
|
||||
case lists:last(Decls) of
|
||||
{_, _, _, [Decl | _]} -> aeso_syntax:get_ann(col, Decl, 1) - 1;
|
||||
_ -> 0
|
||||
end.
|
||||
|
||||
-spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
|
||||
{ok, aeso_syntax:expr()} | {error, term()}.
|
||||
to_sophia_value(ContractString, Fun, ResType, Data) ->
|
||||
to_sophia_value(ContractString, Fun, ResType, Data, []).
|
||||
|
||||
-spec to_sophia_value(string(), string(), ok | error | revert, binary(), options()) ->
|
||||
{ok, aeso_syntax:expr()} | {error, term()}.
|
||||
to_sophia_value(_, _, error, Err, _Options) ->
|
||||
{ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
|
||||
to_sophia_value(_, _, revert, Data, _Options) ->
|
||||
case aeb_heap:from_binary(string, Data) of
|
||||
{ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
|
||||
-spec create_calldata(map(), string(), string()) ->
|
||||
{ok, binary(), aeso_sophia:type(), aeso_sophia:type()}
|
||||
| {error, argument_syntax_error}.
|
||||
create_calldata(Contract, "", CallCode) when is_map(Contract) ->
|
||||
case check_call(CallCode, []) of
|
||||
{ok, FunName, {ArgTypes, RetType}, Args} ->
|
||||
aeso_abi:create_calldata(Contract, FunName, Args, ArgTypes, RetType);
|
||||
{error, _} = Err -> Err
|
||||
end;
|
||||
to_sophia_value(ContractString, FunName, ok, Data, Options) ->
|
||||
try
|
||||
#{ typed_ast := TypedAst,
|
||||
type_env := TypeEnv,
|
||||
icode := Icode } = string_to_icode(ContractString, Options),
|
||||
{ok, _, Type0} = get_decode_type(FunName, TypedAst),
|
||||
Type = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
|
||||
VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
|
||||
case aeb_heap:from_binary(VmType, Data) of
|
||||
{ok, VmValue} ->
|
||||
try
|
||||
{ok, translate_vm_value(VmType, Type, VmValue)}
|
||||
catch throw:cannot_translate_to_sophia ->
|
||||
Type0Str = prettypr:format(aeso_pretty:type(Type0)),
|
||||
{error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n of type ~p\n to Sophia type ~s\n",
|
||||
[Data, VmType, Type0Str]))],
|
||||
fun (E) -> E end)}
|
||||
end;
|
||||
{error, _Err} ->
|
||||
{error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
|
||||
fun(E) -> E end)}
|
||||
end
|
||||
catch
|
||||
error:{parse_errors, Errors} ->
|
||||
{error, join_errors("Parse errors", Errors, fun (E) -> E end)};
|
||||
error:{type_errors, Errors} ->
|
||||
{error, join_errors("Type errors", Errors, fun (E) -> E end)};
|
||||
error:{badmatch, {error, missing_function}} ->
|
||||
{error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
|
||||
fun (E) -> E end)};
|
||||
throw:Error -> %Don't ask
|
||||
{error, join_errors("Code errors", [Error],
|
||||
fun (E) -> io_lib:format("~p", [E]) end)}
|
||||
end.
|
||||
|
||||
address_literal(Type, N) -> {Type, [], <<N:256>>}.
|
||||
|
||||
%% TODO: somewhere else
|
||||
-spec translate_vm_value(aeb_aevm_data:type(), aeso_syntax:type(), aeb_aevm_data:data()) -> aeso_syntax:expr().
|
||||
translate_vm_value(word, {id, _, "address"}, N) -> address_literal(account_pubkey, N);
|
||||
translate_vm_value(word, {app_t, _, {id, _, "oracle"}, _}, N) -> address_literal(oracle_pubkey, N);
|
||||
translate_vm_value(word, {app_t, _, {id, _, "oracle_query"}, _}, N) -> address_literal(oracle_query_id, N);
|
||||
translate_vm_value(word, {con, _, _Name}, N) -> address_literal(contract_pubkey, N);
|
||||
translate_vm_value(word, {id, _, "int"}, N) -> {int, [], N};
|
||||
translate_vm_value(word, {id, _, "bits"}, N) -> error({todo, bits, N});
|
||||
translate_vm_value(word, {id, _, "bool"}, N) -> {bool, [], N /= 0};
|
||||
translate_vm_value(word, {bytes_t, _, Len}, Val) when Len =< 32 ->
|
||||
{bytes, [], <<Val:Len/unit:8>>};
|
||||
translate_vm_value({tuple, _}, {bytes_t, _, Len}, Val) ->
|
||||
{bytes, [], binary:part(<< <<W:32/unit:8>> || W <- tuple_to_list(Val) >>, 0, Len)};
|
||||
translate_vm_value(string, {id, _, "string"}, S) -> {string, [], S};
|
||||
translate_vm_value({list, VmType}, {app_t, _, {id, _, "list"}, [Type]}, List) ->
|
||||
{list, [], [translate_vm_value(VmType, Type, X) || X <- List]};
|
||||
translate_vm_value({option, VmType}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
|
||||
case Val of
|
||||
none -> {con, [], "None"};
|
||||
{some, X} -> {app, [], {con, [], "Some"}, [translate_vm_value(VmType, Type, X)]}
|
||||
end;
|
||||
translate_vm_value({variant, [[], [VmType]]}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
|
||||
case Val of
|
||||
{variant, 0, []} -> {con, [], "None"};
|
||||
{variant, 1, [X]} -> {app, [], {con, [], "Some"}, [translate_vm_value(VmType, Type, X)]}
|
||||
end;
|
||||
translate_vm_value({tuple, VmTypes}, {tuple_t, _, Types}, Val)
|
||||
when length(VmTypes) == length(Types),
|
||||
length(VmTypes) == tuple_size(Val) ->
|
||||
{tuple, [], [translate_vm_value(VmType, Type, X)
|
||||
|| {VmType, Type, X} <- lists:zip3(VmTypes, Types, tuple_to_list(Val))]};
|
||||
translate_vm_value({tuple, VmTypes}, {record_t, Fields}, Val)
|
||||
when length(VmTypes) == length(Fields),
|
||||
length(VmTypes) == tuple_size(Val) ->
|
||||
{record, [], [ {field, [], [{proj, [], FName}], translate_vm_value(VmType, FType, X)}
|
||||
|| {VmType, {field_t, _, FName, FType}, X} <- lists:zip3(VmTypes, Fields, tuple_to_list(Val)) ]};
|
||||
translate_vm_value({map, VmKeyType, VmValType}, {app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
|
||||
when is_map(Map) ->
|
||||
{map, [], [ {translate_vm_value(VmKeyType, KeyType, Key),
|
||||
translate_vm_value(VmValType, ValType, Val)}
|
||||
|| {Key, Val} <- maps:to_list(Map) ]};
|
||||
translate_vm_value({variant, VmCons}, {variant_t, Cons}, {variant, Tag, Args})
|
||||
when length(VmCons) == length(Cons),
|
||||
length(VmCons) > Tag ->
|
||||
VmTypes = lists:nth(Tag + 1, VmCons),
|
||||
ConType = lists:nth(Tag + 1, Cons),
|
||||
translate_vm_value(VmTypes, ConType, Args);
|
||||
translate_vm_value(VmTypes, {constr_t, _, Con, Types}, Args)
|
||||
when length(VmTypes) == length(Types),
|
||||
length(VmTypes) == length(Args) ->
|
||||
{app, [], Con, [ translate_vm_value(VmType, Type, Arg)
|
||||
|| {VmType, Type, Arg} <- lists:zip3(VmTypes, Types, Args) ]};
|
||||
translate_vm_value(_VmType, _Type, _Data) ->
|
||||
throw(cannot_translate_to_sophia).
|
||||
|
||||
-spec create_calldata(string(), string(), [string()]) ->
|
||||
{ok, binary(), aeb_aevm_data:type(), aeb_aevm_data:type()}
|
||||
| {error, term()}.
|
||||
create_calldata(Code, Fun, Args) ->
|
||||
case check_call(Code, Fun, Args, []) of
|
||||
{ok, FunName, {ArgTypes, RetType}, VMArgs} ->
|
||||
aeb_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
|
||||
{error, _} = Err -> Err
|
||||
end.
|
||||
|
||||
-spec decode_calldata(string(), string(), binary()) ->
|
||||
{ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
|
||||
| {error, term()}.
|
||||
decode_calldata(ContractString, FunName, Calldata) ->
|
||||
try
|
||||
#{ typed_ast := TypedAst,
|
||||
type_env := TypeEnv,
|
||||
icode := Icode } = string_to_icode(ContractString, []),
|
||||
{ok, Args, _} = get_decode_type(FunName, TypedAst),
|
||||
DropArg = fun({arg, _, _, T}) -> T; (T) -> T end,
|
||||
ArgTypes = lists:map(DropArg, Args),
|
||||
Type0 = {tuple_t, [], ArgTypes},
|
||||
Type = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
|
||||
VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
|
||||
case aeb_heap:from_binary({tuple, [word, VmType]}, Calldata) of
|
||||
{ok, {_, VmValue}} ->
|
||||
try
|
||||
{tuple, [], Values} = translate_vm_value(VmType, Type, VmValue),
|
||||
{ok, ArgTypes, Values}
|
||||
catch throw:cannot_translate_to_sophia ->
|
||||
Type0Str = prettypr:format(aeso_pretty:type(Type0)),
|
||||
{error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n of type ~p\n to Sophia type ~s\n",
|
||||
[VmValue, VmType, Type0Str]))],
|
||||
fun (E) -> E end)}
|
||||
end;
|
||||
{error, _Err} ->
|
||||
{error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
|
||||
fun(E) -> E end)}
|
||||
end
|
||||
catch
|
||||
error:{parse_errors, Errors} ->
|
||||
{error, join_errors("Parse errors", Errors, fun (E) -> E end)};
|
||||
error:{type_errors, Errors} ->
|
||||
{error, join_errors("Type errors", Errors, fun (E) -> E end)};
|
||||
error:{badmatch, {error, missing_function}} ->
|
||||
{error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
|
||||
fun (E) -> E end)};
|
||||
throw:Error -> %Don't ask
|
||||
{error, join_errors("Code errors", [Error],
|
||||
fun (E) -> io_lib:format("~p", [E]) end)}
|
||||
create_calldata(Contract, Function, Argument) when is_map(Contract) ->
|
||||
%% Slightly hacky shortcut to let you get away without writing the full
|
||||
%% call contract code.
|
||||
%% Function should be "foo : type", and
|
||||
%% Argument should be "Arg1, Arg2, .., ArgN" (no parens)
|
||||
case string:lexemes(Function, ": ") of
|
||||
%% If function is a single word fallback to old calldata generation
|
||||
[FunName] -> aeso_abi:old_create_calldata(Contract, FunName, Argument);
|
||||
[FunName | _] ->
|
||||
Args = lists:map(fun($\n) -> 32; (X) -> X end, Argument), %% newline to space
|
||||
CallContract = lists:flatten(
|
||||
[ "contract Call =\n"
|
||||
, " function ", Function, "\n"
|
||||
, " function __call() = ", FunName, "(", Args, ")"
|
||||
]),
|
||||
create_calldata(Contract, "", CallContract)
|
||||
end.
|
||||
|
||||
|
||||
get_arg_icode(Funs) ->
|
||||
case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
|
||||
[Args] -> Args;
|
||||
[] -> error({missing_call_function, Funs})
|
||||
end.
|
||||
[Args] = [ Args || {?CALL_NAME, _, _, {funcall, _, Args}, _} <- Funs ],
|
||||
Args.
|
||||
|
||||
get_call_type([{contract, _, _, Defs}]) ->
|
||||
case [ {lists:last(QFunName), FunType}
|
||||
case [ {FunName, FunType}
|
||||
|| {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
|
||||
{typed, _,
|
||||
{app, _,
|
||||
{typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
|
||||
{typed, _, {id, _, FunName}, FunType}, _}, _}} <- Defs ] of
|
||||
[Call] -> {ok, Call};
|
||||
[] -> {error, missing_call_function}
|
||||
end;
|
||||
@@ -385,20 +177,8 @@ get_call_type([_ | Contracts]) ->
|
||||
%% The __call should be in the final contract
|
||||
get_call_type(Contracts).
|
||||
|
||||
get_decode_type(FunName, [{contract, _, _, Defs}]) ->
|
||||
GetType = fun({letfun, _, {id, _, Name}, Args, Ret, _}) when Name == FunName -> [{Args, Ret}];
|
||||
({fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Ret}}) when Name == FunName -> [{Args, Ret}];
|
||||
(_) -> [] end,
|
||||
case lists:flatmap(GetType, Defs) of
|
||||
[{Args, Ret}] -> {ok, Args, Ret};
|
||||
[] -> {error, missing_function}
|
||||
end;
|
||||
get_decode_type(FunName, [_ | Contracts]) ->
|
||||
%% The __decode should be in the final contract
|
||||
get_decode_type(FunName, Contracts).
|
||||
|
||||
%% Translate an icode value (error if not value) to an Erlang term that can be
|
||||
%% consumed by aeb_heap:to_binary().
|
||||
%% consumed by aeso_heap:to_binary().
|
||||
icode_to_term(word, {integer, N}) -> N;
|
||||
icode_to_term(string, {tuple, [{integer, Len} | Words]}) ->
|
||||
<<Str:Len/binary, _/binary>> = << <<W:256>> || {integer, W} <- Words >>,
|
||||
@@ -431,7 +211,10 @@ icode_to_term(T, V) ->
|
||||
icodes_to_terms(Ts, Vs) ->
|
||||
[ icode_to_term(T, V) || {T, V} <- lists:zip(Ts, Vs) ].
|
||||
|
||||
ast_to_icode(TypedAst, Options) ->
|
||||
parse(C,_Options) ->
|
||||
parse_string(C).
|
||||
|
||||
to_icode(TypedAst, Options) ->
|
||||
aeso_ast_to_icode:convert_typed(TypedAst, Options).
|
||||
|
||||
assemble(Icode, Options) ->
|
||||
@@ -445,9 +228,7 @@ to_bytecode([Op|Rest], Options) ->
|
||||
to_bytecode([], _) -> [].
|
||||
|
||||
extract_type_info(#{functions := Functions} =_Icode) ->
|
||||
ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
|
||||
TypeInfo = [aeb_abi:function_type_info(list_to_binary(lists:last(Name)),
|
||||
ArgTypesOnly(Args), TypeRep)
|
||||
TypeInfo = [aeso_abi:function_type_info(list_to_binary(Name), Args, TypeRep)
|
||||
|| {Name, Attrs, Args,_Body, TypeRep} <- Functions,
|
||||
not is_tuple(Name),
|
||||
not lists:member(private, Attrs)
|
||||
@@ -482,9 +263,9 @@ sophia_type_to_typerep(String) ->
|
||||
catch _:_ -> {error, bad_type}
|
||||
end.
|
||||
|
||||
parse(Text, Options) ->
|
||||
parse_string(Text) ->
|
||||
%% Try and return something sensible here!
|
||||
case aeso_parser:string(Text, Options) of
|
||||
case aeso_parser:string(Text) of
|
||||
%% Yay, it worked!
|
||||
{ok, Contract} -> Contract;
|
||||
%% Scan errors.
|
||||
@@ -497,23 +278,12 @@ parse(Text, Options) ->
|
||||
parse_error(Pos, Error);
|
||||
{error, {Pos, ambiguous_parse, As}} ->
|
||||
ErrorString = io_lib:format("Ambiguous ~p", [As]),
|
||||
parse_error(Pos, ErrorString);
|
||||
%% Include error
|
||||
{error, {Pos, include_error, File}} ->
|
||||
parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
|
||||
parse_error(Pos, ErrorString)
|
||||
end.
|
||||
|
||||
parse_error(Pos, ErrorString) ->
|
||||
Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
|
||||
parse_error({Line, Pos}, ErrorString) ->
|
||||
Error = io_lib:format("line ~p, column ~p: ~s", [Line, Pos, ErrorString]),
|
||||
error({parse_errors, [Error]}).
|
||||
|
||||
read_contract(Name) ->
|
||||
file:read_file(Name).
|
||||
|
||||
pos_error({Line, Pos}) ->
|
||||
io_lib:format("line ~p, column ~p", [Line, Pos]);
|
||||
pos_error({no_file, Line, Pos}) ->
|
||||
pos_error({Line, Pos});
|
||||
pos_error({File, Line, Pos}) ->
|
||||
io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,301 @@
|
||||
-module(aeso_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("aeso_icode.hrl").
|
||||
-include_lib("aesophia/include/aeso_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(aeso_sophia:data()) -> aeso_sophia: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 = aeso_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.
|
||||
|
||||
|
||||
|
||||
|
||||
+12
-43
@@ -9,30 +9,19 @@
|
||||
%%%-------------------------------------------------------------------
|
||||
-module(aeso_icode).
|
||||
|
||||
-export([new/1,
|
||||
pp/1,
|
||||
set_name/2,
|
||||
set_namespace/2,
|
||||
enter_namespace/2,
|
||||
get_namespace/1,
|
||||
qualify/2,
|
||||
set_functions/2,
|
||||
map_typerep/2,
|
||||
option_typerep/1,
|
||||
get_constructor_tag/2]).
|
||||
|
||||
-export([new/1, pp/1, set_name/2, set_functions/2, map_typerep/2, option_typerep/1, get_constructor_tag/2]).
|
||||
-export_type([icode/0]).
|
||||
|
||||
-include("aeso_icode.hrl").
|
||||
|
||||
-type type_def() :: fun(([aeb_aevm_data:type()]) -> aeb_aevm_data:type()).
|
||||
-type type_def() :: fun(([aeso_sophia:type()]) -> aeso_sophia:type()).
|
||||
|
||||
-type bindings() :: any().
|
||||
-type fun_dec() :: { string()
|
||||
, [modifier()]
|
||||
, arg_list()
|
||||
, expr()
|
||||
, aeb_aevm_data:type()}.
|
||||
, aeso_sophia:type()}.
|
||||
|
||||
-type modifier() :: private | stateful.
|
||||
|
||||
@@ -40,13 +29,12 @@
|
||||
|
||||
-type icode() :: #{ contract_name => string()
|
||||
, functions => [fun_dec()]
|
||||
, namespace => aeso_syntax:con() | aeso_syntax:qcon()
|
||||
, env => [bindings()]
|
||||
, state_type => aeb_aevm_data:type()
|
||||
, event_type => aeb_aevm_data:type()
|
||||
, state_type => aeso_sophia:type()
|
||||
, event_type => aeso_sophia:type()
|
||||
, types => #{ type_name() => type_def() }
|
||||
, type_vars => #{ string() => aeb_aevm_data:type() }
|
||||
, constructors => #{ [string()] => integer() } %% name to tag
|
||||
, type_vars => #{ string() => aeso_sophia:type() }
|
||||
, constructors => #{ string() => integer() } %% name to tag
|
||||
, options => [any()]
|
||||
}.
|
||||
|
||||
@@ -85,10 +73,10 @@ builtin_types() ->
|
||||
}.
|
||||
|
||||
builtin_constructors() ->
|
||||
#{ ["RelativeTTL"] => 0
|
||||
, ["FixedTTL"] => 1
|
||||
, ["None"] => 0
|
||||
, ["Some"] => 1 }.
|
||||
#{ "RelativeTTL" => 0
|
||||
, "FixedTTL" => 1
|
||||
, "None" => 0
|
||||
, "Some" => 1 }.
|
||||
|
||||
map_typerep(K, V) ->
|
||||
{map, K, V}.
|
||||
@@ -103,30 +91,11 @@ new_env() ->
|
||||
set_name(Name, Icode) ->
|
||||
maps:put(contract_name, Name, Icode).
|
||||
|
||||
-spec set_namespace(aeso_syntax:con() | aeso_syntax:qcon(), icode()) -> icode().
|
||||
set_namespace(NS, Icode) -> Icode#{ namespace => NS }.
|
||||
|
||||
-spec enter_namespace(aeso_syntax:con(), icode()) -> icode().
|
||||
enter_namespace(NS, Icode = #{ namespace := NS1 }) ->
|
||||
Icode#{ namespace => aeso_syntax:qualify(NS1, NS) };
|
||||
enter_namespace(NS, Icode) ->
|
||||
Icode#{ namespace => NS }.
|
||||
|
||||
-spec get_namespace(icode()) -> false | aeso_syntax:con() | aeso_syntax:qcon().
|
||||
get_namespace(Icode) -> maps:get(namespace, Icode, false).
|
||||
|
||||
-spec qualify(aeso_syntax:id() | aeso_syntax:con(), icode()) -> aeso_syntax:id() | aeso_syntax:qid() | aeso_syntax:con() | aeso_syntax:qcon().
|
||||
qualify(X, Icode) ->
|
||||
case get_namespace(Icode) of
|
||||
false -> X;
|
||||
NS -> aeso_syntax:qualify(NS, X)
|
||||
end.
|
||||
|
||||
-spec set_functions([fun_dec()], icode()) -> icode().
|
||||
set_functions(NewFuns, Icode) ->
|
||||
maps:put(functions, NewFuns, Icode).
|
||||
|
||||
-spec get_constructor_tag([string()], icode()) -> integer().
|
||||
-spec get_constructor_tag(string(), icode()) -> integer().
|
||||
get_constructor_tag(Name, #{constructors := Constructors}) ->
|
||||
case maps:get(Name, Constructors, undefined) of
|
||||
undefined -> error({undefined_constructor, Name});
|
||||
|
||||
+11
-2
@@ -1,5 +1,14 @@
|
||||
|
||||
-include_lib("aebytecode/include/aeb_typerep_def.hrl").
|
||||
-define(Type(), aeso_sophia: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).
|
||||
|
||||
-record(arg, {name::string(), type::?Type()}).
|
||||
|
||||
@@ -11,7 +20,7 @@
|
||||
, args :: arg_list()
|
||||
, body :: expr()}).
|
||||
|
||||
-record(var_ref, { name :: string() | list(string()) | {builtin, atom() | tuple()}}).
|
||||
-record(var_ref, { name :: string() | {builtin, atom() | tuple()}}).
|
||||
|
||||
-record(prim_call_contract,
|
||||
{ gas :: expr()
|
||||
|
||||
@@ -17,7 +17,7 @@
|
||||
i(Code) -> aeb_opcodes:mnemonic(Code).
|
||||
|
||||
%% We don't track purity or statefulness in the type checker yet.
|
||||
is_stateful({FName, _, _, _, _}) -> lists:last(FName) /= "init".
|
||||
is_stateful({FName, _, _, _, _}) -> FName /= "init".
|
||||
|
||||
is_public({_Name, Attrs, _Args, _Body, _Type}) -> not lists:member(private, Attrs).
|
||||
|
||||
@@ -105,7 +105,7 @@ make_args(Args) ->
|
||||
|
||||
fun_hash({FName, _, Args, _, TypeRep}) ->
|
||||
ArgType = {tuple, [T || {_, T} <- Args]},
|
||||
<<Hash:256>> = aeb_abi:function_type_hash(list_to_binary(lists:last(FName)), ArgType, TypeRep),
|
||||
<<Hash:256>> = aeso_abi:function_type_hash(list_to_binary(FName), ArgType, TypeRep),
|
||||
{integer, Hash}.
|
||||
|
||||
%% Expects two return addresses below N elements on the stack. Picks the top
|
||||
@@ -343,8 +343,6 @@ assemble_expr(Funs, Stack, _Tail, #prim_put{ state = State }) ->
|
||||
%% Environment primitives
|
||||
assemble_expr(_Funs, _Stack, _Tail, prim_contract_address) ->
|
||||
[i(?ADDRESS)];
|
||||
assemble_expr(_Funs, _Stack, _Tail, prim_contract_creator) ->
|
||||
[i(?CREATOR)];
|
||||
assemble_expr(_Funs, _Stack, _Tail, prim_call_origin) ->
|
||||
[i(?ORIGIN)];
|
||||
assemble_expr(_Funs, _Stack, _Tail, prim_caller) ->
|
||||
|
||||
@@ -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(aeso_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>>).
|
||||
|
||||
@@ -19,7 +19,7 @@
|
||||
|
||||
-export_type([parser/1, parser_expr/1, pos/0, token/0, tokens/0]).
|
||||
|
||||
-type pos() :: {string() | no_file, integer(), integer()} | {integer(), integer()}.
|
||||
-type pos() :: {integer(), integer()}.
|
||||
-type token() :: {atom(), pos(), term()} | {atom(), pos()}.
|
||||
-type tokens() :: [token()].
|
||||
-type error() :: {pos(), string() | no_error}.
|
||||
|
||||
+37
-118
@@ -5,37 +5,28 @@
|
||||
-module(aeso_parser).
|
||||
|
||||
-export([string/1,
|
||||
string/2,
|
||||
type/1]).
|
||||
|
||||
-include("aeso_parse_lib.hrl").
|
||||
|
||||
-type parse_result() :: {ok, aeso_syntax:ast()}
|
||||
| {error, {aeso_parse_lib:pos(), atom(), term()}}
|
||||
| {error, {aeso_parse_lib:pos(), atom()}}.
|
||||
|
||||
-spec string(string()) -> parse_result().
|
||||
-spec string(string()) ->
|
||||
{ok, aeso_syntax:ast()}
|
||||
| {error, {aeso_parse_lib:pos(),
|
||||
atom(),
|
||||
term()}}
|
||||
| {error, {aeso_parse_lib:pos(),
|
||||
atom()}}.
|
||||
string(String) ->
|
||||
string(String, []).
|
||||
|
||||
-spec string(string(), aeso_compiler:options()) -> parse_result().
|
||||
string(String, Opts) ->
|
||||
case parse_and_scan(file(), String, Opts) of
|
||||
{ok, AST} ->
|
||||
expand_includes(AST, Opts);
|
||||
Err = {error, _} ->
|
||||
Err
|
||||
end.
|
||||
parse_and_scan(file(), String).
|
||||
|
||||
type(String) ->
|
||||
parse_and_scan(type(), String, []).
|
||||
parse_and_scan(type(), String).
|
||||
|
||||
parse_and_scan(P, S, Opts) ->
|
||||
set_current_file(proplists:get_value(src_file, Opts, no_file)),
|
||||
case aeso_scan:scan(S) of
|
||||
{ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
|
||||
Error -> Error
|
||||
end.
|
||||
parse_and_scan(P, S) ->
|
||||
case aeso_scan:scan(S) of
|
||||
{ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
|
||||
Error -> Error
|
||||
end.
|
||||
|
||||
%% -- Parsing rules ----------------------------------------------------------
|
||||
|
||||
@@ -45,9 +36,7 @@ decl() ->
|
||||
?LAZY_P(
|
||||
choice(
|
||||
%% Contract declaration
|
||||
[ ?RULE(keyword(contract), con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
|
||||
, ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
|
||||
, ?RULE(keyword(include), str(), {include, _2})
|
||||
[ ?RULE(keyword(contract), con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
|
||||
|
||||
%% Type declarations TODO: format annotation for "type bla" vs "type bla()"
|
||||
, ?RULE(keyword(type), id(), {type_decl, _1, _2, []})
|
||||
@@ -68,14 +57,9 @@ decl() ->
|
||||
modifiers() ->
|
||||
many(choice([token(stateful), token(public), token(private), token(internal)])).
|
||||
|
||||
add_modifiers([], Node) -> Node;
|
||||
add_modifiers(Mods = [Tok | _], Node) ->
|
||||
%% Set the position to the position of the first modifier. This is
|
||||
%% important for code transformation tools (like what we do in
|
||||
%% create_calldata) to be able to get the indentation of the declaration.
|
||||
set_pos(get_pos(Tok),
|
||||
lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
|
||||
Node, Mods)).
|
||||
add_modifiers(Mods, Node) ->
|
||||
lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
|
||||
Node, Mods).
|
||||
|
||||
%% -- Type declarations ------------------------------------------------------
|
||||
|
||||
@@ -87,7 +71,7 @@ constructors() ->
|
||||
sep1(constructor(), tok('|')).
|
||||
|
||||
constructor() -> %% TODO: format for Con() vs Con
|
||||
choice(?RULE(con(), {constr_t, get_ann(_1), _1, []}),
|
||||
choice(?RULE(con(), {constr_t, get_ann(_1), _1, []}),
|
||||
?RULE(con(), con_args(), {constr_t, get_ann(_1), _1, _2})).
|
||||
|
||||
con_args() -> paren_list(con_arg()).
|
||||
@@ -99,7 +83,9 @@ con_arg() -> choice(type(), ?RULE(keyword(indexed), type(), set_ann(indexed,
|
||||
%% -- Let declarations -------------------------------------------------------
|
||||
|
||||
letdecl() ->
|
||||
?RULE(keyword('let'), letdef(), set_pos(get_pos(_1), _2)).
|
||||
choice(
|
||||
?RULE(keyword('let'), letdef(), set_pos(get_pos(_1), _2)),
|
||||
?RULE(keyword('let'), tok(rec), sep1(letdef(), tok('and')), {letrec, _1, _3})).
|
||||
|
||||
letdef() -> choice(valdef(), fundef()).
|
||||
|
||||
@@ -134,15 +120,11 @@ type200() ->
|
||||
type300() -> type400().
|
||||
|
||||
type400() ->
|
||||
choice(
|
||||
[?RULE(typeAtom(), optional(type_args()),
|
||||
?RULE(typeAtom(), optional(type_args()),
|
||||
case _2 of
|
||||
none -> _1;
|
||||
{ok, Args} -> {app_t, get_ann(_1), _1, Args}
|
||||
end),
|
||||
?RULE(id("bytes"), parens(token(int)),
|
||||
{bytes_t, get_ann(_1), element(3, _2)})
|
||||
]).
|
||||
end).
|
||||
|
||||
typeAtom() ->
|
||||
?LAZY_P(choice(
|
||||
@@ -205,8 +187,8 @@ exprAtom() ->
|
||||
?LAZY_P(begin
|
||||
Expr = ?LAZY_P(expr()),
|
||||
choice(
|
||||
[ id_or_addr(), con(), token(qid), token(qcon)
|
||||
, token(bytes), token(string), token(char)
|
||||
[ id(), con(), token(qid), token(qcon)
|
||||
, token(hash), token(string), token(char)
|
||||
, token(int)
|
||||
, ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
|
||||
, {bool, keyword(true), true}
|
||||
@@ -319,7 +301,6 @@ binop(Ops) ->
|
||||
con() -> token(con).
|
||||
id() -> token(id).
|
||||
tvar() -> token(tvar).
|
||||
str() -> token(string).
|
||||
|
||||
token(Tag) ->
|
||||
?RULE(tok(Tag),
|
||||
@@ -328,26 +309,6 @@ token(Tag) ->
|
||||
{Tok, {Line, Col}, Val} -> {Tok, pos_ann(Line, Col), Val}
|
||||
end).
|
||||
|
||||
id(Id) ->
|
||||
?LET_P({id, A, X} = Y, id(),
|
||||
if X == Id -> Y;
|
||||
true -> fail({A, "expected 'bytes'"})
|
||||
end).
|
||||
|
||||
id_or_addr() ->
|
||||
?RULE(id(), parse_addr_literal(_1)).
|
||||
|
||||
parse_addr_literal(Id = {id, Ann, Name}) ->
|
||||
case lists:member(lists:sublist(Name, 3), ["ak_", "ok_", "oq_", "ct_"]) of
|
||||
false -> Id;
|
||||
true ->
|
||||
try aeser_api_encoder:decode(list_to_binary(Name)) of
|
||||
{Type, Bin} -> {Type, Ann, Bin}
|
||||
catch _:_ ->
|
||||
Id
|
||||
end
|
||||
end.
|
||||
|
||||
%% -- Helpers ----------------------------------------------------------------
|
||||
|
||||
keyword(K) -> ann(tok(K)).
|
||||
@@ -375,17 +336,10 @@ bracket_list(P) -> brackets(comma_sep(P)).
|
||||
-type ann_col() :: aeso_syntax:ann_col().
|
||||
|
||||
-spec pos_ann(ann_line(), ann_col()) -> ann().
|
||||
pos_ann(Line, Col) -> [{file, current_file()}, {line, Line}, {col, Col}].
|
||||
|
||||
current_file() ->
|
||||
get('$current_file').
|
||||
|
||||
set_current_file(File) ->
|
||||
put('$current_file', File).
|
||||
pos_ann(Line, Col) -> [{line, Line}, {col, Col}].
|
||||
|
||||
ann_pos(Ann) ->
|
||||
{proplists:get_value(file, Ann),
|
||||
proplists:get_value(line, Ann),
|
||||
{proplists:get_value(line, Ann),
|
||||
proplists:get_value(col, Ann)}.
|
||||
|
||||
get_ann(Ann) when is_list(Ann) -> Ann;
|
||||
@@ -403,10 +357,10 @@ set_ann(Key, Val, Node) ->
|
||||
setelement(2, Node, lists:keystore(Key, 1, Ann, {Key, Val})).
|
||||
|
||||
get_pos(Node) ->
|
||||
{current_file(), get_ann(line, Node), get_ann(col, Node)}.
|
||||
{get_ann(line, Node), get_ann(col, Node)}.
|
||||
|
||||
set_pos({F, L, C}, Node) ->
|
||||
set_ann(file, F, set_ann(line, L, set_ann(col, C, Node))).
|
||||
set_pos({L, C}, Node) ->
|
||||
set_ann(line, L, set_ann(col, C, Node)).
|
||||
|
||||
infix(L, Op, R) -> set_ann(format, infix, {app, get_ann(L), Op, [L, R]}).
|
||||
|
||||
@@ -439,7 +393,7 @@ build_if(Ann, Cond, Then, [{elif, Ann1, Cond1, Then1} | Elses]) ->
|
||||
build_if(Ann, Cond, Then, [{else, _Ann, Else}]) ->
|
||||
{'if', Ann, Cond, Then, Else};
|
||||
build_if(Ann, Cond, Then, []) ->
|
||||
{'if', Ann, Cond, Then, {tuple, [{origin, system}], []}}.
|
||||
{'if', Ann, Cond, Then, {unit, [{origin, system}]}}.
|
||||
|
||||
else_branches([Elif = {elif, _, _, _} | Stmts], Acc) ->
|
||||
else_branches(Stmts, [Elif | Acc]);
|
||||
@@ -455,6 +409,7 @@ fun_t(Domains, Type) ->
|
||||
lists:foldr(fun({Dom, Ann}, T) -> {fun_t, Ann, [], Dom, T} end,
|
||||
Type, Domains).
|
||||
|
||||
tuple_e(Ann, []) -> {unit, Ann};
|
||||
tuple_e(_Ann, [Expr]) -> Expr; %% Not a tuple
|
||||
tuple_e(Ann, Exprs) -> {tuple, Ann, Exprs}.
|
||||
|
||||
@@ -475,9 +430,10 @@ parse_pattern({record, Ann, Fs}) ->
|
||||
{record, Ann, lists:map(fun parse_field_pattern/1, Fs)};
|
||||
parse_pattern(E = {con, _, _}) -> E;
|
||||
parse_pattern(E = {id, _, _}) -> E;
|
||||
parse_pattern(E = {unit, _}) -> E;
|
||||
parse_pattern(E = {int, _, _}) -> E;
|
||||
parse_pattern(E = {bool, _, _}) -> E;
|
||||
parse_pattern(E = {bytes, _, _}) -> E;
|
||||
parse_pattern(E = {hash, _, _}) -> E;
|
||||
parse_pattern(E = {string, _, _}) -> E;
|
||||
parse_pattern(E = {char, _, _}) -> E;
|
||||
parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
|
||||
@@ -486,10 +442,8 @@ parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
|
||||
parse_field_pattern({field, Ann, F, E}) ->
|
||||
{field, Ann, F, parse_pattern(E)}.
|
||||
|
||||
return_error({no_file, L, C}, Err) ->
|
||||
fail(io_lib:format("~p:~p:\n~s", [L, C, Err]));
|
||||
return_error({F, L, C}, Err) ->
|
||||
fail(io_lib:format("In ~s at ~p:~p:\n~s", [F, L, C, Err])).
|
||||
return_error({L, C}, Err) ->
|
||||
fail(io_lib:format("~p:~p:\n~s", [L, C, Err])).
|
||||
|
||||
-spec ret_doc_err(ann(), prettypr:document()) -> no_return().
|
||||
ret_doc_err(Ann, Doc) ->
|
||||
@@ -501,38 +455,3 @@ bad_expr_err(Reason, E) ->
|
||||
prettypr:sep([prettypr:text(Reason ++ ":"),
|
||||
prettypr:nest(2, aeso_pretty:expr(E))])).
|
||||
|
||||
%% -- Helper functions -------------------------------------------------------
|
||||
expand_includes(AST, Opts) ->
|
||||
expand_includes(AST, [], Opts).
|
||||
|
||||
expand_includes([], Acc, _Opts) ->
|
||||
{ok, lists:reverse(Acc)};
|
||||
expand_includes([{include, S = {string, _, File}} | AST], Acc, Opts) ->
|
||||
case read_file(File, Opts) of
|
||||
{ok, Bin} ->
|
||||
Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
|
||||
case string(binary_to_list(Bin), Opts1) of
|
||||
{ok, AST1} ->
|
||||
expand_includes(AST1 ++ AST, Acc, Opts);
|
||||
Err = {error, _} ->
|
||||
Err
|
||||
end;
|
||||
{error, _} ->
|
||||
{error, {get_pos(S), include_error, File}}
|
||||
end;
|
||||
expand_includes([E | AST], Acc, Opts) ->
|
||||
expand_includes(AST, [E | Acc], Opts).
|
||||
|
||||
read_file(File, Opts) ->
|
||||
case proplists:get_value(include, Opts, {explicit_files, #{}}) of
|
||||
{file_system, Paths} ->
|
||||
CandidateNames = [ filename:join(Dir, File) || Dir <- Paths ],
|
||||
lists:foldr(fun(F, {error, _}) -> file:read_file(F);
|
||||
(_F, OK) -> OK end, {error, not_found}, CandidateNames);
|
||||
{explicit_files, Files} ->
|
||||
case maps:get(binary_to_list(File), Files, not_found) of
|
||||
not_found -> {error, not_found};
|
||||
Src -> {ok, Src}
|
||||
end
|
||||
end.
|
||||
|
||||
|
||||
+10
-23
@@ -147,8 +147,6 @@ decl(D, Options) ->
|
||||
-spec decl(aeso_syntax:decl()) -> doc().
|
||||
decl({contract, _, C, Ds}) ->
|
||||
block(follow(text("contract"), hsep(name(C), text("="))), decls(Ds));
|
||||
decl({namespace, _, C, Ds}) ->
|
||||
block(follow(text("namespace"), hsep(name(C), text("="))), decls(Ds));
|
||||
decl({type_decl, _, T, Vars}) -> typedecl(alias_t, T, Vars);
|
||||
decl({type_def, _, T, Vars, Def}) ->
|
||||
Kind = element(1, Def),
|
||||
@@ -160,7 +158,8 @@ decl(D = {letfun, Attrs, _, _, _, _}) ->
|
||||
text(atom_to_list(Mod));
|
||||
(_) -> empty() end,
|
||||
hsep(lists:map(Mod, Attrs) ++ [letdecl("function", D)]);
|
||||
decl(D = {letval, _, _, _, _}) -> letdecl("let", D).
|
||||
decl(D = {letval, _, _, _, _}) -> letdecl("let", D);
|
||||
decl(D = {letrec, _, _}) -> letdecl("let", D).
|
||||
|
||||
-spec expr(aeso_syntax:expr(), options()) -> doc().
|
||||
expr(E, Options) ->
|
||||
@@ -183,7 +182,9 @@ name({typed, _, Name, _}) -> name(Name).
|
||||
letdecl(Let, {letval, _, F, T, E}) ->
|
||||
block_expr(0, hsep([text(Let), typed(name(F), T), text("=")]), E);
|
||||
letdecl(Let, {letfun, _, F, Args, T, E}) ->
|
||||
block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E).
|
||||
block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E);
|
||||
letdecl(Let, {letrec, _, [D | Ds]}) ->
|
||||
hsep(text(Let), above([ letdecl("rec", D) | [ letdecl("and", D1) || D1 <- Ds ] ])).
|
||||
|
||||
-spec args([aeso_syntax:arg()]) -> doc().
|
||||
args(Args) ->
|
||||
@@ -233,12 +234,8 @@ type({app_t, _, Type, Args}) ->
|
||||
beside(type(Type), tuple_type(Args));
|
||||
type({tuple_t, _, Args}) ->
|
||||
tuple_type(Args);
|
||||
type({bytes_t, _, Len}) ->
|
||||
text(lists:concat(["bytes(", Len, ")"]));
|
||||
type({named_arg_t, _, Name, Type, _Default}) ->
|
||||
%% Drop the default value
|
||||
%% follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
|
||||
typed(name(Name), Type);
|
||||
type({named_arg_t, _, Name, Type, Default}) ->
|
||||
follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
|
||||
|
||||
type(R = {record_t, _}) -> typedef(R);
|
||||
type(T = {id, _, _}) -> name(T);
|
||||
@@ -306,8 +303,6 @@ expr_p(P, E = {app, _, F = {Op, _}, Args}) when is_atom(Op) ->
|
||||
{prefix, [A]} -> prefix(P, Op, A);
|
||||
_ -> app(P, F, Args)
|
||||
end;
|
||||
expr_p(_, {app, _, C={Tag, _, _}, []}) when Tag == con; Tag == qcon ->
|
||||
expr_p(0, C);
|
||||
expr_p(P, {app, _, F, Args}) ->
|
||||
app(P, F, Args);
|
||||
%% -- Constants
|
||||
@@ -318,17 +313,8 @@ expr_p(_, E = {int, _, N}) ->
|
||||
end,
|
||||
text(S);
|
||||
expr_p(_, {bool, _, B}) -> text(atom_to_list(B));
|
||||
expr_p(_, {bytes, _, Bin}) ->
|
||||
Digits = byte_size(Bin),
|
||||
<<N:Digits/unit:8>> = Bin,
|
||||
text(lists:flatten(io_lib:format("#~*.16.0b", [Digits*2, N])));
|
||||
expr_p(_, {hash, _, <<N:512>>}) -> text("#" ++ integer_to_list(N, 16));
|
||||
expr_p(_, {Type, _, Bin})
|
||||
when Type == account_pubkey;
|
||||
Type == contract_pubkey;
|
||||
Type == oracle_pubkey;
|
||||
Type == oracle_query_id ->
|
||||
text(binary_to_list(aeser_api_encoder:encode(Type, Bin)));
|
||||
expr_p(_, {hash, _, <<N:256>>}) -> text("#" ++ integer_to_list(N, 16));
|
||||
expr_p(_, {unit, _}) -> text("()");
|
||||
expr_p(_, {string, _, S}) -> term(binary_to_list(S));
|
||||
expr_p(_, {char, _, C}) ->
|
||||
case C of
|
||||
@@ -432,6 +418,7 @@ statements(Stmts) ->
|
||||
|
||||
statement(S = {letval, _, _, _, _}) -> letdecl("let", S);
|
||||
statement(S = {letfun, _, _, _, _, _}) -> letdecl("let", S);
|
||||
statement(S = {letrec, _, _}) -> letdecl("let", S);
|
||||
statement(E) -> expr(E).
|
||||
|
||||
get_elifs(Expr) -> get_elifs(Expr, []).
|
||||
|
||||
+10
-8
@@ -20,7 +20,7 @@ lexer() ->
|
||||
CON = [UPPER, "[a-zA-Z0-9_]*"],
|
||||
INT = [DIGIT, "+"],
|
||||
HEX = ["0x", HEXDIGIT, "+"],
|
||||
BYTES = ["#", HEXDIGIT, "+"],
|
||||
HASH = ["#", HEXDIGIT, "+"],
|
||||
WS = "[\\000-\\ ]+",
|
||||
ID = [LOWER, "[a-zA-Z0-9_']*"],
|
||||
TVAR = ["'", ID],
|
||||
@@ -36,8 +36,8 @@ lexer() ->
|
||||
, {"\\*/", pop(skip())}
|
||||
, {"[^/*]+|[/*]", skip()} ],
|
||||
|
||||
Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
|
||||
"stateful", "true", "false", "mod", "public", "private", "indexed", "internal", "namespace"],
|
||||
Keywords = ["contract", "import", "let", "rec", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
|
||||
"stateful", "true", "false", "and", "mod", "public", "private", "indexed", "internal"],
|
||||
KW = string:join(Keywords, "|"),
|
||||
|
||||
Rules =
|
||||
@@ -54,7 +54,7 @@ lexer() ->
|
||||
, {STRING, token(string, fun parse_string/1)}
|
||||
, {HEX, token(hex, fun parse_hex/1)}
|
||||
, {INT, token(int, fun list_to_integer/1)}
|
||||
, {BYTES, token(bytes, fun parse_bytes/1)}
|
||||
, {HASH, token(hash, fun parse_hash/1)}
|
||||
|
||||
%% Identifiers (qualified first!)
|
||||
, {QID, token(qid, fun(S) -> string:tokens(S, ".") end)}
|
||||
@@ -117,8 +117,10 @@ unescape([C | Chars], Acc) ->
|
||||
|
||||
parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
|
||||
|
||||
parse_bytes("#" ++ Chars) ->
|
||||
N = list_to_integer(Chars, 16),
|
||||
Digits = (length(Chars) + 1) div 2,
|
||||
<<N:Digits/unit:8>>.
|
||||
parse_hash("#" ++ Chars) ->
|
||||
N = list_to_integer(Chars, 16),
|
||||
case length(Chars) > 64 of %% 64 hex digits = 32 bytes
|
||||
true -> <<N:64/unit:8>>; %% signature
|
||||
false -> <<N:32/unit:8>> %% address
|
||||
end.
|
||||
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
-module(aeso_sophia).
|
||||
|
||||
-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().
|
||||
|
||||
+7
-16
@@ -8,14 +8,14 @@
|
||||
|
||||
-module(aeso_syntax).
|
||||
|
||||
-export([get_ann/1, get_ann/2, get_ann/3, set_ann/2, qualify/2]).
|
||||
-export([get_ann/1, get_ann/2, get_ann/3, set_ann/2]).
|
||||
|
||||
-export_type([ann_line/0, ann_col/0, ann_origin/0, ann_format/0, ann/0]).
|
||||
-export_type([name/0, id/0, con/0, qid/0, qcon/0, tvar/0, op/0]).
|
||||
-export_type([bin_op/0, un_op/0]).
|
||||
-export_type([decl/0, letbind/0, typedef/0]).
|
||||
-export_type([arg/0, field_t/0, constructor_t/0, named_arg_t/0]).
|
||||
-export_type([type/0, constant/0, expr/0, arg_expr/0, field/1, stmt/0, alt/0, lvalue/0, elim/0, pat/0]).
|
||||
-export_type([arg/0, field_t/0, constructor_t/0]).
|
||||
-export_type([type/0, constant/0, expr/0, arg_expr/0, field/1, stmt/0, alt/0, lvalue/0, pat/0]).
|
||||
-export_type([ast/0]).
|
||||
|
||||
-type ast() :: [decl()].
|
||||
@@ -25,7 +25,7 @@
|
||||
-type ann_origin() :: system | user.
|
||||
-type ann_format() :: '?:' | hex | infix | prefix | elif.
|
||||
|
||||
-type ann() :: [{line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()} | stateful | private].
|
||||
-type ann() :: [{line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()}].
|
||||
|
||||
-type name() :: string().
|
||||
-type id() :: {id, ann(), name()}.
|
||||
@@ -35,7 +35,6 @@
|
||||
-type tvar() :: {tvar, ann(), name()}.
|
||||
|
||||
-type decl() :: {contract, ann(), con(), [decl()]}
|
||||
| {namespace, ann(), con(), [decl()]}
|
||||
| {type_decl, ann(), id(), [tvar()]}
|
||||
| {type_def, ann(), id(), [tvar()], typedef()}
|
||||
| {fun_decl, ann(), id(), type()}
|
||||
@@ -43,7 +42,8 @@
|
||||
|
||||
-type letbind()
|
||||
:: {letval, ann(), id(), type(), expr()}
|
||||
| {letfun, ann(), id(), [arg()], type(), expr()}.
|
||||
| {letfun, ann(), id(), [arg()], type(), expr()}
|
||||
| {letrec, ann(), [letbind()]}.
|
||||
|
||||
-type arg() :: {arg, ann(), id(), type()}.
|
||||
|
||||
@@ -59,7 +59,6 @@
|
||||
-type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
|
||||
| {app_t, ann(), type(), [type()]}
|
||||
| {tuple_t, ann(), [type()]}
|
||||
| {bytes_t, ann(), integer()}
|
||||
| id() | qid()
|
||||
| con() | qcon() %% contracts
|
||||
| tvar().
|
||||
@@ -70,10 +69,7 @@
|
||||
:: {int, ann(), integer()}
|
||||
| {bool, ann(), true | false}
|
||||
| {hash, ann(), binary()}
|
||||
| {account_pubkey, binary()}
|
||||
| {contract_pubkey, binary()}
|
||||
| {oracle_pubkey, binary()}
|
||||
| {oracle_query_id, binary()}
|
||||
| {unit, ann()}
|
||||
| {string, ann(), binary()}
|
||||
| {char, ann(), integer()}.
|
||||
|
||||
@@ -144,8 +140,3 @@ get_ann(Key, Node) ->
|
||||
|
||||
get_ann(Key, Node, Default) ->
|
||||
proplists:get_value(Key, get_ann(Node), Default).
|
||||
|
||||
qualify({con, Ann, N}, X) -> qualify({qcon, Ann, [N]}, X);
|
||||
qualify({qcon, _, NS}, {con, Ann, C}) -> {qcon, Ann, NS ++ [C]};
|
||||
qualify({qcon, _, NS}, {id, Ann, X}) -> {qid, Ann, NS ++ [X]}.
|
||||
|
||||
|
||||
+81
-130
@@ -6,138 +6,89 @@
|
||||
%%%-------------------------------------------------------------------
|
||||
-module(aeso_syntax_utils).
|
||||
|
||||
-export([used_ids/1, used_types/1, used/1]).
|
||||
-export([used_ids/1, used_types/1]).
|
||||
|
||||
-record(alg, {zero, plus, scoped}).
|
||||
%% Var set combinators
|
||||
none() -> [].
|
||||
one(X) -> [X].
|
||||
union_map(F, Xs) -> lists:umerge(lists:map(F, Xs)).
|
||||
minus(Xs, Ys) -> Xs -- Ys.
|
||||
|
||||
-type alg(A) :: #alg{ zero :: A
|
||||
, plus :: fun((A, A) -> A)
|
||||
, scoped :: fun((A, A) -> A) }.
|
||||
%% Compute names used by a definition or expression.
|
||||
used_ids(Es) when is_list(Es) ->
|
||||
union_map(fun used_ids/1, Es);
|
||||
used_ids({bind, A, B}) ->
|
||||
minus(used_ids(B), used_ids(A));
|
||||
%% Declarations
|
||||
used_ids({contract, _, _, Decls}) -> used_ids(Decls);
|
||||
used_ids({type_decl, _, _, _}) -> none();
|
||||
used_ids({type_def, _, _, _, _}) -> none();
|
||||
used_ids({fun_decl, _, _, _}) -> none();
|
||||
used_ids({letval, _, _, _, E}) -> used_ids(E);
|
||||
used_ids({letfun, _, _, Args, _, E}) -> used_ids({bind, Args, E});
|
||||
used_ids({letrec, _, Decls}) -> used_ids(Decls);
|
||||
%% Args
|
||||
used_ids({arg, _, X, _}) -> used_ids(X);
|
||||
used_ids({named_arg, _, _, E}) -> used_ids(E);
|
||||
%% Constants
|
||||
used_ids({int, _, _}) -> none();
|
||||
used_ids({bool, _, _}) -> none();
|
||||
used_ids({hash, _, _}) -> none();
|
||||
used_ids({unit, _}) -> none();
|
||||
used_ids({string, _, _}) -> none();
|
||||
used_ids({char, _, _}) -> none();
|
||||
%% Expressions
|
||||
used_ids({lam, _, Args, E}) -> used_ids({bind, Args, E});
|
||||
used_ids({'if', _, A, B, C}) -> used_ids([A, B, C]);
|
||||
used_ids({switch, _, E, Bs}) -> used_ids([E, Bs]);
|
||||
used_ids({app, _, E, Es}) -> used_ids([E | Es]);
|
||||
used_ids({proj, _, E, _}) -> used_ids(E);
|
||||
used_ids({tuple, _, Es}) -> used_ids(Es);
|
||||
used_ids({list, _, Es}) -> used_ids(Es);
|
||||
used_ids({typed, _, E, _}) -> used_ids(E);
|
||||
used_ids({record, _, Fs}) -> used_ids(Fs);
|
||||
used_ids({record, _, E, Fs}) -> used_ids([E, Fs]);
|
||||
used_ids({map, _, E, Fs}) -> used_ids([E, Fs]);
|
||||
used_ids({map, _, KVs}) -> used_ids([ [K, V] || {K, V} <- KVs ]);
|
||||
used_ids({map_get, _, M, K}) -> used_ids([M, K]);
|
||||
used_ids({map_get, _, M, K, V}) -> used_ids([M, K, V]);
|
||||
used_ids({block, _, Ss}) -> used_ids_s(Ss);
|
||||
used_ids({Op, _}) when is_atom(Op) -> none();
|
||||
used_ids({id, _, X}) -> [X];
|
||||
used_ids({qid, _, _}) -> none();
|
||||
used_ids({con, _, _}) -> none();
|
||||
used_ids({qcon, _, _}) -> none();
|
||||
%% Switch branches
|
||||
used_ids({'case', _, P, E}) -> used_ids({bind, P, E});
|
||||
%% Fields
|
||||
used_ids({field, _, LV, E}) -> used_ids([LV, E]);
|
||||
used_ids({field, _, LV, X, E}) -> used_ids([LV, {bind, X, E}]);
|
||||
used_ids({proj, _, _}) -> none();
|
||||
used_ids({map_get, _, E}) -> used_ids(E).
|
||||
|
||||
-type kind() :: decl | type | bind_type | expr | bind_expr.
|
||||
%% Statements
|
||||
used_ids_s([]) -> none();
|
||||
used_ids_s([S | Ss]) ->
|
||||
used_ids([S, {bind, bound_ids(S), {block, [], Ss}}]).
|
||||
|
||||
-spec fold(alg(A), fun((kind(), _) -> A), kind(), E | [E]) -> A
|
||||
when E :: aeso_syntax:decl()
|
||||
| aeso_syntax:typedef()
|
||||
| aeso_syntax:field_t()
|
||||
| aeso_syntax:constructor_t()
|
||||
| aeso_syntax:type()
|
||||
| aeso_syntax:expr()
|
||||
| aeso_syntax:pat()
|
||||
| aeso_syntax:arg()
|
||||
| aeso_syntax:alt()
|
||||
| aeso_syntax:elim()
|
||||
| aeso_syntax:arg_expr()
|
||||
| aeso_syntax:field(aeso_syntax:expr())
|
||||
| aeso_syntax:stmt().
|
||||
fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
|
||||
Sum = fun(Xs) -> lists:foldl(Plus, Zero, Xs) end,
|
||||
Same = fun(A) -> fold(Alg, Fun, K, A) end,
|
||||
Decl = fun(D) -> fold(Alg, Fun, decl, D) end,
|
||||
Type = fun(T) -> fold(Alg, Fun, type, T) end,
|
||||
Expr = fun(E) -> fold(Alg, Fun, expr, E) end,
|
||||
BindExpr = fun(P) -> fold(Alg, Fun, bind_expr, P) end,
|
||||
BindType = fun(T) -> fold(Alg, Fun, bind_type, T) end,
|
||||
Top = Fun(K, X),
|
||||
Rec = case X of
|
||||
%% lists (bound things in head scope over tail)
|
||||
[A | As] -> Scoped(Same(A), Same(As));
|
||||
%% decl()
|
||||
{contract, _, _, Ds} -> Decl(Ds);
|
||||
{namespace, _, _, Ds} -> Decl(Ds);
|
||||
{type_decl, _, I, _} -> BindType(I);
|
||||
{type_def, _, I, _, D} -> Plus(BindType(I), Decl(D));
|
||||
{fun_decl, _, _, T} -> Type(T);
|
||||
{letval, _, F, T, E} -> Sum([BindExpr(F), Type(T), Expr(E)]);
|
||||
{letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Scoped(BindExpr(Xs), Expr(E))]);
|
||||
%% typedef()
|
||||
{alias_t, T} -> Type(T);
|
||||
{record_t, Fs} -> Type(Fs);
|
||||
{variant_t, Cs} -> Type(Cs);
|
||||
%% field_t() and constructor_t()
|
||||
{field_t, _, _, T} -> Type(T);
|
||||
{constr_t, _, _, Ts} -> Type(Ts);
|
||||
%% type()
|
||||
{fun_t, _, Named, Args, Ret} -> Type([Named, Args, Ret]);
|
||||
{app_t, _, T, Ts} -> Type([T | Ts]);
|
||||
{tuple_t, _, Ts} -> Type(Ts);
|
||||
%% named_arg_t()
|
||||
{named_arg_t, _, _, T, E} -> Plus(Type(T), Expr(E));
|
||||
%% expr()
|
||||
{lam, _, Args, E} -> Scoped(BindExpr(Args), Expr(E));
|
||||
{'if', _, A, B, C} -> Expr([A, B, C]);
|
||||
{switch, _, E, Alts} -> Expr([E, Alts]);
|
||||
{app, _, A, As} -> Expr([A | As]);
|
||||
{proj, _, E, _} -> Expr(E);
|
||||
{tuple, _, As} -> Expr(As);
|
||||
{list, _, As} -> Expr(As);
|
||||
{typed, _, E, T} -> Plus(Expr(E), Type(T));
|
||||
{record, _, Fs} -> Expr(Fs);
|
||||
{record, _, E, Fs} -> Expr([E | Fs]);
|
||||
{map, _, E, Fs} -> Expr([E | Fs]);
|
||||
{map, _, KVs} -> Sum([Expr([Key, Val]) || {Key, Val} <- KVs]);
|
||||
{map_get, _, A, B} -> Expr([A, B]);
|
||||
{map_get, _, A, B, C} -> Expr([A, B, C]);
|
||||
{block, _, Ss} -> Expr(Ss);
|
||||
%% field()
|
||||
{field, _, LV, E} -> Expr([LV, E]);
|
||||
{field, _, LV, _, E} -> Expr([LV, E]);
|
||||
%% arg()
|
||||
{arg, _, X, T} -> Plus(Expr(X), Type(T));
|
||||
%% alt()
|
||||
{'case', _, P, E} -> Scoped(BindExpr(P), Expr(E));
|
||||
%% elim()
|
||||
{proj, _, _} -> Zero;
|
||||
{map_get, _, E} -> Expr(E);
|
||||
%% arg_expr()
|
||||
{named_arg, _, _, E} -> Expr(E);
|
||||
_ -> Alg#alg.zero
|
||||
end,
|
||||
(Alg#alg.plus)(Top, Rec).
|
||||
|
||||
%% Name dependencies
|
||||
|
||||
used_ids(E) ->
|
||||
[ X || {{term, [X]}, _} <- used(E) ].
|
||||
|
||||
used_types(T) ->
|
||||
[ X || {{type, [X]}, _} <- used(T) ].
|
||||
|
||||
-type entity() :: {term, [string()]}
|
||||
| {type, [string()]}
|
||||
| {namespace, [string()]}.
|
||||
|
||||
-spec entity_alg() -> alg(#{entity() => aeso_syntax:ann()}).
|
||||
entity_alg() ->
|
||||
IsBound = fun({K, _}) -> lists:member(K, [bound_term, bound_type]) end,
|
||||
Unbind = fun(bound_term) -> term; (bound_type) -> type end,
|
||||
Remove = fun(Keys, Map) -> lists:foldl(fun maps:remove/2, Map, Keys) end,
|
||||
Scoped = fun(Xs, Ys) ->
|
||||
Bound = [E || E <- maps:keys(Ys), IsBound(E)],
|
||||
Others = Remove(Bound, Ys),
|
||||
Bound1 = [ {Unbind(Tag), X} || {Tag, X} <- Bound ],
|
||||
maps:merge(Remove(Bound1, Xs), Others)
|
||||
end,
|
||||
#alg{ zero = #{}
|
||||
, plus = fun maps:merge/2
|
||||
, scoped = Scoped }.
|
||||
|
||||
-spec used(_) -> [{entity(), aeso_syntax:ann()}].
|
||||
used(D) ->
|
||||
Kind = fun(expr) -> term;
|
||||
(bind_expr) -> bound_term;
|
||||
(type) -> type;
|
||||
(bind_type) -> bound_type
|
||||
end,
|
||||
NS = fun(Xs) -> {namespace, lists:droplast(Xs)} end,
|
||||
NotBound = fun({{Tag, _}, _}) -> not lists:member(Tag, [bound_term, bound_type]) end,
|
||||
Xs =
|
||||
maps:to_list(fold(entity_alg(),
|
||||
fun(K, {id, Ann, X}) -> #{{Kind(K), [X]} => Ann};
|
||||
(K, {qid, Ann, Xs}) -> #{{Kind(K), Xs} => Ann, NS(Xs) => Ann};
|
||||
(K, {con, Ann, X}) -> #{{Kind(K), [X]} => Ann};
|
||||
(K, {qcon, Ann, Xs}) -> #{{Kind(K), Xs} => Ann, NS(Xs) => Ann};
|
||||
(_, _) -> #{}
|
||||
end, decl, D)),
|
||||
lists:filter(NotBound, Xs).
|
||||
bound_ids({letval, _, X, _, _}) -> one(X);
|
||||
bound_ids({letfun, _, X, _, _, _}) -> one(X);
|
||||
bound_ids({letrec, _, Decls}) -> union_map(fun bound_ids/1, Decls);
|
||||
bound_ids(_) -> none().
|
||||
|
||||
used_types(Ts) when is_list(Ts) -> union_map(fun used_types/1, Ts);
|
||||
used_types({type_def, _, _, _, T}) -> used_types(T);
|
||||
used_types({alias_t, T}) -> used_types(T);
|
||||
used_types({record_t, Fs}) -> used_types(Fs);
|
||||
used_types({variant_t, Cs}) -> used_types(Cs);
|
||||
used_types({field_t, _, _, T}) -> used_types(T);
|
||||
used_types({constr_t, _, _, Ts}) -> used_types(Ts);
|
||||
used_types({fun_t, _, Named, Args, T}) -> used_types([T | Named ++ Args]);
|
||||
used_types({named_arg_t, _, _, T, _}) -> used_types(T);
|
||||
used_types({app_t, _, T, Ts}) -> used_types([T | Ts]);
|
||||
used_types({tuple_t, _, Ts}) -> used_types(Ts);
|
||||
used_types({id, _, X}) -> one(X);
|
||||
used_types({qid, _, _}) -> none();
|
||||
used_types({con, _, _}) -> none();
|
||||
used_types({qcon, _, _}) -> none();
|
||||
used_types({tvar, _, _}) -> none().
|
||||
|
||||
@@ -1,11 +1,10 @@
|
||||
{application, aesophia,
|
||||
[{description, "Contract Language for aeternity"},
|
||||
{vsn, "3.0.0"},
|
||||
[{description, "Contract Language for Aethernity"},
|
||||
{vsn, "1.2.0"},
|
||||
{registered, []},
|
||||
{applications,
|
||||
[kernel,
|
||||
stdlib,
|
||||
jsx,
|
||||
syntax_tools,
|
||||
getopt,
|
||||
aebytecode
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
-module(aesophia).
|
||||
|
||||
-export([main/1]).
|
||||
|
||||
-define(OPT_SPEC,
|
||||
[ {src_file, undefined, undefined, string, "Sophia source 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, "aesophia").
|
||||
|
||||
main(Args) ->
|
||||
case getopt:parse(?OPT_SPEC, Args) of
|
||||
{ok, {Opts, []}} ->
|
||||
case proplists:get_value(help, Opts, false) of
|
||||
false ->
|
||||
compile(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.
|
||||
|
||||
|
||||
compile(Opts) ->
|
||||
case proplists:get_value(src_file, Opts, undefined) of
|
||||
undefined ->
|
||||
io:format("Error: no input source file\n\n"),
|
||||
usage();
|
||||
File ->
|
||||
compile(File, Opts)
|
||||
end.
|
||||
|
||||
compile(File, Opts) ->
|
||||
Verbose = proplists:get_value(verbose, Opts, false),
|
||||
OutFile = proplists:get_value(outfile, Opts, undefined),
|
||||
|
||||
try
|
||||
Res = aeso_compiler:file(File, [pp_ast || Verbose]),
|
||||
write_outfile(OutFile, Res),
|
||||
io:format("\nCompiled successfully!\n")
|
||||
catch
|
||||
%% The compiler errors.
|
||||
error:{type_errors, Errors} ->
|
||||
io:format("\n~s\n", [string:join(["** Type errors\n" | Errors], "\n")]);
|
||||
error:{parse_errors, Errors} ->
|
||||
io:format("\n~s\n", [string:join(["** Parse errors\n" | Errors], "\n")]);
|
||||
error:{code_errors, Errors} ->
|
||||
ErrorStrings = [ io_lib:format("~p", [E]) || E <- Errors ],
|
||||
io:format("\n~s\n", [string:join(["** Code errors\n" | ErrorStrings], "\n")]);
|
||||
%% General programming errors in the compiler.
|
||||
error:Error ->
|
||||
Where = hd(erlang:get_stacktrace()),
|
||||
ErrorString = io_lib:format("Error: ~p in\n ~p", [Error,Where]),
|
||||
io:format("\n~s\n", [ErrorString])
|
||||
end.
|
||||
|
||||
write_outfile(undefined, _) -> ok;
|
||||
write_outfile(Out, ResMap) ->
|
||||
%% Lazy approach
|
||||
file:write_file(Out, term_to_binary(ResMap)),
|
||||
io:format("Output written to: ~s\n", [Out]).
|
||||
+21
-132
@@ -4,9 +4,6 @@
|
||||
-compile(export_all).
|
||||
|
||||
-define(SANDBOX(Code), sandbox(fun() -> Code end)).
|
||||
-define(DUMMY_HASH_WORD, 16#123).
|
||||
-define(DUMMY_HASH, <<0:30/unit:8, 127, 119>>). %% 16#123
|
||||
-define(DUMMY_HASH_LIT, "#0000000000000000000000000000000000000000000000000000000000000123").
|
||||
|
||||
sandbox(Code) ->
|
||||
Parent = self(),
|
||||
@@ -22,8 +19,8 @@ sandbox(Code) ->
|
||||
|
||||
malicious_from_binary_test() ->
|
||||
CircularList = from_words([32, 1, 32]), %% Xs = 1 :: Xs
|
||||
{ok, {error, circular_references}} = ?SANDBOX(aeb_heap:from_binary({list, word}, CircularList)),
|
||||
{ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeb_heap:from_binary(word, <<1, 2, 3, 4>>)),
|
||||
{ok, {error, circular_references}} = ?SANDBOX(aeso_heap:from_binary({list, word}, CircularList)),
|
||||
{ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeso_heap:from_binary(word, <<1, 2, 3, 4>>)),
|
||||
ok.
|
||||
|
||||
from_words(Ws) ->
|
||||
@@ -57,143 +54,35 @@ encode_decode_test() ->
|
||||
ok.
|
||||
|
||||
encode_decode_sophia_test() ->
|
||||
Check = fun(Type, Str) -> case {encode_decode_sophia_string(Type, Str), Str} of
|
||||
{X, X} -> ok;
|
||||
Other -> Other
|
||||
end end,
|
||||
ok = Check("int", "42"),
|
||||
ok = Check("bool", "true"),
|
||||
ok = Check("bool", "false"),
|
||||
ok = Check("string", "\"Hello\""),
|
||||
ok = Check("(string, list(int), option(bool))",
|
||||
"(\"Hello\", [1, 2, 3], Some(true))"),
|
||||
ok = Check("variant", "Blue({[\"x\"] = 1})"),
|
||||
ok = Check("r", "{x = (\"foo\", 0), y = Red}"),
|
||||
{42} = encode_decode_sophia_string("int", "42"),
|
||||
{1} = encode_decode_sophia_string("bool", "true"),
|
||||
{0} = encode_decode_sophia_string("bool", "false"),
|
||||
{<<"Hello">>} = encode_decode_sophia_string("string", "\"Hello\""),
|
||||
{<<"Hello">>, [1,2,3], {variant, 1, [1]}} =
|
||||
encode_decode_sophia_string(
|
||||
"(string, list(int), option(bool))",
|
||||
"\"Hello\", [1,2,3], Some(true)"),
|
||||
ok.
|
||||
|
||||
encode_decode_sophia_string(SophiaType, String) ->
|
||||
io:format("String ~p~n", [String]),
|
||||
Code = [ "contract MakeCall =\n"
|
||||
, " type arg_type = ", SophiaType, "\n"
|
||||
, " type an_alias('a) = (string, 'a)\n"
|
||||
, " record r = {x : an_alias(int), y : variant}\n"
|
||||
, " datatype variant = Red | Blue(map(string, int))\n"
|
||||
, " function foo : arg_type => arg_type\n" ],
|
||||
case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], []) of
|
||||
{ok, _, {[Type], _}, [Arg]} ->
|
||||
io:format("Type ~p~n", [Type]),
|
||||
Data = encode(Arg),
|
||||
case aeso_compiler:to_sophia_value(Code, "foo", ok, Data) of
|
||||
{ok, Sophia} ->
|
||||
lists:flatten(io_lib:format("~s", [prettypr:format(aeso_pretty:expr(Sophia))]));
|
||||
{error, Err} ->
|
||||
io:format("~s\n", [Err]),
|
||||
{error, Err}
|
||||
end;
|
||||
{error, Err} ->
|
||||
io:format("~s\n", [Err]),
|
||||
{error, Err}
|
||||
end.
|
||||
|
||||
calldata_test() ->
|
||||
[42, <<"foobar">>] = encode_decode_calldata("foo", ["int", "string"], ["42", "\"foobar\""]),
|
||||
Map = #{ <<"a">> => 4 },
|
||||
[{variant, 1, [Map]}, {{<<"b">>, 5}, {variant, 0, []}}] =
|
||||
encode_decode_calldata("foo", ["variant", "r"], ["Blue({[\"a\"] = 4})", "{x = (\"b\", 5), y = Red}"]),
|
||||
[?DUMMY_HASH_WORD, 16#456] = encode_decode_calldata("foo", ["bytes(32)", "address"],
|
||||
[?DUMMY_HASH_LIT, "ak_1111111111111111111111111111113AFEFpt5"]),
|
||||
[?DUMMY_HASH_WORD, ?DUMMY_HASH_WORD] =
|
||||
encode_decode_calldata("foo", ["bytes(32)", "hash"], [?DUMMY_HASH_LIT, ?DUMMY_HASH_LIT]),
|
||||
|
||||
[119, {0, 0}] = encode_decode_calldata("foo", ["int", "signature"], ["119", [$# | lists:duplicate(128, $0)]]),
|
||||
|
||||
[16#456] = encode_decode_calldata("foo", ["Remote"], ["ct_1111111111111111111111111111113AFEFpt5"]),
|
||||
|
||||
ok.
|
||||
|
||||
calldata_init_test() ->
|
||||
encode_decode_calldata("init", ["int"], ["42"], {tuple, [typerep, word]}),
|
||||
|
||||
Code = parameterized_contract("foo", ["int"]),
|
||||
encode_decode_calldata_(Code, "init", [], {tuple, [typerep, {tuple, []}]}).
|
||||
|
||||
calldata_indent_test() ->
|
||||
Test = fun(Extra) ->
|
||||
encode_decode_calldata_(
|
||||
parameterized_contract(Extra, "foo", ["int"]),
|
||||
"foo", ["42"], word)
|
||||
end,
|
||||
Test(" stateful function bla() = ()"),
|
||||
Test(" type x = int"),
|
||||
Test(" private function bla : int => int"),
|
||||
Test(" public stateful function bla(x : int) =\n"
|
||||
" x + 1"),
|
||||
Test(" stateful private function bla(x : int) : int =\n"
|
||||
" x + 1"),
|
||||
ok.
|
||||
|
||||
parameterized_contract(FunName, Types) ->
|
||||
parameterized_contract([], FunName, Types).
|
||||
|
||||
parameterized_contract(ExtraCode, FunName, Types) ->
|
||||
lists:flatten(
|
||||
["contract Remote =\n"
|
||||
" function bla : () => ()\n\n"
|
||||
"contract Dummy =\n",
|
||||
ExtraCode, "\n",
|
||||
" type an_alias('a) = (string, 'a)\n"
|
||||
" record r = {x : an_alias(int), y : variant}\n"
|
||||
" datatype variant = Red | Blue(map(string, int))\n"
|
||||
" function ", FunName, " : (", string:join(Types, ", "), ") => int\n" ]).
|
||||
|
||||
oracle_test() ->
|
||||
Contract =
|
||||
"contract OracleTest =\n"
|
||||
" function question(o, q : oracle_query(list(string), option(int))) =\n"
|
||||
" Oracle.get_question(o, q)\n",
|
||||
{ok, _, {[word, word], {list, string}}, [16#123, 16#456]} =
|
||||
aeso_compiler:check_call(Contract, "question", ["ok_111111111111111111111111111111ZrdqRz9",
|
||||
"oq_1111111111111111111111111111113AFEFpt5"], []),
|
||||
|
||||
ok.
|
||||
|
||||
permissive_literals_fail_test() ->
|
||||
Contract =
|
||||
"contract OracleTest =\n"
|
||||
" stateful function haxx(o : oracle(list(string), option(int))) =\n"
|
||||
" Chain.spend(o, 1000000)\n",
|
||||
{error, <<"Type errors\nCannot unify", _/binary>>} =
|
||||
aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
|
||||
ok.
|
||||
|
||||
encode_decode_calldata(FunName, Types, Args) ->
|
||||
encode_decode_calldata(FunName, Types, Args, word).
|
||||
|
||||
encode_decode_calldata(FunName, Types, Args, RetType) ->
|
||||
Code = parameterized_contract(FunName, Types),
|
||||
encode_decode_calldata_(Code, FunName, Args, RetType).
|
||||
|
||||
encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
|
||||
{ok, Calldata, CalldataType, RetVMType1} = aeso_compiler:create_calldata(Code, FunName, Args),
|
||||
?assertEqual(RetVMType1, RetVMType),
|
||||
{ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
|
||||
case FunName of
|
||||
"init" ->
|
||||
ok;
|
||||
_ ->
|
||||
{ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata),
|
||||
Values = [ prettypr:format(aeso_pretty:expr(V)) || V <- ValueASTs ],
|
||||
?assertMatch({X, X}, {Args, Values})
|
||||
end,
|
||||
tuple_to_list(ArgTuple).
|
||||
Code = [ "contract Call =\n"
|
||||
, " function foo : ", SophiaType, " => _\n"
|
||||
, " function __call() = foo(", String, ")\n" ],
|
||||
{ok, _, {Types, _}, Args} = aeso_compiler:check_call(lists:flatten(Code), []),
|
||||
Arg = list_to_tuple(Args),
|
||||
Type = {tuple, Types},
|
||||
io:format("Type ~p~n", [Type]),
|
||||
Data = encode(Arg),
|
||||
decode(Type, Data).
|
||||
|
||||
encode_decode(T, D) ->
|
||||
?assertEqual(D, decode(T, encode(D))),
|
||||
D.
|
||||
|
||||
encode(D) ->
|
||||
aeb_heap:to_binary(D).
|
||||
aeso_heap:to_binary(D).
|
||||
|
||||
decode(T,B) ->
|
||||
{ok, D} = aeb_heap:from_binary(T, B),
|
||||
{ok, D} = aeso_heap:from_binary(T, B),
|
||||
D.
|
||||
|
||||
@@ -1,76 +0,0 @@
|
||||
-module(aeso_aci_tests).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
|
||||
do_test() ->
|
||||
test_contract(1),
|
||||
test_contract(2),
|
||||
test_contract(3).
|
||||
|
||||
test_contract(N) ->
|
||||
{Contract,MapACI,DecACI} = test_cases(N),
|
||||
{ok,JSON} = aeso_aci:encode(Contract),
|
||||
?assertEqual(MapACI, jsx:decode(JSON, [return_maps])),
|
||||
?assertEqual(DecACI, aeso_aci:decode(JSON)).
|
||||
|
||||
test_cases(1) ->
|
||||
Contract = <<"contract C =\n"
|
||||
" function a(i : int) = i+1\n">>,
|
||||
MapACI = #{<<"contract">> =>
|
||||
#{<<"name">> => <<"C">>,
|
||||
<<"type_defs">> => [],
|
||||
<<"functions">> =>
|
||||
[#{<<"name">> => <<"a">>,
|
||||
<<"arguments">> =>
|
||||
[#{<<"name">> => <<"i">>,
|
||||
<<"type">> => [<<"int">>]}],
|
||||
<<"returns">> => <<"int">>,
|
||||
<<"stateful">> => false}]}},
|
||||
DecACI = <<"contract C =\n"
|
||||
" function a : (int) => int\n">>,
|
||||
{Contract,MapACI,DecACI};
|
||||
|
||||
test_cases(2) ->
|
||||
Contract = <<"contract C =\n"
|
||||
" type allan = int\n"
|
||||
" function a(i : allan) = i+1\n">>,
|
||||
MapACI = #{<<"contract">> =>
|
||||
#{<<"name">> => <<"C">>,
|
||||
<<"type_defs">> =>
|
||||
[#{<<"name">> => <<"allan">>,
|
||||
<<"typedef">> => <<"int">>,
|
||||
<<"vars">> => []}],
|
||||
<<"functions">> =>
|
||||
[#{<<"arguments">> =>
|
||||
[#{<<"name">> => <<"i">>,
|
||||
<<"type">> => [<<"int">>]}],
|
||||
<<"name">> => <<"a">>,
|
||||
<<"returns">> => <<"int">>,
|
||||
<<"stateful">> => false}]}},
|
||||
DecACI = <<"contract C =\n"
|
||||
" function a : (int) => int\n">>,
|
||||
{Contract,MapACI,DecACI};
|
||||
test_cases(3) ->
|
||||
Contract = <<"contract C =\n"
|
||||
" datatype bert('a) = Bin('a)\n"
|
||||
" function a(i : bert(string)) = 1\n">>,
|
||||
MapACI = #{<<"contract">> =>
|
||||
#{<<"functions">> =>
|
||||
[#{<<"arguments">> =>
|
||||
[#{<<"name">> => <<"i">>,
|
||||
<<"type">> =>
|
||||
[#{<<"C.bert">> => [<<"string">>]}]}],
|
||||
<<"name">> => <<"a">>,<<"returns">> => <<"int">>,
|
||||
<<"stateful">> => false}],
|
||||
<<"name">> => <<"C">>,
|
||||
<<"type_defs">> =>
|
||||
[#{<<"name">> => <<"bert">>,
|
||||
<<"typedef">> =>
|
||||
#{<<"variant">> =>
|
||||
[#{<<"Bin">> => [<<"'a">>]}]},
|
||||
<<"vars">> => [#{<<"name">> => <<"'a">>}]}]}},
|
||||
DecACI = <<"contract C =\n"
|
||||
" datatype bert('a) = Bin('a)\n"
|
||||
" function a : (C.bert(string)) => int\n">>,
|
||||
{Contract,MapACI,DecACI}.
|
||||
@@ -0,0 +1,73 @@
|
||||
%%%=============================================================================
|
||||
%%% @copyright (C) 2019, Aeternity Anstalt
|
||||
%%% @doc
|
||||
%%% Unit tests for the aeso_blake2 module
|
||||
%%%
|
||||
%%% In addition the aeso_blake2 module was compared to the C reference
|
||||
%%% implementation by writing a QuickCheck property.
|
||||
%%% @end
|
||||
%%%=============================================================================
|
||||
-module(aeso_blake2_tests).
|
||||
|
||||
-ifdef(TEST).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
blake2b_test_() ->
|
||||
{"Tests for BLAKE2b hash implementation",
|
||||
[ fun() -> blake2b(Data) end || Data <- test_data_blake2b() ]}.
|
||||
|
||||
blake2b({Msg0, Key0, ExpectedOut0}) ->
|
||||
Msg = mk_binary(Msg0),
|
||||
Key = mk_binary(Key0),
|
||||
ExpectedOut = mk_binary(ExpectedOut0),
|
||||
Result = aeso_blake2:blake2b(byte_size(ExpectedOut), Msg, Key),
|
||||
?assertEqual(Result, {ok, ExpectedOut}).
|
||||
|
||||
mk_binary(Bin) when is_binary(Bin) -> Bin;
|
||||
mk_binary(HexStr) when is_list(HexStr) ->
|
||||
<< << (erlang:list_to_integer([H], 16)):4 >> || H <- HexStr >>.
|
||||
|
||||
test_data_blake2b() ->
|
||||
[ %% {Message, Key, ExpectedHash}
|
||||
%% From Wikipedia
|
||||
%% https://en.wikipedia.org/wiki/BLAKE_(hash_function)#BLAKE2
|
||||
{<<>>,
|
||||
<<>>,
|
||||
"786A02F742015903C6C6FD852552D272912F4740E15847618A86E217F71F5419D25E1031AFEE585313896444934EB04B903A685B1448B755D56F701AFE9BE2CE"}
|
||||
, {<<"The quick brown fox jumps over the lazy dog">>,
|
||||
<<>>,
|
||||
"A8ADD4BDDDFD93E4877D2746E62817B116364A1FA7BC148D95090BC7333B3673F82401CF7AA2E4CB1ECD90296E3F14CB5413F8ED77BE73045B13914CDCD6A918"}
|
||||
|
||||
%% From reference implementation testvectors
|
||||
%% https://github.com/BLAKE2/BLAKE2/tree/master/testvectors
|
||||
%%
|
||||
%% Non-keyed
|
||||
, {"00",
|
||||
"",
|
||||
"2FA3F686DF876995167E7C2E5D74C4C7B6E48F8068FE0E44208344D480F7904C36963E44115FE3EB2A3AC8694C28BCB4F5A0F3276F2E79487D8219057A506E4B"}
|
||||
, {"0001",
|
||||
"",
|
||||
"1C08798DC641ABA9DEE435E22519A4729A09B2BFE0FF00EF2DCD8ED6F8A07D15EAF4AEE52BBF18AB5608A6190F70B90486C8A7D4873710B1115D3DEBBB4327B5"}
|
||||
, {"00010203040506070809",
|
||||
"",
|
||||
"29102511D749DB3CC9B4E335FA1F5E8FACA8421D558F6A3F3321D50D044A248BA595CFC3EFD3D2ADC97334DA732413F5CBF4751C362BA1D53862AC1E8DABEEE8"}
|
||||
|
||||
%% Keyed
|
||||
, {"",
|
||||
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
|
||||
"10ebb67700b1868efb4417987acf4690ae9d972fb7a590c2f02871799aaa4786b5e996e8f0f4eb981fc214b005f42d2ff4233499391653df7aefcbc13fc51568"}
|
||||
, {"00",
|
||||
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
|
||||
"961f6dd1e4dd30f63901690c512e78e4b45e4742ed197c3c5e45c549fd25f2e4187b0bc9fe30492b16b0d0bc4ef9b0f34c7003fac09a5ef1532e69430234cebd"}
|
||||
, {"0001",
|
||||
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
|
||||
"da2cfbe2d8409a0f38026113884f84b50156371ae304c4430173d08a99d9fb1b983164a3770706d537f49e0c916d9f32b95cc37a95b99d857436f0232c88a965"}
|
||||
, {"00010203040506070809",
|
||||
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
|
||||
"4fe181f54ad63a2983feaaf77d1e7235c2beb17fa328b6d9505bda327df19fc37f02c4b6f0368ce23147313a8e5738b5fa2a95b29de1c7f8264eb77b69f585cd"}
|
||||
].
|
||||
|
||||
|
||||
-endif.
|
||||
|
||||
+20
-182
@@ -8,55 +8,31 @@
|
||||
|
||||
-module(aeso_compiler_tests).
|
||||
|
||||
-compile([export_all, nowarn_export_all]).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
%% simple_compile_test_() -> ok.
|
||||
%% Very simply test compile the given contracts. Only basic checks
|
||||
%% are made on the output, just that it is a binary which indicates
|
||||
%% that the compilation worked.
|
||||
|
||||
simple_compile_test_() ->
|
||||
{setup,
|
||||
fun () -> ok end, %Setup
|
||||
fun (_) -> ok end, %Cleanup
|
||||
[ {"Testing the " ++ ContractName ++ " contract",
|
||||
fun() ->
|
||||
case compile(ContractName) of
|
||||
#{byte_code := ByteCode,
|
||||
contract_source := _,
|
||||
type_info := _} -> ?assertMatch(Code when is_binary(Code), ByteCode);
|
||||
ErrBin ->
|
||||
io:format("\n~s", [ErrBin]),
|
||||
error(ErrBin)
|
||||
end
|
||||
#{byte_code := ByteCode,
|
||||
contract_source := _,
|
||||
type_info := _} = compile(ContractName),
|
||||
?assertMatch(Code when is_binary(Code), ByteCode)
|
||||
end} || ContractName <- compilable_contracts() ] ++
|
||||
[ {"Testing error messages of " ++ ContractName,
|
||||
fun() ->
|
||||
case compile(ContractName) of
|
||||
<<"Type errors\n", ErrorString/binary>> ->
|
||||
check_errors(lists:sort(ExpectedErrors), ErrorString);
|
||||
<<"Parse errors\n", ErrorString/binary>> ->
|
||||
check_errors(lists:sort(ExpectedErrors), ErrorString)
|
||||
end
|
||||
<<"Type errors\n",ErrorString/binary>> = compile(ContractName),
|
||||
check_errors(lists:sort(ExpectedErrors), ErrorString)
|
||||
end} ||
|
||||
{ContractName, ExpectedErrors} <- failing_contracts() ] ++
|
||||
[ {"Testing include with explicit files",
|
||||
fun() ->
|
||||
FileSystem = maps:from_list(
|
||||
[ begin
|
||||
{ok, Bin} = file:read_file(filename:join([aeso_test_utils:contract_path(), File])),
|
||||
{File, Bin}
|
||||
end || File <- ["included.aes", "../contracts/included2.aes"] ]),
|
||||
#{byte_code := Code1} = compile("include", [{include, {explicit_files, FileSystem}}]),
|
||||
#{byte_code := Code2} = compile("include"),
|
||||
?assertMatch(true, Code1 == Code2)
|
||||
end} ] ++
|
||||
[ {"Testing deadcode elimination",
|
||||
fun() ->
|
||||
#{ byte_code := NoDeadCode } = compile("nodeadcode"),
|
||||
#{ byte_code := DeadCode } = compile("deadcode"),
|
||||
SizeNoDeadCode = byte_size(NoDeadCode),
|
||||
SizeDeadCode = byte_size(DeadCode),
|
||||
?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + 40 < SizeNoDeadCode}),
|
||||
ok
|
||||
end} ].
|
||||
{ContractName, ExpectedErrors} <- failing_contracts() ]
|
||||
}.
|
||||
|
||||
check_errors(Expect, ErrorString) ->
|
||||
%% This removes the final single \n as well.
|
||||
@@ -68,13 +44,10 @@ check_errors(Expect, ErrorString) ->
|
||||
end.
|
||||
|
||||
compile(Name) ->
|
||||
compile(Name, [{include, {file_system, [aeso_test_utils:contract_path()]}}]).
|
||||
|
||||
compile(Name, Options) ->
|
||||
String = aeso_test_utils:read_contract(Name),
|
||||
case aeso_compiler:from_string(String, [{src_file, Name} | Options]) of
|
||||
{ok, Map} -> Map;
|
||||
{error, ErrorString} -> ErrorString
|
||||
case aeso_compiler:from_string(String, []) of
|
||||
{ok,Map} -> Map;
|
||||
{error,ErrorString} -> ErrorString
|
||||
end.
|
||||
|
||||
%% compilable_contracts() -> [ContractName].
|
||||
@@ -86,7 +59,6 @@ compilable_contracts() ->
|
||||
"dutch_auction",
|
||||
"environment",
|
||||
"factorial",
|
||||
"functions",
|
||||
"fundme",
|
||||
"identity",
|
||||
"maps",
|
||||
@@ -98,18 +70,7 @@ compilable_contracts() ->
|
||||
"stack",
|
||||
"test",
|
||||
"builtin_bug",
|
||||
"builtin_map_get_bug",
|
||||
"nodeadcode",
|
||||
"deadcode",
|
||||
"variant_types",
|
||||
"state_handling",
|
||||
"events",
|
||||
"include",
|
||||
"basic_auth",
|
||||
"bitcoin_auth",
|
||||
"address_literals",
|
||||
"bytes_equality",
|
||||
"address_chain"
|
||||
"builtin_map_get_bug"
|
||||
].
|
||||
|
||||
%% Contracts that should produce type errors
|
||||
@@ -189,13 +150,11 @@ failing_contracts() ->
|
||||
<<"Ambiguous record type with field y (at line 13, column 25) could be one of\n"
|
||||
" - r (at line 4, column 10)\n"
|
||||
" - r' (at line 5, column 10)">>,
|
||||
<<"Record type r2 does not have field y (at line 15, column 22)">>,
|
||||
<<"The field z is missing when constructing an element of type r2 (at line 15, column 24)">>,
|
||||
<<"Repeated name x in pattern\n"
|
||||
" x :: x (at line 26, column 7)">>,
|
||||
<<"Repeated argument x to function repeated_arg (at line 44, column 12).">>,
|
||||
<<"Repeated argument y to function repeated_arg (at line 44, column 12).">>,
|
||||
<<"No record type with fields y, z (at line 14, column 22)">>,
|
||||
<<"The field z is missing when constructing an element of type r2 (at line 15, column 24)">>,
|
||||
<<"Record type r2 does not have field y (at line 15, column 22)">>]}
|
||||
<<"No record type with fields y, z (at line 14, column 22)">>]}
|
||||
, {"init_type_error",
|
||||
[<<"Cannot unify string\n"
|
||||
" and map(int, int)\n"
|
||||
@@ -208,125 +167,4 @@ failing_contracts() ->
|
||||
[<<"The field x is missing when constructing an element of type r('a) (at line 7, column 40)">>,
|
||||
<<"The field y is missing when constructing an element of type r(int) (at line 8, column 40)">>,
|
||||
<<"The fields y, z are missing when constructing an element of type r('1) (at line 6, column 40)">>]}
|
||||
, {"namespace_clash",
|
||||
[<<"The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>]}
|
||||
, {"bad_events",
|
||||
[<<"The payload type int (at line 10, column 30) should be string">>,
|
||||
<<"The payload type alias_address (at line 12, column 30) equals address but it should be string">>,
|
||||
<<"The indexed type string (at line 9, column 25) is not a word type">>,
|
||||
<<"The indexed type alias_string (at line 11, column 25) equals string which is not a word type">>]}
|
||||
, {"bad_events2",
|
||||
[<<"The event constructor BadEvent1 (at line 9, column 7) has too many non-indexed values (max 1)">>,
|
||||
<<"The event constructor BadEvent2 (at line 10, column 7) has too many indexed values (max 3)">>,
|
||||
<<"The event constructor BadEvent3 (at line 11, column 7) has too many non-indexed values (max 1)">>,
|
||||
<<"The payload type address (at line 11, column 17) should be string">>,
|
||||
<<"The payload type int (at line 11, column 26) should be string">>]}
|
||||
, {"type_clash",
|
||||
[<<"Cannot unify int\n"
|
||||
" and string\n"
|
||||
"when checking the record projection at line 12, column 40\n"
|
||||
" r.foo : (gas : int, value : int) => Remote.themap\n"
|
||||
"against the expected type\n"
|
||||
" (gas : int, value : int) => map(string, int)">>]}
|
||||
, {"bad_include_and_ns",
|
||||
[<<"Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
|
||||
<<"Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>]}
|
||||
, {"bad_address_literals",
|
||||
[<<"The type bytes(32) is not a contract type\n"
|
||||
"when checking that the contract literal at line 32, column 5\n"
|
||||
" ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
|
||||
"has the type\n"
|
||||
" bytes(32)">>,
|
||||
<<"The type oracle(int, bool) is not a contract type\n"
|
||||
"when checking that the contract literal at line 30, column 5\n"
|
||||
" ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
|
||||
"has the type\n"
|
||||
" oracle(int, bool)">>,
|
||||
<<"The type address is not a contract type\n"
|
||||
"when checking that the contract literal at line 28, column 5\n"
|
||||
" ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
|
||||
"has the type\n"
|
||||
" address">>,
|
||||
<<"Cannot unify oracle_query('1, '2)\n"
|
||||
" and Remote\n"
|
||||
"when checking the type of the expression at line 25, column 5\n"
|
||||
" oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
|
||||
" oracle_query('1, '2)\n"
|
||||
"against the expected type\n"
|
||||
" Remote">>,
|
||||
<<"Cannot unify oracle_query('3, '4)\n"
|
||||
" and bytes(32)\n"
|
||||
"when checking the type of the expression at line 23, column 5\n"
|
||||
" oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
|
||||
" oracle_query('3, '4)\n"
|
||||
"against the expected type\n"
|
||||
" bytes(32)">>,
|
||||
<<"Cannot unify oracle_query('5, '6)\n"
|
||||
" and oracle(int, bool)\n"
|
||||
"when checking the type of the expression at line 21, column 5\n"
|
||||
" oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
|
||||
" oracle_query('5, '6)\n"
|
||||
"against the expected type\n"
|
||||
" oracle(int, bool)">>,
|
||||
<<"Cannot unify oracle('7, '8)\n"
|
||||
" and Remote\n"
|
||||
"when checking the type of the expression at line 18, column 5\n"
|
||||
" ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
|
||||
" oracle('7, '8)\n"
|
||||
"against the expected type\n"
|
||||
" Remote">>,
|
||||
<<"Cannot unify oracle('9, '10)\n"
|
||||
" and bytes(32)\n"
|
||||
"when checking the type of the expression at line 16, column 5\n"
|
||||
" ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
|
||||
" oracle('9, '10)\n"
|
||||
"against the expected type\n"
|
||||
" bytes(32)">>,
|
||||
<<"Cannot unify oracle('11, '12)\n"
|
||||
" and oracle_query(int, bool)\n"
|
||||
"when checking the type of the expression at line 14, column 5\n"
|
||||
" ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
|
||||
" oracle('11, '12)\n"
|
||||
"against the expected type\n"
|
||||
" oracle_query(int, bool)">>,
|
||||
<<"Cannot unify address\n"
|
||||
" and oracle(int, bool)\n"
|
||||
"when checking the type of the expression at line 11, column 5\n"
|
||||
" ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
|
||||
"against the expected type\n"
|
||||
" oracle(int, bool)">>,
|
||||
<<"Cannot unify address\n"
|
||||
" and Remote\n"
|
||||
"when checking the type of the expression at line 9, column 5\n"
|
||||
" ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
|
||||
"against the expected type\n"
|
||||
" Remote">>,
|
||||
<<"Cannot unify address\n"
|
||||
" and bytes(32)\n"
|
||||
"when checking the type of the expression at line 7, column 5\n"
|
||||
" ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
|
||||
"against the expected type\n"
|
||||
" bytes(32)">>]}
|
||||
, {"stateful",
|
||||
[<<"Cannot reference stateful function Chain.spend (at line 13, column 33)\nin the definition of non-stateful function fail1.">>,
|
||||
<<"Cannot reference stateful function local_spend (at line 14, column 33)\nin the definition of non-stateful function fail2.">>,
|
||||
<<"Cannot reference stateful function Chain.spend (at line 16, column 15)\nin the definition of non-stateful function fail3.">>,
|
||||
<<"Cannot reference stateful function Chain.spend (at line 20, column 31)\nin the definition of non-stateful function fail4.">>,
|
||||
<<"Cannot reference stateful function Chain.spend (at line 35, column 53)\nin the definition of non-stateful function fail5.">>,
|
||||
<<"Cannot pass non-zero value argument 1000 (at line 48, column 55)\nin the definition of non-stateful function fail6.">>,
|
||||
<<"Cannot pass non-zero value argument 1000 (at line 49, column 54)\nin the definition of non-stateful function fail7.">>,
|
||||
<<"Cannot pass non-zero value argument 1000 (at line 52, column 17)\nin the definition of non-stateful function fail8.">>]}
|
||||
, {"bad_init_state_access",
|
||||
[<<"The init function should return the initial state as its result and cannot write the state,\n"
|
||||
"but it calls\n"
|
||||
" - set_state (at line 11, column 5), which calls\n"
|
||||
" - roundabout (at line 8, column 36), which calls\n"
|
||||
" - put (at line 7, column 37)">>,
|
||||
<<"The init function should return the initial state as its result and cannot read the state,\n"
|
||||
"but it calls\n"
|
||||
" - new_state (at line 12, column 5), which calls\n"
|
||||
" - state (at line 5, column 27)">>,
|
||||
<<"The init function should return the initial state as its result and cannot read the state,\n"
|
||||
"but it calls\n"
|
||||
" - state (at line 13, column 13)">>]}
|
||||
].
|
||||
|
||||
@@ -12,11 +12,9 @@ groups() ->
|
||||
, aeso_parser_tests
|
||||
, aeso_compiler_tests
|
||||
, aeso_abi_tests
|
||||
, aeso_aci_tests
|
||||
]}].
|
||||
|
||||
aeso_scan_tests(_Config) -> ok = eunit:test(aeso_scan_tests).
|
||||
aeso_parser_tests(_Config) -> ok = eunit:test(aeso_parser_tests).
|
||||
aeso_compiler_tests(_Config) -> ok = eunit:test(aeso_compiler_tests).
|
||||
aeso_abi_tests(_Config) -> ok = eunit:test(aeso_abi_tests).
|
||||
aeso_aci_tests(_Config) -> ok = eunit:test(aeso_aci_tests).
|
||||
|
||||
@@ -41,14 +41,14 @@ all_tokens() ->
|
||||
%% Operators
|
||||
lists:map(Lit, ['=', '==', '!=', '>', '<', '>=', '=<', '-', '+', '++', '*', '/', mod, ':', '::', '->', '=>', '||', '&&', '!']) ++
|
||||
%% Keywords
|
||||
lists:map(Lit, [contract, type, 'let', switch]) ++
|
||||
lists:map(Lit, [contract, type, 'let', switch, rec, 'and']) ++
|
||||
%% Comment token (not an actual token), just for tests
|
||||
[{comment, 0, "// *Comment!\"\n"},
|
||||
{comment, 0, "/* bla /* bla bla */*/"}] ++
|
||||
%% Literals
|
||||
[ Lit(true), Lit(false)
|
||||
, Tok(id, "foo"), Tok(id, "_"), Tok(con, "Foo")
|
||||
, Tok(bytes, Hash)
|
||||
, Tok(hash, Hash)
|
||||
, Tok(int, 1234567890), Tok(hex, 9876543210)
|
||||
, Tok(string, <<"bla\"\\\b\e\f\n\r\t\vbla">>)
|
||||
].
|
||||
@@ -78,7 +78,7 @@ show_token({param, _, P}) -> "@" ++ P;
|
||||
show_token({string, _, S}) -> fmt(binary_to_list(S));
|
||||
show_token({int, _, N}) -> fmt(N);
|
||||
show_token({hex, _, N}) -> fmt("0x~.16b", N);
|
||||
show_token({bytes, _, <<N:256>>}) -> fmt("#~64.16.0b", N);
|
||||
show_token({hash, _, <<N:256>>}) -> fmt("#~.16b", N);
|
||||
show_token({comment, _, S}) -> S;
|
||||
show_token({_, _, _}) -> "TODO".
|
||||
|
||||
|
||||
@@ -0,0 +1,28 @@
|
||||
-module(contract_tests).
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
make_cmd() -> "make -C " ++ aeso_test_utils:contract_path().
|
||||
|
||||
contracts_test_() ->
|
||||
{setup,
|
||||
fun() -> os:cmd(make_cmd()) end,
|
||||
fun(_) -> os:cmd(make_cmd() ++ " clean") end,
|
||||
[ {"Testing the " ++ Contract ++ " contract",
|
||||
fun() ->
|
||||
?assertCmdOutput(Expected, filename:join(aeso_test_utils:contract_path(), Contract ++ "_test"))
|
||||
end} || {Contract, Expected} <- contracts() ]}.
|
||||
|
||||
contracts() ->
|
||||
[].
|
||||
%% [{"voting",
|
||||
%% "Delegate before vote\n"
|
||||
%% "Cake: 1\n"
|
||||
%% "Beer: 2\n"
|
||||
%% "Winner: Beer\n"
|
||||
%% "Delegate after vote\n"
|
||||
%% "Cake: 1\n"
|
||||
%% "Beer: 2\n"
|
||||
%% "Winner: Beer\n"
|
||||
%% }].
|
||||
|
||||
@@ -1,33 +0,0 @@
|
||||
contract Remote =
|
||||
function main : (int) => ()
|
||||
|
||||
contract AddrChain =
|
||||
type o_type = oracle(string, map(string, int))
|
||||
type oq_type = oracle_query(string, map(string, int))
|
||||
|
||||
function is_o(a : address) =
|
||||
Address.is_oracle(a)
|
||||
|
||||
function is_c(a : address) =
|
||||
Address.is_contract(a)
|
||||
|
||||
// function get_o(a : address) : option(o_type) =
|
||||
// Address.get_oracle(a)
|
||||
|
||||
// function get_c(a : address) : option(Remote) =
|
||||
// Address.get_contract(a)
|
||||
|
||||
function check_o(o : o_type) =
|
||||
Oracle.check(o)
|
||||
|
||||
function check_oq(o : o_type, oq : oq_type) =
|
||||
Oracle.check_query(o, oq)
|
||||
|
||||
// function h_to_i(h : hash) : int =
|
||||
// Hash.to_int(h)
|
||||
|
||||
// function a_to_i(a : address) : int =
|
||||
// Address.to_int(a) mod 10 ^ 16
|
||||
|
||||
function c_creator() : address =
|
||||
Contract.creator
|
||||
@@ -1,14 +0,0 @@
|
||||
|
||||
contract Remote =
|
||||
function foo : () => ()
|
||||
|
||||
contract AddressLiterals =
|
||||
function addr() : address =
|
||||
ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
|
||||
function oracle() : oracle(int, bool) =
|
||||
ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
|
||||
function query() : oracle_query(int, bool) =
|
||||
oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
|
||||
function contr() : Remote =
|
||||
ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
|
||||
|
||||
@@ -36,6 +36,11 @@ contract AllSyntax =
|
||||
(x, [y, z]) => bar({x = z, y = -y + - -z * (-1)})
|
||||
(x, y :: _) => ()
|
||||
|
||||
function mutual() =
|
||||
let rec recFun(x : int) = mutFun(x)
|
||||
and mutFun(x) = if(x =< 0) 1 else x * recFun(x - 1)
|
||||
recFun(0)
|
||||
|
||||
let hash : address = #01ab0fff11
|
||||
let b = false
|
||||
let qcon = Mod.Con
|
||||
|
||||
@@ -1,33 +0,0 @@
|
||||
|
||||
contract Remote =
|
||||
function foo : () => ()
|
||||
|
||||
contract AddressLiterals =
|
||||
function addr1() : bytes(32) =
|
||||
ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
|
||||
function addr2() : Remote =
|
||||
ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
|
||||
function addr3() : oracle(int, bool) =
|
||||
ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
|
||||
|
||||
function oracle1() : oracle_query(int, bool) =
|
||||
ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
|
||||
function oracle2() : bytes(32) =
|
||||
ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
|
||||
function oracle3() : Remote =
|
||||
ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
|
||||
|
||||
function query1() : oracle(int, bool) =
|
||||
oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
|
||||
function query2() : bytes(32) =
|
||||
oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
|
||||
function query3() : Remote =
|
||||
oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
|
||||
|
||||
function contr1() : address =
|
||||
ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
|
||||
function contr2() : oracle(int, bool) =
|
||||
ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
|
||||
function contr3() : bytes(32) =
|
||||
ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
contract Events =
|
||||
type alias_int = int
|
||||
type alias_address = address
|
||||
type alias_string = string
|
||||
|
||||
datatype event =
|
||||
Event1(indexed alias_int, indexed int, string)
|
||||
| Event2(alias_string, indexed alias_address)
|
||||
| BadEvent1(indexed string, string)
|
||||
| BadEvent2(indexed int, int)
|
||||
| BadEvent3(indexed alias_string, string)
|
||||
| BadEvent4(indexed int, alias_address)
|
||||
|
||||
function f1(x : int, y : string) =
|
||||
Chain.event(Event1(x, x+1, y))
|
||||
|
||||
function f2(s : string) =
|
||||
Chain.event(Event2(s, Call.caller))
|
||||
|
||||
function f3(x : int) =
|
||||
Chain.event(Event1(x, x + 2, Int.to_str(x + 7)))
|
||||
|
||||
function i2s(i : int) = Int.to_str(i)
|
||||
function a2s(a : address) = Address.to_str(a)
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
contract Events =
|
||||
type alias_int = int
|
||||
type alias_address = address
|
||||
type alias_string = string
|
||||
|
||||
datatype event =
|
||||
Event1(indexed alias_int, indexed int, string)
|
||||
| Event2(alias_string, indexed alias_address)
|
||||
| BadEvent1(string, string)
|
||||
| BadEvent2(indexed int, indexed int, indexed int, indexed address)
|
||||
| BadEvent3(address, int)
|
||||
|
||||
function f1(x : int, y : string) =
|
||||
Chain.event(Event1(x, x+1, y))
|
||||
|
||||
function f2(s : string) =
|
||||
Chain.event(Event2(s, Call.caller))
|
||||
|
||||
function f3(x : int) =
|
||||
Chain.event(Event1(x, x + 2, Int.to_str(x + 7)))
|
||||
|
||||
function i2s(i : int) = Int.to_str(i)
|
||||
function a2s(a : address) = Address.to_str(a)
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
contract Bad =
|
||||
include "included.aes"
|
||||
namespace Foo =
|
||||
function foo() = 42
|
||||
|
||||
function foo() = 43
|
||||
@@ -1,13 +0,0 @@
|
||||
contract BadInit =
|
||||
|
||||
type state = int
|
||||
|
||||
function new_state(n) = state + n
|
||||
|
||||
stateful function roundabout(n) = put(n)
|
||||
stateful function set_state(n) = roundabout(n)
|
||||
|
||||
stateful function init() =
|
||||
set_state(4)
|
||||
new_state(0)
|
||||
state + state
|
||||
@@ -1,19 +0,0 @@
|
||||
// Contract replicating "normal" Aeternity authentication
|
||||
contract BasicAuth =
|
||||
record state = { nonce : int, owner : address }
|
||||
|
||||
function init() = { nonce = 1, owner = Call.caller }
|
||||
|
||||
stateful function authorize(n : int, s : signature) : bool =
|
||||
require(n >= state.nonce, "Nonce too low")
|
||||
require(n =< state.nonce, "Nonce too high")
|
||||
put(state{ nonce = n + 1 })
|
||||
switch(Auth.tx_hash)
|
||||
None => abort("Not in Auth context")
|
||||
Some(tx_hash) => Crypto.ecverify(to_sign(tx_hash, n), state.owner, s)
|
||||
|
||||
function to_sign(h : hash, n : int) =
|
||||
Crypto.blake2b((h, n))
|
||||
|
||||
private function require(b : bool, err : string) =
|
||||
if(!b) abort(err)
|
||||
@@ -1,18 +0,0 @@
|
||||
contract BitcoinAuth =
|
||||
record state = { nonce : int, owner : bytes(64) }
|
||||
|
||||
function init(owner' : bytes(64)) = { nonce = 1, owner = owner' }
|
||||
|
||||
stateful function authorize(n : int, s : signature) : bool =
|
||||
require(n >= state.nonce, "Nonce too low")
|
||||
require(n =< state.nonce, "Nonce too high")
|
||||
put(state{ nonce = n + 1 })
|
||||
switch(Auth.tx_hash)
|
||||
None => abort("Not in Auth context")
|
||||
Some(tx_hash) => Crypto.ecverify_secp256k1(to_sign(tx_hash, n), state.owner, s)
|
||||
|
||||
function to_sign(h : hash, n : int) : hash =
|
||||
Crypto.blake2b((h, n))
|
||||
|
||||
private function require(b : bool, err : string) =
|
||||
if(!b) abort(err)
|
||||
@@ -1,18 +0,0 @@
|
||||
|
||||
contract BytesEquality =
|
||||
|
||||
function eq16(a : bytes(16), b) = a == b
|
||||
function ne16(a : bytes(16), b) = a != b
|
||||
|
||||
function eq32(a : bytes(32), b) = a == b
|
||||
function ne32(a : bytes(32), b) = a != b
|
||||
|
||||
function eq47(a : bytes(47), b) = a == b
|
||||
function ne47(a : bytes(47), b) = a != b
|
||||
|
||||
function eq64(a : bytes(64), b) = a == b
|
||||
function ne64(a : bytes(64), b) = a != b
|
||||
|
||||
function eq65(a : bytes(65), b) = a == b
|
||||
function ne65(a : bytes(65), b) = a != b
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
// Test more advanced chain interactions
|
||||
|
||||
contract ChainTest =
|
||||
contract Chain =
|
||||
|
||||
record state = { last_bf : address }
|
||||
|
||||
|
||||
@@ -5,5 +5,5 @@ contract Counter =
|
||||
|
||||
function init(val) = { value = val }
|
||||
function get() = state.value
|
||||
stateful function tick() = put(state{ value = state.value + 1 })
|
||||
function tick() = put(state{ value = state.value + 1 })
|
||||
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
|
||||
namespace List =
|
||||
|
||||
function map1(f : 'a => 'b, xs : list('a)) =
|
||||
switch(xs)
|
||||
[] => []
|
||||
x :: xs => f(x) :: map1(f, xs)
|
||||
|
||||
function map2(f : 'a => 'b, xs : list('a)) =
|
||||
switch(xs)
|
||||
[] => []
|
||||
x :: xs => f(x) :: map2(f, xs)
|
||||
|
||||
contract Deadcode =
|
||||
|
||||
function inc1(xs : list(int)) : list(int) =
|
||||
List.map1((x) => x + 1, xs)
|
||||
|
||||
function inc2(xs : list(int)) : list(int) =
|
||||
List.map1((x) => x + 1, xs)
|
||||
|
||||
@@ -10,7 +10,7 @@ contract DutchAuction =
|
||||
sold : bool }
|
||||
|
||||
// Add to work around current lack of predefined functions
|
||||
private stateful function spend(to, amount) =
|
||||
private function spend(to, amount) =
|
||||
let total = Contract.balance
|
||||
Chain.spend(to, amount)
|
||||
total - amount
|
||||
|
||||
@@ -12,7 +12,7 @@ contract Environment =
|
||||
|
||||
function init(remote) = {remote = remote}
|
||||
|
||||
stateful function set_remote(remote) = put({remote = remote})
|
||||
function set_remote(remote) = put({remote = remote})
|
||||
|
||||
// -- Information about the this contract ---
|
||||
|
||||
@@ -38,7 +38,7 @@ contract Environment =
|
||||
|
||||
// Value
|
||||
function call_value() : int = Call.value
|
||||
stateful function nested_value(value : int) : int =
|
||||
function nested_value(value : int) : int =
|
||||
state.remote.call_value(value = value / 2)
|
||||
|
||||
// Gas price
|
||||
|
||||
@@ -9,7 +9,7 @@ contract Factorial =
|
||||
|
||||
function init(worker) = {worker = worker}
|
||||
|
||||
stateful function set_worker(worker) = put(state{worker = worker})
|
||||
function set_worker(worker) = put(state{worker = worker})
|
||||
|
||||
function fac(x : int) : int =
|
||||
if(x == 0) 1
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
contract Functions =
|
||||
private function curry(f : ('a, 'b) => 'c) =
|
||||
(x) => (y) => f(x, y)
|
||||
private function map(f : 'a => 'b, xs : list('a)) =
|
||||
switch(xs)
|
||||
[] => []
|
||||
x :: xs => f(x) :: map(f, xs)
|
||||
private function map'() = map
|
||||
private function plus(x, y) = x + y
|
||||
function test1(xs : list(int)) = map(curry(plus)(5), xs)
|
||||
function test2(xs : list(int)) = map'()(((x) => (y) => ((x, y) => x + y)(x, y))(100), xs)
|
||||
function test3(xs : list(int)) =
|
||||
let m(f, xs) = map(f, xs)
|
||||
m((x) => x + 1, xs)
|
||||
|
||||
@@ -15,7 +15,7 @@ contract FundMe =
|
||||
private function require(b : bool, err : string) =
|
||||
if(!b) abort(err)
|
||||
|
||||
private stateful function spend(args : spend_args) =
|
||||
private function spend(args : spend_args) =
|
||||
Chain.spend(args.recipient, args.amount)
|
||||
|
||||
public function init(beneficiary, deadline, goal) : state =
|
||||
@@ -53,7 +53,7 @@ contract FundMe =
|
||||
require(state.total >= state.goal, "Project was not funded")
|
||||
spend({recipient = state.beneficiary,
|
||||
amount = Contract.balance })
|
||||
put(state{ beneficiary = ak_11111111111111111111111111111111273Yts })
|
||||
put(state{ beneficiary = #0 })
|
||||
|
||||
private stateful function withdraw_contributor() =
|
||||
if(state.total >= state.goal)
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
include "included.aes"
|
||||
include "../contracts/included2.aes"
|
||||
|
||||
contract Include =
|
||||
function foo() =
|
||||
Included.foo() < Included2a.bar()
|
||||
|
||||
function bar() =
|
||||
Included2b.foo() > Included.foo()
|
||||
@@ -1,2 +0,0 @@
|
||||
namespace Included =
|
||||
function foo() = 42
|
||||
@@ -1,5 +0,0 @@
|
||||
namespace Included2a =
|
||||
function bar() = 43
|
||||
|
||||
namespace Included2b =
|
||||
function foo() = 44
|
||||
+12
-12
@@ -17,8 +17,8 @@ contract Maps =
|
||||
{ ["one"] = {x = 1, y = 2},
|
||||
["two"] = {x = 3, y = 4},
|
||||
["three"] = {x = 5, y = 6} }
|
||||
stateful function map_state_i() = put(state{ map_i = map_i() })
|
||||
stateful function map_state_s() = put(state{ map_s = map_s() })
|
||||
function map_state_i() = put(state{ map_i = map_i() })
|
||||
function map_state_s() = put(state{ map_s = map_s() })
|
||||
|
||||
// m[k]
|
||||
function get_i(k, m : map(int, pt)) = m[k]
|
||||
@@ -35,20 +35,20 @@ contract Maps =
|
||||
// m{[k] = v}
|
||||
function set_i(k, p, m : map(int, pt)) = m{ [k] = p }
|
||||
function set_s(k, p, m : map(string, pt)) = m{ [k] = p }
|
||||
stateful function set_state_i(k, p) = put(state{ map_i = set_i(k, p, state.map_i) })
|
||||
stateful function set_state_s(k, p) = put(state{ map_s = set_s(k, p, state.map_s) })
|
||||
function set_state_i(k, p) = put(state{ map_i = set_i(k, p, state.map_i) })
|
||||
function set_state_s(k, p) = put(state{ map_s = set_s(k, p, state.map_s) })
|
||||
|
||||
// m{f[k].x = v}
|
||||
function setx_i(k, x, m : map(int, pt)) = m{ [k].x = x }
|
||||
function setx_s(k, x, m : map(string, pt)) = m{ [k].x = x }
|
||||
stateful function setx_state_i(k, x) = put(state{ map_i[k].x = x })
|
||||
stateful function setx_state_s(k, x) = put(state{ map_s[k].x = x })
|
||||
function setx_state_i(k, x) = put(state{ map_i[k].x = x })
|
||||
function setx_state_s(k, x) = put(state{ map_s[k].x = x })
|
||||
|
||||
// m{[k] @ x = v }
|
||||
function addx_i(k, d, m : map(int, pt)) = m{ [k].x @ x = x + d }
|
||||
function addx_s(k, d, m : map(string, pt)) = m{ [k].x @ x = x + d }
|
||||
stateful function addx_state_i(k, d) = put(state{ map_i[k].x @ x = x + d })
|
||||
stateful function addx_state_s(k, d) = put(state{ map_s[k].x @ x = x + d })
|
||||
function addx_state_i(k, d) = put(state{ map_i[k].x @ x = x + d })
|
||||
function addx_state_s(k, d) = put(state{ map_s[k].x @ x = x + d })
|
||||
|
||||
// m{[k = def] @ x = v }
|
||||
function addx_def_i(k, v, d, m : map(int, pt)) = m{ [k = v].x @ x = x + d }
|
||||
@@ -77,8 +77,8 @@ contract Maps =
|
||||
// Map.delete
|
||||
function delete_i(k, m : map(int, pt)) = Map.delete(k, m)
|
||||
function delete_s(k, m : map(string, pt)) = Map.delete(k, m)
|
||||
stateful function delete_state_i(k) = put(state{ map_i = delete_i(k, state.map_i) })
|
||||
stateful function delete_state_s(k) = put(state{ map_s = delete_s(k, state.map_s) })
|
||||
function delete_state_i(k) = put(state{ map_i = delete_i(k, state.map_i) })
|
||||
function delete_state_s(k) = put(state{ map_s = delete_s(k, state.map_s) })
|
||||
|
||||
// Map.size
|
||||
function size_i(m : map(int, pt)) = Map.size(m)
|
||||
@@ -95,6 +95,6 @@ contract Maps =
|
||||
// Map.from_list
|
||||
function fromlist_i(xs : list((int, pt))) = Map.from_list(xs)
|
||||
function fromlist_s(xs : list((string, pt))) = Map.from_list(xs)
|
||||
stateful function fromlist_state_i(xs) = put(state{ map_i = fromlist_i(xs) })
|
||||
stateful function fromlist_state_s(xs) = put(state{ map_s = fromlist_s(xs) })
|
||||
function fromlist_state_i(xs) = put(state{ map_i = fromlist_i(xs) })
|
||||
function fromlist_state_s(xs) = put(state{ map_s = fromlist_s(xs) })
|
||||
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
|
||||
// You can't shadow existing contracts or namespaces.
|
||||
|
||||
contract Call =
|
||||
function whatever() = ()
|
||||
@@ -1,21 +0,0 @@
|
||||
|
||||
namespace Lib =
|
||||
|
||||
private function rev(xs, ys) =
|
||||
switch(xs)
|
||||
[] => ys
|
||||
x :: xs => rev(xs, x :: ys)
|
||||
|
||||
function reverse(xs : list('a)) : list('a) = rev(xs, [])
|
||||
|
||||
function eqlist(xs : list(int), ys : list(int)) =
|
||||
switch((xs, ys))
|
||||
([], []) => true
|
||||
(x :: xs, y :: ys) => x == y && eqlist(xs, ys)
|
||||
_ => false
|
||||
|
||||
contract TestNamespaces =
|
||||
|
||||
function palindrome(xs : list(int)) : bool =
|
||||
Lib.eqlist(xs, Lib.reverse(xs))
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
|
||||
namespace List =
|
||||
|
||||
function map1(f : 'a => 'b, xs : list('a)) =
|
||||
switch(xs)
|
||||
[] => []
|
||||
x :: xs => f(x) :: map1(f, xs)
|
||||
|
||||
function map2(f : 'a => 'b, xs : list('a)) =
|
||||
switch(xs)
|
||||
[] => []
|
||||
x :: xs => f(x) :: map2(f, xs)
|
||||
|
||||
contract Deadcode =
|
||||
|
||||
function inc1(xs : list(int)) : list(int) =
|
||||
List.map1((x) => x + 1, xs)
|
||||
|
||||
function inc2(xs : list(int)) : list(int) =
|
||||
List.map2((x) => x + 1, xs)
|
||||
|
||||
+13
-13
@@ -9,22 +9,22 @@ contract Oracles =
|
||||
type oracle_id = oracle(query_t, answer_t)
|
||||
type query_id = oracle_query(query_t, answer_t)
|
||||
|
||||
stateful function registerOracle(acct : address,
|
||||
function registerOracle(acct : address,
|
||||
qfee : fee,
|
||||
ttl : ttl) : oracle_id =
|
||||
Oracle.register(acct, qfee, ttl)
|
||||
|
||||
stateful function registerIntIntOracle(acct : address,
|
||||
function registerIntIntOracle(acct : address,
|
||||
qfee : fee,
|
||||
ttl : ttl) : oracle(int, int) =
|
||||
Oracle.register(acct, qfee, ttl)
|
||||
|
||||
stateful function registerStringStringOracle(acct : address,
|
||||
function registerStringStringOracle(acct : address,
|
||||
qfee : fee,
|
||||
ttl : ttl) : oracle(string, string) =
|
||||
Oracle.register(acct, qfee, ttl)
|
||||
|
||||
stateful function signedRegisterOracle(acct : address,
|
||||
function signedRegisterOracle(acct : address,
|
||||
sign : signature,
|
||||
qfee : fee,
|
||||
ttl : ttl) : oracle_id =
|
||||
@@ -33,7 +33,7 @@ contract Oracles =
|
||||
function queryFee(o : oracle_id) : fee =
|
||||
Oracle.query_fee(o)
|
||||
|
||||
stateful function createQuery(o : oracle_id,
|
||||
function createQuery(o : oracle_id,
|
||||
q : query_t,
|
||||
qfee : fee,
|
||||
qttl : ttl,
|
||||
@@ -42,7 +42,7 @@ contract Oracles =
|
||||
Oracle.query(o, q, qfee, qttl, rttl)
|
||||
|
||||
// Do not use in production!
|
||||
stateful function unsafeCreateQuery(o : oracle_id,
|
||||
function unsafeCreateQuery(o : oracle_id,
|
||||
q : query_t,
|
||||
qfee : fee,
|
||||
qttl : ttl,
|
||||
@@ -50,7 +50,7 @@ contract Oracles =
|
||||
Oracle.query(o, q, qfee, qttl, rttl)
|
||||
|
||||
// Do not use in production!
|
||||
stateful function unsafeCreateQueryThenErr(o : oracle_id,
|
||||
function unsafeCreateQueryThenErr(o : oracle_id,
|
||||
q : query_t,
|
||||
qfee : fee,
|
||||
qttl : ttl,
|
||||
@@ -59,21 +59,21 @@ contract Oracles =
|
||||
require(qfee >= 100000000000000000, "causing a late error")
|
||||
res
|
||||
|
||||
stateful function extendOracle(o : oracle_id,
|
||||
function extendOracle(o : oracle_id,
|
||||
ttl : ttl) : () =
|
||||
Oracle.extend(o, ttl)
|
||||
|
||||
stateful function signedExtendOracle(o : oracle_id,
|
||||
function signedExtendOracle(o : oracle_id,
|
||||
sign : signature, // Signed oracle address
|
||||
ttl : ttl) : () =
|
||||
Oracle.extend(o, signature = sign, ttl)
|
||||
|
||||
stateful function respond(o : oracle_id,
|
||||
function respond(o : oracle_id,
|
||||
q : query_id,
|
||||
r : answer_t) : () =
|
||||
Oracle.respond(o, q, r)
|
||||
|
||||
stateful function signedRespond(o : oracle_id,
|
||||
function signedRespond(o : oracle_id,
|
||||
q : query_id,
|
||||
sign : signature,
|
||||
r : answer_t) : () =
|
||||
@@ -96,13 +96,13 @@ contract Oracles =
|
||||
datatype complexQuestion = Why(int) | How(string)
|
||||
datatype complexAnswer = NoAnswer | Answer(complexQuestion, string, int)
|
||||
|
||||
stateful function complexOracle(question) =
|
||||
function complexOracle(question) =
|
||||
let o = Oracle.register(Contract.address, 0, FixedTTL(1000)) : oracle(complexQuestion, complexAnswer)
|
||||
let q = Oracle.query(o, question, 0, RelativeTTL(100), RelativeTTL(100))
|
||||
Oracle.respond(o, q, Answer(question, "magic", 1337))
|
||||
Oracle.get_answer(o, q)
|
||||
|
||||
stateful function signedComplexOracle(question, sig) =
|
||||
function signedComplexOracle(question, sig) =
|
||||
let o = Oracle.register(signature = sig, Contract.address, 0, FixedTTL(1000)) : oracle(complexQuestion, complexAnswer)
|
||||
let q = Oracle.query(o, question, 0, RelativeTTL(100), RelativeTTL(100))
|
||||
Oracle.respond(o, q, Answer(question, "magic", 1337), signature = sig)
|
||||
|
||||
@@ -11,7 +11,7 @@ contract Remote3 =
|
||||
|
||||
contract RemoteCall =
|
||||
|
||||
stateful function call(r : Remote1, x : int) : int =
|
||||
function call(r : Remote1, x : int) : int =
|
||||
r.main(gas = 10000, value = 10, x)
|
||||
|
||||
function staged_call(r1 : Remote1, r2 : Remote2, x : int) =
|
||||
|
||||
@@ -0,0 +1,99 @@
|
||||
contract Oracles =
|
||||
|
||||
function registerOracle :
|
||||
(address,
|
||||
int,
|
||||
Chain.ttl) => oracle(string, int)
|
||||
|
||||
function createQuery :
|
||||
(oracle(string, int),
|
||||
string,
|
||||
int,
|
||||
Chain.ttl,
|
||||
Chain.ttl) => oracle_query(string, int)
|
||||
|
||||
function unsafeCreateQuery :
|
||||
(oracle(string, int),
|
||||
string,
|
||||
int,
|
||||
Chain.ttl,
|
||||
Chain.ttl) => oracle_query(string, int)
|
||||
|
||||
function respond :
|
||||
(oracle(string, int),
|
||||
oracle_query(string, int),
|
||||
int) => ()
|
||||
|
||||
contract OraclesErr =
|
||||
|
||||
function unsafeCreateQueryThenErr :
|
||||
(oracle(string, int),
|
||||
string,
|
||||
int,
|
||||
Chain.ttl,
|
||||
Chain.ttl) => oracle_query(string, int)
|
||||
|
||||
contract RemoteOracles =
|
||||
|
||||
public function callRegisterOracle(
|
||||
r : Oracles,
|
||||
acct : address,
|
||||
qfee : int,
|
||||
ttl : Chain.ttl) : oracle(string, int) =
|
||||
r.registerOracle(acct, qfee, ttl)
|
||||
|
||||
public function callCreateQuery(
|
||||
r : Oracles,
|
||||
value : int,
|
||||
o : oracle(string, int),
|
||||
q : string,
|
||||
qfee : int,
|
||||
qttl : Chain.ttl,
|
||||
rttl : Chain.ttl) : oracle_query(string, int) =
|
||||
require(value =< Call.value, "insufficient value")
|
||||
r.createQuery(value = value, o, q, qfee, qttl, rttl)
|
||||
|
||||
// Do not use in production!
|
||||
public function callUnsafeCreateQuery(
|
||||
r : Oracles,
|
||||
value : int,
|
||||
o : oracle(string, int),
|
||||
q : string,
|
||||
qfee : int,
|
||||
qttl : Chain.ttl,
|
||||
rttl : Chain.ttl) : oracle_query(string, int) =
|
||||
r.unsafeCreateQuery(value = value, o, q, qfee, qttl, rttl)
|
||||
|
||||
// Do not use in production!
|
||||
public function callUnsafeCreateQueryThenErr(
|
||||
r : OraclesErr,
|
||||
value : int,
|
||||
o : oracle(string, int),
|
||||
q : string,
|
||||
qfee : int,
|
||||
qttl : Chain.ttl,
|
||||
rttl : Chain.ttl) : oracle_query(string, int) =
|
||||
r.unsafeCreateQueryThenErr(value = value, o, q, qfee, qttl, rttl)
|
||||
|
||||
// Do not use in production!
|
||||
public function callUnsafeCreateQueryAndThenErr(
|
||||
r : Oracles,
|
||||
value : int,
|
||||
o : oracle(string, int),
|
||||
q : string,
|
||||
qfee : int,
|
||||
qttl : Chain.ttl,
|
||||
rttl : Chain.ttl) : oracle_query(string, int) =
|
||||
let x = r.unsafeCreateQuery(value = value, o, q, qfee, qttl, rttl)
|
||||
switch(0) 1 => ()
|
||||
x // Never reached.
|
||||
|
||||
public function callRespond(
|
||||
r : Oracles,
|
||||
o : oracle(string, int),
|
||||
q : oracle_query(string, int),
|
||||
qr : int) =
|
||||
r.respond(o, q, qr)
|
||||
|
||||
private function require(b : bool, err : string) =
|
||||
if(!b) abort(err)
|
||||
@@ -18,11 +18,12 @@
|
||||
|
||||
contract SimpleStorage =
|
||||
|
||||
type event = int
|
||||
record state = { data : int }
|
||||
|
||||
function init(value : int) : state = { data = value }
|
||||
|
||||
function get() : int = state.data
|
||||
|
||||
stateful function set(value : int) =
|
||||
function set(value : int) =
|
||||
put(state{data = value})
|
||||
|
||||
@@ -4,19 +4,19 @@ contract SpendContract =
|
||||
|
||||
contract SpendTest =
|
||||
|
||||
stateful function spend(to, amount) =
|
||||
function spend(to, amount) =
|
||||
let total = Contract.balance
|
||||
Chain.spend(to, amount)
|
||||
total - amount
|
||||
|
||||
stateful function withdraw(amount) : int =
|
||||
function withdraw(amount) : int =
|
||||
spend(Call.caller, amount)
|
||||
|
||||
stateful function withdraw_from(account, amount) =
|
||||
function withdraw_from(account, amount) =
|
||||
account.withdraw(amount)
|
||||
withdraw(amount)
|
||||
|
||||
stateful function spend_from(from, to, amount) =
|
||||
function spend_from(from, to, amount) =
|
||||
from.withdraw(amount)
|
||||
Chain.spend(to, amount)
|
||||
Chain.balance(to)
|
||||
|
||||
@@ -1,22 +1,19 @@
|
||||
contract Remote =
|
||||
record rstate = { i : int, s : string, m : map(int, int) }
|
||||
|
||||
function look_at : (rstate) => ()
|
||||
function look_at : (state) => ()
|
||||
function return_s : (bool) => string
|
||||
function return_m : (bool) => map(int, int)
|
||||
function get : (rstate) => rstate
|
||||
function get_i : (rstate) => int
|
||||
function get_s : (rstate) => string
|
||||
function get_m : (rstate) => map(int, int)
|
||||
function get : (state) => state
|
||||
function get_i : (state) => int
|
||||
function get_s : (state) => string
|
||||
function get_m : (state) => map(int, int)
|
||||
|
||||
function fun_update_i : (rstate, int) => rstate
|
||||
function fun_update_s : (rstate, string) => rstate
|
||||
function fun_update_m : (rstate, map(int, int)) => rstate
|
||||
function fun_update_mk : (rstate, int, int) => rstate
|
||||
function fun_update_i : (state, int) => state
|
||||
function fun_update_s : (state, string) => state
|
||||
function fun_update_m : (state, map(int, int)) => state
|
||||
function fun_update_mk : (state, int, int) => state
|
||||
|
||||
contract StateHandling =
|
||||
|
||||
type state = Remote.rstate
|
||||
record state = { i : int, s : string, m : map(int, int) }
|
||||
|
||||
function init(r : Remote, i : int) =
|
||||
let state0 = { i = 0, s = "undefined", m = {} }
|
||||
@@ -27,13 +24,13 @@ contract StateHandling =
|
||||
function read_s() = state.s
|
||||
function read_m() = state.m
|
||||
|
||||
stateful function update(new_state : state) = put(new_state)
|
||||
stateful function update_i(new_i) = put(state{ i = new_i })
|
||||
stateful function update_s(new_s) = put(state{ s = new_s })
|
||||
stateful function update_m(new_m) = put(state{ m = new_m })
|
||||
function update(new_state : state) = put(new_state)
|
||||
function update_i(new_i) = put(state{ i = new_i })
|
||||
function update_s(new_s) = put(state{ s = new_s })
|
||||
function update_m(new_m) = put(state{ m = new_m })
|
||||
|
||||
function pass_it(r : Remote) = r.look_at(state)
|
||||
stateful function nop(r : Remote) = put(state{ i = state.i })
|
||||
function nop(r : Remote) = put(state{ i = state.i })
|
||||
function return_it_s(r : Remote, big : bool) =
|
||||
let x = r.return_s(big)
|
||||
String.length(x)
|
||||
@@ -50,10 +47,10 @@ contract StateHandling =
|
||||
function pass_update_s(r : Remote, s) = r.fun_update_s(state, s)
|
||||
function pass_update_m(r : Remote, m) = r.fun_update_m(state, m)
|
||||
|
||||
stateful function remote_update_i (r : Remote, i) = put(r.fun_update_i(state, i))
|
||||
stateful function remote_update_s (r : Remote, s) = put(r.fun_update_s(state, s))
|
||||
stateful function remote_update_m (r : Remote, m) = put(r.fun_update_m(state, m))
|
||||
stateful function remote_update_mk(r : Remote, k, v) = put(r.fun_update_mk(state, k, v))
|
||||
function remote_update_i (r : Remote, i) = put(r.fun_update_i(state, i))
|
||||
function remote_update_s (r : Remote, s) = put(r.fun_update_s(state, s))
|
||||
function remote_update_m (r : Remote, m) = put(r.fun_update_m(state, m))
|
||||
function remote_update_mk(r : Remote, k, v) = put(r.fun_update_mk(state, k, v))
|
||||
|
||||
// remote called
|
||||
function look_at(s : state) = ()
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
|
||||
contract Remote =
|
||||
stateful function remote_spend : (address, int) => ()
|
||||
function remote_pure : int => int
|
||||
|
||||
contract Stateful =
|
||||
|
||||
private function pure(x) = x + 1
|
||||
private stateful function local_spend(a) =
|
||||
Chain.spend(a, 1000)
|
||||
|
||||
// Non-stateful functions cannot mention stateful functions
|
||||
function fail1(a : address) = Chain.spend(a, 1000)
|
||||
function fail2(a : address) = local_spend(a)
|
||||
function fail3(a : address) =
|
||||
let foo = Chain.spend
|
||||
foo(a, 1000)
|
||||
|
||||
// Private functions must also be annotated
|
||||
private function fail4(a) = Chain.spend(a, 1000)
|
||||
|
||||
// If annotated, stateful functions are allowed
|
||||
stateful function ok1(a : address) = Chain.spend(a, 1000)
|
||||
|
||||
// And pure functions are always allowed
|
||||
stateful function ok2(a : address) = pure(5)
|
||||
stateful function ok3(a : address) =
|
||||
let foo = pure
|
||||
foo(5)
|
||||
|
||||
// No error here (fail4 is annotated as not stateful)
|
||||
function ok4(a : address) = fail4(a)
|
||||
|
||||
// Lamdbas are checked at the construction site
|
||||
private function fail5() : address => () = (a) => Chain.spend(a, 1000)
|
||||
|
||||
// .. so you can pass a stateful lambda to a non-stateful higher-order
|
||||
// function:
|
||||
private function apply(f : 'a => 'b, x) = f(x)
|
||||
stateful function ok5(a : address) =
|
||||
apply((val) => Chain.spend(a, val), 1000)
|
||||
|
||||
// It doesn't matter if remote calls are stateful or not
|
||||
function ok6(r : Remote) = r.remote_spend(Contract.address, 1000)
|
||||
function ok7(r : Remote) = r.remote_pure(5)
|
||||
|
||||
// But you can't send any tokens if not stateful
|
||||
function fail6(r : Remote) = r.remote_spend(value = 1000, Contract.address, 1000)
|
||||
function fail7(r : Remote) = r.remote_pure(value = 1000, 5)
|
||||
function fail8(r : Remote) =
|
||||
let foo = r.remote_pure
|
||||
foo(value = 1000, 5)
|
||||
function ok8(r : Remote) = r.remote_spend(Contract.address, 1000, value = 0)
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
|
||||
contract Remote =
|
||||
|
||||
type themap = map(int, string)
|
||||
function foo : () => themap
|
||||
|
||||
contract Main =
|
||||
|
||||
type themap = map(string, int)
|
||||
|
||||
// Should fail
|
||||
function foo(r : Remote) : themap = r.foo()
|
||||
|
||||
@@ -40,5 +40,3 @@ contract Test =
|
||||
|
||||
function type_error(r, x) =
|
||||
set_x(set_x(x, r), x)
|
||||
|
||||
function repeated_arg(x : int, y, x : string, y : bool) : string = x
|
||||
|
||||
@@ -11,11 +11,11 @@ contract VariantTypes =
|
||||
|
||||
function require(b) = if(!b) abort("required")
|
||||
|
||||
stateful function start(bal : int) =
|
||||
function start(bal : int) =
|
||||
switch(state)
|
||||
Stopped => put(Started({owner = Call.caller, balance = bal, color = Grey(0)}))
|
||||
|
||||
stateful function stop() =
|
||||
function stop() =
|
||||
switch(state)
|
||||
Started(st) =>
|
||||
require(Call.caller == st.owner)
|
||||
@@ -23,7 +23,7 @@ contract VariantTypes =
|
||||
st.balance
|
||||
|
||||
function get_color() = switch(state) Started(st) => st.color
|
||||
stateful function set_color(c) = switch(state) Started(st) => put(Started(st{color = c}))
|
||||
function set_color(c) = switch(state) Started(st) => put(Started(st{color = c}))
|
||||
|
||||
function get_state() = state
|
||||
|
||||
|
||||
Reference in New Issue
Block a user