diff options
Diffstat (limited to 'frontend')
| -rw-r--r-- | frontend/ast.ml | 76 | ||||
| -rw-r--r-- | frontend/ast_printer.ml | 177 | ||||
| -rw-r--r-- | frontend/file_parser.ml | 19 | ||||
| -rw-r--r-- | frontend/lexer.mll | 105 | ||||
| -rw-r--r-- | frontend/parser.automaton | 1577 | ||||
| -rw-r--r-- | frontend/parser.conflicts | 32 | ||||
| -rw-r--r-- | frontend/parser.mly | 221 |
7 files changed, 2207 insertions, 0 deletions
diff --git a/frontend/ast.ml b/frontend/ast.ml new file mode 100644 index 0000000..180608c --- /dev/null +++ b/frontend/ast.ml @@ -0,0 +1,76 @@ +open Lexing + +type position = Lexing.position +let position_unknown = Lexing.dummy_pos + +type extent = position * position +let extent_unknown = (position_unknown, position_unknown) + +type 'a ext = 'a * extent + +type id = string + +type typ = + | AST_TINT + | AST_TBOOL + | AST_TREAL + +type unary_op = + | AST_UPLUS + | AST_UMINUS + | AST_NOT + | AST_PRE + +type binary_op = + | AST_PLUS + | AST_MINUS + | AST_MUL + | AST_DIV + | AST_MOD + + | AST_EQ + | AST_NE + + | AST_LT + | AST_LE + | AST_GT + | AST_GE + + | AST_AND + | AST_OR + + | AST_ARROW + +type expr = + | AST_unary of unary_op * (expr ext) + | AST_binary of binary_op * (expr ext) * (expr ext) + | AST_identifier of id ext + | AST_int_const of string ext + | AST_bool_const of bool + | AST_real_const of string ext + | AST_if of (expr ext) * (expr ext) * (expr ext) + | AST_instance of (id ext) * (expr ext list) + +type lvalue = id + +type eqn = + | AST_assign of (lvalue ext) * (expr ext) + | AST_guarantee of (id ext) * (expr ext) + | AST_assume of (id ext) * (expr ext) + (* and more : automaton, activate... *) + +type node_decl = { + name : id; + args : (bool * (id ext) * typ) list; + ret : (bool * (id ext) * typ) list; + var : (bool * (id ext) * typ) list; + body : eqn ext list; +} + +type const_decl = (id ext) * typ * (expr ext) + +type toplevel = + | AST_node_decl of node_decl ext + | AST_const_decl of const_decl ext + +type prog = toplevel list diff --git a/frontend/ast_printer.ml b/frontend/ast_printer.ml new file mode 100644 index 0000000..a02b970 --- /dev/null +++ b/frontend/ast_printer.ml @@ -0,0 +1,177 @@ +open Ast +open Lexing + + +(* Locations *) + +let string_of_position p = + Printf.sprintf "%s:%i:%i" p.pos_fname p.pos_lnum (p.pos_cnum - p.pos_bol) + +let string_of_extent (p,q) = + if p.pos_fname = q.pos_fname then + if p.pos_lnum = q.pos_lnum then + if p.pos_cnum = q.pos_cnum then + Printf.sprintf "%s:%i.%i" p.pos_fname p.pos_lnum (p.pos_cnum - p.pos_bol) + else + Printf.sprintf "%s:%i.%i-%i" p.pos_fname p.pos_lnum (p.pos_cnum - p.pos_bol) (q.pos_cnum - q.pos_bol) + else + Printf.sprintf "%s:%i.%i-%i.%i" p.pos_fname p.pos_lnum (p.pos_cnum - p.pos_bol) q.pos_lnum (q.pos_cnum - q.pos_bol) + else + Printf.sprintf "%s:%i.%i-%s:%i.%i" p.pos_fname p.pos_lnum (p.pos_cnum - p.pos_bol) q.pos_fname q.pos_lnum (q.pos_cnum - q.pos_bol) + + +(* Operators *) + +let string_of_unary_op = function + | AST_UPLUS -> "+" + | AST_UMINUS -> "-" + | AST_NOT -> "not" + | AST_PRE -> "pre" + +let string_of_binary_op = function + | AST_MUL -> "*" + | AST_DIV -> "/" + | AST_MOD -> "mod" + | AST_PLUS -> "+" + | AST_MINUS -> "-" + | AST_EQ -> "=" + | AST_NE -> "<>" + | AST_LT -> "<" + | AST_LE -> "<=" + | AST_GT -> ">" + | AST_GE -> ">=" + | AST_AND -> "and" + | AST_OR -> "or" + | AST_ARROW -> "->" + + +let binary_precedence = function + | AST_MUL| AST_DIV| AST_MOD-> 7 + | AST_PLUS | AST_MINUS -> 6 + | AST_EQ | AST_NE -> 5 + | AST_LT | AST_LE | AST_GT | AST_GE -> 4 + | AST_AND -> 3 + | AST_OR -> 2 + | AST_ARROW -> 1 + +let expr_precedence = function + | AST_unary (op, _) -> 99 + | AST_binary(op, _, _) -> binary_precedence op + | _ -> 100 + +(* utility *) + +let print_list f sep fmt l = + let rec aux = function + | [] -> () + | [a] -> f fmt a + | a::b -> f fmt a; Format.pp_print_string fmt sep; aux b + in + aux l + +(* types *) + +let string_of_typ = function + | AST_TINT -> "int" + | AST_TBOOL -> "bool" + | AST_TREAL -> "real" + +(* expressions *) + +let print_id fmt v = + Format.pp_print_string fmt v + +let rec print_expr fmt e = + match e with + + | AST_unary (op,(e1,_)) -> + Format.pp_print_string fmt (string_of_unary_op op); + if expr_precedence e1 <= expr_precedence e + then Format.fprintf fmt " (%a)" print_expr e1 + else Format.fprintf fmt " %a" print_expr e1 + + | AST_binary (op,(e1,_),(e2,_)) -> + if expr_precedence e1 < expr_precedence e + then Format.fprintf fmt "(%a) " print_expr e1 + else Format.fprintf fmt "%a " print_expr e1; + Format.pp_print_string fmt (string_of_binary_op op); + if expr_precedence e2 <= expr_precedence e + then Format.fprintf fmt " (%a)" print_expr e2 + else Format.fprintf fmt " %a" print_expr e2 + + | AST_int_const (i,_) -> Format.pp_print_string fmt i + + | AST_real_const (i,_) -> Format.pp_print_string fmt i + + | AST_bool_const b -> Format.pp_print_bool fmt b + + | AST_if((c,_), (t,_), (e,_)) -> Format.fprintf fmt + "if %a then %a else %a" + print_expr c print_expr t print_expr e + + | AST_identifier (v,_) -> print_id fmt v + + | AST_instance ((i,_),l) -> + Format.fprintf fmt "%a(%a)" + print_id i (print_list print_expr ",") (List.map fst l) + +let print_lvalue fmt v = + Format.pp_print_string fmt v + +(* equations *) + +let indent ind = ind^" " + +let rec print_eqn ind fmt = function + + | AST_assign ((v,_),(e,_)) -> + Format.fprintf fmt "%s%a = %a;@\n" + ind print_lvalue v print_expr e + | AST_assume((i, _), (e, _)) -> + Format.fprintf fmt "%sassume %s : %a;@\n" + ind i print_expr e + | AST_guarantee((i, _), (e, _)) -> + Format.fprintf fmt "%sguarantee %s : %a;@\n" + ind i print_expr e + +and print_block ind fmt b = + List.iter (fun (bb,_) -> print_eqn (indent ind) fmt bb) b + +(* declarations *) + +let print_var_decl fmt (pr, (i, _), ty) = + Format.fprintf fmt "%s%s: %s" + (if pr then "probe " else "") + i + (string_of_typ ty) + +let rec print_var_decls fmt = function + | [] -> () + | [a] -> print_var_decl fmt a + | a::r -> + print_var_decl fmt a; + Format.fprintf fmt "; "; + print_var_decls fmt r + +let print_node_decl fmt d = + Format.fprintf fmt "node %s(%a) returns(%a)@\n" + d.name + print_var_decls d.args + print_var_decls d.ret; + if d.var <> [] then + Format.fprintf fmt "var %a@\n" print_var_decls d.var; + Format.fprintf fmt "let@\n%atel@\n@\n" + (print_block "") d.body + +let print_const_decl fmt ((i, _), ty, (e, _)) = + Format.fprintf fmt + "const %s: %s = %a@\n@\n" + i (string_of_typ ty) + print_expr e + +let print_toplevel fmt = function + | AST_node_decl (n, _) -> print_node_decl fmt n + | AST_const_decl (c, _) -> print_const_decl fmt c + +let print_prog fmt p = + List.iter (print_toplevel fmt) p diff --git a/frontend/file_parser.ml b/frontend/file_parser.ml new file mode 100644 index 0000000..0e975ce --- /dev/null +++ b/frontend/file_parser.ml @@ -0,0 +1,19 @@ +open Ast +open Ast_printer +open Lexing + +let parse_file (filename : string) : prog = + let f = open_in filename in + let lex = from_channel f in + try + lex.lex_curr_p <- { lex.lex_curr_p with pos_fname = filename; }; + Parser.file Lexer.token lex + with + | Parser.Error -> + Printf.eprintf "Parse error (invalid syntax) near %s\n" + (string_of_position lex.lex_start_p); + failwith "Parse error" + | Failure "lexing: empty token" -> + Printf.eprintf "Parse error (invalid token) near %s\n" + (string_of_position lex.lex_start_p); + failwith "Parse error" diff --git a/frontend/lexer.mll b/frontend/lexer.mll new file mode 100644 index 0000000..9d6c208 --- /dev/null +++ b/frontend/lexer.mll @@ -0,0 +1,105 @@ +{ + open Lexing + open Ast + open Parser + + let kwd_table = Hashtbl.create 10 + let () = + List.iter (fun (a, b) -> Hashtbl.add kwd_table a b) + [ + "bool", BOOL; + "int", INT; + "real", REAL; + + "const", CONST; + "node", NODE; + "returns", RETURNS; + "var", VAR; + "let", LET; + "tel", TEL; + + "if", IF; + "then", THEN; + "else", ELSE; + "pre", PRE; + "not", NOT; + "and", AND; + "or", OR; + "mod", MOD; + + "true", TRUE; + "false", FALSE; + + "assume", ASSUME; + "guarantee",GUARANTEE; + "probe", PROBE; + ] + +} + + +(* special character classes *) +let space = [' ' '\t' '\r']+ +let newline = "\n" | "\r" | "\r\n" + +(* utilities *) +let digit = ['0'-'9'] +let digit_ = ['0'-'9' '_'] + +(* integers *) +let int_dec = digit digit_* +let int_bin = ("0b" | "0B") ['0'-'1'] ['0'-'1' '_']* +let int_oct = ("0o" | "0O") ['0'-'7'] ['0'-'7' '_']* +let int_hex = ("0x" | "0X") ['0'-'9' 'a'-'f' 'A'-'F'] ['0'-'9' 'a'-'f' 'A'-'F' '_']* +let const_int = int_bin | int_oct | int_dec | int_hex + +(* tokens *) +rule token = parse + +(* identifier (TOK_id) or reserved keyword *) +| ['a'-'z' 'A'-'Z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* as id +{ try Hashtbl.find kwd_table id with Not_found -> IDENT id } + +(* symbols *) +| "(" { LPAREN } +| ")" { RPAREN } +| "{" { LCURLY } +| "}" { RCURLY } +| "*" { STAR } +| "+" { PLUS } +| "-" { MINUS } +| "!" { EXCLAIM } +| "/" { DIVIDE } +| "%" { PERCENT } +| "<" { LESS } +| ">" { GREATER } +| "<=" { LESS_EQUAL } +| ">=" { GREATER_EQUAL } +| "==" { EQUAL_EQUAL } +| "<>" { DIFF } +| "&&" { AND_AND } +| "||" { BAR_BAR } +| ";" { SEMICOLON } +| ":" { COLON } +| "," { COMMA } +| "=" { EQUAL } +| "->" { ARROW } + +(* literals *) +| const_int as c { INTVAL c } + +(* spaces, comments *) +| "(*" { comment lexbuf; token lexbuf } +| "--" [^ '\n' '\r']* { token lexbuf } +| newline { new_line lexbuf; token lexbuf } +| space { token lexbuf } + +(* end of files *) +| eof { EOF } + + +(* nested comments (handled recursively) *) +and comment = parse +| "*)" { () } +| [^ '\n' '\r'] { comment lexbuf } +| newline { new_line lexbuf; comment lexbuf } diff --git a/frontend/parser.automaton b/frontend/parser.automaton new file mode 100644 index 0000000..dff892b --- /dev/null +++ b/frontend/parser.automaton @@ -0,0 +1,1577 @@ +State 0: +file' -> . file [ # ] +-- On NODE shift to state 1 +-- On CONST shift to state 103 +-- On toplevel shift to state 109 +-- On node_decl shift to state 110 +-- On list(toplevel) shift to state 113 +-- On file shift to state 115 +-- On const_decl shift to state 112 +-- On EOF reduce production list(toplevel) -> + +State 1: +node_decl -> NODE . IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody [ NODE EOF CONST ] +-- On IDENT shift to state 2 + +State 2: +node_decl -> NODE IDENT . LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody [ NODE EOF CONST ] +-- On LPAREN shift to state 3 + +State 3: +node_decl -> NODE IDENT LPAREN . vars RPAREN RETURNS vars RPAREN var_decl dbody [ NODE EOF CONST ] +-- On IDENT shift to state 4 +-- On vars shift to state 10 +-- On var shift to state 98 +-- On separated_nonempty_list(SEMICOLON,var) shift to state 101 +-- On loption(separated_nonempty_list(SEMICOLON,var)) shift to state 102 +-- On RPAREN reduce production loption(separated_nonempty_list(SEMICOLON,var)) -> + +State 4: +var -> IDENT . COLON typ [ SEMICOLON RPAREN ] +-- On COLON shift to state 5 + +State 5: +var -> IDENT COLON . typ [ SEMICOLON RPAREN ] +-- On REAL shift to state 6 +-- On INT shift to state 7 +-- On BOOL shift to state 8 +-- On typ shift to state 9 + +State 6: +typ -> REAL . [ SEMICOLON RPAREN EQUAL ] +-- On SEMICOLON reduce production typ -> REAL +-- On RPAREN reduce production typ -> REAL +-- On EQUAL reduce production typ -> REAL + +State 7: +typ -> INT . [ SEMICOLON RPAREN EQUAL ] +-- On SEMICOLON reduce production typ -> INT +-- On RPAREN reduce production typ -> INT +-- On EQUAL reduce production typ -> INT + +State 8: +typ -> BOOL . [ SEMICOLON RPAREN EQUAL ] +-- On SEMICOLON reduce production typ -> BOOL +-- On RPAREN reduce production typ -> BOOL +-- On EQUAL reduce production typ -> BOOL + +State 9: +var -> IDENT COLON typ . [ SEMICOLON RPAREN ] +-- On SEMICOLON reduce production var -> IDENT COLON typ +-- On RPAREN reduce production var -> IDENT COLON typ + +State 10: +node_decl -> NODE IDENT LPAREN vars . RPAREN RETURNS vars RPAREN var_decl dbody [ NODE EOF CONST ] +-- On RPAREN shift to state 11 + +State 11: +node_decl -> NODE IDENT LPAREN vars RPAREN . RETURNS vars RPAREN var_decl dbody [ NODE EOF CONST ] +-- On RETURNS shift to state 12 + +State 12: +node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS . vars RPAREN var_decl dbody [ NODE EOF CONST ] +-- On IDENT shift to state 4 +-- On vars shift to state 13 +-- On var shift to state 98 +-- On separated_nonempty_list(SEMICOLON,var) shift to state 101 +-- On loption(separated_nonempty_list(SEMICOLON,var)) shift to state 102 +-- On RPAREN reduce production loption(separated_nonempty_list(SEMICOLON,var)) -> + +State 13: +node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars . RPAREN var_decl dbody [ NODE EOF CONST ] +-- On RPAREN shift to state 14 + +State 14: +node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN . var_decl dbody [ NODE EOF CONST ] +-- On VAR shift to state 15 +-- On var_decl shift to state 20 +-- On LET reduce production var_decl -> +-- On IDENT reduce production var_decl -> +-- On GUARANTEE reduce production var_decl -> +-- On ASSUME reduce production var_decl -> + +State 15: +var_decl -> VAR . nonempty_list(terminated(var,SEMICOLON)) [ LET IDENT GUARANTEE ASSUME ] +-- On IDENT shift to state 4 +-- On var shift to state 16 +-- On nonempty_list(terminated(var,SEMICOLON)) shift to state 19 + +State 16: +nonempty_list(terminated(var,SEMICOLON)) -> var . SEMICOLON [ LET IDENT GUARANTEE ASSUME ] +nonempty_list(terminated(var,SEMICOLON)) -> var . SEMICOLON nonempty_list(terminated(var,SEMICOLON)) [ LET IDENT GUARANTEE ASSUME ] +-- On SEMICOLON shift to state 17 + +State 17: +nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON . [ LET IDENT GUARANTEE ASSUME ] +nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON . nonempty_list(terminated(var,SEMICOLON)) [ LET IDENT GUARANTEE ASSUME ] +-- On IDENT shift to state 4 +-- On var shift to state 16 +-- On nonempty_list(terminated(var,SEMICOLON)) shift to state 18 +-- On LET reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON +-- On IDENT reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON +-- On GUARANTEE reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON +-- On ASSUME reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON +** Conflict on IDENT + +State 18: +nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) . [ LET IDENT GUARANTEE ASSUME ] +-- On LET reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) +-- On IDENT reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) +-- On GUARANTEE reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) +-- On ASSUME reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) + +State 19: +var_decl -> VAR nonempty_list(terminated(var,SEMICOLON)) . [ LET IDENT GUARANTEE ASSUME ] +-- On LET reduce production var_decl -> VAR nonempty_list(terminated(var,SEMICOLON)) +-- On IDENT reduce production var_decl -> VAR nonempty_list(terminated(var,SEMICOLON)) +-- On GUARANTEE reduce production var_decl -> VAR nonempty_list(terminated(var,SEMICOLON)) +-- On ASSUME reduce production var_decl -> VAR nonempty_list(terminated(var,SEMICOLON)) + +State 20: +node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl . dbody [ NODE EOF CONST ] +-- On LET shift to state 21 +-- On IDENT shift to state 22 +-- On GUARANTEE shift to state 23 +-- On ASSUME shift to state 83 +-- On lvalue shift to state 89 +-- On eqn shift to state 95 +-- On dbody shift to state 97 + +State 21: +dbody -> LET . separated_nonempty_list(SEMICOLON,ext(eqn)) TEL [ NODE EOF CONST ] +-- On IDENT shift to state 22 +-- On GUARANTEE shift to state 23 +-- On ASSUME shift to state 83 +-- On separated_nonempty_list(SEMICOLON,ext(eqn)) shift to state 87 +-- On lvalue shift to state 89 +-- On eqn shift to state 92 + +State 22: +lvalue -> IDENT . [ EQUAL ] +-- On EQUAL reduce production lvalue -> IDENT + +State 23: +eqn -> GUARANTEE . IDENT COLON expr [ TEL SEMICOLON ] +-- On IDENT shift to state 24 + +State 24: +eqn -> GUARANTEE IDENT . COLON expr [ TEL SEMICOLON ] +-- On COLON shift to state 25 + +State 25: +eqn -> GUARANTEE IDENT COLON . expr [ TEL SEMICOLON ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IF shift to state 32 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On if_expr shift to state 41 +-- On expr shift to state 82 +-- On binary_expr shift to state 45 + +State 26: +primary_expr -> TRUE . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production primary_expr -> TRUE +-- On TEL reduce production primary_expr -> TRUE +-- On STAR reduce production primary_expr -> TRUE +-- On SEMICOLON reduce production primary_expr -> TRUE +-- On RPAREN reduce production primary_expr -> TRUE +-- On PLUS reduce production primary_expr -> TRUE +-- On PERCENT reduce production primary_expr -> TRUE +-- On NOT_EQUAL reduce production primary_expr -> TRUE +-- On NODE reduce production primary_expr -> TRUE +-- On MINUS reduce production primary_expr -> TRUE +-- On LESS_EQUAL reduce production primary_expr -> TRUE +-- On LESS reduce production primary_expr -> TRUE +-- On GREATER_EQUAL reduce production primary_expr -> TRUE +-- On GREATER reduce production primary_expr -> TRUE +-- On EQUAL_EQUAL reduce production primary_expr -> TRUE +-- On EOF reduce production primary_expr -> TRUE +-- On ELSE reduce production primary_expr -> TRUE +-- On DIVIDE reduce production primary_expr -> TRUE +-- On CONST reduce production primary_expr -> TRUE +-- On COMMA reduce production primary_expr -> TRUE +-- On BAR_BAR reduce production primary_expr -> TRUE +-- On AND_AND reduce production primary_expr -> TRUE + +State 27: +unary_expr -> PLUS . unary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 81 +-- On primary_expr shift to state 38 + +State 28: +unary_expr -> NOT . unary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 80 +-- On primary_expr shift to state 38 + +State 29: +unary_expr -> MINUS . unary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 79 +-- On primary_expr shift to state 38 + +State 30: +primary_expr -> LPAREN . expr RPAREN [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IF shift to state 32 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On if_expr shift to state 41 +-- On expr shift to state 77 +-- On binary_expr shift to state 45 + +State 31: +primary_expr -> INTVAL . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production primary_expr -> INTVAL +-- On TEL reduce production primary_expr -> INTVAL +-- On STAR reduce production primary_expr -> INTVAL +-- On SEMICOLON reduce production primary_expr -> INTVAL +-- On RPAREN reduce production primary_expr -> INTVAL +-- On PLUS reduce production primary_expr -> INTVAL +-- On PERCENT reduce production primary_expr -> INTVAL +-- On NOT_EQUAL reduce production primary_expr -> INTVAL +-- On NODE reduce production primary_expr -> INTVAL +-- On MINUS reduce production primary_expr -> INTVAL +-- On LESS_EQUAL reduce production primary_expr -> INTVAL +-- On LESS reduce production primary_expr -> INTVAL +-- On GREATER_EQUAL reduce production primary_expr -> INTVAL +-- On GREATER reduce production primary_expr -> INTVAL +-- On EQUAL_EQUAL reduce production primary_expr -> INTVAL +-- On EOF reduce production primary_expr -> INTVAL +-- On ELSE reduce production primary_expr -> INTVAL +-- On DIVIDE reduce production primary_expr -> INTVAL +-- On CONST reduce production primary_expr -> INTVAL +-- On COMMA reduce production primary_expr -> INTVAL +-- On BAR_BAR reduce production primary_expr -> INTVAL +-- On AND_AND reduce production primary_expr -> INTVAL + +State 32: +if_expr -> IF . expr THEN expr ELSE expr [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IF shift to state 32 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On if_expr shift to state 41 +-- On expr shift to state 72 +-- On binary_expr shift to state 45 + +State 33: +primary_expr -> IDENT . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +primary_expr -> IDENT . LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On LPAREN shift to state 34 +-- On THEN reduce production primary_expr -> IDENT +-- On TEL reduce production primary_expr -> IDENT +-- On STAR reduce production primary_expr -> IDENT +-- On SEMICOLON reduce production primary_expr -> IDENT +-- On RPAREN reduce production primary_expr -> IDENT +-- On PLUS reduce production primary_expr -> IDENT +-- On PERCENT reduce production primary_expr -> IDENT +-- On NOT_EQUAL reduce production primary_expr -> IDENT +-- On NODE reduce production primary_expr -> IDENT +-- On MINUS reduce production primary_expr -> IDENT +-- On LESS_EQUAL reduce production primary_expr -> IDENT +-- On LESS reduce production primary_expr -> IDENT +-- On GREATER_EQUAL reduce production primary_expr -> IDENT +-- On GREATER reduce production primary_expr -> IDENT +-- On EQUAL_EQUAL reduce production primary_expr -> IDENT +-- On EOF reduce production primary_expr -> IDENT +-- On ELSE reduce production primary_expr -> IDENT +-- On DIVIDE reduce production primary_expr -> IDENT +-- On CONST reduce production primary_expr -> IDENT +-- On COMMA reduce production primary_expr -> IDENT +-- On BAR_BAR reduce production primary_expr -> IDENT +-- On AND_AND reduce production primary_expr -> IDENT + +State 34: +primary_expr -> IDENT LPAREN . loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IF shift to state 32 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On separated_nonempty_list(COMMA,ext(expr)) shift to state 37 +-- On primary_expr shift to state 38 +-- On loption(separated_nonempty_list(COMMA,ext(expr))) shift to state 39 +-- On if_expr shift to state 41 +-- On expr shift to state 42 +-- On binary_expr shift to state 45 +-- On RPAREN reduce production loption(separated_nonempty_list(COMMA,ext(expr))) -> + +State 35: +primary_expr -> FALSE . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production primary_expr -> FALSE +-- On TEL reduce production primary_expr -> FALSE +-- On STAR reduce production primary_expr -> FALSE +-- On SEMICOLON reduce production primary_expr -> FALSE +-- On RPAREN reduce production primary_expr -> FALSE +-- On PLUS reduce production primary_expr -> FALSE +-- On PERCENT reduce production primary_expr -> FALSE +-- On NOT_EQUAL reduce production primary_expr -> FALSE +-- On NODE reduce production primary_expr -> FALSE +-- On MINUS reduce production primary_expr -> FALSE +-- On LESS_EQUAL reduce production primary_expr -> FALSE +-- On LESS reduce production primary_expr -> FALSE +-- On GREATER_EQUAL reduce production primary_expr -> FALSE +-- On GREATER reduce production primary_expr -> FALSE +-- On EQUAL_EQUAL reduce production primary_expr -> FALSE +-- On EOF reduce production primary_expr -> FALSE +-- On ELSE reduce production primary_expr -> FALSE +-- On DIVIDE reduce production primary_expr -> FALSE +-- On CONST reduce production primary_expr -> FALSE +-- On COMMA reduce production primary_expr -> FALSE +-- On BAR_BAR reduce production primary_expr -> FALSE +-- On AND_AND reduce production primary_expr -> FALSE + +State 36: +binary_expr -> unary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production binary_expr -> unary_expr +-- On TEL reduce production binary_expr -> unary_expr +-- On STAR reduce production binary_expr -> unary_expr +-- On SEMICOLON reduce production binary_expr -> unary_expr +-- On RPAREN reduce production binary_expr -> unary_expr +-- On PLUS reduce production binary_expr -> unary_expr +-- On PERCENT reduce production binary_expr -> unary_expr +-- On NOT_EQUAL reduce production binary_expr -> unary_expr +-- On NODE reduce production binary_expr -> unary_expr +-- On MINUS reduce production binary_expr -> unary_expr +-- On LESS_EQUAL reduce production binary_expr -> unary_expr +-- On LESS reduce production binary_expr -> unary_expr +-- On GREATER_EQUAL reduce production binary_expr -> unary_expr +-- On GREATER reduce production binary_expr -> unary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> unary_expr +-- On EOF reduce production binary_expr -> unary_expr +-- On ELSE reduce production binary_expr -> unary_expr +-- On DIVIDE reduce production binary_expr -> unary_expr +-- On CONST reduce production binary_expr -> unary_expr +-- On COMMA reduce production binary_expr -> unary_expr +-- On BAR_BAR reduce production binary_expr -> unary_expr +-- On AND_AND reduce production binary_expr -> unary_expr + +State 37: +loption(separated_nonempty_list(COMMA,ext(expr))) -> separated_nonempty_list(COMMA,ext(expr)) . [ RPAREN ] +-- On RPAREN reduce production loption(separated_nonempty_list(COMMA,ext(expr))) -> separated_nonempty_list(COMMA,ext(expr)) + +State 38: +unary_expr -> primary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production unary_expr -> primary_expr +-- On TEL reduce production unary_expr -> primary_expr +-- On STAR reduce production unary_expr -> primary_expr +-- On SEMICOLON reduce production unary_expr -> primary_expr +-- On RPAREN reduce production unary_expr -> primary_expr +-- On PLUS reduce production unary_expr -> primary_expr +-- On PERCENT reduce production unary_expr -> primary_expr +-- On NOT_EQUAL reduce production unary_expr -> primary_expr +-- On NODE reduce production unary_expr -> primary_expr +-- On MINUS reduce production unary_expr -> primary_expr +-- On LESS_EQUAL reduce production unary_expr -> primary_expr +-- On LESS reduce production unary_expr -> primary_expr +-- On GREATER_EQUAL reduce production unary_expr -> primary_expr +-- On GREATER reduce production unary_expr -> primary_expr +-- On EQUAL_EQUAL reduce production unary_expr -> primary_expr +-- On EOF reduce production unary_expr -> primary_expr +-- On ELSE reduce production unary_expr -> primary_expr +-- On DIVIDE reduce production unary_expr -> primary_expr +-- On CONST reduce production unary_expr -> primary_expr +-- On COMMA reduce production unary_expr -> primary_expr +-- On BAR_BAR reduce production unary_expr -> primary_expr +-- On AND_AND reduce production unary_expr -> primary_expr + +State 39: +primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) . RPAREN [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On RPAREN shift to state 40 + +State 40: +primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On TEL reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On STAR reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On SEMICOLON reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On RPAREN reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On PLUS reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On PERCENT reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On NOT_EQUAL reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On NODE reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On MINUS reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On LESS_EQUAL reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On LESS reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On GREATER_EQUAL reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On GREATER reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On EQUAL_EQUAL reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On EOF reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On ELSE reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On DIVIDE reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On CONST reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On COMMA reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On BAR_BAR reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN +-- On AND_AND reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN + +State 41: +expr -> if_expr . [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ] +-- On THEN reduce production expr -> if_expr +-- On TEL reduce production expr -> if_expr +-- On SEMICOLON reduce production expr -> if_expr +-- On RPAREN reduce production expr -> if_expr +-- On NODE reduce production expr -> if_expr +-- On EOF reduce production expr -> if_expr +-- On ELSE reduce production expr -> if_expr +-- On CONST reduce production expr -> if_expr +-- On COMMA reduce production expr -> if_expr + +State 42: +separated_nonempty_list(COMMA,ext(expr)) -> expr . [ RPAREN ] +separated_nonempty_list(COMMA,ext(expr)) -> expr . COMMA separated_nonempty_list(COMMA,ext(expr)) [ RPAREN ] +-- On COMMA shift to state 43 +-- On RPAREN reduce production separated_nonempty_list(COMMA,ext(expr)) -> expr + +State 43: +separated_nonempty_list(COMMA,ext(expr)) -> expr COMMA . separated_nonempty_list(COMMA,ext(expr)) [ RPAREN ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IF shift to state 32 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On separated_nonempty_list(COMMA,ext(expr)) shift to state 44 +-- On primary_expr shift to state 38 +-- On if_expr shift to state 41 +-- On expr shift to state 42 +-- On binary_expr shift to state 45 + +State 44: +separated_nonempty_list(COMMA,ext(expr)) -> expr COMMA separated_nonempty_list(COMMA,ext(expr)) . [ RPAREN ] +-- On RPAREN reduce production separated_nonempty_list(COMMA,ext(expr)) -> expr COMMA separated_nonempty_list(COMMA,ext(expr)) + +State 45: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +if_expr -> binary_expr . [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ] +-- On STAR shift to state 46 +-- On PLUS shift to state 48 +-- On PERCENT shift to state 50 +-- On NOT_EQUAL shift to state 54 +-- On MINUS shift to state 56 +-- On LESS_EQUAL shift to state 58 +-- On LESS shift to state 60 +-- On GREATER_EQUAL shift to state 62 +-- On GREATER shift to state 64 +-- On EQUAL_EQUAL shift to state 66 +-- On DIVIDE shift to state 52 +-- On BAR_BAR shift to state 68 +-- On AND_AND shift to state 70 +-- On THEN reduce production if_expr -> binary_expr +-- On TEL reduce production if_expr -> binary_expr +-- On SEMICOLON reduce production if_expr -> binary_expr +-- On RPAREN reduce production if_expr -> binary_expr +-- On NODE reduce production if_expr -> binary_expr +-- On EOF reduce production if_expr -> binary_expr +-- On ELSE reduce production if_expr -> binary_expr +-- On CONST reduce production if_expr -> binary_expr +-- On COMMA reduce production if_expr -> binary_expr + +State 46: +binary_expr -> binary_expr STAR . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 47 + +State 47: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr STAR binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production binary_expr -> binary_expr STAR binary_expr +-- On TEL reduce production binary_expr -> binary_expr STAR binary_expr +-- On STAR reduce production binary_expr -> binary_expr STAR binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr STAR binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr STAR binary_expr +-- On PLUS reduce production binary_expr -> binary_expr STAR binary_expr +-- On PERCENT reduce production binary_expr -> binary_expr STAR binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr STAR binary_expr +-- On NODE reduce production binary_expr -> binary_expr STAR binary_expr +-- On MINUS reduce production binary_expr -> binary_expr STAR binary_expr +-- On LESS_EQUAL reduce production binary_expr -> binary_expr STAR binary_expr +-- On LESS reduce production binary_expr -> binary_expr STAR binary_expr +-- On GREATER_EQUAL reduce production binary_expr -> binary_expr STAR binary_expr +-- On GREATER reduce production binary_expr -> binary_expr STAR binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr STAR binary_expr +-- On EOF reduce production binary_expr -> binary_expr STAR binary_expr +-- On ELSE reduce production binary_expr -> binary_expr STAR binary_expr +-- On DIVIDE reduce production binary_expr -> binary_expr STAR binary_expr +-- On CONST reduce production binary_expr -> binary_expr STAR binary_expr +-- On COMMA reduce production binary_expr -> binary_expr STAR binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr STAR binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr STAR binary_expr + +State 48: +binary_expr -> binary_expr PLUS . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 49 + +State 49: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr PLUS binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On STAR shift to state 46 +-- On PERCENT shift to state 50 +-- On DIVIDE shift to state 52 +-- On THEN reduce production binary_expr -> binary_expr PLUS binary_expr +-- On TEL reduce production binary_expr -> binary_expr PLUS binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr PLUS binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr PLUS binary_expr +-- On PLUS reduce production binary_expr -> binary_expr PLUS binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr PLUS binary_expr +-- On NODE reduce production binary_expr -> binary_expr PLUS binary_expr +-- On MINUS reduce production binary_expr -> binary_expr PLUS binary_expr +-- On LESS_EQUAL reduce production binary_expr -> binary_expr PLUS binary_expr +-- On LESS reduce production binary_expr -> binary_expr PLUS binary_expr +-- On GREATER_EQUAL reduce production binary_expr -> binary_expr PLUS binary_expr +-- On GREATER reduce production binary_expr -> binary_expr PLUS binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr PLUS binary_expr +-- On EOF reduce production binary_expr -> binary_expr PLUS binary_expr +-- On ELSE reduce production binary_expr -> binary_expr PLUS binary_expr +-- On CONST reduce production binary_expr -> binary_expr PLUS binary_expr +-- On COMMA reduce production binary_expr -> binary_expr PLUS binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr PLUS binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr PLUS binary_expr + +State 50: +binary_expr -> binary_expr PERCENT . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 51 + +State 51: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr PERCENT binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On TEL reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On STAR reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On PLUS reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On PERCENT reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On NODE reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On MINUS reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On LESS_EQUAL reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On LESS reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On GREATER_EQUAL reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On GREATER reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On EOF reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On ELSE reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On DIVIDE reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On CONST reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On COMMA reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr PERCENT binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr PERCENT binary_expr + +State 52: +binary_expr -> binary_expr DIVIDE . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 53 + +State 53: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr DIVIDE binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On TEL reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On STAR reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On PLUS reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On PERCENT reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On NODE reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On MINUS reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On LESS_EQUAL reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On LESS reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On GREATER_EQUAL reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On GREATER reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On EOF reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On ELSE reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On DIVIDE reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On CONST reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On COMMA reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr DIVIDE binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr DIVIDE binary_expr + +State 54: +binary_expr -> binary_expr NOT_EQUAL . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 55 + +State 55: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr NOT_EQUAL binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On STAR shift to state 46 +-- On PLUS shift to state 48 +-- On PERCENT shift to state 50 +-- On MINUS shift to state 56 +-- On LESS_EQUAL shift to state 58 +-- On LESS shift to state 60 +-- On GREATER_EQUAL shift to state 62 +-- On GREATER shift to state 64 +-- On DIVIDE shift to state 52 +-- On THEN reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On TEL reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On NODE reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On EOF reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On ELSE reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On CONST reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On COMMA reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr + +State 56: +binary_expr -> binary_expr MINUS . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 57 + +State 57: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr MINUS binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On STAR shift to state 46 +-- On PERCENT shift to state 50 +-- On DIVIDE shift to state 52 +-- On THEN reduce production binary_expr -> binary_expr MINUS binary_expr +-- On TEL reduce production binary_expr -> binary_expr MINUS binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr MINUS binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr MINUS binary_expr +-- On PLUS reduce production binary_expr -> binary_expr MINUS binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr MINUS binary_expr +-- On NODE reduce production binary_expr -> binary_expr MINUS binary_expr +-- On MINUS reduce production binary_expr -> binary_expr MINUS binary_expr +-- On LESS_EQUAL reduce production binary_expr -> binary_expr MINUS binary_expr +-- On LESS reduce production binary_expr -> binary_expr MINUS binary_expr +-- On GREATER_EQUAL reduce production binary_expr -> binary_expr MINUS binary_expr +-- On GREATER reduce production binary_expr -> binary_expr MINUS binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr MINUS binary_expr +-- On EOF reduce production binary_expr -> binary_expr MINUS binary_expr +-- On ELSE reduce production binary_expr -> binary_expr MINUS binary_expr +-- On CONST reduce production binary_expr -> binary_expr MINUS binary_expr +-- On COMMA reduce production binary_expr -> binary_expr MINUS binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr MINUS binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr MINUS binary_expr + +State 58: +binary_expr -> binary_expr LESS_EQUAL . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 59 + +State 59: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr LESS_EQUAL binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On STAR shift to state 46 +-- On PLUS shift to state 48 +-- On PERCENT shift to state 50 +-- On MINUS shift to state 56 +-- On DIVIDE shift to state 52 +-- On THEN reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On TEL reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On NODE reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On LESS_EQUAL reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On LESS reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On GREATER_EQUAL reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On GREATER reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On EOF reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On ELSE reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On CONST reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On COMMA reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr + +State 60: +binary_expr -> binary_expr LESS . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 61 + +State 61: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr LESS binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On STAR shift to state 46 +-- On PLUS shift to state 48 +-- On PERCENT shift to state 50 +-- On MINUS shift to state 56 +-- On DIVIDE shift to state 52 +-- On THEN reduce production binary_expr -> binary_expr LESS binary_expr +-- On TEL reduce production binary_expr -> binary_expr LESS binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr LESS binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr LESS binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr LESS binary_expr +-- On NODE reduce production binary_expr -> binary_expr LESS binary_expr +-- On LESS_EQUAL reduce production binary_expr -> binary_expr LESS binary_expr +-- On LESS reduce production binary_expr -> binary_expr LESS binary_expr +-- On GREATER_EQUAL reduce production binary_expr -> binary_expr LESS binary_expr +-- On GREATER reduce production binary_expr -> binary_expr LESS binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr LESS binary_expr +-- On EOF reduce production binary_expr -> binary_expr LESS binary_expr +-- On ELSE reduce production binary_expr -> binary_expr LESS binary_expr +-- On CONST reduce production binary_expr -> binary_expr LESS binary_expr +-- On COMMA reduce production binary_expr -> binary_expr LESS binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr LESS binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr LESS binary_expr + +State 62: +binary_expr -> binary_expr GREATER_EQUAL . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 63 + +State 63: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr GREATER_EQUAL binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On STAR shift to state 46 +-- On PLUS shift to state 48 +-- On PERCENT shift to state 50 +-- On MINUS shift to state 56 +-- On DIVIDE shift to state 52 +-- On THEN reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On TEL reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On NODE reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On LESS_EQUAL reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On LESS reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On GREATER_EQUAL reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On GREATER reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On EOF reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On ELSE reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On CONST reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On COMMA reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr + +State 64: +binary_expr -> binary_expr GREATER . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 65 + +State 65: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr GREATER binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On STAR shift to state 46 +-- On PLUS shift to state 48 +-- On PERCENT shift to state 50 +-- On MINUS shift to state 56 +-- On DIVIDE shift to state 52 +-- On THEN reduce production binary_expr -> binary_expr GREATER binary_expr +-- On TEL reduce production binary_expr -> binary_expr GREATER binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr GREATER binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr GREATER binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr GREATER binary_expr +-- On NODE reduce production binary_expr -> binary_expr GREATER binary_expr +-- On LESS_EQUAL reduce production binary_expr -> binary_expr GREATER binary_expr +-- On LESS reduce production binary_expr -> binary_expr GREATER binary_expr +-- On GREATER_EQUAL reduce production binary_expr -> binary_expr GREATER binary_expr +-- On GREATER reduce production binary_expr -> binary_expr GREATER binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr GREATER binary_expr +-- On EOF reduce production binary_expr -> binary_expr GREATER binary_expr +-- On ELSE reduce production binary_expr -> binary_expr GREATER binary_expr +-- On CONST reduce production binary_expr -> binary_expr GREATER binary_expr +-- On COMMA reduce production binary_expr -> binary_expr GREATER binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr GREATER binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr GREATER binary_expr + +State 66: +binary_expr -> binary_expr EQUAL_EQUAL . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 67 + +State 67: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr EQUAL_EQUAL binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On STAR shift to state 46 +-- On PLUS shift to state 48 +-- On PERCENT shift to state 50 +-- On MINUS shift to state 56 +-- On LESS_EQUAL shift to state 58 +-- On LESS shift to state 60 +-- On GREATER_EQUAL shift to state 62 +-- On GREATER shift to state 64 +-- On DIVIDE shift to state 52 +-- On THEN reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On TEL reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On NOT_EQUAL reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On NODE reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On EOF reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On ELSE reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On CONST reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On COMMA reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr + +State 68: +binary_expr -> binary_expr BAR_BAR . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 69 + +State 69: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr BAR_BAR binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On STAR shift to state 46 +-- On PLUS shift to state 48 +-- On PERCENT shift to state 50 +-- On NOT_EQUAL shift to state 54 +-- On MINUS shift to state 56 +-- On LESS_EQUAL shift to state 58 +-- On LESS shift to state 60 +-- On GREATER_EQUAL shift to state 62 +-- On GREATER shift to state 64 +-- On EQUAL_EQUAL shift to state 66 +-- On DIVIDE shift to state 52 +-- On AND_AND shift to state 70 +-- On THEN reduce production binary_expr -> binary_expr BAR_BAR binary_expr +-- On TEL reduce production binary_expr -> binary_expr BAR_BAR binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr BAR_BAR binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr BAR_BAR binary_expr +-- On NODE reduce production binary_expr -> binary_expr BAR_BAR binary_expr +-- On EOF reduce production binary_expr -> binary_expr BAR_BAR binary_expr +-- On ELSE reduce production binary_expr -> binary_expr BAR_BAR binary_expr +-- On CONST reduce production binary_expr -> binary_expr BAR_BAR binary_expr +-- On COMMA reduce production binary_expr -> binary_expr BAR_BAR binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr BAR_BAR binary_expr + +State 70: +binary_expr -> binary_expr AND_AND . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On binary_expr shift to state 71 + +State 71: +binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr AND_AND binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On STAR shift to state 46 +-- On PLUS shift to state 48 +-- On PERCENT shift to state 50 +-- On NOT_EQUAL shift to state 54 +-- On MINUS shift to state 56 +-- On LESS_EQUAL shift to state 58 +-- On LESS shift to state 60 +-- On GREATER_EQUAL shift to state 62 +-- On GREATER shift to state 64 +-- On EQUAL_EQUAL shift to state 66 +-- On DIVIDE shift to state 52 +-- On THEN reduce production binary_expr -> binary_expr AND_AND binary_expr +-- On TEL reduce production binary_expr -> binary_expr AND_AND binary_expr +-- On SEMICOLON reduce production binary_expr -> binary_expr AND_AND binary_expr +-- On RPAREN reduce production binary_expr -> binary_expr AND_AND binary_expr +-- On NODE reduce production binary_expr -> binary_expr AND_AND binary_expr +-- On EOF reduce production binary_expr -> binary_expr AND_AND binary_expr +-- On ELSE reduce production binary_expr -> binary_expr AND_AND binary_expr +-- On CONST reduce production binary_expr -> binary_expr AND_AND binary_expr +-- On COMMA reduce production binary_expr -> binary_expr AND_AND binary_expr +-- On BAR_BAR reduce production binary_expr -> binary_expr AND_AND binary_expr +-- On AND_AND reduce production binary_expr -> binary_expr AND_AND binary_expr + +State 72: +if_expr -> IF expr . THEN expr ELSE expr [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ] +-- On THEN shift to state 73 + +State 73: +if_expr -> IF expr THEN . expr ELSE expr [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IF shift to state 32 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On if_expr shift to state 41 +-- On expr shift to state 74 +-- On binary_expr shift to state 45 + +State 74: +if_expr -> IF expr THEN expr . ELSE expr [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ] +-- On ELSE shift to state 75 + +State 75: +if_expr -> IF expr THEN expr ELSE . expr [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IF shift to state 32 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On if_expr shift to state 41 +-- On expr shift to state 76 +-- On binary_expr shift to state 45 + +State 76: +if_expr -> IF expr THEN expr ELSE expr . [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ] +-- On THEN reduce production if_expr -> IF expr THEN expr ELSE expr +-- On TEL reduce production if_expr -> IF expr THEN expr ELSE expr +-- On SEMICOLON reduce production if_expr -> IF expr THEN expr ELSE expr +-- On RPAREN reduce production if_expr -> IF expr THEN expr ELSE expr +-- On NODE reduce production if_expr -> IF expr THEN expr ELSE expr +-- On EOF reduce production if_expr -> IF expr THEN expr ELSE expr +-- On ELSE reduce production if_expr -> IF expr THEN expr ELSE expr +-- On CONST reduce production if_expr -> IF expr THEN expr ELSE expr +-- On COMMA reduce production if_expr -> IF expr THEN expr ELSE expr + +State 77: +primary_expr -> LPAREN expr . RPAREN [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On RPAREN shift to state 78 + +State 78: +primary_expr -> LPAREN expr RPAREN . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production primary_expr -> LPAREN expr RPAREN +-- On TEL reduce production primary_expr -> LPAREN expr RPAREN +-- On STAR reduce production primary_expr -> LPAREN expr RPAREN +-- On SEMICOLON reduce production primary_expr -> LPAREN expr RPAREN +-- On RPAREN reduce production primary_expr -> LPAREN expr RPAREN +-- On PLUS reduce production primary_expr -> LPAREN expr RPAREN +-- On PERCENT reduce production primary_expr -> LPAREN expr RPAREN +-- On NOT_EQUAL reduce production primary_expr -> LPAREN expr RPAREN +-- On NODE reduce production primary_expr -> LPAREN expr RPAREN +-- On MINUS reduce production primary_expr -> LPAREN expr RPAREN +-- On LESS_EQUAL reduce production primary_expr -> LPAREN expr RPAREN +-- On LESS reduce production primary_expr -> LPAREN expr RPAREN +-- On GREATER_EQUAL reduce production primary_expr -> LPAREN expr RPAREN +-- On GREATER reduce production primary_expr -> LPAREN expr RPAREN +-- On EQUAL_EQUAL reduce production primary_expr -> LPAREN expr RPAREN +-- On EOF reduce production primary_expr -> LPAREN expr RPAREN +-- On ELSE reduce production primary_expr -> LPAREN expr RPAREN +-- On DIVIDE reduce production primary_expr -> LPAREN expr RPAREN +-- On CONST reduce production primary_expr -> LPAREN expr RPAREN +-- On COMMA reduce production primary_expr -> LPAREN expr RPAREN +-- On BAR_BAR reduce production primary_expr -> LPAREN expr RPAREN +-- On AND_AND reduce production primary_expr -> LPAREN expr RPAREN + +State 79: +unary_expr -> MINUS unary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production unary_expr -> MINUS unary_expr +-- On TEL reduce production unary_expr -> MINUS unary_expr +-- On STAR reduce production unary_expr -> MINUS unary_expr +-- On SEMICOLON reduce production unary_expr -> MINUS unary_expr +-- On RPAREN reduce production unary_expr -> MINUS unary_expr +-- On PLUS reduce production unary_expr -> MINUS unary_expr +-- On PERCENT reduce production unary_expr -> MINUS unary_expr +-- On NOT_EQUAL reduce production unary_expr -> MINUS unary_expr +-- On NODE reduce production unary_expr -> MINUS unary_expr +-- On MINUS reduce production unary_expr -> MINUS unary_expr +-- On LESS_EQUAL reduce production unary_expr -> MINUS unary_expr +-- On LESS reduce production unary_expr -> MINUS unary_expr +-- On GREATER_EQUAL reduce production unary_expr -> MINUS unary_expr +-- On GREATER reduce production unary_expr -> MINUS unary_expr +-- On EQUAL_EQUAL reduce production unary_expr -> MINUS unary_expr +-- On EOF reduce production unary_expr -> MINUS unary_expr +-- On ELSE reduce production unary_expr -> MINUS unary_expr +-- On DIVIDE reduce production unary_expr -> MINUS unary_expr +-- On CONST reduce production unary_expr -> MINUS unary_expr +-- On COMMA reduce production unary_expr -> MINUS unary_expr +-- On BAR_BAR reduce production unary_expr -> MINUS unary_expr +-- On AND_AND reduce production unary_expr -> MINUS unary_expr + +State 80: +unary_expr -> NOT unary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production unary_expr -> NOT unary_expr +-- On TEL reduce production unary_expr -> NOT unary_expr +-- On STAR reduce production unary_expr -> NOT unary_expr +-- On SEMICOLON reduce production unary_expr -> NOT unary_expr +-- On RPAREN reduce production unary_expr -> NOT unary_expr +-- On PLUS reduce production unary_expr -> NOT unary_expr +-- On PERCENT reduce production unary_expr -> NOT unary_expr +-- On NOT_EQUAL reduce production unary_expr -> NOT unary_expr +-- On NODE reduce production unary_expr -> NOT unary_expr +-- On MINUS reduce production unary_expr -> NOT unary_expr +-- On LESS_EQUAL reduce production unary_expr -> NOT unary_expr +-- On LESS reduce production unary_expr -> NOT unary_expr +-- On GREATER_EQUAL reduce production unary_expr -> NOT unary_expr +-- On GREATER reduce production unary_expr -> NOT unary_expr +-- On EQUAL_EQUAL reduce production unary_expr -> NOT unary_expr +-- On EOF reduce production unary_expr -> NOT unary_expr +-- On ELSE reduce production unary_expr -> NOT unary_expr +-- On DIVIDE reduce production unary_expr -> NOT unary_expr +-- On CONST reduce production unary_expr -> NOT unary_expr +-- On COMMA reduce production unary_expr -> NOT unary_expr +-- On BAR_BAR reduce production unary_expr -> NOT unary_expr +-- On AND_AND reduce production unary_expr -> NOT unary_expr + +State 81: +unary_expr -> PLUS unary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ] +-- On THEN reduce production unary_expr -> PLUS unary_expr +-- On TEL reduce production unary_expr -> PLUS unary_expr +-- On STAR reduce production unary_expr -> PLUS unary_expr +-- On SEMICOLON reduce production unary_expr -> PLUS unary_expr +-- On RPAREN reduce production unary_expr -> PLUS unary_expr +-- On PLUS reduce production unary_expr -> PLUS unary_expr +-- On PERCENT reduce production unary_expr -> PLUS unary_expr +-- On NOT_EQUAL reduce production unary_expr -> PLUS unary_expr +-- On NODE reduce production unary_expr -> PLUS unary_expr +-- On MINUS reduce production unary_expr -> PLUS unary_expr +-- On LESS_EQUAL reduce production unary_expr -> PLUS unary_expr +-- On LESS reduce production unary_expr -> PLUS unary_expr +-- On GREATER_EQUAL reduce production unary_expr -> PLUS unary_expr +-- On GREATER reduce production unary_expr -> PLUS unary_expr +-- On EQUAL_EQUAL reduce production unary_expr -> PLUS unary_expr +-- On EOF reduce production unary_expr -> PLUS unary_expr +-- On ELSE reduce production unary_expr -> PLUS unary_expr +-- On DIVIDE reduce production unary_expr -> PLUS unary_expr +-- On CONST reduce production unary_expr -> PLUS unary_expr +-- On COMMA reduce production unary_expr -> PLUS unary_expr +-- On BAR_BAR reduce production unary_expr -> PLUS unary_expr +-- On AND_AND reduce production unary_expr -> PLUS unary_expr + +State 82: +eqn -> GUARANTEE IDENT COLON expr . [ TEL SEMICOLON ] +-- On TEL reduce production eqn -> GUARANTEE IDENT COLON expr +-- On SEMICOLON reduce production eqn -> GUARANTEE IDENT COLON expr + +State 83: +eqn -> ASSUME . IDENT COLON expr [ TEL SEMICOLON ] +-- On IDENT shift to state 84 + +State 84: +eqn -> ASSUME IDENT . COLON expr [ TEL SEMICOLON ] +-- On COLON shift to state 85 + +State 85: +eqn -> ASSUME IDENT COLON . expr [ TEL SEMICOLON ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IF shift to state 32 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On if_expr shift to state 41 +-- On expr shift to state 86 +-- On binary_expr shift to state 45 + +State 86: +eqn -> ASSUME IDENT COLON expr . [ TEL SEMICOLON ] +-- On TEL reduce production eqn -> ASSUME IDENT COLON expr +-- On SEMICOLON reduce production eqn -> ASSUME IDENT COLON expr + +State 87: +dbody -> LET separated_nonempty_list(SEMICOLON,ext(eqn)) . TEL [ NODE EOF CONST ] +-- On TEL shift to state 88 + +State 88: +dbody -> LET separated_nonempty_list(SEMICOLON,ext(eqn)) TEL . [ NODE EOF CONST ] +-- On NODE reduce production dbody -> LET separated_nonempty_list(SEMICOLON,ext(eqn)) TEL +-- On EOF reduce production dbody -> LET separated_nonempty_list(SEMICOLON,ext(eqn)) TEL +-- On CONST reduce production dbody -> LET separated_nonempty_list(SEMICOLON,ext(eqn)) TEL + +State 89: +eqn -> lvalue . EQUAL expr [ TEL SEMICOLON ] +-- On EQUAL shift to state 90 + +State 90: +eqn -> lvalue EQUAL . expr [ TEL SEMICOLON ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IF shift to state 32 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On if_expr shift to state 41 +-- On expr shift to state 91 +-- On binary_expr shift to state 45 + +State 91: +eqn -> lvalue EQUAL expr . [ TEL SEMICOLON ] +-- On TEL reduce production eqn -> lvalue EQUAL expr +-- On SEMICOLON reduce production eqn -> lvalue EQUAL expr + +State 92: +separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn . [ TEL ] +separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn . SEMICOLON separated_nonempty_list(SEMICOLON,ext(eqn)) [ TEL ] +-- On SEMICOLON shift to state 93 +-- On TEL reduce production separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn + +State 93: +separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn SEMICOLON . separated_nonempty_list(SEMICOLON,ext(eqn)) [ TEL ] +-- On IDENT shift to state 22 +-- On GUARANTEE shift to state 23 +-- On ASSUME shift to state 83 +-- On separated_nonempty_list(SEMICOLON,ext(eqn)) shift to state 94 +-- On lvalue shift to state 89 +-- On eqn shift to state 92 + +State 94: +separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn SEMICOLON separated_nonempty_list(SEMICOLON,ext(eqn)) . [ TEL ] +-- On TEL reduce production separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn SEMICOLON separated_nonempty_list(SEMICOLON,ext(eqn)) + +State 95: +dbody -> eqn . SEMICOLON [ NODE EOF CONST ] +-- On SEMICOLON shift to state 96 + +State 96: +dbody -> eqn SEMICOLON . [ NODE EOF CONST ] +-- On NODE reduce production dbody -> eqn SEMICOLON +-- On EOF reduce production dbody -> eqn SEMICOLON +-- On CONST reduce production dbody -> eqn SEMICOLON + +State 97: +node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody . [ NODE EOF CONST ] +-- On NODE reduce production node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody +-- On EOF reduce production node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody +-- On CONST reduce production node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody + +State 98: +separated_nonempty_list(SEMICOLON,var) -> var . [ RPAREN ] +separated_nonempty_list(SEMICOLON,var) -> var . SEMICOLON separated_nonempty_list(SEMICOLON,var) [ RPAREN ] +-- On SEMICOLON shift to state 99 +-- On RPAREN reduce production separated_nonempty_list(SEMICOLON,var) -> var + +State 99: +separated_nonempty_list(SEMICOLON,var) -> var SEMICOLON . separated_nonempty_list(SEMICOLON,var) [ RPAREN ] +-- On IDENT shift to state 4 +-- On var shift to state 98 +-- On separated_nonempty_list(SEMICOLON,var) shift to state 100 + +State 100: +separated_nonempty_list(SEMICOLON,var) -> var SEMICOLON separated_nonempty_list(SEMICOLON,var) . [ RPAREN ] +-- On RPAREN reduce production separated_nonempty_list(SEMICOLON,var) -> var SEMICOLON separated_nonempty_list(SEMICOLON,var) + +State 101: +loption(separated_nonempty_list(SEMICOLON,var)) -> separated_nonempty_list(SEMICOLON,var) . [ RPAREN ] +-- On RPAREN reduce production loption(separated_nonempty_list(SEMICOLON,var)) -> separated_nonempty_list(SEMICOLON,var) + +State 102: +vars -> loption(separated_nonempty_list(SEMICOLON,var)) . [ RPAREN ] +-- On RPAREN reduce production vars -> loption(separated_nonempty_list(SEMICOLON,var)) + +State 103: +const_decl -> CONST . IDENT COLON typ EQUAL expr [ NODE EOF CONST ] +-- On IDENT shift to state 104 + +State 104: +const_decl -> CONST IDENT . COLON typ EQUAL expr [ NODE EOF CONST ] +-- On COLON shift to state 105 + +State 105: +const_decl -> CONST IDENT COLON . typ EQUAL expr [ NODE EOF CONST ] +-- On REAL shift to state 6 +-- On INT shift to state 7 +-- On BOOL shift to state 8 +-- On typ shift to state 106 + +State 106: +const_decl -> CONST IDENT COLON typ . EQUAL expr [ NODE EOF CONST ] +-- On EQUAL shift to state 107 + +State 107: +const_decl -> CONST IDENT COLON typ EQUAL . expr [ NODE EOF CONST ] +-- On TRUE shift to state 26 +-- On PLUS shift to state 27 +-- On NOT shift to state 28 +-- On MINUS shift to state 29 +-- On LPAREN shift to state 30 +-- On INTVAL shift to state 31 +-- On IF shift to state 32 +-- On IDENT shift to state 33 +-- On FALSE shift to state 35 +-- On unary_expr shift to state 36 +-- On primary_expr shift to state 38 +-- On if_expr shift to state 41 +-- On expr shift to state 108 +-- On binary_expr shift to state 45 + +State 108: +const_decl -> CONST IDENT COLON typ EQUAL expr . [ NODE EOF CONST ] +-- On NODE reduce production const_decl -> CONST IDENT COLON typ EQUAL expr +-- On EOF reduce production const_decl -> CONST IDENT COLON typ EQUAL expr +-- On CONST reduce production const_decl -> CONST IDENT COLON typ EQUAL expr + +State 109: +list(toplevel) -> toplevel . list(toplevel) [ EOF ] +-- On NODE shift to state 1 +-- On CONST shift to state 103 +-- On toplevel shift to state 109 +-- On node_decl shift to state 110 +-- On list(toplevel) shift to state 111 +-- On const_decl shift to state 112 +-- On EOF reduce production list(toplevel) -> + +State 110: +toplevel -> node_decl . [ NODE EOF CONST ] +-- On NODE reduce production toplevel -> node_decl +-- On EOF reduce production toplevel -> node_decl +-- On CONST reduce production toplevel -> node_decl + +State 111: +list(toplevel) -> toplevel list(toplevel) . [ EOF ] +-- On EOF reduce production list(toplevel) -> toplevel list(toplevel) + +State 112: +toplevel -> const_decl . [ NODE EOF CONST ] +-- On NODE reduce production toplevel -> const_decl +-- On EOF reduce production toplevel -> const_decl +-- On CONST reduce production toplevel -> const_decl + +State 113: +file -> list(toplevel) . EOF [ # ] +-- On EOF shift to state 114 + +State 114: +file -> list(toplevel) EOF . [ # ] +-- On # reduce production file -> list(toplevel) EOF + +State 115: +file' -> file . [ # ] +-- On # accept file + diff --git a/frontend/parser.conflicts b/frontend/parser.conflicts new file mode 100644 index 0000000..296156a --- /dev/null +++ b/frontend/parser.conflicts @@ -0,0 +1,32 @@ + +** Conflict (shift/reduce) in state 17. +** Token involved: IDENT +** This state is reached from file after reading: + +NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN VAR var SEMICOLON + +** The derivations that appear below have the following common factor: +** (The question mark symbol (?) represents the spot where the derivations begin to differ.) + +file +list(toplevel) EOF +toplevel list(toplevel) +node_decl +(?) + +** In state 17, looking ahead at IDENT, reducing production +** nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON +** is permitted because of the following sub-derivation: + +NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody // lookahead token appears because dbody can begin with IDENT + VAR nonempty_list(terminated(var,SEMICOLON)) // lookahead token is inherited + var SEMICOLON . + +** In state 17, looking ahead at IDENT, shifting is permitted +** because of the following sub-derivation: + +NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody + VAR nonempty_list(terminated(var,SEMICOLON)) + var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) + var SEMICOLON + . IDENT COLON typ diff --git a/frontend/parser.mly b/frontend/parser.mly new file mode 100644 index 0000000..9db1bd5 --- /dev/null +++ b/frontend/parser.mly @@ -0,0 +1,221 @@ +%{ +open Ast +%} + +/* tokens */ +/**********/ + +%token BOOL +%token INT +%token REAL +%token PROBE +%token TRUE +%token THEN +%token FALSE +%token IF +%token ELSE +%token NOT +%token AND +%token OR +%token MOD +%token CONST +%token NODE +%token RETURNS +%token VAR +%token LET +%token TEL +%token PRE +%token ASSUME +%token GUARANTEE + +%token LPAREN +%token RPAREN +%token LCURLY +%token RCURLY +%token STAR +%token PLUS +%token MINUS +%token EXCLAIM +%token DIVIDE +%token PERCENT +%token LESS +%token GREATER +%token LESS_EQUAL +%token GREATER_EQUAL +%token EQUAL_EQUAL +%token DIFF +%token AND_AND +%token BAR_BAR +%token SEMICOLON +%token COLON +%token COMMA +%token EQUAL +%token ARROW + +%token <string> IDENT +%token <string> INTVAL + +%token EOF + +/* priorities of binary operators (lowest to highest) */ +%left ARROW +%left OR +%left AND +%left EQUAL DIFF +%left LESS GREATER LESS_EQUAL GREATER_EQUAL +%left PLUS MINUS +%left STAR DIVIDE MOD + + +/* entry-points */ +/****************/ + +%start<Ast.toplevel list> file + + +%% + + +/* toplevel */ +/************/ + +file: t=list(toplevel) EOF { t } + +toplevel: +| d=ext(const_decl) { AST_const_decl d } +| d=ext(node_decl) { AST_node_decl d } + + +/* expressions */ +/***************/ + +primary_expr: +| LPAREN e=expr RPAREN { e } +| e=ext(IDENT) { AST_identifier e } +| e=ext(INTVAL) { AST_int_const e } +| TRUE { AST_bool_const true } +| FALSE { AST_bool_const false } +| e=ext(IDENT) LPAREN l=separated_list(COMMA,ext(expr)) RPAREN + { AST_instance (e, l) } + + +unary_expr: +| e=primary_expr { e } +| o=unary_op e=ext(unary_expr) { AST_unary (o, e) } + +%inline unary_op: +| PLUS { AST_UPLUS } +| MINUS { AST_UMINUS } +| NOT { AST_NOT } +| PRE { AST_PRE } + + +binary_expr: +| e=unary_expr { e } +| e=ext(binary_expr) o=binary_op f=ext(binary_expr) { AST_binary (o, e, f) } + +%inline binary_op: +| STAR { AST_MUL } +| DIVIDE { AST_DIV } +| MOD { AST_MOD } +| PLUS { AST_PLUS } +| MINUS { AST_MINUS } +| LESS { AST_LT } +| GREATER { AST_GT } +| LESS_EQUAL { AST_LE } +| GREATER_EQUAL { AST_GE } +| EQUAL { AST_EQ} +| DIFF { AST_NE } +| AND { AST_AND } +| OR { AST_OR } +| ARROW { AST_ARROW } + +if_expr: +| IF c=ext(expr) THEN t=ext(expr) ELSE e=ext(expr) + { AST_if(c, t, e) } +| e=binary_expr { e } + +expr: +| e=if_expr { e } + +lvalue: +| i=IDENT { i } + + +/* equations */ +/****************/ + +eqn: +| i=ext(lvalue) EQUAL e=ext(expr) + { AST_assign(i, e) } +| ASSUME i=ext(IDENT) COLON e=ext(expr) + { AST_assume(i, e) } +| GUARANTEE i=ext(IDENT) COLON e=ext(expr) + { AST_guarantee(i, e) } + +typ: +| INT { AST_TINT } +| BOOL { AST_TBOOL } +| REAL { AST_TREAL } + +dbody: +| e=ext(eqn) SEMICOLON + { [e] } +| LET l=nonempty_list(terminated(ext(eqn), SEMICOLON)) TEL + { l } + +/* declarations */ + +var: +| p=boption(PROBE) i=ext(IDENT) + { (p, i) } + +vari: +| vn=separated_list(COMMA, var) COLON t=typ + { List.map (fun (p, i) -> (p, i, t)) vn } + +vars: +| v=separated_list(SEMICOLON, vari) + { List.flatten v } + +const_decl: +| CONST i=ext(IDENT) COLON t=typ EQUAL e=ext(expr) SEMICOLON + { (i, t, e) } + +var_decl: +| VAR l=nonempty_list(terminated(vari, SEMICOLON)) + { List.flatten l } + +node_decl: +| NODE id=IDENT + LPAREN v=vars RPAREN + RETURNS LPAREN rv=vars RPAREN + e = dbody + { { name = id; + args = v; + ret = rv; + var = []; + body = e; + } } +| NODE id=IDENT + LPAREN v=vars RPAREN + RETURNS LPAREN rv=vars RPAREN + lv=var_decl + LET b=nonempty_list(terminated(ext(eqn), SEMICOLON)) TEL + { { name = id; + args = v; + ret = rv; + var = lv; + body = b; + } } + + +/* utilities */ +/*************/ + +/* adds extent information to rule */ +%inline ext(X): +| x=X { x, ($startpos, $endpos) } + + +%% |