tokens.cup

import java_cup.runtime.*;

terminal READ;
terminal PRINT;
terminal PRINTLINE;
terminal TIMES;
terminal DOUBLE_PLUS;
terminal DOUBLE_MINUS;
terminal PLUS;
terminal MINUS;
terminal DIVIDE;
terminal SEMI;
terminal ASSMNT;
terminal CLASS;
terminal DOUBLE_AND;
terminal DOUBLE_OR;
terminal ELSE;
terminal IF;
terminal WHILE;
terminal RETURN;
terminal VOID;
terminal LEFT_PARENTHESIS;
terminal RIGHT_PARENTHESIS;
terminal LEFT_SQUARE_PARENTHESIS;
terminal RIGHT_SQUARE_PARENTHESIS;
terminal LEFT_BRACKET;
terminal RIGHT_BRACKET;
terminal LESS_THAN;
terminal GREATER_THAN;
terminal LESS_THAN_OR_EQUAL_TO;
terminal GREATER_THAN_OR_EQUAL_TO;
terminal EQUAL_TO;
terminal NOT_EQUAL_TO;
terminal NOT;
terminal UPLUS;
terminal UMINUS;
terminal TERNARY_IF;
terminal TERNARY_ELSE;
terminal PARAMETER_SEPARATOR;
terminal FINAL;
terminal INT_PRIMITIVE;
terminal CHAR_PRIMITIVE;
terminal BOOL_PRIMITIVE;
terminal FLOAT_PRIMITIVE;

terminal String VAR;

terminal String ID;
terminal int INTLIT;
terminal String CHARLIT;
terminal String STRLIT;
terminal double FLOATLIT;
terminal boolean BOOL_TRUE;
terminal boolean BOOL_FALSE;

nonterminal tokens.Program program;

nonterminal tokens.MemberDecls memberdecls;
nonterminal tokens.fields.FieldDecls fielddecls;
nonterminal tokens.methods.MethodDecls methoddecls;
nonterminal tokens.methods.args.argdecls.ArgDecls argdecls;
nonterminal tokens.stmts.Stmts stmts;
nonterminal tokens.methods.args.Args args;
nonterminal tokens.methods.args.ReadList readlist;
nonterminal tokens.methods.args.PrintList printlist;
nonterminal tokens.methods.args.PrintLineList printlinelist;

nonterminal tokens.methods.args.argdecls.ArgDeclList argdecllist;

nonterminal tokens.fields.FieldDecl fielddecl;
nonterminal tokens.methods.MethodDecl methoddecl;
nonterminal tokens.methods.args.argdecls.ArgDecl argdecl;
nonterminal tokens.stmts.Stmt stmt;

nonterminal tokens.expr.OptionalExpr optionalexpr;
nonterminal tokens.lexeme.OptionalLexeme optionalsemi;

nonterminal tokens.methods.ReturnType returntype;
nonterminal tokens.lexeme.Type type;

nonterminal tokens.id.Name name;
nonterminal tokens.expr.Expr expr;
nonterminal tokens.expr.BinaryOp binaryop;
nonterminal tokens.id.TypeId typeid;

precedence right ASSMNT;
precedence right TERNARY_IF, TERNARY_ELSE;
precedence left DOUBLE_OR;
precedence left DOUBLE_AND;
precedence left EQUAL_TO, NOT_EQUAL_TO;
precedence nonassoc LESS_THAN, LESS_THAN_OR_EQUAL_TO, GREATER_THAN, GREATER_THAN_OR_EQUAL_TO;
precedence left PLUS, MINUS;
precedence left TIMES, DIVIDE;
precedence right NOT, UPLUS, UMINUS;
precedence nonassoc DOUBLE_PLUS, DOUBLE_MINUS;
precedence left LEFT_SQUARE_PARENTHESIS, RIGHT_SQUARE_PARENTHESIS, LEFT_PARENTHESIS, RIGHT_PARENTHESIS;
precedence left ELSE;

program         ::= CLASS ID:id LEFT_BRACKET memberdecls:memberDecls RIGHT_BRACKET
                {:
                    RESULT = tokens.Program.builder()
                                .id(id)
                                .memberDecls(memberDecls)
                                .build();
                :};

memberdecls     ::= fielddecls:fieldDecls methoddecls:methodDecls
                {:
                    RESULT = tokens.MemberDecls.builder()
                                .fieldDecls(fieldDecls)
                                .methodDecls(methodDecls)
                                .build();
                :}
                |   fielddecls:fieldDecls
                {:
                    RESULT = tokens.MemberDecls.builder()
                                .fieldDecls(fieldDecls)
                                .build();
                :}
                |   methoddecls:methodDecls
                {:
                    RESULT = tokens.MemberDecls.builder()
                                .methodDecls(methodDecls)
                                .build();
                :}
                |
                {:
                    RESULT = tokens.MemberDecls.builder().build();
                :};

