options {
  IGNORE_CASE=true;
//  DEBUG_PARSER = true;
}

PARSER_BEGIN(Pascal2JavaParser)
public class Pascal2JavaParser {}
PARSER_END(Pascal2JavaParser)

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

TOKEN : {
   <PROGRAM:    "program" >
 | <VAR:        "var" >
 | <BEGIN:      "begin" >
 | <END:        "end" >
 | <INTEGER:    "integer" >
 | <FOR:        "for" >
 | <TO:         "to" >
 | <DOWNTO:     "downto" >
 | <STEP:       "step" >
}

TOKEN : {//[IGNORE_CASE]: {

   <#digit:     ["0"-"9"] >
 | <#letter:    ["a"-"z", "_" ] >
 | <INTNUMBER:    (["+","-"])? (<digit>)+ >
 | <IDENTIFIER: <letter> (<letter> | <digit>)* >
}


Trans identifier() :
{Token t;}
{
   t=<IDENTIFIER>
   {return new Trans(0).conc(t);}
}

Trans program() :
{Trans ret= new Trans(0), prog, var, cmd;
}
{
   <PROGRAM> prog=identifier() ";"

   {ret.add( "public class " ).conc( prog ).conc( " {" );
    ret.add("   static void main(String argv[]) {" );
   }

   [
      <VAR>
      (
         var=var()
         {ret.add( new Trans(var) );}
      )*
   ]

   <BEGIN>
      (
         cmd=command() ";" //Last one ";" should be optional...
         {ret.add( new Trans(cmd) ).conc( ';' );}
      )*
   <END> "."

 {return ret.add( "   }" ).add( '}' );}
}

Trans var() :
{Trans name, type= new Trans();
 Trans names= new Trans();
 Trans ret= new Trans();
}
{
   name=identifier()
   {names.add(name);}

   (
      "," name= identifier()
      {names.conc( "," ).conc( name );}
   )*

  ":"

   (
      <INTEGER> {type= new Trans(0).conc("int");}
    | type=identifier()
   )

   ";"

   {return ret.conc( type ).conc( " " ).conc( names ).conc( ";" );}
}

Trans command() :
{Trans ret= new Trans(), var, value, cmd;
}
{
   var=identifier()
   ":="
   value= expression()
   {return ret.conc( var ).conc( "= " ).conc( value );}

 | cmd=for_loop()
   { return cmd; }

 | <BEGIN> {ret.conc("{");}
      (
         cmd= command() ";"
         {ret.add( cmd ).conc( ";" );}
      )*
   <END>
   {return ret.conc( "}" );}
}

Trans for_loop() :
{Trans ret=new Trans(), cmd, var;
 String sign="+", compare="<=";
 Trans from, to, step= new Trans().conc(1);
}
{
   <FOR>
   var=identifier()
   ":="
   from=expression()
   (
      <TO>
    | <DOWNTO>
      {sign="-"; compare=">=";}
   )

   to=expression()

   [
      <STEP> step=expression()
   ]

   cmd= command()

  {return
   ret.conc( "for(" ).conc( var ).conc( "= " ).conc( from ).conc("; ").
   conc( var ).conc( compare ).conc( to ).conc( "; ").
   conc( var ).conc( sign ).conc( "=" ).conc( step ).conc( ")" ).
   add( cmd );
  }
}

Trans expression() :
{Trans first, second;}
{
   first= multiplication()

   [
      "+" second= expression()
      {first.conc( "+" ).conc( second );}

    | "-" second= expression()
      {first.conc( "-" ).conc( second );}
   ]

   {return first;}
}

Trans multiplication() :
{Trans first, second;}
{
   first=parentheses()

   (
      "*" second=parentheses()
      {first.conc( "*" ).conc( second );}

    | "/" second=parentheses()
      {first.conc( "/" ).conc( second );}
   )*

   {return first;}
}


Trans parentheses() :
{Trans ret; Token number;}
{
   "("
      ret=expression()
   ")"
   {return ret.preconc( "(" ).conc( ")" );}

  | ret=identifier()
    {return ret;}

  | number=<INTNUMBER>
    {return new Trans(number);}
}