/*@bgen(jjtree) Generated By:JJTree: Do not edit this line. Pnuts.jj */
/*@egen*//*
 * @(#)Pnuts.jjt    1.28 02/05/01
 *
 * Copyright (c) 1997-2002 Sun Microsystems, Inc. All Rights Reserved.
 *
 * See the file "license.txt" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

options {                 
    STATIC=false;                   
    JAVA_UNICODE_ESCAPE = false;
    USER_CHAR_STREAM=false;
    UNICODE_INPUT=true;
}

PARSER_BEGIN(PnutsParser)

package pnuts.lang;
import pnuts.lang.Runtime;
public class PnutsParser/*@bgen(jjtree)*/implements PnutsParserTreeConstants/*@egen*/ {/*@bgen(jjtree)*/
  protected JJTPnutsParserState jjtree = new JJTPnutsParserState();

/*@egen*/}
PARSER_END(PnutsParser)

SKIP : /* WHITE SPACE */
{
  " "
| "\t"
| "\f"
}

SPECIAL_TOKEN : /* COMMENTS */
{
  <SINGLE_LINE_COMMENT: "//" (~["\n","\r"])*>
| <MULTI_LINE_COMMENT: "/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">
}

TOKEN : /* EOL */
{
  <EOL: ("\r"|"\n"|"\r\n")>
}

TOKEN : /* RESERVED WORDS AND LITERALS */
{
  < TRUE: "true" >
| < FALSE: "false" >
| < NULL: "null" >
| < IF: "if">
| < ELSE: "else">
| < ELIF: "elif">
| < WHILE: "while">
| < FOREACH: "foreach">
| < FOR: "for">
| < SWITCH: "switch">
| < CASE: "case">
| < DFLT: "default">
| < INSTANCEOF: "instanceof" >
| < BREAK: "break">
| < CONTINUE: "continue">
| < RETURN: "return">
| < FUNCTION: "function">
| < CLASS: "class">
| < CATCH: "catch">
}


TOKEN : /* LITERALS */
{
  < INTEGER_LITERAL:
        <DECIMAL_LITERAL>
      | <HEX_LITERAL>
      | <HEX_LITERAL2>
  >
|
  < #DECIMAL_LITERAL: ("0" | ["1"-"9"] (["0"-"9"])*) (<LETTER>)* >
|
  < #HEX_LITERAL: "#" (["0"-"9","a"-"f","A"-"F"])+ >
|
  < #HEX_LITERAL2: "0" ("x" | "X") (["0"-"9","a"-"f","A"-"F"])+ >
|
  < FLOATING_POINT_LITERAL:
        (["0"-"9"])+ "." (["0"-"9"])+ (<EXPONENT>)? (<LETTER>)*
      | "." (["0"-"9"])+ (<EXPONENT>)?  (<LETTER>)*
      | (["0"-"9"])+ <EXPONENT> (<LETTER>)*
  >
|
  < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
|
  < CHARACTER_LITERAL:
      "'"
      (   (~["'","\\","\n","\r"])+
        | ("\\"
            ( ["n","t","b","r","f","0","\\","'","\""] |
          (("u"|"U") (["0"-"9","a"-"f","A"-"F"])+)
            )
          )
      )
      "'"
  >
|
  < STRING_LITERAL:
      "\""
      ( "\"" |
        (   (~["\"","\\"])
          | ("\\"
             ( ["n","t","b","r","f","0","\\","'","\""] |
          (("u"|"U") (["0"-"9","a"-"f","A"-"F"])+)
            )
          )
        )+
       "\""
     )
  >
|
  < STRING_LITERAL2: "`" ( ~["`"] )* "`" >
}

TOKEN : /* IDENTIFIERS */
{
  < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* >
|
  < #LETTER:
      [
       "$",
       "?"-"Z",
       "_",
       "a"-"z",
       "\u0080"-"\uffff"
       ]
  >
|
  < #DIGIT:
      ["0"-"9"]
  >
}

TOKEN : /* SEPARATORS */
{
  < LPAREN: "(" >
| < RPAREN: ")" >
| < LBRACE: "{" >
| < RBRACE: "}" >
| < LBRACKET: "[" >
| < RBRACKET: "]" >
| < SEMICOLON: ";" >
| < COMMA: "," >
| < DOT: "." >
| < COLON: ":" >
| < COLON2: "::" >
| < DOT2: ".." >
| < BACKQUOTE: "`" >
}


TOKEN : /* OPERATORS */
{
  < ASSIGN: "=">
| < TA: "*=">
| < DA: "/=">
| < MA: "%=">
| < PA: "+=">
| < SA: "-=">
| < LA: "<<=">
| < RA: ">>=">
| < RAA: ">>>=">
| < AA: "&=">
| < EA: "^=">
| < OA: "|=">
| < GT: ">" >
| < LT: "<" >
| < BANG: "!" >
| < TILDE: "~" >
| < EQ: "==" >
| < LE: "<=" >
| < GE: ">=" >
| < NE: "!=" >
| < SC_OR: "||" >
| < SC_AND: "&&" >
| < PLUS: "+" >
| < MINUS: "-" >
| < STAR: "*" >
| < SLASH: "/" >
| < BIT_AND: "&" >
| < BIT_OR: "|" >
| < XOR: "^" >
| < REM: "%" >
| < LSHIFT: "<<" >
| < RSIGNEDSHIFT: ">>" >
| < RUNSIGNEDSHIFT: ">>>" >
}

TOKEN : /* OPERATORS */
{
  < NO_MATCH: ~["."] >
}

void Eol()        :
{}
{
  (<EOL>)*
}

SimpleNode StartSet() :
{/*@bgen(jjtree) StartSet */
  SimpleNode jjtn000 = new SimpleNode(JJTSTARTSET);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) StartSet */
   try {
/*@egen*/
   Eol() 
  (
   (ExpressionList() (<EOL> [ ExpressionList()] )* <EOF>)/*@bgen(jjtree)*/
   {
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
   }
/*@egen*/
   {
    jjtn000.info = new int[]{1};
    return jjtn000;
   } 
   |
   <EOF>/*@bgen(jjtree)*/
   {
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
   }
/*@egen*/
   {
    jjtn000.info = new int[]{-1};
    return jjtn000;
   }
  )/*@bgen(jjtree)*/
   } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       throw (RuntimeException)jjte000;
     }
     if (jjte000 instanceof ParseException) {
       throw (ParseException)jjte000;
     }
     throw (Error)jjte000;
   } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
   }
/*@egen*/
}

SimpleNode Start() :
{/*@bgen(jjtree) Start */
  SimpleNode jjtn000 = new SimpleNode(JJTSTART);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) Start */
  try {
/*@egen*/
  ExpressionList() ( t=<EOL> | t=<EOF> )/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
     jjtn000.info = new int[]{1};
     return jjtn000;
  }
 | <EOL>/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
     jjtn000.info = new int[]{0};
     return jjtn000;
  }
 | <EOF>/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
     jjtn000.info = new int[]{-1};
     return jjtn000;
  }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void ExpressionList() :
{/*@bgen(jjtree) ExpressionList */
  SimpleNode jjtn000 = new SimpleNode(JJTEXPRESSIONLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ExpressionList */
  try {
/*@egen*/
  Expression() ( ";" [ Expression() ] )*/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void Expression()       :
{}
{
  ConditionalExpression() [ Assignment() ]
|
  StatementExpression()
}

void PrimaryExpression()       :
{}
{
  PrimaryPrefix() ( PrimarySuffix() )*
}

void IdNode()       :
{ Token t; }
{
  "::"
  t = <IDENTIFIER>/*@bgen(jjtree) Global */
  {
    SimpleNode jjtn001 = new SimpleNode(JJTGLOBAL);
    boolean jjtc001 = true;
    jjtree.openNodeScope(jjtn001);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn001, true);
    jjtc001 = false;
  }
/*@egen*/
  {
    jjtn001.setToken(t);
    jjtn001.str = t.image.intern();
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc001) {
      jjtree.closeNodeScope(jjtn001, true);
    }
  }
/*@egen*/
 |
  t=<IDENTIFIER>/*@bgen(jjtree) IdNode */
  {
    SimpleNode jjtn002 = new SimpleNode(JJTIDNODE);
    boolean jjtc002 = true;
    jjtree.openNodeScope(jjtn002);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn002, true);
    jjtc002 = false;
  }
/*@egen*/
  {
    jjtn002.setToken(t);
    jjtn002.str = t.image.intern();
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc002) {
      jjtree.closeNodeScope(jjtn002, true);
    }
  }
