    001    /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
    002    package org.apache.commons.jexl2.parser;
    003
    004    import java.io.Reader;
    005    import org.apache.commons.jexl2.JexlInfo;
    006
    007    public class Parser extends JexlParser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/
    008      protected JJTParserState jjtree = new JJTParserState();public boolean ALLOW_REGISTERS = false;
    009
    010        public ASTJexlScript parse(Reader reader, JexlInfo info)
    011            throws ParseException {
    012            /*
    013             * If registers are allowed, the default parser state has to be REGISTERS.
    014             */
    015            if (ALLOW_REGISTERS) {
    016                token_source.defaultLexState = REGISTERS;
    017            }
    018            ReInit(reader);
    019            /*
    020             *  lets do the 'Unique Init' in here to be
    021             *  safe - it's a pain to remember
    022             */
    023
    024            ASTJexlScript tree = JexlScript();
    025            tree.value = info;
    026            return tree;
    027        }
    028
    029    /***************************************
    030     *      Statements
    031     ***************************************/
    032      final public ASTJexlScript JexlScript() throws ParseException {
    033                                  /*@bgen(jjtree) JexlScript */
    034      ASTJexlScript jjtn000 = new ASTJexlScript(JJTJEXLSCRIPT);
    035      boolean jjtc000 = true;
    036      jjtree.openNodeScope(jjtn000);
    037      jjtreeOpenNodeScope(jjtn000);
    038        try {
    039          label_1:
    040          while (true) {
    041            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    042            case IF:
    043            case FOR:
    044            case FOREACH:
    045            case WHILE:
    046            case NEW:
    047            case VAR:
    048            case EMPTY:
    049            case SIZE:
    050            case NULL:
    051            case TRUE:
    052            case FALSE:
    053            case RETURN:
    054            case LPAREN:
    055            case LCURLY:
    056            case LBRACKET:
    057            case SEMICOL:
    058            case not:
    059            case minus:
    060            case tilda:
    061            case IDENTIFIER:
    062            case REGISTER:
    063            case INTEGER_LITERAL:
    064            case FLOAT_LITERAL:
    065            case STRING_LITERAL:
    066              ;
    067              break;
    068            default:
    069              jj_la1[0] = jj_gen;
    070              break label_1;
    071            }
    072            Statement();
    073          }
    074          jj_consume_token(0);
    075         jjtree.closeNodeScope(jjtn000, true);
    076         jjtc000 = false;
    077         jjtreeCloseNodeScope(jjtn000);
    078         {if (true) return jjtn000;}
    079        } catch (Throwable jjte000) {
    080         if (jjtc000) {
    081           jjtree.clearNodeScope(jjtn000);
    082           jjtc000 = false;
    083         } else {
    084           jjtree.popNode();
    085         }
    086         if (jjte000 instanceof RuntimeException) {
    087           {if (true) throw (RuntimeException)jjte000;}
    088         }
    089         if (jjte000 instanceof ParseException) {
    090           {if (true) throw (ParseException)jjte000;}
    091         }
    092         {if (true) throw (Error)jjte000;}
    093        } finally {
    094         if (jjtc000) {
    095           jjtree.closeNodeScope(jjtn000, true);
    096           jjtreeCloseNodeScope(jjtn000);
    097         }
    098        }
    099        throw new Error("Missing return statement in function");
    100      }
    101
    102      final public void Statement() throws ParseException {
    103        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    104        case SEMICOL:
    105          jj_consume_token(SEMICOL);
    106          break;
    107        default:
    108          jj_la1[1] = jj_gen;
    109          if (jj_2_1(3)) {
    110            Block();
    111          } else {
    112            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    113            case IF:
    114              IfStatement();
    115              break;
    116            case FOR:
    117            case FOREACH:
    118              ForeachStatement();
    119              break;
    120            case WHILE:
    121              WhileStatement();
    122              break;
    123            case NEW:
    124            case EMPTY:
    125            case SIZE:
    126            case NULL:
    127            case TRUE:
    128            case FALSE:
    129            case LPAREN:
    130            case LCURLY:
    131            case LBRACKET:
    132            case not:
    133            case minus:
    134            case tilda:
    135            case IDENTIFIER:
    136            case REGISTER:
    137            case INTEGER_LITERAL:
    138            case FLOAT_LITERAL:
    139            case STRING_LITERAL:
    140              ExpressionStatement();
    141              break;
    142            case RETURN:
    143              ReturnStatement();
    144              break;
    145            case VAR:
    146              Var();
    147              break;
    148            default:
    149              jj_la1[2] = jj_gen;
    150              jj_consume_token(-1);
    151              throw new ParseException();
    152            }
    153          }
    154        }
    155      }
    156
    157      final public void Block() throws ParseException {
    158                           /*@bgen(jjtree) Block */
    159      ASTBlock jjtn000 = new ASTBlock(JJTBLOCK);
    160      boolean jjtc000 = true;
    161      jjtree.openNodeScope(jjtn000);
    162      jjtreeOpenNodeScope(jjtn000);
    163        try {
    164          jj_consume_token(LCURLY);
    165          label_2:
    166          while (true) {
    167            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    168            case IF:
    169            case FOR:
    170            case FOREACH:
    171            case WHILE:
    172            case NEW:
    173            case VAR:
    174            case EMPTY:
    175            case SIZE:
    176            case NULL:
    177            case TRUE:
    178            case FALSE:
    179            case RETURN:
    180            case LPAREN:
    181            case LCURLY:
    182            case LBRACKET:
    183            case SEMICOL:
    184            case not:
    185            case minus:
    186            case tilda:
    187            case IDENTIFIER:
    188            case REGISTER:
    189            case INTEGER_LITERAL:
    190            case FLOAT_LITERAL:
    191            case STRING_LITERAL:
    192              ;
    193              break;
    194            default:
    195              jj_la1[3] = jj_gen;
    196              break label_2;
    197            }
    198            Statement();
    199          }
    200          jj_consume_token(RCURLY);
    201        } catch (Throwable jjte000) {
    202          if (jjtc000) {
    203            jjtree.clearNodeScope(jjtn000);
    204            jjtc000 = false;
    205          } else {
    206            jjtree.popNode();
    207          }
    208          if (jjte000 instanceof RuntimeException) {
    209            {if (true) throw (RuntimeException)jjte000;}
    210          }
    211          if (jjte000 instanceof ParseException) {
    212            {if (true) throw (ParseException)jjte000;}
    213          }
    214          {if (true) throw (Error)jjte000;}
    215        } finally {
    216          if (jjtc000) {
    217            jjtree.closeNodeScope(jjtn000, true);
    218            jjtreeCloseNodeScope(jjtn000);
    219          }
    220        }
    221      }
    222
    223      final public void ExpressionStatement() throws ParseException {
    224        Expression();
    225        label_3:
    226        while (true) {
    227          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    228          case NEW:
    229          case EMPTY:
    230          case SIZE:
    231          case NULL:
    232          case TRUE:
    233          case FALSE:
    234          case LPAREN:
    235          case LCURLY:
    236          case LBRACKET:
    237          case not:
    238          case minus:
    239          case tilda:
    240          case IDENTIFIER:
    241          case REGISTER:
    242          case INTEGER_LITERAL:
    243          case FLOAT_LITERAL:
    244          case STRING_LITERAL:
    245            ;
    246            break;
    247          default:
    248            jj_la1[4] = jj_gen;
    249            break label_3;
    250          }
    251                                     ASTAmbiguous jjtn001 = new ASTAmbiguous(JJTAMBIGUOUS);
    252                                     boolean jjtc001 = true;
    253                                     jjtree.openNodeScope(jjtn001);
    254                                     jjtreeOpenNodeScope(jjtn001);
    255          try {
    256            Expression();
    257          } catch (Throwable jjte001) {
    258                                     if (jjtc001) {
    259                                       jjtree.clearNodeScope(jjtn001);
    260                                       jjtc001 = false;
    261                                     } else {
    262                                       jjtree.popNode();
    263                                     }
    264                                     if (jjte001 instanceof RuntimeException) {
    265                                       {if (true) throw (RuntimeException)jjte001;}
    266                                     }
    267                                     if (jjte001 instanceof ParseException) {
    268                                       {if (true) throw (ParseException)jjte001;}
    269                                     }
    270                                     {if (true) throw (Error)jjte001;}
    271          } finally {
    272                                     if (jjtc001) {
    273                                       jjtree.closeNodeScope(jjtn001, true);
    274                                       jjtreeCloseNodeScope(jjtn001);
    275                                     }
    276          }
    277        }
    278        if (jj_2_2(2)) {
    279          jj_consume_token(SEMICOL);
    280        } else {
    281          ;
    282        }
    283      }
    284
    285      final public void IfStatement() throws ParseException {
    286                          /*@bgen(jjtree) IfStatement */
    287      ASTIfStatement jjtn000 = new ASTIfStatement(JJTIFSTATEMENT);
    288      boolean jjtc000 = true;
    289      jjtree.openNodeScope(jjtn000);
    290      jjtreeOpenNodeScope(jjtn000);
    291        try {
    292          jj_consume_token(IF);
    293          jj_consume_token(LPAREN);
    294          Expression();
    295          jj_consume_token(RPAREN);
    296          Statement();
    297          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    298          case ELSE:
    299            jj_consume_token(ELSE);
    300            Statement();
    301            break;
    302          default:
    303            jj_la1[5] = jj_gen;
    304            ;
    305          }
    306        } catch (Throwable jjte000) {
    307          if (jjtc000) {
    308            jjtree.clearNodeScope(jjtn000);
    309            jjtc000 = false;
    310          } else {
    311            jjtree.popNode();
    312          }
    313          if (jjte000 instanceof RuntimeException) {
    314            {if (true) throw (RuntimeException)jjte000;}
    315          }
    316          if (jjte000 instanceof ParseException) {
    317            {if (true) throw (ParseException)jjte000;}
    318          }
    319          {if (true) throw (Error)jjte000;}
    320        } finally {
    321          if (jjtc000) {
    322            jjtree.closeNodeScope(jjtn000, true);
    323            jjtreeCloseNodeScope(jjtn000);
    324          }
    325        }
    326      }
    327
    328      final public void WhileStatement() throws ParseException {
    329                             /*@bgen(jjtree) WhileStatement */
    330      ASTWhileStatement jjtn000 = new ASTWhileStatement(JJTWHILESTATEMENT);
    331      boolean jjtc000 = true;
    332      jjtree.openNodeScope(jjtn000);
    333      jjtreeOpenNodeScope(jjtn000);
    334        try {
    335          jj_consume_token(WHILE);
    336          jj_consume_token(LPAREN);
    337          Expression();
    338          jj_consume_token(RPAREN);
    339          Statement();
    340        } catch (Throwable jjte000) {
    341          if (jjtc000) {
    342            jjtree.clearNodeScope(jjtn000);
    343            jjtc000 = false;
    344          } else {
    345            jjtree.popNode();
    346          }
    347          if (jjte000 instanceof RuntimeException) {
    348            {if (true) throw (RuntimeException)jjte000;}
    349          }
    350          if (jjte000 instanceof ParseException) {
    351            {if (true) throw (ParseException)jjte000;}
    352          }
    353          {if (true) throw (Error)jjte000;}
    354        } finally {
    355          if (jjtc000) {
    356            jjtree.closeNodeScope(jjtn000, true);
    357            jjtreeCloseNodeScope(jjtn000);
    358          }
    359        }
    360      }
    361
    362      final public void ForeachStatement() throws ParseException {
    363                               /*@bgen(jjtree) ForeachStatement */
    364      ASTForeachStatement jjtn000 = new ASTForeachStatement(JJTFOREACHSTATEMENT);
    365      boolean jjtc000 = true;
    366      jjtree.openNodeScope(jjtn000);
    367      jjtreeOpenNodeScope(jjtn000);
    368        try {
    369          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    370          case FOR:
    371            jj_consume_token(FOR);
    372            jj_consume_token(LPAREN);
    373            LValueVar();
    374            jj_consume_token(COLON);
    375            Expression();
    376            jj_consume_token(RPAREN);
    377            Statement();
    378            break;
    379          case FOREACH:
    380            jj_consume_token(FOREACH);
    381            jj_consume_token(LPAREN);
    382            LValueVar();
    383            jj_consume_token(IN);
    384            Expression();
    385            jj_consume_token(RPAREN);
    386            Statement();
    387            break;
    388          default:
    389            jj_la1[6] = jj_gen;
    390            jj_consume_token(-1);
    391            throw new ParseException();
    392          }
    393        } catch (Throwable jjte000) {
    394          if (jjtc000) {
    395            jjtree.clearNodeScope(jjtn000);
    396            jjtc000 = false;
    397          } else {
    398            jjtree.popNode();
    399          }
    400          if (jjte000 instanceof RuntimeException) {
    401            {if (true) throw (RuntimeException)jjte000;}
    402          }
    403          if (jjte000 instanceof ParseException) {
    404            {if (true) throw (ParseException)jjte000;}
    405          }
    406          {if (true) throw (Error)jjte000;}
    407        } finally {
    408          if (jjtc000) {
    409            jjtree.closeNodeScope(jjtn000, true);
    410            jjtreeCloseNodeScope(jjtn000);
    411          }
    412        }
    413      }
    414
    415      final public void ReturnStatement() throws ParseException {
    416                              /*@bgen(jjtree) ReturnStatement */
    417      ASTReturnStatement jjtn000 = new ASTReturnStatement(JJTRETURNSTATEMENT);
    418      boolean jjtc000 = true;
    419      jjtree.openNodeScope(jjtn000);
    420      jjtreeOpenNodeScope(jjtn000);
    421        try {
    422          jj_consume_token(RETURN);
    423          Expression();
    424        } catch (Throwable jjte000) {
    425          if (jjtc000) {
    426            jjtree.clearNodeScope(jjtn000);
    427            jjtc000 = false;
    428          } else {
    429            jjtree.popNode();
    430          }
    431          if (jjte000 instanceof RuntimeException) {
    432            {if (true) throw (RuntimeException)jjte000;}
    433          }
    434          if (jjte000 instanceof ParseException) {
    435            {if (true) throw (ParseException)jjte000;}
    436          }
    437          {if (true) throw (Error)jjte000;}
    438        } finally {
    439          if (jjtc000) {
    440            jjtree.closeNodeScope(jjtn000, true);
    441            jjtreeCloseNodeScope(jjtn000);
    442          }
    443        }
    444      }
    445
    446    /***************************************
    447     *      Expression syntax
    448     ***************************************/
    449      final public void Expression() throws ParseException {
    450        ConditionalExpression();
    451        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    452        case assign:
    453          jj_consume_token(assign);
    454                                                         ASTAssignment jjtn001 = new ASTAssignment(JJTASSIGNMENT);
    455                                                         boolean jjtc001 = true;
    456                                                         jjtree.openNodeScope(jjtn001);
    457                                                         jjtreeOpenNodeScope(jjtn001);
    458          try {
    459            Expression();
    460          } catch (Throwable jjte001) {
    461                                                         if (jjtc001) {
    462                                                           jjtree.clearNodeScope(jjtn001);
    463                                                           jjtc001 = false;
    464                                                         } else {
    465                                                           jjtree.popNode();
    466                                                         }
    467                                                         if (jjte001 instanceof RuntimeException) {
    468                                                           {if (true) throw (RuntimeException)jjte001;}
    469                                                         }
    470                                                         if (jjte001 instanceof ParseException) {
    471                                                           {if (true) throw (ParseException)jjte001;}
    472                                                         }
    473                                                         {if (true) throw (Error)jjte001;}
    474          } finally {
    475                                                         if (jjtc001) {
    476                                                           jjtree.closeNodeScope(jjtn001,  2);
    477                                                           jjtreeCloseNodeScope(jjtn001);
    478                                                         }
    479          }
    480          break;
    481        default:
    482          jj_la1[7] = jj_gen;
    483          ;
    484        }
    485      }
    486
    487      final public void Assignment() throws ParseException {
    488                                        /*@bgen(jjtree) #Assignment( 2) */
    489      ASTAssignment jjtn000 = new ASTAssignment(JJTASSIGNMENT);
    490      boolean jjtc000 = true;
    491      jjtree.openNodeScope(jjtn000);
    492      jjtreeOpenNodeScope(jjtn000);
    493        try {
    494          ConditionalExpression();
    495          jj_consume_token(assign);
    496          Expression();
    497        } catch (Throwable jjte000) {
    498          if (jjtc000) {
    499            jjtree.clearNodeScope(jjtn000);
    500            jjtc000 = false;
    501          } else {
    502            jjtree.popNode();
    503          }
    504          if (jjte000 instanceof RuntimeException) {
    505            {if (true) throw (RuntimeException)jjte000;}
    506          }
    507          if (jjte000 instanceof ParseException) {
    508            {if (true) throw (ParseException)jjte000;}
    509          }
    510          {if (true) throw (Error)jjte000;}
    511        } finally {
    512          if (jjtc000) {
    513            jjtree.closeNodeScope(jjtn000,  2);
    514            jjtreeCloseNodeScope(jjtn000);
    515          }
    516        }
    517      }
    518
    519      final public void Var() throws ParseException {
    520        jj_consume_token(VAR);
    521        DeclareVar();
    522        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    523        case assign:
    524          jj_consume_token(assign);
    525                                                    ASTAssignment jjtn001 = new ASTAssignment(JJTASSIGNMENT);
    526                                                    boolean jjtc001 = true;
    527                                                    jjtree.openNodeScope(jjtn001);
    528                                                    jjtreeOpenNodeScope(jjtn001);
    529          try {
    530            Expression();
    531          } catch (Throwable jjte001) {
    532                                                    if (jjtc001) {
    533                                                      jjtree.clearNodeScope(jjtn001);
    534                                                      jjtc001 = false;
    535                                                    } else {
    536                                                      jjtree.popNode();
    537                                                    }
    538                                                    if (jjte001 instanceof RuntimeException) {
    539                                                      {if (true) throw (RuntimeException)jjte001;}
    540                                                    }
    541                                                    if (jjte001 instanceof ParseException) {
    542                                                      {if (true) throw (ParseException)jjte001;}
    543                                                    }
    544                                                    {if (true) throw (Error)jjte001;}
    545          } finally {
    546                                                    if (jjtc001) {
    547                                                      jjtree.closeNodeScope(jjtn001,  2);
    548                                                      jjtreeCloseNodeScope(jjtn001);
    549                                                    }
    550          }
    551          break;
    552        default:
    553          jj_la1[8] = jj_gen;
    554          ;
    555        }
    556      }
    557
    558      final public void DeclareVar() throws ParseException {
    559     /*@bgen(jjtree) Var */
    560        ASTVar jjtn000 = new ASTVar(JJTVAR);
    561        boolean jjtc000 = true;
    562        jjtree.openNodeScope(jjtn000);
    563        jjtreeOpenNodeScope(jjtn000);Token t;
    564        try {
    565          t = jj_consume_token(IDENTIFIER);
    566                         jjtree.closeNodeScope(jjtn000, true);
    567                         jjtc000 = false;
    568                         jjtreeCloseNodeScope(jjtn000);
    569                         declareVariable(jjtn000, t.image);
    570        } finally {
    571          if (jjtc000) {
    572            jjtree.closeNodeScope(jjtn000, true);
    573            jjtreeCloseNodeScope(jjtn000);
    574          }
    575        }
    576      }
    577
    578      final public void LValueVar() throws ParseException {
    579                                   /*@bgen(jjtree) Reference */
    580      ASTReference jjtn000 = new ASTReference(JJTREFERENCE);
    581      boolean jjtc000 = true;
    582      jjtree.openNodeScope(jjtn000);
    583      jjtreeOpenNodeScope(jjtn000);
    584        try {
    585          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    586          case VAR:
    587            jj_consume_token(VAR);
    588            DeclareVar();
    589            DotReference();
    590            break;
    591          case IDENTIFIER:
    592          case REGISTER:
    593            Identifier(true);
    594            DotReference();
    595            break;
    596          default:
    597            jj_la1[9] = jj_gen;
    598            jj_consume_token(-1);
    599            throw new ParseException();
    600          }
    601        } catch (Throwable jjte000) {
    602          if (jjtc000) {
    603            jjtree.clearNodeScope(jjtn000);
    604            jjtc000 = false;
    605          } else {
    606            jjtree.popNode();
    607          }
    608          if (jjte000 instanceof RuntimeException) {
    609            {if (true) throw (RuntimeException)jjte000;}
    610          }
    611          if (jjte000 instanceof ParseException) {
    612            {if (true) throw (ParseException)jjte000;}
    613          }
    614          {if (true) throw (Error)jjte000;}
    615        } finally {
    616          if (jjtc000) {
    617            jjtree.closeNodeScope(jjtn000, true);
    618            jjtreeCloseNodeScope(jjtn000);
    619          }
    620        }
    621      }
    622
    623    /***************************************
    624     *      Conditional & relational
    625     ***************************************/
    626      final public void ConditionalExpression() throws ParseException {
    627        ConditionalOrExpression();
    628        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    629        case QMARK:
    630        case ELVIS:
    631          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    632          case QMARK:
    633            jj_consume_token(QMARK);
    634            Expression();
    635            jj_consume_token(COLON);
    636                                       ASTTernaryNode jjtn001 = new ASTTernaryNode(JJTTERNARYNODE);
    637                                       boolean jjtc001 = true;
    638                                       jjtree.openNodeScope(jjtn001);
    639                                       jjtreeOpenNodeScope(jjtn001);
    640            try {
    641              Expression();
    642            } catch (Throwable jjte001) {
    643                                       if (jjtc001) {
    644                                         jjtree.clearNodeScope(jjtn001);
    645                                         jjtc001 = false;
    646                                       } else {
    647                                         jjtree.popNode();
    648                                       }
    649                                       if (jjte001 instanceof RuntimeException) {
    650                                         {if (true) throw (RuntimeException)jjte001;}
    651                                       }
    652                                       if (jjte001 instanceof ParseException) {
    653                                         {if (true) throw (ParseException)jjte001;}
    654                                       }
    655                                       {if (true) throw (Error)jjte001;}
    656            } finally {
    657                                       if (jjtc001) {
    658                                         jjtree.closeNodeScope(jjtn001,  3);
    659                                         jjtreeCloseNodeScope(jjtn001);
    660                                       }
    661            }
    662            break;
    663          case ELVIS:
    664            jj_consume_token(ELVIS);
    665                  ASTTernaryNode jjtn002 = new ASTTernaryNode(JJTTERNARYNODE);
    666                  boolean jjtc002 = true;
    667                  jjtree.openNodeScope(jjtn002);
    668                  jjtreeOpenNodeScope(jjtn002);
    669            try {
    670              Expression();
    671            } catch (Throwable jjte002) {
    672                  if (jjtc002) {
    673                    jjtree.clearNodeScope(jjtn002);
    674                    jjtc002 = false;
    675                  } else {
    676                    jjtree.popNode();
    677                  }
    678                  if (jjte002 instanceof RuntimeException) {
    679                    {if (true) throw (RuntimeException)jjte002;}
    680                  }
    681                  if (jjte002 instanceof ParseException) {
    682                    {if (true) throw (ParseException)jjte002;}
    683                  }
    684                  {if (true) throw (Error)jjte002;}
    685            } finally {
    686                  if (jjtc002) {
    687                    jjtree.closeNodeScope(jjtn002,  2);
    688                    jjtreeCloseNodeScope(jjtn002);
    689                  }
    690            }
    691            break;
    692          default:
    693            jj_la1[10] = jj_gen;
    694            jj_consume_token(-1);
    695            throw new ParseException();
    696          }
    697          break;
    698        default:
    699          jj_la1[11] = jj_gen;
    700          ;
    701        }
    702      }
    703
    704      final public void ConditionalOrExpression() throws ParseException {
    705        ConditionalAndExpression();
    706        label_4:
    707        while (true) {
    708          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    709          case OR:
    710            ;
    711            break;
    712          default:
    713            jj_la1[12] = jj_gen;
    714            break label_4;
    715          }
    716          jj_consume_token(OR);
    717               ASTOrNode jjtn001 = new ASTOrNode(JJTORNODE);
    718               boolean jjtc001 = true;
    719               jjtree.openNodeScope(jjtn001);
    720               jjtreeOpenNodeScope(jjtn001);
    721          try {
    722            ConditionalAndExpression();
    723          } catch (Throwable jjte001) {
    724               if (jjtc001) {
    725                 jjtree.clearNodeScope(jjtn001);
    726                 jjtc001 = false;
    727               } else {
    728                 jjtree.popNode();
    729               }
    730               if (jjte001 instanceof RuntimeException) {
    731                 {if (true) throw (RuntimeException)jjte001;}
    732               }
    733               if (jjte001 instanceof ParseException) {
    734                 {if (true) throw (ParseException)jjte001;}
    735               }
    736               {if (true) throw (Error)jjte001;}
    737          } finally {
    738               if (jjtc001) {
    739                 jjtree.closeNodeScope(jjtn001,  2);
    740                 jjtreeCloseNodeScope(jjtn001);
    741               }
    742          }
    743        }
    744      }
    745
    746      final public void ConditionalAndExpression() throws ParseException {
    747        InclusiveOrExpression();
    748        label_5:
    749        while (true) {
    750          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    751          case AND:
    752            ;
    753            break;
    754          default:
    755            jj_la1[13] = jj_gen;
    756            break label_5;
    757          }
    758          jj_consume_token(AND);
    759                ASTAndNode jjtn001 = new ASTAndNode(JJTANDNODE);
    760                boolean jjtc001 = true;
    761                jjtree.openNodeScope(jjtn001);
    762                jjtreeOpenNodeScope(jjtn001);
    763          try {
    764            InclusiveOrExpression();
    765          } catch (Throwable jjte001) {
    766                if (jjtc001) {
    767                  jjtree.clearNodeScope(jjtn001);
    768                  jjtc001 = false;
    769                } else {
    770                  jjtree.popNode();
    771                }
    772                if (jjte001 instanceof RuntimeException) {
    773                  {if (true) throw (RuntimeException)jjte001;}
    774                }
    775                if (jjte001 instanceof ParseException) {
    776                  {if (true) throw (ParseException)jjte001;}
    777                }
    778                {if (true) throw (Error)jjte001;}
    779          } finally {
    780                if (jjtc001) {
    781                  jjtree.closeNodeScope(jjtn001,  2);
    782                  jjtreeCloseNodeScope(jjtn001);
    783                }
    784          }
    785        }
    786      }
    787
    788      final public void InclusiveOrExpression() throws ParseException {
    789        ExclusiveOrExpression();
    790        label_6:
    791        while (true) {
    792          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    793          case or:
    794            ;
    795            break;
    796          default:
    797            jj_la1[14] = jj_gen;
    798            break label_6;
    799          }
    800          jj_consume_token(or);
    801               ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(JJTBITWISEORNODE);
    802               boolean jjtc001 = true;
    803               jjtree.openNodeScope(jjtn001);
    804               jjtreeOpenNodeScope(jjtn001);
    805          try {
    806            ExclusiveOrExpression();
    807          } catch (Throwable jjte001) {
    808               if (jjtc001) {
    809                 jjtree.clearNodeScope(jjtn001);
    810                 jjtc001 = false;
    811               } else {
    812                 jjtree.popNode();
    813               }
    814               if (jjte001 instanceof RuntimeException) {
    815                 {if (true) throw (RuntimeException)jjte001;}
    816               }
    817               if (jjte001 instanceof ParseException) {
    818                 {if (true) throw (ParseException)jjte001;}
    819               }
    820               {if (true) throw (Error)jjte001;}
    821          } finally {
    822               if (jjtc001) {
    823                 jjtree.closeNodeScope(jjtn001,  2);
    824                 jjtreeCloseNodeScope(jjtn001);
    825               }
    826          }
    827        }
    828      }
    829
    830      final public void ExclusiveOrExpression() throws ParseException {
    831        AndExpression();
    832        label_7:
    833        while (true) {
    834          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    835          case xor:
    836            ;
    837            break;
    838          default:
    839            jj_la1[15] = jj_gen;
    840            break label_7;
    841          }
    842          jj_consume_token(xor);
    843                ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(JJTBITWISEXORNODE);
    844                boolean jjtc001 = true;
    845                jjtree.openNodeScope(jjtn001);
    846                jjtreeOpenNodeScope(jjtn001);
    847          try {
    848            AndExpression();
    849          } catch (Throwable jjte001) {
    850                if (jjtc001) {
    851                  jjtree.clearNodeScope(jjtn001);
    852                  jjtc001 = false;
    853                } else {
    854                  jjtree.popNode();
    855                }
    856                if (jjte001 instanceof RuntimeException) {
    857                  {if (true) throw (RuntimeException)jjte001;}
    858                }
    859                if (jjte001 instanceof ParseException) {
    860                  {if (true) throw (ParseException)jjte001;}
    861                }
    862                {if (true) throw (Error)jjte001;}
    863          } finally {
    864                if (jjtc001) {
    865                  jjtree.closeNodeScope(jjtn001,  2);
    866                  jjtreeCloseNodeScope(jjtn001);
    867                }
    868          }
    869        }
    870      }
    871
    872      final public void AndExpression() throws ParseException {
    873        EqualityExpression();
    874        label_8:
    875        while (true) {
    876          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    877          case and:
    878            ;
    879            break;
    880          default:
    881            jj_la1[16] = jj_gen;
    882            break label_8;
    883          }
    884          jj_consume_token(and);
    885                ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(JJTBITWISEANDNODE);
    886                boolean jjtc001 = true;
    887                jjtree.openNodeScope(jjtn001);
    888                jjtreeOpenNodeScope(jjtn001);
    889          try {
    890            EqualityExpression();
    891          } catch (Throwable jjte001) {
    892                if (jjtc001) {
    893                  jjtree.clearNodeScope(jjtn001);
    894                  jjtc001 = false;
    895                } else {
    896                  jjtree.popNode();
    897                }
    898                if (jjte001 instanceof RuntimeException) {
    899                  {if (true) throw (RuntimeException)jjte001;}
    900                }
    901                if (jjte001 instanceof ParseException) {
    902                  {if (true) throw (ParseException)jjte001;}
    903                }
    904                {if (true) throw (Error)jjte001;}
    905          } finally {
    906                if (jjtc001) {
    907                  jjtree.closeNodeScope(jjtn001,  2);
    908                  jjtreeCloseNodeScope(jjtn001);
    909                }
    910          }
    911        }
    912      }
    913
    914      final public void EqualityExpression() throws ParseException {
    915        RelationalExpression();
    916        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    917        case eq:
    918        case ne:
    919          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    920          case eq:
    921            jj_consume_token(eq);
    922                ASTEQNode jjtn001 = new ASTEQNode(JJTEQNODE);
    923                boolean jjtc001 = true;
    924                jjtree.openNodeScope(jjtn001);
    925                jjtreeOpenNodeScope(jjtn001);
    926            try {
    927              RelationalExpression();
    928            } catch (Throwable jjte001) {
    929                if (jjtc001) {
    930                  jjtree.clearNodeScope(jjtn001);
    931                  jjtc001 = false;
    932                } else {
    933                  jjtree.popNode();
    934                }
    935                if (jjte001 instanceof RuntimeException) {
    936                  {if (true) throw (RuntimeException)jjte001;}
    937                }
    938                if (jjte001 instanceof ParseException) {
    939                  {if (true) throw (ParseException)jjte001;}
    940                }
    941                {if (true) throw (Error)jjte001;}
    942            } finally {
    943                if (jjtc001) {
    944                  jjtree.closeNodeScope(jjtn001,  2);
    945                  jjtreeCloseNodeScope(jjtn001);
    946                }
    947            }
    948            break;
    949          case ne:
    950            jj_consume_token(ne);
    951                ASTNENode jjtn002 = new ASTNENode(JJTNENODE);
    952                boolean jjtc002 = true;
    953                jjtree.openNodeScope(jjtn002);
    954                jjtreeOpenNodeScope(jjtn002);
    955            try {
    956              RelationalExpression();
    957            } catch (Throwable jjte002) {
    958                if (jjtc002) {
    959                  jjtree.clearNodeScope(jjtn002);
    960                  jjtc002 = false;
    961                } else {
    962                  jjtree.popNode();
    963                }
    964                if (jjte002 instanceof RuntimeException) {
    965                  {if (true) throw (RuntimeException)jjte002;}
    966                }
    967                if (jjte002 instanceof ParseException) {
    968                  {if (true) throw (ParseException)jjte002;}
    969                }
    970                {if (true) throw (Error)jjte002;}
    971            } finally {
    972                if (jjtc002) {
    973                  jjtree.closeNodeScope(jjtn002,  2);
    974                  jjtreeCloseNodeScope(jjtn002);
    975                }
    976            }
    977            break;
    978          default:
    979            jj_la1[17] = jj_gen;
    980            jj_consume_token(-1);
    981            throw new ParseException();
    982          }
    983          break;
    984        default:
    985          jj_la1[18] = jj_gen;
    986          ;
    987        }
    988      }
    989
    990      final public void RelationalExpression() throws ParseException {
    991        AdditiveExpression();
    992        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    993        case req:
    994        case rne:
    995        case gt:
    996        case ge:
    997        case lt:
    998        case le:
    999          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1000          case lt:
    1001            jj_consume_token(lt);
    1002               ASTLTNode jjtn001 = new ASTLTNode(JJTLTNODE);
    1003               boolean jjtc001 = true;
    1004               jjtree.openNodeScope(jjtn001);
    1005               jjtreeOpenNodeScope(jjtn001);
    1006            try {
    1007              AdditiveExpression();
    1008            } catch (Throwable jjte001) {
    1009               if (jjtc001) {
    1010                 jjtree.clearNodeScope(jjtn001);
    1011                 jjtc001 = false;
    1012               } else {
    1013                 jjtree.popNode();
    1014               }
    1015               if (jjte001 instanceof RuntimeException) {
    1016                 {if (true) throw (RuntimeException)jjte001;}
    1017               }
    1018               if (jjte001 instanceof ParseException) {
    1019                 {if (true) throw (ParseException)jjte001;}
    1020               }
    1021               {if (true) throw (Error)jjte001;}
    1022            } finally {
    1023               if (jjtc001) {
    1024                 jjtree.closeNodeScope(jjtn001,  2);
    1025                 jjtreeCloseNodeScope(jjtn001);
    1026               }
    1027            }
    1028            break;
    1029          case gt:
    1030            jj_consume_token(gt);
    1031               ASTGTNode jjtn002 = new ASTGTNode(JJTGTNODE);
    1032               boolean jjtc002 = true;
    1033               jjtree.openNodeScope(jjtn002);
    1034               jjtreeOpenNodeScope(jjtn002);
    1035            try {
    1036              AdditiveExpression();
    1037            } catch (Throwable jjte002) {
    1038               if (jjtc002) {
    1039                 jjtree.clearNodeScope(jjtn002);
    1040                 jjtc002 = false;
    1041               } else {
    1042                 jjtree.popNode();
    1043               }
    1044               if (jjte002 instanceof RuntimeException) {
    1045                 {if (true) throw (RuntimeException)jjte002;}
    1046               }
    1047               if (jjte002 instanceof ParseException) {
    1048                 {if (true) throw (ParseException)jjte002;}
    1049               }
    1050               {if (true) throw (Error)jjte002;}
    1051            } finally {
    1052               if (jjtc002) {
    1053                 jjtree.closeNodeScope(jjtn002,  2);
    1054                 jjtreeCloseNodeScope(jjtn002);
    1055               }
    1056            }
    1057            break;
    1058          case le:
    1059            jj_consume_token(le);
    1060               ASTLENode jjtn003 = new ASTLENode(JJTLENODE);
    1061               boolean jjtc003 = true;
    1062               jjtree.openNodeScope(jjtn003);
    1063               jjtreeOpenNodeScope(jjtn003);
    1064            try {
    1065              AdditiveExpression();
    1066            } catch (Throwable jjte003) {
    1067               if (jjtc003) {
    1068                 jjtree.clearNodeScope(jjtn003);
    1069                 jjtc003 = false;
    1070               } else {
    1071                 jjtree.popNode();
    1072               }
    1073               if (jjte003 instanceof RuntimeException) {
    1074                 {if (true) throw (RuntimeException)jjte003;}
    1075               }
    1076               if (jjte003 instanceof ParseException) {
    1077                 {if (true) throw (ParseException)jjte003;}
    1078               }
    1079               {if (true) throw (Error)jjte003;}
    1080            } finally {
    1081               if (jjtc003) {
    1082                 jjtree.closeNodeScope(jjtn003,  2);
    1083                 jjtreeCloseNodeScope(jjtn003);
    1084               }
    1085            }
    1086            break;
    1087          case ge:
    1088            jj_consume_token(ge);
    1089               ASTGENode jjtn004 = new ASTGENode(JJTGENODE);
    1090               boolean jjtc004 = true;
    1091               jjtree.openNodeScope(jjtn004);
    1092               jjtreeOpenNodeScope(jjtn004);
    1093            try {
    1094              AdditiveExpression();
    1095            } catch (Throwable jjte004) {
    1096               if (jjtc004) {
    1097                 jjtree.clearNodeScope(jjtn004);
    1098                 jjtc004 = false;
    1099               } else {
    1100                 jjtree.popNode();
    1101               }
    1102               if (jjte004 instanceof RuntimeException) {
    1103                 {if (true) throw (RuntimeException)jjte004;}
    1104               }
    1105               if (jjte004 instanceof ParseException) {
    1106                 {if (true) throw (ParseException)jjte004;}
    1107               }
    1108               {if (true) throw (Error)jjte004;}
    1109            } finally {
    1110               if (jjtc004) {
    1111                 jjtree.closeNodeScope(jjtn004,  2);
    1112                 jjtreeCloseNodeScope(jjtn004);
    1113               }
    1114            }
    1115            break;
    1116          case req:
    1117            jj_consume_token(req);
    1118                ASTERNode jjtn005 = new ASTERNode(JJTERNODE);
    1119                boolean jjtc005 = true;
    1120                jjtree.openNodeScope(jjtn005);
    1121                jjtreeOpenNodeScope(jjtn005);
    1122            try {
    1123              AdditiveExpression();
    1124            } catch (Throwable jjte005) {
    1125                if (jjtc005) {
    1126                  jjtree.clearNodeScope(jjtn005);
    1127                  jjtc005 = false;
    1128                } else {
    1129                  jjtree.popNode();
    1130                }
    1131                if (jjte005 instanceof RuntimeException) {
    1132                  {if (true) throw (RuntimeException)jjte005;}
    1133                }
    1134                if (jjte005 instanceof ParseException) {
    1135                  {if (true) throw (ParseException)jjte005;}
    1136                }
    1137                {if (true) throw (Error)jjte005;}
    1138            } finally {
    1139                if (jjtc005) {
    1140                  jjtree.closeNodeScope(jjtn005,  2);
    1141                  jjtreeCloseNodeScope(jjtn005);
    1142                }
    1143            }
    1144            break;
    1145          case rne:
    1146            jj_consume_token(rne);
    1147                ASTNRNode jjtn006 = new ASTNRNode(JJTNRNODE);
    1148                boolean jjtc006 = true;
    1149                jjtree.openNodeScope(jjtn006);
    1150                jjtreeOpenNodeScope(jjtn006);
    1151            try {
    1152              AdditiveExpression();
    1153            } catch (Throwable jjte006) {
    1154                if (jjtc006) {
    1155                  jjtree.clearNodeScope(jjtn006);
    1156                  jjtc006 = false;
    1157                } else {
    1158                  jjtree.popNode();
    1159                }
    1160                if (jjte006 instanceof RuntimeException) {
    1161                  {if (true) throw (RuntimeException)jjte006;}
    1162                }
    1163                if (jjte006 instanceof ParseException) {
    1164                  {if (true) throw (ParseException)jjte006;}
    1165                }
    1166                {if (true) throw (Error)jjte006;}
    1167            } finally {
    1168                if (jjtc006) {
    1169                  jjtree.closeNodeScope(jjtn006,  2);
    1170                  jjtreeCloseNodeScope(jjtn006);
    1171                }
    1172            }
    1173            break;
    1174          default:
    1175            jj_la1[19] = jj_gen;
    1176            jj_consume_token(-1);
    1177            throw new ParseException();
    1178          }
    1179          break;
    1180        default:
    1181          jj_la1[20] = jj_gen;
    1182          ;
    1183        }
    1184      }
    1185
    1186    /***************************************
    1187     *      Arithmetic
    1188     ***************************************/
    1189      final public void AdditiveExpression() throws ParseException {
    1190                                                   /*@bgen(jjtree) #AdditiveNode(> 1) */
    1191      ASTAdditiveNode jjtn000 = new ASTAdditiveNode(JJTADDITIVENODE);
    1192      boolean jjtc000 = true;
    1193      jjtree.openNodeScope(jjtn000);
    1194      jjtreeOpenNodeScope(jjtn000);
    1195        try {
    1196          MultiplicativeExpression();
    1197          label_9:
    1198          while (true) {
    1199            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1200            case plus:
    1201            case minus:
    1202              ;
    1203              break;
    1204            default:
    1205              jj_la1[21] = jj_gen;
    1206              break label_9;
    1207            }
    1208            AdditiveOperator();
    1209            MultiplicativeExpression();
    1210          }
    1211        } catch (Throwable jjte000) {
    1212          if (jjtc000) {
    1213            jjtree.clearNodeScope(jjtn000);
    1214            jjtc000 = false;
    1215          } else {
    1216            jjtree.popNode();
    1217          }
    1218          if (jjte000 instanceof RuntimeException) {
    1219            {if (true) throw (RuntimeException)jjte000;}
    1220          }
    1221          if (jjte000 instanceof ParseException) {
    1222            {if (true) throw (ParseException)jjte000;}
    1223          }
    1224          {if (true) throw (Error)jjte000;}
    1225        } finally {
    1226          if (jjtc000) {
    1227            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    1228            jjtreeCloseNodeScope(jjtn000);
    1229          }
    1230        }
    1231      }
    1232
    1233      final public void AdditiveOperator() throws ParseException {
    1234                               /*@bgen(jjtree) AdditiveOperator */
    1235      ASTAdditiveOperator jjtn000 = new ASTAdditiveOperator(JJTADDITIVEOPERATOR);
    1236      boolean jjtc000 = true;
    1237      jjtree.openNodeScope(jjtn000);
    1238      jjtreeOpenNodeScope(jjtn000);
    1239        try {
    1240          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1241          case plus:
    1242            jj_consume_token(plus);
    1243                 jjtree.closeNodeScope(jjtn000, true);
    1244                 jjtc000 = false;
    1245                 jjtreeCloseNodeScope(jjtn000);
    1246                 jjtn000.image = "+";
    1247            break;
    1248          case minus:
    1249            jj_consume_token(minus);
    1250                  jjtree.closeNodeScope(jjtn000, true);
    1251                  jjtc000 = false;
    1252                  jjtreeCloseNodeScope(jjtn000);
    1253                  jjtn000.image = "-";
    1254            break;
    1255          default:
    1256            jj_la1[22] = jj_gen;
    1257            jj_consume_token(-1);
    1258            throw new ParseException();
    1259          }
    1260        } finally {
    1261          if (jjtc000) {
    1262            jjtree.closeNodeScope(jjtn000, true);
    1263            jjtreeCloseNodeScope(jjtn000);
    1264          }
    1265        }
    1266      }
    1267
    1268      final public void MultiplicativeExpression() throws ParseException {
    1269        UnaryExpression();
    1270        label_10:
    1271        while (true) {
    1272          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1273          case mod:
    1274          case div:
    1275          case mult:
    1276            ;
    1277            break;
    1278          default:
    1279            jj_la1[23] = jj_gen;
    1280            break label_10;
    1281          }
    1282          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1283          case mult:
    1284            jj_consume_token(mult);
    1285                 ASTMulNode jjtn001 = new ASTMulNode(JJTMULNODE);
    1286                 boolean jjtc001 = true;
    1287                 jjtree.openNodeScope(jjtn001);
    1288                 jjtreeOpenNodeScope(jjtn001);
    1289            try {
    1290              UnaryExpression();
    1291            } catch (Throwable jjte001) {
    1292                 if (jjtc001) {
    1293                   jjtree.clearNodeScope(jjtn001);
    1294                   jjtc001 = false;
    1295                 } else {
    1296                   jjtree.popNode();
    1297                 }
    1298                 if (jjte001 instanceof RuntimeException) {
    1299                   {if (true) throw (RuntimeException)jjte001;}
    1300                 }
    1301                 if (jjte001 instanceof ParseException) {
    1302                   {if (true) throw (ParseException)jjte001;}
    1303                 }
    1304                 {if (true) throw (Error)jjte001;}
    1305            } finally {
    1306                 if (jjtc001) {
    1307                   jjtree.closeNodeScope(jjtn001,  2);
    1308                   jjtreeCloseNodeScope(jjtn001);
    1309                 }
    1310            }
    1311            break;
    1312          case div:
    1313            jj_consume_token(div);
    1314                ASTDivNode jjtn002 = new ASTDivNode(JJTDIVNODE);
    1315                boolean jjtc002 = true;
    1316                jjtree.openNodeScope(jjtn002);
    1317                jjtreeOpenNodeScope(jjtn002);
    1318            try {
    1319              UnaryExpression();
    1320            } catch (Throwable jjte002) {
    1321                if (jjtc002) {
    1322                  jjtree.clearNodeScope(jjtn002);
    1323                  jjtc002 = false;
    1324                } else {
    1325                  jjtree.popNode();
    1326                }
    1327                if (jjte002 instanceof RuntimeException) {
    1328                  {if (true) throw (RuntimeException)jjte002;}
    1329                }
    1330                if (jjte002 instanceof ParseException) {
    1331                  {if (true) throw (ParseException)jjte002;}
    1332                }
    1333                {if (true) throw (Error)jjte002;}
    1334            } finally {
    1335                if (jjtc002) {
    1336                  jjtree.closeNodeScope(jjtn002,  2);
    1337                  jjtreeCloseNodeScope(jjtn002);
    1338                }
    1339            }
    1340            break;
    1341          case mod:
    1342            jj_consume_token(mod);
    1343                ASTModNode jjtn003 = new ASTModNode(JJTMODNODE);
    1344                boolean jjtc003 = true;
    1345                jjtree.openNodeScope(jjtn003);
    1346                jjtreeOpenNodeScope(jjtn003);
    1347            try {
    1348              UnaryExpression();
    1349            } catch (Throwable jjte003) {
    1350                if (jjtc003) {
    1351                  jjtree.clearNodeScope(jjtn003);
    1352                  jjtc003 = false;
    1353                } else {
    1354                  jjtree.popNode();
    1355                }
    1356                if (jjte003 instanceof RuntimeException) {
    1357                  {if (true) throw (RuntimeException)jjte003;}
    1358                }
    1359                if (jjte003 instanceof ParseException) {
    1360                  {if (true) throw (ParseException)jjte003;}
    1361                }
    1362                {if (true) throw (Error)jjte003;}
    1363            } finally {
    1364                if (jjtc003) {
    1365                  jjtree.closeNodeScope(jjtn003,  2);
    1366                  jjtreeCloseNodeScope(jjtn003);
    1367                }
    1368            }
    1369            break;
    1370          default:
    1371            jj_la1[24] = jj_gen;
    1372            jj_consume_token(-1);
    1373            throw new ParseException();
    1374          }
    1375        }
    1376      }
    1377
    1378      final public void UnaryExpression() throws ParseException {
    1379        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1380        case minus:
    1381          jj_consume_token(minus);
    1382                ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(JJTUNARYMINUSNODE);
    1383                boolean jjtc001 = true;
    1384                jjtree.openNodeScope(jjtn001);
    1385                jjtreeOpenNodeScope(jjtn001);
    1386          try {
    1387            UnaryExpression();
    1388          } catch (Throwable jjte001) {
    1389                if (jjtc001) {
    1390                  jjtree.clearNodeScope(jjtn001);
    1391                  jjtc001 = false;
    1392                } else {
    1393                  jjtree.popNode();
    1394                }
    1395                if (jjte001 instanceof RuntimeException) {
    1396                  {if (true) throw (RuntimeException)jjte001;}
    1397                }
    1398                if (jjte001 instanceof ParseException) {
    1399                  {if (true) throw (ParseException)jjte001;}
    1400                }
    1401                {if (true) throw (Error)jjte001;}
    1402          } finally {
    1403                if (jjtc001) {
    1404                  jjtree.closeNodeScope(jjtn001,  1);
    1405                  jjtreeCloseNodeScope(jjtn001);
    1406                }
    1407          }
    1408          break;
    1409        case tilda:
    1410          jj_consume_token(tilda);
    1411                ASTBitwiseComplNode jjtn002 = new ASTBitwiseComplNode(JJTBITWISECOMPLNODE);
    1412                boolean jjtc002 = true;
    1413                jjtree.openNodeScope(jjtn002);
    1414                jjtreeOpenNodeScope(jjtn002);
    1415          try {
    1416            UnaryExpression();
    1417          } catch (Throwable jjte002) {
    1418                if (jjtc002) {
    1419                  jjtree.clearNodeScope(jjtn002);
    1420                  jjtc002 = false;
    1421                } else {
    1422                  jjtree.popNode();
    1423                }
    1424                if (jjte002 instanceof RuntimeException) {
    1425                  {if (true) throw (RuntimeException)jjte002;}
    1426                }
    1427                if (jjte002 instanceof ParseException) {
    1428                  {if (true) throw (ParseException)jjte002;}
    1429                }
    1430                {if (true) throw (Error)jjte002;}
    1431          } finally {
    1432                if (jjtc002) {
    1433                  jjtree.closeNodeScope(jjtn002,  1);
    1434                  jjtreeCloseNodeScope(jjtn002);
    1435                }
    1436          }
    1437          break;
    1438        case not:
    1439          jj_consume_token(not);
    1440              ASTNotNode jjtn003 = new ASTNotNode(JJTNOTNODE);
    1441              boolean jjtc003 = true;
    1442              jjtree.openNodeScope(jjtn003);
    1443              jjtreeOpenNodeScope(jjtn003);
    1444          try {
    1445            UnaryExpression();
    1446          } catch (Throwable jjte003) {
    1447              if (jjtc003) {
    1448                jjtree.clearNodeScope(jjtn003);
    1449                jjtc003 = false;
    1450              } else {
    1451                jjtree.popNode();
    1452              }
    1453              if (jjte003 instanceof RuntimeException) {
    1454                {if (true) throw (RuntimeException)jjte003;}
    1455              }
    1456              if (jjte003 instanceof ParseException) {
    1457                {if (true) throw (ParseException)jjte003;}
    1458              }
    1459              {if (true) throw (Error)jjte003;}
    1460          } finally {
    1461              if (jjtc003) {
    1462                jjtree.closeNodeScope(jjtn003,  1);
    1463                jjtreeCloseNodeScope(jjtn003);
    1464              }
    1465          }
    1466          break;
    1467        case NEW:
    1468        case EMPTY:
    1469        case SIZE:
    1470        case NULL:
    1471        case TRUE:
    1472        case FALSE:
    1473        case LPAREN:
    1474        case LCURLY:
    1475        case LBRACKET:
    1476        case IDENTIFIER:
    1477        case REGISTER:
    1478        case INTEGER_LITERAL:
    1479        case FLOAT_LITERAL:
    1480        case STRING_LITERAL:
    1481          PrimaryExpression();
    1482          break;
    1483        default:
    1484          jj_la1[25] = jj_gen;
    1485          jj_consume_token(-1);
    1486          throw new ParseException();
    1487        }
    1488      }
    1489
    1490    /***************************************
    1491     *      Identifier & Literals
    1492     ***************************************/
    1493      final public void Identifier(boolean top) throws ParseException {
    1494     /*@bgen(jjtree) Identifier */
    1495        ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER);
    1496        boolean jjtc000 = true;
    1497        jjtree.openNodeScope(jjtn000);
    1498        jjtreeOpenNodeScope(jjtn000);Token t;
    1499        try {
    1500          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1501          case IDENTIFIER:
    1502            t = jj_consume_token(IDENTIFIER);
    1503                         jjtree.closeNodeScope(jjtn000, true);
    1504                         jjtc000 = false;
    1505                         jjtreeCloseNodeScope(jjtn000);
    1506                         jjtn000.image = top? checkVariable(jjtn000, t.image) : t.image;
    1507            break;
    1508          case REGISTER:
    1509            t = jj_consume_token(REGISTER);
    1510                       jjtree.closeNodeScope(jjtn000, true);
    1511                       jjtc000 = false;
    1512                       jjtreeCloseNodeScope(jjtn000);
    1513                       jjtn000.image = t.image; jjtn000.setRegister(t.image);
    1514            break;
    1515          default:
    1516            jj_la1[26] = jj_gen;
    1517            jj_consume_token(-1);
    1518            throw new ParseException();
    1519          }
    1520        } finally {
    1521          if (jjtc000) {
    1522            jjtree.closeNodeScope(jjtn000, true);
    1523            jjtreeCloseNodeScope(jjtn000);
    1524          }
    1525        }
    1526      }
    1527
    1528      final public void StringIdentifier() throws ParseException {
    1529     /*@bgen(jjtree) Identifier */
    1530        ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER);
    1531        boolean jjtc000 = true;
    1532        jjtree.openNodeScope(jjtn000);
    1533        jjtreeOpenNodeScope(jjtn000);Token t;
    1534        try {
    1535          t = jj_consume_token(STRING_LITERAL);
    1536        jjtree.closeNodeScope(jjtn000, true);
    1537        jjtc000 = false;
    1538        jjtreeCloseNodeScope(jjtn000);
    1539        jjtn000.image = Parser.buildString(t.image, true);
    1540        } finally {
    1541        if (jjtc000) {
    1542          jjtree.closeNodeScope(jjtn000, true);
    1543          jjtreeCloseNodeScope(jjtn000);
    1544        }
    1545        }
    1546      }
    1547
    1548      final public void Literal() throws ParseException {
    1549       Token t;
    1550        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1551        case INTEGER_LITERAL:
    1552          IntegerLiteral();
    1553          break;
    1554        case FLOAT_LITERAL:
    1555          FloatLiteral();
    1556          break;
    1557        case TRUE:
    1558        case FALSE:
    1559          BooleanLiteral();
    1560          break;
    1561        case STRING_LITERAL:
    1562          StringLiteral();
    1563          break;
    1564        case NULL:
    1565          NullLiteral();
    1566          break;
    1567        default:
    1568          jj_la1[27] = jj_gen;
    1569          jj_consume_token(-1);
    1570          throw new ParseException();
    1571        }
    1572      }
    1573
    1574      final public void NullLiteral() throws ParseException {
    1575                          /*@bgen(jjtree) NullLiteral */
    1576      ASTNullLiteral jjtn000 = new ASTNullLiteral(JJTNULLLITERAL);
    1577      boolean jjtc000 = true;
    1578      jjtree.openNodeScope(jjtn000);
    1579      jjtreeOpenNodeScope(jjtn000);
    1580        try {
    1581          jj_consume_token(NULL);
    1582        } finally {
    1583          if (jjtc000) {
    1584            jjtree.closeNodeScope(jjtn000, true);
    1585            jjtreeCloseNodeScope(jjtn000);
    1586          }
    1587        }
    1588      }
    1589
    1590      final public void BooleanLiteral() throws ParseException {
    1591        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1592        case TRUE:
    1593        ASTTrueNode jjtn001 = new ASTTrueNode(JJTTRUENODE);
    1594        boolean jjtc001 = true;
    1595        jjtree.openNodeScope(jjtn001);
    1596        jjtreeOpenNodeScope(jjtn001);
    1597          try {
    1598            jj_consume_token(TRUE);
    1599          } finally {
    1600        if (jjtc001) {
    1601          jjtree.closeNodeScope(jjtn001, true);
    1602          jjtreeCloseNodeScope(jjtn001);
    1603        }
    1604          }
    1605          break;
    1606        case FALSE:
    1607        ASTFalseNode jjtn002 = new ASTFalseNode(JJTFALSENODE);
    1608        boolean jjtc002 = true;
    1609        jjtree.openNodeScope(jjtn002);
    1610        jjtreeOpenNodeScope(jjtn002);
    1611          try {
    1612            jj_consume_token(FALSE);
    1613          } finally {
    1614        if (jjtc002) {
    1615          jjtree.closeNodeScope(jjtn002, true);
    1616          jjtreeCloseNodeScope(jjtn002);
    1617        }
    1618          }
    1619          break;
    1620        default:
    1621          jj_la1[28] = jj_gen;
    1622          jj_consume_token(-1);
    1623          throw new ParseException();
    1624        }
    1625      }
    1626
    1627      final public void IntegerLiteral() throws ParseException {
    1628     /*@bgen(jjtree) NumberLiteral */
    1629      ASTNumberLiteral jjtn000 = new ASTNumberLiteral(JJTNUMBERLITERAL);
    1630      boolean jjtc000 = true;
    1631      jjtree.openNodeScope(jjtn000);
    1632      jjtreeOpenNodeScope(jjtn000);Token t;
    1633        try {
    1634          t = jj_consume_token(INTEGER_LITERAL);
    1635        jjtree.closeNodeScope(jjtn000, true);
    1636        jjtc000 = false;
    1637        jjtreeCloseNodeScope(jjtn000);
    1638        jjtn000.image = t.image; jjtn000.setNatural(t.image);
    1639        } finally {
    1640        if (jjtc000) {
    1641          jjtree.closeNodeScope(jjtn000, true);
    1642          jjtreeCloseNodeScope(jjtn000);
    1643        }
    1644        }
    1645      }
    1646
    1647      final public void FloatLiteral() throws ParseException {
    1648     /*@bgen(jjtree) NumberLiteral */
    1649      ASTNumberLiteral jjtn000 = new ASTNumberLiteral(JJTNUMBERLITERAL);
    1650      boolean jjtc000 = true;
    1651      jjtree.openNodeScope(jjtn000);
    1652      jjtreeOpenNodeScope(jjtn000);Token t;
    1653        try {
    1654          t = jj_consume_token(FLOAT_LITERAL);
    1655        jjtree.closeNodeScope(jjtn000, true);
    1656        jjtc000 = false;
    1657        jjtreeCloseNodeScope(jjtn000);
    1658        jjtn000.image = t.image; jjtn000.setReal(t.image);
    1659        } finally {
    1660        if (jjtc000) {
    1661          jjtree.closeNodeScope(jjtn000, true);
    1662          jjtreeCloseNodeScope(jjtn000);
    1663        }
    1664        }
    1665      }
    1666
    1667      final public void StringLiteral() throws ParseException {
    1668     /*@bgen(jjtree) StringLiteral */
    1669       ASTStringLiteral jjtn000 = new ASTStringLiteral(JJTSTRINGLITERAL);
    1670       boolean jjtc000 = true;
    1671       jjtree.openNodeScope(jjtn000);
    1672       jjtreeOpenNodeScope(jjtn000);Token t;
    1673        try {
    1674          t = jj_consume_token(STRING_LITERAL);
    1675        jjtree.closeNodeScope(jjtn000, true);
    1676        jjtc000 = false;
    1677        jjtreeCloseNodeScope(jjtn000);
    1678        jjtn000.image = Parser.buildString(t.image, true);
    1679        } finally {
    1680        if (jjtc000) {
    1681          jjtree.closeNodeScope(jjtn000, true);
    1682          jjtreeCloseNodeScope(jjtn000);
    1683        }
    1684        }
    1685      }
    1686
    1687      final public void ArrayLiteral() throws ParseException {
    1688                           /*@bgen(jjtree) ArrayLiteral */
    1689      ASTArrayLiteral jjtn000 = new ASTArrayLiteral(JJTARRAYLITERAL);
    1690      boolean jjtc000 = true;
    1691      jjtree.openNodeScope(jjtn000);
    1692      jjtreeOpenNodeScope(jjtn000);
    1693        try {
    1694          jj_consume_token(LBRACKET);
    1695          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1696          case NEW:
    1697          case EMPTY:
    1698          case SIZE:
    1699          case NULL:
    1700          case TRUE:
    1701          case FALSE:
    1702          case LPAREN:
    1703          case LCURLY:
    1704          case LBRACKET:
    1705          case not:
    1706          case minus:
    1707          case tilda:
    1708          case IDENTIFIER:
    1709          case REGISTER:
    1710          case INTEGER_LITERAL:
    1711          case FLOAT_LITERAL:
    1712          case STRING_LITERAL:
    1713            Expression();
    1714            label_11:
    1715            while (true) {
    1716              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1717              case COMMA:
    1718                ;
    1719                break;
    1720              default:
    1721                jj_la1[29] = jj_gen;
    1722                break label_11;
    1723              }
    1724              jj_consume_token(COMMA);
    1725              Expression();
    1726            }
    1727            break;
    1728          default:
    1729            jj_la1[30] = jj_gen;
    1730            ;
    1731          }
    1732          jj_consume_token(RBRACKET);
    1733        } catch (Throwable jjte000) {
    1734        if (jjtc000) {
    1735          jjtree.clearNodeScope(jjtn000);
    1736          jjtc000 = false;
    1737        } else {
    1738          jjtree.popNode();
    1739        }
    1740        if (jjte000 instanceof RuntimeException) {
    1741          {if (true) throw (RuntimeException)jjte000;}
    1742        }
    1743        if (jjte000 instanceof ParseException) {
    1744          {if (true) throw (ParseException)jjte000;}
    1745        }
    1746        {if (true) throw (Error)jjte000;}
    1747        } finally {
    1748        if (jjtc000) {
    1749          jjtree.closeNodeScope(jjtn000, true);
    1750          jjtreeCloseNodeScope(jjtn000);
    1751        }
    1752        }
    1753      }
    1754
    1755      final public void MapLiteral() throws ParseException {
    1756                         /*@bgen(jjtree) MapLiteral */
    1757      ASTMapLiteral jjtn000 = new ASTMapLiteral(JJTMAPLITERAL);
    1758      boolean jjtc000 = true;
    1759      jjtree.openNodeScope(jjtn000);
    1760      jjtreeOpenNodeScope(jjtn000);
    1761        try {
    1762          jj_consume_token(LCURLY);
    1763          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1764          case NEW:
    1765          case EMPTY:
    1766          case SIZE:
    1767          case NULL:
    1768          case TRUE:
    1769          case FALSE:
    1770          case LPAREN:
    1771          case LCURLY:
    1772          case LBRACKET:
    1773          case not:
    1774          case minus:
    1775          case tilda:
    1776          case IDENTIFIER:
    1777          case REGISTER:
    1778          case INTEGER_LITERAL:
    1779          case FLOAT_LITERAL:
    1780          case STRING_LITERAL:
    1781            MapEntry();
    1782            label_12:
    1783            while (true) {
    1784              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1785              case COMMA:
    1786                ;
    1787                break;
    1788              default:
    1789                jj_la1[31] = jj_gen;
    1790                break label_12;
    1791              }
    1792              jj_consume_token(COMMA);
    1793              MapEntry();
    1794            }
    1795            break;
    1796          case COLON:
    1797            jj_consume_token(COLON);
    1798            break;
    1799          default:
    1800            jj_la1[32] = jj_gen;
    1801            jj_consume_token(-1);
    1802            throw new ParseException();
    1803          }
    1804          jj_consume_token(RCURLY);
    1805        } catch (Throwable jjte000) {
    1806          if (jjtc000) {
    1807            jjtree.clearNodeScope(jjtn000);
    1808            jjtc000 = false;
    1809          } else {
    1810            jjtree.popNode();
    1811          }
    1812          if (jjte000 instanceof RuntimeException) {
    1813            {if (true) throw (RuntimeException)jjte000;}
    1814          }
    1815          if (jjte000 instanceof ParseException) {
    1816            {if (true) throw (ParseException)jjte000;}
    1817          }
    1818          {if (true) throw (Error)jjte000;}
    1819        } finally {
    1820          if (jjtc000) {
    1821            jjtree.closeNodeScope(jjtn000, true);
    1822            jjtreeCloseNodeScope(jjtn000);
    1823          }
    1824        }
    1825      }
    1826
    1827      final public void MapEntry() throws ParseException {
    1828                       /*@bgen(jjtree) MapEntry */
    1829      ASTMapEntry jjtn000 = new ASTMapEntry(JJTMAPENTRY);
    1830      boolean jjtc000 = true;
    1831      jjtree.openNodeScope(jjtn000);
    1832      jjtreeOpenNodeScope(jjtn000);
    1833        try {
    1834          Expression();
    1835          jj_consume_token(COLON);
    1836          Expression();
    1837        } catch (Throwable jjte000) {
    1838          if (jjtc000) {
    1839            jjtree.clearNodeScope(jjtn000);
    1840            jjtc000 = false;
    1841          } else {
    1842            jjtree.popNode();
    1843          }
    1844          if (jjte000 instanceof RuntimeException) {
    1845            {if (true) throw (RuntimeException)jjte000;}
    1846          }
    1847          if (jjte000 instanceof ParseException) {
    1848            {if (true) throw (ParseException)jjte000;}
    1849          }
    1850          {if (true) throw (Error)jjte000;}
    1851        } finally {
    1852          if (jjtc000) {
    1853            jjtree.closeNodeScope(jjtn000, true);
    1854            jjtreeCloseNodeScope(jjtn000);
    1855          }
    1856        }
    1857      }
    1858
    1859    /***************************************
    1860     *      Functions & Methods
    1861     ***************************************/
    1862      final public void EmptyFunction() throws ParseException {
    1863                            /*@bgen(jjtree) EmptyFunction */
    1864      ASTEmptyFunction jjtn000 = new ASTEmptyFunction(JJTEMPTYFUNCTION);
    1865      boolean jjtc000 = true;
    1866      jjtree.openNodeScope(jjtn000);
    1867      jjtreeOpenNodeScope(jjtn000);
    1868        try {
    1869          if (jj_2_3(3)) {
    1870            jj_consume_token(EMPTY);
    1871            jj_consume_token(LPAREN);
    1872            Expression();
    1873            jj_consume_token(RPAREN);
    1874          } else {
    1875            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1876            case EMPTY:
    1877              jj_consume_token(EMPTY);
    1878              Reference();
    1879              break;
    1880            default:
    1881              jj_la1[33] = jj_gen;
    1882              jj_consume_token(-1);
    1883              throw new ParseException();
    1884            }
    1885          }
    1886        } catch (Throwable jjte000) {
    1887          if (jjtc000) {
    1888            jjtree.clearNodeScope(jjtn000);
    1889            jjtc000 = false;
    1890          } else {
    1891            jjtree.popNode();
    1892          }
    1893          if (jjte000 instanceof RuntimeException) {
    1894            {if (true) throw (RuntimeException)jjte000;}
    1895          }
    1896          if (jjte000 instanceof ParseException) {
    1897            {if (true) throw (ParseException)jjte000;}
    1898          }
    1899          {if (true) throw (Error)jjte000;}
    1900        } finally {
    1901          if (jjtc000) {
    1902            jjtree.closeNodeScope(jjtn000, true);
    1903            jjtreeCloseNodeScope(jjtn000);
    1904          }
    1905        }
    1906      }
    1907
    1908      final public void SizeFunction() throws ParseException {
    1909                           /*@bgen(jjtree) SizeFunction */
    1910      ASTSizeFunction jjtn000 = new ASTSizeFunction(JJTSIZEFUNCTION);
    1911      boolean jjtc000 = true;
    1912      jjtree.openNodeScope(jjtn000);
    1913      jjtreeOpenNodeScope(jjtn000);
    1914        try {
    1915          jj_consume_token(SIZE);
    1916          jj_consume_token(LPAREN);
    1917          Expression();
    1918          jj_consume_token(RPAREN);
    1919        } catch (Throwable jjte000) {
    1920          if (jjtc000) {
    1921            jjtree.clearNodeScope(jjtn000);
    1922            jjtc000 = false;
    1923          } else {
    1924            jjtree.popNode();
    1925          }
    1926          if (jjte000 instanceof RuntimeException) {
    1927            {if (true) throw (RuntimeException)jjte000;}
    1928          }
    1929          if (jjte000 instanceof ParseException) {
    1930            {if (true) throw (ParseException)jjte000;}
    1931          }
    1932          {if (true) throw (Error)jjte000;}
    1933        } finally {
    1934          if (jjtc000) {
    1935            jjtree.closeNodeScope(jjtn000, true);
    1936            jjtreeCloseNodeScope(jjtn000);
    1937          }
    1938        }
    1939      }
    1940
    1941      final public void Function() throws ParseException {
    1942                                    /*@bgen(jjtree) FunctionNode */
    1943      ASTFunctionNode jjtn000 = new ASTFunctionNode(JJTFUNCTIONNODE);
    1944      boolean jjtc000 = true;
    1945      jjtree.openNodeScope(jjtn000);
    1946      jjtreeOpenNodeScope(jjtn000);
    1947        try {
    1948          Identifier();
    1949          jj_consume_token(COLON);
    1950          Identifier();
    1951          jj_consume_token(LPAREN);
    1952          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1953          case NEW:
    1954          case EMPTY:
    1955          case SIZE:
    1956          case NULL:
    1957          case TRUE:
    1958          case FALSE:
    1959          case LPAREN:
    1960          case LCURLY:
    1961          case LBRACKET:
    1962          case not:
    1963          case minus:
    1964          case tilda:
    1965          case IDENTIFIER:
    1966          case REGISTER:
    1967          case INTEGER_LITERAL:
    1968          case FLOAT_LITERAL:
    1969          case STRING_LITERAL:
    1970            Expression();
    1971            label_13:
    1972            while (true) {
    1973              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1974              case COMMA:
    1975                ;
    1976                break;
    1977              default:
    1978                jj_la1[34] = jj_gen;
    1979                break label_13;
    1980              }
    1981              jj_consume_token(COMMA);
    1982              Expression();
    1983            }
    1984            break;
    1985          default:
    1986            jj_la1[35] = jj_gen;
    1987            ;
    1988          }
    1989          jj_consume_token(RPAREN);
    1990        } catch (Throwable jjte000) {
    1991         if (jjtc000) {
    1992           jjtree.clearNodeScope(jjtn000);
    1993           jjtc000 = false;
    1994         } else {
    1995           jjtree.popNode();
    1996         }
    1997         if (jjte000 instanceof RuntimeException) {
    1998           {if (true) throw (RuntimeException)jjte000;}
    1999         }
    2000         if (jjte000 instanceof ParseException) {
    2001           {if (true) throw (ParseException)jjte000;}
    2002         }
    2003         {if (true) throw (Error)jjte000;}
    2004        } finally {
    2005         if (jjtc000) {
    2006           jjtree.closeNodeScope(jjtn000, true);
    2007           jjtreeCloseNodeScope(jjtn000);
    2008         }
    2009        }
    2010      }
    2011
    2012      final public void Method() throws ParseException {
    2013                                /*@bgen(jjtree) MethodNode */
    2014      ASTMethodNode jjtn000 = new ASTMethodNode(JJTMETHODNODE);
    2015      boolean jjtc000 = true;
    2016      jjtree.openNodeScope(jjtn000);
    2017      jjtreeOpenNodeScope(jjtn000);
    2018        try {
    2019          Identifier();
    2020          jj_consume_token(LPAREN);
    2021          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2022          case NEW:
    2023          case EMPTY:
    2024          case SIZE:
    2025          case NULL:
    2026          case TRUE:
    2027          case FALSE:
    2028          case LPAREN:
    2029          case LCURLY:
    2030          case LBRACKET:
    2031          case not:
    2032          case minus:
    2033          case tilda:
    2034          case IDENTIFIER:
    2035          case REGISTER:
    2036          case INTEGER_LITERAL:
    2037          case FLOAT_LITERAL:
    2038          case STRING_LITERAL:
    2039            Expression();
    2040            label_14:
    2041            while (true) {
    2042              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2043              case COMMA:
    2044                ;
    2045                break;
    2046              default:
    2047                jj_la1[36] = jj_gen;
    2048                break label_14;
    2049              }
    2050              jj_consume_token(COMMA);
    2051              Expression();
    2052            }
    2053            break;
    2054          default:
    2055            jj_la1[37] = jj_gen;
    2056            ;
    2057          }
    2058          jj_consume_token(RPAREN);
    2059        } catch (Throwable jjte000) {
    2060         if (jjtc000) {
    2061           jjtree.clearNodeScope(jjtn000);
    2062           jjtc000 = false;
    2063         } else {
    2064           jjtree.popNode();
    2065         }
    2066         if (jjte000 instanceof RuntimeException) {
    2067           {if (true) throw (RuntimeException)jjte000;}
    2068         }
    2069         if (jjte000 instanceof ParseException) {
    2070           {if (true) throw (ParseException)jjte000;}
    2071         }
    2072         {if (true) throw (Error)jjte000;}
    2073        } finally {
    2074         if (jjtc000) {
    2075           jjtree.closeNodeScope(jjtn000, true);
    2076           jjtreeCloseNodeScope(jjtn000);
    2077         }
    2078        }
    2079      }
    2080
    2081      final public void AnyMethod() throws ParseException {
    2082        if (jj_2_4(2147483647)) {
    2083          SizeMethod();
    2084        } else if (jj_2_5(2147483647)) {
    2085          Method();
    2086        } else {
    2087          jj_consume_token(-1);
    2088          throw new ParseException();
    2089        }
    2090      }
    2091
    2092      final public void SizeMethod() throws ParseException {
    2093                         /*@bgen(jjtree) SizeMethod */
    2094      ASTSizeMethod jjtn000 = new ASTSizeMethod(JJTSIZEMETHOD);
    2095      boolean jjtc000 = true;
    2096      jjtree.openNodeScope(jjtn000);
    2097      jjtreeOpenNodeScope(jjtn000);
    2098        try {
    2099          jj_consume_token(SIZE);
    2100          jj_consume_token(LPAREN);
    2101          jj_consume_token(RPAREN);
    2102        } finally {
    2103          if (jjtc000) {
    2104            jjtree.closeNodeScope(jjtn000, true);
    2105            jjtreeCloseNodeScope(jjtn000);
    2106          }
    2107        }
    2108      }
    2109
    2110      final public void Constructor() throws ParseException {
    2111                                             /*@bgen(jjtree) #ConstructorNode(true) */
    2112      ASTConstructorNode jjtn000 = new ASTConstructorNode(JJTCONSTRUCTORNODE);
    2113      boolean jjtc000 = true;
    2114      jjtree.openNodeScope(jjtn000);
    2115      jjtreeOpenNodeScope(jjtn000);
    2116        try {
    2117          jj_consume_token(NEW);
    2118          jj_consume_token(LPAREN);
    2119          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2120          case NEW:
    2121          case EMPTY:
    2122          case SIZE:
    2123          case NULL:
    2124          case TRUE:
    2125          case FALSE:
    2126          case LPAREN:
    2127          case LCURLY:
    2128          case LBRACKET:
    2129          case not:
    2130          case minus:
    2131          case tilda:
    2132          case IDENTIFIER:
    2133          case REGISTER:
    2134          case INTEGER_LITERAL:
    2135          case FLOAT_LITERAL:
    2136          case STRING_LITERAL:
    2137            Expression();
    2138            label_15:
    2139            while (true) {
    2140              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2141              case COMMA:
    2142                ;
    2143                break;
    2144              default:
    2145                jj_la1[38] = jj_gen;
    2146                break label_15;
    2147              }
    2148              jj_consume_token(COMMA);
    2149              Expression();
    2150            }
    2151            break;
    2152          default:
    2153            jj_la1[39] = jj_gen;
    2154            ;
    2155          }
    2156          jj_consume_token(RPAREN);
    2157        } catch (Throwable jjte000) {
    2158        if (jjtc000) {
    2159          jjtree.clearNodeScope(jjtn000);
    2160          jjtc000 = false;
    2161        } else {
    2162          jjtree.popNode();
    2163        }
    2164        if (jjte000 instanceof RuntimeException) {
    2165          {if (true) throw (RuntimeException)jjte000;}
    2166        }
    2167        if (jjte000 instanceof ParseException) {
    2168          {if (true) throw (ParseException)jjte000;}
    2169        }
    2170        {if (true) throw (Error)jjte000;}
    2171        } finally {
    2172        if (jjtc000) {
    2173          jjtree.closeNodeScope(jjtn000, true);
    2174          jjtreeCloseNodeScope(jjtn000);
    2175        }
    2176        }
    2177      }
    2178
    2179    /***************************************
    2180     *     References
    2181     ***************************************/
    2182      final public void PrimaryExpression() throws ParseException {
    2183        if (jj_2_6(2)) {
    2184          Reference();
    2185        } else if (jj_2_7(2147483647)) {
    2186          EmptyFunction();
    2187        } else if (jj_2_8(2147483647)) {
    2188          SizeFunction();
    2189        } else if (jj_2_9(2147483647)) {
    2190          Constructor();
    2191        } else if (jj_2_10(2147483647)) {
    2192          MapLiteral();
    2193        } else if (jj_2_11(2147483647)) {
    2194          ArrayLiteral();
    2195        } else {
    2196          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2197          case NULL:
    2198          case TRUE:
    2199          case FALSE:
    2200          case INTEGER_LITERAL:
    2201          case FLOAT_LITERAL:
    2202          case STRING_LITERAL:
    2203            Literal();
    2204            break;
    2205          default:
    2206            jj_la1[40] = jj_gen;
    2207            jj_consume_token(-1);
    2208            throw new ParseException();
    2209          }
    2210        }
    2211      }
    2212
    2213      final public void ArrayAccess() throws ParseException {
    2214                          /*@bgen(jjtree) ArrayAccess */
    2215      ASTArrayAccess jjtn000 = new ASTArrayAccess(JJTARRAYACCESS);
    2216      boolean jjtc000 = true;
    2217      jjtree.openNodeScope(jjtn000);
    2218      jjtreeOpenNodeScope(jjtn000);
    2219        try {
    2220          Identifier();
    2221          label_16:
    2222          while (true) {
    2223            jj_consume_token(LBRACKET);
    2224            Expression();
    2225            jj_consume_token(RBRACKET);
    2226            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2227            case LBRACKET:
    2228              ;
    2229              break;
    2230            default:
    2231              jj_la1[41] = jj_gen;
    2232              break label_16;
    2233            }
    2234          }
    2235        } catch (Throwable jjte000) {
    2236          if (jjtc000) {
    2237            jjtree.clearNodeScope(jjtn000);
    2238            jjtc000 = false;
    2239          } else {
    2240            jjtree.popNode();
    2241          }
    2242          if (jjte000 instanceof RuntimeException) {
    2243            {if (true) throw (RuntimeException)jjte000;}
    2244          }
    2245          if (jjte000 instanceof ParseException) {
    2246            {if (true) throw (ParseException)jjte000;}
    2247          }
    2248          {if (true) throw (Error)jjte000;}
    2249        } finally {
    2250          if (jjtc000) {
    2251            jjtree.closeNodeScope(jjtn000, true);
    2252            jjtreeCloseNodeScope(jjtn000);
    2253          }
    2254        }
    2255      }
    2256
    2257      final public void DotReference() throws ParseException {
    2258        label_17:
    2259        while (true) {
    2260          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2261          case DOT:
    2262            ;
    2263            break;
    2264          default:
    2265            jj_la1[42] = jj_gen;
    2266            break label_17;
    2267          }
    2268          jj_consume_token(DOT);
    2269          if (jj_2_13(2147483647)) {
    2270            ArrayAccess();
    2271          } else {
    2272            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2273            case SIZE:
    2274            case IDENTIFIER:
    2275            case REGISTER:
    2276            case INTEGER_LITERAL:
    2277            case STRING_LITERAL:
    2278              if (jj_2_12(2)) {
    2279                AnyMethod();
    2280              } else {
    2281                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2282                case IDENTIFIER:
    2283                case REGISTER:
    2284                  Identifier();
    2285                  break;
    2286                case INTEGER_LITERAL:
    2287                  IntegerLiteral();
    2288                  break;
    2289                case STRING_LITERAL:
    2290                  StringIdentifier();
    2291                  break;
    2292                default:
    2293                  jj_la1[43] = jj_gen;
    2294                  jj_consume_token(-1);
    2295                  throw new ParseException();
    2296                }
    2297              }
    2298              break;
    2299            default:
    2300              jj_la1[44] = jj_gen;
    2301              jj_consume_token(-1);
    2302              throw new ParseException();
    2303            }
    2304          }
    2305        }
    2306      }
    2307
    2308      final public void Reference() throws ParseException {
    2309                        /*@bgen(jjtree) Reference */
    2310      ASTReference jjtn000 = new ASTReference(JJTREFERENCE);
    2311      boolean jjtc000 = true;
    2312      jjtree.openNodeScope(jjtn000);
    2313      jjtreeOpenNodeScope(jjtn000);
    2314        try {
    2315          if (jj_2_14(2147483647)) {
    2316            Constructor();
    2317          } else if (jj_2_15(2147483647)) {
    2318            ArrayAccess();
    2319          } else if (jj_2_16(2147483647)) {
    2320            Function();
    2321          } else if (jj_2_17(2147483647)) {
    2322            Method();
    2323          } else if (jj_2_18(2147483647)) {
    2324            MapLiteral();
    2325          } else if (jj_2_19(2147483647)) {
    2326            ArrayLiteral();
    2327          } else if (jj_2_20(2147483647)) {
    2328            ReferenceExpression();
    2329          } else {
    2330            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2331            case STRING_LITERAL:
    2332              StringLiteral();
    2333              break;
    2334            case IDENTIFIER:
    2335            case REGISTER:
    2336              Identifier(true);
    2337              break;
    2338            default:
    2339              jj_la1[45] = jj_gen;
    2340              jj_consume_token(-1);
    2341              throw new ParseException();
    2342            }
    2343          }
    2344          DotReference();
    2345        } catch (Throwable jjte000) {
    2346        if (jjtc000) {
    2347          jjtree.clearNodeScope(jjtn000);
    2348          jjtc000 = false;
    2349        } else {
    2350          jjtree.popNode();
    2351        }
    2352        if (jjte000 instanceof RuntimeException) {
    2353          {if (true) throw (RuntimeException)jjte000;}
    2354        }
    2355        if (jjte000 instanceof ParseException) {
    2356          {if (true) throw (ParseException)jjte000;}
    2357        }
    2358        {if (true) throw (Error)jjte000;}
    2359        } finally {
    2360        if (jjtc000) {
    2361          jjtree.closeNodeScope(jjtn000, true);
    2362          jjtreeCloseNodeScope(jjtn000);
    2363        }
    2364        }
    2365      }
    2366
    2367    /**
    2368     * ReferenceExpression is a subclass of ArrayAccess
    2369     */
    2370      final public void ReferenceExpression() throws ParseException {
    2371                                  /*@bgen(jjtree) ReferenceExpression */
    2372      ASTReferenceExpression jjtn000 = new ASTReferenceExpression(JJTREFERENCEEXPRESSION);
    2373      boolean jjtc000 = true;
    2374      jjtree.openNodeScope(jjtn000);
    2375      jjtreeOpenNodeScope(jjtn000);
    2376        try {
    2377          jj_consume_token(LPAREN);
    2378          Expression();
    2379          jj_consume_token(RPAREN);
    2380          label_18:
    2381          while (true) {
    2382            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2383            case LBRACKET:
    2384              ;
    2385              break;
    2386            default:
    2387              jj_la1[46] = jj_gen;
    2388              break label_18;
    2389            }
    2390            jj_consume_token(LBRACKET);
    2391            Expression();
    2392            jj_consume_token(RBRACKET);
    2393          }
    2394        } catch (Throwable jjte000) {
    2395          if (jjtc000) {
    2396            jjtree.clearNodeScope(jjtn000);
    2397            jjtc000 = false;
    2398          } else {
    2399            jjtree.popNode();
    2400          }
    2401          if (jjte000 instanceof RuntimeException) {
    2402            {if (true) throw (RuntimeException)jjte000;}
    2403          }
    2404          if (jjte000 instanceof ParseException) {
    2405            {if (true) throw (ParseException)jjte000;}
    2406          }
    2407          {if (true) throw (Error)jjte000;}
    2408        } finally {
    2409          if (jjtc000) {
    2410            jjtree.closeNodeScope(jjtn000, true);
    2411            jjtreeCloseNodeScope(jjtn000);
    2412          }
    2413        }
    2414      }
    2415
    2416      private boolean jj_2_1(int xla) {
    2417        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2418        try { return !jj_3_1(); }
    2419        catch(LookaheadSuccess ls) { return true; }
    2420        finally { jj_save(0, xla); }
    2421      }
    2422
    2423      private boolean jj_2_2(int xla) {
    2424        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2425        try { return !jj_3_2(); }
    2426        catch(LookaheadSuccess ls) { return true; }
    2427        finally { jj_save(1, xla); }
    2428      }
    2429
    2430      private boolean jj_2_3(int xla) {
    2431        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2432        try { return !jj_3_3(); }
    2433        catch(LookaheadSuccess ls) { return true; }
    2434        finally { jj_save(2, xla); }
    2435      }
    2436
    2437      private boolean jj_2_4(int xla) {
    2438        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2439        try { return !jj_3_4(); }
    2440        catch(LookaheadSuccess ls) { return true; }
    2441        finally { jj_save(3, xla); }
    2442      }
    2443
    2444      private boolean jj_2_5(int xla) {
    2445        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2446        try { return !jj_3_5(); }
    2447        catch(LookaheadSuccess ls) { return true; }
    2448        finally { jj_save(4, xla); }
    2449      }
    2450
    2451      private boolean jj_2_6(int xla) {
    2452        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2453        try { return !jj_3_6(); }
    2454        catch(LookaheadSuccess ls) { return true; }
    2455        finally { jj_save(5, xla); }
    2456      }
    2457
    2458      private boolean jj_2_7(int xla) {
    2459        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2460        try { return !jj_3_7(); }
    2461        catch(LookaheadSuccess ls) { return true; }
    2462        finally { jj_save(6, xla); }
    2463      }
    2464
    2465      private boolean jj_2_8(int xla) {
    2466        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2467        try { return !jj_3_8(); }
    2468        catch(LookaheadSuccess ls) { return true; }
    2469        finally { jj_save(7, xla); }
    2470      }
    2471
    2472      private boolean jj_2_9(int xla) {
    2473        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2474        try { return !jj_3_9(); }
    2475        catch(LookaheadSuccess ls) { return true; }
    2476        finally { jj_save(8, xla); }
    2477      }
    2478
    2479      private boolean jj_2_10(int xla) {
    2480        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2481        try { return !jj_3_10(); }
    2482        catch(LookaheadSuccess ls) { return true; }
    2483        finally { jj_save(9, xla); }
    2484      }
    2485
    2486      private boolean jj_2_11(int xla) {
    2487        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2488        try { return !jj_3_11(); }
    2489        catch(LookaheadSuccess ls) { return true; }
    2490        finally { jj_save(10, xla); }
    2491      }
    2492
    2493      private boolean jj_2_12(int xla) {
    2494        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2495        try { return !jj_3_12(); }
    2496        catch(LookaheadSuccess ls) { return true; }
    2497        finally { jj_save(11, xla); }
    2498      }
    2499
    2500      private boolean jj_2_13(int xla) {
    2501        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2502        try { return !jj_3_13(); }
    2503        catch(LookaheadSuccess ls) { return true; }
    2504        finally { jj_save(12, xla); }
    2505      }
    2506
    2507      private boolean jj_2_14(int xla) {
    2508        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2509        try { return !jj_3_14(); }
    2510        catch(LookaheadSuccess ls) { return true; }
    2511        finally { jj_save(13, xla); }
    2512      }
    2513
    2514      private boolean jj_2_15(int xla) {
    2515        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2516        try { return !jj_3_15(); }
    2517        catch(LookaheadSuccess ls) { return true; }
    2518        finally { jj_save(14, xla); }
    2519      }
    2520
    2521      private boolean jj_2_16(int xla) {
    2522        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2523        try { return !jj_3_16(); }
    2524        catch(LookaheadSuccess ls) { return true; }
    2525        finally { jj_save(15, xla); }
    2526      }
    2527
    2528      private boolean jj_2_17(int xla) {
    2529        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2530        try { return !jj_3_17(); }
    2531        catch(LookaheadSuccess ls) { return true; }
    2532        finally { jj_save(16, xla); }
    2533      }
    2534
    2535      private boolean jj_2_18(int xla) {
    2536        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2537        try { return !jj_3_18(); }
    2538        catch(LookaheadSuccess ls) { return true; }
    2539        finally { jj_save(17, xla); }
    2540      }
    2541
    2542      private boolean jj_2_19(int xla) {
    2543        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2544        try { return !jj_3_19(); }
    2545        catch(LookaheadSuccess ls) { return true; }
    2546        finally { jj_save(18, xla); }
    2547      }
    2548
    2549      private boolean jj_2_20(int xla) {
    2550        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2551        try { return !jj_3_20(); }
    2552        catch(LookaheadSuccess ls) { return true; }
    2553        finally { jj_save(19, xla); }
    2554      }
    2555
    2556      private boolean jj_3R_94() {
    2557        if (jj_3R_102()) return true;
    2558        Token xsp;
    2559        while (true) {
    2560          xsp = jj_scanpos;
    2561          if (jj_3R_103()) { jj_scanpos = xsp; break; }
    2562        }
    2563        return false;
    2564      }
    2565
    2566      private boolean jj_3R_113() {
    2567        if (jj_scan_token(minus)) return true;
    2568        return false;
    2569      }
    2570
    2571      private boolean jj_3R_104() {
    2572        Token xsp;
    2573        xsp = jj_scanpos;
    2574        if (jj_3R_112()) {
    2575        jj_scanpos = xsp;
    2576        if (jj_3R_113()) return true;
    2577        }
    2578        return false;
    2579      }
    2580
    2581      private boolean jj_3R_112() {
    2582        if (jj_scan_token(plus)) return true;
    2583        return false;
    2584      }
    2585
    2586      private boolean jj_3R_90() {
    2587        if (jj_3R_94()) return true;
    2588        Token xsp;
    2589        while (true) {
    2590          xsp = jj_scanpos;
    2591          if (jj_3R_95()) { jj_scanpos = xsp; break; }
    2592        }
    2593        return false;
    2594      }
    2595
    2596      private boolean jj_3R_101() {
    2597        if (jj_scan_token(rne)) return true;
    2598        if (jj_3R_90()) return true;
    2599        return false;
    2600      }
    2601
    2602      private boolean jj_3R_100() {
    2603        if (jj_scan_token(req)) return true;
    2604        if (jj_3R_90()) return true;
    2605        return false;
    2606      }
    2607
    2608      private boolean jj_3R_99() {
    2609        if (jj_scan_token(ge)) return true;
    2610        if (jj_3R_90()) return true;
    2611        return false;
    2612      }
    2613
    2614      private boolean jj_3R_98() {
    2615        if (jj_scan_token(le)) return true;
    2616        if (jj_3R_90()) return true;
    2617        return false;
    2618      }
    2619
    2620      private boolean jj_3R_97() {
    2621        if (jj_scan_token(gt)) return true;
    2622        if (jj_3R_90()) return true;
    2623        return false;
    2624      }
    2625
    2626      private boolean jj_3R_91() {
    2627        Token xsp;
    2628        xsp = jj_scanpos;
    2629        if (jj_3R_96()) {
    2630        jj_scanpos = xsp;
    2631        if (jj_3R_97()) {
    2632        jj_scanpos = xsp;
    2633        if (jj_3R_98()) {
    2634        jj_scanpos = xsp;
    2635        if (jj_3R_99()) {
    2636        jj_scanpos = xsp;
    2637        if (jj_3R_100()) {
    2638        jj_scanpos = xsp;
    2639        if (jj_3R_101()) return true;
    2640        }
    2641        }
    2642        }
    2643        }
    2644        }
    2645        return false;
    2646      }
    2647
    2648      private boolean jj_3R_96() {
    2649        if (jj_scan_token(lt)) return true;
    2650        if (jj_3R_90()) return true;
    2651        return false;
    2652      }
    2653
    2654      private boolean jj_3R_88() {
    2655        if (jj_3R_90()) return true;
    2656        Token xsp;
    2657        xsp = jj_scanpos;
    2658        if (jj_3R_91()) jj_scanpos = xsp;
    2659        return false;
    2660      }
    2661
    2662      private boolean jj_3R_93() {
    2663        if (jj_scan_token(ne)) return true;
    2664        if (jj_3R_88()) return true;
    2665        return false;
    2666      }
    2667
    2668      private boolean jj_3R_89() {
    2669        Token xsp;
    2670        xsp = jj_scanpos;
    2671        if (jj_3R_92()) {
    2672        jj_scanpos = xsp;
    2673        if (jj_3R_93()) return true;
    2674        }
    2675        return false;
    2676      }
    2677
    2678      private boolean jj_3R_92() {
    2679        if (jj_scan_token(eq)) return true;
    2680        if (jj_3R_88()) return true;
    2681        return false;
    2682      }
    2683
    2684      private boolean jj_3R_86() {
    2685        if (jj_3R_88()) return true;
    2686        Token xsp;
    2687        xsp = jj_scanpos;
    2688        if (jj_3R_89()) jj_scanpos = xsp;
    2689        return false;
    2690      }
    2691
    2692      private boolean jj_3R_87() {
    2693        if (jj_scan_token(and)) return true;
    2694        if (jj_3R_86()) return true;
    2695        return false;
    2696      }
    2697
    2698      private boolean jj_3R_84() {
    2699        if (jj_3R_86()) return true;
    2700        Token xsp;
    2701        while (true) {
    2702          xsp = jj_scanpos;
    2703          if (jj_3R_87()) { jj_scanpos = xsp; break; }
    2704        }
    2705        return false;
    2706      }
    2707
    2708      private boolean jj_3R_85() {
    2709        if (jj_scan_token(xor)) return true;
    2710        if (jj_3R_84()) return true;
    2711        return false;
    2712      }
    2713
    2714      private boolean jj_3R_82() {
    2715        if (jj_3R_84()) return true;
    2716        Token xsp;
    2717        while (true) {
    2718          xsp = jj_scanpos;
    2719          if (jj_3R_85()) { jj_scanpos = xsp; break; }
    2720        }
    2721        return false;
    2722      }
    2723
    2724      private boolean jj_3R_83() {
    2725        if (jj_scan_token(or)) return true;
    2726        if (jj_3R_82()) return true;
    2727        return false;
    2728      }
    2729
    2730      private boolean jj_3R_75() {
    2731        if (jj_3R_82()) return true;
    2732        Token xsp;
    2733        while (true) {
    2734          xsp = jj_scanpos;
    2735          if (jj_3R_83()) { jj_scanpos = xsp; break; }
    2736        }
    2737        return false;
    2738      }
    2739
    2740      private boolean jj_3R_77() {
    2741        if (jj_scan_token(AND)) return true;
    2742        if (jj_3R_75()) return true;
    2743        return false;
    2744      }
    2745
    2746      private boolean jj_3R_62() {
    2747        if (jj_3R_75()) return true;
    2748        Token xsp;
    2749        while (true) {
    2750          xsp = jj_scanpos;
    2751          if (jj_3R_77()) { jj_scanpos = xsp; break; }
    2752        }
    2753        return false;
    2754      }
    2755
    2756      private boolean jj_3R_66() {
    2757        if (jj_scan_token(OR)) return true;
    2758        if (jj_3R_62()) return true;
    2759        return false;
    2760      }
    2761
    2762      private boolean jj_3R_44() {
    2763        if (jj_3R_62()) return true;
    2764        Token xsp;
    2765        while (true) {
    2766          xsp = jj_scanpos;
    2767          if (jj_3R_66()) { jj_scanpos = xsp; break; }
    2768        }
    2769        return false;
    2770      }
    2771
    2772      private boolean jj_3R_68() {
    2773        if (jj_scan_token(ELVIS)) return true;
    2774        if (jj_3R_20()) return true;
    2775        return false;
    2776      }
    2777
    2778      private boolean jj_3R_67() {
    2779        if (jj_scan_token(QMARK)) return true;
    2780        if (jj_3R_20()) return true;
    2781        if (jj_scan_token(COLON)) return true;
    2782        if (jj_3R_20()) return true;
    2783        return false;
    2784      }
    2785
    2786      private boolean jj_3R_55() {
    2787        Token xsp;
    2788        xsp = jj_scanpos;
    2789        if (jj_3R_67()) {
    2790        jj_scanpos = xsp;
    2791        if (jj_3R_68()) return true;
    2792        }
    2793        return false;
    2794      }
    2795
    2796      private boolean jj_3R_27() {
    2797        if (jj_3R_44()) return true;
    2798        Token xsp;
    2799        xsp = jj_scanpos;
    2800        if (jj_3R_55()) jj_scanpos = xsp;
    2801        return false;
    2802      }
    2803
    2804      private boolean jj_3R_42() {
    2805        if (jj_scan_token(assign)) return true;
    2806        if (jj_3R_20()) return true;
    2807        return false;
    2808      }
    2809
    2810      private boolean jj_3R_142() {
    2811        if (jj_scan_token(LBRACKET)) return true;
    2812        if (jj_3R_20()) return true;
    2813        if (jj_scan_token(RBRACKET)) return true;
    2814        return false;
    2815      }
    2816
    2817      private boolean jj_3_2() {
    2818        if (jj_scan_token(SEMICOL)) return true;
    2819        return false;
    2820      }
    2821
    2822      private boolean jj_3R_81() {
    2823        if (jj_scan_token(IDENTIFIER)) return true;
    2824        return false;
    2825      }
    2826
    2827      private boolean jj_3R_74() {
    2828        if (jj_scan_token(VAR)) return true;
    2829        if (jj_3R_81()) return true;
    2830        return false;
    2831      }
    2832
    2833      private boolean jj_3R_20() {
    2834        if (jj_3R_27()) return true;
    2835        Token xsp;
    2836        xsp = jj_scanpos;
    2837        if (jj_3R_42()) jj_scanpos = xsp;
    2838        return false;
    2839      }
    2840
    2841      private boolean jj_3R_73() {
    2842        if (jj_scan_token(RETURN)) return true;
    2843        if (jj_3R_20()) return true;
    2844        return false;
    2845      }
    2846
    2847      private boolean jj_3R_51() {
    2848        if (jj_scan_token(LPAREN)) return true;
    2849        if (jj_3R_20()) return true;
    2850        if (jj_scan_token(RPAREN)) return true;
    2851        Token xsp;
    2852        while (true) {
    2853          xsp = jj_scanpos;
    2854          if (jj_3R_142()) { jj_scanpos = xsp; break; }
    2855        }
    2856        return false;
    2857      }
    2858
    2859      private boolean jj_3_20() {
    2860        if (jj_scan_token(LPAREN)) return true;
    2861        if (jj_3R_20()) return true;
    2862        return false;
    2863      }
    2864
    2865      private boolean jj_3R_79() {
    2866        if (jj_scan_token(FOREACH)) return true;
    2867        if (jj_scan_token(LPAREN)) return true;
    2868        return false;
    2869      }
    2870
    2871      private boolean jj_3R_70() {
    2872        Token xsp;
    2873        xsp = jj_scanpos;
    2874        if (jj_3R_78()) {
    2875        jj_scanpos = xsp;
    2876        if (jj_3R_79()) return true;
    2877        }
    2878        return false;
    2879      }
    2880
    2881      private boolean jj_3R_78() {
    2882        if (jj_scan_token(FOR)) return true;
    2883        if (jj_scan_token(LPAREN)) return true;
    2884        return false;
    2885      }
    2886
    2887      private boolean jj_3_19() {
    2888        if (jj_scan_token(LBRACKET)) return true;
    2889        return false;
    2890      }
    2891
    2892      private boolean jj_3_18() {
    2893        if (jj_scan_token(LCURLY)) return true;
    2894        return false;
    2895      }
    2896
    2897      private boolean jj_3R_80() {
    2898        if (jj_3R_20()) return true;
    2899        return false;
    2900      }
    2901
    2902      private boolean jj_3R_38() {
    2903        if (jj_3R_21()) return true;
    2904        return false;
    2905      }
    2906
    2907      private boolean jj_3_17() {
    2908        if (jj_3R_21()) return true;
    2909        if (jj_scan_token(LPAREN)) return true;
    2910        return false;
    2911      }
    2912
    2913      private boolean jj_3R_71() {
    2914        if (jj_scan_token(WHILE)) return true;
    2915        if (jj_scan_token(LPAREN)) return true;
    2916        return false;
    2917      }
    2918
    2919      private boolean jj_3R_37() {
    2920        if (jj_3R_52()) return true;
    2921        return false;
    2922      }
    2923
    2924      private boolean jj_3_16() {
    2925        if (jj_3R_21()) return true;
    2926        if (jj_scan_token(COLON)) return true;
    2927        if (jj_3R_21()) return true;
    2928        if (jj_scan_token(LPAREN)) return true;
    2929        return false;
    2930      }
    2931
    2932      private boolean jj_3R_36() {
    2933        if (jj_3R_51()) return true;
    2934        return false;
    2935      }
    2936
    2937      private boolean jj_3_15() {
    2938        if (jj_3R_21()) return true;
    2939        if (jj_scan_token(LBRACKET)) return true;
    2940        return false;
    2941      }
    2942
    2943      private boolean jj_3R_35() {
    2944        if (jj_3R_50()) return true;
    2945        return false;
    2946      }
    2947
    2948      private boolean jj_3_14() {
    2949        if (jj_scan_token(NEW)) return true;
    2950        return false;
    2951      }
    2952
    2953      private boolean jj_3R_69() {
    2954        if (jj_scan_token(IF)) return true;
    2955        if (jj_scan_token(LPAREN)) return true;
    2956        return false;
    2957      }
    2958
    2959      private boolean jj_3R_34() {
    2960        if (jj_3R_49()) return true;
    2961        return false;
    2962      }
    2963
    2964      private boolean jj_3R_26() {
    2965        if (jj_3R_43()) return true;
    2966        return false;
    2967      }
    2968
    2969      private boolean jj_3R_33() {
    2970        if (jj_3R_48()) return true;
    2971        return false;
    2972      }
    2973
    2974      private boolean jj_3R_32() {
    2975        if (jj_3R_47()) return true;
    2976        return false;
    2977      }
    2978
    2979      private boolean jj_3R_72() {
    2980        if (jj_3R_20()) return true;
    2981        Token xsp;
    2982        while (true) {
    2983          xsp = jj_scanpos;
    2984          if (jj_3R_80()) { jj_scanpos = xsp; break; }
    2985        }
    2986        xsp = jj_scanpos;
    2987        if (jj_3_2()) jj_scanpos = xsp;
    2988        return false;
    2989      }
    2990
    2991      private boolean jj_3R_31() {
    2992        if (jj_3R_46()) return true;
    2993        return false;
    2994      }
    2995
    2996      private boolean jj_3R_149() {
    2997        if (jj_3R_150()) return true;
    2998        return false;
    2999      }
    3000
    3001      private boolean jj_3R_30() {
    3002        if (jj_3R_45()) return true;
    3003        return false;
    3004      }
    3005
    3006      private boolean jj_3R_148() {
    3007        if (jj_3R_131()) return true;
    3008        return false;
    3009      }
    3010
    3011      private boolean jj_3R_22() {
    3012        Token xsp;
    3013        xsp = jj_scanpos;
    3014        if (jj_3R_30()) {
    3015        jj_scanpos = xsp;
    3016        if (jj_3R_31()) {
    3017        jj_scanpos = xsp;
    3018        if (jj_3R_32()) {
    3019        jj_scanpos = xsp;
    3020        if (jj_3R_33()) {
    3021        jj_scanpos = xsp;
    3022        if (jj_3R_34()) {
    3023        jj_scanpos = xsp;
    3024        if (jj_3R_35()) {
    3025        jj_scanpos = xsp;
    3026        if (jj_3R_36()) {
    3027        jj_scanpos = xsp;
    3028        if (jj_3R_37()) {
    3029        jj_scanpos = xsp;
    3030        if (jj_3R_38()) return true;
    3031        }
    3032        }
    3033        }
    3034        }
    3035        }
    3036        }
    3037        }
    3038        }
    3039        if (jj_3R_39()) return true;
    3040        return false;
    3041      }
    3042
    3043      private boolean jj_3R_147() {
    3044        if (jj_3R_21()) return true;
    3045        return false;
    3046      }
    3047
    3048      private boolean jj_3R_19() {
    3049        if (jj_scan_token(LCURLY)) return true;
    3050        Token xsp;
    3051        while (true) {
    3052          xsp = jj_scanpos;
    3053          if (jj_3R_26()) { jj_scanpos = xsp; break; }
    3054        }
    3055        if (jj_scan_token(RCURLY)) return true;
    3056        return false;
    3057      }
    3058
    3059      private boolean jj_3_13() {
    3060        if (jj_3R_21()) return true;
    3061        if (jj_scan_token(LBRACKET)) return true;
    3062        return false;
    3063      }
    3064
    3065      private boolean jj_3R_61() {
    3066        if (jj_3R_74()) return true;
    3067        return false;
    3068      }
    3069
    3070      private boolean jj_3R_60() {
    3071        if (jj_3R_73()) return true;
    3072        return false;
    3073      }
    3074
    3075      private boolean jj_3R_59() {
    3076        if (jj_3R_72()) return true;
    3077        return false;
    3078      }
    3079
    3080      private boolean jj_3R_58() {
    3081        if (jj_3R_71()) return true;
    3082        return false;
    3083      }
    3084
    3085      private boolean jj_3R_63() {
    3086        if (jj_scan_token(LBRACKET)) return true;
    3087        if (jj_3R_20()) return true;
    3088        if (jj_scan_token(RBRACKET)) return true;
    3089        return false;
    3090      }
    3091
    3092      private boolean jj_3_12() {
    3093        if (jj_3R_25()) return true;
    3094        return false;
    3095      }
    3096
    3097      private boolean jj_3R_24() {
    3098        if (jj_3R_20()) return true;
    3099        return false;
    3100      }
    3101
    3102      private boolean jj_3R_57() {
    3103        if (jj_3R_70()) return true;
    3104        return false;
    3105      }
    3106
    3107      private boolean jj_3R_144() {
    3108        Token xsp;
    3109        xsp = jj_scanpos;
    3110        if (jj_3_12()) {
    3111        jj_scanpos = xsp;
    3112        if (jj_3R_147()) {
    3113        jj_scanpos = xsp;
    3114        if (jj_3R_148()) {
    3115        jj_scanpos = xsp;
    3116        if (jj_3R_149()) return true;
    3117        }
    3118        }
    3119        }
    3120        return false;
    3121      }
    3122
    3123      private boolean jj_3R_56() {
    3124        if (jj_3R_69()) return true;
    3125        return false;
    3126      }
    3127
    3128      private boolean jj_3_1() {
    3129        if (jj_3R_19()) return true;
    3130        return false;
    3131      }
    3132
    3133      private boolean jj_3R_23() {
    3134        if (jj_3R_20()) return true;
    3135        return false;
    3136      }
    3137
    3138      private boolean jj_3R_145() {
    3139        if (jj_scan_token(COMMA)) return true;
    3140        if (jj_3R_20()) return true;
    3141        return false;
    3142      }
    3143
    3144      private boolean jj_3R_143() {
    3145        if (jj_3R_46()) return true;
    3146        return false;
    3147      }
    3148
    3149      private boolean jj_3R_43() {
    3150        Token xsp;
    3151        xsp = jj_scanpos;
    3152        if (jj_scan_token(29)) {
    3153        jj_scanpos = xsp;
    3154        if (jj_3_1()) {
    3155        jj_scanpos = xsp;
    3156        if (jj_3R_56()) {
    3157        jj_scanpos = xsp;
    3158        if (jj_3R_57()) {
    3159        jj_scanpos = xsp;
    3160        if (jj_3R_58()) {
    3161        jj_scanpos = xsp;
    3162        if (jj_3R_59()) {
    3163        jj_scanpos = xsp;
    3164        if (jj_3R_60()) {
    3165        jj_scanpos = xsp;
    3166        if (jj_3R_61()) return true;
    3167        }
    3168        }
    3169        }
    3170        }
    3171        }
    3172        }
    3173        }
    3174        return false;
    3175      }
    3176
    3177      private boolean jj_3R_53() {
    3178        if (jj_scan_token(DOT)) return true;
    3179        Token xsp;
    3180        xsp = jj_scanpos;
    3181        if (jj_3R_143()) {
    3182        jj_scanpos = xsp;
    3183        if (jj_3R_144()) return true;
    3184        }
    3185        return false;
    3186      }
    3187
    3188      private boolean jj_3R_39() {
    3189        Token xsp;
    3190        while (true) {
    3191          xsp = jj_scanpos;
    3192          if (jj_3R_53()) { jj_scanpos = xsp; break; }
    3193        }
    3194        return false;
    3195      }
    3196
    3197      private boolean jj_3_11() {
    3198        if (jj_scan_token(LBRACKET)) return true;
    3199        Token xsp;
    3200        xsp = jj_scanpos;
    3201        if (jj_3R_24()) {
    3202        jj_scanpos = xsp;
    3203        if (jj_scan_token(28)) return true;
    3204        }
    3205        return false;
    3206      }
    3207
    3208      private boolean jj_3R_135() {
    3209        if (jj_scan_token(COMMA)) return true;
    3210        if (jj_3R_20()) return true;
    3211        return false;
    3212      }
    3213
    3214      private boolean jj_3R_46() {
    3215        if (jj_3R_21()) return true;
    3216        Token xsp;
    3217        if (jj_3R_63()) return true;
    3218        while (true) {
    3219          xsp = jj_scanpos;
    3220          if (jj_3R_63()) { jj_scanpos = xsp; break; }
    3221        }
    3222        return false;
    3223      }
    3224
    3225      private boolean jj_3_10() {
    3226        if (jj_scan_token(LCURLY)) return true;
    3227        Token xsp;
    3228        xsp = jj_scanpos;
    3229        if (jj_3R_23()) jj_scanpos = xsp;
    3230        if (jj_scan_token(COLON)) return true;
    3231        return false;
    3232      }
    3233
    3234      private boolean jj_3_9() {
    3235        if (jj_scan_token(NEW)) return true;
    3236        if (jj_scan_token(LPAREN)) return true;
    3237        return false;
    3238      }
    3239
    3240      private boolean jj_3_8() {
    3241        if (jj_scan_token(SIZE)) return true;
    3242        return false;
    3243      }
    3244
    3245      private boolean jj_3_7() {
    3246        if (jj_scan_token(EMPTY)) return true;
    3247        return false;
    3248      }
    3249
    3250      private boolean jj_3R_140() {
    3251        if (jj_3R_20()) return true;
    3252        Token xsp;
    3253        while (true) {
    3254          xsp = jj_scanpos;
    3255          if (jj_3R_145()) { jj_scanpos = xsp; break; }
    3256        }
    3257        return false;
    3258      }
    3259
    3260      private boolean jj_3R_146() {
    3261        if (jj_scan_token(COMMA)) return true;
    3262        if (jj_3R_20()) return true;
    3263        return false;
    3264      }
    3265
    3266      private boolean jj_3R_120() {
    3267        if (jj_3R_123()) return true;
    3268        return false;
    3269      }
    3270
    3271      private boolean jj_3R_119() {
    3272        if (jj_3R_50()) return true;
    3273        return false;
    3274      }
    3275
    3276      private boolean jj_3R_118() {
    3277        if (jj_3R_49()) return true;
    3278        return false;
    3279      }
    3280
    3281      private boolean jj_3R_117() {
    3282        if (jj_3R_45()) return true;
    3283        return false;
    3284      }
    3285
    3286      private boolean jj_3R_130() {
    3287        if (jj_3R_20()) return true;
    3288        Token xsp;
    3289        while (true) {
    3290          xsp = jj_scanpos;
    3291          if (jj_3R_135()) { jj_scanpos = xsp; break; }
    3292        }
    3293        return false;
    3294      }
    3295
    3296      private boolean jj_3R_116() {
    3297        if (jj_3R_122()) return true;
    3298        return false;
    3299      }
    3300
    3301      private boolean jj_3R_115() {
    3302        if (jj_3R_121()) return true;
    3303        return false;
    3304      }
    3305
    3306      private boolean jj_3_6() {
    3307        if (jj_3R_22()) return true;
    3308        return false;
    3309      }
    3310
    3311      private boolean jj_3R_114() {
    3312        Token xsp;
    3313        xsp = jj_scanpos;
    3314        if (jj_3_6()) {
    3315        jj_scanpos = xsp;
    3316        if (jj_3R_115()) {
    3317        jj_scanpos = xsp;
    3318        if (jj_3R_116()) {
    3319        jj_scanpos = xsp;
    3320        if (jj_3R_117()) {
    3321        jj_scanpos = xsp;
    3322        if (jj_3R_118()) {
    3323        jj_scanpos = xsp;
    3324        if (jj_3R_119()) {
    3325        jj_scanpos = xsp;
    3326        if (jj_3R_120()) return true;
    3327        }
    3328        }
    3329        }
    3330        }
    3331        }
    3332        }
    3333        return false;
    3334      }
    3335
    3336      private boolean jj_3R_141() {
    3337        if (jj_3R_20()) return true;
    3338        Token xsp;
    3339        while (true) {
    3340          xsp = jj_scanpos;
    3341          if (jj_3R_146()) { jj_scanpos = xsp; break; }
    3342        }
    3343        return false;
    3344      }
    3345
    3346      private boolean jj_3_5() {
    3347        if (jj_3R_21()) return true;
    3348        if (jj_scan_token(LPAREN)) return true;
    3349        return false;
    3350      }
    3351
    3352      private boolean jj_3R_45() {
    3353        if (jj_scan_token(NEW)) return true;
    3354        if (jj_scan_token(LPAREN)) return true;
    3355        Token xsp;
    3356        xsp = jj_scanpos;
    3357        if (jj_3R_130()) jj_scanpos = xsp;
    3358        if (jj_scan_token(RPAREN)) return true;
    3359        return false;
    3360      }
    3361
    3362      private boolean jj_3_4() {
    3363        if (jj_scan_token(SIZE)) return true;
    3364        return false;
    3365      }
    3366
    3367      private boolean jj_3R_54() {
    3368        if (jj_scan_token(SIZE)) return true;
    3369        if (jj_scan_token(LPAREN)) return true;
    3370        if (jj_scan_token(RPAREN)) return true;
    3371        return false;
    3372      }
    3373
    3374      private boolean jj_3R_41() {
    3375        if (jj_3R_48()) return true;
    3376        return false;
    3377      }
    3378
    3379      private boolean jj_3R_40() {
    3380        if (jj_3R_54()) return true;
    3381        return false;
    3382      }
    3383
    3384      private boolean jj_3R_25() {
    3385        Token xsp;
    3386        xsp = jj_scanpos;
    3387        if (jj_3R_40()) {
    3388        jj_scanpos = xsp;
    3389        if (jj_3R_41()) return true;
    3390        }
    3391        return false;
    3392      }
    3393
    3394      private boolean jj_3R_48() {
    3395        if (jj_3R_21()) return true;
    3396        if (jj_scan_token(LPAREN)) return true;
    3397        Token xsp;
    3398        xsp = jj_scanpos;
    3399        if (jj_3R_141()) jj_scanpos = xsp;
    3400        if (jj_scan_token(RPAREN)) return true;
    3401        return false;
    3402      }
    3403
    3404      private boolean jj_3R_47() {
    3405        if (jj_3R_21()) return true;
    3406        if (jj_scan_token(COLON)) return true;
    3407        if (jj_3R_21()) return true;
    3408        if (jj_scan_token(LPAREN)) return true;
    3409        Token xsp;
    3410        xsp = jj_scanpos;
    3411        if (jj_3R_140()) jj_scanpos = xsp;
    3412        if (jj_scan_token(RPAREN)) return true;
    3413        return false;
    3414      }
    3415
    3416      private boolean jj_3R_122() {
    3417        if (jj_scan_token(SIZE)) return true;
    3418        if (jj_scan_token(LPAREN)) return true;
    3419        if (jj_3R_20()) return true;
    3420        if (jj_scan_token(RPAREN)) return true;
    3421        return false;
    3422      }
    3423
    3424      private boolean jj_3R_124() {
    3425        if (jj_scan_token(EMPTY)) return true;
    3426        if (jj_3R_22()) return true;
    3427        return false;
    3428      }
    3429
    3430      private boolean jj_3_3() {
    3431        if (jj_scan_token(EMPTY)) return true;
    3432        if (jj_scan_token(LPAREN)) return true;
    3433        if (jj_3R_20()) return true;
    3434        if (jj_scan_token(RPAREN)) return true;
    3435        return false;
    3436      }
    3437
    3438      private boolean jj_3R_121() {
    3439        Token xsp;
    3440        xsp = jj_scanpos;
    3441        if (jj_3_3()) {
    3442        jj_scanpos = xsp;
    3443        if (jj_3R_124()) return true;
    3444        }
    3445        return false;
    3446      }
    3447
    3448      private boolean jj_3R_137() {
    3449        if (jj_scan_token(COMMA)) return true;
    3450        if (jj_3R_20()) return true;
    3451        return false;
    3452      }
    3453
    3454      private boolean jj_3R_136() {
    3455        if (jj_scan_token(COMMA)) return true;
    3456        if (jj_3R_76()) return true;
    3457        return false;
    3458      }
    3459
    3460      private boolean jj_3R_76() {
    3461        if (jj_3R_20()) return true;
    3462        if (jj_scan_token(COLON)) return true;
    3463        if (jj_3R_20()) return true;
    3464        return false;
    3465      }
    3466
    3467      private boolean jj_3R_64() {
    3468        if (jj_3R_76()) return true;
    3469        Token xsp;
    3470        while (true) {
    3471          xsp = jj_scanpos;
    3472          if (jj_3R_136()) { jj_scanpos = xsp; break; }
    3473        }
    3474        return false;
    3475      }
    3476
    3477      private boolean jj_3R_65() {
    3478        if (jj_3R_20()) return true;
    3479        Token xsp;
    3480        while (true) {
    3481          xsp = jj_scanpos;
    3482          if (jj_3R_137()) { jj_scanpos = xsp; break; }
    3483        }
    3484        return false;
    3485      }
    3486
    3487      private boolean jj_3R_49() {
    3488        if (jj_scan_token(LCURLY)) return true;
    3489        Token xsp;
    3490        xsp = jj_scanpos;
    3491        if (jj_3R_64()) {
    3492        jj_scanpos = xsp;
    3493        if (jj_scan_token(30)) return true;
    3494        }
    3495        if (jj_scan_token(RCURLY)) return true;
    3496        return false;
    3497      }
    3498
    3499      private boolean jj_3R_50() {
    3500        if (jj_scan_token(LBRACKET)) return true;
    3501        Token xsp;
    3502        xsp = jj_scanpos;
    3503        if (jj_3R_65()) jj_scanpos = xsp;
    3504        if (jj_scan_token(RBRACKET)) return true;
    3505        return false;
    3506      }
    3507
    3508      private boolean jj_3R_52() {
    3509        if (jj_scan_token(STRING_LITERAL)) return true;
    3510        return false;
    3511      }
    3512
    3513      private boolean jj_3R_132() {
    3514        if (jj_scan_token(FLOAT_LITERAL)) return true;
    3515        return false;
    3516      }
    3517
    3518      private boolean jj_3R_131() {
    3519        if (jj_scan_token(INTEGER_LITERAL)) return true;
    3520        return false;
    3521      }
    3522
    3523      private boolean jj_3R_139() {
    3524        if (jj_scan_token(FALSE)) return true;
    3525        return false;
    3526      }
    3527
    3528      private boolean jj_3R_133() {
    3529        Token xsp;
    3530        xsp = jj_scanpos;
    3531        if (jj_3R_138()) {
    3532        jj_scanpos = xsp;
    3533        if (jj_3R_139()) return true;
    3534        }
    3535        return false;
    3536      }
    3537
    3538      private boolean jj_3R_138() {
    3539        if (jj_scan_token(TRUE)) return true;
    3540        return false;
    3541      }
    3542
    3543      private boolean jj_3R_134() {
    3544        if (jj_scan_token(NULL)) return true;
    3545        return false;
    3546      }
    3547
    3548      private boolean jj_3R_129() {
    3549        if (jj_3R_134()) return true;
    3550        return false;
    3551      }
    3552
    3553      private boolean jj_3R_128() {
    3554        if (jj_3R_52()) return true;
    3555        return false;
    3556      }
    3557
    3558      private boolean jj_3R_127() {
    3559        if (jj_3R_133()) return true;
    3560        return false;
    3561      }
    3562
    3563      private boolean jj_3R_126() {
    3564        if (jj_3R_132()) return true;
    3565        return false;
    3566      }
    3567
    3568      private boolean jj_3R_123() {
    3569        Token xsp;
    3570        xsp = jj_scanpos;
    3571        if (jj_3R_125()) {
    3572        jj_scanpos = xsp;
    3573        if (jj_3R_126()) {
    3574        jj_scanpos = xsp;
    3575        if (jj_3R_127()) {
    3576        jj_scanpos = xsp;
    3577        if (jj_3R_128()) {
    3578        jj_scanpos = xsp;
    3579        if (jj_3R_129()) return true;
    3580        }
    3581        }
    3582        }
    3583        }
    3584        return false;
    3585      }
    3586
    3587      private boolean jj_3R_125() {
    3588        if (jj_3R_131()) return true;
    3589        return false;
    3590      }
    3591
    3592      private boolean jj_3R_150() {
    3593        if (jj_scan_token(STRING_LITERAL)) return true;
    3594        return false;
    3595      }
    3596
    3597      private boolean jj_3R_29() {
    3598        if (jj_scan_token(REGISTER)) return true;
    3599        return false;
    3600      }
    3601
    3602      private boolean jj_3R_21() {
    3603        Token xsp;
    3604        xsp = jj_scanpos;
    3605        if (jj_3R_28()) {
    3606        jj_scanpos = xsp;
    3607        if (jj_3R_29()) return true;
    3608        }
    3609        return false;
    3610      }
    3611
    3612      private boolean jj_3R_28() {
    3613        if (jj_scan_token(IDENTIFIER)) return true;
    3614        return false;
    3615      }
    3616
    3617      private boolean jj_3R_95() {
    3618        if (jj_3R_104()) return true;
    3619        if (jj_3R_94()) return true;
    3620        return false;
    3621      }
    3622
    3623      private boolean jj_3R_108() {
    3624        if (jj_3R_114()) return true;
    3625        return false;
    3626      }
    3627
    3628      private boolean jj_3R_107() {
    3629        if (jj_scan_token(not)) return true;
    3630        if (jj_3R_102()) return true;
    3631        return false;
    3632      }
    3633
    3634      private boolean jj_3R_106() {
    3635        if (jj_scan_token(tilda)) return true;
    3636        if (jj_3R_102()) return true;
    3637        return false;
    3638      }
    3639
    3640      private boolean jj_3R_102() {
    3641        Token xsp;
    3642        xsp = jj_scanpos;
    3643        if (jj_3R_105()) {
    3644        jj_scanpos = xsp;
    3645        if (jj_3R_106()) {
    3646        jj_scanpos = xsp;
    3647        if (jj_3R_107()) {
    3648        jj_scanpos = xsp;
    3649        if (jj_3R_108()) return true;
    3650        }
    3651        }
    3652        }
    3653        return false;
    3654      }
    3655
    3656      private boolean jj_3R_105() {
    3657        if (jj_scan_token(minus)) return true;
    3658        if (jj_3R_102()) return true;
    3659        return false;
    3660      }
    3661
    3662      private boolean jj_3R_111() {
    3663        if (jj_scan_token(mod)) return true;
    3664        if (jj_3R_102()) return true;
    3665        return false;
    3666      }
    3667
    3668      private boolean jj_3R_110() {
    3669        if (jj_scan_token(div)) return true;
    3670        if (jj_3R_102()) return true;
    3671        return false;
    3672      }
    3673
    3674      private boolean jj_3R_103() {
    3675        Token xsp;
    3676        xsp = jj_scanpos;
    3677        if (jj_3R_109()) {
    3678        jj_scanpos = xsp;
    3679        if (jj_3R_110()) {
    3680        jj_scanpos = xsp;
    3681        if (jj_3R_111()) return true;
    3682        }
    3683        }
    3684        return false;
    3685      }
    3686
    3687      private boolean jj_3R_109() {
    3688        if (jj_scan_token(mult)) return true;
    3689        if (jj_3R_102()) return true;
    3690        return false;
    3691      }
    3692
    3693      /** Generated Token Manager. */
    3694      public ParserTokenManager token_source;
    3695      SimpleCharStream jj_input_stream;
    3696      /** Current token. */
    3697      public Token token;
    3698      /** Next token. */
    3699      public Token jj_nt;
    3700      private int jj_ntk;
    3701      private Token jj_scanpos, jj_lastpos;
    3702      private int jj_la;
    3703      private int jj_gen;
    3704      final private int[] jj_la1 = new int[47];
    3705      static private int[] jj_la1_0;
    3706      static private int[] jj_la1_1;
    3707      static {
    3708          jj_la1_init_0();
    3709          jj_la1_init_1();
    3710       }
    3711       private static void jj_la1_init_0() {
    3712          jj_la1_0 = new int[] {0x2abffa00,0x20000000,0xabffa00,0x2abffa00,0xa9f4000,0x400,0x1800,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa9f4000,0x0,0x1c0000,0x180000,0x80000000,0xa9f4000,0x80000000,0x4a9f4000,0x10000,0x80000000,0xa9f4000,0x80000000,0xa9f4000,0x80000000,0xa9f4000,0x1c0000,0x8000000,0x0,0x0,0x20000,0x0,0x8000000,};
    3713       }
    3714       private static void jj_la1_init_1() {
    3715          jj_la1_1 = new int[] {0x79150000,0x0,0x79150000,0x79150000,0x79150000,0x0,0x0,0x2000,0x2000,0x9000000,0x6,0x6,0x10,0x8,0x400000,0x800000,0x200000,0x60,0x60,0x1f80,0x1f80,0x60000,0x60000,0x8c000,0x8c000,0x79150000,0x9000000,0x70000000,0x0,0x0,0x79150000,0x0,0x79150000,0x0,0x0,0x79150000,0x0,0x79150000,0x0,0x79150000,0x70000000,0x0,0x1,0x59000000,0x59000000,0x49000000,0x0,};
    3716       }
    3717      final private JJCalls[] jj_2_rtns = new JJCalls[20];
    3718      private boolean jj_rescan = false;
    3719      private int jj_gc = 0;
    3720
    3721      /** Constructor with InputStream. */
    3722      public Parser(java.io.InputStream stream) {
    3723         this(stream, null);
    3724      }
    3725      /** Constructor with InputStream and supplied encoding */
    3726      public Parser(java.io.InputStream stream, String encoding) {
    3727        try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    3728        token_source = new ParserTokenManager(jj_input_stream);
    3729        token = new Token();
    3730        jj_ntk = -1;
    3731        jj_gen = 0;
    3732        for (int i = 0; i < 47; i++) jj_la1[i] = -1;
    3733        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3734      }
    3735
    3736      /** Reinitialise. */
    3737      public void ReInit(java.io.InputStream stream) {
    3738         ReInit(stream, null);
    3739      }
    3740      /** Reinitialise. */
    3741      public void ReInit(java.io.InputStream stream, String encoding) {
    3742        try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    3743        token_source.ReInit(jj_input_stream);
    3744        token = new Token();
    3745        jj_ntk = -1;
    3746        jjtree.reset();
    3747        jj_gen = 0;
    3748        for (int i = 0; i < 47; i++) jj_la1[i] = -1;
    3749        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3750      }
    3751
    3752      /** Constructor. */
    3753      public Parser(java.io.Reader stream) {
    3754        jj_input_stream = new SimpleCharStream(stream, 1, 1);
    3755        token_source = new ParserTokenManager(jj_input_stream);
    3756        token = new Token();
    3757        jj_ntk = -1;
    3758        jj_gen = 0;
    3759        for (int i = 0; i < 47; i++) jj_la1[i] = -1;
    3760        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3761      }
    3762
    3763      /** Reinitialise. */
    3764      public void ReInit(java.io.Reader stream) {
    3765        jj_input_stream.ReInit(stream, 1, 1);
    3766        token_source.ReInit(jj_input_stream);
    3767        token = new Token();
    3768        jj_ntk = -1;
    3769        jjtree.reset();
    3770        jj_gen = 0;
    3771        for (int i = 0; i < 47; i++) jj_la1[i] = -1;
    3772        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3773      }
    3774
    3775      /** Constructor with generated Token Manager. */
    3776      public Parser(ParserTokenManager tm) {
    3777        token_source = tm;
    3778        token = new Token();
    3779        jj_ntk = -1;
    3780        jj_gen = 0;
    3781        for (int i = 0; i < 47; i++) jj_la1[i] = -1;
    3782        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3783      }
    3784
    3785      /** Reinitialise. */
    3786      public void ReInit(ParserTokenManager tm) {
    3787        token_source = tm;
    3788        token = new Token();
    3789        jj_ntk = -1;
    3790        jjtree.reset();
    3791        jj_gen = 0;
    3792        for (int i = 0; i < 47; i++) jj_la1[i] = -1;
    3793        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3794      }
    3795
    3796      private Token jj_consume_token(int kind) throws ParseException {
    3797        Token oldToken;
    3798        if ((oldToken = token).next != null) token = token.next;
    3799        else token = token.next = token_source.getNextToken();
    3800        jj_ntk = -1;
    3801        if (token.kind == kind) {
    3802          jj_gen++;
    3803          if (++jj_gc > 100) {
    3804            jj_gc = 0;
    3805            for (int i = 0; i < jj_2_rtns.length; i++) {
    3806              JJCalls c = jj_2_rtns[i];
    3807              while (c != null) {
    3808                if (c.gen < jj_gen) c.first = null;
    3809                c = c.next;
    3810              }
    3811            }
    3812          }
    3813          return token;
    3814        }
    3815        token = oldToken;
    3816        jj_kind = kind;
    3817        throw generateParseException();
    3818      }
    3819
    3820      static private final class LookaheadSuccess extends java.lang.Error { }
    3821      final private LookaheadSuccess jj_ls = new LookaheadSuccess();
    3822      private boolean jj_scan_token(int kind) {
    3823        if (jj_scanpos == jj_lastpos) {
    3824          jj_la--;
    3825          if (jj_scanpos.next == null) {
    3826            jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
    3827          } else {
    3828            jj_lastpos = jj_scanpos = jj_scanpos.next;
    3829          }
    3830        } else {
    3831          jj_scanpos = jj_scanpos.next;
    3832        }
    3833        if (jj_rescan) {
    3834          int i = 0; Token tok = token;
    3835          while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
    3836          if (tok != null) jj_add_error_token(kind, i);
    3837        }
    3838        if (jj_scanpos.kind != kind) return true;
    3839        if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    3840        return false;
    3841      }
    3842
    3843
    3844    /** Get the next Token. */
    3845      final public Token getNextToken() {
    3846        if (token.next != null) token = token.next;
    3847        else token = token.next = token_source.getNextToken();
    3848        jj_ntk = -1;
    3849        jj_gen++;
    3850        return token;
    3851      }
    3852
    3853    /** Get the specific Token. */
    3854      final public Token getToken(int index) {
    3855        Token t = token;
    3856        for (int i = 0; i < index; i++) {
    3857          if (t.next != null) t = t.next;
    3858          else t = t.next = token_source.getNextToken();
    3859        }
    3860        return t;
    3861      }
    3862
    3863      private int jj_ntk() {
    3864        if ((jj_nt=token.next) == null)
    3865          return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    3866        else
    3867          return (jj_ntk = jj_nt.kind);
    3868      }
    3869
    3870      private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
    3871      private int[] jj_expentry;
    3872      private int jj_kind = -1;
    3873      private int[] jj_lasttokens = new int[100];
    3874      private int jj_endpos;
    3875
    3876      private void jj_add_error_token(int kind, int pos) {
    3877        if (pos >= 100) return;
    3878        if (pos == jj_endpos + 1) {
    3879          jj_lasttokens[jj_endpos++] = kind;
    3880        } else if (jj_endpos != 0) {
    3881          jj_expentry = new int[jj_endpos];
    3882          for (int i = 0; i < jj_endpos; i++) {
    3883            jj_expentry[i] = jj_lasttokens[i];
    3884          }
    3885          jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
    3886            int[] oldentry = (int[])(it.next());
    3887            if (oldentry.length == jj_expentry.length) {
    3888              for (int i = 0; i < jj_expentry.length; i++) {
    3889                if (oldentry[i] != jj_expentry[i]) {
    3890                  continue jj_entries_loop;
    3891                }
    3892              }
    3893              jj_expentries.add(jj_expentry);
    3894              break jj_entries_loop;
    3895            }
    3896          }
    3897          if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    3898        }
    3899      }
    3900
    3901      /** Generate ParseException. */
    3902      public ParseException generateParseException() {
    3903        jj_expentries.clear();
    3904        boolean[] la1tokens = new boolean[63];
    3905        if (jj_kind >= 0) {
    3906          la1tokens[jj_kind] = true;
    3907          jj_kind = -1;
    3908        }
    3909        for (int i = 0; i < 47; i++) {
    3910          if (jj_la1[i] == jj_gen) {
    3911            for (int j = 0; j < 32; j++) {
    3912              if ((jj_la1_0[i] & (1<<j)) != 0) {
    3913                la1tokens[j] = true;
    3914              }
    3915              if ((jj_la1_1[i] & (1<<j)) != 0) {
    3916                la1tokens[32+j] = true;
    3917              }
    3918            }
    3919          }
    3920        }
    3921        for (int i = 0; i < 63; i++) {
    3922          if (la1tokens[i]) {
    3923            jj_expentry = new int[1];
    3924            jj_expentry[0] = i;
    3925            jj_expentries.add(jj_expentry);
    3926          }
    3927        }
    3928        jj_endpos = 0;
    3929        jj_rescan_token();
    3930        jj_add_error_token(0, 0);
    3931        int[][] exptokseq = new int[jj_expentries.size()][];
    3932        for (int i = 0; i < jj_expentries.size(); i++) {
    3933          exptokseq[i] = jj_expentries.get(i);
    3934        }
    3935        return new ParseException(token, exptokseq, tokenImage);
    3936      }
    3937
    3938      /** Enable tracing. */
    3939      final public void enable_tracing() {
    3940      }
    3941
    3942      /** Disable tracing. */
    3943      final public void disable_tracing() {
    3944      }
    3945
    3946      private void jj_rescan_token() {
    3947        jj_rescan = true;
    3948        for (int i = 0; i < 20; i++) {
    3949        try {
    3950          JJCalls p = jj_2_rtns[i];
    3951          do {
    3952            if (p.gen > jj_gen) {
    3953              jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
    3954              switch (i) {
    3955                case 0: jj_3_1(); break;
    3956                case 1: jj_3_2(); break;
    3957                case 2: jj_3_3(); break;
    3958                case 3: jj_3_4(); break;
    3959                case 4: jj_3_5(); break;
    3960                case 5: jj_3_6(); break;
    3961                case 6: jj_3_7(); break;
    3962                case 7: jj_3_8(); break;
    3963                case 8: jj_3_9(); break;
    3964                case 9: jj_3_10(); break;
    3965                case 10: jj_3_11(); break;
    3966                case 11: jj_3_12(); break;
    3967                case 12: jj_3_13(); break;
    3968                case 13: jj_3_14(); break;
    3969                case 14: jj_3_15(); break;
    3970                case 15: jj_3_16(); break;
    3971                case 16: jj_3_17(); break;
    3972                case 17: jj_3_18(); break;
    3973                case 18: jj_3_19(); break;
    3974                case 19: jj_3_20(); break;
    3975              }
    3976            }
    3977            p = p.next;
    3978          } while (p != null);
    3979          } catch(LookaheadSuccess ls) { }
    3980        }
    3981        jj_rescan = false;
    3982      }
    3983
    3984      private void jj_save(int index, int xla) {
    3985        JJCalls p = jj_2_rtns[index];
    3986        while (p.gen > jj_gen) {
    3987          if (p.next == null) { p = p.next = new JJCalls(); break; }
    3988          p = p.next;
    3989        }
    3990        p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
    3991      }
    3992
    3993      static final class JJCalls {
    3994        int gen;
    3995        Token first;
    3996        int arg;
    3997        JJCalls next;
    3998      }
    3999
    4000    }