Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Ulf Norell
|
4cd1554a2d |
@@ -8,15 +8,6 @@ executors:
|
||||
working_directory: ~/aesophia
|
||||
|
||||
jobs:
|
||||
verify_rebar_lock:
|
||||
executor: aebuilder
|
||||
steps:
|
||||
- checkout
|
||||
- run:
|
||||
name: Ensure lock file is up-to-date
|
||||
command: |
|
||||
./rebar3 upgrade
|
||||
git diff --quiet -- rebar.lock || (echo "rebar.lock is not up-to-date" && exit 1)
|
||||
build:
|
||||
executor: aebuilder
|
||||
steps:
|
||||
@@ -44,10 +35,3 @@ jobs:
|
||||
- _build/default/rebar3_20.3.8_plt
|
||||
- store_artifacts:
|
||||
path: _build/test/logs
|
||||
|
||||
workflows:
|
||||
version: 2
|
||||
build_test:
|
||||
jobs:
|
||||
- build
|
||||
- verify_rebar_lock
|
||||
|
||||
+25
-77
@@ -9,71 +9,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
||||
### Changed
|
||||
### Removed
|
||||
|
||||
## [4.3.0]
|
||||
## [4.0.0-rc4] - 2019-09-13
|
||||
### Added
|
||||
- Added documentation (moved from `protocol`)
|
||||
- `Frac.aes` – library for rational numbers
|
||||
- Added some more meaningful error messages
|
||||
- Exported several parsing functionalities
|
||||
- With option `keep_included` it is possible to see which files were included during the parse
|
||||
- There is a function `run_parser` that be used to evaluate any parsing rule
|
||||
- Exported parsers: `body`, `type` and `decl`
|
||||
### Changed
|
||||
- Performance improvements in the standard library
|
||||
- Fixed ACI encoder to handle `-` unary operator
|
||||
- Fixed including by absolute path
|
||||
- Fixed variant type printing in the ACI error messages
|
||||
- Fixed pretty printing of combined function clauses
|
||||
### Removed
|
||||
- `let` definitions are no longer supported in the toplevel of the contract
|
||||
- type declarations are no longer supported
|
||||
|
||||
## [4.2.0] - 2020-01-15
|
||||
### Added
|
||||
- Allow separate entrypoint/function type signature and definition, and pattern
|
||||
matching in left-hand sides:
|
||||
```
|
||||
function
|
||||
length : list('a) => int
|
||||
length([]) = 0
|
||||
length(x :: xs) = 1 + length(xs)
|
||||
```
|
||||
- Allow pattern matching in list comprehension generators (filtering out match
|
||||
failures):
|
||||
```
|
||||
function somes(xs : list(option('a))) : list('a) =
|
||||
[ x | Some(x) <- xs ]
|
||||
```
|
||||
- Allow pattern matching in let-bindings (aborting on match failures):
|
||||
```
|
||||
function test(m : map(int, int)) =
|
||||
let Some(x) = Map.lookup(m, 0)
|
||||
x
|
||||
```
|
||||
### Changed
|
||||
- FATE code generator improvements.
|
||||
- Bug fix: Handle qualified constructors in patterns.
|
||||
- Bug fix: Allow switching also on negative numbers.
|
||||
### Removed
|
||||
|
||||
## [4.1.0] - 2019-11-26
|
||||
### Added
|
||||
- Support encoding and decoding bit fields in call arguments and results.
|
||||
### Changed
|
||||
- Various improvements to FATE code generator.
|
||||
### Removed
|
||||
|
||||
## [4.0.0] - 2019-10-11
|
||||
### Added
|
||||
- `Address.to_contract` - casts an address to a (any) contract type.
|
||||
- Pragma to check compiler version, e.g. `@compiler >= 4.0`.
|
||||
- Handle numeric escapes, i.e. `"\x19Ethereum Signed Message:\n"`, and similar strings.
|
||||
### Changed
|
||||
### Removed
|
||||
|
||||
## [4.0.0-rc3] - 2019-09-12
|
||||
### Added
|
||||
- `Bytes.concat` and `Bytes.split` are added to be able to
|
||||
(de-)construct byte arrays.
|
||||
- `[a..b]` language construct, returning the list of numbers between
|
||||
`a` and `b` (inclusive). Returns the empty list if `a` > `b`.
|
||||
- [Standard libraries](https://github.com/aeternity/aesophia/blob/master/docs/sophia_stdlib.md)
|
||||
- [Standard libraries] (https://github.com/aeternity/protocol/blob/master/contracts/sophia_stdlib.md)
|
||||
- Checks that `init` is not called from other functions.
|
||||
### Changed
|
||||
- Error messages are changed into a uniform format, and more helpful
|
||||
messages have been added.
|
||||
- `Crypto.<hash_fun>` and `String.<hash_fun>` for byte arrays now only
|
||||
hash the actual byte array - not the internal ABI format.
|
||||
- More strict checks for polymorphic oracles and higher order oracles
|
||||
and entrypoints.
|
||||
- `AENS.claim` is updated with a `NameFee` field - to be able to do
|
||||
name auctions within contracts.
|
||||
- Fixed a bug in `Bytes.to_str` for AEVM.
|
||||
### Removed
|
||||
|
||||
## [4.0.0-rc1] - 2019-08-22
|
||||
### Added
|
||||
- FATE backend - the compiler is able to produce VM code for both `AEVM` and `FATE`. Many
|
||||
of the APIs now take `{backend, aevm | fate}` to decide wich backend to produce artifacts
|
||||
for.
|
||||
@@ -90,20 +53,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
||||
that shall be able to receive funds should be marked as payable. `Address.is_payable(a)`
|
||||
can be used to check if an (contract) address is payable or not.
|
||||
### Changed
|
||||
- Nice type error if contract function is called as from a namespace.
|
||||
- Fail on function definitions in contracts other than the main contract.
|
||||
- Bug fix in variable optimization - don't discard writes to the store/state.
|
||||
- Bug fixes in error reporting.
|
||||
- Bug fix in variable liveness analysis for FATE.
|
||||
- Error messages are changed into a uniform format, and more helpful
|
||||
messages have been added.
|
||||
- `Crypto.<hash_fun>` and `String.<hash_fun>` for byte arrays now only
|
||||
hash the actual byte array - not the internal ABI format.
|
||||
- More strict checks for polymorphic oracles and higher order oracles
|
||||
and entrypoints.
|
||||
- `AENS.claim` is updated with a `NameFee` field - to be able to do
|
||||
name auctions within contracts.
|
||||
- Fixed a bug in `Bytes.to_str` for AEVM.
|
||||
- New syntax for tuple types. Now 0-tuple type is encoded as `unit` instead of `()` and
|
||||
regular tuples are encoded by interspersing inner types with `*`, for instance `int * string`.
|
||||
Parens are not necessary. Note it only affects the types, values remain as their were before,
|
||||
@@ -211,11 +160,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
||||
- Simplify calldata creation - instead of passing a compiled contract, simply
|
||||
pass a (stubbed) contract string.
|
||||
|
||||
[Unreleased]: https://github.com/aeternity/aesophia/compare/v4.3.0...HEAD
|
||||
[4.3.0]: https://github.com/aeternity/aesophia/compare/v4.2.0...v4.3.0
|
||||
[4.2.0]: https://github.com/aeternity/aesophia/compare/v4.1.0...v4.2.0
|
||||
[4.1.0]: https://github.com/aeternity/aesophia/compare/v4.0.0...v4.1.0
|
||||
[4.0.0]: https://github.com/aeternity/aesophia/compare/v3.2.0...v4.0.0
|
||||
[Unreleased]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc4...HEAD
|
||||
[4.0.0-rc4]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc3...v4.0.0-rc4
|
||||
[4.0.0-rc3]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc1...v4.0.0-rc3
|
||||
[4.0.0-rc1]: https://github.com/aeternity/aesophia/compare/v3.2.0...v4.0.0-rc1
|
||||
[3.2.0]: https://github.com/aeternity/aesophia/compare/v3.1.0...v3.2.0
|
||||
[3.1.0]: https://github.com/aeternity/aesophia/compare/v3.0.0...v3.1.0
|
||||
[3.0.0]: https://github.com/aeternity/aesophia/compare/v2.1.0...v3.0.0
|
||||
|
||||
@@ -1,17 +1,13 @@
|
||||
# aesophia
|
||||
|
||||
This is the __sophia__ compiler for the æternity system which compiles contracts written in __sophia__ to [FATE](https://github.com/aeternity/protocol/blob/master/contracts/fate.md) instructions.
|
||||
This is the __sophia__ compiler for the æternity system which compiles contracts written in __sophia__ code to the æternity VM code.
|
||||
|
||||
The compiler is currently being used three places
|
||||
- [The command line compiler](https://github.com/aeternity/aesophia_cli)
|
||||
- [The HTTP compiler](https://github.com/aeternity/aesophia_http)
|
||||
- In [Aeternity node](https://github.com/aeternity/aeternity) tests
|
||||
For more information about æternity smart contracts and the sophia language see [Smart Contracts](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md) and the [Sophia Language](https://github.com/aeternity/protocol/blob/master/contracts/sophia.md).
|
||||
|
||||
## Documentation
|
||||
|
||||
* [Smart Contracts on aeternity Blockchain](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md).
|
||||
* [Sophia Documentation](docs/sophia.md).
|
||||
* [Sophia Standard Library](docs/sophia_stdlib.md).
|
||||
It is an OTP application written in Erlang and is by default included in
|
||||
[the æternity node](https://github.com/aeternity/epoch). However, it can
|
||||
also be included in other systems to compile contracts coded in sophia which
|
||||
can then be loaded into the æternity system.
|
||||
|
||||
## Versioning
|
||||
|
||||
|
||||
-1159
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,68 +0,0 @@
|
||||
namespace BLS12_381 =
|
||||
type fr = MCL_BLS12_381.fr
|
||||
type fp = MCL_BLS12_381.fp
|
||||
record fp2 = { x1 : fp, x2 : fp }
|
||||
record g1 = { x : fp, y : fp, z : fp }
|
||||
record g2 = { x : fp2, y : fp2, z : fp2 }
|
||||
record gt = { x1 : fp, x2 : fp, x3 : fp, x4 : fp, x5 : fp, x6 : fp,
|
||||
x7 : fp, x8 : fp, x9 : fp, x10 : fp, x11 : fp, x12 : fp }
|
||||
|
||||
function pairing_check(xs : list(g1), ys : list(g2)) =
|
||||
switch((xs, ys))
|
||||
([], []) => true
|
||||
(x :: xs, y :: ys) => pairing_check_(pairing(x, y), xs, ys)
|
||||
|
||||
function pairing_check_(acc : gt, xs : list(g1), ys : list(g2)) =
|
||||
switch((xs, ys))
|
||||
([], []) => gt_is_one(acc)
|
||||
(x :: xs, y :: ys) =>
|
||||
pairing_check_(gt_mul(acc, pairing(x, y)), xs, ys)
|
||||
|
||||
function int_to_fr(x : int) = MCL_BLS12_381.int_to_fr(x)
|
||||
function int_to_fp(x : int) = MCL_BLS12_381.int_to_fp(x)
|
||||
function fr_to_int(x : fr) = MCL_BLS12_381.fr_to_int(x)
|
||||
function fp_to_int(x : fp) = MCL_BLS12_381.fp_to_int(x)
|
||||
|
||||
function mk_g1(x : int, y : int, z : int) : g1 =
|
||||
{ x = int_to_fp(x), y = int_to_fp(y), z = int_to_fp(z) }
|
||||
|
||||
function mk_g2(x1 : int, x2 : int, y1 : int, y2 : int, z1 : int, z2 : int) : g2 =
|
||||
{ x = {x1 = int_to_fp(x1), x2 = int_to_fp(x2)},
|
||||
y = {x1 = int_to_fp(y1), x2 = int_to_fp(y2)},
|
||||
z = {x1 = int_to_fp(z1), x2 = int_to_fp(z2)} }
|
||||
|
||||
function pack_g1(t) = switch(t)
|
||||
(x, y, z) => {x = x, y = y, z = z} : g1
|
||||
function pack_g2(t) = switch(t)
|
||||
((x1, x2), (y1, y2), (z1, z2)) =>
|
||||
{x = {x1 = x1, x2 = x2}, y = {x1 = y1, x2 = y2}, z = {x1 = z1, x2 = z2}} : g2
|
||||
function pack_gt(t) = switch(t)
|
||||
(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) =>
|
||||
{x1 = x1, x2 = x2, x3 = x3, x4 = x4, x5 = x5, x6 = x6,
|
||||
x7 = x7, x8 = x8, x9 = x9, x10 = x10, x11 = x11, x12 = x12} : gt
|
||||
|
||||
function g1_neg(p : g1) = pack_g1(MCL_BLS12_381.g1_neg((p.x, p.y, p.z)))
|
||||
function g1_norm(p : g1) = pack_g1(MCL_BLS12_381.g1_norm((p.x, p.y, p.z)))
|
||||
function g1_valid(p : g1) = MCL_BLS12_381.g1_valid((p.x, p.y, p.z))
|
||||
function g1_is_zero(p : g1) = MCL_BLS12_381.g1_is_zero((p.x, p.y, p.z))
|
||||
function g1_add(p : g1, q : g1) = pack_g1(MCL_BLS12_381.g1_add((p.x, p.y, p.z), (q.x, q.y, q.z)))
|
||||
function g1_mul(k : fr, p : g1) = pack_g1(MCL_BLS12_381.g1_mul(k, (p.x, p.y, p.z)))
|
||||
|
||||
function g2_neg(p : g2) = pack_g2(MCL_BLS12_381.g2_neg(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2))))
|
||||
function g2_norm(p : g2) = pack_g2(MCL_BLS12_381.g2_norm(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2))))
|
||||
function g2_valid(p : g2) = MCL_BLS12_381.g2_valid(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2)))
|
||||
function g2_is_zero(p : g2) = MCL_BLS12_381.g2_is_zero(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2)))
|
||||
function g2_add(p : g2, q : g2) = pack_g2(MCL_BLS12_381.g2_add(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2)),
|
||||
((q.x.x1, q.x.x2), (q.y.x1, q.y.x2), (q.z.x1, q.z.x2))))
|
||||
function g2_mul(k : fr, p : g2) = pack_g2(MCL_BLS12_381.g2_mul(k, ((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2))))
|
||||
|
||||
function gt_inv(p : gt) = pack_gt(MCL_BLS12_381.gt_inv((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12)))
|
||||
function gt_add(p : gt, q : gt) = pack_gt(MCL_BLS12_381.gt_add((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12),
|
||||
(q.x1, q.x2, q.x3, q.x4, q.x5, q.x6, q.x7, q.x8, q.x9, q.x10, q.x11, q.x12)))
|
||||
function gt_mul(p : gt, q : gt) = pack_gt(MCL_BLS12_381.gt_mul((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12),
|
||||
(q.x1, q.x2, q.x3, q.x4, q.x5, q.x6, q.x7, q.x8, q.x9, q.x10, q.x11, q.x12)))
|
||||
function gt_pow(p : gt, k : fr) = pack_gt(MCL_BLS12_381.gt_pow((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12), k))
|
||||
function gt_is_one(p : gt) = MCL_BLS12_381.gt_is_one((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12))
|
||||
function pairing(p : g1, q : g2) = pack_gt(MCL_BLS12_381.pairing((p.x, p.y, p.z), ((q.x.x1, q.x.x2), (q.y.x1, q.y.x2), (q.z.x1, q.z.x2))))
|
||||
function miller_loop(p : g1, q : g2) = pack_gt(MCL_BLS12_381.miller_loop((p.x, p.y, p.z), ((q.x.x1, q.x.x2), (q.y.x1, q.y.x2), (q.z.x1, q.z.x2))))
|
||||
function final_exp(p : gt) = pack_gt(MCL_BLS12_381.final_exp((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12)))
|
||||
@@ -1,183 +0,0 @@
|
||||
namespace Frac =
|
||||
|
||||
private function gcd(a : int, b : int) =
|
||||
if (b == 0) a else gcd(b, a mod b)
|
||||
|
||||
private function abs_int(a : int) = if (a < 0) -a else a
|
||||
|
||||
datatype frac = Pos(int, int) | Zero | Neg(int, int)
|
||||
|
||||
/** Checks if the internal representation is correct.
|
||||
* Numerator and denominator must be positive.
|
||||
* Exposed for debug purposes
|
||||
*/
|
||||
function is_sane(f : frac) : bool = switch(f)
|
||||
Pos(n, d) => n > 0 && d > 0
|
||||
Zero => true
|
||||
Neg(n, d) => n > 0 && d > 0
|
||||
|
||||
function num(f : frac) : int = switch(f)
|
||||
Pos(n, _) => n
|
||||
Neg(n, _) => -n
|
||||
Zero => 0
|
||||
|
||||
function den(f : frac) : int = switch(f)
|
||||
Pos(_, d) => d
|
||||
Neg(_, d) => d
|
||||
Zero => 1
|
||||
|
||||
function to_pair(f : frac) : int * int = switch(f)
|
||||
Pos(n, d) => (n, d)
|
||||
Neg(n, d) => (-n, d)
|
||||
Zero => (0, 1)
|
||||
|
||||
function sign(f : frac) : int = switch(f)
|
||||
Pos(_, _) => 1
|
||||
Neg(_, _) => -1
|
||||
Zero => 0
|
||||
|
||||
function to_str(f : frac) : string = switch(f)
|
||||
Pos(n, d) => String.concat(Int.to_str(n), if (d == 1) "" else String.concat("/", Int.to_str(d)))
|
||||
Neg(n, d) => String.concat("-", to_str(Pos(n, d)))
|
||||
Zero => "0"
|
||||
|
||||
/** Reduce fraction to normal form
|
||||
*/
|
||||
function simplify(f : frac) : frac =
|
||||
switch(f)
|
||||
Neg(n, d) =>
|
||||
let cd = gcd(n, d)
|
||||
Neg(n / cd, d / cd)
|
||||
Zero => Zero
|
||||
Pos(n, d) =>
|
||||
let cd = gcd(n, d)
|
||||
Pos(n / cd, d / cd)
|
||||
|
||||
/** Integer to rational division
|
||||
*/
|
||||
function make_frac(n : int, d : int) : frac =
|
||||
if (d == 0) abort("Zero denominator")
|
||||
elif (n == 0) Zero
|
||||
elif ((n < 0) == (d < 0)) simplify(Pos(abs_int(n), abs_int(d)))
|
||||
else simplify(Neg(abs_int(n), abs_int(d)))
|
||||
|
||||
function one() : frac = Pos(1, 1)
|
||||
function zero() : frac = Zero
|
||||
|
||||
function eq(a : frac, b : frac) : bool =
|
||||
let (na, da) = to_pair(a)
|
||||
let (nb, db) = to_pair(b)
|
||||
(na == nb && da == db) || na * db == nb * da // they are more likely to be normalized
|
||||
|
||||
function neq(a : frac, b : frac) : bool =
|
||||
let (na, da) = to_pair(a)
|
||||
let (nb, db) = to_pair(b)
|
||||
(na != nb || da != db) && na * db != nb * da
|
||||
|
||||
function geq(a : frac, b : frac) : bool = num(a) * den(b) >= num(b) * den(a)
|
||||
|
||||
function leq(a : frac, b : frac) : bool = num(a) * den(b) =< num(b) * den(a)
|
||||
|
||||
function gt(a : frac, b : frac) : bool = num(a) * den(b) > num(b) * den(a)
|
||||
|
||||
function lt(a : frac, b : frac) : bool = num(a) * den(b) < num(b) * den(a)
|
||||
|
||||
function min(a : frac, b : frac) : frac = if (leq(a, b)) a else b
|
||||
|
||||
function max(a : frac, b : frac) : frac = if (geq(a, b)) a else b
|
||||
|
||||
function abs(f : frac) : frac = switch(f)
|
||||
Pos(n, d) => Pos(n, d)
|
||||
Zero => Zero
|
||||
Neg(n, d) => Pos(n, d)
|
||||
|
||||
function from_int(n : int) : frac =
|
||||
if (n > 0) Pos(n, 1)
|
||||
elif (n < 0) Neg(-n, 1)
|
||||
else Zero
|
||||
|
||||
function floor(f : frac) : int = switch(f)
|
||||
Pos(n, d) => n / d
|
||||
Zero => 0
|
||||
Neg(n, d) => -(n + d - 1) / d
|
||||
|
||||
function ceil(f : frac) : int = switch(f)
|
||||
Pos(n, d) => (n + d - 1) / d
|
||||
Zero => 0
|
||||
Neg(n, d) => -n / d
|
||||
|
||||
function round_to_zero(f : frac) : int = switch(f)
|
||||
Pos(n, d) => n / d
|
||||
Zero => 0
|
||||
Neg(n, d) => -n / d
|
||||
|
||||
function round_from_zero(f : frac) : int = switch(f)
|
||||
Pos(n, d) => (n + d - 1) / d
|
||||
Zero => 0
|
||||
Neg(n, d) => -(n + d - 1) / d
|
||||
|
||||
/** Round towards nearest integer. If two integers are in the same
|
||||
* distance, choose the even one.
|
||||
*/
|
||||
function round(f : frac) : int =
|
||||
let fl = floor(f)
|
||||
let cl = ceil(f)
|
||||
let dif_fl = abs(sub(f, from_int(fl)))
|
||||
let dif_cl = abs(sub(f, from_int(cl)))
|
||||
if (gt(dif_fl, dif_cl)) cl
|
||||
elif (gt(dif_cl, dif_fl)) fl
|
||||
elif (fl mod 2 == 0) fl
|
||||
else cl
|
||||
|
||||
function add(a : frac, b : frac) : frac =
|
||||
let (na, da) = to_pair(a)
|
||||
let (nb, db) = to_pair(b)
|
||||
if (da == db) make_frac(na + nb, da)
|
||||
else make_frac(na * db + nb * da, da * db)
|
||||
|
||||
function neg(a : frac) : frac = switch(a)
|
||||
Neg(n, d) => Pos(n, d)
|
||||
Zero => Zero
|
||||
Pos(n, d) => Neg(n, d)
|
||||
|
||||
function sub(a : frac, b : frac) : frac = add(a, neg(b))
|
||||
|
||||
function inv(a : frac) : frac = switch(a)
|
||||
Neg(n, d) => Neg(d, n)
|
||||
Zero => abort("Inversion of zero")
|
||||
Pos(n, d) => Pos(d, n)
|
||||
|
||||
function mul(a : frac, b : frac) : frac = make_frac(num(a) * num(b), den(a) * den(b))
|
||||
|
||||
function div(a : frac, b : frac) : frac = switch(b)
|
||||
Neg(n, d) => mul(a, Neg(d, n))
|
||||
Zero => abort("Division by zero")
|
||||
Pos(n, d) => mul(a, Pos(d, n))
|
||||
|
||||
/** `b` to the power of `e`
|
||||
*/
|
||||
function int_exp(b : frac, e : int) : frac =
|
||||
if (sign(b) == 0 && e == 0) abort("Zero to the zero exponentation")
|
||||
elif (e < 0) inv(int_exp_(b, -e))
|
||||
else int_exp_(b, e)
|
||||
private function int_exp_(b : frac, e : int) =
|
||||
if (e == 0) from_int(1)
|
||||
elif (e == 1) b
|
||||
else
|
||||
let half = int_exp_(b, e / 2)
|
||||
if (e mod 2 == 1) mul(mul(half, half), b)
|
||||
else mul(half, half)
|
||||
|
||||
/** Reduces the fraction's in-memory size by dividing its components by two until the
|
||||
* the error is bigger than `loss` value
|
||||
*/
|
||||
function optimize(f : frac, loss : frac) : frac =
|
||||
require(geq(loss, Zero), "negative loss optimize")
|
||||
let s = sign(f)
|
||||
mul(from_int(s), run_optimize(abs(f), abs(f), loss))
|
||||
private function run_optimize(orig : frac, f : frac, loss : frac) : frac =
|
||||
let (n, d) = to_pair(f)
|
||||
let t = make_frac((n+1)/2, (d+1)/2)
|
||||
if(gt(abs(sub(t, orig)), loss)) f
|
||||
elif (eq(t, f)) f
|
||||
else run_optimize(orig, t, loss)
|
||||
+10
-41
@@ -12,66 +12,35 @@ namespace Func =
|
||||
|
||||
function rapply(x : 'a, f : 'a => 'b) : 'b = f(x)
|
||||
|
||||
/** The Z combinator - replacement for local and anonymous recursion.
|
||||
*/
|
||||
/* The Z combinator - replacement for local and anonymous recursion.
|
||||
*/
|
||||
function recur(f : ('arg => 'res, 'arg) => 'res) : 'arg => 'res =
|
||||
(x) => f(recur(f), x)
|
||||
|
||||
/** n-times composition with itself
|
||||
*/
|
||||
function iter(n : int, f : 'a => 'a) : 'a => 'a = iter_(n, f, (x) => x)
|
||||
private function iter_(n : int, f : 'a => 'a, acc : 'a => 'a) : 'a => 'a =
|
||||
if(n == 0) acc
|
||||
elif(n == 1) comp(f, acc)
|
||||
else iter_(n / 2, comp(f, f), if(n mod 2 == 0) acc else comp(f, acc))
|
||||
|
||||
/** Turns an ugly, bad and disgusting arity-n function into
|
||||
* a beautiful and sweet function taking the first argument
|
||||
* and returning a function watiting for the remaining ones
|
||||
* in the same manner
|
||||
*/
|
||||
function curry2(f : ('a, 'b) => 'x) : 'a => ('b => 'x) =
|
||||
function curry2(f : ('a, 'b) => 'c) : 'a => ('b => 'c) =
|
||||
(x) => (y) => f(x, y)
|
||||
function curry3(f : ('a, 'b, 'c) => 'x) : 'a => ('b => ('c => 'x)) =
|
||||
function curry3(f : ('a, 'b, 'c) => 'd) : 'a => ('b => ('c => 'd)) =
|
||||
(x) => (y) => (z) => f(x, y, z)
|
||||
function curry4(f : ('a, 'b, 'c, 'd) => 'x) : 'a => ('b => ('c => ('d => 'x))) =
|
||||
(x) => (y) => (z) => (w) => f(x, y, z, w)
|
||||
function curry5(f : ('a, 'b, 'c, 'd, 'e) => 'x) : 'a => ('b => ('c => ('d => ('e => 'x)))) =
|
||||
(x) => (y) => (z) => (w) => (q) => f(x, y, z, w, q)
|
||||
|
||||
/** Opposite of curry. Gross
|
||||
*/
|
||||
function uncurry2(f : 'a => ('b => 'x)) : ('a, 'b) => 'x =
|
||||
function uncurry2(f : 'a => ('b => 'c)) : ('a, 'b) => 'c =
|
||||
(x, y) => f(x)(y)
|
||||
function uncurry3(f : 'a => ('b => ('c => 'x))) : ('a, 'b, 'c) => 'x =
|
||||
function uncurry3(f : 'a => ('b => ('c => 'd))) : ('a, 'b, 'c) => 'd =
|
||||
(x, y, z) => f(x)(y)(z)
|
||||
function uncurry4(f : 'a => ('b => ('c => ('d => 'x)))) : ('a, 'b, 'c, 'd) => 'x =
|
||||
(x, y, z, w) => f(x)(y)(z)(w)
|
||||
function uncurry5(f : 'a => ('b => ('c => ('d => ('e => 'x))))) : ('a, 'b, 'c, 'd, 'e) => 'x =
|
||||
(x, y, z, w, q) => f(x)(y)(z)(w)(q)
|
||||
|
||||
/** Turns an arity-n function into a function taking n-tuple
|
||||
*/
|
||||
function tuplify2(f : ('a, 'b) => 'x) : (('a * 'b)) => 'x =
|
||||
function tuplify2(f : ('a, 'b) => 'c) : (('a * 'b)) => 'c =
|
||||
(t) => switch(t)
|
||||
(x, y) => f(x, y)
|
||||
function tuplify3(f : ('a, 'b, 'c) => 'x) : 'a * 'b * 'c => 'x =
|
||||
function tuplify3(f : ('a, 'b, 'c) => 'd) : 'a * 'b * 'c => 'd =
|
||||
(t) => switch(t)
|
||||
(x, y, z) => f(x, y, z)
|
||||
function tuplify4(f : ('a, 'b, 'c, 'd) => 'x) : 'a * 'b * 'c * 'd => 'x =
|
||||
(t) => switch(t)
|
||||
(x, y, z, w) => f(x, y, z, w)
|
||||
function tuplify5(f : ('a, 'b, 'c, 'd, 'e) => 'x) : 'a * 'b * 'c * 'd * 'e => 'x =
|
||||
(t) => switch(t)
|
||||
(x, y, z, w, q) => f(x, y, z, w, q)
|
||||
|
||||
/** Opposite of tuplify
|
||||
*/
|
||||
function untuplify2(f : 'a * 'b => 'x) : ('a, 'b) => 'x =
|
||||
function untuplify2(f : 'a * 'b => 'c) : ('a, 'b) => 'c =
|
||||
(x, y) => f((x, y))
|
||||
function untuplify3(f : 'a * 'b * 'c => 'x) : ('a, 'b, 'c) => 'x =
|
||||
function untuplify3(f : 'a * 'b * 'c => 'd) : ('a, 'b, 'c) => 'd =
|
||||
(x, y, z) => f((x, y, z))
|
||||
function untuplify4(f : 'a * 'b * 'c * 'd => 'x) : ('a, 'b, 'c, 'd) => 'x =
|
||||
(x, y, z, w) => f((x, y, z, w))
|
||||
function untuplify5(f : 'a * 'b * 'c * 'd * 'e => 'x) : ('a, 'b, 'c, 'd, 'e) => 'x =
|
||||
(x, y, z, w, q) => f((x, y, z, w, q))
|
||||
|
||||
+86
-128
@@ -15,42 +15,22 @@ namespace List =
|
||||
_::t => Some(t)
|
||||
|
||||
function last(l : list('a)) : option('a) = switch(l)
|
||||
[] => None
|
||||
[x] => Some(x)
|
||||
[] => None
|
||||
[x] => Some(x)
|
||||
_::t => last(t)
|
||||
|
||||
function drop_last(l : list('a)) : option(list('a)) = switch(l)
|
||||
[] => None
|
||||
_ => Some(drop_last_unsafe(l))
|
||||
|
||||
function drop_last_unsafe(l : list('a)) : list('a) = switch(l)
|
||||
[_] => []
|
||||
h::t => h::drop_last_unsafe(t)
|
||||
[] => abort("drop_last_unsafe: list empty")
|
||||
|
||||
|
||||
function contains(e : 'a, l : list('a)) = switch(l)
|
||||
[] => false
|
||||
h::t => h == e || contains(e, t)
|
||||
|
||||
/** Finds first element of `l` fulfilling predicate `p` as `Some` or `None`
|
||||
* if no such element exists.
|
||||
*/
|
||||
function find(p : 'a => bool, l : list('a)) : option('a) = switch(l)
|
||||
[] => None
|
||||
h::t => if(p(h)) Some(h) else find(p, t)
|
||||
|
||||
/** Returns list of all indices of elements from `l` that fulfill the predicate `p`.
|
||||
*/
|
||||
function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0)
|
||||
function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0, [])
|
||||
private function find_indices_( p : 'a => bool
|
||||
, l : list('a)
|
||||
, n : int
|
||||
, acc : list(int)
|
||||
) : list(int) = switch(l)
|
||||
[] => []
|
||||
h::t =>
|
||||
let rest = find_indices_(p, t, n+1)
|
||||
if(p(h)) n::rest else rest
|
||||
[] => reverse(acc)
|
||||
h::t => find_indices_(p, t, n+1, if(p(h)) n::acc else acc)
|
||||
|
||||
function nth(n : int, l : list('a)) : option('a) =
|
||||
switch(l)
|
||||
@@ -70,53 +50,41 @@ namespace List =
|
||||
_::t => length_(t, acc + 1)
|
||||
|
||||
|
||||
/** Creates an ascending sequence of all integer numbers
|
||||
* between `a` and `b` (including `a` and `b`)
|
||||
*/
|
||||
function from_to(a : int, b : int) : list(int) = [a..b]
|
||||
|
||||
/** Creates an ascending sequence of integer numbers betweeen
|
||||
* `a` and `b` jumping by given `step`. Includes `a` and takes
|
||||
* `b` only if `(b - a) mod step == 0`. `step` should be bigger than 0.
|
||||
*/
|
||||
function from_to_step(a : int, b : int, s : int) : list(int) =
|
||||
from_to_step_(a, b - (b-a) mod s, s, [])
|
||||
private function from_to_step_(a : int, b : int, s : int, acc : list(int)) : list(int) =
|
||||
if(b < a) acc
|
||||
else from_to_step_(a, b - s, s, b::acc)
|
||||
function from_to_step(a : int, b : int, s : int) : list(int) = from_to_step_(a, b, s, [])
|
||||
private function from_to_step_(a, b, s, acc) =
|
||||
if (a > b) reverse(acc) else from_to_step_(a + s, b, s, a :: acc)
|
||||
|
||||
|
||||
/** Unsafe. Replaces `n`th element of `l` with `e`. Crashes on over/underflow
|
||||
*/
|
||||
/* Unsafe. Replaces `n`th element of `l` with `e`. Crashes on over/underflow */
|
||||
function replace_at(n : int, e : 'a, l : list('a)) : list('a) =
|
||||
if(n<0) abort("insert_at underflow") else replace_at_(n, e, l)
|
||||
private function replace_at_(n : int, e : 'a, l : list('a)) : list('a) =
|
||||
if(n<0) abort("insert_at underflow") else replace_at_(n, e, l, [])
|
||||
private function replace_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
|
||||
switch(l)
|
||||
[] => abort("replace_at overflow")
|
||||
h::t => if (n == 0) e::t
|
||||
else h::replace_at_(n-1, e, t)
|
||||
h::t => if (n == 0) reverse(e::acc) ++ t
|
||||
else replace_at_(n-1, e, t, h::acc)
|
||||
|
||||
/** Unsafe. Adds `e` to `l` to be its `n`th element. Crashes on over/underflow
|
||||
*/
|
||||
/* Unsafe. Adds `e` to `l` to be its `n`th element. Crashes on over/underflow */
|
||||
function insert_at(n : int, e : 'a, l : list('a)) : list('a) =
|
||||
if(n<0) abort("insert_at underflow") else insert_at_(n, e, l)
|
||||
private function insert_at_(n : int, e : 'a, l : list('a)) : list('a) =
|
||||
if (n == 0) e::l
|
||||
if(n<0) abort("insert_at underflow") else insert_at_(n, e, l, [])
|
||||
private function insert_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
|
||||
if (n == 0) reverse(e::acc) ++ l
|
||||
else switch(l)
|
||||
[] => abort("insert_at overflow")
|
||||
h::t => h::insert_at_(n-1, e, t)
|
||||
h::t => insert_at_(n-1, e, t, h::acc)
|
||||
|
||||
/** Assuming that cmp represents `<` comparison, inserts `x` before
|
||||
* the first element in the list `l` which is greater than it
|
||||
*/
|
||||
function insert_by(cmp : (('a, 'a) => bool), x : 'a, l : list('a)) : list('a) =
|
||||
insert_by_(cmp, x, l, [])
|
||||
private function insert_by_(cmp : (('a, 'a) => bool), x : 'a, l : list('a), acc : list('a)) : list('a) =
|
||||
switch(l)
|
||||
[] => [x]
|
||||
[] => reverse(x::acc)
|
||||
h::t =>
|
||||
if(cmp(x, h)) // x < h
|
||||
x::l
|
||||
reverse(acc) ++ (x::l)
|
||||
else
|
||||
h::insert_by(cmp, x, t)
|
||||
insert_by_(cmp, x, t, h::acc)
|
||||
|
||||
|
||||
function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
|
||||
@@ -134,71 +102,61 @@ namespace List =
|
||||
f(e)
|
||||
foreach(l', f)
|
||||
|
||||
function reverse(l : list('a)) : list('a) = reverse_(l, [])
|
||||
private function reverse_(l : list('a), acc : list('a)) : list('a) = switch(l)
|
||||
[] => acc
|
||||
h::t => reverse_(t, h::acc)
|
||||
function reverse(l : list('a)) : list('a) = foldl((lst, el) => el :: lst, [], l)
|
||||
|
||||
function map(f : 'a => 'b, l : list('a)) : list('b) = switch(l)
|
||||
[] => []
|
||||
h::t => f(h)::map(f, t)
|
||||
function map(f : 'a => 'b, l : list('a)) : list('b) = map_(f, l, [])
|
||||
private function map_(f : 'a => 'b, l : list('a), acc : list('b)) : list('b) = switch(l)
|
||||
[] => reverse(acc)
|
||||
h::t => map_(f, t, f(h)::acc)
|
||||
|
||||
/** Effectively composition of `map` and `flatten`
|
||||
*/
|
||||
function flat_map(f : 'a => list('b), l : list('a)) : list('b) =
|
||||
ListInternal.flat_map(f, l)
|
||||
|
||||
function filter(p : 'a => bool, l : list('a)) : list('a) = switch(l)
|
||||
[] => []
|
||||
h::t =>
|
||||
let rest = filter(p, t)
|
||||
if(p(h)) h::rest else rest
|
||||
function filter(p : 'a => bool, l : list('a)) : list('a) = filter_(p, l, [])
|
||||
private function filter_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
|
||||
[] => reverse(acc)
|
||||
h::t => filter_(p, t, if(p(h)) h::acc else acc)
|
||||
|
||||
/** Take up to `n` first elements
|
||||
*/
|
||||
/* Take `n` first elements */
|
||||
function take(n : int, l : list('a)) : list('a) =
|
||||
if(n < 0) abort("Take negative number of elements") else take_(n, l)
|
||||
private function take_(n : int, l : list('a)) : list('a) =
|
||||
if(n == 0) []
|
||||
if(n < 0) abort("Take negative number of elements") else take_(n, l, [])
|
||||
private function take_(n : int, l : list('a), acc : list('a)) : list('a) =
|
||||
if(n == 0) reverse(acc)
|
||||
else switch(l)
|
||||
[] => []
|
||||
h::t => h::take_(n-1, t)
|
||||
[] => reverse(acc)
|
||||
h::t => take_(n-1, t, h::acc)
|
||||
|
||||
/** Drop up to `n` first elements
|
||||
*/
|
||||
/* Drop `n` first elements */
|
||||
function drop(n : int, l : list('a)) : list('a) =
|
||||
if(n < 0) abort("Drop negative number of elements") else drop_(n, l)
|
||||
private function drop_(n : int, l : list('a)) : list('a) =
|
||||
if (n == 0) l
|
||||
if(n < 0) abort("Drop negative number of elements")
|
||||
elif (n == 0) l
|
||||
else switch(l)
|
||||
[] => []
|
||||
h::t => drop_(n-1, t)
|
||||
h::t => drop(n-1, t)
|
||||
|
||||
/** Get the longest prefix of a list in which every element
|
||||
* matches predicate `p`
|
||||
*/
|
||||
function take_while(p : 'a => bool, l : list('a)) : list('a) = switch(l)
|
||||
[] => []
|
||||
h::t => if(p(h)) h::take_while(p, t) else []
|
||||
/* Get the longest prefix of a list in which every element matches predicate `p` */
|
||||
function take_while(p : 'a => bool, l : list('a)) : list('a) = take_while_(p, l, [])
|
||||
private function take_while_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
|
||||
[] => reverse(acc)
|
||||
h::t => if(p(h)) take_while_(p, t, h::acc) else reverse(acc)
|
||||
|
||||
/** Drop elements from `l` until `p` holds
|
||||
*/
|
||||
/* Drop elements from `l` until `p` holds */
|
||||
function drop_while(p : 'a => bool, l : list('a)) : list('a) = switch(l)
|
||||
[] => []
|
||||
h::t => if(p(h)) drop_while(p, t) else l
|
||||
|
||||
/** Splits list into two lists of elements that respectively
|
||||
* match and don't match predicate `p`
|
||||
*/
|
||||
function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = switch(l)
|
||||
[] => ([], [])
|
||||
h::t =>
|
||||
let (l, r) = partition(p, t)
|
||||
if(p(h)) (h::l, r) else (l, h::r)
|
||||
/* Splits list into two lists of elements that respectively match and don't match predicate `p` */
|
||||
function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = partition_(p, l, [], [])
|
||||
private function partition_( p : 'a => bool
|
||||
, l : list('a)
|
||||
, acc_t : list('a)
|
||||
, acc_f : list('a)
|
||||
) : (list('a) * list('a)) = switch(l)
|
||||
[] => (reverse(acc_t), reverse(acc_f))
|
||||
h::t => if(p(h)) partition_(p, t, h::acc_t, acc_f) else partition_(p, t, acc_t, h::acc_f)
|
||||
|
||||
function flatten(l : list(list('a))) : list('a) = switch(l)
|
||||
[] => []
|
||||
h::t => h ++ flatten(t)
|
||||
|
||||
function flatten(ll : list(list('a))) : list('a) = foldr((l1, l2) => l1 ++ l2, [], ll)
|
||||
|
||||
function all(p : 'a => bool, l : list('a)) : bool = switch(l)
|
||||
[] => true
|
||||
@@ -213,26 +171,26 @@ namespace List =
|
||||
function product(l : list(int)) : int = foldl((a, b) => a * b, 1, l)
|
||||
|
||||
|
||||
/** Zips two list by applying bimapping function on respective elements.
|
||||
* Drops the tail of the longer list.
|
||||
*/
|
||||
private function zip_with( f : ('a, 'b) => 'c
|
||||
/* Zips two list by applying bimapping function on respective elements. Drops longer tail. */
|
||||
function zip_with(f : ('a, 'b) => 'c, l1 : list('a), l2 : list('b)) : list('c) = zip_with_(f, l1, l2, [])
|
||||
private function zip_with_( f : ('a, 'b) => 'c
|
||||
, l1 : list('a)
|
||||
, l2 : list('b)
|
||||
, acc : list('c)
|
||||
) : list('c) = switch ((l1, l2))
|
||||
(h1::t1, h2::t2) => f(h1, h2)::zip_with(f, t1, t2)
|
||||
_ => []
|
||||
(h1::t1, h2::t2) => zip_with_(f, t1, t2, f(h1, h2)::acc)
|
||||
_ => reverse(acc)
|
||||
|
||||
/** Zips two lists into list of pairs.
|
||||
* Drops the tail of the longer list.
|
||||
*/
|
||||
/* Zips two lists into list of pairs. Drops longer tail. */
|
||||
function zip(l1 : list('a), l2 : list('b)) : list('a * 'b) = zip_with((a, b) => (a, b), l1, l2)
|
||||
|
||||
function unzip(l : list('a * 'b)) : (list('a) * list('b)) = switch(l)
|
||||
[] => ([], [])
|
||||
(h1, h2)::t =>
|
||||
let (t1, t2) = unzip(t)
|
||||
(h1::t1, h2::t2)
|
||||
function unzip(l : list('a * 'b)) : list('a) * list('b) = unzip_(l, [], [])
|
||||
private function unzip_( l : list('a * 'b)
|
||||
, acc_l : list('a)
|
||||
, acc_r : list('b)
|
||||
) : (list('a) * list('b)) = switch(l)
|
||||
[] => (reverse(acc_l), reverse(acc_r))
|
||||
(left, right)::t => unzip_(t, left::acc_l, right::acc_r)
|
||||
|
||||
|
||||
// TODO: Improve?
|
||||
@@ -241,16 +199,16 @@ namespace List =
|
||||
h::t => switch (partition((x) => lesser_cmp(x, h), t))
|
||||
(lesser, bigger) => sort(lesser_cmp, lesser) ++ h::sort(lesser_cmp, bigger)
|
||||
|
||||
/** Puts `delim` between every two members of the list
|
||||
*/
|
||||
function intersperse(delim : 'a, l : list('a)) : list('a) = switch(l)
|
||||
[] => []
|
||||
[e] => [e]
|
||||
h::t => h::delim::intersperse(delim, t)
|
||||
|
||||
/** Effectively a zip with an infinite sequence of natural numbers
|
||||
*/
|
||||
function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0)
|
||||
private function enumerate_(l : list('a), n : int) : list(int * 'a) = switch(l)
|
||||
[] => []
|
||||
h::t => (n, h)::enumerate_(t, n + 1)
|
||||
function intersperse(delim : 'a, l : list('a)) : list('a) = intersperse_(delim, l, [])
|
||||
private function intersperse_(delim : 'a, l : list('a), acc : list('a)) : list('a) = switch(l)
|
||||
[] => reverse(acc)
|
||||
[e] => reverse(e::acc)
|
||||
h::t => intersperse_(delim, t, delim::h::acc)
|
||||
|
||||
|
||||
function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0, [])
|
||||
private function enumerate_(l : list('a), n : int, acc : list(int * 'a)) : list(int * 'a) = switch(l)
|
||||
[] => reverse(acc)
|
||||
h::t => enumerate_(t, n + 1, (n, h)::acc)
|
||||
|
||||
|
||||
+13
-35
@@ -10,23 +10,14 @@ namespace Option =
|
||||
None => false
|
||||
Some(_) => true
|
||||
|
||||
/** Catamorphism on `option`. Also known as inlined pattern matching.
|
||||
*/
|
||||
|
||||
function match(n : 'b, s : 'a => 'b, o : option('a)) : 'b = switch(o)
|
||||
None => n
|
||||
Some(x) => s(x)
|
||||
|
||||
/** Escape option providing default if `None`
|
||||
*/
|
||||
function default(def : 'a, o : option('a)) : 'a = match(def, (x) => x, o)
|
||||
|
||||
/** Assume it is `Some`
|
||||
*/
|
||||
function force(o : option('a)) : 'a = switch(o)
|
||||
None => abort("Forced None value")
|
||||
Some(x) => x
|
||||
|
||||
function contains(e : 'a, o : option('a)) = o == Some(e)
|
||||
function force(o : option('a)) : 'a = default(abort("Forced None value"), o)
|
||||
|
||||
function on_elem(o : option('a), f : 'a => unit) : unit = match((), f, o)
|
||||
|
||||
@@ -49,14 +40,10 @@ namespace Option =
|
||||
(Some(x1), Some(x2), Some(x3)) => Some(f(x1, x2, x3))
|
||||
_ => None
|
||||
|
||||
/** Like `map`, but the function is in `option`
|
||||
*/
|
||||
function app_over(f : option ('a => 'b), o : option('a)) : option('b) = switch((f, o))
|
||||
(Some(ff), Some(xx)) => Some(ff(xx))
|
||||
_ => None
|
||||
|
||||
/** Monadic bind
|
||||
*/
|
||||
function flat_map(f : 'a => option('b), o : option('a)) : option('b) = switch(o)
|
||||
None => None
|
||||
Some(x) => f(x)
|
||||
@@ -66,33 +53,24 @@ namespace Option =
|
||||
None => []
|
||||
Some(x) => [x]
|
||||
|
||||
/** Turns list of options into a list of elements that are under `Some`s.
|
||||
* Safe.
|
||||
*/
|
||||
function filter_options(l : list(option('a))) : list('a) = switch(l)
|
||||
[] => []
|
||||
None::t => filter_options(t)
|
||||
Some(x)::t => x::filter_options(t)
|
||||
function filter_options(l : list(option('a))) : list('a) = filter_options_(l, [])
|
||||
private function filter_options_(l : list (option('a)), acc : list('a)) : list('a) = switch(l)
|
||||
[] => List.reverse(acc)
|
||||
None::t => filter_options_(t, acc)
|
||||
Some(x)::t => filter_options_(t, x::acc)
|
||||
|
||||
/** Just like `filter_options` but requires all elements to be `Some` and returns
|
||||
* None if any of them is not
|
||||
*/
|
||||
function seq_options(l : list (option('a))) : option (list('a)) = switch(l)
|
||||
[] => Some([])
|
||||
None::_ => None
|
||||
Some(x)::t => switch(seq_options(t))
|
||||
None => None
|
||||
Some(st) => Some(x::st)
|
||||
function seq_options(l : list (option('a))) : option (list('a)) = seq_options_(l, [])
|
||||
private function seq_options_(l : list (option('a)), acc : list('a)) : option(list('a)) = switch(l)
|
||||
[] => Some(List.reverse(acc))
|
||||
None::t => None
|
||||
Some(x)::t => seq_options_(t, x::acc)
|
||||
|
||||
|
||||
/** Choose `Some` out of two if possible
|
||||
*/
|
||||
function choose(o1 : option('a), o2 : option('a)) : option('a) =
|
||||
if(is_some(o1)) o1 else o2
|
||||
|
||||
/** Choose `Some` from list of options if possible
|
||||
*/
|
||||
function choose_first(l : list(option('a))) : option('a) = switch(l)
|
||||
[] => None
|
||||
None::t => choose_first(t)
|
||||
Some(x)::_ => Some(x)
|
||||
|
||||
|
||||
@@ -6,18 +6,12 @@ namespace Pair =
|
||||
function snd(t : ('a * 'b)) : 'b = switch(t)
|
||||
(_, y) => y
|
||||
|
||||
/** Map over first
|
||||
*/
|
||||
function map1(f : 'a => 'c, t : ('a * 'b)) : ('c * 'b) = switch(t)
|
||||
(x, y) => (f(x), y)
|
||||
|
||||
/** Map over second
|
||||
*/
|
||||
function map2(f : 'b => 'c, t : ('a * 'b)) : ('a * 'c) = switch(t)
|
||||
(x, y) => (x, f(y))
|
||||
|
||||
/** Map over both
|
||||
*/
|
||||
function bimap(f : 'a => 'c, g : 'b => 'd, t : ('a * 'b)) : ('c * 'd) = switch(t)
|
||||
(x, y) => (f(x), g(y))
|
||||
|
||||
|
||||
@@ -1,117 +0,0 @@
|
||||
include "List.aes"
|
||||
namespace String =
|
||||
// Computes the SHA3/Keccak hash of the string
|
||||
function sha3(s : string) : hash = StringInternal.sha3(s)
|
||||
// Computes the SHA256 hash of the string.
|
||||
function sha256(s : string) : hash = StringInternal.sha256(s)
|
||||
// Computes the Blake2B hash of the string.
|
||||
function blake2b(s : string) : hash = StringInternal.blake2b(s)
|
||||
|
||||
// The length of a string - equivalent to List.lenght(to_list(s))
|
||||
function length(s : string) : int = StringInternal.length(s)
|
||||
// Concatenates `s1` and `s2`.
|
||||
function concat(s1 : string, s2 : string) : string = StringInternal.concat(s1, s2)
|
||||
// Concatenates a list of strings.
|
||||
function
|
||||
concats : (list(string)) => string
|
||||
concats([]) = ""
|
||||
concats(s :: ss) = List.foldl(StringInternal.concat, s, ss)
|
||||
|
||||
// Converts a `string` to a list of `char` - the code points are normalized, but
|
||||
// composite characters are possibly converted to multiple `char`s.
|
||||
function from_list(cs : list(char)) : string = StringInternal.from_list(cs)
|
||||
// Converts a list of characters into a normalized UTF-8 string.
|
||||
function to_list(s : string) : list(char) = StringInternal.to_list(s)
|
||||
|
||||
// Converts a string to lowercase.
|
||||
function to_lower(s : string) = StringInternal.to_lower(s)
|
||||
// Converts a string to uppercase.
|
||||
function to_upper(s : string) = StringInternal.to_upper(s)
|
||||
|
||||
// Splits a string at (zero-based) index `ix`.
|
||||
function split(i : int, s : string) : string * string =
|
||||
let cs = StringInternal.to_list(s)
|
||||
(StringInternal.from_list(List.take(i, cs)), StringInternal.from_list(List.drop(i, cs)))
|
||||
|
||||
// Returns the character/codepoint at (zero-based) index `ix`.
|
||||
function at(ix : int, s : string) =
|
||||
switch(List.drop(ix, StringInternal.to_list(s)))
|
||||
[] => None
|
||||
x :: _ => Some(x)
|
||||
|
||||
// Searches for `pat` in `str`, returning `Some(ix)` if `pat` is a substring
|
||||
// of `str` starting at position `ix`, otherwise returns `None`.
|
||||
function contains(str : string, substr : string) : option(int) =
|
||||
if(substr == "") Some(0)
|
||||
else
|
||||
contains_(0, StringInternal.to_list(str), StringInternal.to_list(substr))
|
||||
|
||||
// Splits `s` into tokens, `pat` is the divider of tokens.
|
||||
function tokens(s : string, pat : string) =
|
||||
require(pat != "", "String.tokens: empty pattern")
|
||||
tokens_(StringInternal.to_list(pat), StringInternal.to_list(s), [])
|
||||
|
||||
// Converts a decimal ("123", "-253") or a hexadecimal ("0xa2f", "-0xBBB") string
|
||||
// into an integer. If the string doesn't contain a valid number `None` is returned.
|
||||
function to_int(s : string) : option(int) =
|
||||
let s = StringInternal.to_list(s)
|
||||
switch(is_prefix(['-'], s))
|
||||
None => to_int_pos(s)
|
||||
Some(s) => switch(to_int_pos(s))
|
||||
None => None
|
||||
Some(x) => Some(-x)
|
||||
|
||||
// Private helper functions below
|
||||
private function to_int_pos(s : list(char)) =
|
||||
switch(is_prefix(['0', 'x'], s))
|
||||
None =>
|
||||
to_int_(s, ch_to_int_10, 0, 10)
|
||||
Some(s) =>
|
||||
to_int_(s, ch_to_int_16, 0, 16)
|
||||
|
||||
private function
|
||||
tokens_(_, [], acc) = [StringInternal.from_list(List.reverse(acc))]
|
||||
tokens_(pat, str, acc) =
|
||||
switch(is_prefix(pat, str))
|
||||
Some(str') =>
|
||||
StringInternal.from_list(List.reverse(acc)) :: tokens_(pat, str', [])
|
||||
None =>
|
||||
let c :: cs = str
|
||||
tokens_(pat, cs, c :: acc)
|
||||
|
||||
private function
|
||||
contains_(_, [], _) = None
|
||||
contains_(ix, str, substr) =
|
||||
switch(is_prefix(substr, str))
|
||||
None =>
|
||||
let _ :: str = str
|
||||
contains_(ix + 1, str, substr)
|
||||
Some(_) =>
|
||||
Some(ix)
|
||||
|
||||
private function
|
||||
is_prefix([], ys) = Some(ys)
|
||||
is_prefix(_, []) = None
|
||||
is_prefix(x :: xs, y :: ys) =
|
||||
if(x == y) is_prefix(xs, ys)
|
||||
else None
|
||||
|
||||
private function
|
||||
to_int_([], _, x, _) = Some(x)
|
||||
to_int_(i :: is, value, x, b) =
|
||||
switch(value(i))
|
||||
None => None
|
||||
Some(i) => to_int_(is, value, x * b + i, b)
|
||||
|
||||
private function ch_to_int_10(c) =
|
||||
let c = Char.to_int(c)
|
||||
if(c >= 48 && c =< 57) Some(c - 48)
|
||||
else None
|
||||
|
||||
private function ch_to_int_16(c) =
|
||||
let c = Char.to_int(c)
|
||||
if(c >= 48 && c =< 57) Some(c - 48)
|
||||
elif(c >= 65 && c =< 70) Some(c - 55)
|
||||
elif(c >= 97 && c =< 102) Some(c - 87)
|
||||
else None
|
||||
|
||||
@@ -10,23 +10,15 @@ namespace Triple =
|
||||
(_, _, z) => z
|
||||
|
||||
|
||||
/** Map over first
|
||||
*/
|
||||
function map1(f : 'a => 'm, t : ('a * 'b * 'c)) : ('m * 'b * 'c) = switch(t)
|
||||
(x, y, z) => (f(x), y, z)
|
||||
|
||||
/** Map over second
|
||||
*/
|
||||
function map2(f : 'b => 'm, t : ('a * 'b * 'c)) : ('a * 'm * 'c) = switch(t)
|
||||
(x, y, z) => (x, f(y), z)
|
||||
|
||||
/** Map over third
|
||||
*/
|
||||
function map3(f : 'c => 'm, t : ('a * 'b * 'c)) : ('a * 'b * 'm) = switch(t)
|
||||
(x, y, z) => (x, y, f(z))
|
||||
|
||||
/** Map over all elements
|
||||
*/
|
||||
function trimap( f : 'a => 'x
|
||||
, g : 'b => 'y
|
||||
, h : 'c => 'z
|
||||
@@ -37,13 +29,9 @@ namespace Triple =
|
||||
function swap(t : ('a * 'b * 'c)) : ('c * 'b * 'a) = switch(t)
|
||||
(x, y, z) => (z, y, x)
|
||||
|
||||
/** Right rotation
|
||||
*/
|
||||
function rotr(t : ('a * 'b * 'c)) : ('c * 'a * 'b) = switch(t)
|
||||
(x, y, z) => (z, x, y)
|
||||
|
||||
/** Left rotation
|
||||
*/
|
||||
function rotl(t : ('a * 'b * 'c)) : ('b * 'c * 'a) = switch(t)
|
||||
(x, y, z) => (y, z, x)
|
||||
|
||||
|
||||
+2
-2
@@ -2,7 +2,7 @@
|
||||
|
||||
{erl_opts, [debug_info]}.
|
||||
|
||||
{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"7f0d309"}}}
|
||||
{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"a66dc0a"}}}
|
||||
, {getopt, "1.0.1"}
|
||||
, {eblake2, "1.0.0"}
|
||||
, {jsx, {git, "https://github.com/talentdeficit/jsx.git",
|
||||
@@ -15,7 +15,7 @@
|
||||
{base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
|
||||
]}.
|
||||
|
||||
{relx, [{release, {aesophia, "4.3.0"},
|
||||
{relx, [{release, {aesophia, "4.0.0-rc4"},
|
||||
[aesophia, aebytecode, getopt]},
|
||||
|
||||
{dev_mode, true},
|
||||
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
{"1.1.0",
|
||||
[{<<"aebytecode">>,
|
||||
{git,"https://github.com/aeternity/aebytecode.git",
|
||||
{ref,"7f0d3090d4dc6c4d5fca7645b0c21eb0e65ad208"}},
|
||||
{ref,"a66dc0a97facdeaad7e5403018ad195d989e4793"}},
|
||||
0},
|
||||
{<<"aeserialization">>,
|
||||
{git,"https://github.com/aeternity/aeserialization.git",
|
||||
|
||||
+8
-16
@@ -14,8 +14,6 @@
|
||||
, contract_interface/2
|
||||
, contract_interface/3
|
||||
|
||||
, from_typed_ast/2
|
||||
|
||||
, render_aci_json/1
|
||||
|
||||
, json_encode_expr/1
|
||||
@@ -25,8 +23,6 @@
|
||||
-type json() :: jsx:json_term().
|
||||
-type json_text() :: binary().
|
||||
|
||||
-export_type([aci_type/0]).
|
||||
|
||||
%% External API
|
||||
-spec file(aci_type(), string()) -> {ok, json() | string()} | {error, term()}.
|
||||
file(Type, File) ->
|
||||
@@ -69,20 +65,18 @@ do_contract_interface(Type, ContractString, Options) ->
|
||||
try
|
||||
Ast = aeso_compiler:parse(ContractString, Options),
|
||||
%% io:format("~p\n", [Ast]),
|
||||
{TypedAst, _} = aeso_ast_infer_types:infer(Ast, [dont_unfold | Options]),
|
||||
TypedAst = aeso_ast_infer_types:infer(Ast, [dont_unfold]),
|
||||
%% io:format("~p\n", [TypedAst]),
|
||||
from_typed_ast(Type, TypedAst)
|
||||
JArray = [ encode_contract(C) || C <- TypedAst ],
|
||||
|
||||
case Type of
|
||||
json -> {ok, JArray};
|
||||
string -> do_render_aci_json(JArray)
|
||||
end
|
||||
catch
|
||||
throw:{error, Errors} -> {error, Errors}
|
||||
end.
|
||||
|
||||
from_typed_ast(Type, TypedAst) ->
|
||||
JArray = [ encode_contract(C) || C <- TypedAst ],
|
||||
case Type of
|
||||
json -> {ok, JArray};
|
||||
string -> do_render_aci_json(JArray)
|
||||
end.
|
||||
|
||||
encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
|
||||
C0 = #{name => encode_name(Name)},
|
||||
|
||||
@@ -135,7 +129,7 @@ encode_anon_args(Types) ->
|
||||
|
||||
encode_args(Args) -> [ encode_arg(A) || A <- Args ].
|
||||
|
||||
encode_arg({typed, _, Id, T}) ->
|
||||
encode_arg({arg, _, Id, T}) ->
|
||||
#{name => encode_type(Id),
|
||||
type => encode_type(T)}.
|
||||
|
||||
@@ -200,8 +194,6 @@ encode_expr({bytes, _, B}) ->
|
||||
encode_expr({Lit, _, L}) when Lit == oracle_pubkey; Lit == oracle_query_id;
|
||||
Lit == contract_pubkey; Lit == account_pubkey ->
|
||||
aeser_api_encoder:encode(Lit, L);
|
||||
encode_expr({app, _, {'-', _}, [{int, _, N}]}) ->
|
||||
encode_expr({int, [], -N});
|
||||
encode_expr({app, _, F, As}) ->
|
||||
Ef = encode_expr(F),
|
||||
Eas = encode_exprs(As),
|
||||
|
||||
+148
-546
File diff suppressed because it is too large
Load Diff
+118
-630
File diff suppressed because it is too large
Load Diff
+10
-31
@@ -131,7 +131,7 @@ contract_to_icode([Decl | Code], Icode) ->
|
||||
ast_id({id, _, Id}) -> Id;
|
||||
ast_id({qid, _, Id}) -> Id.
|
||||
|
||||
ast_args([{typed, _, Name, Type}|Rest], Acc, Icode) ->
|
||||
ast_args([{arg, _, Name, Type}|Rest], Acc, Icode) ->
|
||||
ast_args(Rest, [{ast_id(Name), ast_typerep1(Type, Icode)}| Acc], Icode);
|
||||
ast_args([], Acc, _Icode) -> lists:reverse(Acc).
|
||||
|
||||
@@ -318,23 +318,19 @@ ast_body({app, As, Fun, Args}, Icode) ->
|
||||
end;
|
||||
ast_body({list_comp, _, Yield, []}, Icode) ->
|
||||
#list{elems = [ast_body(Yield, Icode)]};
|
||||
ast_body({list_comp, As, Yield, [{comprehension_bind, {typed, _, Pat, ArgType}, BindExpr}|Rest]}, Icode) ->
|
||||
Arg = "%lc",
|
||||
Body = {switch, As, {typed, As, {id, As, Arg}, ArgType},
|
||||
[{'case', As, Pat, {list_comp, As, Yield, Rest}},
|
||||
{'case', As, {id, As, "_"}, {list, As, []}}]},
|
||||
ast_body({list_comp, As, Yield, [{comprehension_bind, {typed, Arg, ArgType}, BindExpr}|Rest]}, Icode) ->
|
||||
#funcall
|
||||
{ function = #var_ref{ name = ["ListInternal", "flat_map"] }
|
||||
, args =
|
||||
[ #lambda{ args=[#arg{name = Arg, type = ast_type(ArgType, Icode)}]
|
||||
, body = ast_body(Body, Icode)
|
||||
[ #lambda{ args=[#arg{name = ast_id(Arg), type = ast_type(ArgType, Icode)}]
|
||||
, body = ast_body({list_comp, As, Yield, Rest}, Icode)
|
||||
}
|
||||
, ast_body(BindExpr, Icode)
|
||||
]
|
||||
};
|
||||
ast_body({list_comp, As, Yield, [{comprehension_if, AsIF, Cond}|Rest]}, Icode) ->
|
||||
ast_body({'if', AsIF, Cond, {list_comp, As, Yield, Rest}, {list, As, []}}, Icode);
|
||||
ast_body({list_comp, As, Yield, [LV = {letval, _, _, _}|Rest]}, Icode) ->
|
||||
ast_body({list_comp, As, Yield, [LV = {letval, _, _, _, _}|Rest]}, Icode) ->
|
||||
ast_body({block, As, [LV, {list_comp, As, Yield, Rest}]}, Icode);
|
||||
ast_body({list_comp, As, Yield, [LF = {letfun, _, _, _, _, _}|Rest]}, Icode) ->
|
||||
ast_body({block, As, [LF, {list_comp, As, Yield, Rest}]}, Icode);
|
||||
@@ -348,16 +344,14 @@ ast_body({switch,_,A,Cases}, Icode) ->
|
||||
#switch{expr=ast_body(A, Icode),
|
||||
cases=[{ast_body(Pat, Icode),ast_body(Body, Icode)}
|
||||
|| {'case',_,Pat,Body} <- Cases]};
|
||||
ast_body({block, As, [{letval, _, Pat, E} | Rest]}, Icode) ->
|
||||
ast_body({block, As, [{letval, _, Pat, _, E} | Rest]}, Icode) ->
|
||||
E1 = ast_body(E, Icode),
|
||||
Pat1 = ast_body(Pat, Icode),
|
||||
Rest1 = ast_body({block, As, Rest}, Icode),
|
||||
#switch{expr = E1,
|
||||
cases = [{Pat1, Rest1}]};
|
||||
ast_body({block, As, [{letfun, Ann, F, Args, _Type, Expr} | Rest]}, Icode) ->
|
||||
ToArg = fun({typed, Ann1, Id, T}) -> {arg, Ann1, Id, T} end, %% Pattern matching has been desugared
|
||||
LamArgs = lists:map(ToArg, Args),
|
||||
ast_body({block, As, [{letval, Ann, F, {lam, Ann, LamArgs, 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) ->
|
||||
@@ -469,7 +463,6 @@ is_builtin_fun({qid, _, ["AENS", "preclaim"]}, _Icode) ->
|
||||
is_builtin_fun({qid, _, ["AENS", "claim"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["AENS", "transfer"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["AENS", "revoke"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["AENS", "update"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["Map", "lookup"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["Map", "lookup_default"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["Map", "member"]}, _Icode) -> true;
|
||||
@@ -501,7 +494,6 @@ is_builtin_fun({qid, _, ["Address", "to_str"]}, _Icode) ->
|
||||
is_builtin_fun({qid, _, ["Address", "is_oracle"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["Address", "is_contract"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["Address", "is_payable"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["Address", "to_contract"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["Bytes", "to_int"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["Bytes", "to_str"]}, _Icode) -> true;
|
||||
is_builtin_fun({qid, _, ["Bytes", "concat"]}, _Icode) -> true;
|
||||
@@ -625,12 +617,6 @@ builtin_code(_, {qid, _, ["AENS", "revoke"]}, Args, _, _, Icode) ->
|
||||
[ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Sign, Icode)],
|
||||
[word, word, sign_t()], {tuple, []});
|
||||
|
||||
builtin_code(_, {qid, _, ["AENS", "update"]}, Args, _, _, Icode) ->
|
||||
{Sign, [Addr, Name, TTL, ClientTTL, Pointers]} = get_signature_arg(Args),
|
||||
prim_call(?PRIM_CALL_AENS_UPDATE, #integer{value = 0},
|
||||
[ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(TTL, Icode), ast_body(ClientTTL, Icode), ast_body(Pointers, Icode), ast_body(Sign, Icode)],
|
||||
[word, string, word, word, word, sign_t()], {tuple, []});
|
||||
|
||||
%% -- Maps
|
||||
%% -- lookup functions
|
||||
builtin_code(_, {qid, _, ["Map", "lookup"]}, [Key, Map], _, _, Icode) ->
|
||||
@@ -727,8 +713,6 @@ builtin_code(_, {qid, _, ["Address", "is_contract"]}, [Addr], _, _, Icode) ->
|
||||
builtin_code(_, {qid, _, ["Address", "is_payable"]}, [Addr], _, _, Icode) ->
|
||||
prim_call(?PRIM_CALL_ADDR_IS_PAYABLE, #integer{value = 0},
|
||||
[ast_body(Addr, Icode)], [word], word);
|
||||
builtin_code(_, {qid, _, ["Address", "to_contract"]}, [Addr], _, _, Icode) ->
|
||||
ast_body(Addr, Icode);
|
||||
|
||||
builtin_code(_, {qid, _, ["Bytes", "to_int"]}, [Bytes], _, _, Icode) ->
|
||||
{typed, _, _, {bytes_t, _, N}} = Bytes,
|
||||
@@ -813,10 +797,10 @@ check_entrypoint_type(Ann, Name, Args, Ret) ->
|
||||
true -> ok
|
||||
end end,
|
||||
[ CheckFirstOrder(T, {invalid_entrypoint, higher_order, Ann1, Name, {argument, X, T}})
|
||||
|| {typed, Ann1, X, T} <- Args ],
|
||||
|| {arg, Ann1, X, T} <- Args ],
|
||||
CheckFirstOrder(Ret, {invalid_entrypoint, higher_order, Ann, Name, {result, Ret}}),
|
||||
[ CheckMonomorphic(T, {invalid_entrypoint, polymorphic, Ann1, Name, {argument, X, T}})
|
||||
|| {typed, Ann1, X, T} <- Args ],
|
||||
|| {arg, Ann1, X, T} <- Args ],
|
||||
CheckMonomorphic(Ret, {invalid_entrypoint, polymorphic, Ann, Name, {result, Ret}}).
|
||||
|
||||
check_oracle_type(Ann, Type = ?oracle_t(QType, RType)) ->
|
||||
@@ -934,16 +918,11 @@ ast_typerep1({variant_t, Cons}, Icode) ->
|
||||
{variant, [ begin
|
||||
{constr_t, _, _, Args} = Con,
|
||||
[ ast_typerep1(Arg, Icode) || Arg <- Args ]
|
||||
end || Con <- Cons ]};
|
||||
ast_typerep1({if_t, _, _, _, Else}, Icode) ->
|
||||
ast_typerep1(Else, Icode). %% protected remote calls are not in AEVM
|
||||
end || Con <- Cons ]}.
|
||||
|
||||
ttl_t(Icode) ->
|
||||
ast_typerep({qid, [], ["Chain", "ttl"]}, Icode).
|
||||
|
||||
%% pointee_t(Icode) ->
|
||||
%% ast_typerep({qid, [], ["AENS", "pointee"]}, Icode).
|
||||
|
||||
sign_t() -> bytes_t(64).
|
||||
bytes_t(Len) when Len =< 32 -> word;
|
||||
bytes_t(Len) -> {tuple, lists:duplicate((31 + Len) div 32, word)}.
|
||||
|
||||
+43
-166
@@ -15,7 +15,6 @@
|
||||
, create_calldata/3 %% deprecated
|
||||
, create_calldata/4
|
||||
, version/0
|
||||
, numeric_version/0
|
||||
, sophia_type_to_typerep/1
|
||||
, to_sophia_value/4 %% deprecated, need a backend
|
||||
, to_sophia_value/5
|
||||
@@ -23,7 +22,6 @@
|
||||
, decode_calldata/4
|
||||
, parse/2
|
||||
, add_include_path/2
|
||||
, validate_byte_code/3
|
||||
]).
|
||||
|
||||
-include_lib("aebytecode/include/aeb_opcodes.hrl").
|
||||
@@ -38,13 +36,10 @@
|
||||
| pp_assembler
|
||||
| pp_bytecode
|
||||
| no_code
|
||||
| keep_included
|
||||
| debug_mode
|
||||
| {backend, aevm | fate}
|
||||
| {include, {file_system, [string()]} |
|
||||
{explicit_files, #{string() => binary()}}}
|
||||
| {src_file, string()}
|
||||
| {aci, aeso_aci:aci_type()}.
|
||||
| {src_file, string()}.
|
||||
-type options() :: [option()].
|
||||
|
||||
-export_type([ option/0
|
||||
@@ -70,17 +65,6 @@ version() ->
|
||||
{ok, list_to_binary(VsnString)}
|
||||
end.
|
||||
|
||||
-spec numeric_version() -> {ok, [non_neg_integer()]} | {error, term()}.
|
||||
numeric_version() ->
|
||||
case version() of
|
||||
{ok, Bin} ->
|
||||
[NoSuf | _] = binary:split(Bin, <<"-">>),
|
||||
Numbers = binary:split(NoSuf, <<".">>, [global]),
|
||||
{ok, [binary_to_integer(Num) || Num <- Numbers]};
|
||||
{error, _} = Err ->
|
||||
Err
|
||||
end.
|
||||
|
||||
-spec file(string()) -> {ok, map()} | {error, [aeso_errors:error()]}.
|
||||
file(Filename) ->
|
||||
file(Filename, []).
|
||||
@@ -118,8 +102,7 @@ from_string(Backend, ContractString, Options) ->
|
||||
end.
|
||||
|
||||
from_string1(aevm, ContractString, Options) ->
|
||||
#{ icode := Icode
|
||||
, folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
|
||||
#{icode := Icode} = string_to_code(ContractString, Options),
|
||||
TypeInfo = extract_type_info(Icode),
|
||||
Assembler = assemble(Icode, Options),
|
||||
pp_assembler(aevm, Assembler, Options),
|
||||
@@ -127,63 +110,47 @@ from_string1(aevm, ContractString, Options) ->
|
||||
ByteCode = << << B:8 >> || B <- ByteCodeList >>,
|
||||
pp_bytecode(ByteCode, Options),
|
||||
{ok, Version} = version(),
|
||||
Res = #{byte_code => ByteCode,
|
||||
compiler_version => Version,
|
||||
contract_source => ContractString,
|
||||
type_info => TypeInfo,
|
||||
abi_version => aeb_aevm_abi:abi_version(),
|
||||
payable => maps:get(payable, Icode)
|
||||
},
|
||||
{ok, maybe_generate_aci(Res, FoldedTypedAst, Options)};
|
||||
{ok, #{byte_code => ByteCode,
|
||||
compiler_version => Version,
|
||||
contract_source => ContractString,
|
||||
type_info => TypeInfo,
|
||||
abi_version => aeb_aevm_abi:abi_version(),
|
||||
payable => maps:get(payable, Icode)
|
||||
}};
|
||||
from_string1(fate, ContractString, Options) ->
|
||||
#{ fcode := FCode
|
||||
, folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
|
||||
#{fcode := FCode} = string_to_code(ContractString, Options),
|
||||
FateCode = aeso_fcode_to_fate:compile(FCode, Options),
|
||||
pp_assembler(fate, FateCode, Options),
|
||||
ByteCode = aeb_fate_code:serialize(FateCode, []),
|
||||
{ok, Version} = version(),
|
||||
Res = #{byte_code => ByteCode,
|
||||
compiler_version => Version,
|
||||
contract_source => ContractString,
|
||||
type_info => [],
|
||||
fate_code => FateCode,
|
||||
abi_version => aeb_fate_abi:abi_version(),
|
||||
payable => maps:get(payable, FCode)
|
||||
},
|
||||
{ok, maybe_generate_aci(Res, FoldedTypedAst, Options)}.
|
||||
|
||||
maybe_generate_aci(Result, FoldedTypedAst, Options) ->
|
||||
case proplists:get_value(aci, Options) of
|
||||
undefined ->
|
||||
Result;
|
||||
Type ->
|
||||
{ok, Aci} = aeso_aci:from_typed_ast(Type, FoldedTypedAst),
|
||||
maps:put(aci, Aci, Result)
|
||||
end.
|
||||
{ok, #{byte_code => ByteCode,
|
||||
compiler_version => Version,
|
||||
contract_source => ContractString,
|
||||
type_info => [],
|
||||
fate_code => FateCode,
|
||||
abi_version => aeb_fate_abi:abi_version(),
|
||||
payable => maps:get(payable, FCode)
|
||||
}}.
|
||||
|
||||
-spec string_to_code(string(), options()) -> map().
|
||||
string_to_code(ContractString, Options) ->
|
||||
Ast = parse(ContractString, Options),
|
||||
pp_sophia_code(Ast, Options),
|
||||
pp_ast(Ast, Options),
|
||||
{TypeEnv, FoldedTypedAst, UnfoldedTypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
|
||||
pp_typed_ast(UnfoldedTypedAst, Options),
|
||||
{TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
|
||||
pp_typed_ast(TypedAst, Options),
|
||||
case proplists:get_value(backend, Options, aevm) of
|
||||
aevm ->
|
||||
Icode = ast_to_icode(UnfoldedTypedAst, Options),
|
||||
Icode = ast_to_icode(TypedAst, Options),
|
||||
pp_icode(Icode, Options),
|
||||
#{ icode => Icode
|
||||
, unfolded_typed_ast => UnfoldedTypedAst
|
||||
, folded_typed_ast => FoldedTypedAst
|
||||
, type_env => TypeEnv
|
||||
, ast => Ast };
|
||||
#{ icode => Icode,
|
||||
typed_ast => TypedAst,
|
||||
type_env => TypeEnv};
|
||||
fate ->
|
||||
Fcode = aeso_ast_to_fcode:ast_to_fcode(UnfoldedTypedAst, Options),
|
||||
#{ fcode => Fcode
|
||||
, unfolded_typed_ast => UnfoldedTypedAst
|
||||
, folded_typed_ast => FoldedTypedAst
|
||||
, type_env => TypeEnv
|
||||
, ast => Ast }
|
||||
Fcode = aeso_ast_to_fcode:ast_to_fcode(TypedAst, Options),
|
||||
#{ fcode => Fcode,
|
||||
typed_ast => TypedAst,
|
||||
type_env => TypeEnv}
|
||||
end.
|
||||
|
||||
-define(CALL_NAME, "__call").
|
||||
@@ -218,9 +185,9 @@ check_call1(ContractString0, FunName, Args, Options) ->
|
||||
case proplists:get_value(backend, Options, aevm) of
|
||||
aevm ->
|
||||
%% First check the contract without the __call function
|
||||
#{ast := Ast} = string_to_code(ContractString0, Options),
|
||||
ContractString = insert_call_function(Ast, ContractString0, ?CALL_NAME, FunName, Args),
|
||||
#{unfolded_typed_ast := TypedAst,
|
||||
#{} = string_to_code(ContractString0, Options),
|
||||
ContractString = insert_call_function(ContractString0, ?CALL_NAME, FunName, Args, Options),
|
||||
#{typed_ast := TypedAst,
|
||||
icode := Icode} = string_to_code(ContractString, Options),
|
||||
{ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
|
||||
ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
|
||||
@@ -240,14 +207,13 @@ check_call1(ContractString0, FunName, Args, Options) ->
|
||||
{ok, FunName, {ArgVMTypes, RetVMType1}, ArgTerms};
|
||||
fate ->
|
||||
%% First check the contract without the __call function
|
||||
#{ fcode := OrgFcode
|
||||
, ast := Ast } = string_to_code(ContractString0, Options),
|
||||
#{fcode := OrgFcode} = string_to_code(ContractString0, Options),
|
||||
FateCode = aeso_fcode_to_fate:compile(OrgFcode, []),
|
||||
%% collect all hashes and compute the first name without hash collision to
|
||||
SymbolHashes = maps:keys(aeb_fate_code:symbols(FateCode)),
|
||||
CallName = first_none_match(?CALL_NAME, SymbolHashes,
|
||||
lists:seq($1, $9) ++ lists:seq($A, $Z) ++ lists:seq($a, $z)),
|
||||
ContractString = insert_call_function(Ast, ContractString0, CallName, FunName, Args),
|
||||
ContractString = insert_call_function(ContractString0, CallName, FunName, Args, Options),
|
||||
#{fcode := Fcode} = string_to_code(ContractString, Options),
|
||||
CallArgs = arguments_of_body(CallName, FunName, Fcode),
|
||||
{ok, FunName, CallArgs}
|
||||
@@ -273,8 +239,9 @@ first_none_match(CallName, Hashes, [Char|Chars]) ->
|
||||
end.
|
||||
|
||||
%% Add the __call function to a contract.
|
||||
-spec insert_call_function(aeso_syntax:ast(), string(), string(), string(), [string()]) -> string().
|
||||
insert_call_function(Ast, Code, Call, FunName, Args) ->
|
||||
-spec insert_call_function(string(), string(), string(), [string()], options()) -> string().
|
||||
insert_call_function(Code, Call, FunName, Args, Options) ->
|
||||
Ast = parse(Code, Options),
|
||||
Ind = last_contract_indent(Ast),
|
||||
lists:flatten(
|
||||
[ Code,
|
||||
@@ -330,7 +297,7 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
|
||||
Options = [no_code | Options0],
|
||||
try
|
||||
Code = string_to_code(ContractString, Options),
|
||||
#{ unfolded_typed_ast := TypedAst, type_env := TypeEnv} = Code,
|
||||
#{ typed_ast := TypedAst, type_env := TypeEnv} = Code,
|
||||
{ok, _, Type0} = get_decode_type(FunName, TypedAst),
|
||||
Type = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
|
||||
|
||||
@@ -356,12 +323,12 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
|
||||
try
|
||||
{ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
|
||||
catch throw:cannot_translate_to_sophia ->
|
||||
Type1 = prettypr:format(aeso_pretty:type(Type0)),
|
||||
Type1 = prettypr:format(aeso_pretty:type(Type)),
|
||||
Msg = io_lib:format("Cannot translate FATE value ~p\n of Sophia type ~s\n",
|
||||
[aeb_fate_encoding:deserialize(Data), Type1]),
|
||||
{error, [aeso_errors:new(data_error, Msg)]};
|
||||
_:_ ->
|
||||
Type1 = prettypr:format(aeso_pretty:type(Type0)),
|
||||
Type1 = prettypr:format(aeso_pretty:type(Type)),
|
||||
Msg = io_lib:format("Failed to decode binary as type ~s\n", [Type1]),
|
||||
{error, [aeso_errors:new(data_error, Msg)]}
|
||||
end
|
||||
@@ -406,11 +373,11 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
|
||||
Options = [no_code | Options0],
|
||||
try
|
||||
Code = string_to_code(ContractString, Options),
|
||||
#{ unfolded_typed_ast := TypedAst, type_env := TypeEnv} = Code,
|
||||
#{ typed_ast := TypedAst, type_env := TypeEnv} = Code,
|
||||
|
||||
{ok, Args, _} = get_decode_type(FunName, TypedAst),
|
||||
GetType = fun({typed, _, _, T}) -> T; (T) -> T end,
|
||||
ArgTypes = lists:map(GetType, Args),
|
||||
DropArg = fun({arg, _, _, T}) -> T; (T) -> T end,
|
||||
ArgTypes = lists:map(DropArg, Args),
|
||||
Type0 = {tuple_t, [], ArgTypes},
|
||||
%% user defined data types such as variants needed to match against
|
||||
Type = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
|
||||
@@ -528,14 +495,6 @@ icode_to_term(T = {map, KT, VT}, M) ->
|
||||
#{};
|
||||
_ -> throw({todo, M})
|
||||
end;
|
||||
icode_to_term(word, {unop, 'bnot', A}) ->
|
||||
bnot icode_to_term(word, A);
|
||||
icode_to_term(word, {binop, 'bor', A, B}) ->
|
||||
icode_to_term(word, A) bor icode_to_term(word, B);
|
||||
icode_to_term(word, {binop, 'bsl', A, B}) ->
|
||||
icode_to_term(word, B) bsl icode_to_term(word, A);
|
||||
icode_to_term(word, {binop, 'band', A, B}) ->
|
||||
icode_to_term(word, A) band icode_to_term(word, B);
|
||||
icode_to_term(typerep, _) ->
|
||||
throw({todo, typerep});
|
||||
icode_to_term(T, V) ->
|
||||
@@ -587,92 +546,10 @@ pp(Code, Options, Option, PPFun) ->
|
||||
ok
|
||||
end.
|
||||
|
||||
%% -- Byte code validation ---------------------------------------------------
|
||||
|
||||
-define(protect(Tag, Code), fun() -> try Code catch _:Err1 -> throw({Tag, Err1}) end end()).
|
||||
|
||||
-spec validate_byte_code(map(), string(), options()) -> ok | {error, [aeso_errors:error()]}.
|
||||
validate_byte_code(#{ byte_code := ByteCode, payable := Payable }, Source, Options) ->
|
||||
Fail = fun(Err) -> {error, [aeso_errors:new(data_error, Err)]} end,
|
||||
case proplists:get_value(backend, Options, aevm) of
|
||||
B when B /= fate -> Fail(io_lib:format("Unsupported backend: ~s\n", [B]));
|
||||
fate ->
|
||||
try
|
||||
FCode1 = ?protect(deserialize, aeb_fate_code:strip_init_function(aeb_fate_code:deserialize(ByteCode))),
|
||||
{FCode2, SrcPayable} =
|
||||
?protect(compile,
|
||||
begin
|
||||
{ok, #{ byte_code := SrcByteCode, payable := SrcPayable }} =
|
||||
from_string1(fate, Source, Options),
|
||||
FCode = aeb_fate_code:deserialize(SrcByteCode),
|
||||
{aeb_fate_code:strip_init_function(FCode), SrcPayable}
|
||||
end),
|
||||
case compare_fate_code(FCode1, FCode2) of
|
||||
ok when SrcPayable /= Payable ->
|
||||
Not = fun(true) -> ""; (false) -> " not" end,
|
||||
Fail(io_lib:format("Byte code contract is~s payable, but source code contract is~s.\n",
|
||||
[Not(Payable), Not(SrcPayable)]));
|
||||
ok -> ok;
|
||||
{error, Why} -> Fail(io_lib:format("Byte code does not match source code.\n~s", [Why]))
|
||||
end
|
||||
catch
|
||||
throw:{deserialize, _} -> Fail("Invalid byte code");
|
||||
throw:{compile, {error, Errs}} -> {error, Errs}
|
||||
end
|
||||
end.
|
||||
|
||||
compare_fate_code(FCode1, FCode2) ->
|
||||
Funs1 = aeb_fate_code:functions(FCode1),
|
||||
Funs2 = aeb_fate_code:functions(FCode2),
|
||||
Syms1 = aeb_fate_code:symbols(FCode1),
|
||||
Syms2 = aeb_fate_code:symbols(FCode2),
|
||||
FunHashes1 = maps:keys(Funs1),
|
||||
FunHashes2 = maps:keys(Funs2),
|
||||
case FunHashes1 == FunHashes2 of
|
||||
false ->
|
||||
InByteCode = [ binary_to_list(maps:get(H, Syms1)) || H <- FunHashes1 -- FunHashes2 ],
|
||||
InSourceCode = [ binary_to_list(maps:get(H, Syms2)) || H <- FunHashes2 -- FunHashes1 ],
|
||||
Msg = [ io_lib:format("- Functions in the byte code but not in the source code:\n"
|
||||
" ~s\n", [string:join(InByteCode, ", ")]) || InByteCode /= [] ] ++
|
||||
[ io_lib:format("- Functions in the source code but not in the byte code:\n"
|
||||
" ~s\n", [string:join(InSourceCode, ", ")]) || InSourceCode /= [] ],
|
||||
{error, Msg};
|
||||
true ->
|
||||
case lists:append([ compare_fate_fun(maps:get(H, Syms1), Fun1, Fun2)
|
||||
|| {{H, Fun1}, {_, Fun2}} <- lists:zip(maps:to_list(Funs1),
|
||||
maps:to_list(Funs2)) ]) of
|
||||
[] -> ok;
|
||||
Errs -> {error, Errs}
|
||||
end
|
||||
end.
|
||||
|
||||
compare_fate_fun(_Name, Fun, Fun) -> [];
|
||||
compare_fate_fun(Name, {Attr, Type, _}, {Attr, Type, _}) ->
|
||||
[io_lib:format("- The implementation of the function ~s is different.\n", [Name])];
|
||||
compare_fate_fun(Name, {Attr1, Type, _}, {Attr2, Type, _}) ->
|
||||
[io_lib:format("- The attributes of the function ~s differ:\n"
|
||||
" Byte code: ~s\n"
|
||||
" Source code: ~s\n",
|
||||
[Name, string:join([ atom_to_list(A) || A <- Attr1 ], ", "),
|
||||
string:join([ atom_to_list(A) || A <- Attr2 ], ", ")])];
|
||||
compare_fate_fun(Name, {_, Type1, _}, {_, Type2, _}) ->
|
||||
[io_lib:format("- The type of the function ~s differs:\n"
|
||||
" Byte code: ~s\n"
|
||||
" Source code: ~s\n",
|
||||
[Name, pp_fate_sig(Type1), pp_fate_sig(Type2)])].
|
||||
|
||||
pp_fate_sig({[Arg], Res}) ->
|
||||
io_lib:format("~s => ~s", [pp_fate_type(Arg), pp_fate_type(Res)]);
|
||||
pp_fate_sig({Args, Res}) ->
|
||||
io_lib:format("(~s) => ~s", [string:join([pp_fate_type(Arg) || Arg <- Args], ", "), pp_fate_type(Res)]).
|
||||
|
||||
pp_fate_type(T) -> io_lib:format("~w", [T]).
|
||||
|
||||
%% -------------------------------------------------------------------
|
||||
|
||||
-spec sophia_type_to_typerep(string()) -> {error, bad_type} | {ok, aeb_aevm_data:type()}.
|
||||
sophia_type_to_typerep(String) ->
|
||||
Ast = aeso_parser:run_parser(aeso_parser:type(), String),
|
||||
{ok, Ast} = aeso_parser:type(String),
|
||||
try aeso_ast_to_icode:ast_typerep(Ast) of
|
||||
Type -> {ok, Type}
|
||||
catch _:_ -> {error, bad_type}
|
||||
|
||||
+305
-457
File diff suppressed because it is too large
Load Diff
+20
-24
@@ -73,33 +73,28 @@ new(Options) ->
|
||||
|
||||
builtin_types() ->
|
||||
Word = fun([]) -> word end,
|
||||
#{ "bool" => Word
|
||||
, "int" => Word
|
||||
, "char" => Word
|
||||
, "bits" => Word
|
||||
, "string" => fun([]) -> string end
|
||||
, "address" => Word
|
||||
, "hash" => Word
|
||||
, "unit" => fun([]) -> {tuple, []} end
|
||||
, "signature" => fun([]) -> {tuple, [word, word]} end
|
||||
, "oracle" => fun([_, _]) -> word end
|
||||
, "oracle_query" => fun([_, _]) -> word end
|
||||
, "list" => fun([A]) -> {list, A} end
|
||||
, "option" => fun([A]) -> {variant, [[], [A]]} end
|
||||
, "map" => fun([K, V]) -> map_typerep(K, V) end
|
||||
, ["Chain", "ttl"] => fun([]) -> {variant, [[word], [word]]} end
|
||||
, ["AENS", "pointee"] => fun([]) -> {variant, [[word], [word], [word]]} end
|
||||
#{ "bool" => Word
|
||||
, "int" => Word
|
||||
, "char" => Word
|
||||
, "bits" => Word
|
||||
, "string" => fun([]) -> string end
|
||||
, "address" => Word
|
||||
, "hash" => Word
|
||||
, "unit" => fun([]) -> {tuple, []} end
|
||||
, "signature" => fun([]) -> {tuple, [word, word]} end
|
||||
, "oracle" => fun([_, _]) -> word end
|
||||
, "oracle_query" => fun([_, _]) -> word end
|
||||
, "list" => fun([A]) -> {list, A} end
|
||||
, "option" => fun([A]) -> {variant, [[], [A]]} end
|
||||
, "map" => fun([K, V]) -> map_typerep(K, V) end
|
||||
, ["Chain", "ttl"] => fun([]) -> {variant, [[word], [word]]} end
|
||||
}.
|
||||
|
||||
builtin_constructors() ->
|
||||
#{ ["RelativeTTL"] => 0
|
||||
, ["FixedTTL"] => 1
|
||||
, ["None"] => 0
|
||||
, ["Some"] => 1
|
||||
, ["AccountPointee"] => 0
|
||||
, ["OraclePointee"] => 1
|
||||
, ["ContractPointee"] => 2
|
||||
}.
|
||||
#{ ["RelativeTTL"] => 0
|
||||
, ["FixedTTL"] => 1
|
||||
, ["None"] => 0
|
||||
, ["Some"] => 1 }.
|
||||
|
||||
map_typerep(K, V) ->
|
||||
{map, K, V}.
|
||||
@@ -151,3 +146,4 @@ get_constructor_tag(Name, #{constructors := Constructors}) ->
|
||||
undefined -> error({undefined_constructor, Name});
|
||||
Tag -> Tag
|
||||
end.
|
||||
|
||||
|
||||
@@ -355,6 +355,7 @@ unexpected_token_error(Ts, Expect, T) ->
|
||||
{con, _, X} when ExpectId -> io_lib:format(" Did you mean ~s?", [mk_lower(X)]);
|
||||
{qcon, _, Xs} when ExpectCon -> io_lib:format(" Did you mean ~s?", [lists:last(Xs)]);
|
||||
{qid, _, Xs} when ExpectId -> io_lib:format(" Did you mean ~s?", [lists:last(Xs)]);
|
||||
{return, _} -> " [Polite reminder that Sophia is not JavaScript]";
|
||||
_ -> ""
|
||||
end,
|
||||
mk_error(Ts, io_lib:format("Unexpected ~s.~s", [describe(T), Fix])).
|
||||
|
||||
+45
-106
@@ -3,33 +3,20 @@
|
||||
%%% Description :
|
||||
%%% Created : 1 Mar 2018 by Ulf Norell
|
||||
-module(aeso_parser).
|
||||
-compile({no_auto_import,[map_get/2]}).
|
||||
|
||||
-export([string/1,
|
||||
string/2,
|
||||
string/3,
|
||||
auto_imports/1,
|
||||
hash_include/2,
|
||||
decl/0,
|
||||
type/0,
|
||||
body/0,
|
||||
maybe_block/1,
|
||||
run_parser/2,
|
||||
run_parser/3]).
|
||||
type/1]).
|
||||
|
||||
-include("aeso_parse_lib.hrl").
|
||||
-import(aeso_parse_lib, [current_file/0, set_current_file/1]).
|
||||
|
||||
-type parse_result() :: aeso_syntax:ast() | {aeso_syntax:ast(), sets:set(include_hash())} | none().
|
||||
-type parse_result() :: aeso_syntax:ast() | none().
|
||||
|
||||
-type include_hash() :: {string(), binary()}.
|
||||
|
||||
|
||||
escape_errors({ok, Ok}) ->
|
||||
Ok;
|
||||
escape_errors({error, Err}) ->
|
||||
parse_error(Err).
|
||||
|
||||
-spec string(string()) -> parse_result().
|
||||
string(String) ->
|
||||
string(String, sets:new(), []).
|
||||
@@ -43,24 +30,27 @@ string(String, Opts) ->
|
||||
|
||||
-spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
|
||||
string(String, Included, Opts) ->
|
||||
AST = run_parser(file(), String, Opts),
|
||||
case expand_includes(AST, Included, Opts) of
|
||||
{ok, AST1} -> AST1;
|
||||
{error, Err} -> parse_error(Err)
|
||||
case parse_and_scan(file(), String, Opts) of
|
||||
{ok, AST} ->
|
||||
case expand_includes(AST, Included, Opts) of
|
||||
{ok, AST1} -> AST1;
|
||||
{error, Err} -> parse_error(Err)
|
||||
end;
|
||||
{error, Err} ->
|
||||
parse_error(Err)
|
||||
end.
|
||||
|
||||
|
||||
run_parser(P, Inp) ->
|
||||
escape_errors(parse_and_scan(P, Inp, [])).
|
||||
run_parser(P, Inp, Opts) ->
|
||||
escape_errors(parse_and_scan(P, Inp, Opts)).
|
||||
type(String) ->
|
||||
case parse_and_scan(type(), String, []) of
|
||||
{ok, AST} -> {ok, AST};
|
||||
{error, Err} -> {error, [mk_error(Err)]}
|
||||
end.
|
||||
|
||||
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, {{Input, Pos}, _}} ->
|
||||
{error, {Pos, scan_error, Input}}
|
||||
Error -> Error
|
||||
end.
|
||||
|
||||
-dialyzer({nowarn_function, parse_error/1}).
|
||||
@@ -70,8 +60,8 @@ parse_error(Err) ->
|
||||
mk_p_err(Pos, Msg) ->
|
||||
aeso_errors:new(parse_error, mk_pos(Pos), lists:flatten(Msg)).
|
||||
|
||||
mk_error({Pos, scan_error, Input}) ->
|
||||
mk_p_err(Pos, io_lib:format("Lexical error on input: ~s\n", [Input]));
|
||||
mk_error({Pos, ScanE}) when ScanE == scan_error; ScanE == scan_error_no_state ->
|
||||
mk_p_err(Pos, "Scan error\n");
|
||||
mk_error({Pos, parse_error, Err}) ->
|
||||
Msg = io_lib:format("~s\n", [Err]),
|
||||
mk_p_err(Pos, Msg);
|
||||
@@ -97,7 +87,6 @@ decl() ->
|
||||
, ?RULE(token(payable), keyword(contract), con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract, _2, _3, _5}))
|
||||
, ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
|
||||
, ?RULE(keyword(include), str(), {include, get_ann(_1), _2})
|
||||
, pragma()
|
||||
|
||||
%% Type declarations TODO: format annotation for "type bla" vs "type bla()"
|
||||
, ?RULE(keyword(type), id(), {type_decl, _1, _2, []})
|
||||
@@ -110,31 +99,13 @@ decl() ->
|
||||
, ?RULE(keyword(datatype), id(), type_vars(), tok('='), typedef(variant), {type_def, _1, _2, _3, _5})
|
||||
|
||||
%% Function declarations
|
||||
, ?RULE(modifiers(), fun_or_entry(), maybe_block(fundef_or_decl()), fun_block(_1, _2, _3))
|
||||
, ?RULE(keyword('let'), valdef(), set_pos(get_pos(_1), _2))
|
||||
, ?RULE(modifiers(), fun_or_entry(), id(), tok(':'), type(), add_modifiers(_1, _2, {fun_decl, get_ann(_2), _3, _5}))
|
||||
, ?RULE(modifiers(), fun_or_entry(), fundef(), add_modifiers(_1, _2, set_pos(get_pos(get_ann(_2)), _3)))
|
||||
, ?RULE(keyword('let'), valdef(), set_pos(get_pos(_1), _2))
|
||||
])).
|
||||
|
||||
fun_block(Mods, Kind, [Decl]) ->
|
||||
add_modifiers(Mods, Kind, set_pos(get_pos(Kind), Decl));
|
||||
fun_block(Mods, Kind, Decls) ->
|
||||
{block, get_ann(Kind), [ add_modifiers(Mods, Kind, Decl) || Decl <- Decls ]}.
|
||||
|
||||
fundef_or_decl() ->
|
||||
choice([?RULE(id(), tok(':'), type(), {fun_decl, get_ann(_1), _1, _3}),
|
||||
fundef()]).
|
||||
|
||||
pragma() ->
|
||||
Op = choice([token(T) || T <- ['<', '=<', '==', '>=', '>']]),
|
||||
?RULE(tok('@'), id("compiler"), Op, version(), {pragma, get_ann(_1), {compiler, element(1, _3), _4}}).
|
||||
|
||||
version() ->
|
||||
?RULE(token(int), many({tok('.'), token(int)}), mk_version(_1, _2)).
|
||||
|
||||
mk_version({int, _, Maj}, Rest) ->
|
||||
[Maj | [N || {_, {int, _, N}} <- Rest]].
|
||||
|
||||
fun_or_entry() ->
|
||||
choice([?RULE(keyword(function), {function, _1}),
|
||||
choice([?RULE(keyword(function), {function, _1}),
|
||||
?RULE(keyword(entrypoint), {entrypoint, _1})]).
|
||||
|
||||
modifiers() ->
|
||||
@@ -181,19 +152,20 @@ letdecl() ->
|
||||
letdef() -> choice(valdef(), fundef()).
|
||||
|
||||
valdef() ->
|
||||
?RULE(pattern(), tok('='), body(), {letval, [], _1, _3}).
|
||||
choice(
|
||||
?RULE(id(), tok('='), body(), {letval, [], _1, type_wildcard(), _3}),
|
||||
?RULE(id(), tok(':'), type(), tok('='), body(), {letval, [], _1, _3, _5})).
|
||||
|
||||
fundef() ->
|
||||
choice(
|
||||
[ ?RULE(id(), args(), tok('='), body(), {letfun, get_ann(_1), _1, _2, type_wildcard(get_ann(_1)), _4})
|
||||
, ?RULE(id(), args(), tok(':'), type(), tok('='), body(), {letfun, get_ann(_1), _1, _2, _4, _6})
|
||||
[ ?RULE(id(), args(), tok('='), body(), {letfun, [], _1, _2, type_wildcard(), _4})
|
||||
, ?RULE(id(), args(), tok(':'), type(), tok('='), body(), {letfun, [], _1, _2, _4, _6})
|
||||
]).
|
||||
|
||||
args() -> paren_list(pattern()).
|
||||
lam_args() -> paren_list(arg()).
|
||||
args() -> paren_list(arg()).
|
||||
|
||||
arg() -> choice(
|
||||
?RULE(id(), {arg, get_ann(_1), _1, type_wildcard(get_ann(_1))}),
|
||||
?RULE(id(), {arg, get_ann(_1), _1, type_wildcard()}),
|
||||
?RULE(id(), tok(':'), type(), {arg, get_ann(_1), _1, _3})).
|
||||
|
||||
%% -- Types ------------------------------------------------------------------
|
||||
@@ -254,7 +226,7 @@ branch() ->
|
||||
?RULE(pattern(), keyword('=>'), body(), {'case', _2, _1, _3}).
|
||||
|
||||
pattern() ->
|
||||
?LET_P(E, expr(), parse_pattern(E)).
|
||||
?LET_P(E, expr500(), parse_pattern(E)).
|
||||
|
||||
%% -- Expressions ------------------------------------------------------------
|
||||
|
||||
@@ -264,7 +236,7 @@ expr100() ->
|
||||
Expr100 = ?LAZY_P(expr100()),
|
||||
Expr200 = ?LAZY_P(expr200()),
|
||||
choice(
|
||||
[ ?RULE(lam_args(), keyword('=>'), body(), {lam, _2, _1, _3}) %% TODO: better location
|
||||
[ ?RULE(args(), keyword('=>'), body(), {lam, _2, _1, _3}) %% TODO: better location
|
||||
, {'if', keyword('if'), parens(Expr100), Expr200, right(tok(else), Expr100)}
|
||||
, ?RULE(Expr200, optional(right(tok(':'), type())),
|
||||
case _2 of
|
||||
@@ -313,7 +285,7 @@ comprehension_if() ->
|
||||
?RULE(keyword('if'), parens(expr()), {comprehension_if, _1, _2}).
|
||||
|
||||
comprehension_bind() ->
|
||||
?RULE(pattern(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
|
||||
?RULE(id(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
|
||||
|
||||
arg_expr() ->
|
||||
?LAZY_P(
|
||||
@@ -365,9 +337,7 @@ record(Fs) ->
|
||||
bad_expr_err("Cannot use '@' in map construction", infix({lvalue, FAnn, LV}, {'@', Ann}, Id));
|
||||
({field, FAnn, LV, _}) ->
|
||||
bad_expr_err("Cannot use nested fields or keys in map construction", {lvalue, FAnn, LV}) end,
|
||||
{map, Ann, lists:map(KV, Fs)};
|
||||
record_or_map_error ->
|
||||
{record_or_map_error, get_ann(hd(Fs)), Fs}
|
||||
{map, Ann, lists:map(KV, Fs)}
|
||||
end.
|
||||
|
||||
record_or_map(Fields) ->
|
||||
@@ -379,7 +349,9 @@ record_or_map(Fields) ->
|
||||
case lists:usort(lists:map(Kind, Fields)) of
|
||||
[proj] -> record;
|
||||
[map_get] -> map;
|
||||
_ -> record_or_map_error %% Defer error until type checking
|
||||
_ ->
|
||||
[{field, Ann, _, _} | _] = Fields,
|
||||
bad_expr_err("Mixed record fields and map keys in", {record, Ann, Fields})
|
||||
end.
|
||||
|
||||
field_assignment() ->
|
||||
@@ -434,7 +406,7 @@ token(Tag) ->
|
||||
id(Id) ->
|
||||
?LET_P({id, A, X} = Y, id(),
|
||||
if X == Id -> Y;
|
||||
true -> fail({A, "expected '" ++ Id ++ "'"})
|
||||
true -> fail({A, "expected 'bytes'"})
|
||||
end).
|
||||
|
||||
id_or_addr() ->
|
||||
@@ -510,8 +482,8 @@ infix(L, Op, R) -> set_ann(format, infix, {app, get_ann(L), Op, [L, R]}).
|
||||
prefixes(Ops, E) -> lists:foldr(fun prefix/2, E, Ops).
|
||||
prefix(Op, E) -> set_ann(format, prefix, {app, get_ann(Op), Op, [E]}).
|
||||
|
||||
type_wildcard(Ann) ->
|
||||
{id, [{origin, system} | Ann], "_"}.
|
||||
type_wildcard() ->
|
||||
{id, [{origin, system}], "_"}.
|
||||
|
||||
block_e(Stmts) ->
|
||||
group_ifs(Stmts, []).
|
||||
@@ -561,9 +533,7 @@ list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.
|
||||
-spec parse_pattern(aeso_syntax:expr()) -> aeso_parse_lib:parser(aeso_syntax:pat()).
|
||||
parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
|
||||
{app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
|
||||
parse_pattern({app, Ann, {'-', _}, [{int, _, N}]}) ->
|
||||
{int, Ann, -N};
|
||||
parse_pattern({app, Ann, Con = {Tag, _, _}, Es}) when Tag == con; Tag == qcon ->
|
||||
parse_pattern({app, Ann, Con = {con, _, _}, Es}) ->
|
||||
{app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
|
||||
parse_pattern({tuple, Ann, Es}) ->
|
||||
{tuple, Ann, lists:map(fun parse_pattern/1, Es)};
|
||||
@@ -571,10 +541,7 @@ parse_pattern({list, Ann, Es}) ->
|
||||
{list, Ann, lists:map(fun parse_pattern/1, Es)};
|
||||
parse_pattern({record, Ann, Fs}) ->
|
||||
{record, Ann, lists:map(fun parse_field_pattern/1, Fs)};
|
||||
parse_pattern({typed, Ann, E, Type}) ->
|
||||
{typed, Ann, parse_pattern(E), Type};
|
||||
parse_pattern(E = {con, _, _}) -> E;
|
||||
parse_pattern(E = {qcon, _, _}) -> E;
|
||||
parse_pattern(E = {id, _, _}) -> E;
|
||||
parse_pattern(E = {int, _, _}) -> E;
|
||||
parse_pattern(E = {bool, _, _}) -> E;
|
||||
@@ -605,13 +572,8 @@ expand_includes(AST, Included, Opts) ->
|
||||
|| File <- lists:usort(auto_imports(AST)) ] ++ AST,
|
||||
expand_includes(AST1, Included, [], Opts).
|
||||
|
||||
expand_includes([], Included, Acc, Opts) ->
|
||||
case lists:member(keep_included, Opts) of
|
||||
false ->
|
||||
{ok, lists:reverse(Acc)};
|
||||
true ->
|
||||
{ok, {lists:reverse(Acc), Included}}
|
||||
end;
|
||||
expand_includes([], _Included, Acc, _Opts) ->
|
||||
{ok, lists:reverse(Acc)};
|
||||
expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Opts) ->
|
||||
case get_include_code(File, Ann, Opts) of
|
||||
{ok, Code} ->
|
||||
@@ -645,39 +607,16 @@ read_file(File, Opts) ->
|
||||
case maps:get(binary_to_list(File), Files, not_found) of
|
||||
not_found -> {error, not_found};
|
||||
Src -> {ok, Src}
|
||||
end;
|
||||
escript ->
|
||||
try
|
||||
Escript = escript:script_name(),
|
||||
{ok, Sections} = escript:extract(Escript, []),
|
||||
Archive = proplists:get_value(archive, Sections),
|
||||
FileName = binary_to_list(filename:join([aesophia, priv, stdlib, File])),
|
||||
case zip:extract(Archive, [{file_list, [FileName]}, memory]) of
|
||||
{ok, [{_, Src}]} -> {ok, Src};
|
||||
_ -> {error, not_found}
|
||||
end
|
||||
catch _:_ ->
|
||||
{error, not_found}
|
||||
end
|
||||
end.
|
||||
|
||||
stdlib_options() ->
|
||||
StdLibDir = aeso_stdlib:stdlib_include_path(),
|
||||
case filelib:is_dir(StdLibDir) of
|
||||
true -> [{include, {file_system, [StdLibDir]}}];
|
||||
false -> [{include, escript}]
|
||||
end.
|
||||
[{include, {file_system, [aeso_stdlib:stdlib_include_path()]}}].
|
||||
|
||||
get_include_code(File, Ann, Opts) ->
|
||||
case {read_file(File, Opts), read_file(File, stdlib_options())} of
|
||||
{{ok, Bin}, {ok, _}} ->
|
||||
case filename:basename(File) == File of
|
||||
true -> { error
|
||||
, fail( ann_pos(Ann)
|
||||
, "Illegal redefinition of standard library " ++ binary_to_list(File))};
|
||||
%% If a path is provided then the stdlib takes lower priority
|
||||
false -> {ok, binary_to_list(Bin)}
|
||||
end;
|
||||
{{ok, _}, {ok,_ }} ->
|
||||
fail(ann_pos(Ann), "Illegal redefinition of standard library " ++ File);
|
||||
{_, {ok, Bin}} ->
|
||||
{ok, binary_to_list(Bin)};
|
||||
{{ok, Bin}, _} ->
|
||||
|
||||
+23
-50
@@ -145,30 +145,22 @@ decl(D, Options) ->
|
||||
with_options(Options, fun() -> decl(D) end).
|
||||
|
||||
-spec decl(aeso_syntax:decl()) -> doc().
|
||||
decl({contract, Attrs, C, Ds}) ->
|
||||
Mod = fun({Mod, true}) when Mod == payable ->
|
||||
text(atom_to_list(Mod));
|
||||
(_) -> empty() end,
|
||||
block(follow( hsep(lists:map(Mod, Attrs) ++ [text("contract")])
|
||||
, hsep(name(C), text("="))), decls(Ds));
|
||||
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({pragma, _, Pragma}) -> pragma(Pragma);
|
||||
decl({type_decl, _, T, Vars}) -> typedecl(alias_t, T, Vars);
|
||||
decl({type_def, _, T, Vars, Def}) ->
|
||||
Kind = element(1, Def),
|
||||
equals(typedecl(Kind, T, Vars), typedef(Def));
|
||||
decl({fun_decl, Ann, F, T}) ->
|
||||
Mod = fun({Mod, true}) when Mod == private; Mod == stateful; Mod == payable ->
|
||||
text(atom_to_list(Mod));
|
||||
(_) -> empty() end,
|
||||
Fun = case aeso_syntax:get_ann(entrypoint, Ann, false) of
|
||||
true -> text("entrypoint");
|
||||
false -> text("function")
|
||||
end,
|
||||
hsep(lists:map(Mod, Ann) ++ [Fun, typed(name(F), T)]);
|
||||
hsep(Fun, typed(name(F), T));
|
||||
decl(D = {letfun, Attrs, _, _, _, _}) ->
|
||||
Mod = fun({Mod, true}) when Mod == private; Mod == stateful; Mod == payable ->
|
||||
Mod = fun({Mod, true}) when Mod == private; Mod == stateful ->
|
||||
text(atom_to_list(Mod));
|
||||
(_) -> empty() end,
|
||||
Fun = case aeso_syntax:get_ann(entrypoint, Attrs, false) of
|
||||
@@ -176,15 +168,7 @@ decl(D = {letfun, Attrs, _, _, _, _}) ->
|
||||
false -> "function"
|
||||
end,
|
||||
hsep(lists:map(Mod, Attrs) ++ [letdecl(Fun, D)]);
|
||||
decl({fun_clauses, Ann, Name, Type, Clauses}) ->
|
||||
above([ decl(D) || D <- [{fun_decl, Ann, Name, Type} | Clauses] ]);
|
||||
decl(D = {letval, _, _, _}) -> letdecl("let", D);
|
||||
decl({block, _, Ds}) ->
|
||||
above([ decl(D) || D <- Ds ]).
|
||||
|
||||
-spec pragma(aeso_syntax:pragma()) -> doc().
|
||||
pragma({compiler, Op, Ver}) ->
|
||||
text("@compiler " ++ atom_to_list(Op) ++ " " ++ string:join([integer_to_list(N) || N <- Ver], ".")).
|
||||
decl(D = {letval, _, _, _, _}) -> letdecl("let", D).
|
||||
|
||||
-spec expr(aeso_syntax:expr(), options()) -> doc().
|
||||
expr(E, Options) ->
|
||||
@@ -204,10 +188,10 @@ name({tvar, _, Name}) -> text(Name);
|
||||
name({typed, _, Name, _}) -> name(Name).
|
||||
|
||||
-spec letdecl(string(), aeso_syntax:letbind()) -> doc().
|
||||
letdecl(Let, {letval, _, P, E}) ->
|
||||
block_expr(0, hsep([text(Let), expr(P), text("=")]), E);
|
||||
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), expr({tuple, [], Args})), T), text("=")]), E).
|
||||
block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E).
|
||||
|
||||
-spec args([aeso_syntax:arg()]) -> doc().
|
||||
args(Args) ->
|
||||
@@ -264,8 +248,6 @@ type({args_t, _, Args}) ->
|
||||
type({bytes_t, _, any}) -> text("bytes(_)");
|
||||
type({bytes_t, _, Len}) ->
|
||||
text(lists:concat(["bytes(", Len, ")"]));
|
||||
type({if_t, _, Id, Then, Else}) ->
|
||||
beside(text("if"), args_type([Id, Then, Else]));
|
||||
type({named_arg_t, _, Name, Type, _Default}) ->
|
||||
%% Drop the default value
|
||||
%% follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
|
||||
@@ -292,9 +274,12 @@ tuple_type(Factors) ->
|
||||
, text(")")
|
||||
]).
|
||||
|
||||
-spec expr_p(integer(), aeso_syntax:arg_expr()) -> doc().
|
||||
expr_p(P, {named_arg, _, Name, E}) ->
|
||||
paren(P > 100, follow(hsep(expr(Name), text("=")), expr(E)));
|
||||
-spec arg_expr(aeso_syntax:arg_expr()) -> doc().
|
||||
arg_expr({named_arg, _, Name, E}) ->
|
||||
follow(hsep(expr(Name), text("=")), expr(E));
|
||||
arg_expr(E) -> expr(E).
|
||||
|
||||
-spec expr_p(integer(), aeso_syntax:expr()) -> doc().
|
||||
expr_p(P, {lam, _, Args, E}) ->
|
||||
paren(P > 100, follow(hsep(args(Args), text("=>")), expr_p(100, E)));
|
||||
expr_p(P, If = {'if', Ann, Cond, Then, Else}) ->
|
||||
@@ -315,8 +300,6 @@ expr_p(_, {tuple, _, Es}) ->
|
||||
tuple(lists:map(fun expr/1, Es));
|
||||
expr_p(_, {list, _, Es}) ->
|
||||
list(lists:map(fun expr/1, Es));
|
||||
expr_p(_, {list_comp, _, E, Binds}) ->
|
||||
list([follow(expr(E), hsep(text("|"), par(punctuate(text(","), lists:map(fun lc_bind/1, Binds)), 0)), 0)]);
|
||||
expr_p(_, {record, _, Fs}) ->
|
||||
record(lists:map(fun field/1, Fs));
|
||||
expr_p(_, {map, Ann, KVs}) ->
|
||||
@@ -370,19 +353,13 @@ expr_p(_, {Type, _, Bin})
|
||||
Type == oracle_query_id ->
|
||||
text(binary_to_list(aeser_api_encoder:encode(Type, Bin)));
|
||||
expr_p(_, {string, _, <<>>}) -> text("\"\"");
|
||||
expr_p(_, {string, _, S}) ->
|
||||
text(io_lib:format("\"~s\"", [binary_to_list(S)]));
|
||||
expr_p(_, {string, _, S}) -> term(binary_to_list(S));
|
||||
expr_p(_, {char, _, C}) ->
|
||||
case C of
|
||||
$' -> text("'\\''");
|
||||
$" -> text("'\"'");
|
||||
_ when C < 16#80 ->
|
||||
S = lists:flatten(io_lib:format("~p", [[C]])),
|
||||
text("'" ++ tl(lists:droplast(S)) ++ "'");
|
||||
_ ->
|
||||
S = lists:flatten(
|
||||
io_lib:format("'~ts'", [list_to_binary(aeso_scan:utf8_encode([C]))])),
|
||||
text(S)
|
||||
_ -> S = lists:flatten(io_lib:format("~p", [[C]])),
|
||||
text("'" ++ tl(lists:droplast(S)) ++ "'")
|
||||
end;
|
||||
%% -- Names
|
||||
expr_p(_, E = {id, _, _}) -> name(E);
|
||||
@@ -405,13 +382,6 @@ stmt_p({else, Else}) ->
|
||||
_ -> block_expr(200, text("else"), Else)
|
||||
end.
|
||||
|
||||
lc_bind({comprehension_bind, P, E}) ->
|
||||
follow(hsep(expr(P), text("<-")), expr(E));
|
||||
lc_bind({comprehension_if, _, E}) ->
|
||||
beside([text("if("), expr(E), text(")")]);
|
||||
lc_bind(Let) ->
|
||||
letdecl("let", Let).
|
||||
|
||||
-spec bin_prec(aeso_syntax:bin_op()) -> {integer(), integer(), integer()}.
|
||||
bin_prec('..') -> { 0, 0, 0}; %% Always printed inside '[ ]'
|
||||
bin_prec('=') -> { 0, 0, 0}; %% Always printed inside '[ ]'
|
||||
@@ -454,7 +424,7 @@ prefix(P, Op, A) ->
|
||||
app(P, F, Args) ->
|
||||
paren(P > 900,
|
||||
beside(expr_p(900, F),
|
||||
tuple(lists:map(fun expr/1, Args)))).
|
||||
tuple(lists:map(fun arg_expr/1, Args)))).
|
||||
|
||||
field({field, _, LV, E}) ->
|
||||
follow(hsep(lvalue(LV), text("=")), expr(E));
|
||||
@@ -475,7 +445,7 @@ elim1(Get={map_get, _, _}) -> elim(Get);
|
||||
elim1(Get={map_get, _, _, _}) -> elim(Get).
|
||||
|
||||
alt({'case', _, Pat, Body}) ->
|
||||
block_expr(0, hsep(expr(Pat), text("=>")), Body).
|
||||
block_expr(0, hsep(expr_p(500, Pat), text("=>")), Body).
|
||||
|
||||
block_expr(_, Header, {block, _, Ss}) ->
|
||||
block(Header, statements(Ss));
|
||||
@@ -485,7 +455,7 @@ block_expr(P, Header, E) ->
|
||||
statements(Stmts) ->
|
||||
above([ statement(S) || S <- Stmts ]).
|
||||
|
||||
statement(S = {letval, _, _, _}) -> letdecl("let", S);
|
||||
statement(S = {letval, _, _, _, _}) -> letdecl("let", S);
|
||||
statement(S = {letfun, _, _, _, _, _}) -> letdecl("let", S);
|
||||
statement(E) -> expr(E).
|
||||
|
||||
@@ -498,3 +468,6 @@ get_elifs(If = {'if', Ann, Cond, Then, Else}, Elifs) ->
|
||||
end;
|
||||
get_elifs(Else, Elifs) -> {lists:reverse(Elifs), {else, Else}}.
|
||||
|
||||
fmt(Fmt, Args) -> text(lists:flatten(io_lib:format(Fmt, Args))).
|
||||
term(X) -> fmt("~p", [X]).
|
||||
|
||||
|
||||
+40
-54
@@ -7,34 +7,27 @@
|
||||
%%%-------------------------------------------------------------------
|
||||
-module(aeso_scan).
|
||||
|
||||
-export([scan/1, utf8_encode/1]).
|
||||
-export([scan/1]).
|
||||
|
||||
-import(aeso_scan_lib, [token/1, token/2, symbol/0, skip/0,
|
||||
override/2, push/2, pop/1]).
|
||||
|
||||
lexer() ->
|
||||
Number = fun(Digit) -> [Digit, "+(_", Digit, "+)*"] end,
|
||||
DIGIT = "[0-9]",
|
||||
HEXDIGIT = "[0-9a-fA-F]",
|
||||
LOWER = "[a-z_]",
|
||||
UPPER = "[A-Z]",
|
||||
CON = [UPPER, "[a-zA-Z0-9_]*"],
|
||||
INT = Number(DIGIT),
|
||||
HEX = ["0x", Number(HEXDIGIT)],
|
||||
BYTES = ["#", Number(HEXDIGIT)],
|
||||
INT = [DIGIT, "+"],
|
||||
HEX = ["0x", HEXDIGIT, "+"],
|
||||
BYTES = ["#", HEXDIGIT, "+"],
|
||||
WS = "[\\000-\\ ]+",
|
||||
ID = [LOWER, "[a-zA-Z0-9_']*"],
|
||||
TVAR = ["'", ID],
|
||||
QID = ["(", CON, "\\.)+", ID],
|
||||
QCON = ["(", CON, "\\.)+", CON],
|
||||
OP = "[=!<>+\\-*/:&|?~@^]+",
|
||||
%% Five cases for a character
|
||||
%% * 1 7-bit ascii, not \ or '
|
||||
%% * 2-4 8-bit values (UTF8)
|
||||
%% * \ followed by a known modifier [aernrtv]
|
||||
%% * \xhh
|
||||
%% * \x{hhh...}
|
||||
CHAR = "'(([\\x00-\\x26\\x28-\\x5b\\x5d-\\x7f])|([\\x00-\\xff][\\x80-\\xff]{1,3})|(\\\\[befnrtv'\\\\])|(\\\\x[0-9a-fA-F]{2,2})|(\\\\x\\{[0-9a-fA-F]*\\}))'",
|
||||
CHAR = "'([^'\\\\]|(\\\\.))'",
|
||||
STRING = "\"([^\"\\\\]|(\\\\.))*\"",
|
||||
|
||||
CommentStart = {"/\\*", push(comment, skip())},
|
||||
@@ -44,7 +37,8 @@ lexer() ->
|
||||
, {"[^/*]+|[/*]", skip()} ],
|
||||
|
||||
Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
|
||||
"stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace"],
|
||||
"stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace",
|
||||
"return"],
|
||||
KW = string:join(Keywords, "|"),
|
||||
|
||||
Rules =
|
||||
@@ -60,7 +54,7 @@ lexer() ->
|
||||
, {CHAR, token(char, fun parse_char/1)}
|
||||
, {STRING, token(string, fun parse_string/1)}
|
||||
, {HEX, token(hex, fun parse_hex/1)}
|
||||
, {INT, token(int, fun parse_int/1)}
|
||||
, {INT, token(int, fun list_to_integer/1)}
|
||||
, {BYTES, token(bytes, fun parse_bytes/1)}
|
||||
|
||||
%% Identifiers (qualified first!)
|
||||
@@ -83,34 +77,34 @@ scan(String) ->
|
||||
%% -- Helpers ----------------------------------------------------------------
|
||||
|
||||
parse_string([$" | Chars]) ->
|
||||
unicode:characters_to_nfc_binary(unescape(Chars)).
|
||||
unescape(Chars).
|
||||
|
||||
parse_char([$' | Chars]) ->
|
||||
case unicode:characters_to_nfc_list(unescape($', Chars, [])) of
|
||||
[Char] -> Char;
|
||||
_Bad -> {error, "Bad character literal: '" ++ Chars}
|
||||
end.
|
||||
|
||||
utf8_encode(Cs) ->
|
||||
binary_to_list(unicode:characters_to_binary(Cs)).
|
||||
|
||||
unescape(Str) -> unescape($", Str, []).
|
||||
|
||||
unescape(Delim, [Delim], Acc) ->
|
||||
list_to_binary(lists:reverse(Acc));
|
||||
unescape(Delim, [$\\, $x, ${ | Chars ], Acc) ->
|
||||
{Ds, [_ | Cs]} = lists:splitwith(fun($}) -> false ; (_) -> true end, Chars),
|
||||
C = list_to_integer(Ds, 16),
|
||||
Utf8Cs = binary_to_list(unicode:characters_to_binary([C])),
|
||||
unescape(Delim, Cs, [Utf8Cs | Acc]);
|
||||
unescape(Delim, [$\\, $x, D1, D2 | Chars ], Acc) ->
|
||||
C = list_to_integer([D1, D2], 16),
|
||||
Utf8Cs = binary_to_list(unicode:characters_to_binary([C])),
|
||||
unescape(Delim, Chars, [Utf8Cs | Acc]);
|
||||
unescape(Delim, [$\\, Code | Chars], Acc) ->
|
||||
Ok = fun(C) -> unescape(Delim, Chars, [C | Acc]) end,
|
||||
parse_char([$', $\\, Code, $']) ->
|
||||
case Code of
|
||||
Delim -> Ok(Delim);
|
||||
$' -> $';
|
||||
$\\ -> $\\;
|
||||
$b -> $\b;
|
||||
$e -> $\e;
|
||||
$f -> $\f;
|
||||
$n -> $\n;
|
||||
$r -> $\r;
|
||||
$t -> $\t;
|
||||
$v -> $\v;
|
||||
_ -> {error, "Bad control sequence: \\" ++ [Code]}
|
||||
end;
|
||||
parse_char([$', C, $']) -> C.
|
||||
|
||||
unescape(Str) -> unescape(Str, []).
|
||||
|
||||
unescape([$"], Acc) ->
|
||||
list_to_binary(lists:reverse(Acc));
|
||||
unescape([$\\, $x, D1, D2 | Chars ], Acc) ->
|
||||
C = list_to_integer([D1, D2], 16),
|
||||
unescape(Chars, [C | Acc]);
|
||||
unescape([$\\, Code | Chars], Acc) ->
|
||||
Ok = fun(C) -> unescape(Chars, [C | Acc]) end,
|
||||
case Code of
|
||||
$" -> Ok($");
|
||||
$\\ -> Ok($\\);
|
||||
$b -> Ok($\b);
|
||||
$e -> Ok($\e);
|
||||
@@ -121,21 +115,13 @@ unescape(Delim, [$\\, Code | Chars], Acc) ->
|
||||
$v -> Ok($\v);
|
||||
_ -> error("Bad control sequence: \\" ++ [Code]) %% TODO
|
||||
end;
|
||||
unescape(Delim, [C | Chars], Acc) ->
|
||||
unescape(Delim, Chars, [C | Acc]).
|
||||
unescape([C | Chars], Acc) ->
|
||||
unescape(Chars, [C | Acc]).
|
||||
|
||||
strip_underscores(S) ->
|
||||
lists:filter(fun(C) -> C /= $_ end, S).
|
||||
parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
|
||||
|
||||
parse_hex("0x" ++ S) ->
|
||||
list_to_integer(strip_underscores(S), 16).
|
||||
|
||||
parse_int(S) ->
|
||||
list_to_integer(strip_underscores(S)).
|
||||
|
||||
parse_bytes("#" ++ S0) ->
|
||||
S = strip_underscores(S0),
|
||||
N = list_to_integer(S, 16),
|
||||
Digits = (length(S) + 1) div 2,
|
||||
parse_bytes("#" ++ Chars) ->
|
||||
N = list_to_integer(Chars, 16),
|
||||
Digits = (length(Chars) + 1) div 2,
|
||||
<<N:Digits/unit:8>>.
|
||||
|
||||
|
||||
+10
-25
@@ -13,7 +13,7 @@
|
||||
-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, pragma/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([ast/0]).
|
||||
@@ -36,27 +36,14 @@
|
||||
|
||||
-type decl() :: {contract, ann(), con(), [decl()]}
|
||||
| {namespace, ann(), con(), [decl()]}
|
||||
| {pragma, ann(), pragma()}
|
||||
| {type_decl, ann(), id(), [tvar()]} % Only for error msgs
|
||||
| {type_decl, ann(), id(), [tvar()]}
|
||||
| {type_def, ann(), id(), [tvar()], typedef()}
|
||||
| {fun_clauses, ann(), id(), type(), [letfun() | fundecl()]}
|
||||
| {block, ann(), [decl()]}
|
||||
| fundecl()
|
||||
| letfun()
|
||||
| letval(). % Only for error msgs
|
||||
|
||||
-type compiler_version() :: [non_neg_integer()].
|
||||
|
||||
-type pragma() :: {compiler, '==' | '<' | '>' | '=<' | '>=', compiler_version()}.
|
||||
|
||||
|
||||
-type letval() :: {letval, ann(), pat(), expr()}.
|
||||
-type letfun() :: {letfun, ann(), id(), [pat()], type(), expr()}.
|
||||
-type fundecl() :: {fun_decl, ann(), id(), type()}.
|
||||
| {fun_decl, ann(), id(), type()}
|
||||
| letbind().
|
||||
|
||||
-type letbind()
|
||||
:: letfun()
|
||||
| letval().
|
||||
:: {letval, ann(), id(), type(), expr()}
|
||||
| {letfun, ann(), id(), [arg()], type(), expr()}.
|
||||
|
||||
-type arg() :: {arg, ann(), id(), type()}.
|
||||
|
||||
@@ -108,8 +95,9 @@
|
||||
| {list, ann(), [expr()]}
|
||||
| {list_comp, ann(), expr(), [comprehension_exp()]}
|
||||
| {typed, ann(), expr(), type()}
|
||||
| {record_or_map(), ann(), [field(expr())]}
|
||||
| {record_or_map(), ann(), expr(), [field(expr())]} %% record/map update
|
||||
| {record, ann(), [field(expr())]}
|
||||
| {record, ann(), expr(), [field(expr())]} %% record update
|
||||
| {map, ann(), expr(), [field(expr())]} %% map update
|
||||
| {map, ann(), [{expr(), expr()}]}
|
||||
| {map_get, ann(), expr(), expr()}
|
||||
| {map_get, ann(), expr(), expr(), expr()}
|
||||
@@ -118,9 +106,7 @@
|
||||
| id() | qid() | con() | qcon()
|
||||
| constant().
|
||||
|
||||
-type record_or_map() :: record | map | record_or_map_error.
|
||||
|
||||
-type comprehension_exp() :: [ {comprehension_bind, pat(), expr()}
|
||||
-type comprehension_exp() :: [ {comprehension_bind, id(), expr()}
|
||||
| {comprehension_if, ann(), expr()}
|
||||
| letbind() ].
|
||||
|
||||
@@ -148,7 +134,6 @@
|
||||
-type pat() :: {app, ann(), con() | op(), [pat()]}
|
||||
| {tuple, ann(), [pat()]}
|
||||
| {list, ann(), [pat()]}
|
||||
| {typed, ann(), pat(), type()}
|
||||
| {record, ann(), [field(pat())]}
|
||||
| constant()
|
||||
| con()
|
||||
|
||||
@@ -45,11 +45,11 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
|
||||
%% 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, _, P, E} -> Scoped(BindExpr(P), Expr(E));
|
||||
{letval, _, F, T, E} -> Sum([BindExpr(F), Type(T), Expr(E)]);
|
||||
{letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ [E])]);
|
||||
{fun_clauses, _, _, T, Cs} -> Sum([Type(T) | [Decl(C) || C <- Cs]]);
|
||||
%% typedef()
|
||||
{alias_t, T} -> Type(T);
|
||||
{record_t, Fs} -> Type(Fs);
|
||||
@@ -76,8 +76,8 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
|
||||
Plus(Expr(E), Scoped(BindExpr(I), Expr({list_comp, A, Y, R})));
|
||||
{list_comp, A, Y, [{comprehension_if, _, E}|R]} ->
|
||||
Plus(Expr(E), Expr({list_comp, A, Y, R}));
|
||||
{list_comp, A, Y, [D = {letval, _, Pat, _} | R]} ->
|
||||
Plus(Decl(D), Scoped(BindExpr(Pat), Expr({list_comp, A, Y, R})));
|
||||
{list_comp, A, Y, [D = {letval, _, F, _, _} | R]} ->
|
||||
Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
|
||||
{list_comp, A, Y, [D = {letfun, _, F, _, _, _} | R]} ->
|
||||
Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
|
||||
{typed, _, E, T} -> Plus(Expr(E), Type(T));
|
||||
|
||||
+5
-29
@@ -18,14 +18,9 @@ from_aevm(word, {id, _, "address"}, N) -> address_literal(ac
|
||||
from_aevm(word, {app_t, _, {id, _, "oracle"}, _}, N) -> address_literal(oracle_pubkey, N);
|
||||
from_aevm(word, {app_t, _, {id, _, "oracle_query"}, _}, N) -> address_literal(oracle_query_id, N);
|
||||
from_aevm(word, {con, _, _Name}, N) -> address_literal(contract_pubkey, N);
|
||||
from_aevm(word, {id, _, "int"}, N0) ->
|
||||
<<N:256/signed>> = <<N0:256>>,
|
||||
if N < 0 -> {app, [{format, prefix}], {'-', []}, [{int, [], -N}]};
|
||||
true -> {int, [], N} end;
|
||||
from_aevm(word, {id, _, "bits"}, N0) ->
|
||||
<<N:256/signed>> = <<N0:256>>,
|
||||
make_bits(N);
|
||||
from_aevm(word, {id, _, "bool"}, N) -> {bool, [], N /= 0};
|
||||
from_aevm(word, {id, _, "int"}, N) -> <<N1:256/signed>> = <<N:256>>, {int, [], N1};
|
||||
from_aevm(word, {id, _, "bits"}, N) -> error({todo, bits, N});
|
||||
from_aevm(word, {id, _, "bool"}, N) -> {bool, [], N /= 0};
|
||||
from_aevm(word, {bytes_t, _, Len}, Val) when Len =< 32 ->
|
||||
<<Bytes:Len/unit:8, _/binary>> = <<Val:32/unit:8>>,
|
||||
{bytes, [], <<Bytes:Len/unit:8>>};
|
||||
@@ -60,7 +55,6 @@ from_aevm({variant, VmCons}, {variant_t, Cons}, {variant, Tag, Args})
|
||||
VmTypes = lists:nth(Tag + 1, VmCons),
|
||||
ConType = lists:nth(Tag + 1, Cons),
|
||||
from_aevm(VmTypes, ConType, Args);
|
||||
from_aevm([], {constr_t, _, Con, []}, []) -> Con;
|
||||
from_aevm(VmTypes, {constr_t, _, Con, Types}, Args)
|
||||
when length(VmTypes) == length(Types),
|
||||
length(VmTypes) == length(Args) ->
|
||||
@@ -76,10 +70,8 @@ from_fate({app_t, _, {id, _, "oracle"}, _}, ?FATE_ORACLE(Bin)) -> {oracle_pubkey
|
||||
from_fate({app_t, _, {id, _, "oracle_query"}, _}, ?FATE_ORACLE_Q(Bin)) -> {oracle_query_id, [], Bin};
|
||||
from_fate({con, _, _Name}, ?FATE_CONTRACT(Bin)) -> {contract_pubkey, [], Bin};
|
||||
from_fate({bytes_t, _, N}, ?FATE_BYTES(Bin)) when byte_size(Bin) == N -> {bytes, [], Bin};
|
||||
from_fate({id, _, "bits"}, ?FATE_BITS(N)) -> make_bits(N);
|
||||
from_fate({id, _, "int"}, N) when is_integer(N) ->
|
||||
if N < 0 -> {app, [{format, prefix}], {'-', []}, [{int, [], -N}]};
|
||||
true -> {int, [], N} end;
|
||||
from_fate({id, _, "bits"}, ?FATE_BITS(Bin)) -> error({todo, bits, Bin});
|
||||
from_fate({id, _, "int"}, N) when is_integer(N) -> {int, [], N};
|
||||
from_fate({id, _, "bool"}, B) when is_boolean(B) -> {bool, [], B};
|
||||
from_fate({id, _, "string"}, S) when is_binary(S) -> {string, [], S};
|
||||
from_fate({app_t, _, {id, _, "list"}, [Type]}, List) when is_list(List) ->
|
||||
@@ -95,8 +87,6 @@ from_fate({tuple_t, _, Types}, ?FATE_TUPLE(Val))
|
||||
when length(Types) == tuple_size(Val) ->
|
||||
{tuple, [], [from_fate(Type, X)
|
||||
|| {Type, X} <- lists:zip(Types, tuple_to_list(Val))]};
|
||||
from_fate({record_t, [{field_t, _, FName, FType}]}, Val) ->
|
||||
{record, [], [{field, [], [{proj, [], FName}], from_fate(FType, Val)}]};
|
||||
from_fate({record_t, Fields}, ?FATE_TUPLE(Val))
|
||||
when length(Fields) == tuple_size(Val) ->
|
||||
{record, [], [ {field, [], [{proj, [], FName}], from_fate(FType, X)}
|
||||
@@ -115,23 +105,9 @@ from_fate({variant_t, Cons}, {variant, Ar, Tag, Args})
|
||||
from_fate(ConType, ArgList);
|
||||
_ -> throw(cannot_translate_to_sophia)
|
||||
end;
|
||||
from_fate({constr_t, _, Con, []}, []) -> Con;
|
||||
from_fate({constr_t, _, Con, Types}, Args)
|
||||
when length(Types) == length(Args) ->
|
||||
{app, [], Con, [ from_fate(Type, Arg)
|
||||
|| {Type, Arg} <- lists:zip(Types, Args) ]};
|
||||
from_fate(_Type, _Data) ->
|
||||
throw(cannot_translate_to_sophia).
|
||||
|
||||
|
||||
make_bits(N) ->
|
||||
Id = fun(F) -> {qid, [], ["Bits", F]} end,
|
||||
if N < 0 -> make_bits(Id("clear"), Id("all"), 0, bnot N);
|
||||
true -> make_bits(Id("set"), Id("none"), 0, N) end.
|
||||
|
||||
make_bits(_Set, Zero, _I, 0) -> Zero;
|
||||
make_bits(Set, Zero, I, N) when 0 == N rem 2 ->
|
||||
make_bits(Set, Zero, I + 1, N div 2);
|
||||
make_bits(Set, Zero, I, N) ->
|
||||
{app, [], Set, [make_bits(Set, Zero, I + 1, N div 2), {int, [], I}]}.
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{application, aesophia,
|
||||
[{description, "Contract Language for aeternity"},
|
||||
{vsn, "4.3.0"},
|
||||
{vsn, "4.0.0-rc4"},
|
||||
{registered, []},
|
||||
{applications,
|
||||
[kernel,
|
||||
|
||||
@@ -62,7 +62,7 @@ encode_decode_sophia_test() ->
|
||||
Other -> Other
|
||||
end end,
|
||||
ok = Check("int", "42"),
|
||||
ok = Check("int", "- 42"),
|
||||
ok = Check("int", "-42"),
|
||||
ok = Check("bool", "true"),
|
||||
ok = Check("bool", "false"),
|
||||
ok = Check("string", "\"Hello\""),
|
||||
|
||||
+11
-18
@@ -11,10 +11,7 @@ test_contract(N) ->
|
||||
{Contract,MapACI,DecACI} = test_cases(N),
|
||||
{ok,JSON} = aeso_aci:contract_interface(json, Contract),
|
||||
?assertEqual([MapACI], JSON),
|
||||
?assertEqual({ok, DecACI}, aeso_aci:render_aci_json(JSON)),
|
||||
%% Check if the compiler provides correct aci
|
||||
{ok,#{aci := JSON2}} = aeso_compiler:from_string(Contract, [{aci, json}]),
|
||||
?assertEqual(JSON, JSON2).
|
||||
?assertEqual({ok, DecACI}, aeso_aci:render_aci_json(JSON)).
|
||||
|
||||
test_cases(1) ->
|
||||
Contract = <<"payable contract C =\n"
|
||||
@@ -83,11 +80,11 @@ test_cases(3) ->
|
||||
DecACI = <<"contract C =\n"
|
||||
" type state = unit\n"
|
||||
" datatype event = SingleEventDefined\n"
|
||||
" datatype bert('a) = Bin('a)\n"
|
||||
" entrypoint a : (C.bert(string)) => int\n">>,
|
||||
" datatype bert('a) = Bin('a)\n"
|
||||
" entrypoint a : (C.bert(string)) => int\n">>,
|
||||
{Contract,MapACI,DecACI}.
|
||||
|
||||
%% Roundtrip
|
||||
%% Rounttrip
|
||||
aci_test_() ->
|
||||
[{"Testing ACI generation for " ++ ContractName,
|
||||
fun() -> aci_test_contract(ContractName) end}
|
||||
@@ -97,13 +94,8 @@ all_contracts() -> aeso_compiler_tests:compilable_contracts().
|
||||
|
||||
aci_test_contract(Name) ->
|
||||
String = aeso_test_utils:read_contract(Name),
|
||||
Opts = case lists:member(Name, aeso_compiler_tests:debug_mode_contracts()) of
|
||||
true -> [debug_mode];
|
||||
false -> []
|
||||
end ++ [{include, {file_system, [aeso_test_utils:contract_path()]}}],
|
||||
Opts = [{include, {file_system, [aeso_test_utils:contract_path()]}}],
|
||||
{ok, JSON} = aeso_aci:contract_interface(json, String, Opts),
|
||||
{ok, #{aci := JSON1}} = aeso_compiler:from_string(String, [{aci, json}, {backend, fate} | Opts]),
|
||||
?assertEqual(JSON, JSON1),
|
||||
|
||||
io:format("JSON:\n~p\n", [JSON]),
|
||||
{ok, ContractStub} = aeso_aci:render_aci_json(JSON),
|
||||
@@ -114,7 +106,7 @@ aci_test_contract(Name) ->
|
||||
ok.
|
||||
|
||||
check_stub(Stub, Options) ->
|
||||
try aeso_parser:string(binary_to_list(Stub), Options) of
|
||||
case aeso_parser:string(binary_to_list(Stub), Options) of
|
||||
Ast ->
|
||||
try
|
||||
%% io:format("AST: ~120p\n", [Ast]),
|
||||
@@ -125,8 +117,9 @@ check_stub(Stub, Options) ->
|
||||
_:R ->
|
||||
io:format("Error: ~p\n", [R]),
|
||||
error(R)
|
||||
end
|
||||
catch throw:{error, Errs} ->
|
||||
_ = [ io:format("~s\n", [aeso_errors:pp(E)]) || E <- Errs ],
|
||||
error({parse_errors, Errs})
|
||||
end;
|
||||
{error, E} ->
|
||||
io:format("Error: ~p\n", [E]),
|
||||
error({parse_error, E})
|
||||
end.
|
||||
|
||||
|
||||
@@ -29,10 +29,11 @@ calldata_test_() ->
|
||||
true -> ast_exprs(ContractString, Fun, Args, [{backend, fate}]);
|
||||
false -> undefined
|
||||
end,
|
||||
ParsedExprs = parse_args(Fun, Args),
|
||||
[ ?assertEqual(ParsedExprs, AevmExprs) || AevmExprs /= undefined ],
|
||||
[ ?assertEqual(ParsedExprs, FateExprs) || FateExprs /= undefined ],
|
||||
ok
|
||||
case FateExprs == undefined orelse AevmExprs == undefined of
|
||||
true -> ok;
|
||||
false ->
|
||||
?assertEqual(FateExprs, AevmExprs)
|
||||
end
|
||||
end} || {ContractName, Fun, Args} <- compilable_contracts()].
|
||||
|
||||
calldata_aci_test_() ->
|
||||
@@ -52,34 +53,19 @@ calldata_aci_test_() ->
|
||||
true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]);
|
||||
false -> undefined
|
||||
end,
|
||||
ParsedExprs = parse_args(Fun, Args),
|
||||
[ ?assertEqual(ParsedExprs, AevmExprs) || AevmExprs /= undefined ],
|
||||
[ ?assertEqual(ParsedExprs, FateExprs) || FateExprs /= undefined ],
|
||||
ok
|
||||
case FateExprs == undefined orelse AevmExprs == undefined of
|
||||
true -> ok;
|
||||
false ->
|
||||
?assertEqual(FateExprs, AevmExprs)
|
||||
end
|
||||
end} || {ContractName, Fun, Args} <- compilable_contracts()].
|
||||
|
||||
parse_args(Fun, Args) ->
|
||||
[{contract, _, _, [{letfun, _, _, _, _, {app, _, _, AST}}]}] =
|
||||
aeso_parser:string("contract Temp = function foo() = " ++ Fun ++ "(" ++ string:join(Args, ", ") ++ ")"),
|
||||
strip_ann(AST).
|
||||
|
||||
strip_ann(T) when is_tuple(T) ->
|
||||
strip_ann1(setelement(2, T, []));
|
||||
strip_ann(X) -> strip_ann1(X).
|
||||
|
||||
strip_ann1({map, [], KVs}) ->
|
||||
{map, [], [{strip_ann(K), strip_ann(V)} || {K, V} <- KVs]};
|
||||
strip_ann1(T) when is_tuple(T) ->
|
||||
list_to_tuple(strip_ann1(tuple_to_list(T)));
|
||||
strip_ann1(L) when is_list(L) ->
|
||||
lists:map(fun strip_ann/1, L);
|
||||
strip_ann1(X) -> X.
|
||||
|
||||
ast_exprs(ContractString, Fun, Args, Opts) ->
|
||||
{ok, Data} = (catch aeso_compiler:create_calldata(ContractString, Fun, Args, Opts)),
|
||||
{ok, _Types, Exprs} = (catch aeso_compiler:decode_calldata(ContractString, Fun, Data, Opts)),
|
||||
?assert(is_list(Exprs)),
|
||||
strip_ann(Exprs).
|
||||
Exprs.
|
||||
|
||||
check_errors(Expect, ErrorString) ->
|
||||
%% This removes the final single \n as well.
|
||||
@@ -99,9 +85,7 @@ compilable_contracts() ->
|
||||
{"maps", "init", []},
|
||||
{"funargs", "menot", ["false"]},
|
||||
{"funargs", "append", ["[\"false\", \" is\", \" not\", \" true\"]"]},
|
||||
{"funargs", "bitsum", ["Bits.all"]},
|
||||
{"funargs", "bitsum", ["Bits.clear(Bits.clear(Bits.all, 4), 2)"]}, %% Order matters for test
|
||||
{"funargs", "bitsum", ["Bits.set(Bits.set(Bits.none, 4), 2)"]},
|
||||
%% TODO {"funargs", "bitsum", ["Bits.all"]},
|
||||
{"funargs", "read", ["{label = \"question 1\", result = 4}"]},
|
||||
{"funargs", "sjutton", ["#0011012003100011012003100011012003"]},
|
||||
{"funargs", "sextiosju", ["#01020304050607080910111213141516171819202122232425262728293031323334353637383940"
|
||||
@@ -113,7 +97,6 @@ compilable_contracts() ->
|
||||
{"funargs", "traffic_light", ["Pantone(12)"]},
|
||||
{"funargs", "tuples", ["()"]},
|
||||
%% TODO {"funargs", "due", ["FixedTTL(1020)"]},
|
||||
{"funargs", "singleton_rec", ["{x = 1000}"]},
|
||||
{"variant_types", "init", []},
|
||||
{"basic_auth", "init", []},
|
||||
{"address_literals", "init", []},
|
||||
@@ -143,4 +126,4 @@ compilable_contracts() ->
|
||||
not_yet_compilable(fate) ->
|
||||
[];
|
||||
not_yet_compilable(aevm) ->
|
||||
["funargs", "strings"].
|
||||
[].
|
||||
|
||||
+88
-301
@@ -12,14 +12,6 @@
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
run_test(Test) ->
|
||||
TestFun = list_to_atom(lists:concat([Test, "_test_"])),
|
||||
[ begin
|
||||
io:format("~s\n", [Label]),
|
||||
Fun()
|
||||
end || {Label, Fun} <- ?MODULE:TestFun() ],
|
||||
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.
|
||||
@@ -39,7 +31,7 @@ simple_compile_test_() ->
|
||||
error(ErrBin)
|
||||
end
|
||||
end} || ContractName <- compilable_contracts(), Backend <- [aevm, fate],
|
||||
not lists:member(ContractName, not_compilable_on(Backend))] ++
|
||||
not lists:member(ContractName, not_yet_compilable(Backend))] ++
|
||||
[ {"Test file not found error",
|
||||
fun() ->
|
||||
{error, Errors} = aeso_compiler:file("does_not_exist.aes"),
|
||||
@@ -110,15 +102,7 @@ compile(Backend, Name) ->
|
||||
|
||||
compile(Backend, Name, Options) ->
|
||||
String = aeso_test_utils:read_contract(Name),
|
||||
Options1 =
|
||||
case lists:member(Name, debug_mode_contracts()) of
|
||||
true -> [debug_mode];
|
||||
false -> []
|
||||
end ++
|
||||
[ {src_file, Name ++ ".aes"}, {backend, Backend}
|
||||
, {include, {file_system, [aeso_test_utils:contract_path()]}}
|
||||
] ++ Options,
|
||||
case aeso_compiler:from_string(String, Options1) of
|
||||
case aeso_compiler:from_string(String, [{src_file, Name ++ ".aes"}, {backend, Backend} | Options]) of
|
||||
{ok, Map} -> Map;
|
||||
{error, ErrorString} when is_binary(ErrorString) -> ErrorString;
|
||||
{error, Errors} -> Errors
|
||||
@@ -146,7 +130,6 @@ compilable_contracts() ->
|
||||
"test",
|
||||
"builtin_bug",
|
||||
"builtin_map_get_bug",
|
||||
"lc_record_bug",
|
||||
"nodeadcode",
|
||||
"deadcode",
|
||||
"variant_types",
|
||||
@@ -154,7 +137,6 @@ compilable_contracts() ->
|
||||
"events",
|
||||
"include",
|
||||
"basic_auth",
|
||||
"basic_auth_tx",
|
||||
"bitcoin_auth",
|
||||
"address_literals",
|
||||
"bytes_equality",
|
||||
@@ -163,7 +145,6 @@ compilable_contracts() ->
|
||||
"bytes_to_x",
|
||||
"bytes_concat",
|
||||
"aens",
|
||||
"aens_update",
|
||||
"tuple_match",
|
||||
"cyclic_include",
|
||||
"stdlib_include",
|
||||
@@ -171,28 +152,11 @@ compilable_contracts() ->
|
||||
"manual_stdlib_include",
|
||||
"list_comp",
|
||||
"payable",
|
||||
"unapplied_builtins",
|
||||
"underscore_number_literals",
|
||||
"pairing_crypto",
|
||||
"qualified_constructor",
|
||||
"let_patterns",
|
||||
"lhs_matching",
|
||||
"more_strings",
|
||||
"protected_call",
|
||||
"hermetization_turnoff"
|
||||
"unapplied_builtins"
|
||||
].
|
||||
|
||||
not_compilable_on(fate) -> [];
|
||||
not_compilable_on(aevm) ->
|
||||
[ "stdlib_include", "manual_stdlib_include", "pairing_crypto"
|
||||
, "aens_update", "basic_auth_tx", "more_strings"
|
||||
, "unapplied_builtins", "bytes_to_x", "state_handling", "protected_call"
|
||||
, "hermetization_turnoff"
|
||||
|
||||
].
|
||||
|
||||
debug_mode_contracts() ->
|
||||
["hermetization_turnoff"].
|
||||
not_yet_compilable(fate) -> [];
|
||||
not_yet_compilable(aevm) -> [].
|
||||
|
||||
%% Contracts that should produce type errors
|
||||
|
||||
@@ -211,8 +175,6 @@ debug_mode_contracts() ->
|
||||
-define(PARSE_ERROR(Name, Errs), ?ERROR("Parse", Name, Errs)).
|
||||
|
||||
failing_contracts() ->
|
||||
{ok, V} = aeso_compiler:numeric_version(),
|
||||
Version = list_to_binary(string:join([integer_to_list(N) || N <- V], ".")),
|
||||
%% Parse errors
|
||||
[ ?PARSE_ERROR(field_parse_error,
|
||||
[<<?Pos(5, 26)
|
||||
@@ -323,22 +285,9 @@ failing_contracts() ->
|
||||
"Repeated name x in pattern\n"
|
||||
" x :: x (at line 26, column 7)">>,
|
||||
<<?Pos(44, 14)
|
||||
"Repeated names x, y in pattern\n"
|
||||
" (x : int, y, x : string, y : bool) (at line 44, column 14)">>,
|
||||
<<?Pos(44, 39)
|
||||
"Cannot unify int\n"
|
||||
" and string\n"
|
||||
"when checking the type of the expression at line 44, column 39\n"
|
||||
" x : int\n"
|
||||
"against the expected type\n"
|
||||
" string">>,
|
||||
<<?Pos(44, 72)
|
||||
"Cannot unify int\n"
|
||||
" and string\n"
|
||||
"when checking the type of the expression at line 44, column 72\n"
|
||||
" x : int\n"
|
||||
"against the expected type\n"
|
||||
" string">>,
|
||||
"Repeated argument x to function repeated_arg (at line 44, column 14).">>,
|
||||
<<?Pos(44, 14)
|
||||
"Repeated argument y to function repeated_arg (at line 44, column 14).">>,
|
||||
<<?Pos(14, 24)
|
||||
"No record type with fields y, z (at line 14, column 24)">>,
|
||||
<<?Pos(15, 26)
|
||||
@@ -394,21 +343,83 @@ failing_contracts() ->
|
||||
[<<?Pos(12, 42)
|
||||
"Cannot unify int\n"
|
||||
" and string\n"
|
||||
"when checking the type of the expression at line 12, column 42\n"
|
||||
" r.foo() : map(int, string)\n"
|
||||
"when checking the record projection at line 12, column 42\n"
|
||||
" r.foo : (gas : int, value : int) => Remote.themap\n"
|
||||
"against the expected type\n"
|
||||
" map(string, int)">>])
|
||||
, ?TYPE_ERROR(not_toplevel_include,
|
||||
[<<?Pos(2, 11)
|
||||
"Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>])
|
||||
, ?TYPE_ERROR(not_toplevel_namespace,
|
||||
[<<?Pos(2, 13)
|
||||
"Nested namespaces are not allowed\nNamespace 'Foo' at line 2, column 13 not defined at top level.">>])
|
||||
, ?TYPE_ERROR(not_toplevel_contract,
|
||||
[<<?Pos(2, 12)
|
||||
"Nested contracts are not allowed\nContract 'Con' at line 2, column 12 not defined at top level.">>])
|
||||
" (gas : int, value : int) => map(string, int)">>])
|
||||
, ?TYPE_ERROR(bad_include_and_ns,
|
||||
[<<?Pos(2, 11)
|
||||
"Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
|
||||
<<?Pos(3, 13)
|
||||
"Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>])
|
||||
, ?TYPE_ERROR(bad_address_literals,
|
||||
[<<?Pos(11, 5)
|
||||
[<<?Pos(32, 5)
|
||||
"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)">>,
|
||||
<<?Pos(30, 5)
|
||||
"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)">>,
|
||||
<<?Pos(28, 5)
|
||||
"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">>,
|
||||
<<?Pos(25, 5)
|
||||
"Cannot unify oracle_query('a, 'b)\n"
|
||||
" and Remote\n"
|
||||
"when checking the type of the expression at line 25, column 5\n"
|
||||
" oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
|
||||
" oracle_query('a, 'b)\n"
|
||||
"against the expected type\n"
|
||||
" Remote">>,
|
||||
<<?Pos(23, 5)
|
||||
"Cannot unify oracle_query('c, 'd)\n"
|
||||
" and bytes(32)\n"
|
||||
"when checking the type of the expression at line 23, column 5\n"
|
||||
" oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
|
||||
" oracle_query('c, 'd)\n"
|
||||
"against the expected type\n"
|
||||
" bytes(32)">>,
|
||||
<<?Pos(21, 5)
|
||||
"Cannot unify oracle_query('e, 'f)\n"
|
||||
" and oracle(int, bool)\n"
|
||||
"when checking the type of the expression at line 21, column 5\n"
|
||||
" oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
|
||||
" oracle_query('e, 'f)\n"
|
||||
"against the expected type\n"
|
||||
" oracle(int, bool)">>,
|
||||
<<?Pos(18, 5)
|
||||
"Cannot unify oracle('g, 'h)\n"
|
||||
" and Remote\n"
|
||||
"when checking the type of the expression at line 18, column 5\n"
|
||||
" ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
|
||||
" oracle('g, 'h)\n"
|
||||
"against the expected type\n"
|
||||
" Remote">>,
|
||||
<<?Pos(16, 5)
|
||||
"Cannot unify oracle('i, 'j)\n"
|
||||
" and bytes(32)\n"
|
||||
"when checking the type of the expression at line 16, column 5\n"
|
||||
" ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
|
||||
" oracle('i, 'j)\n"
|
||||
"against the expected type\n"
|
||||
" bytes(32)">>,
|
||||
<<?Pos(14, 5)
|
||||
"Cannot unify oracle('k, 'l)\n"
|
||||
" and oracle_query(int, bool)\n"
|
||||
"when checking the type of the expression at line 14, column 5\n"
|
||||
" ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
|
||||
" oracle('k, 'l)\n"
|
||||
"against the expected type\n"
|
||||
" oracle_query(int, bool)">>,
|
||||
<<?Pos(11, 5)
|
||||
"Cannot unify address\n"
|
||||
" and oracle(int, bool)\n"
|
||||
"when checking the type of the expression at line 11, column 5\n"
|
||||
@@ -428,79 +439,7 @@ failing_contracts() ->
|
||||
"when checking the type of the expression at line 7, column 5\n"
|
||||
" ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
|
||||
"against the expected type\n"
|
||||
" bytes(32)">>,
|
||||
<<?Pos(14, 5)
|
||||
"Cannot unify oracle('a, 'b)\n"
|
||||
" and oracle_query(int, bool)\n"
|
||||
"when checking the type of the expression at line 14, column 5\n"
|
||||
" ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
|
||||
" oracle('a, 'b)\n"
|
||||
"against the expected type\n"
|
||||
" oracle_query(int, bool)">>,
|
||||
<<?Pos(16, 5)
|
||||
"Cannot unify oracle('c, 'd)\n"
|
||||
" and bytes(32)\n"
|
||||
"when checking the type of the expression at line 16, column 5\n"
|
||||
" ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
|
||||
" oracle('c, 'd)\n"
|
||||
"against the expected type\n"
|
||||
" bytes(32)">>,
|
||||
<<?Pos(18, 5)
|
||||
"Cannot unify oracle('e, 'f)\n"
|
||||
" and Remote\n"
|
||||
"when checking the type of the expression at line 18, column 5\n"
|
||||
" ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
|
||||
" oracle('e, 'f)\n"
|
||||
"against the expected type\n"
|
||||
" Remote">>,
|
||||
<<?Pos(21, 5)
|
||||
"Cannot unify oracle_query('g, 'h)\n"
|
||||
" and oracle(int, bool)\n"
|
||||
"when checking the type of the expression at line 21, column 5\n"
|
||||
" oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
|
||||
" oracle_query('g, 'h)\n"
|
||||
"against the expected type\n"
|
||||
" oracle(int, bool)">>,
|
||||
<<?Pos(23, 5)
|
||||
"Cannot unify oracle_query('i, 'j)\n"
|
||||
" and bytes(32)\n"
|
||||
"when checking the type of the expression at line 23, column 5\n"
|
||||
" oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
|
||||
" oracle_query('i, 'j)\n"
|
||||
"against the expected type\n"
|
||||
" bytes(32)">>,
|
||||
<<?Pos(25, 5)
|
||||
"Cannot unify oracle_query('k, 'l)\n"
|
||||
" and Remote\n"
|
||||
"when checking the type of the expression at line 25, column 5\n"
|
||||
" oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
|
||||
" oracle_query('k, 'l)\n"
|
||||
"against the expected type\n"
|
||||
" Remote">>,
|
||||
<<?Pos(28, 5)
|
||||
"The type address is not a contract type\n"
|
||||
"when checking that the contract literal\n"
|
||||
" ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
|
||||
"has the type\n"
|
||||
" address">>,
|
||||
<<?Pos(30, 5)
|
||||
"The type oracle(int, bool) is not a contract type\n"
|
||||
"when checking that the contract literal\n"
|
||||
" ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
|
||||
"has the type\n"
|
||||
" oracle(int, bool)">>,
|
||||
<<?Pos(32, 5)
|
||||
"The type bytes(32) is not a contract type\n"
|
||||
"when checking that the contract literal\n"
|
||||
" ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
|
||||
"has the type\n"
|
||||
" bytes(32)">>,
|
||||
<<?Pos(34, 5),
|
||||
"The type address is not a contract type\n"
|
||||
"when checking that the call to\n"
|
||||
" Address.to_contract\n"
|
||||
"has the type\n"
|
||||
" address">>])
|
||||
" bytes(32)">>])
|
||||
, ?TYPE_ERROR(stateful,
|
||||
[<<?Pos(13, 35)
|
||||
"Cannot reference stateful function Chain.spend (at line 13, column 35)\nin the definition of non-stateful function fail1.">>,
|
||||
@@ -562,15 +501,11 @@ failing_contracts() ->
|
||||
"Cannot unify int\n and string\nwhen checking the type of the pattern at line 2, column 53\n x : int\nagainst the expected type\n string">>
|
||||
])
|
||||
, ?TYPE_ERROR(map_as_map_key,
|
||||
[<<?Pos(5, 47)
|
||||
[<<?Pos(5, 25)
|
||||
"Invalid key type\n"
|
||||
" map(int, int)\n"
|
||||
"Map keys cannot contain other maps.">>,
|
||||
<<?Pos(6, 31)
|
||||
"Invalid key type\n"
|
||||
" list(map(int, int))\n"
|
||||
"Map keys cannot contain other maps.">>,
|
||||
<<?Pos(6, 31)
|
||||
<<?Pos(6, 25)
|
||||
"Invalid key type\n"
|
||||
" lm\n"
|
||||
"Map keys cannot contain other maps.">>])
|
||||
@@ -614,7 +549,7 @@ failing_contracts() ->
|
||||
"Failed to resolve byte array lengths in call to Bytes.split with argument of type\n"
|
||||
" - 'f (at line 12, column 20)\n"
|
||||
"and result types\n"
|
||||
" - 'e (at line 12, column 25)\n"
|
||||
" - 'e (at line 13, column 5)\n"
|
||||
" - bytes(20) (at line 12, column 29)">>,
|
||||
<<?Pos(16, 5)
|
||||
"Failed to resolve byte array lengths in call to Bytes.split with argument of type\n"
|
||||
@@ -627,109 +562,7 @@ failing_contracts() ->
|
||||
" - 'b (at line 18, column 20)\n"
|
||||
"and result types\n"
|
||||
" - bytes(20) (at line 18, column 25)\n"
|
||||
" - 'a (at line 18, column 37)">>])
|
||||
, ?TYPE_ERROR(wrong_compiler_version,
|
||||
[<<?Pos(1, 1)
|
||||
"Cannot compile with this version of the compiler,\n"
|
||||
"because it does not satisfy the constraint ", Version/binary, " < 1.0">>,
|
||||
<<?Pos(2, 1)
|
||||
"Cannot compile with this version of the compiler,\n"
|
||||
"because it does not satisfy the constraint ", Version/binary, " == 9.9.9">>])
|
||||
, ?TYPE_ERROR(multiple_contracts,
|
||||
[<<?Pos(2, 3)
|
||||
"Only the main contract can contain defined functions or entrypoints.\n"
|
||||
"Fix: replace the definition of 'foo' by a type signature.">>])
|
||||
, ?TYPE_ERROR(contract_as_namespace,
|
||||
[<<?Pos(5, 28)
|
||||
"Invalid call to contract entrypoint 'Foo.foo'.\n"
|
||||
"It must be called as 'c.foo' for some c : Foo.">>])
|
||||
, ?TYPE_ERROR(toplevel_let,
|
||||
[<<?Pos(2, 7)
|
||||
"Toplevel \"let\" definitions are not supported\n"
|
||||
"Value this_is_illegal at line 2, column 7 could be replaced by 0-argument function">>])
|
||||
, ?TYPE_ERROR(empty_typedecl,
|
||||
[<<?Pos(2, 8)
|
||||
"Empty type declarations are not supported\n"
|
||||
"Type t at line 2, column 8 lacks a definition">>])
|
||||
, ?TYPE_ERROR(higher_kinded_type,
|
||||
[<<?Pos(2, 35)
|
||||
"Type 'm is a higher kinded type variable\n"
|
||||
"(takes another type as an argument)">>])
|
||||
, ?TYPE_ERROR(bad_arity,
|
||||
[<<?Pos(3, 20)
|
||||
"Arity for id doesn't match. Expected 1, got 0">>,
|
||||
<<?Pos(3, 25)
|
||||
"Cannot unify int\n"
|
||||
" and id\n"
|
||||
"when checking the type of the expression at line 3, column 25\n"
|
||||
" 123 : int\n"
|
||||
"against the expected type\n"
|
||||
" id">>,
|
||||
<<?Pos(4, 20)
|
||||
"Arity for id doesn't match. Expected 1, got 2">>,
|
||||
<<?Pos(4, 35)
|
||||
"Cannot unify int\n"
|
||||
" and id(int, int)\n"
|
||||
"when checking the type of the expression at line 4, column 35\n"
|
||||
" 123 : int\n"
|
||||
"against the expected type\n"
|
||||
" id(int, int)">>])
|
||||
, ?TYPE_ERROR(bad_unnamed_map_update_default,
|
||||
[<<?Pos(4, 17)
|
||||
"Invalid map update with default">>])
|
||||
, ?TYPE_ERROR(non_functional_entrypoint,
|
||||
[<<?Pos(2, 14)
|
||||
"f at line 2, column 14 was declared with an invalid type int.\n"
|
||||
"Entrypoints and functions must have functional types">>])
|
||||
, ?TYPE_ERROR(bad_records,
|
||||
[<<?Pos(3, 16)
|
||||
"Mixed record fields and map keys in\n"
|
||||
" {x = 0, [0] = 1}">>,
|
||||
<<?Pos(4, 6)
|
||||
"Mixed record fields and map keys in\n"
|
||||
" r {x = 0, [0] = 1}">>,
|
||||
<<?Pos(5, 6)
|
||||
"Empty record/map update\n"
|
||||
" r {}">>
|
||||
])
|
||||
, ?TYPE_ERROR(bad_protected_call,
|
||||
[<<?Pos(6, 22)
|
||||
"Invalid 'protected' argument\n"
|
||||
" (0 : int) == (1 : int) : bool\n"
|
||||
"It must be either 'true' or 'false'.">>
|
||||
])
|
||||
, ?TYPE_ERROR(bad_function_block,
|
||||
[<<?Pos(4, 5)
|
||||
"Mismatch in the function block. Expected implementation/type declaration of g function">>,
|
||||
<<?Pos(5, 5)
|
||||
"Mismatch in the function block. Expected implementation/type declaration of g function">>
|
||||
])
|
||||
, ?TYPE_ERROR(just_an_empty_file,
|
||||
[<<?Pos(0, 0)
|
||||
"Empty contract">>
|
||||
])
|
||||
, ?TYPE_ERROR(bad_number_of_args,
|
||||
[<<?Pos(3, 39)
|
||||
"Cannot unify () => unit\n"
|
||||
" and (int) => 'a\n",
|
||||
"when checking the application at line 3, column 39 of\n"
|
||||
" f : () => unit\n"
|
||||
"to arguments\n"
|
||||
" 1 : int">>,
|
||||
<<?Pos(4, 20)
|
||||
"Cannot unify (int, string) => 'e\n"
|
||||
" and (int) => 'd\n"
|
||||
"when checking the application at line 4, column 20 of\n"
|
||||
" g : (int, string) => 'e\n"
|
||||
"to arguments\n"
|
||||
" 1 : int">>,
|
||||
<<?Pos(5, 20)
|
||||
"Cannot unify (int, string) => 'c\n"
|
||||
" and (string) => 'b\n"
|
||||
"when checking the application at line 5, column 20 of\n"
|
||||
" g : (int, string) => 'c\nto arguments\n"
|
||||
" \"Litwo, ojczyzno moja\" : string">>
|
||||
])
|
||||
" - 'a (at line 19, column 5)">>])
|
||||
].
|
||||
|
||||
-define(Path(File), "code_errors/" ??File).
|
||||
@@ -845,49 +678,3 @@ failing_code_gen_contracts() ->
|
||||
"The state cannot contain functions in the AEVM. Use FATE if you need this.")
|
||||
].
|
||||
|
||||
validation_test_() ->
|
||||
[{"Validation fail: " ++ C1 ++ " /= " ++ C2,
|
||||
fun() ->
|
||||
Actual = case validate(C1, C2) of
|
||||
{error, Errs} -> Errs;
|
||||
ok -> #{}
|
||||
end,
|
||||
check_errors(Expect, Actual)
|
||||
end} || {C1, C2, Expect} <- validation_fails()] ++
|
||||
[{"Validation of " ++ C,
|
||||
fun() ->
|
||||
?assertEqual(ok, validate(C, C))
|
||||
end} || C <- compilable_contracts()].
|
||||
|
||||
validation_fails() ->
|
||||
[{"deadcode", "nodeadcode",
|
||||
[<<"Data error:\n"
|
||||
"Byte code does not match source code.\n"
|
||||
"- Functions in the source code but not in the byte code:\n"
|
||||
" .MyList.map2">>]},
|
||||
{"validation_test1", "validation_test2",
|
||||
[<<"Data error:\n"
|
||||
"Byte code does not match source code.\n"
|
||||
"- The implementation of the function code_fail is different.\n"
|
||||
"- The attributes of the function attr_fail differ:\n"
|
||||
" Byte code: payable\n"
|
||||
" Source code: \n"
|
||||
"- The type of the function type_fail differs:\n"
|
||||
" Byte code: integer => integer\n"
|
||||
" Source code: {tvar,0} => {tvar,0}">>]},
|
||||
{"validation_test1", "validation_test3",
|
||||
[<<"Data error:\n"
|
||||
"Byte code contract is not payable, but source code contract is.">>]}].
|
||||
|
||||
validate(Contract1, Contract2) ->
|
||||
ByteCode = #{ fate_code := FCode } = compile(fate, Contract1),
|
||||
FCode1 = aeb_fate_code:serialize(aeb_fate_code:strip_init_function(FCode)),
|
||||
Source = aeso_test_utils:read_contract(Contract2),
|
||||
aeso_compiler:validate_byte_code(
|
||||
ByteCode#{ byte_code := FCode1 }, Source,
|
||||
case lists:member(Contract2, debug_mode_contracts()) of
|
||||
true -> [debug_mode];
|
||||
false -> []
|
||||
end ++
|
||||
[{backend, fate}, {include, {file_system, [aeso_test_utils:contract_path()]}}]).
|
||||
|
||||
|
||||
@@ -4,8 +4,6 @@
|
||||
|
||||
-include_lib("eunit/include/eunit.hrl").
|
||||
|
||||
id(X) -> X.
|
||||
|
||||
simple_contracts_test_() ->
|
||||
{foreach,
|
||||
fun() -> ok end,
|
||||
@@ -16,7 +14,7 @@ simple_contracts_test_() ->
|
||||
" function id(x) = x\n",
|
||||
?assertMatch(
|
||||
[{contract, _, {con, _, "Identity"},
|
||||
[{letfun, _, {id, _, "id"}, [{id, _, "x"}], {id, _, "_"},
|
||||
[{letfun, _, {id, _, "id"}, [{arg, _, {id, _, "x"}, {id, _, "_"}}], {id, _, "_"},
|
||||
{id, _, "x"}}]}], parse_string(Text)),
|
||||
ok
|
||||
end},
|
||||
@@ -32,7 +30,7 @@ simple_contracts_test_() ->
|
||||
end,
|
||||
Parse = fun(S) ->
|
||||
try remove_line_numbers(parse_expr(S))
|
||||
catch _:_ -> ?assertMatch(ok, id({parse_fail, S})) end
|
||||
catch _:_ -> ?assertMatch(ok, {parse_fail, S}) end
|
||||
end,
|
||||
CheckParens = fun(Expr) ->
|
||||
?assertEqual(Parse(NoPar(Expr)), Parse(Par(Expr)))
|
||||
@@ -40,6 +38,7 @@ simple_contracts_test_() ->
|
||||
LeftAssoc = fun(Op) -> CheckParens({{a, Op, b}, Op, c}) end,
|
||||
RightAssoc = fun(Op) -> CheckParens({a, Op, {b, Op, c}}) end,
|
||||
NonAssoc = fun(Op) ->
|
||||
OpAtom = list_to_atom(Op),
|
||||
?assertThrow({error, [_]},
|
||||
parse_expr(NoPar({a, Op, {b, Op, c}}))) end,
|
||||
Stronger = fun(Op1, Op2) ->
|
||||
@@ -63,8 +62,7 @@ simple_contracts_test_() ->
|
||||
%% Parse tests of example contracts
|
||||
[ {lists:concat(["Parse the ", Contract, " contract."]),
|
||||
fun() -> roundtrip_contract(Contract) end}
|
||||
|| Contract <- [counter, voting, all_syntax, '05_greeter', aeproof,
|
||||
multi_sig, simple_storage, fundme, dutch_auction, utf8] ]
|
||||
|| Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, fundme, dutch_auction] ]
|
||||
}.
|
||||
|
||||
parse_contract(Name) ->
|
||||
@@ -79,14 +77,14 @@ parse_string(Text, Opts) ->
|
||||
aeso_parser:string(Text, Opts).
|
||||
|
||||
parse_expr(Text) ->
|
||||
[{letval, _, _, Expr}] =
|
||||
[{letval, _, _, _, Expr}] =
|
||||
parse_string("let _ = " ++ Text),
|
||||
Expr.
|
||||
|
||||
round_trip(Text) ->
|
||||
Contract = parse_string(Text),
|
||||
Text1 = prettypr:format(aeso_pretty:decls(strip_stdlib(Contract))),
|
||||
Contract1 = parse_string(aeso_scan:utf8_encode(Text1)),
|
||||
Contract1 = parse_string(Text1),
|
||||
NoSrcLoc = remove_line_numbers(Contract),
|
||||
NoSrcLoc1 = remove_line_numbers(Contract1),
|
||||
?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).
|
||||
|
||||
@@ -58,7 +58,8 @@ contract Greeter =
|
||||
|
||||
let state = { greeting = "Hello" }
|
||||
|
||||
function setGreeting(greeting: string) =
|
||||
let setGreeting =
|
||||
(greeting: string) =>
|
||||
state{ greeting = greeting }
|
||||
|
||||
|
||||
|
||||
@@ -11,6 +11,4 @@ contract AddressLiterals =
|
||||
oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
|
||||
entrypoint contr() : Remote =
|
||||
ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
|
||||
entrypoint contr_addr() : Remote =
|
||||
Address.to_contract(addr())
|
||||
|
||||
|
||||
+1
-16
@@ -33,22 +33,7 @@ contract AENSTest =
|
||||
sign : signature) : unit =
|
||||
AENS.claim(addr, name, salt, name_fee, signature = sign)
|
||||
|
||||
|
||||
stateful entrypoint update(owner : address,
|
||||
name : string,
|
||||
ttl : option(Chain.ttl),
|
||||
client_ttl : option(int),
|
||||
pointers : option(map(string, AENS.pointee))) : unit =
|
||||
AENS.update(owner, name, ttl, client_ttl, pointers)
|
||||
|
||||
stateful entrypoint signedUpdate(owner : address,
|
||||
name : string,
|
||||
ttl : option(Chain.ttl),
|
||||
client_ttl : option(int),
|
||||
pointers : option(map(string, AENS.pointee)),
|
||||
sign : signature) : unit =
|
||||
AENS.update(owner, name, ttl, client_ttl, pointers, signature = sign)
|
||||
|
||||
// TODO: update() -- how to handle pointers?
|
||||
|
||||
stateful entrypoint transfer(owner : address,
|
||||
new_owner : address,
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
contract AENSUpdate =
|
||||
stateful entrypoint update_name(owner : address, name : string) =
|
||||
let p1 : AENS.pointee = AENS.AccountPt(Call.caller)
|
||||
let p2 : AENS.pointee = AENS.OraclePt(Call.caller)
|
||||
let p3 : AENS.pointee = AENS.ContractPt(Call.caller)
|
||||
let p4 : AENS.pointee = AENS.ChannelPt(Call.caller)
|
||||
AENS.update(owner, name, None, None,
|
||||
Some({ ["account_pubkey"] = p1, ["oracle_pubkey"] = p2,
|
||||
["contract_pubkey"] = p3, ["misc"] = p4 }))
|
||||
|
||||
entrypoint get_ttl(name : string) =
|
||||
switch(AENS.lookup(name))
|
||||
Some(AENS.Name(_, FixedTTL(ttl), _)) => ttl
|
||||
|
||||
entrypoint expiry(o : oracle(int, int)) : int =
|
||||
Oracle.expiry(o)
|
||||
|
||||
@@ -1,82 +1,44 @@
|
||||
// Try to cover all syntactic constructs.
|
||||
@compiler > 0
|
||||
@compiler =< 10.1.1.1.1.1.2.3.4
|
||||
|
||||
contract AllSyntaxType =
|
||||
type typeDecl /* bla */
|
||||
type paramTypeDecl('a, 'b)
|
||||
|
||||
namespace Ns =
|
||||
datatype d('a) = D | S(int) | M('a, list('a), int)
|
||||
private function fff() = 123
|
||||
|
||||
stateful entrypoint
|
||||
f (1, x) = (_) => x
|
||||
|
||||
payable contract AllSyntaxType =
|
||||
/** Multi-
|
||||
* line
|
||||
* comment
|
||||
*/
|
||||
stateful function foo : _
|
||||
entrypoint bar : int => (int * 'a)
|
||||
|
||||
function foo : _
|
||||
|
||||
contract AllSyntax =
|
||||
|
||||
datatype mickiewicz = Adam | Mickiewicz
|
||||
record goethe('a, 'b) = {
|
||||
johann : int,
|
||||
wolfgang : 'a,
|
||||
von : 'a * 'b * int,
|
||||
goethe : unit
|
||||
}
|
||||
type dante = Ns.d(int)
|
||||
type shakespeare('a) = goethe('a, 'a)
|
||||
type typeDecl = int
|
||||
type paramTypeDecl('a, 'b) = (('a, 'b) => 'b) => list('a) => 'b => 'b
|
||||
|
||||
type state = shakespeare(int)
|
||||
record nestedRecord = { x : int }
|
||||
record recordType = { z : nestedRecord, y : int }
|
||||
datatype variantType('a) = None | Some('a)
|
||||
|
||||
entrypoint init() = {
|
||||
johann = 1000,
|
||||
wolfgang = -10,
|
||||
let valWithType : map(int, int) => option(int) = (m) => Map.get(m, 42)
|
||||
let valNoType =
|
||||
if(valWithType(Map.empty) == None)
|
||||
print(42 mod 10 * 5 / 3)
|
||||
|
||||
/* TODO: This does not compile because of bug in the parser tester.
|
||||
von = (2 + 2, 0, List.sum([x | k <- [1,2,3]
|
||||
, let l = k + 1
|
||||
, if(l < 10)
|
||||
, let f(x) = x + 100
|
||||
, Adam <- [Adam, Mickiewicz]
|
||||
, let x = f(l)
|
||||
])),
|
||||
*/
|
||||
von = (2 + 2, 0, List.sum([1,2,3,4])),
|
||||
goethe = () }
|
||||
function funWithType(x : int, y) : int * list(int) = (x, 0 :: [y] ++ [])
|
||||
function funNoType() =
|
||||
let foo = (x, y : bool) =>
|
||||
if (! (y && x =< 0x0b || true)) [x]
|
||||
else [11..20]
|
||||
let setY(r : recordType) : unit = r{ y = 5 }
|
||||
let setX(r : recordType, x : int) : recordType = r { z.x = x } // nested record update
|
||||
let getY(r) = switch(r) {y = y} => y
|
||||
switch (funWithType(1, -2))
|
||||
(x, [y, z]) => bar({x = z, y = -y + - -z * (-1)})
|
||||
(x, y :: _) => ()
|
||||
|
||||
function f() =
|
||||
let kp = "nietzsche"
|
||||
// let p = "Пушкин" // TODO: this also doesn't do right round_trip...
|
||||
let k(x : bytes(8)) : bytes(8) = Bytes.to_int(#fedcba9876543210)
|
||||
let hash : address = #01ab0fff11
|
||||
let b = false
|
||||
let qcon = Mod.Con
|
||||
let str = "blabla\nfoo"
|
||||
let chr = '"'
|
||||
|
||||
let f : () => address = () => ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
|
||||
if(Bits.test(Bits.all, 10))
|
||||
abort("ohno")
|
||||
if(true && false)
|
||||
require(true, "ohyes")
|
||||
elif(false || 2 == 2)
|
||||
()
|
||||
else
|
||||
()
|
||||
if(true) f(1,2)((1,2))
|
||||
else switch(1::[1,2,3])
|
||||
[] => 1
|
||||
a::b => 123
|
||||
1::2::3 => 123123
|
||||
[2,3,4] => 1
|
||||
_ => 13
|
||||
1::[2] => 2138
|
||||
put(state{johann = 1})
|
||||
|
||||
let m = {["foo"] = 19, /*hey wanna talk about inlined comments?*/ ["bar"] = 42}
|
||||
let n = {}
|
||||
m{ ["x" = 0] @ z = z + state.johann }
|
||||
|
||||
let sh : shakespeare(shakespeare(int)) =
|
||||
{wolfgang = state}
|
||||
sh{wolfgang.wolfgang = sh.wolfgang} // comment
|
||||
|
||||
@@ -30,6 +30,4 @@ contract AddressLiterals =
|
||||
ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
|
||||
entrypoint contr3() : bytes(32) =
|
||||
ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
|
||||
entrypoint contr4() : address =
|
||||
Address.to_contract(Contract.address)
|
||||
|
||||
|
||||
@@ -1,4 +0,0 @@
|
||||
contract C =
|
||||
type id('a) = 'a
|
||||
entrypoint f() : id = 123
|
||||
entrypoint g() : id(int, int) = 123
|
||||
@@ -1,5 +0,0 @@
|
||||
contract C =
|
||||
function
|
||||
g(1) = 2
|
||||
f(2) = 3
|
||||
h(1) = 123
|
||||
@@ -1,4 +1,5 @@
|
||||
contract BadCon =
|
||||
contract Bad =
|
||||
include "included.aes"
|
||||
namespace Foo =
|
||||
function foo() = 42
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
contract Test =
|
||||
entrypoint f() = ()
|
||||
entrypoint g(x : int, y : string) = f(1)
|
||||
entrypoint h() = g(1)
|
||||
entrypoint i() = g("Litwo, ojczyzno moja")
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
contract Remote =
|
||||
entrypoint id : int => int
|
||||
|
||||
contract ProtectedCall =
|
||||
entrypoint bad(r : Remote) =
|
||||
r.id(protected = 0 == 1, 18)
|
||||
@@ -1,5 +0,0 @@
|
||||
contract BadRecord =
|
||||
entrypoint foo() =
|
||||
let r = {x = 0, [0] = 1}
|
||||
r{x = 0, [0] = 1}
|
||||
r{}
|
||||
@@ -1,5 +0,0 @@
|
||||
contract C =
|
||||
entrypoint f() =
|
||||
let z = 123
|
||||
{}{ [1 = 0] = z + 1 }
|
||||
2
|
||||
@@ -1,74 +0,0 @@
|
||||
// namespace Chain =
|
||||
// record tx = { paying_for : option(Chain.paying_for_tx)
|
||||
// , ga_metas : list(Chain.ga_meta_tx)
|
||||
// , actor : address
|
||||
// , fee : int
|
||||
// , ttl : int
|
||||
// , tx : Chain.base_tx }
|
||||
|
||||
// datatype ga_meta_tx = GAMetaTx(address, int)
|
||||
// datatype paying_for_tx = PayingForTx(address, int)
|
||||
// datatype base_tx = SpendTx(address, int, string)
|
||||
// | OracleRegisterTx | OracleQueryTx | OracleResponseTx | OracleExtendTx
|
||||
// | NamePreclaimTx | NameClaimTx(hash) | NameUpdateTx(string)
|
||||
// | NameRevokeTx(hash) | NameTransferTx(address, string)
|
||||
// | ChannelCreateTx(address) | ChannelDepositTx(address, int) | ChannelWithdrawTx(address, int) |
|
||||
// | ChannelForceProgressTx(address) | ChannelCloseMutualTx(address) | ChannelCloseSoloTx(address)
|
||||
// | ChannelSlashTx(address) | ChannelSettleTx(address) | ChannelSnapshotSoloTx(address)
|
||||
// | ContractCreateTx(int) | ContractCallTx(address, int)
|
||||
// | GAAttachTx
|
||||
|
||||
|
||||
// Contract replicating "normal" Aeternity authentication
|
||||
contract BasicAuthTx =
|
||||
record state = { nonce : int, owner : address }
|
||||
datatype foo = Bar | Baz()
|
||||
|
||||
entrypoint init() = { nonce = 1, owner = Call.caller }
|
||||
|
||||
stateful entrypoint 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) =>
|
||||
let Some(tx0) = Auth.tx
|
||||
let x : option(Chain.paying_for_tx) = tx0.paying_for
|
||||
let x : list(Chain.ga_meta_tx) = tx0.ga_metas
|
||||
let x : int = tx0.fee + tx0.ttl
|
||||
let x : address = tx0.actor
|
||||
let x : Chain.tx = { tx = Chain.NamePreclaimTx, paying_for = None, ga_metas = [],
|
||||
fee = 123, ttl = 0, actor = Call.caller }
|
||||
switch(tx0.tx)
|
||||
Chain.SpendTx(receiver, amount, payload) => verify(tx_hash, n, s)
|
||||
Chain.OracleRegisterTx => false
|
||||
Chain.OracleQueryTx => false
|
||||
Chain.OracleResponseTx => false
|
||||
Chain.OracleExtendTx => false
|
||||
Chain.NamePreclaimTx => false
|
||||
Chain.NameClaimTx(name) => false
|
||||
Chain.NameUpdateTx(name) => false
|
||||
Chain.NameRevokeTx(name) => false
|
||||
Chain.NameTransferTx(to, name) => false
|
||||
Chain.ChannelCreateTx(other_party) => false
|
||||
Chain.ChannelDepositTx(channel, amount) => false
|
||||
Chain.ChannelWithdrawTx(channel, amount) => false
|
||||
Chain.ChannelForceProgressTx(channel) => false
|
||||
Chain.ChannelCloseMutualTx(channel) => false
|
||||
Chain.ChannelCloseSoloTx(channel) => false
|
||||
Chain.ChannelSlashTx(channel) => false
|
||||
Chain.ChannelSettleTx(channel) => false
|
||||
Chain.ChannelSnapshotSoloTx(channel) => false
|
||||
Chain.ContractCreateTx(amount) => false
|
||||
Chain.ContractCallTx(ct_address, amount) => false
|
||||
Chain.GAAttachTx => false
|
||||
|
||||
function verify(tx_hash, n, s) =
|
||||
Crypto.verify_sig(to_sign(tx_hash, n), state.owner, s)
|
||||
|
||||
entrypoint to_sign(h : hash, n : int) =
|
||||
Crypto.blake2b((h, n))
|
||||
|
||||
entrypoint weird_string() : string =
|
||||
"\x19Weird String\x42\nMore\n"
|
||||
@@ -1,4 +1,4 @@
|
||||
include "String.aes"
|
||||
|
||||
contract BytesToX =
|
||||
|
||||
entrypoint to_int(b : bytes(42)) : int = Bytes.to_int(b)
|
||||
|
||||
@@ -17,7 +17,7 @@ contract ChannelOnChainContractOracle =
|
||||
bets = {}
|
||||
}
|
||||
|
||||
public stateful function place_bet(answer: string) =
|
||||
public stateful function place_bet(answer: string) =
|
||||
switch(Map.lookup(answer, state.bets))
|
||||
None =>
|
||||
put(state{ bets = state.bets{[answer] = Call.caller}})
|
||||
@@ -25,9 +25,6 @@ contract ChannelOnChainContractOracle =
|
||||
Some(_value) =>
|
||||
"bet_already_taken"
|
||||
|
||||
public function expiry() =
|
||||
Oracle.expiry(state.oracle)
|
||||
|
||||
public function query_fee() =
|
||||
Oracle.query_fee(state.oracle)
|
||||
|
||||
@@ -38,7 +35,7 @@ contract ChannelOnChainContractOracle =
|
||||
switch(Oracle.get_answer(state.oracle, q))
|
||||
None =>
|
||||
"no response"
|
||||
Some(result) =>
|
||||
Some(result) =>
|
||||
if(state.question == Oracle.get_question(state.oracle, q))
|
||||
switch(Map.lookup(result, state.bets))
|
||||
None =>
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
contract Foo =
|
||||
entrypoint foo : () => int
|
||||
|
||||
contract Fail =
|
||||
entrypoint bad() : int = Foo.foo()
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
contract C =
|
||||
type t
|
||||
entrypoint f() = 123
|
||||
@@ -11,7 +11,7 @@ contract Factorial =
|
||||
|
||||
stateful entrypoint set_worker(worker) = put(state{worker = worker})
|
||||
|
||||
entrypoint
|
||||
fac : int => int
|
||||
fac(0) = 1
|
||||
fac(x) = x * state.worker.fac(x - 1)
|
||||
entrypoint fac(x : int) : int =
|
||||
if(x == 0) 1
|
||||
else x * state.worker.fac(x - 1)
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
include "String.aes"
|
||||
|
||||
contract FunctionArguments =
|
||||
|
||||
entrypoint sum(n : int, m: int) =
|
||||
@@ -45,8 +45,3 @@ contract FunctionArguments =
|
||||
|
||||
entrypoint due(t : Chain.ttl) =
|
||||
true
|
||||
|
||||
record singleton_r = { x : int }
|
||||
|
||||
entrypoint singleton_rec(r : singleton_r) =
|
||||
r.x
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
namespace M =
|
||||
function mf() = mg()
|
||||
function mg() = mf()
|
||||
|
||||
namespace N =
|
||||
function nf() = ng() + M.mf() + M.mg()
|
||||
private function ng() = nf() + M.mf() + M.mg()
|
||||
|
||||
contract C =
|
||||
entrypoint f() = N.ng() + N.nf() + g()
|
||||
function g() = N.ng() + N.nf() + f()
|
||||
@@ -1,3 +0,0 @@
|
||||
contract IWantToBelieve =
|
||||
type stateT('s, 'm, 'a) = 's => 'm('a * 's)
|
||||
entrypoint s() = 123
|
||||
@@ -1,4 +0,0 @@
|
||||
contract Foo =
|
||||
record r = {x : int}
|
||||
// Crashed in the backend due to missing type annotation on the lc body.
|
||||
entrypoint lc(xs) = [ {x = x} | x <- xs ]
|
||||
@@ -1,15 +0,0 @@
|
||||
contract LetPatterns =
|
||||
|
||||
record r = {x : int, y : int, b : bool}
|
||||
|
||||
entrypoint test() = foo([1, 0], (2, 3), Some(4), {x = 5, y = 6, b = false})
|
||||
|
||||
entrypoint foo(xs : list(int), p : int * int, some : option(int), r : r) =
|
||||
let x :: _ = xs
|
||||
let (a, b) = p
|
||||
let Some(n) = some
|
||||
let {x = i, y = j} = r
|
||||
x + a + b + n + i + j
|
||||
|
||||
entrypoint lc(xs : list(option(int))) : list(int) =
|
||||
[ x | Some(x) <- xs ]
|
||||
@@ -1,22 +0,0 @@
|
||||
contract LHSMatching =
|
||||
|
||||
function from_some(Some(x)) = x
|
||||
|
||||
function
|
||||
length : list('a) => int
|
||||
length([]) = 0
|
||||
length(_ :: xs) = 1 + length(xs)
|
||||
|
||||
function
|
||||
append([], ys) = ys
|
||||
append(x :: xs, ys) = x :: append(xs, ys)
|
||||
|
||||
function local_match(xs : list('a)) =
|
||||
let null([]) = true
|
||||
let null(_ :: _) = false
|
||||
!null(xs)
|
||||
|
||||
entrypoint main() =
|
||||
from_some(Some([0]))
|
||||
++ append([length([true]), 2, 3], [4, 5, 6])
|
||||
++ [7 | if (local_match([false]))]
|
||||
@@ -1,14 +0,0 @@
|
||||
include "String.aes"
|
||||
contract StringX =
|
||||
entrypoint test() =
|
||||
let s1 = "a string"
|
||||
let s2 = "another string"
|
||||
let s = String.concat(s1, s2)
|
||||
String.sha256(s)
|
||||
String.length(s1)
|
||||
String.from_list(String.to_list(s))
|
||||
String.split(4, s1)
|
||||
String.at(2, s2)
|
||||
String.tokens(s, ",")
|
||||
String.to_upper(s1)
|
||||
String.to_lower(s2)
|
||||
@@ -15,7 +15,7 @@ contract MultiSig =
|
||||
| OwnerRemoved (address) // of { .removedOwner : Address }
|
||||
| ReqChanged (int) // of { .newReq : int }
|
||||
|
||||
function maxOwners() : int = 250
|
||||
let maxOwners : int = 250
|
||||
|
||||
record state = { nRequired : int
|
||||
, nOwners : int
|
||||
@@ -68,7 +68,7 @@ contract MultiSig =
|
||||
switch(check_pending(callhash()))
|
||||
CheckFail(state') => { state = state' }
|
||||
CheckOk(state') =>
|
||||
if(state.nOwners >= maxOwners()) () /* TODO */
|
||||
if(state.nOwners >= maxOwners) () /* TODO */
|
||||
else
|
||||
let nOwners' = state'.nOwners + 1
|
||||
{ state = state' { owners = Map.insert(nOwners', newOwner, state'.owners)
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
contract ContractOne =
|
||||
entrypoint foo() = "foo"
|
||||
|
||||
contract ContractTwo =
|
||||
entrypoint bar() = "bar"
|
||||
@@ -1,5 +0,0 @@
|
||||
contract C1 =
|
||||
entrypoint f : int
|
||||
|
||||
contract C =
|
||||
entrypoint f() = 123
|
||||
@@ -1,6 +0,0 @@
|
||||
namespace BadNs =
|
||||
contract Con =
|
||||
entrypoint e : () => int
|
||||
|
||||
contract Con =
|
||||
entrypoint foo() = 43
|
||||
@@ -1,5 +0,0 @@
|
||||
namespace BadNs =
|
||||
include "included.aes"
|
||||
|
||||
contract Con =
|
||||
entrypoint foo() = 43
|
||||
@@ -1,30 +0,0 @@
|
||||
include "BLS12_381.aes"
|
||||
|
||||
contract GrothVerify =
|
||||
type fr = BLS12_381.fr
|
||||
type g1 = BLS12_381.g1
|
||||
type g2 = BLS12_381.g2
|
||||
|
||||
record proof = { a : g1, b : g2, c : g1 }
|
||||
record verify_key = { a : g1, b : g2, c : g2, d : g2, ic : list(g1) }
|
||||
|
||||
record state = { vk : verify_key }
|
||||
|
||||
entrypoint init(vk0 : verify_key) = {vk = vk0}
|
||||
|
||||
entrypoint verify_proof(p : proof, input : list(fr)) =
|
||||
let vk = state.vk
|
||||
let vk_x = calc_vk_x(vk.ic, input)
|
||||
|
||||
BLS12_381.pairing_check([BLS12_381.g1_neg(p.a), vk.a, vk_x, p.c],
|
||||
[p.b, vk.b, vk.c, vk.d])
|
||||
|
||||
function calc_vk_x(ics : list(g1), xs : list(fr)) =
|
||||
switch(ics)
|
||||
(ic :: ics) => calc_vk_x_(ic, ics, xs)
|
||||
|
||||
function calc_vk_x_(vk_x : g1, ics : list(g1), xs : list(fr)) =
|
||||
switch((ics, xs))
|
||||
([], []) => vk_x
|
||||
(ic :: ics, x :: xs) => calc_vk_x_(BLS12_381.g1_add(vk_x, BLS12_381.g1_mul(x, ic)), ics, xs)
|
||||
|
||||
@@ -1,14 +0,0 @@
|
||||
contract Remote =
|
||||
entrypoint id : int => int
|
||||
|
||||
contract ProtectedCall =
|
||||
|
||||
function higher_order(r : Remote) =
|
||||
r.id
|
||||
|
||||
entrypoint test_ok(r : Remote) =
|
||||
let f = higher_order(r)
|
||||
let Some(n) = r.id(protected = true, 10)
|
||||
let Some(m) = f(protected = true, 5)
|
||||
n + m + r.id(protected = false, 100) + f(1)
|
||||
|
||||
@@ -1,8 +0,0 @@
|
||||
namespace Foo =
|
||||
datatype x = A | B(int)
|
||||
|
||||
contract Bar =
|
||||
entrypoint f(a : Foo.x) =
|
||||
switch(a)
|
||||
Foo.A => 0
|
||||
Foo.B(n) => n
|
||||
@@ -8,9 +8,10 @@ contract Stack =
|
||||
|
||||
entrypoint init(ss : list(string)) = { stack = ss, size = length(ss) }
|
||||
|
||||
function
|
||||
length([]) = 0
|
||||
length(_ :: xs) = length(xs) + 1
|
||||
function length(xs) =
|
||||
switch(xs)
|
||||
[] => 0
|
||||
_ :: xs => length(xs) + 1
|
||||
|
||||
stateful entrypoint pop() : string =
|
||||
switch(state.stack)
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
include "String.aes"
|
||||
contract Remote =
|
||||
record rstate = { i : int, s : string, m : map(int, int) }
|
||||
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
include "String.aes"
|
||||
contract Strings =
|
||||
entrypoint str_len(s) = String.length(s)
|
||||
entrypoint str_concat(s1, s2) = String.concat(s1, s2)
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
contract C =
|
||||
let this_is_illegal = 2/0
|
||||
entrypoint this_is_legal() = 2/0
|
||||
@@ -7,7 +7,6 @@
|
||||
// AENS.transfer
|
||||
// AENS.revoke
|
||||
// Oracle.extend
|
||||
include "String.aes"
|
||||
contract UnappliedBuiltins =
|
||||
entrypoint main() = ()
|
||||
type o = oracle(int, int)
|
||||
@@ -22,7 +21,6 @@ contract UnappliedBuiltins =
|
||||
function b_abort() = abort
|
||||
function b_require() = require
|
||||
function oracle_query_fee() = Oracle.query_fee
|
||||
function oracle_expiry() = Oracle.expiry
|
||||
stateful function oracle_query() = Oracle.query : (o, _, _, _, _) => _
|
||||
function oracle_get_question() = Oracle.get_question : (o, _) => _
|
||||
function oracle_get_answer() = Oracle.get_answer : (o, _) => _
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
|
||||
contract UnderscoreNumberLiterals =
|
||||
|
||||
entrypoint ints() : list(int) =
|
||||
[ 1_999_000_000,
|
||||
19_99_00_00_00,
|
||||
0xfff_FFF_010 ]
|
||||
|
||||
entrypoint bytes() : list(bytes(4)) =
|
||||
[ #abcd_ef_00,
|
||||
#01_02_03_04,
|
||||
#aaaa_FFFF ]
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
contract UTF8 =
|
||||
entrypoint f1() : char = '1'
|
||||
entrypoint f2() : char = '+'
|
||||
entrypoint f3() : char = 'd'
|
||||
entrypoint f4() : char = 'X'
|
||||
entrypoint f5() : char = 'å'
|
||||
entrypoint f6() : char = 'Ä'
|
||||
entrypoint f7() : char = 'æ'
|
||||
entrypoint f8() : char = 'ë'
|
||||
entrypoint f9() : char = 'ẻ'
|
||||
entrypoint f10() : char = '\x27'
|
||||
entrypoint f11() : char = '\x{2200}'
|
||||
entrypoint f12() : char = '💩'
|
||||
entrypoint f13() : char = '\n'
|
||||
|
||||
|
||||
|
||||
// entrypoint f13() : char = 'e̊'
|
||||
// entrypoint f14() : char = '\Ì'
|
||||
|
||||
// '💩' vs. map('a,'b)
|
||||
@@ -1,4 +0,0 @@
|
||||
contract ValidationTest =
|
||||
payable entrypoint attr_fail() = ()
|
||||
entrypoint type_fail(x : int) = x
|
||||
entrypoint code_fail(x) = x + 1
|
||||
@@ -1,4 +0,0 @@
|
||||
contract ValidationTest =
|
||||
entrypoint attr_fail() = ()
|
||||
entrypoint type_fail(x) = x
|
||||
entrypoint code_fail(x) = x - 1
|
||||
@@ -1,4 +0,0 @@
|
||||
payable contract ValidationTest =
|
||||
payable entrypoint attr_fail() = ()
|
||||
entrypoint type_fail(x : int) = x
|
||||
entrypoint code_fail(x) = x + 1
|
||||
@@ -1,3 +1,16 @@
|
||||
|
||||
/* Contract type */
|
||||
contract VotingType =
|
||||
type state
|
||||
function init : list(string) => state
|
||||
|
||||
function giveRightToVote : address => unit
|
||||
function delegate : address => unit
|
||||
function vote : int => unit
|
||||
function winnerName : unit => string
|
||||
function currentTally : unit => list(string * int)
|
||||
|
||||
/* Contract implementation */
|
||||
contract Voting =
|
||||
|
||||
// Types
|
||||
|
||||
@@ -1,7 +0,0 @@
|
||||
@compiler < 1.0
|
||||
@compiler == 9.9.9
|
||||
@compiler >= 0.1
|
||||
@compiler =< 100.0.1
|
||||
|
||||
contract Fail =
|
||||
entrypoint foo() = ()
|
||||
Reference in New Issue
Block a user