fielddecls      ::= fielddecls:fieldDecls fielddecl:fieldDecl
                {:
                    RESULT = tokens.fields.FieldDecls.builder()
                                .fieldDecl(fieldDecl)
                                .fieldDecls(fieldDecls)
                                .build();
                :}
                |   fielddecl:fieldDecl
                {:
                    RESULT = tokens.fields.FieldDecls.builder()
                                .fieldDecl(fieldDecl)
                                .build();
                :};

methoddecls     ::= methoddecls:methodDecls methoddecl:methodDecl
                {:
                    RESULT = tokens.methods.MethodDecls.builder()
                                .methodDecl(methodDecl)
                                .methodDecls(methodDecls)
                                .build();
                :}
                | methoddecl:methodDecl
                {:
                    RESULT = tokens.methods.MethodDecls.builder()
                                .methodDecl(methodDecl)
                                .build();
                :};

fielddecl       ::= FINAL typeid:typeId optionalexpr:optionalExpr SEMI
                {:
                    RESULT = tokens.fields.ExpressionFieldDecl.builder()
                                .type(typeId.getType())
                                .id(typeId.getId())
                                .optionalFinal(tokens.lexeme.OptionalLexeme.shown(tokens.lexeme.Lexeme.of("final")))
                                .optionalExpr(optionalExpr)
                                .build();
                :}
                |   typeid:typeId optionalexpr:optionalExpr SEMI
                {:
                    RESULT = tokens.fields.ExpressionFieldDecl.builder()
                                .type(typeId.getType())
                                .id(typeId.getId())
                                .optionalFinal(tokens.lexeme.OptionalLexeme.hidden())
                                .optionalExpr(optionalExpr)
                                .build();
                :}
                |   typeid:typeId LEFT_SQUARE_PARENTHESIS INTLIT:size RIGHT_SQUARE_PARENTHESIS SEMI
                {:
                    RESULT = tokens.fields.ArrayFieldDecl.builder()
                                .type(typeId.getType())
                                .id(typeId.getId())
                                .size(size)
                                .build();
                :};

optionalexpr    ::= ASSMNT expr:expr
                {:
                    RESULT = tokens.expr.OptionalExpr.shownExpr(expr);
                :}
                |
                {:
                    RESULT = tokens.expr.OptionalExpr.hidden();
                :};

