ligo/ParToken.mly

%{
%}

(* Tokens (mirroring thise defined in module LexToken) *)

  (* Literals *)

%token           <LexToken.lexeme Region.reg> String
%token <(LexToken.lexeme * Hex.t) Region.reg> Bytes
%token   <(LexToken.lexeme * Z.t) Region.reg> Int
%token           <LexToken.lexeme Region.reg> Ident
%token           <LexToken.lexeme Region.reg> Constr

  (* Symbols *)

%token <Region.t> SEMI        (* ";"   *)
%token <Region.t> COMMA       (* ","   *)
%token <Region.t> LPAR        (* "("   *)
%token <Region.t> RPAR        (* ")"   *)
%token <Region.t> LBRACE      (* "{"   *)
%token <Region.t> RBRACE      (* "}"   *)
%token <Region.t> LBRACKET    (* "["   *)
%token <Region.t> RBRACKET    (* "]"   *)
%token <Region.t> CONS        (* "#"   *)
%token <Region.t> VBAR        (* "|"   *)
%token <Region.t> ARROW       (* "->"  *)
%token <Region.t> ASS         (* ":="  *)
%token <Region.t> EQUAL       (* "="   *)
%token <Region.t> COLON       (* ":"   *)
%token <Region.t> LT          (* "<"   *)
%token <Region.t> LEQ         (* "<="  *)
%token <Region.t> GT          (* ">"   *)
%token <Region.t> GEQ         (* ">="  *)
%token <Region.t> NEQ         (* "=/=" *)
%token <Region.t> PLUS        (* "+"   *)
%token <Region.t> MINUS       (* "-"   *)
%token <Region.t> SLASH       (* "/"   *)
%token <Region.t> TIMES       (* "*"   *)
%token <Region.t> DOT         (* "."   *)
%token <Region.t> WILD        (* "_"   *)
%token <Region.t> CAT         (* "^"   *)

  (* Keywords *)

%token <Region.t> And         (* "and"        *)
%token <Region.t> Begin       (* "begin"      *)
%token <Region.t> Block       (* "block"      *)
%token <Region.t> Case        (* "case"       *)
%token <Region.t> Const       (* "const"      *)
%token <Region.t> Contains    (* "contains"   *)
%token <Region.t> Down        (* "down"       *)
%token <Region.t> Else        (* "else"       *)
%token <Region.t> End         (* "end"        *)
%token <Region.t> Entrypoint  (* "entrypoint" *)
%token <Region.t> Fail        (* "fail"       *)
%token <Region.t> For         (* "for"        *)
%token <Region.t> Function    (* "function"   *)
%token <Region.t> From        (* "from"       *)
%token <Region.t> If          (* "if"         *)
%token <Region.t> In          (* "in"         *)
%token <Region.t> Is          (* "is"         *)
%token <Region.t> List        (* "list"       *)
%token <Region.t> Map         (* "map"        *)
%token <Region.t> Mod         (* "mod"        *)
%token <Region.t> Nil         (* "nil"        *)
%token <Region.t> Not         (* "not"        *)
%token <Region.t> Of          (* "of"         *)
%token <Region.t> Or          (* "or"         *)
%token <Region.t> Patch       (* "patch"      *)
%token <Region.t> Procedure   (* "procedure"  *)
%token <Region.t> Record      (* "record"     *)
%token <Region.t> Remove      (* "remove"     *)
%token <Region.t> Set         (* "set"        *)
%token <Region.t> Skip        (* "skip"       *)
%token <Region.t> Step        (* "step"       *)
%token <Region.t> Storage     (* "storage"    *)
%token <Region.t> Then        (* "then"       *)
%token <Region.t> To          (* "to"         *)
%token <Region.t> Type        (* "type"       *)
%token <Region.t> Var         (* "var"        *)
%token <Region.t> While       (* "while"      *)
%token <Region.t> With        (* "with"       *)

  (* Data constructors *)

%token <Region.t> C_False     (* "False" *)
%token <Region.t> C_None      (* "None"  *)
%token <Region.t> C_Some      (* "Some"  *)
%token <Region.t> C_True      (* "True"  *)
%token <Region.t> C_Unit      (* "Unit"  *)

  (* Virtual tokens *)

%token <Region.t> EOF

%%
initial commit 2019-02-26 01:29:29 +04:00			`%{`
			`%}`

			`(* Tokens (mirroring thise defined in module LexToken) *)`

			`(* Literals *)`

