From d417a679e60c7a5fdb025abf99fa0c92f0b62410 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gr=C3=A9goire=20Henry?= Date: Sun, 11 Feb 2018 19:17:38 +0100 Subject: [PATCH] Alpha/test: fix symbolic link --- .../test/michelson_parser/michelson_macros.ml | 889 +----------------- .../michelson_parser/michelson_macros.mli | 1 + .../michelson_parser/michelson_v1_parser.ml | 98 +- .../michelson_parser/michelson_v1_parser.mli | 1 + 4 files changed, 4 insertions(+), 985 deletions(-) mode change 100644 => 120000 src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.ml create mode 120000 src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.mli mode change 100644 => 120000 src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.ml create mode 120000 src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.mli diff --git a/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.ml b/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.ml deleted file mode 100644 index 2d4156ed7..000000000 --- a/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.ml +++ /dev/null @@ -1,888 +0,0 @@ -(**************************************************************************) -(* *) -(* Copyright (c) 2014 - 2018. *) -(* Dynamic Ledger Solutions, Inc. *) -(* *) -(* All rights reserved. No warranty, explicit or implicit, provided. *) -(* *) -(**************************************************************************) - -open Tezos_micheline -open Micheline - -type 'l node = ('l, string) Micheline.node - -type error += Unexpected_macro_annotation of string -type error += Sequence_expected of string -type error += Invalid_arity of string * int * int - -let rec check_letters str i j f = - i > j || f (String.get str i) && check_letters str (i + 1) j f - -let expand_caddadr original = - match original with - | Prim (loc, str, args, annot) -> - let len = String.length str in - if len > 3 - && String.get str 0 = 'C' - && String.get str (len - 1) = 'R' - && check_letters str 1 (len - 2) - (function 'A' | 'D' -> true | _ -> false) then - begin match args with - | [] -> ok () - | _ :: _ -> error (Invalid_arity (str, List.length args, 0)) - end >>? fun () -> - let rec parse i ?annot acc = - if i = 0 then - Seq (loc, acc, None) - else - let annot = if i = (String.length str - 2) then annot else None in - match String.get str i with - | 'A' -> parse (i - 1) (Prim (loc, "CAR", [], annot) :: acc) - | 'D' -> parse (i - 1) (Prim (loc, "CDR", [], annot) :: acc) - | _ -> assert false in - ok (Some (parse (len - 2) ?annot [])) - else - ok None - | _ -> ok None - -let expand_set_caddadr original = - match original with - | Prim (loc, str, args, annot) -> - let len = String.length str in - if len >= 7 - && String.sub str 0 5 = "SET_C" - && String.get str (len - 1) = 'R' - && check_letters str 5 (len - 2) - (function 'A' | 'D' -> true | _ -> false) then - begin match args with - | [] -> ok () - | _ :: _ -> error (Invalid_arity (str, List.length args, 0)) - end >>? fun () -> - let rec parse i acc = - if i = 4 then - acc - else - match String.get str i with - | 'A' -> - let acc = - Seq (loc, - [ Prim (loc, "DUP", [], None) ; - Prim (loc, "DIP", - [ Seq (loc, - [ Prim (loc, "CAR", [], None) ; - acc ], None) ], None) ; - Prim (loc, "CDR", [], None) ; - Prim (loc, "SWAP", [], None) ; - Prim (loc, "PAIR", [], None) ], None) in - parse (i - 1) acc - | 'D' -> - let acc = - Seq (loc, - [ Prim (loc, "DUP", [], None) ; - Prim (loc, "DIP", - [ Seq (loc, - [ Prim (loc, "CDR", [], None) ; - acc ], None) ], None) ; - Prim (loc, "CAR", [], None) ; - Prim (loc, "PAIR", [], None) ], None) in - parse (i - 1) acc - | _ -> assert false in - match String.get str (len - 2) with - | 'A' -> - let init = - Seq (loc, - [ Prim (loc, "CDR", [], None) ; - Prim (loc, "SWAP", [], annot) ; - Prim (loc, "PAIR", [], None) ], None) in - ok (Some (parse (len - 3) init)) - | 'D' -> - let init = - Seq (loc, - (Prim (loc, "CAR", [], None)) :: - (let pair = Prim (loc, "PAIR", [], None) in - match annot with - | None -> [ pair ] - | Some _ -> [ Prim (loc, "SWAP", [], annot) ; - Prim (loc, "SWAP", [], None) ; - pair]), None) in - ok (Some (parse (len - 3) init)) - | _ -> assert false - else - ok None - | _ -> ok None - -let expand_map_caddadr original = - match original with - | Prim (loc, str, args, annot) -> - let len = String.length str in - if len >= 7 - && String.sub str 0 5 = "MAP_C" - && String.get str (len - 1) = 'R' - && check_letters str 5 (len - 2) - (function 'A' | 'D' -> true | _ -> false) then - begin match annot with - | Some _ -> (error (Unexpected_macro_annotation str)) - | None -> ok () - end >>? fun () -> - begin match args with - | [ Seq _ as code ] -> ok code - | [ _ ] -> error (Sequence_expected str) - | [] | _ :: _ :: _ -> error (Invalid_arity (str, List.length args, 1)) - end >>? fun code -> - let rec parse i acc = - if i = 4 then - acc - else - match String.get str i with - | 'A' -> - let acc = - Seq (loc, - [ Prim (loc, "DUP", [], None) ; - Prim (loc, "DIP", - [ Seq (loc, - [ Prim (loc, "CAR", [], None) ; - acc ], None) ], None) ; - Prim (loc, "CDR", [], None) ; - Prim (loc, "SWAP", [], None) ; - Prim (loc, "PAIR", [], None) ], None) in - parse (i - 1) acc - | 'D' -> - let acc = - Seq (loc, - [ Prim (loc, "DUP", [], None) ; - Prim (loc, "DIP", - [ Seq (loc, - [ Prim (loc, "CDR", [], None) ; - acc ], None) ], None) ; - Prim (loc, "CAR", [], None) ; - Prim (loc, "PAIR", [], None) ], None) in - parse (i - 1) acc - | _ -> assert false in - match String.get str (len - 2) with - | 'A' -> - let init = - Seq (loc, - [ Prim (loc, "DUP", [], None) ; - Prim (loc, "CDR", [], None) ; - Prim (loc, "DIP", - [ Seq (loc, [ Prim (loc, "CAR", [], None) ; code ], None) ], None) ; - Prim (loc, "SWAP", [], None) ; - Prim (loc, "PAIR", [], None) ], None) in - ok (Some (parse (len - 3) init)) - | 'D' -> - let init = - Seq (loc, - [ Prim (loc, "DUP", [], None) ; - Prim (loc, "CDR", [], None) ; - code ; - Prim (loc, "SWAP", [], None) ; - Prim (loc, "CAR", [], None) ; - Prim (loc, "PAIR", [], None) ], None) in - ok (Some (parse (len - 3) init)) - | _ -> assert false - else - ok None - | _ -> ok None - -exception Not_a_roman - -let decimal_of_roman roman = - (* http://rosettacode.org/wiki/Roman_numerals/Decode#OCaml *) - let arabic = ref 0 in - let lastval = ref 0 in - for i = (String.length roman) - 1 downto 0 do - let n = - match roman.[i] with - | 'M' -> 1000 - | 'D' -> 500 - | 'C' -> 100 - | 'L' -> 50 - | 'X' -> 10 - | 'V' -> 5 - | 'I' -> 1 - | _ -> raise_notrace Not_a_roman - in - if Compare.Int.(n < !lastval) - then arabic := !arabic - n - else arabic := !arabic + n; - lastval := n - done; - !arabic - -let expand_dxiiivp original = - match original with - | Prim (loc, str, args, annot) -> - let len = String.length str in - if len > 3 - && String.get str 0 = 'D' - && String.get str (len - 1) = 'P' then - try - let depth = decimal_of_roman (String.sub str 1 (len - 2)) in - let rec make i acc = - if i = 0 then - acc - else - make (i - 1) - (Seq (loc, [ Prim (loc, "DIP", [ acc ], annot) ], None)) in - match args with - | [ Seq (_, _, _) as arg ] -> ok @@ Some (make depth arg) - | [ _ ] -> error (Sequence_expected str) - | [] | _ :: _ :: _ -> error (Invalid_arity (str, List.length args, 1)) - with Not_a_roman -> ok None - else ok None - | _ -> ok None - -exception Not_a_pair - -let expand_paaiair original = - match original with - | Prim (loc, str, args, annot) -> - let len = String.length str in - if len > 4 - && String.get str 0 = 'P' - && String.get str (len - 1) = 'R' - && check_letters str 1 (len - 2) - (function 'A' | 'I' -> true | _ -> false) then - try - let rec parse i acc = - if i = 0 then - acc - else if String.get str i = 'I' - && String.get str (i - 1) = 'A' then - parse (i - 2) (Prim (loc, "PAIR", [], if i = (len - 2) then annot else None) :: acc) - else if String.get str i = 'A' then - match acc with - | [] -> - raise_notrace Not_a_pair - | acc :: accs -> - parse (i - 1) - (Prim (loc, "DIP", [ Seq (loc, [ acc ], None) ], None) - :: accs) - else - raise_notrace Not_a_pair in - let expanded = parse (len - 2) [] in - begin match args with - | [] -> ok () - | _ :: _ -> error (Invalid_arity (str, List.length args, 0)) - end >>? fun () -> - ok (Some (Seq (loc, expanded, None))) - with Not_a_pair -> ok None - else - ok None - | _ -> ok None - -let expand_unpaaiair original = - match original with - | Prim (loc, str, args, None) -> - let len = String.length str in - if len >= 6 - && String.sub str 0 3 = "UNP" - && String.get str (len - 1) = 'R' - && check_letters str 3 (len - 2) - (function 'A' | 'I' -> true | _ -> false) then - try - let rec parse i acc = - if i = 2 then - match acc with - | [ Seq _ as acc ] -> acc - | _ -> Seq (loc, List.rev acc, None) - else if String.get str i = 'I' - && String.get str (i - 1) = 'A' then - parse (i - 2) - (Seq (loc, [ Prim (loc, "DUP", [], None) ; - Prim (loc, "CAR", [], None) ; - Prim (loc, "DIP", - [ Seq (loc, - [ Prim (loc, "CDR", [], None) ], - None) ], None) ], None) - :: acc) - else if String.get str i = 'A' then - match acc with - | [] -> - raise_notrace Not_a_pair - | (Seq _ as acc) :: accs -> - parse (i - 1) - (Prim (loc, "DIP", [ acc ], None) :: accs) - | acc :: accs -> - parse (i - 1) - (Prim (loc, "DIP", - [ Seq (loc, [ acc ], None) ], - None) :: accs) - else - raise_notrace Not_a_pair in - let expanded = parse (len - 2) [] in - begin match args with - | [] -> ok () - | _ :: _ -> error (Invalid_arity (str, List.length args, 0)) - end >>? fun () -> - ok (Some expanded) - with Not_a_pair -> ok None - else - ok None - | _ -> ok None - -exception Not_a_dup - -let expand_duuuuup original = - match original with - | Prim (loc, str, args, annot) -> - let len = String.length str in - if len > 3 - && String.get str 0 = 'D' - && String.get str (len - 1) = 'P' - && check_letters str 1 (len - 2) ((=) 'U') then - begin match args with - | [] -> ok () - | _ :: _ -> error (Invalid_arity (str, List.length args, 0)) - end >>? fun () -> - try - let rec parse i acc = - if i = 1 then acc - else if String.get str i = 'U' then - parse (i - 1) - (Seq (loc, [ Prim (loc, "DIP", [ acc ], None) ; - Prim (loc, "SWAP", [], None) ], None)) - else - raise_notrace Not_a_dup in - ok (Some (parse (len - 2) (Seq (loc, [ Prim (loc, "DUP", [], annot) ], None)))) - with Not_a_dup -> ok None - else - ok None - | _ -> ok None - -let expand_compare original = - let cmp loc is = - let is = - List.map (fun i -> Prim (loc, i, [], None)) is in - ok (Some (Seq (loc, is, None))) in - let ifcmp loc is l r = - let is = - List.map (fun i -> Prim (loc, i, [], None)) is @ - [ Prim (loc, "IF", [ l ; r ], None) ] in - ok (Some (Seq (loc, is, None))) in - match original with - | Prim (loc, "CMPEQ", [], None) -> - cmp loc [ "COMPARE" ; "EQ" ] - | Prim (loc, "CMPNEQ", [], None) -> - cmp loc [ "COMPARE" ; "NEQ" ] - | Prim (loc, "CMPLT", [], None) -> - cmp loc [ "COMPARE" ; "LT" ] - | Prim (loc, "CMPGT", [], None) -> - cmp loc [ "COMPARE" ; "GT" ] - | Prim (loc, "CMPLE", [], None) -> - cmp loc [ "COMPARE" ; "LE" ] - | Prim (loc, "CMPGE", [], None) -> - cmp loc [ "COMPARE" ; "GE" ] - | Prim (_, ("CMPEQ" | "CMPNEQ" | "CMPLT" - | "CMPGT" | "CMPLE" | "CMPGE" as str), args, None) -> - error (Invalid_arity (str, List.length args, 0)) - | Prim (loc, "IFCMPEQ", [ l ; r ], None) -> - ifcmp loc [ "COMPARE" ; "EQ" ] l r - | Prim (loc, "IFCMPNEQ", [ l ; r ], None) -> - ifcmp loc [ "COMPARE" ; "NEQ" ] l r - | Prim (loc, "IFCMPLT", [ l ; r ], None) -> - ifcmp loc [ "COMPARE" ; "LT" ] l r - | Prim (loc, "IFCMPGT", [ l ; r ], None) -> - ifcmp loc [ "COMPARE" ; "GT" ] l r - | Prim (loc, "IFCMPLE", [ l ; r ], None) -> - ifcmp loc [ "COMPARE" ; "LE" ] l r - | Prim (loc, "IFCMPGE", [ l ; r ], None) -> - ifcmp loc [ "COMPARE" ; "GE" ] l r - | Prim (loc, "IFEQ", [ l ; r ], None) -> - ifcmp loc [ "EQ" ] l r - | Prim (loc, "IFNEQ", [ l ; r ], None) -> - ifcmp loc [ "NEQ" ] l r - | Prim (loc, "IFLT", [ l ; r ], None) -> - ifcmp loc [ "LT" ] l r - | Prim (loc, "IFGT", [ l ; r ], None) -> - ifcmp loc [ "GT" ] l r - | Prim (loc, "IFLE", [ l ; r ], None) -> - ifcmp loc [ "LE" ] l r - | Prim (loc, "IFGE", [ l ; r ], None) -> - ifcmp loc [ "GE" ] l r - | Prim (_, ("IFCMPEQ" | "IFCMPNEQ" | "IFCMPLT" - | "IFCMPGT" | "IFCMPLE" | "IFCMPGE" - | "IFEQ" | "IFNEQ" | "IFLT" - | "IFGT" | "IFLE" | "IFGE" as str), args, None) -> - error (Invalid_arity (str, List.length args, 2)) - | Prim (_, ("IFCMPEQ" | "IFCMPNEQ" | "IFCMPLT" - | "IFCMPGT" | "IFCMPLE" | "IFCMPGE" - | "IFEQ" | "IFNEQ" | "IFLT" - | "IFGT" | "IFLE" | "IFGE" - | "CMPEQ" | "CMPNEQ" | "CMPLT" - | "CMPGT" | "CMPLE" | "CMPGE" as str), [], Some _) -> - error (Unexpected_macro_annotation str) - | _ -> ok None - -let expand_asserts original = - let fail_false loc = - [ Seq(loc, [], None) ; Seq(loc, [ Prim (loc, "FAIL", [], None) ], None) ] in - let fail_true loc = - [ Seq(loc, [ Prim (loc, "FAIL", [], None) ], None) ; Seq(loc, [], None) ] in - match original with - | Prim (loc, "ASSERT", [], None) -> - ok @@ Some (Seq (loc, [ Prim (loc, "IF", fail_false loc, None) ], None)) - | Prim (loc, "ASSERT_NONE", [], None) -> - ok @@ Some (Seq (loc, [ Prim (loc, "IF_NONE", fail_false loc, None) ], None)) - | Prim (loc, "ASSERT_SOME", [], None) -> - ok @@ Some (Seq (loc, [ Prim (loc, "IF_NONE", fail_true loc, None) ], None)) - | Prim (loc, "ASSERT_LEFT", [], None) -> - ok @@ Some (Seq (loc, [ Prim (loc, "IF_LEFT", fail_false loc, None) ], None)) - | Prim (loc, "ASSERT_RIGHT", [], None) -> - ok @@ Some (Seq (loc, [ Prim (loc, "IF_LEFT", fail_true loc, None) ], None)) - | Prim (_, ("ASSERT" | "ASSERT_NONE" | "ASSERT_SOME" - | "ASSERT_LEFT" | "ASSERT_RIGHT" as str), args, None) -> - error (Invalid_arity (str, List.length args, 0)) - | Prim (_, ("ASSERT" | "ASSERT_NONE" | "ASSERT_SOME" - | "ASSERT_LEFT" | "ASSERT_RIGHT" as str), [], Some _) -> - error (Unexpected_macro_annotation str) - | Prim (loc, s, args, annot) - when String.(length s > 7 && equal (sub s 0 7) "ASSERT_") -> - begin match args with - | [] -> ok () - | _ :: _ -> error (Invalid_arity (s, List.length args, 0)) - end >>? fun () -> - begin match annot with - | Some _ -> (error (Unexpected_macro_annotation s)) - | None -> ok () end >>? fun () -> - begin - let remaining = String.(sub s 7 ((length s) - 7)) in - let remaining_prim = Prim(loc, remaining, [], None) in - match remaining with - | "EQ" | "NEQ" | "LT" | "LE" | "GE" | "GT" -> - ok @@ Some (Seq (loc, [ remaining_prim ; - Prim (loc, "IF", fail_false loc, None) ], None)) - | _ -> - begin - expand_compare remaining_prim >|? function - | None -> None - | Some seq -> - Some (Seq (loc, [ seq ; - Prim (loc, "IF", fail_false loc, None) ], None)) - end - end - | _ -> ok None - - -let expand_if_some = function - | Prim (loc, "IF_SOME", [ right ; left ], None) -> - ok @@ Some (Seq (loc, [ Prim (loc, "IF_NONE", [ left ; right ], None) ], None)) - | Prim (_, "IF_SOME", args, None) -> - error (Invalid_arity ("IF_SOME", List.length args, 2)) - | Prim (_, "IF_SOME", [], Some _) -> - error (Unexpected_macro_annotation "IF_SOME") - | _ -> ok @@ None - -let expand_if_right = function - | Prim (loc, "IF_RIGHT", [ right ; left ], None) -> - ok @@ Some (Seq (loc, [ Prim (loc, "IF_LEFT", [ left ; right ], None) ], None)) - | Prim (_, "IF_RIGHT", args, None) -> - error (Invalid_arity ("IF_RIGHT", List.length args, 2)) - | Prim (_, "IF_RIGHT", [], Some _) -> - error (Unexpected_macro_annotation "IF_RIGHT") - | _ -> ok @@ None - -let expand original = - let rec try_expansions = function - | [] -> ok @@ original - | expander :: expanders -> - expander original >>? function - | None -> try_expansions expanders - | Some rewritten -> ok rewritten in - try_expansions - [ expand_caddadr ; - expand_set_caddadr ; - expand_map_caddadr ; - expand_dxiiivp ; - expand_paaiair ; - expand_unpaaiair ; - expand_duuuuup ; - expand_compare ; - expand_asserts ; - expand_if_some ; - expand_if_right ] - -let unexpand_caddadr expanded = - let rec rsteps acc = function - | [] -> Some acc - | Prim (_, "CAR" , [], None) :: rest -> - rsteps ("A" :: acc) rest - | Prim (_, "CDR" , [], None) :: rest -> - rsteps ("D" :: acc) rest - | _ -> None in - match expanded with - | Seq (loc, (Prim (_, "CAR" , [], None) :: _ as nodes), None) - | Seq (loc, (Prim (_, "CDR" , [], None) :: _ as nodes), None) -> - begin match rsteps [] nodes with - | Some steps -> - let name = String.concat "" ("C" :: List.rev ("R" :: steps)) in - Some (Prim (loc, name, [], None)) - | None -> None - end - | _ -> None - -let unexpand_set_caddadr expanded = - let rec steps acc = function - | Seq (loc, - [ Prim (_, "CDR", [], None) ; - Prim (_, "SWAP", [], None) ; - Prim (_, "PAIR", [], None) ], None) -> - Some (loc, "A" :: acc) - | Seq (loc, - [ Prim (_, "CAR", [], None) ; - Prim (_, "PAIR", [], None) ], None) -> - Some (loc, "D" :: acc) - | Seq (_, - [ Prim (_, "DUP", [], None) ; - Prim (_, "DIP", - [ Seq (_, - [ Prim (_, "CAR", [], None) ; - sub ], None) ], None) ; - Prim (_, "CDR", [], None) ; - Prim (_, "SWAP", [], None) ; - Prim (_, "PAIR", [], None) ], None) -> - steps ("A" :: acc) sub - | Seq (_, - [ Prim (_, "DUP", [], None) ; - Prim (_, "DIP", - [ Seq (_, - [ Prim (_, "CDR", [], None) ; - sub ], None) ], None) ; - Prim (_, "CAR", [], None) ; - Prim (_, "PAIR", [], None) ], None) -> - steps ("D" :: acc) sub - | _ -> None in - match steps [] expanded with - | Some (loc, steps) -> - let name = String.concat "" ("SET_C" :: List.rev ("R" :: steps)) in - Some (Prim (loc, name, [], None)) - | None -> None - -let unexpand_map_caddadr expanded = - let rec steps acc = function - | Seq (loc, - [ Prim (_, "DUP", [], None) ; - Prim (_, "CDR", [], None) ; - Prim (_, "SWAP", [], None) ; - Prim (_, "CAR", [], None) ; - code ; - Prim (_, "PAIR", [], None) ], None) -> - Some (loc, "A" :: acc, code) - | Seq (loc, - [ Prim (_, "DUP", [], None) ; - Prim (_, "CDR", [], None) ; - code ; - Prim (_, "SWAP", [], None) ; - Prim (_, "CAR", [], None) ; - Prim (_, "PAIR", [], None) ], None) -> - Some (loc, "D" :: acc, code) - | Seq (_, - [ Prim (_, "DUP", [], None) ; - Prim (_, "DIP", - [ Seq (_, - [ Prim (_, "CAR", [], None) ; - sub ], None) ], None) ; - Prim (_, "CDR", [], None) ; - Prim (_, "SWAP", [], None) ; - Prim (_, "PAIR", [], None) ], None) -> - steps ("A" :: acc) sub - | Seq (_, - [ Prim (_, "DUP", [], None) ; - Prim (_, "DIP", - [ Seq (_, - [ Prim (_, "CDR", [], None) ; - sub ], None) ], None) ; - Prim (_, "CAR", [], None) ; - Prim (_, "PAIR", [], None) ], None) -> - steps ("D" :: acc) sub - | _ -> None in - match steps [] expanded with - | Some (loc, steps, code) -> - let name = String.concat "" ("MAP_C" :: List.rev ("R" :: steps)) in - Some (Prim (loc, name, [ code ], None)) - | None -> None - -let roman_of_decimal decimal = - (* http://rosettacode.org/wiki/Roman_numerals/Encode#OCaml *) - let digit x y z = function - | 1 -> [ x ] - | 2 -> [ x ; x ] - | 3 -> [ x ; x ; x ] - | 4 -> [ x ; y ] - | 5 -> [ y ] - | 6 -> [ y ; x ] - | 7 -> [ y ; x ; x ] - | 8 -> [ y ; x ; x ; x ] - | 9 -> [ x ; z ] - | _ -> assert false in - let rec to_roman x = - if x = 0 then [] - else if x < 0 then - invalid_arg "Negative roman numeral" - else if x >= 1000 then - "M" :: to_roman (x - 1000) - else if x >= 100 then - digit "C" "D" "M" (x / 100) @ to_roman (x mod 100) - else if x >= 10 then - digit "X" "L" "C" (x / 10) @ to_roman (x mod 10) - else - digit "I" "V" "X" x in - String.concat "" (to_roman decimal) - -let unexpand_dxiiivp expanded = - match expanded with - | Seq (loc, - [ Prim (_, "DIP", - [ Seq (_, [ Prim (_, "DIP", [ _ ], None) ], None) as sub ], - None) ], - None) -> - let rec count acc = function - | Seq (_, [ Prim (_, "DIP", [ sub ], None) ], None) -> count (acc + 1) sub - | sub -> (acc, sub) in - let depth, sub = count 1 sub in - let name = "D" ^ roman_of_decimal depth ^ "P" in - Some (Prim (loc, name, [ sub ], None)) - | _ -> None - -let unexpand_duuuuup expanded = - let rec help expanded = - match expanded with - | Seq (loc, [ Prim (_, "DUP", [], None) ], None) -> Some (loc, 1) - | Seq (_, [ Prim (_, "DIP", [expanded'], None); - Prim (_, "SWAP", [], None) ], None) -> - begin - match help expanded' with - | None -> None - | Some (loc, n) -> Some (loc, n + 1) - end - | _ -> None - in let rec dupn = function - | 0 -> "P" - | n -> "U" ^ (dupn (n - 1)) in - match help expanded with - | None -> None - | Some (loc, n) -> Some (Prim (loc, "D" ^ (dupn n), [], None)) - -let unexpand_paaiair expanded = - match expanded with - | Seq (_, [ Prim (_, "PAIR", [], None) ], None) -> Some expanded - | Seq (loc, (_ :: _ as nodes), None) -> - let rec destruct acc = function - | [] -> Some acc - | Prim (_, "DIP", [ Seq (_, [ sub ], None) ], None) :: rest -> - destruct ("A" :: acc) (sub :: rest) - | Prim (_, "PAIR", [], None) :: rest -> - destruct ("AI" :: acc) rest - | _ -> None in - begin match destruct [] nodes with - | None -> None - | Some seq -> - let name = String.concat "" ("P" :: List.rev ("R" :: seq)) in - Some (Prim (loc, name, [], None)) - end - | _ -> None - -let unexpand_unpaaiair expanded = - match expanded with - | Seq (loc, (_ :: _ as nodes), None) -> - let rec destruct sacc acc = function - | [] -> Some acc - | Prim (_, "DIP", [ Seq (_, [ sub ], None) ], None) :: rest - | Prim (_, "DIP", [ Seq (_, _, _) as sub ], None) :: rest -> - destruct ("A" :: sacc) acc (sub :: rest) - | Seq (_, [ Prim (_, "DUP", [], None) ; - Prim (_, "CAR", [], None) ; - Prim (_, "DIP", - [ Seq (_, - [ Prim (_, "CDR", [], None) ], None) ], - None) ], None) :: rest -> - destruct [] (List.rev ("AI" :: sacc) :: acc) rest - | _ -> None in - begin match destruct [] [ [ "R" ] ] nodes with - | None -> None - | Some seq -> - let name = String.concat "" ("UNP" :: List.flatten seq) in - Some (Prim (loc, name, [], None)) - end - | _ -> None - -let unexpand_compare expanded = - match expanded with - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "EQ", [], None) ], None) -> - Some (Prim (loc, "CMPEQ", [], None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "NEQ", [], None) ], None) -> - Some (Prim (loc, "CMPNEQ", [], None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "LT", [], None) ], None) -> - Some (Prim (loc, "CMPLT", [], None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "GT", [], None) ], None) -> - Some (Prim (loc, "CMPGT", [], None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "LE", [], None) ], None) -> - Some (Prim (loc, "CMPLE", [], None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "GE", [], None) ], None) -> - Some (Prim (loc, "CMPGE", [], None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "EQ", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFCMPEQ", args, None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "NEQ", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFCMPNEQ", args, None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "LT", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFCMPLT", args, None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "GT", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFCMPGT", args, None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "LE", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFCMPLE", args, None)) - | Seq (loc, [ Prim (_, "COMPARE", [], None) ; - Prim (_, "GE", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFCMPGE", args, None)) - | Seq (loc, [ Prim (_, "EQ", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFEQ", args, None)) - | Seq (loc, [ Prim (_, "NEQ", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFNEQ", args, None)) - | Seq (loc, [ Prim (_, "LT", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFLT", args, None)) - | Seq (loc, [ Prim (_, "GT", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFGT", args, None)) - | Seq (loc, [ Prim (_, "LE", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFLE", args, None)) - | Seq (loc, [ Prim (_, "GE", [], None) ; - Prim (_, "IF", args, None) ], None) -> - Some (Prim (loc, "IFGE", args, None)) - | _ -> None - -let unexpand_asserts expanded = - match expanded with - | Seq (loc, [ Prim (_, "IF", [ Seq (_, [ ], None) ; - Seq (_, [ Prim(_, "FAIL", [], None) ], None) ], - None) ], None) -> - Some (Prim (loc, "ASSERT", [], None)) - | Seq (loc, [ Seq (_, [ Prim(_, "COMPARE", [], None) ; Prim(_, comparison, [], None) ], None) ; - Prim (_, "IF", [ Seq (_, [ ], None) ; - Seq (_, [ Prim(_, "FAIL", [], None) ], None) ], - None) ], None) -> - Some (Prim (loc, "ASSERT_CMP" ^ comparison, [], None)) - | Seq (loc, [ Prim (_, comparison, [], None) ; - Prim (_, "IF", [ Seq (_, [ ], None) ; - Seq (_, [ Prim(_, "FAIL", [], None) ], None) ], - None) ], None) -> - Some (Prim (loc, "ASSERT_" ^ comparison, [], None)) - | Seq (loc, [ Prim (_, "IF_NONE", [ Seq (_, [ ], None) ; - Seq (_, [ Prim(_, "FAIL", [], None) ], None) ], - None) ], None) -> - Some (Prim (loc, "ASSERT_NONE", [], None)) - | Seq (loc, [ Prim (_, "IF_NONE", [ Seq (_, [ Prim(_, "FAIL", [], None) ], None) ; - Seq (_, [ ], None)], - None) ], None) -> - Some (Prim (loc, "ASSERT_SOME", [], None)) - | Seq (loc, [ Prim (_, "IF_LEFT", [ Seq (_, [ ], None) ; - Seq (_, [ Prim(_, "FAIL", [], None) ], None) ], - None) ], None) -> - Some (Prim (loc, "ASSERT_LEFT", [], None)) - | Seq (loc, [ Prim (_, "IF_LEFT", [ Seq (_, [ Prim(_, "FAIL", [], None) ], None) ; - Seq (_, [ ], None) ], - None) ], None) -> - Some (Prim (loc, "ASSERT_RIGHT", [], None)) - | _ -> None - - -let unexpand_if_some = function - | Seq (loc, [ Prim (_, "IF_NONE", [ left ; right ], None) ], None) -> - Some (Prim (loc, "IF_SOME", [ right ; left ], None)) - | _ -> None - -let unexpand_if_right = function - | Seq (loc, [ Prim (_, "IF_LEFT", [ left ; right ], None) ], None) -> - Some (Prim (loc, "IF_RIGHT", [ right ; left ], None)) - | _ -> None - -let unexpand original = - let try_unexpansions unexpanders = - match - List.fold_left - (fun acc f -> - match acc with - | None -> f original - | Some rewritten -> Some rewritten) - None unexpanders with - | None -> original - | Some rewritten -> rewritten in - try_unexpansions - [ unexpand_asserts ; - unexpand_caddadr ; - unexpand_set_caddadr ; - unexpand_map_caddadr ; - unexpand_dxiiivp ; - unexpand_paaiair ; - unexpand_unpaaiair ; - unexpand_duuuuup ; - unexpand_compare ; - unexpand_if_some ; - unexpand_if_right ] - -let () = - let open Data_encoding in - register_error_kind - `Permanent - ~id:"michelson.macros.unexpected_annotation" - ~title:"Unexpected annotation" - ~description:"A macro had an annotation, but no annotation was permitted on this macro." - ~pp:(fun ppf -> - Format.fprintf ppf - "Unexpected annotation on macro %s.") - (obj1 - (req "macro_name" string)) - (function - | Unexpected_macro_annotation str -> Some str - | _ -> None) - (fun s -> Unexpected_macro_annotation s) ; - register_error_kind - `Permanent - ~id:"michelson.macros.sequence_expected" - ~title:"Macro expects a sequence" - ~description:"An macro expects a sequence, but a sequence was not provided" - ~pp:(fun ppf name -> - Format.fprintf ppf - "Macro %s expects a sequence, but did not receive one." name) - (obj1 - (req "macro_name" string)) - (function - | Sequence_expected name -> Some name - | _ -> None) - (fun name -> Sequence_expected name) ; - register_error_kind - `Permanent - ~id:"michelson.macros.bas_arity" - ~title:"Wrong number of arguments to macro" - ~description:"A wrong number of arguments was provided to a macro" - ~pp:(fun ppf (name, got, exp) -> - Format.fprintf ppf - "Macro %s expects %d arguments, was given %d." name got exp) - (obj3 - (req "macro_name" string) - (req "given_number_of_arguments" uint16) - (req "expected_number_of_arguments" uint16)) - (function - | Invalid_arity (name, got, exp) -> Some (name, got, exp) - | _ -> None) - (fun (name, got, exp) -> Invalid_arity (name, got, exp)) diff --git a/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.ml b/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.ml new file mode 120000 index 000000000..861e17bc3 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.ml @@ -0,0 +1 @@ +../../../lib_client/michelson_macros.ml \ No newline at end of file diff --git a/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.mli b/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.mli new file mode 120000 index 000000000..560f339cd --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_macros.mli @@ -0,0 +1 @@ +../../../lib_client/michelson_macros.mli \ No newline at end of file diff --git a/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.ml b/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.ml deleted file mode 100644 index 0b400adbd..000000000 --- a/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.ml +++ /dev/null @@ -1,97 +0,0 @@ -(**************************************************************************) -(* *) -(* Copyright (c) 2014 - 2018. *) -(* Dynamic Ledger Solutions, Inc. *) -(* *) -(* All rights reserved. No warranty, explicit or implicit, provided. *) -(* *) -(**************************************************************************) - -open Proto_alpha -open Tezos_micheline -open Micheline_parser -open Micheline - -type parsed = - { source : string ; - unexpanded : string canonical ; - expanded : Michelson_v1_primitives.prim canonical ; - expansion_table : (int * (Micheline_parser.location * int list)) list ; - unexpansion_table : (int * int) list } - -(* Unexpanded toplevel expression should be a sequence *) -let expand_all source ast errors = - let unexpanded, loc_table = - extract_locations ast in - let rec error_map (expanded, errors) f = function - | [] -> (List.rev expanded, List.rev errors) - | hd :: tl -> - let (new_expanded, new_errors) = f hd in - error_map - (new_expanded :: expanded, List.rev_append new_errors errors) - f tl in - let error_map = error_map ([], []) in - let rec expand expr = - match Michelson_macros.expand expr with - | Ok expanded -> - begin - match expanded with - | Seq (loc, items, annot) -> - let items, errors = error_map expand items in - (Seq (loc, items, annot), errors) - | Prim (loc, name, args, annot) -> - let args, errors = error_map expand args in - (Prim (loc, name, args, annot), errors) - | Int _ | String _ as atom -> (atom, []) end - | Error errors -> (expr, errors) in - let expanded, expansion_errors = expand (root unexpanded) in - let expanded, unexpansion_table = - extract_locations expanded in - let expansion_table = - let sorted = - List.sort (fun (_, a) (_, b) -> compare a b) unexpansion_table in - let grouped = - let rec group = function - | acc, [] -> acc - | [], (u, e) :: r -> - group ([ (e, [ u ]) ], r) - | ((pe, us) :: racc as acc), (u, e) :: r -> - if e = pe then - group (((e, u :: us) :: racc), r) - else - group (((e, [ u ]) :: acc), r) in - group ([], sorted) in - List.map2 - (fun (l, ploc) (l', elocs) -> - assert (l = l') ; - (l, (ploc, elocs))) - (List.sort compare loc_table) - (List.sort compare grouped) in - match Environment.wrap_error (Michelson_v1_primitives.prims_of_strings expanded) with - | Ok expanded -> - { source ; unexpanded ; expanded ; - expansion_table ; unexpansion_table }, - errors @ expansion_errors - | Error errs -> - { source ; unexpanded ; - expanded = Micheline.strip_locations (Seq ((), [], None)) ; - expansion_table ; unexpansion_table }, - errs @ errors @ expansion_errors - -let parse_toplevel ?check source = - let tokens, lexing_errors = Micheline_parser.tokenize source in - let asts, parsing_errors = Micheline_parser.parse_toplevel ?check tokens in - let ast = match asts with - | [ ast ] -> ast - | asts -> - let start = min_point asts and stop = max_point asts in - Seq ({ start ; stop }, asts, None) in - expand_all source ast (lexing_errors @ parsing_errors) - -let parse_expression ?check source = - let tokens, lexing_errors = Micheline_parser.tokenize source in - let ast, parsing_errors = Micheline_parser.parse_expression ?check tokens in - expand_all source ast (lexing_errors @ parsing_errors) - -let expand_all ~source ~original = - expand_all source original [] diff --git a/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.ml b/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.ml new file mode 120000 index 000000000..68138c4bc --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.ml @@ -0,0 +1 @@ +../../../lib_client/michelson_v1_parser.ml \ No newline at end of file diff --git a/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.mli b/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.mli new file mode 120000 index 000000000..fbd4c39c2 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/michelson_parser/michelson_v1_parser.mli @@ -0,0 +1 @@ +../../../lib_client/michelson_v1_parser.mli \ No newline at end of file