methoddecl      ::= typeid:typeId LEFT_PARENTHESIS argdecllist:argDeclList RIGHT_PARENTHESIS LEFT_BRACKET
                    fielddecls:fieldDecls stmts:stmts RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withType(typeId.getType()))
                                .id(typeId.getId())
                                .argDeclList(argDeclList)
                                .fieldDecls(fieldDecls)
                                .stmts(stmts)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   typeid:typeId LEFT_PARENTHESIS argdecllist:argDeclList RIGHT_PARENTHESIS LEFT_BRACKET
                    fielddecls:fieldDecls RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withType(typeId.getType()))
                                .id(typeId.getId())
                                .argDeclList(argDeclList)
                                .fieldDecls(fieldDecls)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   VOID ID:id LEFT_PARENTHESIS argdecllist:argDeclList RIGHT_PARENTHESIS LEFT_BRACKET
                    fielddecls:fieldDecls RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withoutType())
                                .id(id)
                                .argDeclList(argDeclList)
                                .fieldDecls(fieldDecls)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   VOID ID:id LEFT_PARENTHESIS argdecllist:argDeclList RIGHT_PARENTHESIS LEFT_BRACKET
                    fielddecls:fieldDecls stmts:stmts RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withoutType())
                                .id(id)
                                .argDeclList(argDeclList)
                                .fieldDecls(fieldDecls)
                                .stmts(stmts)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   typeid:typeId LEFT_PARENTHESIS RIGHT_PARENTHESIS LEFT_BRACKET
                    fielddecls:fieldDecls RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withType(typeId.getType()))
                                .id(typeId.getId())
                                .fieldDecls(fieldDecls)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   typeid:typeId LEFT_PARENTHESIS RIGHT_PARENTHESIS LEFT_BRACKET
                    fielddecls:fieldDecls stmts:stmts RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withType(typeId.getType()))
                                .id(typeId.getId())
                                .fieldDecls(fieldDecls)
                                .stmts(stmts)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   VOID ID:id LEFT_PARENTHESIS RIGHT_PARENTHESIS LEFT_BRACKET
                    fielddecls:fieldDecls RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withoutType())
                                .id(id)
                                .fieldDecls(fieldDecls)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   VOID ID:id LEFT_PARENTHESIS RIGHT_PARENTHESIS LEFT_BRACKET
                    fielddecls:fieldDecls stmts:stmts RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withoutType())
                                .id(id)
                                .fieldDecls(fieldDecls)
                                .stmts(stmts)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   typeid:typeId LEFT_PARENTHESIS argdecllist:argDeclList RIGHT_PARENTHESIS LEFT_BRACKET
                    RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withType(typeId.getType()))
                                .id(typeId.getId())
                                .argDeclList(argDeclList)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   typeid:typeId LEFT_PARENTHESIS argdecllist:argDeclList RIGHT_PARENTHESIS LEFT_BRACKET
                    stmts:stmts RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withType(typeId.getType()))
                                .id(typeId.getId())
                                .argDeclList(argDeclList)
                                .stmts(stmts)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   VOID ID:id LEFT_PARENTHESIS argdecllist:argDeclList RIGHT_PARENTHESIS LEFT_BRACKET
                    RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withoutType())
                                .id(id)
                                .argDeclList(argDeclList)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   VOID ID:id LEFT_PARENTHESIS argdecllist:argDeclList RIGHT_PARENTHESIS LEFT_BRACKET
                    stmts:stmts RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withoutType())
                                .id(id)
                                .argDeclList(argDeclList)
                                .stmts(stmts)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   typeid:typeId LEFT_PARENTHESIS RIGHT_PARENTHESIS LEFT_BRACKET
                    RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withType(typeId.getType()))
                                .id(typeId.getId())
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   typeid:typeId LEFT_PARENTHESIS RIGHT_PARENTHESIS LEFT_BRACKET
                    stmts:stmts RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withType(typeId.getType()))
                                .id(typeId.getId())
                                .stmts(stmts)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   VOID ID:id LEFT_PARENTHESIS RIGHT_PARENTHESIS LEFT_BRACKET
                    RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withoutType())
                                .id(id)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   VOID ID:id LEFT_PARENTHESIS RIGHT_PARENTHESIS LEFT_BRACKET
                    stmts:stmts RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.methods.MethodDecl.builder()
                                .returnType(tokens.methods.ReturnType.withoutType())
                                .id(id)
                                .stmts(stmts)
                                .optionalSemi(optionalSemi)
                                .build();
                :};

optionalsemi    ::= SEMI
                {:
                    RESULT = tokens.lexeme.OptionalLexeme.shown(tokens.lexeme.Lexeme.of(";"));
                :}
                |
                {:
                    RESULT = tokens.lexeme.OptionalLexeme.hidden();
                :};

type            ::= INT_PRIMITIVE
                {:
                    RESULT = tokens.lexeme.Types.INTLIT;
                :}
                |   CHAR_PRIMITIVE
                {:
                    RESULT = tokens.lexeme.Types.CHARLIT;
                :}
                |   BOOL_PRIMITIVE
                {:
                    RESULT = tokens.lexeme.Types.BOOLLIT;
                :}
                |   FLOAT_PRIMITIVE
                {:
                    RESULT = tokens.lexeme.Types.FLOATLIT;
                :};

argdecllist     ::= argdecl:argDecl PARAMETER_SEPARATOR argdecllist:argDeclList
                {:
                    RESULT = tokens.methods.args.argdecls.ArgDeclList.builder()
                                .argDecl(argDecl)
                                .argDeclList(argDeclList)
                                .build();
                :}
                | argdecl:argDecl
                {:
                    RESULT = tokens.methods.args.argdecls.ArgDeclList.builder()
                                .argDecl(argDecl)
                                .build();
                :};

argdecl         ::= typeid:typeId
                {:
                    RESULT = tokens.methods.args.argdecls.RegularArgDecl.builder()
                                .type(typeId.getType())
                                .id(typeId.getId())
                                .build();
                :}
                |   typeid:typeId LEFT_SQUARE_PARENTHESIS RIGHT_SQUARE_PARENTHESIS
                {:
                    RESULT = tokens.methods.args.argdecls.ArrayArgDecl.builder()
                                .type(typeId.getType())
                                .id(typeId.getId())
                                .build();
                :};

