balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

parser and test

Browse Source
This commit is contained in:
Pierre-Emmanuel Wulfman 2020-04-15 17:15:55 +02:00
parent 7872a1d4bc
commit fa7cc825eb
33 changed files with 291 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/passes/01-parser/cameligo/AST.ml
View File

@ -56,6 +56,7 @@ type c_Some = Region.t
type arrow = Region.t (* "->" *)
type cons = Region.t (* "::" *)
type percent = Region.t (* "%" *)
type cat = Region.t (* "^" *)
type append = Region.t (* "@" *)
type dot = Region.t (* "." *)
@ -246,6 +247,7 @@ and expr =
| ELetIn of let_in reg
| EFun of fun_expr reg
| ESeq of expr injection reg
| ECodeInsert of code_insert reg
and annot_expr = expr * colon * type_expr
@ -398,6 +400,13 @@ and cond_expr = {
ifnot : expr
}
and code_insert = {
language : string reg;
code : string reg;
colon : colon;
type_anno : type_expr;
rbracket : rbracket;
}
(* Projecting regions from some nodes of the AST *)
let rec last to_region = function
@ -477,11 +486,12 @@ let expr_to_region = function
| EString e -> string_expr_to_region e
| EList e -> list_expr_to_region e
| EConstr e -> constr_expr_to_region e
| EAnnot {region;_ } | ELetIn {region;_} | EFun {region;_}
| ECond {region;_} | ETuple {region;_} | ECase {region;_}
| ECall {region;_} | EVar {region; _} | EProj {region; _}
| EUnit {region;_} | EPar {region;_} | EBytes {region; _}
| ESeq {region; _} | ERecord {region; _} | EUpdate {region; _} -> region
| EAnnot {region;_ } | ELetIn {region;_} | EFun {region;_}
| ECond {region;_} | ETuple {region;_} | ECase {region;_}
| ECall {region;_} | EVar {region; _} | EProj {region; _}
| EUnit {region;_} | EPar {region;_} | EBytes {region; _}
| ESeq {region; _} | ERecord {region; _} | EUpdate {region; _}
| ECodeInsert {region; _} -> region
let selection_to_region = function
FieldName f -> f.region

46
src/passes/01-parser/cameligo/LexToken.mli
View File

@ -38,10 +38,10 @@ type t =
(* Arithmetics *)
| MINUS of Region.t (* "-" *)
| PLUS of Region.t (* "+" *)
| SLASH of Region.t (* "/" *)
| TIMES of Region.t (* "*" *)
| MINUS of Region.t (* "-" *)
| PLUS of Region.t (* "+" *)
| SLASH of Region.t (* "/" *)
| TIMES of Region.t (* "*" *)
(* Compounds *)
@ -87,28 +87,29 @@ type t =
| Verbatim of string Region.reg
| Bytes of (string * Hex.t) Region.reg
| Attr of string Region.reg
| Insert of string Region.reg
(* Keywords *)
(*| And*)
| Begin of Region.t
| Else of Region.t
| End of Region.t
| False of Region.t
| Fun of Region.t
| Rec of Region.t
| If of Region.t
| In of Region.t
| Let of Region.t
| Match of Region.t
| Mod of Region.t
| Not of Region.t
| Of of Region.t
| Or of Region.t
| Then of Region.t
| True of Region.t
| Type of Region.t
| With of Region.t
| Begin of Region.t
| Else of Region.t
| End of Region.t
| False of Region.t
| Fun of Region.t
| Rec of Region.t
| If of Region.t
| In of Region.t
| Let of Region.t
| Match of Region.t
| Mod of Region.t
| Not of Region.t
| Of of Region.t
| Or of Region.t
| Then of Region.t
| True of Region.t
| Type of Region.t
| With of Region.t
(* Data constructors *)
@ -154,6 +155,7 @@ val mk_verbatim : lexeme -> Region.t -> token
val mk_bytes : lexeme -> Region.t -> token
val mk_constr : lexeme -> Region.t -> token
val mk_attr : string -> lexeme -> Region.t -> (token, attr_err) result
val mk_insert : lexeme -> Region.t -> token
val eof : Region.t -> token
(* Predicates *)

87
src/passes/01-parser/cameligo/LexToken.mll
View File

