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