/*@egen*/
}

void CatchNode() :
{/*@bgen(jjtree) CatchNode */
  SimpleNode jjtn000 = new SimpleNode(JJTCATCHNODE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t1, t2 = null; }
{/*@bgen(jjtree) CatchNode */
    try {
/*@egen*/
    t1=<CATCH> [ "(" Eol()/*@bgen(jjtree) ListElements */
                           {
                             SimpleNode jjtn001 = new SimpleNode(JJTLISTELEMENTS);
                             boolean jjtc001 = true;
                             jjtree.openNodeScope(jjtn001);
                           }
                           try {
/*@egen*/ [ ListElements() ]/*@bgen(jjtree)*/
                           } catch (Throwable jjte001) {
                             if (jjtc001) {
                               jjtree.clearNodeScope(jjtn001);
                               jjtc001 = false;
                             } else {
                               jjtree.popNode();
                             }
                             if (jjte001 instanceof RuntimeException) {
                               throw (RuntimeException)jjte001;
                             }
                             if (jjte001 instanceof ParseException) {
                               throw (ParseException)jjte001;
                             }
                             throw (Error)jjte001;
                           } finally {
                             if (jjtc001) {
                               jjtree.closeNodeScope(jjtn001, true);
                             }
                           }
/*@egen*/ t2=<RPAREN> ]/*@bgen(jjtree)*/
    {
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
    }
/*@egen*/
    {
    if (t2 == null){
        t2 = t1;
    }
    jjtn000.setToken(t1, t2);
    jjtn000.str = t1.image.intern();
    }/*@bgen(jjtree)*/
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        throw (RuntimeException)jjte000;
      }
      if (jjte000 instanceof ParseException) {
        throw (ParseException)jjte000;
      }
      throw (Error)jjte000;
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
/*@egen*/
}

void PrimaryPrefix()       :
{}
{
  Literal()
|
  IdNode()
|
  List()
|
  Class()
|
  "(" Expression() ")"
}

void List()       :
{}
{
  "[" Eol()/*@bgen(jjtree) ListElements */
            {
              SimpleNode jjtn001 = new SimpleNode(JJTLISTELEMENTS);
              boolean jjtc001 = true;
              jjtree.openNodeScope(jjtn001);
            }
            try {
/*@egen*/ [ ListElements() ]/*@bgen(jjtree)*/
            } catch (Throwable jjte001) {
              if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte001 instanceof RuntimeException) {
                throw (RuntimeException)jjte001;
              }
              if (jjte001 instanceof ParseException) {
                throw (ParseException)jjte001;
              }
              throw (Error)jjte001;
            } finally {
              if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, true);
              }
            }
/*@egen*/ "]"
}

void ListElements()       :
{}
{
  Expression() ( "," Eol() Expression() )* Eol()
}

void Class() :
{/*@bgen(jjtree) Class */
  SimpleNode jjtn000 = new SimpleNode(JJTCLASS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t1, t2 = null; }
{/*@bgen(jjtree) Class */
  try {
/*@egen*/
  t1=<CLASS> [ t2=<IDENTIFIER> (LOOKAHEAD(2) "." Package() )* ]/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
    if (t2 != null){
    jjtn000.str = t2.image;
    }
    jjtn000.setToken(t1);
  }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void Package() :
{/*@bgen(jjtree) Package */
  SimpleNode jjtn000 = new SimpleNode(JJTPACKAGE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) Package */
  try {
/*@egen*/
  t=<IDENTIFIER>/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
    jjtn000.str = t.image;
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void MethodNode()       :
{ Token t1, t2; }
{

   "." t1=<IDENTIFIER> "(" Eol()/*@bgen(jjtree) ListElements */
                                 {
                                   SimpleNode jjtn001 = new SimpleNode(JJTLISTELEMENTS);
                                   boolean jjtc001 = true;
                                   jjtree.openNodeScope(jjtn001);
                                 }
                                 try {
/*@egen*/ [ ListElements() ]/*@bgen(jjtree)*/
                                 } catch (Throwable jjte001) {
                                   if (jjtc001) {
                                     jjtree.clearNodeScope(jjtn001);
                                     jjtc001 = false;
                                   } else {
                                     jjtree.popNode();
                                   }
                                   if (jjte001 instanceof RuntimeException) {
                                     throw (RuntimeException)jjte001;
                                   }
                                   if (jjte001 instanceof ParseException) {
                                     throw (ParseException)jjte001;
                                   }
                                   throw (Error)jjte001;
                                 } finally {
                                   if (jjtc001) {
                                     jjtree.closeNodeScope(jjtn001, true);
                                   }
                                 }
/*@egen*/ t2=<RPAREN>/*@bgen(jjtree) #MethodNode( 2) */
  {
    SimpleNode jjtn002 = new SimpleNode(JJTMETHODNODE);
    boolean jjtc002 = true;
    jjtree.openNodeScope(jjtn002);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn002,  2);
    jjtc002 = false;
  }
/*@egen*/
  {
    jjtn002.str = t1.image.intern();
    jjtn002.setToken(t1, t2);
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc002) {
      jjtree.closeNodeScope(jjtn002,  2);
    }
  }
/*@egen*/
}

void StaticMethodNode()       :
{ Token t1, t2; }
{

  "::" t1=<IDENTIFIER> "(" Eol()/*@bgen(jjtree) ListElements */
                                 {
                                   SimpleNode jjtn001 = new SimpleNode(JJTLISTELEMENTS);
                                   boolean jjtc001 = true;
                                   jjtree.openNodeScope(jjtn001);
                                 }
                                 try {
/*@egen*/ [ ListElements() ]/*@bgen(jjtree)*/
                                 } catch (Throwable jjte001) {
                                   if (jjtc001) {
                                     jjtree.clearNodeScope(jjtn001);
                                     jjtc001 = false;
                                   } else {
                                     jjtree.popNode();
                                   }
                                   if (jjte001 instanceof RuntimeException) {
                                     throw (RuntimeException)jjte001;
                                   }
                                   if (jjte001 instanceof ParseException) {
                                     throw (ParseException)jjte001;
                                   }
                                   throw (Error)jjte001;
                                 } finally {
                                   if (jjtc001) {
                                     jjtree.closeNodeScope(jjtn001, true);
                                   }
                                 }
/*@egen*/ t2=<RPAREN>/*@bgen(jjtree) #StaticMethodNode( 2) */
  {
    SimpleNode jjtn002 = new SimpleNode(JJTSTATICMETHODNODE);
    boolean jjtc002 = true;
    jjtree.openNodeScope(jjtn002);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn002,  2);
    jjtc002 = false;
  }
/*@egen*/
  {
    jjtn002.str = t1.image.intern();
    jjtn002.setToken(t1, t2);
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc002) {
      jjtree.closeNodeScope(jjtn002,  2);
    }
  }
/*@egen*/
}

void MemberNode()       :
{ Token t; }
{
  "." t=<IDENTIFIER>/*@bgen(jjtree) #MemberNode( 1) */
  {
    SimpleNode jjtn001 = new SimpleNode(JJTMEMBERNODE);
    boolean jjtc001 = true;
    jjtree.openNodeScope(jjtn001);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn001,  1);
    jjtc001 = false;
  }
/*@egen*/
  {
    jjtn001.str = t.image.intern();
    jjtn001.setToken(t);
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc001) {
      jjtree.closeNodeScope(jjtn001,  1);
    }
  }
/*@egen*/
}