stmts           ::= stmts:stmts stmt:stmt
                {:
                    RESULT = tokens.stmts.Stmts.builder()
                                .stmt(stmt)
                                .stmts(stmts)
                                .build();
                :}
                |   stmt:stmt
                {:
                    RESULT = tokens.stmts.Stmts.builder()
                                .stmt(stmt)
                                .build();
                :};

stmt            ::= IF LEFT_PARENTHESIS expr:expr RIGHT_PARENTHESIS stmt:stmt
                {:
                    RESULT = tokens.stmts.IfStmt.builder()
                                .expr(expr)
                                .stmt(stmt)
                                .ifEnd(tokens.stmts.IfEnd.end())
                                .build();
                :}
                |   IF LEFT_PARENTHESIS expr:expr RIGHT_PARENTHESIS stmt:ifStmt ELSE stmt:elseStmt
                {:
                    RESULT = tokens.stmts.IfStmt.builder()
                                .expr(expr)
                                .stmt(ifStmt)
                                .ifEnd(tokens.stmts.IfEnd.withStmt(elseStmt))
                                .build();
                :}
                |   WHILE LEFT_PARENTHESIS expr:expr RIGHT_PARENTHESIS stmt:stmt
                {:
                    RESULT = tokens.stmts.WhileStmt.builder()
                                .expr(expr)
                                .stmt(stmt)
                                .build();
                :}
                |   name:name ASSMNT expr:expr SEMI
                {:
                    RESULT = tokens.stmts.ReassignStmt.builder()
                                .name(name)
                                .expr(expr)
                                .build();
                :}
                |   READ LEFT_PARENTHESIS readlist:readList RIGHT_PARENTHESIS SEMI
                {:
                    RESULT = tokens.stmts.ReadStmt.of(readList);
                :}
                |   PRINT LEFT_PARENTHESIS printlist:printList RIGHT_PARENTHESIS SEMI
                {:
                    RESULT = tokens.stmts.PrintStmt.of(printList);
                :}
                |   PRINTLINE LEFT_PARENTHESIS printlinelist:printLineList RIGHT_PARENTHESIS SEMI
                {:
                    RESULT = tokens.stmts.PrintLineStmt.of(printLineList);
                :}
                |   ID:id LEFT_PARENTHESIS RIGHT_PARENTHESIS SEMI
                {:
                    RESULT = tokens.stmts.MethodInvocationStmt.blank(id);
                :}
                |   ID:id LEFT_PARENTHESIS args:args RIGHT_PARENTHESIS SEMI
                {:
                    RESULT = tokens.stmts.MethodInvocationStmt.withArgs(id, args);
                :}
                |   RETURN SEMI
                {:
                    RESULT = tokens.stmts.ReturnStmt.blank();
                :}
                |   RETURN expr:expr SEMI
                {:
                    RESULT = tokens.stmts.ReturnStmt.withExpr(expr);
                :}
                |   name:name DOUBLE_PLUS SEMI
                {:
                    RESULT = tokens.stmts.IncrementStmt.withName(name);
                :}
                |   name:name DOUBLE_MINUS SEMI
                {:
                    RESULT = tokens.stmts.DecrementStmt.withName(name);
                :}
                |   LEFT_BRACKET fielddecls:fieldDecls stmts:stmts RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.stmts.BodyStmt.builder()
                                .fieldDecls(fieldDecls)
                                .stmts(stmts)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   LEFT_BRACKET fielddecls:fieldDecls RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.stmts.BodyStmt.builder()
                                .fieldDecls(fieldDecls)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   LEFT_BRACKET stmts:stmts RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.stmts.BodyStmt.builder()
                                .stmts(stmts)
                                .optionalSemi(optionalSemi)
                                .build();
                :}
                |   LEFT_BRACKET RIGHT_BRACKET optionalsemi:optionalSemi
                {:
                    RESULT = tokens.stmts.BodyStmt.builder()
                                .optionalSemi(optionalSemi)
                                .build();
                :};

name            ::= ID:id
                {:
                    RESULT = tokens.id.Name.simple(id);
                :}
                |   ID:id LEFT_SQUARE_PARENTHESIS expr:expr RIGHT_SQUARE_PARENTHESIS
                {:
                    RESULT = tokens.id.Name.array(id, expr);
                :};

args            ::= expr:expr PARAMETER_SEPARATOR args:args
                {:
                    RESULT = tokens.methods.args.Args.builder()
                                .expr(expr)
                                .args(args)
                                .build();
                :}
                |   expr:expr
                {:
                    RESULT = tokens.methods.args.Args.builder()
                                .expr(expr)
                                .build();
                :};