@ -22,10 +22,10 @@ type t =
(* Arithmetics *)
| MINUS of Region.t (* "-" *)
| PLUS of Region.t (* "+" *)
| SLASH of Region.t (* "/" *)
| TIMES of Region.t (* "*" *)
| MINUS of Region.t (* "-" *)
| PLUS of Region.t (* "+" *)
| SLASH of Region.t (* "/" *)
| TIMES of Region.t (* "*" *)
(* Compounds *)
@ -71,28 +71,29 @@ type t =
| Verbatim of string Region.reg
| Bytes of (string * Hex.t) Region.reg
| Attr of string Region.reg
| Insert of string Region.reg
(* Keywords *)
(*| And*)
| Begin of Region.t
| Else of Region.t
| End of Region.t
| False of Region.t
| Fun of Region.t
| Rec of Region.t
| If of Region.t
| In of Region.t
| Let of Region.t
| Match of Region.t
| Mod of Region.t
| Not of Region.t
| Of of Region.t
| Or of Region.t
| Then of Region.t
| True of Region.t
| Type of Region.t
| With of Region.t
| Begin of Region.t
| Else of Region.t
| End of Region.t
| False of Region.t
| Fun of Region.t
| Rec of Region.t
| If of Region.t
| In of Region.t
| Let of Region.t
| Match of Region.t
| Mod of Region.t
| Not of Region.t
| Of of Region.t
| Or of Region.t
| Then of Region.t
| True of Region.t
| Type of Region.t
| With of Region.t
(* Data constructors *)
@ -130,6 +131,8 @@ let proj_token = function
region, sprintf "Constr %s" value
| Attr Region.{region; value} ->
region, sprintf "Attr \"%s\"" value
| Insert Region.{region; value} ->
region, sprintf "Insert \"%s\"" value
(* Symbols *)
@ -204,6 +207,7 @@ let to_lexeme = function
| Ident id -> id.Region.value
| Constr id -> id.Region.value
| Attr a -> a.Region.value
| Insert i -> i.Region.value
(* Symbols *)
@ -277,24 +281,24 @@ let to_region token = proj_token token |> fst
(* LEXIS *)
let keywords = [
(fun reg -> Begin reg);
(fun reg -> Else reg);
(fun reg -> End reg);
(fun reg -> False reg);
(fun reg -> Fun reg);
(fun reg -> Rec reg);
(fun reg -> If reg);
(fun reg -> In reg);
(fun reg -> Let reg);
(fun reg -> Match reg);
(fun reg -> Mod reg);
(fun reg -> Not reg);
(fun reg -> Of reg);
(fun reg -> Or reg);
(fun reg -> Then reg);
(fun reg -> True reg);
(fun reg -> Type reg);
(fun reg -> With reg)]
(fun reg -> Begin reg);
(fun reg -> Else reg);
(fun reg -> End reg);
(fun reg -> False reg);
(fun reg -> Fun reg);
(fun reg -> Rec reg);
(fun reg -> If reg);
(fun reg -> In reg);
(fun reg -> Let reg);
(fun reg -> Match reg);
(fun reg -> Mod reg);
(fun reg -> Not reg);
(fun reg -> Of reg);
(fun reg -> Or reg);
(fun reg -> Then reg);
(fun reg -> True reg);
(fun reg -> Type reg);
(fun reg -> With reg)]
let reserved =
let open SSet in
@ -508,6 +512,9 @@ let mk_attr header lexeme region =
if header = "[@" then Error Invalid_attribute
else Ok (Attr Region.{value=lexeme; region})
let mk_insert lexeme region =
Insert Region.{value=lexeme;region}
(* Predicates *)
let is_string = function String _ -> true | _ -> false

1
src/passes/01-parser/cameligo/ParToken.mly
View File

@ -14,6 +14,7 @@
%token <string Region.reg> Ident "<ident>"
%token <string Region.reg> Constr "<constr>"
%token <string Region.reg> Attr "<attr>"
%token <string Region.reg> Insert "<insert>"
(* Symbols *)

12
src/passes/01-parser/cameligo/Parser.mly
View File