void StaticMemberNode()       :
{ Token t; }
{
  "::" t=<IDENTIFIER>/*@bgen(jjtree) #StaticMemberNode( 1) */
  {
    SimpleNode jjtn001 = new SimpleNode(JJTSTATICMEMBERNODE);
    boolean jjtc001 = true;
    jjtree.openNodeScope(jjtn001);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn001,  1);
    jjtc001 = false;
  }
/*@egen*/
  {
    jjtn001.str = t.image.intern();
    jjtn001.setToken(t);
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc001) {
      jjtree.closeNodeScope(jjtn001,  1);
    }
  }
/*@egen*/
}

void ApplicationNode()       :
{ Token t1, t2; }
{
  t1="(" Eol()/*@bgen(jjtree) ListElements */
               {
                 SimpleNode jjtn001 = new SimpleNode(JJTLISTELEMENTS);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
               }
               try {
/*@egen*/ [ ListElements() ]/*@bgen(jjtree)*/
               } catch (Throwable jjte001) {
                 if (jjtc001) {
                   jjtree.clearNodeScope(jjtn001);
                   jjtc001 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte001 instanceof RuntimeException) {
                   throw (RuntimeException)jjte001;
                 }
                 if (jjte001 instanceof ParseException) {
                   throw (ParseException)jjte001;
                 }
                 throw (Error)jjte001;
               } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001, true);
                 }
               }
/*@egen*/ t2=<RPAREN>/*@bgen(jjtree) #ApplicationNode( 2) */
  {
    SimpleNode jjtn002 = new SimpleNode(JJTAPPLICATIONNODE);
    boolean jjtc002 = true;
    jjtree.openNodeScope(jjtn002);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn002,  2);
    jjtc002 = false;
  }
/*@egen*/
  {
    jjtn002.setToken(t1, t2);
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc002) {
      jjtree.closeNodeScope(jjtn002,  2);
    }
  }
/*@egen*/
}

void PrimarySuffix()       :
{}
{
  "[" Eol() (
        LOOKAHEAD("]")/*@bgen(jjtree) #ArrayType( 1) */
                       {
                         SimpleNode jjtn001 = new SimpleNode(JJTARRAYTYPE);
                         boolean jjtc001 = true;
                         jjtree.openNodeScope(jjtn001);
                       }
                       try {
/*@egen*/ "]"/*@bgen(jjtree)*/
                       } finally {
                         if (jjtc001) {
                           jjtree.closeNodeScope(jjtn001,  1);
                         }
                       }
/*@egen*/
       |
        Expression() Eol() ( ".." Eol() ( LOOKAHEAD("]")/*@bgen(jjtree) #RangeNode( 2) */
                                                         {
                                                           SimpleNode jjtn002 = new SimpleNode(JJTRANGENODE);
                                                           boolean jjtc002 = true;
                                                           jjtree.openNodeScope(jjtn002);
                                                         }
                                                         try {
/*@egen*/ "]"/*@bgen(jjtree)*/
                                                         } finally {
                                                           if (jjtc002) {
                                                             jjtree.closeNodeScope(jjtn002,  2);
                                                           }
                                                         }
/*@egen*/
                                     |
                                 Expression() Eol()/*@bgen(jjtree) #RangeNode( 3) */
                                                            {
                                                              SimpleNode jjtn003 = new SimpleNode(JJTRANGENODE);
                                                              boolean jjtc003 = true;
                                                              jjtree.openNodeScope(jjtn003);
                                                            }
                                                            try {
/*@egen*/ "]"/*@bgen(jjtree)*/
                                                            } finally {
                                                              if (jjtc003) {
                                                                jjtree.closeNodeScope(jjtn003,  3);
                                                              }
                                                            }
/*@egen*/)
                          |/*@bgen(jjtree) #IndexNode( 2) */
                             {
                               SimpleNode jjtn004 = new SimpleNode(JJTINDEXNODE);
                               boolean jjtc004 = true;
                               jjtree.openNodeScope(jjtn004);
                             }
                             try {
/*@egen*/
                             "]"/*@bgen(jjtree)*/
                             } finally {
                               if (jjtc004) {
                                 jjtree.closeNodeScope(jjtn004,  2);
                               }
                             }
/*@egen*/  ))
|
  LOOKAHEAD( Eol() "."  Eol() t=<IDENTIFIER> "(" ) MethodNode()
|
  LOOKAHEAD( Eol() "::" Eol() t=<IDENTIFIER> "(" ) StaticMethodNode()
|
  MemberNode()
|
  StaticMemberNode()
|
  ApplicationNode()
}

void Literal()       :
{ Token t; }
{
  t = <INTEGER_LITERAL>/*@bgen(jjtree) IntegerNode */
  {
    SimpleNode jjtn001 = new SimpleNode(JJTINTEGERNODE);
    boolean jjtc001 = true;
    jjtree.openNodeScope(jjtn001);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn001, true);
    jjtc001 = false;
  }
/*@egen*/
  { jjtn001.str = t.image; jjtn001.setToken(t); }/*@bgen(jjtree)*/
  } finally {
    if (jjtc001) {
      jjtree.closeNodeScope(jjtn001, true);
    }
  }
/*@egen*/
|
  t = <FLOATING_POINT_LITERAL>/*@bgen(jjtree) FloatingNode */
  {
    SimpleNode jjtn002 = new SimpleNode(JJTFLOATINGNODE);
    boolean jjtc002 = true;
    jjtree.openNodeScope(jjtn002);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn002, true);
    jjtc002 = false;
  }
/*@egen*/
  { jjtn002.str = t.image; jjtn002.setToken(t); }/*@bgen(jjtree)*/
  } finally {
    if (jjtc002) {
      jjtree.closeNodeScope(jjtn002, true);
    }
  }
/*@egen*/
|
  t = <CHARACTER_LITERAL>/*@bgen(jjtree) CharacterNode */
  {
    SimpleNode jjtn003 = new SimpleNode(JJTCHARACTERNODE);
    boolean jjtc003 = true;
    jjtree.openNodeScope(jjtn003);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn003, true);
    jjtc003 = false;
  }
/*@egen*/
  { try {
    jjtn003.str = t.image;
    jjtn003.info = Runtime.parseChar(t.image);
    } catch (ParseException e){
        token.next = token_source.getNextToken();
    throw generateParseException();
    }
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc003) {
      jjtree.closeNodeScope(jjtn003, true);
    }
  }
/*@egen*/
|
  t = <STRING_LITERAL>/*@bgen(jjtree) StringNode */
  {
    SimpleNode jjtn004 = new SimpleNode(JJTSTRINGNODE);
    boolean jjtc004 = true;
    jjtree.openNodeScope(jjtn004);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn004, true);
    jjtc004 = false;
  }
/*@egen*/
  { try {
    jjtn004.str = t.image;
    jjtn004.info = Runtime.parseString(t.image);
    } catch (ParseException e){
        token.next = token_source.getNextToken();
    throw generateParseException();
    }
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc004) {
      jjtree.closeNodeScope(jjtn004, true);
    }
  }
/*@egen*/
|
  t = <STRING_LITERAL2>/*@bgen(jjtree) StringNode */
  {
    SimpleNode jjtn005 = new SimpleNode(JJTSTRINGNODE);
    boolean jjtc005 = true;
    jjtree.openNodeScope(jjtn005);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn005, true);
    jjtc005 = false;
  }
/*@egen*/
  { try {
    jjtn005.str = t.image;
    jjtn005.info = Runtime.parseString(t.image);
    } catch (ParseException e){
        token.next = token_source.getNextToken();
    throw generateParseException();
    }
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc005) {
      jjtree.closeNodeScope(jjtn005, true);
    }
  }
/*@egen*/
|
  BooleanLiteral()
|
  NullLiteral()
}

