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