options {
  JAVA_UNICODE_ESCAPE = true;
}

PARSER_BEGIN(JayParser)

public class JayParser
{}

PARSER_END(JayParser)


/* WHITE SPACE */

SKIP :
{
  " "
| "\t"
| "\n"
| "\r"
| "\f"
}

/* COMMENTS */

MORE :
{
  "//" : IN_SINGLE_LINE_COMMENT
|
  <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
|
  "/*" : IN_MULTI_LINE_COMMENT
}

<IN_SINGLE_LINE_COMMENT>
SPECIAL_TOKEN :
{
  <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : DEFAULT
}

<IN_FORMAL_COMMENT>
SPECIAL_TOKEN :
{
  <FORMAL_COMMENT: "*/" > : DEFAULT
}

<IN_MULTI_LINE_COMMENT>
SPECIAL_TOKEN :
{
  <MULTI_LINE_COMMENT: "*/" > : DEFAULT
}

<IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
MORE :
{
  < ~[] >
}

/* RESERVED WORDS AND LITERALS */

TOKEN :
{
 < BOOLEAN: "boolean" >
| < ELSE: "else" >
| < IF: "if" >
| < INT: "int" >
| < VOID: "void" >
| < MAIN: "main" >
| < WHILE: "while" >
| < PRINT: "System.out.println" >
}

/* LITERALS */

TOKEN :
{
  < INTEGER_LITERAL:
        <DECIMAL_LITERAL> (["l","L"])?
      | <HEX_LITERAL> (["l","L"])?
      | <OCTAL_LITERAL> (["l","L"])?
  >
|
  < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
|
  < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
|
  < #OCTAL_LITERAL: "0" (["0"-"7"])* >
|
  < BOOLEAN_LITERAL: "true" | "false" >
|
  < STRING_LITERAL:
      "\""
      (   (~["\"","\\","\n","\r"])
        | ("\\"
            ( ["n","t","b","r","f","\\","'","\""]
            | ["0"-"7"] ( ["0"-"7"] )?
            | ["0"-"3"] ["0"-"7"] ["0"-"7"]
            )
          )
      )*
      "\""
  >
}

/* IDENTIFIERS */

TOKEN :
{
  < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* >
|
  < #LETTER:
      [
       "\u0024",
       "\u0041"-"\u005a",
       "\u005f",
       "\u0061"-"\u007a",
       "\u00c0"-"\u00d6",
       "\u00d8"-"\u00f6",
       "\u00f8"-"\u00ff",
       "\u0100"-"\u1fff",
       "\u3040"-"\u318f",
       "\u3300"-"\u337f",
       "\u3400"-"\u3d2d",
       "\u4e00"-"\u9fff",
       "\uf900"-"\ufaff"
      ]
  >
|
  < #DIGIT:
      [
       "\u0030"-"\u0039",
       "\u0660"-"\u0669",
       "\u06f0"-"\u06f9",
       "\u0966"-"\u096f",
       "\u09e6"-"\u09ef",
       "\u0a66"-"\u0a6f",
       "\u0ae6"-"\u0aef",
       "\u0b66"-"\u0b6f",
       "\u0be7"-"\u0bef",
       "\u0c66"-"\u0c6f",
       "\u0ce6"-"\u0cef",
       "\u0d66"-"\u0d6f",
       "\u0e50"-"\u0e59",
       "\u0ed0"-"\u0ed9",
       "\u1040"-"\u1049"
      ]
  >
}

/* SEPARATORS */

TOKEN :
{
  < LPAREN: "(" >
| < RPAREN: ")" >
| < LBRACE: "{" >
| < RBRACE: "}" >
| < SEMICOLON: ";" >
| < COMMA: "," >
}

/* OPERATORS */

TOKEN :
{
  < ASSIGN: "=" >
| < GT: ">" >
| < LT: "<" >
| < BANG: "!" >
| < EQ: "==" >
| < LE: "<=" >
| < GE: ">=" >
| < NE: "!=" >
| < SC_OR: "||" >
| < SC_AND: "&&" >
| < PLUS: "+" >
| < MINUS: "-" >
| < STAR: "*" >
| < SLASH: "/" >
}

/*****************************************
 * THE JAY LANGUAGE GRAMMAR STARTS HERE *
 *****************************************/


void Program():
{}
{
    "void" "main" "(" ")" "{" Declarations() Statements() "}"
    <EOF>
}

void Declarations():
{}
{
     ( Declaration() )*
}

void Declaration():
{}
{
    Type() Identifiers() ";"
}

void Type():
{}
{ 
    "int"
|   "boolean"
}

void Identifiers():
{}
{
    <IDENTIFIER>  ( "," <IDENTIFIER> )*
}

void Statements():
{}
{
    ( Statement() )*
}

void Statement():
{}
{
    Skip()
|   Block()
|   Assignment()
|   IfStatement()
|   WhileStatement()
|   PrintStatement()
}

void Skip():
{}
{
   ";"
}

void Block():
{}
{
     "{" Statements() "}"
}

void Assignment():
{}
{
    <IDENTIFIER> "=" Expression() ";"
}

void IfStatement():
{}
{
   "if" "(" Expression() ")" Statement() [ LOOKAHEAD(2) "else" Statement() ]
}

void WhileStatement():
{}
{
     "while" "(" Expression() ")" Statement()
}

void PrintStatement():
{}
{
     "System.out.println" "(" Expression() ")" ";"
}

void Expression():
{}
{
   Conjunction() ( "||" Conjunction() )*
}

void Conjunction():
{}
{
    Relation() ( "&&" Relation() )*
}

void Relation():
{}
{
    Addition() [ ComparisonOperator() Addition()  ]
}

void ComparisonOperator():
{}
{
    "<"
|   "<="
|   ">"
|   ">="
|   "=="
|   "!="
}

void Addition():
{}
{
    Term() ( AdditionOperator() Term() )*
}

void AdditionOperator():
{}
{
    "+"
|   "-"
}

void Term():
{}
{
   Negation() ( MultiplicationOperator() Negation() )*
}

void MultiplicationOperator():
{}
{
   "*"
|  "/"
}

void Negation():
{}
{
    [ "!" ] Factor()
}

void Factor():
{}
{
    <IDENTIFIER>
|   <INTEGER_LITERAL>
|   <BOOLEAN_LITERAL>
|   "(" Expression() ")"
}