void BooleanLiteral()       :
{ Token t; }
{
  t="true"/*@bgen(jjtree) TrueNode */
           {
             SimpleNode jjtn001 = new SimpleNode(JJTTRUENODE);
             boolean jjtc001 = true;
             jjtree.openNodeScope(jjtn001);
           }
           try {
/*@egen*//*@bgen(jjtree)*/
           {
             jjtree.closeNodeScope(jjtn001, true);
             jjtc001 = false;
           }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
           } finally {
             if (jjtc001) {
               jjtree.closeNodeScope(jjtn001, true);
             }
           }
/*@egen*/
|
  t="false"/*@bgen(jjtree) FalseNode */
            {
              SimpleNode jjtn002 = new SimpleNode(JJTFALSENODE);
              boolean jjtc002 = true;
              jjtree.openNodeScope(jjtn002);
            }
            try {
/*@egen*//*@bgen(jjtree)*/
            {
              jjtree.closeNodeScope(jjtn002, true);
              jjtc002 = false;
            }
/*@egen*/ { jjtn002.setToken(t); }/*@bgen(jjtree)*/
            } finally {
              if (jjtc002) {
                jjtree.closeNodeScope(jjtn002, true);
              }
            }
/*@egen*/
}

void NullLiteral()       :
{ Token t; }
{
  t="null"/*@bgen(jjtree) NullNode */
           {
             SimpleNode jjtn001 = new SimpleNode(JJTNULLNODE);
             boolean jjtc001 = true;
             jjtree.openNodeScope(jjtn001);
           }
           try {
/*@egen*//*@bgen(jjtree)*/
           {
             jjtree.closeNodeScope(jjtn001, true);
             jjtc001 = false;
           }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
           } finally {
             if (jjtc001) {
               jjtree.closeNodeScope(jjtn001, true);
             }
           }
/*@egen*/
}

void Assignment()       :
{ Token t; }
{
  ( t="="    Eol() Expression()/*@bgen(jjtree) #Assignment( 2) */
                                {
                                  SimpleNode jjtn001 = new SimpleNode(JJTASSIGNMENT);
                                  boolean jjtc001 = true;
                                  jjtree.openNodeScope(jjtn001);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn001,  2);
                                  jjtc001 = false;
                                }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc001) {
                                    jjtree.closeNodeScope(jjtn001,  2);
                                  }
                                }
/*@egen*/
  | t="*="   Eol() Expression()/*@bgen(jjtree) #AssignmentTA( 2) */
                                {
                                  SimpleNode jjtn002 = new SimpleNode(JJTASSIGNMENTTA);
                                  boolean jjtc002 = true;
                                  jjtree.openNodeScope(jjtn002);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn002,  2);
                                  jjtc002 = false;
                                }
/*@egen*/ { jjtn002.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc002) {
                                    jjtree.closeNodeScope(jjtn002,  2);
                                  }
                                }
/*@egen*/
  | t="%="   Eol() Expression()/*@bgen(jjtree) #AssignmentMA( 2) */
                                {
                                  SimpleNode jjtn003 = new SimpleNode(JJTASSIGNMENTMA);
                                  boolean jjtc003 = true;
                                  jjtree.openNodeScope(jjtn003);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn003,  2);
                                  jjtc003 = false;
                                }
/*@egen*/ { jjtn003.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc003) {
                                    jjtree.closeNodeScope(jjtn003,  2);
                                  }
                                }
/*@egen*/
  | t="/="   Eol() Expression()/*@bgen(jjtree) #AssignmentDA( 2) */
                                {
                                  SimpleNode jjtn004 = new SimpleNode(JJTASSIGNMENTDA);
                                  boolean jjtc004 = true;
                                  jjtree.openNodeScope(jjtn004);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn004,  2);
                                  jjtc004 = false;
                                }
/*@egen*/ { jjtn004.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc004) {
                                    jjtree.closeNodeScope(jjtn004,  2);
                                  }
                                }
/*@egen*/
  | t="+="   Eol() Expression()/*@bgen(jjtree) #AssignmentPA( 2) */
                                {
                                  SimpleNode jjtn005 = new SimpleNode(JJTASSIGNMENTPA);
                                  boolean jjtc005 = true;
                                  jjtree.openNodeScope(jjtn005);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn005,  2);
                                  jjtc005 = false;
                                }
/*@egen*/ { jjtn005.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc005) {
                                    jjtree.closeNodeScope(jjtn005,  2);
                                  }
                                }
/*@egen*/
  | t="-="   Eol() Expression()/*@bgen(jjtree) #AssignmentSA( 2) */
                                {
                                  SimpleNode jjtn006 = new SimpleNode(JJTASSIGNMENTSA);
                                  boolean jjtc006 = true;
                                  jjtree.openNodeScope(jjtn006);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn006,  2);
                                  jjtc006 = false;
                                }
/*@egen*/ { jjtn006.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc006) {
                                    jjtree.closeNodeScope(jjtn006,  2);
                                  }
                                }
/*@egen*/
  | t="<<="  Eol() Expression()/*@bgen(jjtree) #AssignmentLA( 2) */
                                {
                                  SimpleNode jjtn007 = new SimpleNode(JJTASSIGNMENTLA);
                                  boolean jjtc007 = true;
                                  jjtree.openNodeScope(jjtn007);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn007,  2);
                                  jjtc007 = false;
                                }
/*@egen*/ { jjtn007.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc007) {
                                    jjtree.closeNodeScope(jjtn007,  2);
                                  }
                                }
/*@egen*/
  | t=">>="  Eol() Expression()/*@bgen(jjtree) #AssignmentRA( 2) */
                                {
                                  SimpleNode jjtn008 = new SimpleNode(JJTASSIGNMENTRA);
                                  boolean jjtc008 = true;
                                  jjtree.openNodeScope(jjtn008);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn008,  2);
                                  jjtc008 = false;
                                }
/*@egen*/ { jjtn008.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc008) {
                                    jjtree.closeNodeScope(jjtn008,  2);
                                  }
                                }
/*@egen*/
  | t=">>>=" Eol() Expression()/*@bgen(jjtree) #AssignmentRAA( 2) */
                                {
                                  SimpleNode jjtn009 = new SimpleNode(JJTASSIGNMENTRAA);
                                  boolean jjtc009 = true;
                                  jjtree.openNodeScope(jjtn009);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn009,  2);
                                  jjtc009 = false;
                                }
/*@egen*/ { jjtn009.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc009) {
                                    jjtree.closeNodeScope(jjtn009,  2);
                                  }
                                }
/*@egen*/
  | t="&="   Eol() Expression()/*@bgen(jjtree) #AssignmentAA( 2) */
                                {
                                  SimpleNode jjtn010 = new SimpleNode(JJTASSIGNMENTAA);
                                  boolean jjtc010 = true;
                                  jjtree.openNodeScope(jjtn010);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn010,  2);
                                  jjtc010 = false;
                                }
/*@egen*/ { jjtn010.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc010) {
                                    jjtree.closeNodeScope(jjtn010,  2);
                                  }
                                }
/*@egen*/
  | t="^="   Eol() Expression()/*@bgen(jjtree) #AssignmentEA( 2) */
                                {
                                  SimpleNode jjtn011 = new SimpleNode(JJTASSIGNMENTEA);
                                  boolean jjtc011 = true;
                                  jjtree.openNodeScope(jjtn011);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn011,  2);
                                  jjtc011 = false;
                                }
/*@egen*/ { jjtn011.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc011) {
                                    jjtree.closeNodeScope(jjtn011,  2);
                                  }
                                }
/*@egen*/
  | t="|="   Eol() Expression()/*@bgen(jjtree) #AssignmentOA( 2) */
                                {
                                  SimpleNode jjtn012 = new SimpleNode(JJTASSIGNMENTOA);
                                  boolean jjtc012 = true;
                                  jjtree.openNodeScope(jjtn012);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn012,  2);
                                  jjtc012 = false;
                                }
/*@egen*/ { jjtn012.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc012) {
                                    jjtree.closeNodeScope(jjtn012,  2);
                                  }
                                }
/*@egen*/
  )
}

