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