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