void ConditionalExpression()       :
{}
{
  ConditionalAndExpression()
  ( "||" Eol()/*@bgen(jjtree) #OrNode( 2) */
               {
                 SimpleNode jjtn001 = new SimpleNode(JJTORNODE);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
               }
               try {
/*@egen*/ ConditionalAndExpression()/*@bgen(jjtree)*/
               } catch (Throwable jjte001) {
                 if (jjtc001) {
                   jjtree.clearNodeScope(jjtn001);
                   jjtc001 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte001 instanceof RuntimeException) {
                   throw (RuntimeException)jjte001;
                 }
                 if (jjte001 instanceof ParseException) {
                   throw (ParseException)jjte001;
                 }
                 throw (Error)jjte001;
               } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001,  2);
                 }
               }
/*@egen*/ )*
}


void ConditionalAndExpression()       :
{}
{
  InclusiveOrExpression()
  ( "&&" Eol()/*@bgen(jjtree) #AndNode( 2) */
               {
                 SimpleNode jjtn001 = new SimpleNode(JJTANDNODE);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
               }
               try {
/*@egen*/ InclusiveOrExpression()/*@bgen(jjtree)*/
               } catch (Throwable jjte001) {
                 if (jjtc001) {
                   jjtree.clearNodeScope(jjtn001);
                   jjtc001 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte001 instanceof RuntimeException) {
                   throw (RuntimeException)jjte001;
                 }
                 if (jjte001 instanceof ParseException) {
                   throw (ParseException)jjte001;
                 }
                 throw (Error)jjte001;
               } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001,  2);
                 }
               }
/*@egen*/ )*
}

void InclusiveOrExpression()       :
{ Token t = null; }
{
  ExclusiveOrExpression()
  ( t="|" Eol() ExclusiveOrExpression()/*@bgen(jjtree) #LogOrNode( 2) */
                                        {
                                          SimpleNode jjtn001 = new SimpleNode(JJTLOGORNODE);
                                          boolean jjtc001 = true;
                                          jjtree.openNodeScope(jjtn001);
                                        }
                                        try {
/*@egen*//*@bgen(jjtree)*/
                                        {
                                          jjtree.closeNodeScope(jjtn001,  2);
                                          jjtc001 = false;
                                        }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
                                        } finally {
                                          if (jjtc001) {
                                            jjtree.closeNodeScope(jjtn001,  2);
                                          }
                                        }
/*@egen*/ )*
}

void ExclusiveOrExpression()       :
{ Token t = null; }
{
  AndExpression()
  ( t="^" Eol() AndExpression()/*@bgen(jjtree) #LogExorNode( 2) */
                                {
                                  SimpleNode jjtn001 = new SimpleNode(JJTLOGEXORNODE);
                                  boolean jjtc001 = true;
                                  jjtree.openNodeScope(jjtn001);
                                }
                                try {
/*@egen*//*@bgen(jjtree)*/
                                {
                                  jjtree.closeNodeScope(jjtn001,  2);
                                  jjtc001 = false;
                                }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
                                } finally {
                                  if (jjtc001) {
                                    jjtree.closeNodeScope(jjtn001,  2);
                                  }
                                }
/*@egen*/ )*
}

void AndExpression()       :
{ Token t = null; }
{
  EqualityExpression()
  ( t="&" Eol() EqualityExpression()/*@bgen(jjtree) #LogAndNode( 2) */
                                     {
                                       SimpleNode jjtn001 = new SimpleNode(JJTLOGANDNODE);
                                       boolean jjtc001 = true;
                                       jjtree.openNodeScope(jjtn001);
                                     }
                                     try {
/*@egen*//*@bgen(jjtree)*/
                                     {
                                       jjtree.closeNodeScope(jjtn001,  2);
                                       jjtc001 = false;
                                     }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
                                     } finally {
                                       if (jjtc001) {
                                         jjtree.closeNodeScope(jjtn001,  2);
                                       }
                                     }
/*@egen*/ )*
}

void EqualityExpression()       :
{ Token t = null; }
{
  InstanceofExpression()
  (
     t="==" Eol() InstanceofExpression()/*@bgen(jjtree) #EqualNode( 2) */
                                         {
                                           SimpleNode jjtn001 = new SimpleNode(JJTEQUALNODE);
                                           boolean jjtc001 = true;
                                           jjtree.openNodeScope(jjtn001);
                                         }
                                         try {
/*@egen*//*@bgen(jjtree)*/
                                         {
                                           jjtree.closeNodeScope(jjtn001,  2);
                                           jjtc001 = false;
                                         }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
                                         } finally {
                                           if (jjtc001) {
                                             jjtree.closeNodeScope(jjtn001,  2);
                                           }
                                         }
/*@egen*/
  |
     t="!=" Eol() InstanceofExpression()/*@bgen(jjtree) #NotEqNode( 2) */
                                         {
                                           SimpleNode jjtn002 = new SimpleNode(JJTNOTEQNODE);
                                           boolean jjtc002 = true;
                                           jjtree.openNodeScope(jjtn002);
                                         }
                                         try {
/*@egen*//*@bgen(jjtree)*/
                                         {
                                           jjtree.closeNodeScope(jjtn002,  2);
                                           jjtc002 = false;
                                         }
/*@egen*/ { jjtn002.setToken(t); }/*@bgen(jjtree)*/
                                         } finally {
                                           if (jjtc002) {
                                             jjtree.closeNodeScope(jjtn002,  2);
                                           }
                                         }
/*@egen*/
  )*
}

void InstanceofExpression()      :
{ Token t = null; }
{
  RelationalExpression() 
   [ t="instanceof" RelationalExpression()/*@bgen(jjtree) #InstanceofExpression( 2) */
                                           {
                                             SimpleNode jjtn001 = new SimpleNode(JJTINSTANCEOFEXPRESSION);
                                             boolean jjtc001 = true;
                                             jjtree.openNodeScope(jjtn001);
                                           }
                                           try {
/*@egen*//*@bgen(jjtree)*/
                                           {
                                             jjtree.closeNodeScope(jjtn001,  2);
                                             jjtc001 = false;
                                           }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
                                           } finally {
                                             if (jjtc001) {
                                               jjtree.closeNodeScope(jjtn001,  2);
                                             }
                                           }
/*@egen*/ ]
}

void RelationalExpression()      :
{}
{
  ShiftExpression()
  ( 
     "<" Eol()/*@bgen(jjtree) #LTNode( 2) */
               {
                 SimpleNode jjtn001 = new SimpleNode(JJTLTNODE);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
               }
               try {
/*@egen*/ ShiftExpression()/*@bgen(jjtree)*/
               } catch (Throwable jjte001) {
                 if (jjtc001) {
                   jjtree.clearNodeScope(jjtn001);
                   jjtc001 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte001 instanceof RuntimeException) {
                   throw (RuntimeException)jjte001;
                 }
                 if (jjte001 instanceof ParseException) {
                   throw (ParseException)jjte001;
                 }
                 throw (Error)jjte001;
               } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001,  2);
                 }
               }
/*@egen*/
  |
     ">" Eol()/*@bgen(jjtree) #GTNode( 2) */
               {
                 SimpleNode jjtn002 = new SimpleNode(JJTGTNODE);
                 boolean jjtc002 = true;
                 jjtree.openNodeScope(jjtn002);
               }
               try {
/*@egen*/ ShiftExpression()/*@bgen(jjtree)*/
               } catch (Throwable jjte002) {
                 if (jjtc002) {
                   jjtree.clearNodeScope(jjtn002);
                   jjtc002 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte002 instanceof RuntimeException) {
                   throw (RuntimeException)jjte002;
                 }
                 if (jjte002 instanceof ParseException) {
                   throw (ParseException)jjte002;
                 }
                 throw (Error)jjte002;
               } finally {
                 if (jjtc002) {
                   jjtree.closeNodeScope(jjtn002,  2);
                 }
               }