@ -583,6 +583,7 @@ core_expr:
| sequence { ESeq $1 }
| record_expr { ERecord $1 }
| update_record { EUpdate $1 }
| code_insert { ECodeInsert $1 }
| par(expr) { EPar $1 }
| par(annot_expr) { EAnnot $1 }
@ -706,3 +707,14 @@ last_expr:
seq_expr:
disj_expr_level | if_then_else (seq_expr) { $1 }
code_insert:
Insert "<verbatim>" ":" type_expr "]" {
let region = cover $1.region $5 in
let value = {
language =$1;
code =$2;
colon =$3;
type_anno=$4;
rbracket =$5}
in {region; value} }

27
src/passes/01-parser/cameligo/ParserLog.ml
View File

@ -366,6 +366,7 @@ and print_expr state = function
| ESeq seq -> print_sequence state seq
| ERecord e -> print_record_expr state e
| EConstr e -> print_constr_expr state e
| ECodeInsert e -> print_code_insert state e
and print_constr_expr state = function
ENone e -> print_none_expr state e
@ -518,6 +519,14 @@ and print_comp_expr state = function
and print_record_expr state e =
print_ne_injection state print_field_assign e
and print_code_insert state {value; _} =
let {language;code;colon;type_anno;rbracket} : code_insert = value in
print_string state language;
print_string state code;
print_token state colon ":";
print_type_expr state type_anno;
print_token state rbracket "]"
and print_field_assign state {value; _} =
let {field_name; assignment; field_expr} = value in
print_var state field_name;
@ -860,6 +869,9 @@ and pp_expr state = function
| ESeq {value; region} ->
pp_loc_node state "ESeq" region;
pp_injection pp_expr state value
| ECodeInsert {value; region} ->
pp_loc_node state "ECodeInsert" region;
pp_code_insert state value
and pp_fun_expr state node =
let {binders; lhs_type; body; _} = node in
@ -881,6 +893,21 @@ and pp_fun_expr state node =
pp_expr (state#pad 1 0) body
in ()
and pp_code_insert state (rc : code_insert) =
let () =
let state = state#pad 3 0 in
pp_node state "<language>";
pp_string (state#pad 1 0) rc.language in
let () =
let state = state#pad 3 1 in
pp_node state "<code>";
pp_string (state#pad 1 0) rc.code in
let () =
let state = state#pad 3 2 in
pp_node state "<type annotation>";
pp_type_expr (state#pad 1 0) rc.type_anno
in ()
and pp_let_in state node =
let {binding; body; attributes; kwd_rec; _} = node in
let {binders; lhs_type; let_rhs; _} = binding in

1
src/passes/01-parser/cameligo/Unlexer.ml
View File

@ -43,6 +43,7 @@ let concrete = function
| "PLUS" -> "+"
| "SLASH" -> "/"
| "TIMES" -> "*"
| "PERCENT" -> "%"
| "LPAR" -> "("
| "RPAR" -> ")"

13
src/passes/01-parser/pascaligo/AST.ml
View File

@ -82,6 +82,7 @@ type rbrace = Region.t (* "}" *)
type lbracket = Region.t (* "[" *)
type rbracket = Region.t (* "]" *)
type cons = Region.t (* "#" *)
type percent = Region.t (* "%" *)
type vbar = Region.t (* "|" *)
type arrow = Region.t (* "->" *)
type assign = Region.t (* ":=" *)
@ -436,6 +437,14 @@ and for_collect = {
block : block reg
}
and code_insert = {
language : string reg;
code : string reg;
colon : colon;
type_anno : type_expr;
rbracket : rbracket;
}
and collection =
Map of kwd_map
| Set of kwd_set
@ -464,6 +473,7 @@ and expr =
| ETuple of tuple_expr
| EPar of expr par reg
| EFun of fun_expr reg
| ECodeInsert of code_insert reg
and annot_expr = expr * colon * type_expr
@ -687,7 +697,8 @@ let rec expr_to_region = function
| ECase {region;_}
| ECond {region; _}
| EPar {region; _}
| EFun {region; _} -> region
| EFun {region; _}
| ECodeInsert {region; _} -> region
and tuple_expr_to_region {region; _} = region

2
src/passes/01-parser/pascaligo/LexToken.mli
View File

@ -44,6 +44,7 @@ type t =
| Mutez of (lexeme * Z.t) Region.reg
| Ident of lexeme Region.reg
| Constr of lexeme Region.reg
| Insert of lexeme Region.reg
(* Symbols *)
@ -161,6 +162,7 @@ val mk_verbatim : lexeme -> Region.t -> token
val mk_bytes : lexeme -> Region.t -> token
val mk_constr : lexeme -> Region.t -> token
val mk_attr : string -> lexeme -> Region.t -> (token, attr_err) result
val mk_insert : lexeme -> Region.t -> token
val eof : Region.t -> token
(* Predicates *)

17
src/passes/01-parser/pascaligo/LexToken.mll
View File

@ -32,6 +32,7 @@ type t =
| Mutez of (lexeme * Z.t) Region.reg
| Ident of lexeme Region.reg
| Constr of lexeme Region.reg
| Insert of lexeme Region.reg
(* Symbols *)
@ -141,6 +142,14 @@ let proj_token = function
| Constr Region.{region; value} ->
region, sprintf "Constr \"%s\"" value
| Insert Region.{region; value} ->
region, sprintf "Insert \"%s\"" value
(*
| Attr {header; string={region; value}} ->
region, sprintf "Attr (\"%s\",\"%s\")" header value
*)
(* Symbols *)
| SEMI region -> region, "SEMI"
@ -233,6 +242,7 @@ let to_lexeme = function
| Mutez i -> fst i.Region.value
| Ident id
| Constr id -> id.Region.value
| Insert i -> i.Region.value
(* Symbols *)
@ -365,7 +375,7 @@ let keywords = [
(fun reg -> Unit reg);
(fun reg -> Var reg);
(fun reg -> While reg);
(fun reg -> With reg)
(fun reg -> With reg);
]
let reserved = SSet.empty
@ -543,6 +553,11 @@ type attr_err = Invalid_attribute
let mk_attr _ _ _ = Error Invalid_attribute
(* Raw Code Insertion *)
let mk_insert lexeme region =
Insert Region.{value=lexeme;region}
(* Predicates *)
let is_string = function String _ -> true | _ -> false

1
src/passes/01-parser/pascaligo/ParToken.mly
View File

@ -13,6 +13,7 @@
%token <(LexToken.lexeme * Z.t) Region.reg> Mutez "<mutez>"
%token <LexToken.lexeme Region.reg> Ident "<ident>"
%token <LexToken.lexeme Region.reg> Constr "<constr>"
%token <LexToken.lexeme Region.reg> Insert "<insert>"
(* Symbols *)

12
src/passes/01-parser/pascaligo/Parser.mly
View File

@ -855,6 +855,7 @@ core_expr:
| set_expr { ESet $1 }
| record_expr { ERecord $1 }
| update_record { EUpdate $1 }
| code_insert_expr { ECodeInsert $1 }
| "<constr>" arguments {
let region = cover $1.region $2.region in
EConstr (ConstrApp {region; value = $1, Some $2})
@ -973,6 +974,17 @@ update_record:
let value = {record=$1; kwd_with=$2; updates}
in {region; value} }
code_insert_expr:
Insert "<verbatim>" ":" type_expr "]" {
let region = cover $1.region $5 in
let value = {
language =$1;
code =$2;
colon =$3;
type_anno=$4;
rbracket =$5}
in {region; value} }
field_assignment:
field_name "=" expr {
let region = cover $1.region (expr_to_region $3)

67
src/passes/01-parser/pascaligo/ParserLog.ml
View File

@ -230,6 +230,14 @@ and print_fun_expr state {value; _} =
print_token state kwd_is "is";
print_expr state return
and print_code_insert state {value; _} =
let {language;code;colon;type_anno;rbracket} : code_insert = value in
print_string state language;
print_string state code;
print_token state colon ":";
print_type_expr state type_anno;
print_token state rbracket "]"
and print_parameters state {value; _} =
let {lpar; inside; rpar} = value in
print_token state lpar "(";
@ -439,26 +447,27 @@ and print_bind_to state = function
| None -> ()
and print_expr state = function
ECase {value;_} -> print_case_expr state value
| ECond {value;_} -> print_cond_expr state value
| EAnnot {value;_} -> print_annot_expr state value
| ELogic e -> print_logic_expr state e
| EArith e -> print_arith_expr state e
| EString e -> print_string_expr state e
| EList e -> print_list_expr state e
| ESet e -> print_set_expr state e
| EConstr e -> print_constr_expr state e
| ERecord e -> print_record_expr state e
| EUpdate e -> print_update_expr state e
| EProj e -> print_projection state e
| EMap e -> print_map_expr state e
| EVar v -> print_var state v
| ECall e -> print_fun_call state e
| EBytes b -> print_bytes state b
| EUnit r -> print_token state r "Unit"
| ETuple e -> print_tuple_expr state e
| EPar e -> print_par_expr state e
| EFun e -> print_fun_expr state e
ECase {value;_} -> print_case_expr state value
| ECond {value;_} -> print_cond_expr state value
| EAnnot {value;_} -> print_annot_expr state value
| ELogic e -> print_logic_expr state e
| EArith e -> print_arith_expr state e
| EString e -> print_string_expr state e
| EList e -> print_list_expr state e
| ESet e -> print_set_expr state e
| EConstr e -> print_constr_expr state e
| ERecord e -> print_record_expr state e
| EUpdate e -> print_update_expr state e
| EProj e -> print_projection state e
| EMap e -> print_map_expr state e
| EVar v -> print_var state v
| ECall e -> print_fun_call state e
| EBytes b -> print_bytes state b
| EUnit r -> print_token state r "Unit"
| ETuple e -> print_tuple_expr state e
| EPar e -> print_par_expr state e
| EFun e -> print_fun_expr state e
| ECodeInsert e -> print_code_insert state e
and print_annot_expr state node =
let {inside; _} : annot_expr par = node in
@ -1010,6 +1019,21 @@ and pp_fun_expr state (expr: fun_expr) =
pp_expr (state#pad 1 0) expr.return
in ()
and pp_code_insert state (rc : code_insert) =
let () =
let state = state#pad 3 0 in
pp_node state "<language>";
pp_string (state#pad 1 0) rc.language in
let () =
let state = state#pad 3 1 in
pp_node state "<code>";
pp_string (state#pad 1 0) rc.code in
let () =
let state = state#pad 3 2 in
pp_node state "<type annotation>";
pp_type_expr (state#pad 1 0) rc.type_anno
in ()
and pp_parameters state {value; _} =
let params = Utils.nsepseq_to_list value.inside in
let arity = List.length params in
@ -1491,6 +1515,9 @@ and pp_expr state = function
| EFun {value; region} ->
pp_loc_node state "EFun" region;
pp_fun_expr state value;
| ECodeInsert {value; region} ->
pp_loc_node state "ECodeInsert" region;
pp_code_insert state value;
and pp_list_expr state = function
ECons {value; region} ->

2
src/passes/01-parser/reasonligo/LexToken.mli
View File

@ -90,6 +90,7 @@ type t =
| Verbatim of string Region.reg
| Bytes of (string * Hex.t) Region.reg
| Attr of string Region.reg
| Insert of string Region.reg
(* Keywords *)
@ -153,6 +154,7 @@ val mk_string : lexeme -> Region.t -> token
val mk_verbatim : lexeme -> Region.t -> token
val mk_bytes : lexeme -> Region.t -> token
val mk_constr : lexeme -> Region.t -> token
val mk_insert : lexeme -> Region.t -> token
val eof : Region.t -> token
(* Predicates *)

8
src/passes/01-parser/reasonligo/LexToken.mll
View File

@ -76,6 +76,7 @@ type t =
| Verbatim of string Region.reg
| Bytes of (string * Hex.t) Region.reg
| Attr of string Region.reg
| Insert of string Region.reg
(* Keywords *)
@ -169,6 +170,7 @@ let proj_token = function
| C_None region -> region, "C_None"
| C_Some region -> region, "C_Some"
| Attr Region.{region; value} -> region, sprintf "Attr %s" value
| Insert Region.{region; value} -> region, sprintf "Insert %s" value
| EOF region -> region, "EOF"
let to_lexeme = function
@ -183,6 +185,7 @@ let to_lexeme = function
| Ident id -> id.Region.value
| Constr id -> id.Region.value
| Attr a -> a.Region.value
| Insert i -> i.Region.value
(* Symbols *)
@ -484,6 +487,11 @@ let mk_attr header lexeme region =
Ok (Attr Region.{value=lexeme; region})
else Error Invalid_attribute
(* Raw Code Insertion *)
let mk_insert lexeme region =
Insert Region.{value=lexeme;region}
(* Predicates *)
let is_string = function String _ -> true | _ -> false

1
src/passes/01-parser/reasonligo/ParToken.mly
View File

@ -14,6 +14,7 @@
%token <string Region.reg> Ident "<ident>"
%token <string Region.reg> Constr "<constr>"
%token <string Region.reg> Attr "<attr>"
%token <string Region.reg> Insert "<insert>"
(* Symbols *)

12
src/passes/01-parser/reasonligo/Parser.mly
View File

@ -814,6 +814,7 @@ common_expr:
| unit { EUnit $1 }
| "false" { ELogic (BoolExpr (False $1)) }
| "true" { ELogic (BoolExpr (True $1)) }
| code_insert { ECodeInsert $1 }
core_expr_2:
common_expr { $1 }
@ -919,6 +920,17 @@ update_record:
rbrace = $6}
in {region; value} }
code_insert:
Insert "<verbatim>" ":" type_expr "]" {
let region = cover $1.region $5 in
let value = {
language =$1;
code =$2;
colon =$3;
type_anno=$4;
rbracket =$5}
in {region; value} }
expr_with_let_expr:
expr
| let_expr(expr_with_let_expr) { $1 }

1
src/passes/01-parser/shared/Lexer.mli
View File

@ -79,6 +79,7 @@ module type TOKEN =
val mk_bytes : lexeme -> Region.t -> token
val mk_constr : lexeme -> Region.t -> token
val mk_attr : string -> lexeme -> Region.t -> (token, attr_err) result
val mk_insert : lexeme -> Region.t -> token
val eof : Region.t -> token
(* Predicates *)

10
src/passes/01-parser/shared/Lexer.mll
View File

@ -43,6 +43,7 @@ module type TOKEN =
val mk_bytes : lexeme -> Region.t -> token
val mk_constr : lexeme -> Region.t -> token
val mk_attr : string -> lexeme -> Region.t -> (token, attr_err) result
val mk_insert : lexeme -> Region.t -> token
val eof : Region.t -> token
(* Predicates *)
@ -268,6 +269,11 @@ module Make (Token : TOKEN) : (S with module Token = Token) =
| Error Token.Invalid_attribute ->
fail region Invalid_attribute
let mk_insert insert state buffer =
let region, _, state = state#sync buffer in
let token = Token.mk_insert insert region
in state#enqueue token
let mk_constr state buffer =
let region, lexeme, state = state#sync buffer in
let token = Token.mk_constr lexeme region
@ -314,7 +320,7 @@ let esc = "\\n" | "\\\"" | "\\\\" | "\\b"
let common_sym = ';' | ',' | '(' | ')' | '[' | ']' | '{' | '}'
| '=' | ':' | '|' | "->" | '.' | '_' | '^'
| '+' | '-' | '*' | '/' | '<' | "<=" | '>' | ">="
| '+' | '-' | '*' | '/' | '%' | '<' | "<=" | '>' | ">="
let pascaligo_sym = "=/=" | '#' | ":="
let cameligo_sym = "<>" | "::" | "||" | "&&"
let reasonligo_sym = '!' | "=>" | "!=" | "==" | "++" | "..." | "||" | "&&"
@ -353,6 +359,7 @@ let line_comments =
(* #include files *)
let string = [^'"' '\\' '\n']* (* For strings of #include *)
let insert = attr
(* RULES *)
@ -388,6 +395,7 @@ and scan state = parse
| eof { mk_eof state lexbuf }
| "[@" (attr as a) "]" { mk_attr "[@" a state lexbuf }
| "[@@" (attr as a) "]" { mk_attr "[@@" a state lexbuf }
| "[%" (insert as i) "]" { mk_insert i state lexbuf }
(* Management of #include preprocessing directives

7
src/passes/02-concrete_to_imperative/cameligo.ml
View File

@ -638,6 +638,13 @@ in trace (abstracting_expr t) @@
let%bind match_false = compile_expression c.ifnot in
return @@ e_cond ~loc expr match_true match_false
)
| ECodeInsert ci -> (
let (ci, loc) = r_split ci in
let language = ci.language.value in
let code = ci.code.value in
let%bind type_anno = compile_type_expression ci.type_anno in
return @@ e_raw_code ~loc language code type_anno
)
and compile_fun lamb' : expr result =
let return x = ok x in

7
src/passes/02-concrete_to_imperative/pascaligo.ml
View File

@ -459,6 +459,13 @@ let rec compile_expression (t:Raw.expr) : expr result =
let (f , loc) = r_split f in
let%bind (_ty_opt, f') = compile_fun_expression ~loc f
in return @@ f'
| ECodeInsert ci ->
let (ci, loc) = r_split ci in
let language = ci.language.value in
let code = ci.code.value in
let%bind type_anno = compile_type_expression ci.type_anno in
return @@ e_raw_code ~loc language code type_anno
and compile_update (u: Raw.update Region.reg) =
let u, loc = r_split u in
let name, path = compile_path u.record in

2
src/passes/04-imperative_to_sugar/imperative_to_sugar.ml
View File

@ -220,7 +220,7 @@ and compile_expression' : I.expression -> (O.expression option -> O.expression)
return @@ O.e_let_in ~loc (binder,ty_opt) false inline rhs let_result
| I.E_raw_code {language;code;type_anno} ->
let%bind type_anno = compile_type_expression type_anno in
return @@ O.E_raw_code {language;code;type_anno}
return @@ O.e_raw_code ~loc language code type_anno
| I.E_constructor {constructor;element} ->
let%bind element = compile_expression element in
return @@ O.e_constructor ~loc constructor element

2
src/passes/06-sugar_to_core/sugar_to_core.ml
View File

@ -72,7 +72,7 @@ let rec compile_expression : I.expression -> O.expression result =
let%bind let_result = compile_expression let_result in
return @@ O.E_let_in {let_binder=(binder,ty_opt);inline;rhs;let_result}
| I.E_raw_code {language;code;type_anno} ->
let%bind type_anno = idle_type_expression type_anno in
let%bind type_anno = compile_type_expression type_anno in
return @@ O.E_raw_code {language;code;type_anno}
| I.E_constructor {constructor;element} ->
let%bind element = compile_expression element in

6
src/passes/07-self_ast_core/helpers.ml
View File

@ -24,7 +24,7 @@ let rec fold_expression : 'a folder -> 'a -> expression -> 'a result = fun f ini
let self = fold_expression f in
let%bind init' = f init e in
match e.expression_content with
| E_literal _ | E_variable _ -> ok init'
| E_literal _ | E_variable _ | E_raw_code _ -> ok init'
| E_constant {arguments=lst} -> (
let%bind res = bind_fold_list self init' lst in
ok res
@ -148,7 +148,7 @@ let rec map_expression : exp_mapper -> expression -> expression result = fun f e
let%bind args = bind_map_list self c.arguments in
return @@ E_constant {c with arguments=args}
)
| E_literal _ | E_variable _ as e' -> return e'
| E_literal _ | E_variable _ | E_raw_code _ as e' -> return e'
and map_type_expression : ty_exp_mapper -> type_expression -> type_expression result = fun f ({type_content ; location ; type_meta} as te) ->
let self = map_type_expression f in
@ -262,7 +262,7 @@ let rec fold_map_expression : 'a fold_mapper -> 'a -> expression -> ('a * expres
let%bind (res,args) = bind_fold_map_list self init' c.arguments in
ok (res, return @@ E_constant {c with arguments=args})
)
| E_literal _ | E_variable _ as e' -> ok (init', return e')
| E_literal _ | E_variable _ | E_raw_code _ as e' -> ok (init', return e')
and fold_map_cases : 'a fold_mapper -> 'a -> matching_expr -> ('a * matching_expr) result = fun f init m ->
match m with

10
src/passes/08-typer-new/wrap.ml
View File

@ -309,11 +309,11 @@ let recursive : T.type_expression -> (constraints * T.type_variable) =
let raw_code : T.type_expression -> (constraints * T.type_variable) =
fun type_anno ->
let type_anno = type_expression_to_type_value type_anno in
let whole_expr = Core.fresh_type_variable () in
O.[
C_equation (type_anno, P_variable whole_expr)
], whole_expr
let type_anno = type_expression_to_type_value type_anno in
let whole_expr = Core.fresh_type_variable () in
[
c_equation type_anno (P_variable whole_expr) "wrap: raw_code: type_anno (whole)";
], whole_expr
let assign : T.type_expression -> T.type_expression -> (constraints * T.type_variable) =
fun v e ->

1
src/stages/1-ast_imperative/combinators.ml
View File

@ -115,6 +115,7 @@ let e_application ?loc a b = make_e ?loc @@ E_application {lamb=a ; args=b}
let e_lambda ?loc binder input_type output_type result : expression = make_e ?loc @@ E_lambda {binder; input_type; output_type; result}
let e_recursive ?loc fun_name fun_type lambda = make_e ?loc @@ E_recursive {fun_name; fun_type; lambda}
let e_let_in ?loc (binder, ascr) inline rhs let_result = make_e ?loc @@ E_let_in { let_binder = (binder, ascr) ; rhs ; let_result; inline }
let e_raw_code ?loc language code type_anno = make_e ?loc @@ E_raw_code {language; code; type_anno}
let e_constructor ?loc s a : expression = make_e ?loc @@ E_constructor { constructor = Constructor s; element = a}
let e_matching ?loc a b : expression = make_e ?loc @@ E_matching {matchee=a;cases=b}

1
src/stages/1-ast_imperative/combinators.mli
View File

@ -95,6 +95,7 @@ val e_application : ?loc:Location.t -> expression -> expression -> expression
val e_lambda : ?loc:Location.t -> expression_variable -> type_expression option -> type_expression option -> expression -> expression
val e_recursive : ?loc:Location.t -> expression_variable -> type_expression -> lambda -> expression
val e_let_in : ?loc:Location.t -> ( expression_variable * type_expression option ) -> bool -> expression -> expression -> expression
val e_raw_code : ?loc:Location.t -> string -> string -> type_expression -> expression
val e_constructor : ?loc:Location.t -> string -> expression -> expression
val e_matching : ?loc:Location.t -> expression -> matching_expr -> expression

1
src/stages/2-ast_sugar/combinators.ml
View File

@ -104,6 +104,7 @@ let e_lambda ?loc binder input_type output_type result : expression = make_e ?lo
let e_recursive ?loc fun_name fun_type lambda = make_e ?loc @@ E_recursive {fun_name; fun_type; lambda}
let e_let_in ?loc (binder, ascr) mut inline rhs let_result = make_e ?loc @@ E_let_in { let_binder = (binder, ascr) ; rhs ; let_result; inline; mut }
let e_raw_code ?loc language code type_anno: expression = make_e ?loc @@ E_raw_code { language; code; type_anno}
let e_constructor ?loc s a : expression = make_e ?loc @@ E_constructor { constructor = s; element = a}
let e_matching ?loc a b : expression = make_e ?loc @@ E_matching {matchee=a;cases=b}

1
src/stages/2-ast_sugar/combinators.mli
View File

@ -70,6 +70,7 @@ val e_some : ?loc:Location.t -> expression -> expression
val e_none : ?loc:Location.t -> unit -> expression
val e_variable : ?loc:Location.t -> expression_variable -> expression
val e_raw_code : ?loc:Location.t -> string -> string -> type_expression -> expression
val e_constructor : ?loc:Location.t -> constructor' -> expression -> expression
val e_constant : ?loc:Location.t -> constant' -> expression list -> expression

1
src/stages/4-ast_typed/compute_environment.ml
View File

@ -45,6 +45,7 @@ let rec expression : environment -> expression -> expression = fun env expr ->
let (lamb , args) = self_2 c.lamb c.args in
return @@ E_application { lamb ; args }
)
| E_raw_code _ -> return_id
| E_constructor c -> (
let element = self c.element in
return @@ E_constructor { c with element }

4
src/test/contracts/michelson_insertion.ligo Normal file
View File

@ -0,0 +1,4 @@
// Test michelson insertion in PascaLIGO
function michelson_add (var n : nat) : nat is
[%Michelson {| DUP;ADD |} : nat -> nat ]

4
src/test/contracts/michelson_insertion.mligo Normal file
View File

@ -0,0 +1,4 @@
// Test michelson insertion in CameLIGO
let michelson_add (n : nat) : nat =
[%Michelson {| DUP;ADD; PUSH "hello" |} : nat -> nat ]

4
src/test/contracts/michelson_insertion.religo Normal file
View File

@ -0,0 +1,4 @@
// Test michelson insertion in ReasonLIGO
let michelson_add = (n : nat) : nat =>
[%Michelson {| DUP;ADD; PUSH "hello" |} : nat => nat ]