readlist        ::= name:name PARAMETER_SEPARATOR readlist:readlist
                {:
                    RESULT = tokens.methods.args.ReadList.builder()
                                .name(name)
                                .readList(readlist)
                                .build();
                :}
                |   name:name
                {:
                    RESULT = tokens.methods.args.ReadList.builder()
                                .name(name)
                                .build();
                :};

printlist       ::= expr:expr PARAMETER_SEPARATOR printlist:printList
                {:
                    RESULT = tokens.methods.args.PrintList.builder()
                                .expr(expr)
                                .printList(printList)
                                .build();
                :}
                |   expr:expr
                {:
                    RESULT = tokens.methods.args.PrintList.builder()
                                .expr(expr)
                                .build();
                :};

printlinelist   ::= printlist:printList
                {:
                    RESULT = tokens.methods.args.PrintLineList.withPrintList(printList);
                :}
                |
                {:
                    RESULT = tokens.methods.args.PrintLineList.empty();
                :};

expr            ::= name:name
                {:
                    RESULT = tokens.expr.Expr.simple(name);
                :}
                |   ID:id LEFT_PARENTHESIS RIGHT_PARENTHESIS
                {:
                    RESULT = tokens.expr.Expr.simpleInvocation(id);
                :}
                |   ID:id LEFT_PARENTHESIS args:args RIGHT_PARENTHESIS
                {:
                    RESULT = tokens.expr.Expr.invocation(id, args);
                :}
                |   INTLIT:intlit
                {:
                    RESULT = tokens.expr.Expr.intlit(intlit);
                :}
                |   CHARLIT:charlit
                {:
                    RESULT = tokens.expr.Expr.charlit(charlit);
                :}
                |   STRLIT:strlit
                {:
                    RESULT = tokens.expr.Expr.strlit(strlit);
                :}
                |   FLOATLIT:floatlit
                {:
                    RESULT = tokens.expr.Expr.floatlit(floatlit);
                :}
                |   BOOL_TRUE
                {:
                    RESULT = tokens.expr.Expr.boollit(true);
                :}
                |   BOOL_FALSE
                {:
                    RESULT = tokens.expr.Expr.boollit(false);
                :}
                |   LEFT_PARENTHESIS expr:expr RIGHT_PARENTHESIS
                {:
                    RESULT = tokens.expr.Expr.parenthesized(expr);
                :}
                |   NOT expr:expr
                {:
                    RESULT = tokens.expr.Expr.not(expr);
                :}
                |   MINUS expr:expr
                {:
                    RESULT = tokens.expr.Expr.minus(expr);
                :} %prec UMINUS
                |   PLUS expr:expr
                {:
                    RESULT = tokens.expr.Expr.plus(expr);
                :} %prec UPLUS
                |   LEFT_PARENTHESIS type:type RIGHT_PARENTHESIS expr:expr
                {:
                    RESULT = tokens.expr.Expr.casting(type, expr);
                :}
                |   binaryop:binaryOp
                {:
                    RESULT = tokens.expr.Expr.binaryOp(binaryOp);
                :}
                |   LEFT_PARENTHESIS expr:expr TERNARY_IF expr:exprTrue TERNARY_ELSE expr:exprFalse RIGHT_PARENTHESIS
                {:
                    RESULT = tokens.expr.Expr.ternary(expr, exprTrue, exprFalse);
                :};

binaryop        ::= expr:expr1 TIMES expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, "*", expr2);
                :}
                |   expr:expr1 DIVIDE expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, "/", expr2);
                :}
                |   expr:expr1 PLUS expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, "+", expr2);
                :}
                |   expr:expr1 MINUS expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, "-", expr2);
                :}
                |   expr:expr1 LESS_THAN expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, "<", expr2);
                :}
                |   expr:expr1 GREATER_THAN expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, ">", expr2);
                :}
                |   expr:expr1 LESS_THAN_OR_EQUAL_TO expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, "<=", expr2);
                :}
                |   expr:expr1 GREATER_THAN_OR_EQUAL_TO expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, ">=", expr2);
                :}
                |   expr:expr1 EQUAL_TO expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, "==", expr2);
                :}
                |   expr:expr1 NOT_EQUAL_TO expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, "<>", expr2);
                :}
                |   expr:expr1 DOUBLE_OR expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, "||", expr2);
                :}
                |   expr:expr1 DOUBLE_AND expr:expr2
                {:
                    RESULT = tokens.expr.BinaryOp.of(expr1, "&&", expr2);
                :};

typeid          ::= type:type ID:id
                {:
                    RESULT = tokens.id.TypeId.of(type, id);
                :};