/*@egen*/
  |
     "<=" Eol()/*@bgen(jjtree) #LENode( 2) */
                {
                  SimpleNode jjtn003 = new SimpleNode(JJTLENODE);
                  boolean jjtc003 = true;
                  jjtree.openNodeScope(jjtn003);
                }
                try {
/*@egen*/ ShiftExpression()/*@bgen(jjtree)*/
                } catch (Throwable jjte003) {
                  if (jjtc003) {
                    jjtree.clearNodeScope(jjtn003);
                    jjtc003 = false;
                  } else {
                    jjtree.popNode();
                  }
                  if (jjte003 instanceof RuntimeException) {
                    throw (RuntimeException)jjte003;
                  }
                  if (jjte003 instanceof ParseException) {
                    throw (ParseException)jjte003;
                  }
                  throw (Error)jjte003;
                } finally {
                  if (jjtc003) {
                    jjtree.closeNodeScope(jjtn003,  2);
                  }
                }
/*@egen*/
  |
     ">=" Eol()/*@bgen(jjtree) #GENode( 2) */
                {
                  SimpleNode jjtn004 = new SimpleNode(JJTGENODE);
                  boolean jjtc004 = true;
                  jjtree.openNodeScope(jjtn004);
                }
                try {
/*@egen*/ ShiftExpression()/*@bgen(jjtree)*/
                } catch (Throwable jjte004) {
                  if (jjtc004) {
                    jjtree.clearNodeScope(jjtn004);
                    jjtc004 = false;
                  } else {
                    jjtree.popNode();
                  }
                  if (jjte004 instanceof RuntimeException) {
                    throw (RuntimeException)jjte004;
                  }
                  if (jjte004 instanceof ParseException) {
                    throw (ParseException)jjte004;
                  }
                  throw (Error)jjte004;
                } finally {
                  if (jjtc004) {
                    jjtree.closeNodeScope(jjtn004,  2);
                  }
                }
/*@egen*/
  )*
}

void ShiftExpression()       :
{ Token t; }
{
  AdditiveExpression()
  (
    t="<<" Eol() AdditiveExpression()/*@bgen(jjtree) #ShiftLeftNode( 2) */
                                      {
                                        SimpleNode jjtn001 = new SimpleNode(JJTSHIFTLEFTNODE);
                                        boolean jjtc001 = true;
                                        jjtree.openNodeScope(jjtn001);
                                      }
                                      try {
/*@egen*//*@bgen(jjtree)*/
                                      {
                                        jjtree.closeNodeScope(jjtn001,  2);
                                        jjtc001 = false;
                                      }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
                                      } finally {
                                        if (jjtc001) {
                                          jjtree.closeNodeScope(jjtn001,  2);
                                        }
                                      }
/*@egen*/
  |
    t=">>" Eol() AdditiveExpression()/*@bgen(jjtree) #ShiftRightNode( 2) */
                                      {
                                        SimpleNode jjtn002 = new SimpleNode(JJTSHIFTRIGHTNODE);
                                        boolean jjtc002 = true;
                                        jjtree.openNodeScope(jjtn002);
                                      }
                                      try {
/*@egen*//*@bgen(jjtree)*/
                                      {
                                        jjtree.closeNodeScope(jjtn002,  2);
                                        jjtc002 = false;
                                      }
/*@egen*/ { jjtn002.setToken(t); }/*@bgen(jjtree)*/
                                      } finally {
                                        if (jjtc002) {
                                          jjtree.closeNodeScope(jjtn002,  2);
                                        }
                                      }
/*@egen*/
  |
    t=">>>" Eol() AdditiveExpression()/*@bgen(jjtree) #ShiftArithmeticNode( 2) */
                                       {
                                         SimpleNode jjtn003 = new SimpleNode(JJTSHIFTARITHMETICNODE);
                                         boolean jjtc003 = true;
                                         jjtree.openNodeScope(jjtn003);
                                       }
                                       try {
/*@egen*//*@bgen(jjtree)*/
                                       {
                                         jjtree.closeNodeScope(jjtn003,  2);
                                         jjtc003 = false;
                                       }
/*@egen*/ { jjtn003.setToken(t); }/*@bgen(jjtree)*/
                                       } finally {
                                         if (jjtc003) {
                                           jjtree.closeNodeScope(jjtn003,  2);
                                         }
                                       }
/*@egen*/
  )*
}

void AdditiveExpression()       :
{ Token t; }
{
  MultiplicativeExpression()
  (
    t="+" Eol() MultiplicativeExpression()/*@bgen(jjtree) #AddNode( 2) */
  {
    SimpleNode jjtn001 = new SimpleNode(JJTADDNODE);
    boolean jjtc001 = true;
    jjtree.openNodeScope(jjtn001);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn001,  2);
    jjtc001 = false;
  }
/*@egen*/
  {
     jjtn001.setToken(t);
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc001) {
      jjtree.closeNodeScope(jjtn001,  2);
    }
  }
/*@egen*/
  |
    t="-" Eol() MultiplicativeExpression()/*@bgen(jjtree) #SubtractNode( 2) */
  {
    SimpleNode jjtn002 = new SimpleNode(JJTSUBTRACTNODE);
    boolean jjtc002 = true;
    jjtree.openNodeScope(jjtn002);
  }
  try {
/*@egen*//*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn002,  2);
    jjtc002 = false;
  }
/*@egen*/
  {
     jjtn002.setToken(t);
  }/*@bgen(jjtree)*/
  } finally {
    if (jjtc002) {
      jjtree.closeNodeScope(jjtn002,  2);
    }
  }
/*@egen*/
  )*
}

void MultiplicativeExpression()       :
{ Token t; }
{
  UnaryExpression()
  (
    t="*" Eol() UnaryExpression()/*@bgen(jjtree) #MultNode( 2) */
                                  {
                                    SimpleNode jjtn001 = new SimpleNode(JJTMULTNODE);
                                    boolean jjtc001 = true;
                                    jjtree.openNodeScope(jjtn001);
                                  }
                                  try {
/*@egen*//*@bgen(jjtree)*/
                                  {
                                    jjtree.closeNodeScope(jjtn001,  2);
                                    jjtc001 = false;
                                  }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
                                  } finally {
                                    if (jjtc001) {
                                      jjtree.closeNodeScope(jjtn001,  2);
                                    }
                                  }
/*@egen*/
  |
    t="/" Eol() UnaryExpression()/*@bgen(jjtree) #DivideNode( 2) */
                                  {
                                    SimpleNode jjtn002 = new SimpleNode(JJTDIVIDENODE);
                                    boolean jjtc002 = true;
                                    jjtree.openNodeScope(jjtn002);
                                  }
                                  try {
/*@egen*//*@bgen(jjtree)*/
                                  {
                                    jjtree.closeNodeScope(jjtn002,  2);
                                    jjtc002 = false;
                                  }
/*@egen*/ { jjtn002.setToken(t); }/*@bgen(jjtree)*/
                                  } finally {
                                    if (jjtc002) {
                                      jjtree.closeNodeScope(jjtn002,  2);
                                    }
                                  }
/*@egen*/
  |
    t="%" Eol() UnaryExpression()/*@bgen(jjtree) #ModNode( 2) */
                                  {
                                    SimpleNode jjtn003 = new SimpleNode(JJTMODNODE);
                                    boolean jjtc003 = true;
                                    jjtree.openNodeScope(jjtn003);
                                  }
                                  try {
/*@egen*//*@bgen(jjtree)*/
                                  {
                                    jjtree.closeNodeScope(jjtn003,  2);
                                    jjtc003 = false;
                                  }
/*@egen*/ { jjtn003.setToken(t); }/*@bgen(jjtree)*/
                                  } finally {
                                    if (jjtc003) {
                                      jjtree.closeNodeScope(jjtn003,  2);
                                    }
                                  }
/*@egen*/
  )*
}