I removed dummy module [MBytes] an use [Hex] directly. 2019-03-20 19:31:33 +04:00			`%token <LexToken.lexeme Region.reg> String`
			`%token <(LexToken.lexeme * Hex.t) Region.reg> Bytes`
			`%token <(LexToken.lexeme * Z.t) Region.reg> Int`
			`%token <LexToken.lexeme Region.reg> Ident`
			`%token <LexToken.lexeme Region.reg> Constr`
initial commit 2019-02-26 01:29:29 +04:00
			`(* Symbols *)`

Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> SEMI (* ";" *)`
			`%token <Region.t> COMMA (* "," *)`
			`%token <Region.t> LPAR (* "(" *)`
			`%token <Region.t> RPAR (* ")" *)`
I added and alternate syntax for blocks of instructions. The syntax: block { ... } The other syntax: begin ... end This implies adding a new keyword to LIGO: "block". 2019-03-25 19:38:07 +04:00			`%token <Region.t> LBRACE (* "{" *)`
			`%token <Region.t> RBRACE (* "}" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> LBRACKET (* "[" *)`
			`%token <Region.t> RBRACKET (* "]" *)`
Storage and operations are now explicitly named. Refactoring of AST to enable the detection of incomplete pattern matchings by the OCaml compiler. Some record fields renamed for better readability. 2019-03-10 22:41:27 +04:00			`%token <Region.t> CONS (* "#" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> VBAR (* "\|" *)`
			`%token <Region.t> ARROW (* "->" *)`
I extended the grammar with optional semicolons and vertical bars. 2019-03-07 20:06:02 +04:00			`%token <Region.t> ASS (* ":=" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> EQUAL (* "=" *)`
			`%token <Region.t> COLON (* ":" *)`
			`%token <Region.t> LT (* "<" *)`
			`%token <Region.t> LEQ (* "<=" *)`
			`%token <Region.t> GT (* ">" *)`
			`%token <Region.t> GEQ (* ">=" *)`
			`%token <Region.t> NEQ (* "=/=" *)`
			`%token <Region.t> PLUS (* "+" *)`
			`%token <Region.t> MINUS (* "-" *)`
			`%token <Region.t> SLASH (* "/" *)`
			`%token <Region.t> TIMES (* "" )`
			`%token <Region.t> DOT (* "." *)`
			`%token <Region.t> WILD (* "_" *)`
			`%token <Region.t> CAT (* "^" *)`
initial commit 2019-02-26 01:29:29 +04:00
			`(* Keywords *)`

Changed "\|\|" -> "or" and "&&" -> "and" to be more Pascal-like. 2019-03-20 15:28:25 +04:00			`%token <Region.t> And (* "and" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> Begin (* "begin" *)`
I added and alternate syntax for blocks of instructions. The syntax: block { ... } The other syntax: begin ... end This implies adding a new keyword to LIGO: "block". 2019-03-25 19:38:07 +04:00			`%token <Region.t> Block (* "block" *)`
Changed "match ... with ..." to "case ... of ..." 2019-03-19 14:46:30 +04:00			`%token <Region.t> Case (* "case" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> Const (* "const" *)`
I added support for set membership. Syntax: if s contains e then ... else (only as a test expression in conditionals). 2019-03-22 02:45:19 +04:00			`%token <Region.t> Contains (* "contains" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> Down (* "down" *)`
Support for empty sets and maps. Alternate syntax for maps and lists: sets, maps and lists are now homogeneous. Lists by extension now require the "list" keyword, like sets and maps. Semicolons needed, instead of commas. New syntax for lists: `list [e_1; e_2; ...; e_n]`. The empty list can now be denoted either by `list []` or `list end` or `nil'. Both `list` and `nil` are new keywords. Lists can also be denoted without brackets, as sets and maps: `list e_1; e_2; ...; e_n end`. The extension for maps follows the extension for sets: `map [b_1; b_2; ...; b_n]` or `maps b_1; ...; b_n end`. 2019-03-26 13:31:55 +04:00			`%token <Region.t> Else (* "else" *)`
			`%token <Region.t> End (* "end" *)`
			`%token <Region.t> Entrypoint (* "entrypoint" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> Fail (* "fail" *)`
Support for empty sets and maps. Alternate syntax for maps and lists: sets, maps and lists are now homogeneous. Lists by extension now require the "list" keyword, like sets and maps. Semicolons needed, instead of commas. New syntax for lists: `list [e_1; e_2; ...; e_n]`. The empty list can now be denoted either by `list []` or `list end` or `nil'. Both `list` and `nil` are new keywords. Lists can also be denoted without brackets, as sets and maps: `list e_1; e_2; ...; e_n end`. The extension for maps follows the extension for sets: `map [b_1; b_2; ...; b_n]` or `maps b_1; ...; b_n end`. 2019-03-26 13:31:55 +04:00			`%token <Region.t> For (* "for" *)`
			`%token <Region.t> Function (* "function" *)`
Added construct `remove k from map m`. 2019-03-22 00:55:59 +04:00			`%token <Region.t> From (* "from" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> If (* "if" *)`
			`%token <Region.t> In (* "in" *)`
			`%token <Region.t> Is (* "is" *)`
Support for empty sets and maps. Alternate syntax for maps and lists: sets, maps and lists are now homogeneous. Lists by extension now require the "list" keyword, like sets and maps. Semicolons needed, instead of commas. New syntax for lists: `list [e_1; e_2; ...; e_n]`. The empty list can now be denoted either by `list []` or `list end` or `nil'. Both `list` and `nil` are new keywords. Lists can also be denoted without brackets, as sets and maps: `list e_1; e_2; ...; e_n end`. The extension for maps follows the extension for sets: `map [b_1; b_2; ...; b_n]` or `maps b_1; ...; b_n end`. 2019-03-26 13:31:55 +04:00			`%token <Region.t> List (* "list" *)`
			`%token <Region.t> Map (* "map" *)`
			`%token <Region.t> Mod (* "mod" *)`
			`%token <Region.t> Nil (* "nil" *)`
			`%token <Region.t> Not (* "not" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> Of (* "of" *)`
Changed "\|\|" -> "or" and "&&" -> "and" to be more Pascal-like. 2019-03-20 15:28:25 +04:00			`%token <Region.t> Or (* "or" *)`
Replaced expression "copy ... with ..." by instruction "patch ... with". 2019-03-19 17:32:43 +04:00			`%token <Region.t> Patch (* "patch" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> Procedure (* "procedure" *)`
			`%token <Region.t> Record (* "record" *)`
Added construct `remove k from map m`. 2019-03-22 00:55:59 +04:00			`%token <Region.t> Remove (* "remove" *)`
I added set definitions by extension. For example: const bar : set (int) = set 1; 1+1; f(3); end 2019-03-22 01:55:08 +04:00			`%token <Region.t> Set (* "set" *)`
Changed "do nothing" to "skip". 2019-03-18 21:09:15 +04:00			`%token <Region.t> Skip (* "skip" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> Step (* "step" *)`
Added keyword "storage" as parameter kind (with "var" and "const") for entrypoints. 2019-03-14 21:17:19 +04:00			`%token <Region.t> Storage (* "storage" *)`
Support for empty sets and maps. Alternate syntax for maps and lists: sets, maps and lists are now homogeneous. Lists by extension now require the "list" keyword, like sets and maps. Semicolons needed, instead of commas. New syntax for lists: `list [e_1; e_2; ...; e_n]`. The empty list can now be denoted either by `list []` or `list end` or `nil'. Both `list` and `nil` are new keywords. Lists can also be denoted without brackets, as sets and maps: `list e_1; e_2; ...; e_n end`. The extension for maps follows the extension for sets: `map [b_1; b_2; ...; b_n]` or `maps b_1; ...; b_n end`. 2019-03-26 13:31:55 +04:00			`%token <Region.t> Then (* "then" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> To (* "to" *)`
Support for empty sets and maps. Alternate syntax for maps and lists: sets, maps and lists are now homogeneous. Lists by extension now require the "list" keyword, like sets and maps. Semicolons needed, instead of commas. New syntax for lists: `list [e_1; e_2; ...; e_n]`. The empty list can now be denoted either by `list []` or `list end` or `nil'. Both `list` and `nil` are new keywords. Lists can also be denoted without brackets, as sets and maps: `list e_1; e_2; ...; e_n end`. The extension for maps follows the extension for sets: `map [b_1; b_2; ...; b_n]` or `maps b_1; ...; b_n end`. 2019-03-26 13:31:55 +04:00			`%token <Region.t> Type (* "type" *)`
			`%token <Region.t> Var (* "var" *)`
Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> While (* "while" *)`
			`%token <Region.t> With (* "with" *)`
initial commit 2019-02-26 01:29:29 +04:00
			`(* Data constructors *)`

Added instruction 'fail'. I changed the grammar and AST for local functions and removed global mutable variables. 2019-02-28 18:46:34 +04:00			`%token <Region.t> C_False (* "False" *)`
			`%token <Region.t> C_None (* "None" *)`
			`%token <Region.t> C_Some (* "Some" *)`
			`%token <Region.t> C_True (* "True" *)`
			`%token <Region.t> C_Unit (* "Unit" *)`
initial commit 2019-02-26 01:29:29 +04:00
			`(* Virtual tokens *)`

			`%token <Region.t> EOF`

			`%%`