void UnaryExpression()       :
{ Token t; }
{
  t="+" UnaryExpression()
|
  t="-" UnaryExpression()/*@bgen(jjtree) #NegativeNode( 1) */
                          {
                            SimpleNode jjtn001 = new SimpleNode(JJTNEGATIVENODE);
                            boolean jjtc001 = true;
                            jjtree.openNodeScope(jjtn001);
                          }
                          try {
/*@egen*//*@bgen(jjtree)*/
                          {
                            jjtree.closeNodeScope(jjtn001,  1);
                            jjtc001 = false;
                          }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
                          } finally {
                            if (jjtc001) {
                              jjtree.closeNodeScope(jjtn001,  1);
                            }
                          }
/*@egen*/
|
  t="++" PrimaryExpression()/*@bgen(jjtree) #PreIncrNode( 1) */
                             {
                               SimpleNode jjtn002 = new SimpleNode(JJTPREINCRNODE);
                               boolean jjtc002 = true;
                               jjtree.openNodeScope(jjtn002);
                             }
                             try {
/*@egen*//*@bgen(jjtree)*/
                             {
                               jjtree.closeNodeScope(jjtn002,  1);
                               jjtc002 = false;
                             }
/*@egen*/ { jjtn002.setToken(t); }/*@bgen(jjtree)*/
                             } finally {
                               if (jjtc002) {
                                 jjtree.closeNodeScope(jjtn002,  1);
                               }
                             }
/*@egen*/
|
  t="--" PrimaryExpression()/*@bgen(jjtree) #PreDecrNode( 1) */
                             {
                               SimpleNode jjtn003 = new SimpleNode(JJTPREDECRNODE);
                               boolean jjtc003 = true;
                               jjtree.openNodeScope(jjtn003);
                             }
                             try {
/*@egen*//*@bgen(jjtree)*/
                             {
                               jjtree.closeNodeScope(jjtn003,  1);
                               jjtc003 = false;
                             }
/*@egen*/ { jjtn003.setToken(t); }/*@bgen(jjtree)*/
                             } finally {
                               if (jjtc003) {
                                 jjtree.closeNodeScope(jjtn003,  1);
                               }
                             }
/*@egen*/
|
  UnaryExpressionNotPlusMinus()
}

void UnaryExpressionNotPlusMinus()       :
{ Token t; }
{
    t="~" UnaryExpression()/*@bgen(jjtree) #LogNotNode( 1) */
                            {
                              SimpleNode jjtn001 = new SimpleNode(JJTLOGNOTNODE);
                              boolean jjtc001 = true;
                              jjtree.openNodeScope(jjtn001);
                            }
                            try {
/*@egen*//*@bgen(jjtree)*/
                            {
                              jjtree.closeNodeScope(jjtn001,  1);
                              jjtc001 = false;
                            }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
                            } finally {
                              if (jjtc001) {
                                jjtree.closeNodeScope(jjtn001,  1);
                              }
                            }
/*@egen*/
  |
    t="!" UnaryExpression()/*@bgen(jjtree) #NotNode( 1) */
                            {
                              SimpleNode jjtn002 = new SimpleNode(JJTNOTNODE);
                              boolean jjtc002 = true;
                              jjtree.openNodeScope(jjtn002);
                            }
                            try {
/*@egen*//*@bgen(jjtree)*/
                            {
                              jjtree.closeNodeScope(jjtn002,  1);
                              jjtc002 = false;
                            }
/*@egen*/ { jjtn002.setToken(t); }/*@bgen(jjtree)*/
                            } finally {
                              if (jjtc002) {
                                jjtree.closeNodeScope(jjtn002,  1);
                              }
                            }
/*@egen*/
  |
    LOOKAHEAD(CastLookAhead())
    CastExpression()
  |
    PostOpe()
}

void CastLookAhead()       :
{}
{
   "(" <IDENTIFIER> ( "[" "]" )* ")" FirstSet()
}

void FirstSet()       :
{}
{
   ( <IDENTIFIER> | "::" | Literal() | "++" | "--" | "~" | "!" | "[" | "(" | "class" )
}

void FirstSet2()       :
{}
{
   ( <IF> | <WHILE> | <FOR> | <FOREACH> | <SWITCH> | <FUNCTION> |
     <CATCH> | <RETURN> | <BREAK> | <CONTINUE> )
}

void CastExpression()       :
{ Token t; }
{
   t="(" PrimaryExpression() ")" UnaryExpressionNotPlusMinus()/*@bgen(jjtree) #CastExpression( 2) */
   {
     SimpleNode jjtn001 = new SimpleNode(JJTCASTEXPRESSION);
     boolean jjtc001 = true;
     jjtree.openNodeScope(jjtn001);
   }
   try {
/*@egen*//*@bgen(jjtree)*/
   {
     jjtree.closeNodeScope(jjtn001,  2);
     jjtc001 = false;
   }
/*@egen*/
   { jjtn001.setToken(t); }/*@bgen(jjtree)*/
   } finally {
     if (jjtc001) {
       jjtree.closeNodeScope(jjtn001,  2);
     }
   }
/*@egen*/
}

void PostOpe()       : 
{ Token t; }
{
  PrimaryExpression()
  [
    t="++"/*@bgen(jjtree) #PostIncrNode( 1) */
           {
             SimpleNode jjtn001 = new SimpleNode(JJTPOSTINCRNODE);
             boolean jjtc001 = true;
             jjtree.openNodeScope(jjtn001);
           }
           try {
/*@egen*//*@bgen(jjtree)*/
           {
             jjtree.closeNodeScope(jjtn001,  1);
             jjtc001 = false;
           }
/*@egen*/ { jjtn001.setToken(t); }/*@bgen(jjtree)*/
           } finally {
             if (jjtc001) {
               jjtree.closeNodeScope(jjtn001,  1);
             }
           }
/*@egen*/
   |
    t="--"/*@bgen(jjtree) #PostDecrNode( 1) */
           {
             SimpleNode jjtn002 = new SimpleNode(JJTPOSTDECRNODE);
             boolean jjtc002 = true;
             jjtree.openNodeScope(jjtn002);
           }
           try {
/*@egen*//*@bgen(jjtree)*/
           {
             jjtree.closeNodeScope(jjtn002,  1);
             jjtc002 = false;
           }
/*@egen*/ { jjtn002.setToken(t); }/*@bgen(jjtree)*/
           } finally {
             if (jjtc002) {
               jjtree.closeNodeScope(jjtn002,  1);
             }
           }
/*@egen*/
  ]
}

void StatementExpression()       :
{}
{
  IfStatement()
|
  WhileStatement()
|
  ForeachStatement()
|
  ForStatement()
|
  SwitchStatement()
|
  Break()
|
  Continue()
|
  Return()
|
  FunctionStatement()
|
  CatchNode()
}

void Break() :
{/*@bgen(jjtree) Break */
  SimpleNode jjtn000 = new SimpleNode(JJTBREAK);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) Break */
  try {
/*@egen*/
  t=<BREAK> [ Expression() ]/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  { jjtn000.setToken(t); }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void Continue() :
{/*@bgen(jjtree) Continue */
  SimpleNode jjtn000 = new SimpleNode(JJTCONTINUE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t;}
{/*@bgen(jjtree) Continue */
  try {
/*@egen*/
  t=<CONTINUE>/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  { jjtn000.setToken(t); }/*@bgen(jjtree)*/
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void Return() :
{/*@bgen(jjtree) Return */
  SimpleNode jjtn000 = new SimpleNode(JJTRETURN);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) Return */
  try {
/*@egen*/
  t=<RETURN> [ Expression() ]/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  { jjtn000.setToken(t); }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void Block() :
{/*@bgen(jjtree) Block */
  SimpleNode jjtn000 = new SimpleNode(JJTBLOCK);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t1, t2; }
{/*@bgen(jjtree) Block */
   try {
/*@egen*/
   t1="{" Eol() [ Expression() ( (";" |<EOL>) [ Expression() ] )* ] t2="}"/*@bgen(jjtree)*/
   {
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
   }
/*@egen*/
   {
      jjtn000.info = new Object[]{Boolean.FALSE, Boolean.FALSE, null};
      jjtn000.setToken(t1, t2);
   }
|
   Expression()/*@bgen(jjtree)*/
   {
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
   }
/*@egen*/
   {
      jjtn000.info = new Object[]{Boolean.FALSE, Boolean.FALSE, null};
   }
|
    ";"/*@bgen(jjtree)*/
   } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       throw (RuntimeException)jjte000;
     }
     if (jjte000 instanceof ParseException) {
       throw (ParseException)jjte000;
     }
     throw (Error)jjte000;
   } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
   }
/*@egen*/
}

void IfStatement() :
{/*@bgen(jjtree) IfStatement */
  SimpleNode jjtn000 = new SimpleNode(JJTIFSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) IfStatement */
  try {
/*@egen*/
  t=<IF> "(" Expression() ")" Eol() Block()
  ( LOOKAHEAD(Eol() <ELSE> <IF>) ElseIfNode() )*
  [ LOOKAHEAD(Eol() <ELSE> Eol() ("{" | FirstSet() | FirstSet2())) ElseNode() ]/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
    jjtn000.setToken(t);
  }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void ElseIfNode() :
{/*@bgen(jjtree) ElseIfNode */
  SimpleNode jjtn000 = new SimpleNode(JJTELSEIFNODE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ElseIfNode */
  try {
/*@egen*/
  Eol() <ELSE> <IF> "(" Expression() ")" Eol() Block()/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void ElseNode() : 
{/*@bgen(jjtree) ElseNode */
  SimpleNode jjtn000 = new SimpleNode(JJTELSENODE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) ElseNode */
  try {
/*@egen*/
  Eol() t=<ELSE> Eol() Block()/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  { jjtn000.setToken(t); }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void WhileStatement() :
{/*@bgen(jjtree) WhileStatement */
  SimpleNode jjtn000 = new SimpleNode(JJTWHILESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) WhileStatement */
  try {
/*@egen*/
  t=<WHILE> "(" Expression() ")" Eol() Block()/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
    jjtn000.setToken(t);
    jjtn000.info = new Object[]{Boolean.FALSE, Boolean.FALSE, null};
  }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}


void ForStatement() :
{/*@bgen(jjtree) ForStatement */
  SimpleNode jjtn000 = new SimpleNode(JJTFORSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) ForStatement */
  try {
/*@egen*/
  t=<FOR> "(" [ ForInit() ] ";" Eol()
            [ Expression() ] ";" Eol()
            [ ForUpdate() ] ")" Eol()
  Block()/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
    jjtn000.setToken(t);
    jjtn000.info = new Object[]{Boolean.FALSE, Boolean.FALSE, null};
  }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void ForInit() :
{/*@bgen(jjtree) ForInit */
  SimpleNode jjtn000 = new SimpleNode(JJTFORINIT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ForInit */
  try {
/*@egen*/
  Local() ( "," Eol() Local() )*/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void ForUpdate() :
{/*@bgen(jjtree) ForUpdate */
  SimpleNode jjtn000 = new SimpleNode(JJTFORUPDATE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) ForUpdate */
  try {
/*@egen*/
  Expression() ( "," Eol() Expression() )*/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void Local() :
{/*@bgen(jjtree) Local */
  SimpleNode jjtn000 = new SimpleNode(JJTLOCAL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) Local */
  try {
/*@egen*/
  t=<IDENTIFIER> "=" Eol() Expression()/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  { jjtn000.str = t.image.intern(); }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void ForeachStatement() :
{/*@bgen(jjtree) ForeachStatement */
  SimpleNode jjtn000 = new SimpleNode(JJTFOREACHSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) ForeachStatement */
  try {
/*@egen*/
  <FOREACH> t = <IDENTIFIER> 
  (
     List()
  |
     "(" Expression() ")"
  )
  Eol() Block()/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
     jjtn000.str = t.image.intern();
     jjtn000.setToken(t);
     jjtn000.info = new Object[]{Boolean.FALSE, Boolean.FALSE, null};
  }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void SwitchStatement() :
{/*@bgen(jjtree) SwitchStatement */
  SimpleNode jjtn000 = new SimpleNode(JJTSWITCHSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t1, t2; }
{/*@bgen(jjtree) SwitchStatement */
  try {
/*@egen*/
  t1=<SWITCH> "(" Expression() ")" Eol() "{" Eol()
    ( SwitchLabel() SwitchBlock() )*
  t2="}"/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
     jjtn000.setToken(t1, t2);
     jjtn000.info = new Object[]{Boolean.FALSE, Boolean.FALSE, null};
  }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void SwitchBlock() :
{/*@bgen(jjtree) SwitchBlock */
  SimpleNode jjtn000 = new SimpleNode(JJTSWITCHBLOCK);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SwitchBlock */
   try {
/*@egen*/
   Eol() (Expression() (";" |<EOL>) Eol() )*/*@bgen(jjtree)*/
   {
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
   }
/*@egen*/
   {
     jjtn000.info = new Object[]{Boolean.FALSE, Boolean.FALSE, null};
   }/*@bgen(jjtree)*/
   } catch (Throwable jjte000) {
     if (jjtc000) {
       jjtree.clearNodeScope(jjtn000);
       jjtc000 = false;
     } else {
       jjtree.popNode();
     }
     if (jjte000 instanceof RuntimeException) {
       throw (RuntimeException)jjte000;
     }
     if (jjte000 instanceof ParseException) {
       throw (ParseException)jjte000;
     }
     throw (Error)jjte000;
   } finally {
     if (jjtc000) {
       jjtree.closeNodeScope(jjtn000, true);
     }
   }
/*@egen*/
}

void SwitchLabel() :
{/*@bgen(jjtree) SwitchLabel */
  SimpleNode jjtn000 = new SimpleNode(JJTSWITCHLABEL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SwitchLabel */
  try {
/*@egen*/
  "case" Expression() ":"
|
  "default" ":"/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void FunctionStatement() :
{/*@bgen(jjtree) FunctionStatement */
  SimpleNode jjtn000 = new SimpleNode(JJTFUNCTIONSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t = null; Token f = null; }
{/*@bgen(jjtree) FunctionStatement */
  try {
/*@egen*/
  f=<FUNCTION> [t = <IDENTIFIER>]
  "("/*@bgen(jjtree) ParamList */
      {
        SimpleNode jjtn001 = new SimpleNode(JJTPARAMLIST);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
      }
      try {
/*@egen*/ [ ParamList() ]/*@bgen(jjtree)*/
      } catch (Throwable jjte001) {
        if (jjtc001) {
          jjtree.clearNodeScope(jjtn001);
          jjtc001 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte001 instanceof RuntimeException) {
          throw (RuntimeException)jjte001;
        }
        if (jjte001 instanceof ParseException) {
          throw (ParseException)jjte001;
        }
        throw (Error)jjte001;
      } finally {
        if (jjtc001) {
          jjtree.closeNodeScope(jjtn001, true);
        }
      }
/*@egen*/ ")" Eol()  Block()/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  {
     if (t != null) {
    jjtn000.str = t.image.intern();
        jjtn000.setToken(t);
     }
     jjtn000.info = new int[]{1};
  }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}

void ParamList()       :
{ Token t; }
{
  Param() (
           "["/*@bgen(jjtree) #IndexNode( 1) */
               {
                 SimpleNode jjtn001 = new SimpleNode(JJTINDEXNODE);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
               }
               try {
/*@egen*/ "]"/*@bgen(jjtree)*/
               } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001,  1);
                 }
               }
/*@egen*/
          |
           ("," Param() )*
          )
}

void Param() :
{/*@bgen(jjtree) Param */
  SimpleNode jjtn000 = new SimpleNode(JJTPARAM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ Token t; }
{/*@bgen(jjtree) Param */
  try {
/*@egen*/
  Eol() t = <IDENTIFIER> Eol()/*@bgen(jjtree)*/
  {
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
  }
/*@egen*/
  { jjtn000.str = t.image.intern(); }/*@bgen(jjtree)*/
  } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      throw (RuntimeException)jjte000;
    }
    if (jjte000 instanceof ParseException) {
      throw (ParseException)jjte000;
    }
    throw (Error)jjte000;
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
/*@egen*/
}
