View Javadoc
1   /* Parser.java */
2   /* Generated by:  JJTree&ParserGeneratorCC: Do not edit this line. Parser.java */
3   package org.apache.commons.jexl3.parser;
4   
5   import java.util.Collections;
6   import java.util.LinkedList;
7   
8   import org.apache.commons.jexl3.JexlInfo;
9   import org.apache.commons.jexl3.JexlFeatures;
10  import org.apache.commons.jexl3.JexlException;
11  import org.apache.commons.jexl3.internal.Scope;
12  
13  public final class Parser extends JexlParser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/
14    protected JJTParserState jjtree = new JJTParserState();public ASTJexlScript parse(JexlInfo jexlInfo, JexlFeatures jexlFeatures, String jexlSrc, Scope jexlScope) {
15          JexlFeatures previous = getFeatures();
16          try {
17              setFeatures(jexlFeatures);
18              // lets do the 'Unique Init' in here to be safe - it's a pain to remember
19              info = jexlInfo != null? jexlInfo : new JexlInfo();
20              source = jexlSrc;
21              pragmas = null;
22              this.scope = jexlScope;
23              token_source.comparatorNames = jexlFeatures.supportsComparatorNames();
24              ReInit(jexlSrc);
25              ASTJexlScript script = jexlFeatures.supportsScript()? JexlScript(jexlScope) : JexlExpression(jexlScope);
26              script.jjtSetValue(info.detach());
27              script.setFeatures(jexlFeatures);
28              script.setPragmas(pragmas != null
29                               ? Collections.unmodifiableMap(pragmas)
30                               : Collections.emptyMap());
31              return script;
32          } catch (TokenMgrException xtme) {
33              throw new JexlException.Tokenization(info, xtme).clean();
34          } catch (ParseException xparse) {
35              Token errortok = errorToken(jj_lastpos, jj_scanpos, token.next, token);
36              throw new JexlException.Parsing(info.at(errortok.beginLine, errortok.beginColumn), errortok.image).clean();
37          } finally {
38              token_source.defaultLexState = DEFAULT;
39              cleanup(previous);
40              jjtree.reset();
41          }
42      }
43  
44  /***************************************
45   *      Statements
46   ***************************************/
47    final public 
48  ASTJexlScript JexlScript(Scope frame) throws ParseException {/*@bgen(jjtree) JexlScript */
49      ASTJexlScript jjtn000 = new ASTJexlScript(JJTJEXLSCRIPT);
50      boolean jjtc000 = true;
51      jjtree.openNodeScope(jjtn000);
52      jjtreeOpenNodeScope(jjtn000);
53      jjtn000.jjtSetFirstToken(getToken(1));jjtn000.setScope(frame);
54      try {
55  pushUnit(jjtn000);
56        label_1:
57        while (true) {
58          if (jj_2_1(1)) {
59          } else {
60            break label_1;
61          }
62          if (jj_2_2(2147483647)) {
63            Pragma();
64          } else if (jj_2_3(1)) {
65  controlPragmaAnywhere();
66            Statement();
67          } else {
68            jj_consume_token(-1);
69            throw new ParseException();
70          }
71        }
72        jj_consume_token(0);
73  jjtree.closeNodeScope(jjtn000, true);
74       jjtc000 = false;
75       if (jjtree.nodeCreated()) {
76        jjtreeCloseNodeScope(jjtn000);
77       }
78       jjtn000.jjtSetLastToken(getToken(0));
79  popUnit(jjtn000);
80          {if ("" != null) return jjtn000.script();}
81      } catch (Throwable jjte000) {
82  if (jjtc000) {
83         jjtree.clearNodeScope(jjtn000);
84         jjtc000 = false;
85       } else {
86         jjtree.popNode();
87       }
88       if (jjte000 instanceof ParseException) {
89         throw (ParseException)jjte000;
90       }
91       if (jjte000 instanceof RuntimeException) {
92         throw (RuntimeException)jjte000;
93       }
94       throw (Error)jjte000;
95      } finally {
96  if (jjtc000) {
97         jjtree.closeNodeScope(jjtn000, true);
98         if (jjtree.nodeCreated()) {
99          jjtreeCloseNodeScope(jjtn000);
100        }
101        jjtn000.jjtSetLastToken(getToken(0));
102      }
103     }
104     throw new IllegalStateException ("Missing return statement in function");
105 }
106 
107   final public ASTJexlScript JexlExpression(Scope frame) throws ParseException {/*@bgen(jjtree) JexlScript */
108     ASTJexlScript jjtn000 = new ASTJexlScript(JJTJEXLSCRIPT);
109     boolean jjtc000 = true;
110     jjtree.openNodeScope(jjtn000);
111     jjtreeOpenNodeScope(jjtn000);
112     jjtn000.jjtSetFirstToken(getToken(1));jjtn000.setScope(frame);
113     try {
114 pushUnit(jjtn000);
115       label_2:
116       while (true) {
117         switch (jj_nt.kind) {
118         case PRAGMA:{
119           break;
120           }
121         default:
122           break label_2;
123         }
124         Pragma();
125       }
126 controlPragmaAnywhere();
127       if (jj_2_4(1)) {
128         Expression();
129       } else {
130         ;
131       }
132       jj_consume_token(0);
133 jjtree.closeNodeScope(jjtn000, true);
134      jjtc000 = false;
135      if (jjtree.nodeCreated()) {
136       jjtreeCloseNodeScope(jjtn000);
137      }
138      jjtn000.jjtSetLastToken(getToken(0));
139 popUnit(jjtn000);
140         {if ("" != null) return jjtn000.script();}
141     } catch (Throwable jjte000) {
142 if (jjtc000) {
143        jjtree.clearNodeScope(jjtn000);
144        jjtc000 = false;
145      } else {
146        jjtree.popNode();
147      }
148      if (jjte000 instanceof ParseException) {
149        throw (ParseException)jjte000;
150      }
151      if (jjte000 instanceof RuntimeException) {
152        throw (RuntimeException)jjte000;
153      }
154      throw (Error)jjte000;
155     } finally {
156 if (jjtc000) {
157        jjtree.closeNodeScope(jjtn000, true);
158        if (jjtree.nodeCreated()) {
159         jjtreeCloseNodeScope(jjtn000);
160        }
161        jjtn000.jjtSetLastToken(getToken(0));
162      }
163     }
164     throw new IllegalStateException ("Missing return statement in function");
165 }
166 
167   final public void Annotation() throws ParseException {/*@bgen(jjtree) Annotation */
168     ASTAnnotation jjtn000 = new ASTAnnotation(JJTANNOTATION);
169     boolean jjtc000 = true;
170     jjtree.openNodeScope(jjtn000);
171     jjtreeOpenNodeScope(jjtn000);
172     jjtn000.jjtSetFirstToken(getToken(1));Token t;
173     try {
174       t = jj_consume_token(ANNOTATION);
175       if (jj_2_5(2147483647)) {
176         Arguments();
177       } else {
178         ;
179       }
180 jjtree.closeNodeScope(jjtn000, true);
181                                                          jjtc000 = false;
182                                                          if (jjtree.nodeCreated()) {
183                                                           jjtreeCloseNodeScope(jjtn000);
184                                                          }
185                                                          jjtn000.jjtSetLastToken(getToken(0));
186 jjtn000.setName(t.image);
187     } catch (Throwable jjte000) {
188 if (jjtc000) {
189         jjtree.clearNodeScope(jjtn000);
190         jjtc000 = false;
191       } else {
192         jjtree.popNode();
193       }
194       if (jjte000 instanceof ParseException) {
195         throw (ParseException)jjte000;
196       }
197       if (jjte000 instanceof RuntimeException) {
198         throw (RuntimeException)jjte000;
199       }
200       throw (Error)jjte000;
201     } finally {
202 if (jjtc000) {
203         jjtree.closeNodeScope(jjtn000, true);
204         if (jjtree.nodeCreated()) {
205          jjtreeCloseNodeScope(jjtn000);
206         }
207         jjtn000.jjtSetLastToken(getToken(0));
208       }
209     }
210 }
211 
212   final public void AnnotatedStatement() throws ParseException {/*@bgen(jjtree) AnnotatedStatement */
213   ASTAnnotatedStatement jjtn000 = new ASTAnnotatedStatement(JJTANNOTATEDSTATEMENT);
214   boolean jjtc000 = true;
215   jjtree.openNodeScope(jjtn000);
216   jjtreeOpenNodeScope(jjtn000);
217   jjtn000.jjtSetFirstToken(getToken(1));
218     try {
219       label_3:
220       while (true) {
221         Annotation();
222         if (jj_2_6(2147483647)) {
223         } else {
224           break label_3;
225         }
226       }
227       switch (jj_nt.kind) {
228       case LCURLY:{
229         Block();
230         break;
231         }
232       default:
233         if (jj_2_7(1)) {
234           Statement();
235         } else {
236           jj_consume_token(-1);
237           throw new ParseException();
238         }
239       }
240     } catch (Throwable jjte000) {
241 if (jjtc000) {
242         jjtree.clearNodeScope(jjtn000);
243         jjtc000 = false;
244       } else {
245         jjtree.popNode();
246       }
247       if (jjte000 instanceof ParseException) {
248         throw (ParseException)jjte000;
249       }
250       if (jjte000 instanceof RuntimeException) {
251         throw (RuntimeException)jjte000;
252       }
253       throw (Error)jjte000;
254     } finally {
255 if (jjtc000) {
256         jjtree.closeNodeScope(jjtn000, true);
257         if (jjtree.nodeCreated()) {
258          jjtreeCloseNodeScope(jjtn000);
259         }
260         jjtn000.jjtSetLastToken(getToken(0));
261       }
262     }
263 }
264 
265   final public void Statement() throws ParseException {
266     if (jj_2_8(2147483647)) {
267       Var();
268     } else if (jj_2_9(2147483647)) {
269       FunctionStatement();
270     } else if (jj_2_10(1)) {
271       StatementNoVar();
272     } else {
273       jj_consume_token(-1);
274       throw new ParseException();
275     }
276 }
277 
278   final public void StatementNoVar() throws ParseException {
279     switch (jj_nt.kind) {
280     case SEMICOL:{
281       jj_consume_token(SEMICOL);
282       break;
283       }
284     default:
285       if (jj_2_11(2147483647)) {
286         AnnotatedStatement();
287       } else if (jj_2_12(2147483647)) {
288         IfStatement();
289       } else if (jj_2_13(2147483647)) {
290         ForeachStatement();
291       } else if (jj_2_14(2147483647)) {
292         WhileStatement();
293       } else if (jj_2_15(2147483647)) {
294         DoWhileStatement();
295       } else if (jj_2_16(2147483647)) {
296         ReturnStatement();
297       } else if (jj_2_17(2147483647)) {
298         Continue();
299       } else if (jj_2_18(2147483647)) {
300         Break();
301       } else if (jj_2_19(2147483647)) {
302         ExpressionStatement();
303       } else {
304         switch (jj_nt.kind) {
305         case LCURLY:{
306           Block();
307           break;
308           }
309         default:
310           if (jj_2_20(2147483647) && (!getFeatures().isLexical())) {
311             Var();
312           } else {
313             jj_consume_token(-1);
314             throw new ParseException();
315           }
316         }
317       }
318     }
319 }
320 
321   final public void Block() throws ParseException {/*@bgen(jjtree) Block */
322   ASTBlock jjtn000 = new ASTBlock(JJTBLOCK);
323   boolean jjtc000 = true;
324   jjtree.openNodeScope(jjtn000);
325   jjtreeOpenNodeScope(jjtn000);
326   jjtn000.jjtSetFirstToken(getToken(1));
327     try {
328       jj_consume_token(LCURLY);
329 pushUnit(jjtn000);
330       label_4:
331       while (true) {
332         if (jj_2_21(1)) {
333         } else {
334           break label_4;
335         }
336         if (jj_2_22(2147483647)) {
337           Pragma();
338         } else if (jj_2_23(1)) {
339           Statement();
340         } else {
341           jj_consume_token(-1);
342           throw new ParseException();
343         }
344       }
345 popUnit(jjtn000);
346       jj_consume_token(RCURLY);
347     } catch (Throwable jjte000) {
348 if (jjtc000) {
349         jjtree.clearNodeScope(jjtn000);
350         jjtc000 = false;
351       } else {
352         jjtree.popNode();
353       }
354       if (jjte000 instanceof ParseException) {
355         throw (ParseException)jjte000;
356       }
357       if (jjte000 instanceof RuntimeException) {
358         throw (RuntimeException)jjte000;
359       }
360       throw (Error)jjte000;
361     } finally {
362 if (jjtc000) {
363         jjtree.closeNodeScope(jjtn000, true);
364         if (jjtree.nodeCreated()) {
365          jjtreeCloseNodeScope(jjtn000);
366         }
367         jjtn000.jjtSetLastToken(getToken(0));
368       }
369     }
370 }
371 
372   final public void FunctionStatement() throws ParseException {/*@bgen(jjtree) JexlLambda */
373   ASTJexlLambda jjtn000 = new ASTJexlLambda(JJTJEXLLAMBDA);
374   boolean jjtc000 = true;
375   jjtree.openNodeScope(jjtn000);
376   jjtreeOpenNodeScope(jjtn000);
377   jjtn000.jjtSetFirstToken(getToken(1));
378     try {
379       jj_consume_token(FUNCTION);
380       DeclareFunction();
381 pushScope(); pushUnit(jjtn000);
382       Parameters();
383       if (jj_2_24(3)) {
384         Block();
385       } else if (jj_2_25(1)) {
386         Expression();
387       } else {
388         jj_consume_token(-1);
389         throw new ParseException();
390       }
391 jjtree.closeNodeScope(jjtn000, true);
392                                                                                                                        jjtc000 = false;
393                                                                                                                        if (jjtree.nodeCreated()) {
394                                                                                                                         jjtreeCloseNodeScope(jjtn000);
395                                                                                                                        }
396                                                                                                                        jjtn000.jjtSetLastToken(getToken(0));
397 popUnit(jjtn000); popScope();
398     } catch (Throwable jjte000) {
399 if (jjtc000) {
400     jjtree.clearNodeScope(jjtn000);
401     jjtc000 = false;
402   } else {
403     jjtree.popNode();
404   }
405   if (jjte000 instanceof ParseException) {
406     throw (ParseException)jjte000;
407   }
408   if (jjte000 instanceof RuntimeException) {
409     throw (RuntimeException)jjte000;
410   }
411   throw (Error)jjte000;
412     } finally {
413 if (jjtc000) {
414     jjtree.closeNodeScope(jjtn000, true);
415     if (jjtree.nodeCreated()) {
416      jjtreeCloseNodeScope(jjtn000);
417     }
418     jjtn000.jjtSetLastToken(getToken(0));
419   }
420     }
421 }
422 
423   final public void ExpressionStatement() throws ParseException {
424     Expression();
425     label_5:
426     while (true) {
427       if (jj_2_26(2147483647)) {
428       } else {
429         break label_5;
430       }
431 ASTAmbiguous jjtn001 = new ASTAmbiguous(JJTAMBIGUOUS);
432                                             boolean jjtc001 = true;
433                                             jjtree.openNodeScope(jjtn001);
434                                             jjtreeOpenNodeScope(jjtn001);
435                                             jjtn001.jjtSetFirstToken(getToken(1));
436       try {
437         Expression();
438       } catch (Throwable jjte001) {
439 if (jjtc001) {
440                                               jjtree.clearNodeScope(jjtn001);
441                                               jjtc001 = false;
442                                             } else {
443                                               jjtree.popNode();
444                                             }
445                                             if (jjte001 instanceof ParseException) {
446                                               throw (ParseException)jjte001;
447                                             }
448                                             if (jjte001 instanceof RuntimeException) {
449                                               throw (RuntimeException)jjte001;
450                                             }
451                                             throw (Error)jjte001;
452       } finally {
453 if (jjtc001) {
454                                               jjtree.closeNodeScope(jjtn001,  1);
455                                               if (jjtree.nodeCreated()) {
456                                                jjtreeCloseNodeScope(jjtn001);
457                                               }
458                                               jjtn001.jjtSetLastToken(getToken(0));
459                                             }
460       }
461     }
462     switch (jj_nt.kind) {
463     case SEMICOL:{
464       jj_consume_token(SEMICOL);
465       break;
466       }
467     default:
468       ;
469     }
470 }
471 
472   final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStatement */
473   ASTIfStatement jjtn000 = new ASTIfStatement(JJTIFSTATEMENT);
474   boolean jjtc000 = true;
475   jjtree.openNodeScope(jjtn000);
476   jjtreeOpenNodeScope(jjtn000);
477   jjtn000.jjtSetFirstToken(getToken(1));
478     try {
479       jj_consume_token(IF);
480       jj_consume_token(LPAREN);
481       Expression();
482       jj_consume_token(RPAREN);
483       switch (jj_nt.kind) {
484       case LCURLY:{
485         Block();
486         break;
487         }
488       default:
489         if (jj_2_27(1)) {
490           StatementNoVar();
491         } else {
492           jj_consume_token(-1);
493           throw new ParseException();
494         }
495       }
496       label_6:
497       while (true) {
498         if (jj_2_28(2)) {
499         } else {
500           break label_6;
501         }
502         jj_consume_token(ELSE);
503         jj_consume_token(IF);
504         jj_consume_token(LPAREN);
505         Expression();
506         jj_consume_token(RPAREN);
507         switch (jj_nt.kind) {
508         case LCURLY:{
509           Block();
510           break;
511           }
512         default:
513           if (jj_2_29(1)) {
514             StatementNoVar();
515           } else {
516             jj_consume_token(-1);
517             throw new ParseException();
518           }
519         }
520       }
521       switch (jj_nt.kind) {
522       case ELSE:{
523         jj_consume_token(ELSE);
524         switch (jj_nt.kind) {
525         case LCURLY:{
526           Block();
527           break;
528           }
529         default:
530           if (jj_2_30(1)) {
531             StatementNoVar();
532           } else {
533             jj_consume_token(-1);
534             throw new ParseException();
535           }
536         }
537         break;
538         }
539       default:
540         ;
541       }
542     } catch (Throwable jjte000) {
543 if (jjtc000) {
544         jjtree.clearNodeScope(jjtn000);
545         jjtc000 = false;
546       } else {
547         jjtree.popNode();
548       }
549       if (jjte000 instanceof ParseException) {
550         throw (ParseException)jjte000;
551       }
552       if (jjte000 instanceof RuntimeException) {
553         throw (RuntimeException)jjte000;
554       }
555       throw (Error)jjte000;
556     } finally {
557 if (jjtc000) {
558         jjtree.closeNodeScope(jjtn000, true);
559         if (jjtree.nodeCreated()) {
560          jjtreeCloseNodeScope(jjtn000);
561         }
562         jjtn000.jjtSetLastToken(getToken(0));
563       }
564     }
565 }
566 
567   final public void WhileStatement() throws ParseException {/*@bgen(jjtree) WhileStatement */
568   ASTWhileStatement jjtn000 = new ASTWhileStatement(JJTWHILESTATEMENT);
569   boolean jjtc000 = true;
570   jjtree.openNodeScope(jjtn000);
571   jjtreeOpenNodeScope(jjtn000);
572   jjtn000.jjtSetFirstToken(getToken(1));
573     try {
574       jj_consume_token(WHILE);
575       jj_consume_token(LPAREN);
576       Expression();
577       jj_consume_token(RPAREN);
578 loopCount += 1;
579       switch (jj_nt.kind) {
580       case LCURLY:{
581         Block();
582         break;
583         }
584       default:
585         if (jj_2_31(1)) {
586           StatementNoVar();
587         } else {
588           jj_consume_token(-1);
589           throw new ParseException();
590         }
591       }
592 jjtree.closeNodeScope(jjtn000, true);
593                                                                                                              jjtc000 = false;
594                                                                                                              if (jjtree.nodeCreated()) {
595                                                                                                               jjtreeCloseNodeScope(jjtn000);
596                                                                                                              }
597                                                                                                              jjtn000.jjtSetLastToken(getToken(0));
598 loopCount -= 1;
599     } catch (Throwable jjte000) {
600 if (jjtc000) {
601         jjtree.clearNodeScope(jjtn000);
602         jjtc000 = false;
603       } else {
604         jjtree.popNode();
605       }
606       if (jjte000 instanceof ParseException) {
607         throw (ParseException)jjte000;
608       }
609       if (jjte000 instanceof RuntimeException) {
610         throw (RuntimeException)jjte000;
611       }
612       throw (Error)jjte000;
613     } finally {
614 if (jjtc000) {
615         jjtree.closeNodeScope(jjtn000, true);
616         if (jjtree.nodeCreated()) {
617          jjtreeCloseNodeScope(jjtn000);
618         }
619         jjtn000.jjtSetLastToken(getToken(0));
620       }
621     }
622 }
623 
624   final public void DoWhileStatement() throws ParseException {/*@bgen(jjtree) DoWhileStatement */
625   ASTDoWhileStatement jjtn000 = new ASTDoWhileStatement(JJTDOWHILESTATEMENT);
626   boolean jjtc000 = true;
627   jjtree.openNodeScope(jjtn000);
628   jjtreeOpenNodeScope(jjtn000);
629   jjtn000.jjtSetFirstToken(getToken(1));
630     try {
631       jj_consume_token(DO);
632 loopCount += 1;
633       switch (jj_nt.kind) {
634       case LCURLY:{
635         Block();
636         break;
637         }
638       default:
639         if (jj_2_32(1)) {
640           StatementNoVar();
641         } else {
642           jj_consume_token(-1);
643           throw new ParseException();
644         }
645       }
646       jj_consume_token(WHILE);
647       jj_consume_token(LPAREN);
648       Expression();
649       jj_consume_token(RPAREN);
650 jjtree.closeNodeScope(jjtn000, true);
651                                                                                                                 jjtc000 = false;
652                                                                                                                 if (jjtree.nodeCreated()) {
653                                                                                                                  jjtreeCloseNodeScope(jjtn000);
654                                                                                                                 }
655                                                                                                                 jjtn000.jjtSetLastToken(getToken(0));
656 loopCount -= 1;
657     } catch (Throwable jjte000) {
658 if (jjtc000) {
659         jjtree.clearNodeScope(jjtn000);
660         jjtc000 = false;
661       } else {
662         jjtree.popNode();
663       }
664       if (jjte000 instanceof ParseException) {
665         throw (ParseException)jjte000;
666       }
667       if (jjte000 instanceof RuntimeException) {
668         throw (RuntimeException)jjte000;
669       }
670       throw (Error)jjte000;
671     } finally {
672 if (jjtc000) {
673         jjtree.closeNodeScope(jjtn000, true);
674         if (jjtree.nodeCreated()) {
675          jjtreeCloseNodeScope(jjtn000);
676         }
677         jjtn000.jjtSetLastToken(getToken(0));
678       }
679     }
680 }
681 
682   final public void ReturnStatement() throws ParseException {/*@bgen(jjtree) ReturnStatement */
683   ASTReturnStatement jjtn000 = new ASTReturnStatement(JJTRETURNSTATEMENT);
684   boolean jjtc000 = true;
685   jjtree.openNodeScope(jjtn000);
686   jjtreeOpenNodeScope(jjtn000);
687   jjtn000.jjtSetFirstToken(getToken(1));
688     try {
689       jj_consume_token(RETURN);
690       ExpressionStatement();
691     } catch (Throwable jjte000) {
692 if (jjtc000) {
693         jjtree.clearNodeScope(jjtn000);
694         jjtc000 = false;
695       } else {
696         jjtree.popNode();
697       }
698       if (jjte000 instanceof ParseException) {
699         throw (ParseException)jjte000;
700       }
701       if (jjte000 instanceof RuntimeException) {
702         throw (RuntimeException)jjte000;
703       }
704       throw (Error)jjte000;
705     } finally {
706 if (jjtc000) {
707         jjtree.closeNodeScope(jjtn000, true);
708         if (jjtree.nodeCreated()) {
709          jjtreeCloseNodeScope(jjtn000);
710         }
711         jjtn000.jjtSetLastToken(getToken(0));
712       }
713     }
714 }
715 
716   final public void Continue() throws ParseException {/*@bgen(jjtree) Continue */
717     ASTContinue jjtn000 = new ASTContinue(JJTCONTINUE);
718     boolean jjtc000 = true;
719     jjtree.openNodeScope(jjtn000);
720     jjtreeOpenNodeScope(jjtn000);
721     jjtn000.jjtSetFirstToken(getToken(1));Token t;
722     try {
723       t = jj_consume_token(CONTINUE);
724 jjtree.closeNodeScope(jjtn000, true);
725                    jjtc000 = false;
726                    if (jjtree.nodeCreated()) {
727                     jjtreeCloseNodeScope(jjtn000);
728                    }
729                    jjtn000.jjtSetLastToken(getToken(0));
730 if (loopCount == 0) { throwParsingException(t); }
731     } finally {
732 if (jjtc000) {
733         jjtree.closeNodeScope(jjtn000, true);
734         if (jjtree.nodeCreated()) {
735          jjtreeCloseNodeScope(jjtn000);
736         }
737         jjtn000.jjtSetLastToken(getToken(0));
738       }
739     }
740 }
741 
742   final public void Break() throws ParseException {/*@bgen(jjtree) Break */
743     ASTBreak jjtn000 = new ASTBreak(JJTBREAK);
744     boolean jjtc000 = true;
745     jjtree.openNodeScope(jjtn000);
746     jjtreeOpenNodeScope(jjtn000);
747     jjtn000.jjtSetFirstToken(getToken(1));Token t;
748     try {
749       t = jj_consume_token(BREAK);
750 jjtree.closeNodeScope(jjtn000, true);
751                 jjtc000 = false;
752                 if (jjtree.nodeCreated()) {
753                  jjtreeCloseNodeScope(jjtn000);
754                 }
755                 jjtn000.jjtSetLastToken(getToken(0));
756 if (loopCount == 0) { throwParsingException(t); }
757     } finally {
758 if (jjtc000) {
759         jjtree.closeNodeScope(jjtn000, true);
760         if (jjtree.nodeCreated()) {
761          jjtreeCloseNodeScope(jjtn000);
762         }
763         jjtn000.jjtSetLastToken(getToken(0));
764       }
765     }
766 }
767 
768   final public void ForeachStatement() throws ParseException {/*@bgen(jjtree) ForeachStatement */
769  ASTForeachStatement jjtn000 = new ASTForeachStatement(JJTFOREACHSTATEMENT);
770  boolean jjtc000 = true;
771  jjtree.openNodeScope(jjtn000);
772  jjtreeOpenNodeScope(jjtn000);
773  jjtn000.jjtSetFirstToken(getToken(1));int loopForm = 0;
774     try {
775 pushUnit(jjtn000);
776       jj_consume_token(FOR);
777       jj_consume_token(LPAREN);
778       if (jj_2_37(3)) {
779         ForEachVar();
780         jj_consume_token(COLON);
781         Expression();
782 loopForm = 0;
783       } else if (jj_2_38(1)) {
784         if (jj_2_34(1)) {
785           switch (jj_nt.kind) {
786           case VAR:
787           case LET:
788           case CONST:{
789             Var();
790             break;
791             }
792           default:
793             if (jj_2_33(1)) {
794               Expression();
795             } else {
796               jj_consume_token(-1);
797               throw new ParseException();
798             }
799           }
800 loopForm = 1;
801         } else {
802           ;
803         }
804         jj_consume_token(SEMICOL);
805         if (jj_2_35(1)) {
806           Expression();
807 loopForm |= 2;
808         } else {
809           ;
810         }
811         jj_consume_token(SEMICOL);
812         if (jj_2_36(1)) {
813           Expression();
814 loopForm |= 4;
815         } else {
816           ;
817         }
818 loopForm |= 8;
819       } else {
820         jj_consume_token(-1);
821         throw new ParseException();
822       }
823       jj_consume_token(RPAREN);
824 loopCount += 1;
825       switch (jj_nt.kind) {
826       case LCURLY:{
827         Block();
828         break;
829         }
830       default:
831         if (jj_2_39(1)) {
832           StatementNoVar();
833         } else {
834           jj_consume_token(-1);
835           throw new ParseException();
836         }
837       }
838 jjtree.closeNodeScope(jjtn000, true);
839       jjtc000 = false;
840       if (jjtree.nodeCreated()) {
841        jjtreeCloseNodeScope(jjtn000);
842       }
843       jjtn000.jjtSetLastToken(getToken(0));
844 loopCount -= 1;
845         jjtn000.setLoopForm(loopForm);
846         popUnit(jjtn000);
847     } catch (Throwable jjte000) {
848 if (jjtc000) {
849         jjtree.clearNodeScope(jjtn000);
850         jjtc000 = false;
851       } else {
852         jjtree.popNode();
853       }
854       if (jjte000 instanceof ParseException) {
855         throw (ParseException)jjte000;
856       }
857       if (jjte000 instanceof RuntimeException) {
858         throw (RuntimeException)jjte000;
859       }
860       throw (Error)jjte000;
861     } finally {
862 if (jjtc000) {
863         jjtree.closeNodeScope(jjtn000, true);
864         if (jjtree.nodeCreated()) {
865          jjtreeCloseNodeScope(jjtn000);
866         }
867         jjtn000.jjtSetLastToken(getToken(0));
868       }
869     }
870 }
871 
872   final public void ForEachVar() throws ParseException {/*@bgen(jjtree) Reference */
873   ASTReference jjtn000 = new ASTReference(JJTREFERENCE);
874   boolean jjtc000 = true;
875   jjtree.openNodeScope(jjtn000);
876   jjtreeOpenNodeScope(jjtn000);
877   jjtn000.jjtSetFirstToken(getToken(1));
878     try {
879       switch (jj_nt.kind) {
880       case VAR:{
881         jj_consume_token(VAR);
882         DeclareVar(false, false);
883         break;
884         }
885       case LET:{
886         jj_consume_token(LET);
887         DeclareVar(true, false);
888         break;
889         }
890       case IDENTIFIER:
891       case REGISTER:{
892         Identifier(true);
893         break;
894         }
895       default:
896         jj_consume_token(-1);
897         throw new ParseException();
898       }
899     } catch (Throwable jjte000) {
900 if (jjtc000) {
901         jjtree.clearNodeScope(jjtn000);
902         jjtc000 = false;
903       } else {
904         jjtree.popNode();
905       }
906       if (jjte000 instanceof ParseException) {
907         throw (ParseException)jjte000;
908       }
909       if (jjte000 instanceof RuntimeException) {
910         throw (RuntimeException)jjte000;
911       }
912       throw (Error)jjte000;
913     } finally {
914 if (jjtc000) {
915         jjtree.closeNodeScope(jjtn000, true);
916         if (jjtree.nodeCreated()) {
917          jjtreeCloseNodeScope(jjtn000);
918         }
919         jjtn000.jjtSetLastToken(getToken(0));
920       }
921     }
922 }
923 
924   final public void Var() throws ParseException {
925     switch (jj_nt.kind) {
926     case VAR:{
927 ASTDefineVars jjtn001 = new ASTDefineVars(JJTDEFINEVARS);
928       boolean jjtc001 = true;
929       jjtree.openNodeScope(jjtn001);
930       jjtreeOpenNodeScope(jjtn001);
931       jjtn001.jjtSetFirstToken(getToken(1));
932       try {
933         jj_consume_token(VAR);
934         DefineVar();
935         label_7:
936         while (true) {
937           switch (jj_nt.kind) {
938           case COMMA:{
939             break;
940             }
941           default:
942             break label_7;
943           }
944           jj_consume_token(COMMA);
945           DefineVar();
946         }
947       } catch (Throwable jjte001) {
948 if (jjtc001) {
949         jjtree.clearNodeScope(jjtn001);
950         jjtc001 = false;
951       } else {
952         jjtree.popNode();
953       }
954       if (jjte001 instanceof ParseException) {
955         throw (ParseException)jjte001;
956       }
957       if (jjte001 instanceof RuntimeException) {
958         throw (RuntimeException)jjte001;
959       }
960       throw (Error)jjte001;
961       } finally {
962 if (jjtc001) {
963         jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() >  1);
964         if (jjtree.nodeCreated()) {
965          jjtreeCloseNodeScope(jjtn001);
966         }
967         jjtn001.jjtSetLastToken(getToken(0));
968       }
969       }
970       break;
971       }
972     case LET:{
973 ASTDefineVars jjtn002 = new ASTDefineVars(JJTDEFINEVARS);
974       boolean jjtc002 = true;
975       jjtree.openNodeScope(jjtn002);
976       jjtreeOpenNodeScope(jjtn002);
977       jjtn002.jjtSetFirstToken(getToken(1));
978       try {
979         jj_consume_token(LET);
980         DefineLet();
981         label_8:
982         while (true) {
983           switch (jj_nt.kind) {
984           case COMMA:{
985             break;
986             }
987           default:
988             break label_8;
989           }
990           jj_consume_token(COMMA);
991           DefineLet();
992         }
993       } catch (Throwable jjte002) {
994 if (jjtc002) {
995         jjtree.clearNodeScope(jjtn002);
996         jjtc002 = false;
997       } else {
998         jjtree.popNode();
999       }
1000       if (jjte002 instanceof ParseException) {
1001         throw (ParseException)jjte002;
1002       }
1003       if (jjte002 instanceof RuntimeException) {
1004         throw (RuntimeException)jjte002;
1005       }
1006       throw (Error)jjte002;
1007       } finally {
1008 if (jjtc002) {
1009         jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() >  1);
1010         if (jjtree.nodeCreated()) {
1011          jjtreeCloseNodeScope(jjtn002);
1012         }
1013         jjtn002.jjtSetLastToken(getToken(0));
1014       }
1015       }
1016       break;
1017       }
1018     case CONST:{
1019 ASTDefineVars jjtn003 = new ASTDefineVars(JJTDEFINEVARS);
1020       boolean jjtc003 = true;
1021       jjtree.openNodeScope(jjtn003);
1022       jjtreeOpenNodeScope(jjtn003);
1023       jjtn003.jjtSetFirstToken(getToken(1));
1024       try {
1025         jj_consume_token(CONST);
1026         DefineConst();
1027         label_9:
1028         while (true) {
1029           switch (jj_nt.kind) {
1030           case COMMA:{
1031             break;
1032             }
1033           default:
1034             break label_9;
1035           }
1036           jj_consume_token(COMMA);
1037           DefineConst();
1038         }
1039       } catch (Throwable jjte003) {
1040 if (jjtc003) {
1041         jjtree.clearNodeScope(jjtn003);
1042         jjtc003 = false;
1043       } else {
1044         jjtree.popNode();
1045       }
1046       if (jjte003 instanceof ParseException) {
1047         throw (ParseException)jjte003;
1048       }
1049       if (jjte003 instanceof RuntimeException) {
1050         throw (RuntimeException)jjte003;
1051       }
1052       throw (Error)jjte003;
1053       } finally {
1054 if (jjtc003) {
1055         jjtree.closeNodeScope(jjtn003, jjtree.nodeArity() >  1);
1056         if (jjtree.nodeCreated()) {
1057          jjtreeCloseNodeScope(jjtn003);
1058         }
1059         jjtn003.jjtSetLastToken(getToken(0));
1060       }
1061       }
1062       break;
1063       }
1064     default:
1065       jj_consume_token(-1);
1066       throw new ParseException();
1067     }
1068 }
1069 
1070   final public void DefineVar() throws ParseException {
1071     DeclareVar(false, false);
1072     switch (jj_nt.kind) {
1073     case assign:{
1074       jj_consume_token(assign);
1075 ASTAssignment jjtn001 = new ASTAssignment(JJTASSIGNMENT);
1076                                                       boolean jjtc001 = true;
1077                                                       jjtree.openNodeScope(jjtn001);
1078                                                       jjtreeOpenNodeScope(jjtn001);
1079                                                       jjtn001.jjtSetFirstToken(getToken(1));
1080       try {
1081         Expression();
1082       } catch (Throwable jjte001) {
1083 if (jjtc001) {
1084                                                         jjtree.clearNodeScope(jjtn001);
1085                                                         jjtc001 = false;
1086                                                       } else {
1087                                                         jjtree.popNode();
1088                                                       }
1089                                                       if (jjte001 instanceof ParseException) {
1090                                                         throw (ParseException)jjte001;
1091                                                       }
1092                                                       if (jjte001 instanceof RuntimeException) {
1093                                                         throw (RuntimeException)jjte001;
1094                                                       }
1095                                                       throw (Error)jjte001;
1096       } finally {
1097 if (jjtc001) {
1098                                                         jjtree.closeNodeScope(jjtn001,  2);
1099                                                         if (jjtree.nodeCreated()) {
1100                                                          jjtreeCloseNodeScope(jjtn001);
1101                                                         }
1102                                                         jjtn001.jjtSetLastToken(getToken(0));
1103                                                       }
1104       }
1105       break;
1106       }
1107     default:
1108       ;
1109     }
1110 }
1111 
1112   final public void DefineLet() throws ParseException {
1113     DeclareVar(true, false);
1114     switch (jj_nt.kind) {
1115     case assign:{
1116       jj_consume_token(assign);
1117 ASTAssignment jjtn001 = new ASTAssignment(JJTASSIGNMENT);
1118                                                      boolean jjtc001 = true;
1119                                                      jjtree.openNodeScope(jjtn001);
1120                                                      jjtreeOpenNodeScope(jjtn001);
1121                                                      jjtn001.jjtSetFirstToken(getToken(1));
1122       try {
1123         Expression();
1124       } catch (Throwable jjte001) {
1125 if (jjtc001) {
1126                                                        jjtree.clearNodeScope(jjtn001);
1127                                                        jjtc001 = false;
1128                                                      } else {
1129                                                        jjtree.popNode();
1130                                                      }
1131                                                      if (jjte001 instanceof ParseException) {
1132                                                        throw (ParseException)jjte001;
1133                                                      }
1134                                                      if (jjte001 instanceof RuntimeException) {
1135                                                        throw (RuntimeException)jjte001;
1136                                                      }
1137                                                      throw (Error)jjte001;
1138       } finally {
1139 if (jjtc001) {
1140                                                        jjtree.closeNodeScope(jjtn001,  2);
1141                                                        if (jjtree.nodeCreated()) {
1142                                                         jjtreeCloseNodeScope(jjtn001);
1143                                                        }
1144                                                        jjtn001.jjtSetLastToken(getToken(0));
1145                                                      }
1146       }
1147       break;
1148       }
1149     default:
1150       ;
1151     }
1152 }
1153 
1154   final public void DefineConst() throws ParseException {
1155     DeclareVar(true, true);
1156     jj_consume_token(assign);
1157 ASTAssignment jjtn001 = new ASTAssignment(JJTASSIGNMENT);
1158                                       boolean jjtc001 = true;
1159                                       jjtree.openNodeScope(jjtn001);
1160                                       jjtreeOpenNodeScope(jjtn001);
1161                                       jjtn001.jjtSetFirstToken(getToken(1));
1162     try {
1163       Expression();
1164     } catch (Throwable jjte001) {
1165 if (jjtc001) {
1166                                         jjtree.clearNodeScope(jjtn001);
1167                                         jjtc001 = false;
1168                                       } else {
1169                                         jjtree.popNode();
1170                                       }
1171                                       if (jjte001 instanceof ParseException) {
1172                                         throw (ParseException)jjte001;
1173                                       }
1174                                       if (jjte001 instanceof RuntimeException) {
1175                                         throw (RuntimeException)jjte001;
1176                                       }
1177                                       throw (Error)jjte001;
1178     } finally {
1179 if (jjtc001) {
1180                                         jjtree.closeNodeScope(jjtn001,  2);
1181                                         if (jjtree.nodeCreated()) {
1182                                          jjtreeCloseNodeScope(jjtn001);
1183                                         }
1184                                         jjtn001.jjtSetLastToken(getToken(0));
1185                                       }
1186     }
1187 }
1188 
1189   final public void DeclareVar(boolean lexical, boolean constant) throws ParseException {/*@bgen(jjtree) Var */
1190     ASTVar jjtn000 = new ASTVar(JJTVAR);
1191     boolean jjtc000 = true;
1192     jjtree.openNodeScope(jjtn000);
1193     jjtreeOpenNodeScope(jjtn000);
1194     jjtn000.jjtSetFirstToken(getToken(1));Token t;
1195     try {
1196       t = jj_consume_token(IDENTIFIER);
1197 jjtree.closeNodeScope(jjtn000, true);
1198                      jjtc000 = false;
1199                      if (jjtree.nodeCreated()) {
1200                       jjtreeCloseNodeScope(jjtn000);
1201                      }
1202                      jjtn000.jjtSetLastToken(getToken(0));
1203 declareVariable(jjtn000, t, lexical, constant);
1204     } finally {
1205 if (jjtc000) {
1206         jjtree.closeNodeScope(jjtn000, true);
1207         if (jjtree.nodeCreated()) {
1208          jjtreeCloseNodeScope(jjtn000);
1209         }
1210         jjtn000.jjtSetLastToken(getToken(0));
1211       }
1212     }
1213 }
1214 
1215   final public void DeclareFunction() throws ParseException {/*@bgen(jjtree) Var */
1216     ASTVar jjtn000 = new ASTVar(JJTVAR);
1217     boolean jjtc000 = true;
1218     jjtree.openNodeScope(jjtn000);
1219     jjtreeOpenNodeScope(jjtn000);
1220     jjtn000.jjtSetFirstToken(getToken(1));Token t;
1221     try {
1222       t = jj_consume_token(IDENTIFIER);
1223 jjtree.closeNodeScope(jjtn000, true);
1224                      jjtc000 = false;
1225                      if (jjtree.nodeCreated()) {
1226                       jjtreeCloseNodeScope(jjtn000);
1227                      }
1228                      jjtn000.jjtSetLastToken(getToken(0));
1229 declareFunction(jjtn000, t);
1230     } finally {
1231 if (jjtc000) {
1232         jjtree.closeNodeScope(jjtn000, true);
1233         if (jjtree.nodeCreated()) {
1234          jjtreeCloseNodeScope(jjtn000);
1235         }
1236         jjtn000.jjtSetLastToken(getToken(0));
1237       }
1238     }
1239 }
1240 
1241   final public void Pragma() throws ParseException {LinkedList<String> lstr = new LinkedList<String>();
1242     Object value;
1243     jj_consume_token(PRAGMA);
1244     pragmaKey(lstr);
1245     value = pragmaValue();
1246 declarePragma(stringify(lstr), value);
1247 }
1248 
1249   final public void pragmaKey(LinkedList<String> lstr) throws ParseException {Token t;
1250     switch (jj_nt.kind) {
1251     case IDENTIFIER:{
1252       t = jj_consume_token(IDENTIFIER);
1253 lstr.add(t.image);
1254       label_10:
1255       while (true) {
1256         if (jj_2_40(2147483647)) {
1257         } else {
1258           break label_10;
1259         }
1260         pragmaKey(lstr);
1261       }
1262       break;
1263       }
1264     case DOT:{
1265       jj_consume_token(DOT);
1266       t = jj_consume_token(DOT_IDENTIFIER);
1267 lstr.add(t.image);
1268       break;
1269       }
1270     default:
1271       jj_consume_token(-1);
1272       throw new ParseException();
1273     }
1274 }
1275 
1276   final public Object pragmaValue() throws ParseException {Token s = null;
1277 Token v;
1278 LinkedList<String> lstr = new LinkedList<String>();
1279 Object result;
1280     if (jj_2_41(2)) {
1281       switch (jj_nt.kind) {
1282       case plus:
1283       case minus:{
1284         switch (jj_nt.kind) {
1285         case plus:{
1286           s = jj_consume_token(plus);
1287           break;
1288           }
1289         case minus:{
1290           s = jj_consume_token(minus);
1291           break;
1292           }
1293         default:
1294           jj_consume_token(-1);
1295           throw new ParseException();
1296         }
1297         break;
1298         }
1299       default:
1300         ;
1301       }
1302       v = jj_consume_token(INTEGER_LITERAL);
1303 result = NumberParser.parseInteger(s, v);
1304     } else if (jj_2_42(2)) {
1305       switch (jj_nt.kind) {
1306       case plus:
1307       case minus:{
1308         switch (jj_nt.kind) {
1309         case plus:{
1310           s = jj_consume_token(plus);
1311           break;
1312           }
1313         case minus:{
1314           s = jj_consume_token(minus);
1315           break;
1316           }
1317         default:
1318           jj_consume_token(-1);
1319           throw new ParseException();
1320         }
1321         break;
1322         }
1323       default:
1324         ;
1325       }
1326       v = jj_consume_token(FLOAT_LITERAL);
1327 result = NumberParser.parseDouble(s, v);
1328     } else {
1329       switch (jj_nt.kind) {
1330       case STRING_LITERAL:{
1331         v = jj_consume_token(STRING_LITERAL);
1332 result = Parser.buildString(v.image, true);
1333         break;
1334         }
1335       case DOT:
1336       case IDENTIFIER:{
1337         pragmaKey(lstr);
1338 result = stringify(lstr);
1339         break;
1340         }
1341       case TRUE:{
1342         jj_consume_token(TRUE);
1343 result = true;
1344         break;
1345         }
1346       case FALSE:{
1347         jj_consume_token(FALSE);
1348 result = false;
1349         break;
1350         }
1351       case NULL:{
1352         jj_consume_token(NULL);
1353 result = null;
1354         break;
1355         }
1356       case NAN_LITERAL:{
1357         jj_consume_token(NAN_LITERAL);
1358 result = Double.NaN;
1359         break;
1360         }
1361       default:
1362         jj_consume_token(-1);
1363         throw new ParseException();
1364       }
1365     }
1366 {if ("" != null) return result;}
1367     throw new IllegalStateException ("Missing return statement in function");
1368 }
1369 
1370 /***************************************
1371  *      Expression syntax
1372  ***************************************/
1373   final public 
1374 void Expression() throws ParseException {
1375     AssignmentExpression();
1376 }
1377 
1378   final public void AssignmentExpression() throws ParseException {
1379     ConditionalExpression();
1380     if (jj_2_43(2)) {
1381       switch (jj_nt.kind) {
1382       case plus_assign:{
1383         jj_consume_token(plus_assign);
1384 ASTSetAddNode jjtn001 = new ASTSetAddNode(JJTSETADDNODE);
1385                      boolean jjtc001 = true;
1386                      jjtree.openNodeScope(jjtn001);
1387                      jjtreeOpenNodeScope(jjtn001);
1388                      jjtn001.jjtSetFirstToken(getToken(1));
1389         try {
1390           Expression();
1391         } catch (Throwable jjte001) {
1392 if (jjtc001) {
1393                        jjtree.clearNodeScope(jjtn001);
1394                        jjtc001 = false;
1395                      } else {
1396                        jjtree.popNode();
1397                      }
1398                      if (jjte001 instanceof ParseException) {
1399                        throw (ParseException)jjte001;
1400                      }
1401                      if (jjte001 instanceof RuntimeException) {
1402                        throw (RuntimeException)jjte001;
1403                      }
1404                      throw (Error)jjte001;
1405         } finally {
1406 if (jjtc001) {
1407                        jjtree.closeNodeScope(jjtn001,  2);
1408                        if (jjtree.nodeCreated()) {
1409                         jjtreeCloseNodeScope(jjtn001);
1410                        }
1411                        jjtn001.jjtSetLastToken(getToken(0));
1412                      }
1413         }
1414         break;
1415         }
1416       case mult_assign:{
1417         jj_consume_token(mult_assign);
1418 ASTSetMultNode jjtn002 = new ASTSetMultNode(JJTSETMULTNODE);
1419                      boolean jjtc002 = true;
1420                      jjtree.openNodeScope(jjtn002);
1421                      jjtreeOpenNodeScope(jjtn002);
1422                      jjtn002.jjtSetFirstToken(getToken(1));
1423         try {
1424           Expression();
1425         } catch (Throwable jjte002) {
1426 if (jjtc002) {
1427                        jjtree.clearNodeScope(jjtn002);
1428                        jjtc002 = false;
1429                      } else {
1430                        jjtree.popNode();
1431                      }
1432                      if (jjte002 instanceof ParseException) {
1433                        throw (ParseException)jjte002;
1434                      }
1435                      if (jjte002 instanceof RuntimeException) {
1436                        throw (RuntimeException)jjte002;
1437                      }
1438                      throw (Error)jjte002;
1439         } finally {
1440 if (jjtc002) {
1441                        jjtree.closeNodeScope(jjtn002,  2);
1442                        if (jjtree.nodeCreated()) {
1443                         jjtreeCloseNodeScope(jjtn002);
1444                        }
1445                        jjtn002.jjtSetLastToken(getToken(0));
1446                      }
1447         }
1448         break;
1449         }
1450       case div_assign:{
1451         jj_consume_token(div_assign);
1452 ASTSetDivNode jjtn003 = new ASTSetDivNode(JJTSETDIVNODE);
1453                     boolean jjtc003 = true;
1454                     jjtree.openNodeScope(jjtn003);
1455                     jjtreeOpenNodeScope(jjtn003);
1456                     jjtn003.jjtSetFirstToken(getToken(1));
1457         try {
1458           Expression();
1459         } catch (Throwable jjte003) {
1460 if (jjtc003) {
1461                       jjtree.clearNodeScope(jjtn003);
1462                       jjtc003 = false;
1463                     } else {
1464                       jjtree.popNode();
1465                     }
1466                     if (jjte003 instanceof ParseException) {
1467                       throw (ParseException)jjte003;
1468                     }
1469                     if (jjte003 instanceof RuntimeException) {
1470                       throw (RuntimeException)jjte003;
1471                     }
1472                     throw (Error)jjte003;
1473         } finally {
1474 if (jjtc003) {
1475                       jjtree.closeNodeScope(jjtn003,  2);
1476                       if (jjtree.nodeCreated()) {
1477                        jjtreeCloseNodeScope(jjtn003);
1478                       }
1479                       jjtn003.jjtSetLastToken(getToken(0));
1480                     }
1481         }
1482         break;
1483         }
1484       case mod_assign:{
1485         jj_consume_token(mod_assign);
1486 ASTSetModNode jjtn004 = new ASTSetModNode(JJTSETMODNODE);
1487                     boolean jjtc004 = true;
1488                     jjtree.openNodeScope(jjtn004);
1489                     jjtreeOpenNodeScope(jjtn004);
1490                     jjtn004.jjtSetFirstToken(getToken(1));
1491         try {
1492           Expression();
1493         } catch (Throwable jjte004) {
1494 if (jjtc004) {
1495                       jjtree.clearNodeScope(jjtn004);
1496                       jjtc004 = false;
1497                     } else {
1498                       jjtree.popNode();
1499                     }
1500                     if (jjte004 instanceof ParseException) {
1501                       throw (ParseException)jjte004;
1502                     }
1503                     if (jjte004 instanceof RuntimeException) {
1504                       throw (RuntimeException)jjte004;
1505                     }
1506                     throw (Error)jjte004;
1507         } finally {
1508 if (jjtc004) {
1509                       jjtree.closeNodeScope(jjtn004,  2);
1510                       if (jjtree.nodeCreated()) {
1511                        jjtreeCloseNodeScope(jjtn004);
1512                       }
1513                       jjtn004.jjtSetLastToken(getToken(0));
1514                     }
1515         }
1516         break;
1517         }
1518       case and_assign:{
1519         jj_consume_token(and_assign);
1520 ASTSetAndNode jjtn005 = new ASTSetAndNode(JJTSETANDNODE);
1521                     boolean jjtc005 = true;
1522                     jjtree.openNodeScope(jjtn005);
1523                     jjtreeOpenNodeScope(jjtn005);
1524                     jjtn005.jjtSetFirstToken(getToken(1));
1525         try {
1526           Expression();
1527         } catch (Throwable jjte005) {
1528 if (jjtc005) {
1529                       jjtree.clearNodeScope(jjtn005);
1530                       jjtc005 = false;
1531                     } else {
1532                       jjtree.popNode();
1533                     }
1534                     if (jjte005 instanceof ParseException) {
1535                       throw (ParseException)jjte005;
1536                     }
1537                     if (jjte005 instanceof RuntimeException) {
1538                       throw (RuntimeException)jjte005;
1539                     }
1540                     throw (Error)jjte005;
1541         } finally {
1542 if (jjtc005) {
1543                       jjtree.closeNodeScope(jjtn005,  2);
1544                       if (jjtree.nodeCreated()) {
1545                        jjtreeCloseNodeScope(jjtn005);
1546                       }
1547                       jjtn005.jjtSetLastToken(getToken(0));
1548                     }
1549         }
1550         break;
1551         }
1552       case or_assign:{
1553         jj_consume_token(or_assign);
1554 ASTSetOrNode jjtn006 = new ASTSetOrNode(JJTSETORNODE);
1555                    boolean jjtc006 = true;
1556                    jjtree.openNodeScope(jjtn006);
1557                    jjtreeOpenNodeScope(jjtn006);
1558                    jjtn006.jjtSetFirstToken(getToken(1));
1559         try {
1560           Expression();
1561         } catch (Throwable jjte006) {
1562 if (jjtc006) {
1563                      jjtree.clearNodeScope(jjtn006);
1564                      jjtc006 = false;
1565                    } else {
1566                      jjtree.popNode();
1567                    }
1568                    if (jjte006 instanceof ParseException) {
1569                      throw (ParseException)jjte006;
1570                    }
1571                    if (jjte006 instanceof RuntimeException) {
1572                      throw (RuntimeException)jjte006;
1573                    }
1574                    throw (Error)jjte006;
1575         } finally {
1576 if (jjtc006) {
1577                      jjtree.closeNodeScope(jjtn006,  2);
1578                      if (jjtree.nodeCreated()) {
1579                       jjtreeCloseNodeScope(jjtn006);
1580                      }
1581                      jjtn006.jjtSetLastToken(getToken(0));
1582                    }
1583         }
1584         break;
1585         }
1586       case xor_assign:{
1587         jj_consume_token(xor_assign);
1588 ASTSetXorNode jjtn007 = new ASTSetXorNode(JJTSETXORNODE);
1589                    boolean jjtc007 = true;
1590                    jjtree.openNodeScope(jjtn007);
1591                    jjtreeOpenNodeScope(jjtn007);
1592                    jjtn007.jjtSetFirstToken(getToken(1));
1593         try {
1594           Expression();
1595         } catch (Throwable jjte007) {
1596 if (jjtc007) {
1597                      jjtree.clearNodeScope(jjtn007);
1598                      jjtc007 = false;
1599                    } else {
1600                      jjtree.popNode();
1601                    }
1602                    if (jjte007 instanceof ParseException) {
1603                      throw (ParseException)jjte007;
1604                    }
1605                    if (jjte007 instanceof RuntimeException) {
1606                      throw (RuntimeException)jjte007;
1607                    }
1608                    throw (Error)jjte007;
1609         } finally {
1610 if (jjtc007) {
1611                      jjtree.closeNodeScope(jjtn007,  2);
1612                      if (jjtree.nodeCreated()) {
1613                       jjtreeCloseNodeScope(jjtn007);
1614                      }
1615                      jjtn007.jjtSetLastToken(getToken(0));
1616                    }
1617         }
1618         break;
1619         }
1620       case minus_assign:{
1621         jj_consume_token(minus_assign);
1622 ASTSetSubNode jjtn008 = new ASTSetSubNode(JJTSETSUBNODE);
1623                       boolean jjtc008 = true;
1624                       jjtree.openNodeScope(jjtn008);
1625                       jjtreeOpenNodeScope(jjtn008);
1626                       jjtn008.jjtSetFirstToken(getToken(1));
1627         try {
1628           Expression();
1629         } catch (Throwable jjte008) {
1630 if (jjtc008) {
1631                         jjtree.clearNodeScope(jjtn008);
1632                         jjtc008 = false;
1633                       } else {
1634                         jjtree.popNode();
1635                       }
1636                       if (jjte008 instanceof ParseException) {
1637                         throw (ParseException)jjte008;
1638                       }
1639                       if (jjte008 instanceof RuntimeException) {
1640                         throw (RuntimeException)jjte008;
1641                       }
1642                       throw (Error)jjte008;
1643         } finally {
1644 if (jjtc008) {
1645                         jjtree.closeNodeScope(jjtn008,  2);
1646                         if (jjtree.nodeCreated()) {
1647                          jjtreeCloseNodeScope(jjtn008);
1648                         }
1649                         jjtn008.jjtSetLastToken(getToken(0));
1650                       }
1651         }
1652         break;
1653         }
1654       case lshift_assign:{
1655         jj_consume_token(lshift_assign);
1656 ASTSetShiftLeftNode jjtn009 = new ASTSetShiftLeftNode(JJTSETSHIFTLEFTNODE);
1657                        boolean jjtc009 = true;
1658                        jjtree.openNodeScope(jjtn009);
1659                        jjtreeOpenNodeScope(jjtn009);
1660                        jjtn009.jjtSetFirstToken(getToken(1));
1661         try {
1662           Expression();
1663         } catch (Throwable jjte009) {
1664 if (jjtc009) {
1665                          jjtree.clearNodeScope(jjtn009);
1666                          jjtc009 = false;
1667                        } else {
1668                          jjtree.popNode();
1669                        }
1670                        if (jjte009 instanceof ParseException) {
1671                          throw (ParseException)jjte009;
1672                        }
1673                        if (jjte009 instanceof RuntimeException) {
1674                          throw (RuntimeException)jjte009;
1675                        }
1676                        throw (Error)jjte009;
1677         } finally {
1678 if (jjtc009) {
1679                          jjtree.closeNodeScope(jjtn009,  2);
1680                          if (jjtree.nodeCreated()) {
1681                           jjtreeCloseNodeScope(jjtn009);
1682                          }
1683                          jjtn009.jjtSetLastToken(getToken(0));
1684                        }
1685         }
1686         break;
1687         }
1688       case rshift_assign:{
1689         jj_consume_token(rshift_assign);
1690 ASTSetShiftRightNode jjtn010 = new ASTSetShiftRightNode(JJTSETSHIFTRIGHTNODE);
1691                        boolean jjtc010 = true;
1692                        jjtree.openNodeScope(jjtn010);
1693                        jjtreeOpenNodeScope(jjtn010);
1694                        jjtn010.jjtSetFirstToken(getToken(1));
1695         try {
1696           Expression();
1697         } catch (Throwable jjte010) {
1698 if (jjtc010) {
1699                          jjtree.clearNodeScope(jjtn010);
1700                          jjtc010 = false;
1701                        } else {
1702                          jjtree.popNode();
1703                        }
1704                        if (jjte010 instanceof ParseException) {
1705                          throw (ParseException)jjte010;
1706                        }
1707                        if (jjte010 instanceof RuntimeException) {
1708                          throw (RuntimeException)jjte010;
1709                        }
1710                        throw (Error)jjte010;
1711         } finally {
1712 if (jjtc010) {
1713                          jjtree.closeNodeScope(jjtn010,  2);
1714                          if (jjtree.nodeCreated()) {
1715                           jjtreeCloseNodeScope(jjtn010);
1716                          }
1717                          jjtn010.jjtSetLastToken(getToken(0));
1718                        }
1719         }
1720         break;
1721         }
1722       case rshiftu_assign:{
1723         jj_consume_token(rshiftu_assign);
1724 ASTSetShiftRightUnsignedNode jjtn011 = new ASTSetShiftRightUnsignedNode(JJTSETSHIFTRIGHTUNSIGNEDNODE);
1725                         boolean jjtc011 = true;
1726                         jjtree.openNodeScope(jjtn011);
1727                         jjtreeOpenNodeScope(jjtn011);
1728                         jjtn011.jjtSetFirstToken(getToken(1));
1729         try {
1730           Expression();
1731         } catch (Throwable jjte011) {
1732 if (jjtc011) {
1733                           jjtree.clearNodeScope(jjtn011);
1734                           jjtc011 = false;
1735                         } else {
1736                           jjtree.popNode();
1737                         }
1738                         if (jjte011 instanceof ParseException) {
1739                           throw (ParseException)jjte011;
1740                         }
1741                         if (jjte011 instanceof RuntimeException) {
1742                           throw (RuntimeException)jjte011;
1743                         }
1744                         throw (Error)jjte011;
1745         } finally {
1746 if (jjtc011) {
1747                           jjtree.closeNodeScope(jjtn011,  2);
1748                           if (jjtree.nodeCreated()) {
1749                            jjtreeCloseNodeScope(jjtn011);
1750                           }
1751                           jjtn011.jjtSetLastToken(getToken(0));
1752                         }
1753         }
1754         break;
1755         }
1756       case assign:{
1757         jj_consume_token(assign);
1758 ASTAssignment jjtn012 = new ASTAssignment(JJTASSIGNMENT);
1759                boolean jjtc012 = true;
1760                jjtree.openNodeScope(jjtn012);
1761                jjtreeOpenNodeScope(jjtn012);
1762                jjtn012.jjtSetFirstToken(getToken(1));
1763         try {
1764           Expression();
1765         } catch (Throwable jjte012) {
1766 if (jjtc012) {
1767                  jjtree.clearNodeScope(jjtn012);
1768                  jjtc012 = false;
1769                } else {
1770                  jjtree.popNode();
1771                }
1772                if (jjte012 instanceof ParseException) {
1773                  throw (ParseException)jjte012;
1774                }
1775                if (jjte012 instanceof RuntimeException) {
1776                  throw (RuntimeException)jjte012;
1777                }
1778                throw (Error)jjte012;
1779         } finally {
1780 if (jjtc012) {
1781                  jjtree.closeNodeScope(jjtn012,  2);
1782                  if (jjtree.nodeCreated()) {
1783                   jjtreeCloseNodeScope(jjtn012);
1784                  }
1785                  jjtn012.jjtSetLastToken(getToken(0));
1786                }
1787         }
1788         break;
1789         }
1790       default:
1791         jj_consume_token(-1);
1792         throw new ParseException();
1793       }
1794     } else {
1795       ;
1796     }
1797 }
1798 
1799 /***************************************
1800  *      Conditional & relational
1801  ***************************************/
1802   final public 
1803 void ConditionalExpression() throws ParseException {
1804     ConditionalOrExpression();
1805     if (jj_2_44(2)) {
1806       switch (jj_nt.kind) {
1807       case QMARK:{
1808         jj_consume_token(QMARK);
1809         Expression();
1810         jj_consume_token(COLON);
1811 ASTTernaryNode jjtn001 = new ASTTernaryNode(JJTTERNARYNODE);
1812                                    boolean jjtc001 = true;
1813                                    jjtree.openNodeScope(jjtn001);
1814                                    jjtreeOpenNodeScope(jjtn001);
1815                                    jjtn001.jjtSetFirstToken(getToken(1));
1816         try {
1817           Expression();
1818         } catch (Throwable jjte001) {
1819 if (jjtc001) {
1820                                      jjtree.clearNodeScope(jjtn001);
1821                                      jjtc001 = false;
1822                                    } else {
1823                                      jjtree.popNode();
1824                                    }
1825                                    if (jjte001 instanceof ParseException) {
1826                                      throw (ParseException)jjte001;
1827                                    }
1828                                    if (jjte001 instanceof RuntimeException) {
1829                                      throw (RuntimeException)jjte001;
1830                                    }
1831                                    throw (Error)jjte001;
1832         } finally {
1833 if (jjtc001) {
1834                                      jjtree.closeNodeScope(jjtn001,  3);
1835                                      if (jjtree.nodeCreated()) {
1836                                       jjtreeCloseNodeScope(jjtn001);
1837                                      }
1838                                      jjtn001.jjtSetLastToken(getToken(0));
1839                                    }
1840         }
1841         break;
1842         }
1843       case ELVIS:{
1844         jj_consume_token(ELVIS);
1845 ASTTernaryNode jjtn002 = new ASTTernaryNode(JJTTERNARYNODE);
1846               boolean jjtc002 = true;
1847               jjtree.openNodeScope(jjtn002);
1848               jjtreeOpenNodeScope(jjtn002);
1849               jjtn002.jjtSetFirstToken(getToken(1));
1850         try {
1851           Expression();
1852         } catch (Throwable jjte002) {
1853 if (jjtc002) {
1854                 jjtree.clearNodeScope(jjtn002);
1855                 jjtc002 = false;
1856               } else {
1857                 jjtree.popNode();
1858               }
1859               if (jjte002 instanceof ParseException) {
1860                 throw (ParseException)jjte002;
1861               }
1862               if (jjte002 instanceof RuntimeException) {
1863                 throw (RuntimeException)jjte002;
1864               }
1865               throw (Error)jjte002;
1866         } finally {
1867 if (jjtc002) {
1868                 jjtree.closeNodeScope(jjtn002,  2);
1869                 if (jjtree.nodeCreated()) {
1870                  jjtreeCloseNodeScope(jjtn002);
1871                 }
1872                 jjtn002.jjtSetLastToken(getToken(0));
1873               }
1874         }
1875         break;
1876         }
1877       case NULLP:{
1878         jj_consume_token(NULLP);
1879 ASTNullpNode jjtn003 = new ASTNullpNode(JJTNULLPNODE);
1880               boolean jjtc003 = true;
1881               jjtree.openNodeScope(jjtn003);
1882               jjtreeOpenNodeScope(jjtn003);
1883               jjtn003.jjtSetFirstToken(getToken(1));
1884         try {
1885           Expression();
1886         } catch (Throwable jjte003) {
1887 if (jjtc003) {
1888                 jjtree.clearNodeScope(jjtn003);
1889                 jjtc003 = false;
1890               } else {
1891                 jjtree.popNode();
1892               }
1893               if (jjte003 instanceof ParseException) {
1894                 throw (ParseException)jjte003;
1895               }
1896               if (jjte003 instanceof RuntimeException) {
1897                 throw (RuntimeException)jjte003;
1898               }
1899               throw (Error)jjte003;
1900         } finally {
1901 if (jjtc003) {
1902                 jjtree.closeNodeScope(jjtn003,  2);
1903                 if (jjtree.nodeCreated()) {
1904                  jjtreeCloseNodeScope(jjtn003);
1905                 }
1906                 jjtn003.jjtSetLastToken(getToken(0));
1907               }
1908         }
1909         break;
1910         }
1911       default:
1912         jj_consume_token(-1);
1913         throw new ParseException();
1914       }
1915     } else {
1916       ;
1917     }
1918 }
1919 
1920   final public void ConditionalOrExpression() throws ParseException {
1921     ConditionalAndExpression();
1922     label_11:
1923     while (true) {
1924       if (jj_2_45(2)) {
1925       } else {
1926         break label_11;
1927       }
1928       switch (jj_nt.kind) {
1929       case OR:{
1930         jj_consume_token(OR);
1931         break;
1932         }
1933       case _OR:{
1934         jj_consume_token(_OR);
1935         break;
1936         }
1937       default:
1938         jj_consume_token(-1);
1939         throw new ParseException();
1940       }
1941 ASTOrNode jjtn001 = new ASTOrNode(JJTORNODE);
1942                                   boolean jjtc001 = true;
1943                                   jjtree.openNodeScope(jjtn001);
1944                                   jjtreeOpenNodeScope(jjtn001);
1945                                   jjtn001.jjtSetFirstToken(getToken(1));
1946       try {
1947         ConditionalAndExpression();
1948       } catch (Throwable jjte001) {
1949 if (jjtc001) {
1950                                     jjtree.clearNodeScope(jjtn001);
1951                                     jjtc001 = false;
1952                                   } else {
1953                                     jjtree.popNode();
1954                                   }
1955                                   if (jjte001 instanceof ParseException) {
1956                                     throw (ParseException)jjte001;
1957                                   }
1958                                   if (jjte001 instanceof RuntimeException) {
1959                                     throw (RuntimeException)jjte001;
1960                                   }
1961                                   throw (Error)jjte001;
1962       } finally {
1963 if (jjtc001) {
1964                                     jjtree.closeNodeScope(jjtn001,  2);
1965                                     if (jjtree.nodeCreated()) {
1966                                      jjtreeCloseNodeScope(jjtn001);
1967                                     }
1968                                     jjtn001.jjtSetLastToken(getToken(0));
1969                                   }
1970       }
1971     }
1972 }
1973 
1974   final public void ConditionalAndExpression() throws ParseException {
1975     InclusiveOrExpression();
1976     label_12:
1977     while (true) {
1978       if (jj_2_46(2)) {
1979       } else {
1980         break label_12;
1981       }
1982       switch (jj_nt.kind) {
1983       case AND:{
1984         jj_consume_token(AND);
1985         break;
1986         }
1987       case _AND:{
1988         jj_consume_token(_AND);
1989         break;
1990         }
1991       default:
1992         jj_consume_token(-1);
1993         throw new ParseException();
1994       }
1995 ASTAndNode jjtn001 = new ASTAndNode(JJTANDNODE);
1996                                     boolean jjtc001 = true;
1997                                     jjtree.openNodeScope(jjtn001);
1998                                     jjtreeOpenNodeScope(jjtn001);
1999                                     jjtn001.jjtSetFirstToken(getToken(1));
2000       try {
2001         InclusiveOrExpression();
2002       } catch (Throwable jjte001) {
2003 if (jjtc001) {
2004                                       jjtree.clearNodeScope(jjtn001);
2005                                       jjtc001 = false;
2006                                     } else {
2007                                       jjtree.popNode();
2008                                     }
2009                                     if (jjte001 instanceof ParseException) {
2010                                       throw (ParseException)jjte001;
2011                                     }
2012                                     if (jjte001 instanceof RuntimeException) {
2013                                       throw (RuntimeException)jjte001;
2014                                     }
2015                                     throw (Error)jjte001;
2016       } finally {
2017 if (jjtc001) {
2018                                       jjtree.closeNodeScope(jjtn001,  2);
2019                                       if (jjtree.nodeCreated()) {
2020                                        jjtreeCloseNodeScope(jjtn001);
2021                                       }
2022                                       jjtn001.jjtSetLastToken(getToken(0));
2023                                     }
2024       }
2025     }
2026 }
2027 
2028   final public void InclusiveOrExpression() throws ParseException {
2029     ExclusiveOrExpression();
2030     label_13:
2031     while (true) {
2032       if (jj_2_47(2)) {
2033       } else {
2034         break label_13;
2035       }
2036       jj_consume_token(or);
2037 ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(JJTBITWISEORNODE);
2038                           boolean jjtc001 = true;
2039                           jjtree.openNodeScope(jjtn001);
2040                           jjtreeOpenNodeScope(jjtn001);
2041                           jjtn001.jjtSetFirstToken(getToken(1));
2042       try {
2043         ExclusiveOrExpression();
2044       } catch (Throwable jjte001) {
2045 if (jjtc001) {
2046                             jjtree.clearNodeScope(jjtn001);
2047                             jjtc001 = false;
2048                           } else {
2049                             jjtree.popNode();
2050                           }
2051                           if (jjte001 instanceof ParseException) {
2052                             throw (ParseException)jjte001;
2053                           }
2054                           if (jjte001 instanceof RuntimeException) {
2055                             throw (RuntimeException)jjte001;
2056                           }
2057                           throw (Error)jjte001;
2058       } finally {
2059 if (jjtc001) {
2060                             jjtree.closeNodeScope(jjtn001,  2);
2061                             if (jjtree.nodeCreated()) {
2062                              jjtreeCloseNodeScope(jjtn001);
2063                             }
2064                             jjtn001.jjtSetLastToken(getToken(0));
2065                           }
2066       }
2067     }
2068 }
2069 
2070   final public void ExclusiveOrExpression() throws ParseException {
2071     AndExpression();
2072     label_14:
2073     while (true) {
2074       if (jj_2_48(2)) {
2075       } else {
2076         break label_14;
2077       }
2078       jj_consume_token(xor);
2079 ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(JJTBITWISEXORNODE);
2080                            boolean jjtc001 = true;
2081                            jjtree.openNodeScope(jjtn001);
2082                            jjtreeOpenNodeScope(jjtn001);
2083                            jjtn001.jjtSetFirstToken(getToken(1));
2084       try {
2085         AndExpression();
2086       } catch (Throwable jjte001) {
2087 if (jjtc001) {
2088                              jjtree.clearNodeScope(jjtn001);
2089                              jjtc001 = false;
2090                            } else {
2091                              jjtree.popNode();
2092                            }
2093                            if (jjte001 instanceof ParseException) {
2094                              throw (ParseException)jjte001;
2095                            }
2096                            if (jjte001 instanceof RuntimeException) {
2097                              throw (RuntimeException)jjte001;
2098                            }
2099                            throw (Error)jjte001;
2100       } finally {
2101 if (jjtc001) {
2102                              jjtree.closeNodeScope(jjtn001,  2);
2103                              if (jjtree.nodeCreated()) {
2104                               jjtreeCloseNodeScope(jjtn001);
2105                              }
2106                              jjtn001.jjtSetLastToken(getToken(0));
2107                            }
2108       }
2109     }
2110 }
2111 
2112   final public void AndExpression() throws ParseException {
2113     EqualityExpression();
2114     label_15:
2115     while (true) {
2116       if (jj_2_49(2)) {
2117       } else {
2118         break label_15;
2119       }
2120       jj_consume_token(and);
2121 ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(JJTBITWISEANDNODE);
2122                           boolean jjtc001 = true;
2123                           jjtree.openNodeScope(jjtn001);
2124                           jjtreeOpenNodeScope(jjtn001);
2125                           jjtn001.jjtSetFirstToken(getToken(1));
2126       try {
2127         EqualityExpression();
2128       } catch (Throwable jjte001) {
2129 if (jjtc001) {
2130                             jjtree.clearNodeScope(jjtn001);
2131                             jjtc001 = false;
2132                           } else {
2133                             jjtree.popNode();
2134                           }
2135                           if (jjte001 instanceof ParseException) {
2136                             throw (ParseException)jjte001;
2137                           }
2138                           if (jjte001 instanceof RuntimeException) {
2139                             throw (RuntimeException)jjte001;
2140                           }
2141                           throw (Error)jjte001;
2142       } finally {
2143 if (jjtc001) {
2144                             jjtree.closeNodeScope(jjtn001,  2);
2145                             if (jjtree.nodeCreated()) {
2146                              jjtreeCloseNodeScope(jjtn001);
2147                             }
2148                             jjtn001.jjtSetLastToken(getToken(0));
2149                           }
2150       }
2151     }
2152 }
2153 
2154   final public void EqualityExpression() throws ParseException {
2155     RelationalExpression();
2156     if (jj_2_50(2)) {
2157       switch (jj_nt.kind) {
2158       case eq:
2159       case EQ:{
2160         switch (jj_nt.kind) {
2161         case eq:{
2162           jj_consume_token(eq);
2163           break;
2164           }
2165         case EQ:{
2166           jj_consume_token(EQ);
2167           break;
2168           }
2169         default:
2170           jj_consume_token(-1);
2171           throw new ParseException();
2172         }
2173 ASTEQNode jjtn001 = new ASTEQNode(JJTEQNODE);
2174                      boolean jjtc001 = true;
2175                      jjtree.openNodeScope(jjtn001);
2176                      jjtreeOpenNodeScope(jjtn001);
2177                      jjtn001.jjtSetFirstToken(getToken(1));
2178         try {
2179           RelationalExpression();
2180         } catch (Throwable jjte001) {
2181 if (jjtc001) {
2182                        jjtree.clearNodeScope(jjtn001);
2183                        jjtc001 = false;
2184                      } else {
2185                        jjtree.popNode();
2186                      }
2187                      if (jjte001 instanceof ParseException) {
2188                        throw (ParseException)jjte001;
2189                      }
2190                      if (jjte001 instanceof RuntimeException) {
2191                        throw (RuntimeException)jjte001;
2192                      }
2193                      throw (Error)jjte001;
2194         } finally {
2195 if (jjtc001) {
2196                        jjtree.closeNodeScope(jjtn001,  2);
2197                        if (jjtree.nodeCreated()) {
2198                         jjtreeCloseNodeScope(jjtn001);
2199                        }
2200                        jjtn001.jjtSetLastToken(getToken(0));
2201                      }
2202         }
2203         break;
2204         }
2205       case ne:
2206       case NE:{
2207         switch (jj_nt.kind) {
2208         case ne:{
2209           jj_consume_token(ne);
2210           break;
2211           }
2212         case NE:{
2213           jj_consume_token(NE);
2214           break;
2215           }
2216         default:
2217           jj_consume_token(-1);
2218           throw new ParseException();
2219         }
2220 ASTNENode jjtn002 = new ASTNENode(JJTNENODE);
2221                      boolean jjtc002 = true;
2222                      jjtree.openNodeScope(jjtn002);
2223                      jjtreeOpenNodeScope(jjtn002);
2224                      jjtn002.jjtSetFirstToken(getToken(1));
2225         try {
2226           RelationalExpression();
2227         } catch (Throwable jjte002) {
2228 if (jjtc002) {
2229                        jjtree.clearNodeScope(jjtn002);
2230                        jjtc002 = false;
2231                      } else {
2232                        jjtree.popNode();
2233                      }
2234                      if (jjte002 instanceof ParseException) {
2235                        throw (ParseException)jjte002;
2236                      }
2237                      if (jjte002 instanceof RuntimeException) {
2238                        throw (RuntimeException)jjte002;
2239                      }
2240                      throw (Error)jjte002;
2241         } finally {
2242 if (jjtc002) {
2243                        jjtree.closeNodeScope(jjtn002,  2);
2244                        if (jjtree.nodeCreated()) {
2245                         jjtreeCloseNodeScope(jjtn002);
2246                        }
2247                        jjtn002.jjtSetLastToken(getToken(0));
2248                      }
2249         }
2250         break;
2251         }
2252       case range:{
2253         jj_consume_token(range);
2254 ASTRangeNode jjtn003 = new ASTRangeNode(JJTRANGENODE);
2255                boolean jjtc003 = true;
2256                jjtree.openNodeScope(jjtn003);
2257                jjtreeOpenNodeScope(jjtn003);
2258                jjtn003.jjtSetFirstToken(getToken(1));
2259         try {
2260           RelationalExpression();
2261         } catch (Throwable jjte003) {
2262 if (jjtc003) {
2263                  jjtree.clearNodeScope(jjtn003);
2264                  jjtc003 = false;
2265                } else {
2266                  jjtree.popNode();
2267                }
2268                if (jjte003 instanceof ParseException) {
2269                  throw (ParseException)jjte003;
2270                }
2271                if (jjte003 instanceof RuntimeException) {
2272                  throw (RuntimeException)jjte003;
2273                }
2274                throw (Error)jjte003;
2275         } finally {
2276 if (jjtc003) {
2277                  jjtree.closeNodeScope(jjtn003,  2);
2278                  if (jjtree.nodeCreated()) {
2279                   jjtreeCloseNodeScope(jjtn003);
2280                  }
2281                  jjtn003.jjtSetLastToken(getToken(0));
2282                }
2283         }
2284         break;
2285         }
2286       default:
2287         jj_consume_token(-1);
2288         throw new ParseException();
2289       }
2290     } else {
2291       ;
2292     }
2293 }
2294 
2295   final public void RelationalExpression() throws ParseException {
2296     ShiftExpression();
2297     if (jj_2_51(2)) {
2298       switch (jj_nt.kind) {
2299       case lt:
2300       case LT:{
2301         switch (jj_nt.kind) {
2302         case lt:{
2303           jj_consume_token(lt);
2304           break;
2305           }
2306         case LT:{
2307           jj_consume_token(LT);
2308           break;
2309           }
2310         default:
2311           jj_consume_token(-1);
2312           throw new ParseException();
2313         }
2314 ASTLTNode jjtn001 = new ASTLTNode(JJTLTNODE);
2315                     boolean jjtc001 = true;
2316                     jjtree.openNodeScope(jjtn001);
2317                     jjtreeOpenNodeScope(jjtn001);
2318                     jjtn001.jjtSetFirstToken(getToken(1));
2319         try {
2320           ShiftExpression();
2321         } catch (Throwable jjte001) {
2322 if (jjtc001) {
2323                       jjtree.clearNodeScope(jjtn001);
2324                       jjtc001 = false;
2325                     } else {
2326                       jjtree.popNode();
2327                     }
2328                     if (jjte001 instanceof ParseException) {
2329                       throw (ParseException)jjte001;
2330                     }
2331                     if (jjte001 instanceof RuntimeException) {
2332                       throw (RuntimeException)jjte001;
2333                     }
2334                     throw (Error)jjte001;
2335         } finally {
2336 if (jjtc001) {
2337                       jjtree.closeNodeScope(jjtn001,  2);
2338                       if (jjtree.nodeCreated()) {
2339                        jjtreeCloseNodeScope(jjtn001);
2340                       }
2341                       jjtn001.jjtSetLastToken(getToken(0));
2342                     }
2343         }
2344         break;
2345         }
2346       case gt:
2347       case GT:{
2348         switch (jj_nt.kind) {
2349         case gt:{
2350           jj_consume_token(gt);
2351           break;
2352           }
2353         case GT:{
2354           jj_consume_token(GT);
2355           break;
2356           }
2357         default:
2358           jj_consume_token(-1);
2359           throw new ParseException();
2360         }
2361 ASTGTNode jjtn002 = new ASTGTNode(JJTGTNODE);
2362                     boolean jjtc002 = true;
2363                     jjtree.openNodeScope(jjtn002);
2364                     jjtreeOpenNodeScope(jjtn002);
2365                     jjtn002.jjtSetFirstToken(getToken(1));
2366         try {
2367           ShiftExpression();
2368         } catch (Throwable jjte002) {
2369 if (jjtc002) {
2370                       jjtree.clearNodeScope(jjtn002);
2371                       jjtc002 = false;
2372                     } else {
2373                       jjtree.popNode();
2374                     }
2375                     if (jjte002 instanceof ParseException) {
2376                       throw (ParseException)jjte002;
2377                     }
2378                     if (jjte002 instanceof RuntimeException) {
2379                       throw (RuntimeException)jjte002;
2380                     }
2381                     throw (Error)jjte002;
2382         } finally {
2383 if (jjtc002) {
2384                       jjtree.closeNodeScope(jjtn002,  2);
2385                       if (jjtree.nodeCreated()) {
2386                        jjtreeCloseNodeScope(jjtn002);
2387                       }
2388                       jjtn002.jjtSetLastToken(getToken(0));
2389                     }
2390         }
2391         break;
2392         }
2393       case le:
2394       case LE:{
2395         switch (jj_nt.kind) {
2396         case le:{
2397           jj_consume_token(le);
2398           break;
2399           }
2400         case LE:{
2401           jj_consume_token(LE);
2402           break;
2403           }
2404         default:
2405           jj_consume_token(-1);
2406           throw new ParseException();
2407         }
2408 ASTLENode jjtn003 = new ASTLENode(JJTLENODE);
2409                     boolean jjtc003 = true;
2410                     jjtree.openNodeScope(jjtn003);
2411                     jjtreeOpenNodeScope(jjtn003);
2412                     jjtn003.jjtSetFirstToken(getToken(1));
2413         try {
2414           ShiftExpression();
2415         } catch (Throwable jjte003) {
2416 if (jjtc003) {
2417                       jjtree.clearNodeScope(jjtn003);
2418                       jjtc003 = false;
2419                     } else {
2420                       jjtree.popNode();
2421                     }
2422                     if (jjte003 instanceof ParseException) {
2423                       throw (ParseException)jjte003;
2424                     }
2425                     if (jjte003 instanceof RuntimeException) {
2426                       throw (RuntimeException)jjte003;
2427                     }
2428                     throw (Error)jjte003;
2429         } finally {
2430 if (jjtc003) {
2431                       jjtree.closeNodeScope(jjtn003,  2);
2432                       if (jjtree.nodeCreated()) {
2433                        jjtreeCloseNodeScope(jjtn003);
2434                       }
2435                       jjtn003.jjtSetLastToken(getToken(0));
2436                     }
2437         }
2438         break;
2439         }
2440       case ge:
2441       case GE:{
2442         switch (jj_nt.kind) {
2443         case ge:{
2444           jj_consume_token(ge);
2445           break;
2446           }
2447         case GE:{
2448           jj_consume_token(GE);
2449           break;
2450           }
2451         default:
2452           jj_consume_token(-1);
2453           throw new ParseException();
2454         }
2455 ASTGENode jjtn004 = new ASTGENode(JJTGENODE);
2456                     boolean jjtc004 = true;
2457                     jjtree.openNodeScope(jjtn004);
2458                     jjtreeOpenNodeScope(jjtn004);
2459                     jjtn004.jjtSetFirstToken(getToken(1));
2460         try {
2461           ShiftExpression();
2462         } catch (Throwable jjte004) {
2463 if (jjtc004) {
2464                       jjtree.clearNodeScope(jjtn004);
2465                       jjtc004 = false;
2466                     } else {
2467                       jjtree.popNode();
2468                     }
2469                     if (jjte004 instanceof ParseException) {
2470                       throw (ParseException)jjte004;
2471                     }
2472                     if (jjte004 instanceof RuntimeException) {
2473                       throw (RuntimeException)jjte004;
2474                     }
2475                     throw (Error)jjte004;
2476         } finally {
2477 if (jjtc004) {
2478                       jjtree.closeNodeScope(jjtn004,  2);
2479                       if (jjtree.nodeCreated()) {
2480                        jjtreeCloseNodeScope(jjtn004);
2481                       }
2482                       jjtn004.jjtSetLastToken(getToken(0));
2483                     }
2484         }
2485         break;
2486         }
2487       case req:{
2488         jj_consume_token(req);
2489 ASTERNode jjtn005 = new ASTERNode(JJTERNODE);
2490             boolean jjtc005 = true;
2491             jjtree.openNodeScope(jjtn005);
2492             jjtreeOpenNodeScope(jjtn005);
2493             jjtn005.jjtSetFirstToken(getToken(1));
2494         try {
2495           ShiftExpression();
2496         } catch (Throwable jjte005) {
2497 if (jjtc005) {
2498               jjtree.clearNodeScope(jjtn005);
2499               jjtc005 = false;
2500             } else {
2501               jjtree.popNode();
2502             }
2503             if (jjte005 instanceof ParseException) {
2504               throw (ParseException)jjte005;
2505             }
2506             if (jjte005 instanceof RuntimeException) {
2507               throw (RuntimeException)jjte005;
2508             }
2509             throw (Error)jjte005;
2510         } finally {
2511 if (jjtc005) {
2512               jjtree.closeNodeScope(jjtn005,  2);
2513               if (jjtree.nodeCreated()) {
2514                jjtreeCloseNodeScope(jjtn005);
2515               }
2516               jjtn005.jjtSetLastToken(getToken(0));
2517             }
2518         }
2519         break;
2520         }
2521       case rne:{
2522         jj_consume_token(rne);
2523 ASTNRNode jjtn006 = new ASTNRNode(JJTNRNODE);
2524             boolean jjtc006 = true;
2525             jjtree.openNodeScope(jjtn006);
2526             jjtreeOpenNodeScope(jjtn006);
2527             jjtn006.jjtSetFirstToken(getToken(1));
2528         try {
2529           ShiftExpression();
2530         } catch (Throwable jjte006) {
2531 if (jjtc006) {
2532               jjtree.clearNodeScope(jjtn006);
2533               jjtc006 = false;
2534             } else {
2535               jjtree.popNode();
2536             }
2537             if (jjte006 instanceof ParseException) {
2538               throw (ParseException)jjte006;
2539             }
2540             if (jjte006 instanceof RuntimeException) {
2541               throw (RuntimeException)jjte006;
2542             }
2543             throw (Error)jjte006;
2544         } finally {
2545 if (jjtc006) {
2546               jjtree.closeNodeScope(jjtn006,  2);
2547               if (jjtree.nodeCreated()) {
2548                jjtreeCloseNodeScope(jjtn006);
2549               }
2550               jjtn006.jjtSetLastToken(getToken(0));
2551             }
2552         }
2553         break;
2554         }
2555       case seq:{
2556         jj_consume_token(seq);
2557 ASTSWNode jjtn007 = new ASTSWNode(JJTSWNODE);
2558             boolean jjtc007 = true;
2559             jjtree.openNodeScope(jjtn007);
2560             jjtreeOpenNodeScope(jjtn007);
2561             jjtn007.jjtSetFirstToken(getToken(1));
2562         try {
2563           ShiftExpression();
2564         } catch (Throwable jjte007) {
2565 if (jjtc007) {
2566               jjtree.clearNodeScope(jjtn007);
2567               jjtc007 = false;
2568             } else {
2569               jjtree.popNode();
2570             }
2571             if (jjte007 instanceof ParseException) {
2572               throw (ParseException)jjte007;
2573             }
2574             if (jjte007 instanceof RuntimeException) {
2575               throw (RuntimeException)jjte007;
2576             }
2577             throw (Error)jjte007;
2578         } finally {
2579 if (jjtc007) {
2580               jjtree.closeNodeScope(jjtn007,  2);
2581               if (jjtree.nodeCreated()) {
2582                jjtreeCloseNodeScope(jjtn007);
2583               }
2584               jjtn007.jjtSetLastToken(getToken(0));
2585             }
2586         }
2587         break;
2588         }
2589       case sne:{
2590         jj_consume_token(sne);
2591 ASTNSWNode jjtn008 = new ASTNSWNode(JJTNSWNODE);
2592             boolean jjtc008 = true;
2593             jjtree.openNodeScope(jjtn008);
2594             jjtreeOpenNodeScope(jjtn008);
2595             jjtn008.jjtSetFirstToken(getToken(1));
2596         try {
2597           ShiftExpression();
2598         } catch (Throwable jjte008) {
2599 if (jjtc008) {
2600               jjtree.clearNodeScope(jjtn008);
2601               jjtc008 = false;
2602             } else {
2603               jjtree.popNode();
2604             }
2605             if (jjte008 instanceof ParseException) {
2606               throw (ParseException)jjte008;
2607             }
2608             if (jjte008 instanceof RuntimeException) {
2609               throw (RuntimeException)jjte008;
2610             }
2611             throw (Error)jjte008;
2612         } finally {
2613 if (jjtc008) {
2614               jjtree.closeNodeScope(jjtn008,  2);
2615               if (jjtree.nodeCreated()) {
2616                jjtreeCloseNodeScope(jjtn008);
2617               }
2618               jjtn008.jjtSetLastToken(getToken(0));
2619             }
2620         }
2621         break;
2622         }
2623       case eeq:{
2624         jj_consume_token(eeq);
2625 ASTEWNode jjtn009 = new ASTEWNode(JJTEWNODE);
2626             boolean jjtc009 = true;
2627             jjtree.openNodeScope(jjtn009);
2628             jjtreeOpenNodeScope(jjtn009);
2629             jjtn009.jjtSetFirstToken(getToken(1));
2630         try {
2631           ShiftExpression();
2632         } catch (Throwable jjte009) {
2633 if (jjtc009) {
2634               jjtree.clearNodeScope(jjtn009);
2635               jjtc009 = false;
2636             } else {
2637               jjtree.popNode();
2638             }
2639             if (jjte009 instanceof ParseException) {
2640               throw (ParseException)jjte009;
2641             }
2642             if (jjte009 instanceof RuntimeException) {
2643               throw (RuntimeException)jjte009;
2644             }
2645             throw (Error)jjte009;
2646         } finally {
2647 if (jjtc009) {
2648               jjtree.closeNodeScope(jjtn009,  2);
2649               if (jjtree.nodeCreated()) {
2650                jjtreeCloseNodeScope(jjtn009);
2651               }
2652               jjtn009.jjtSetLastToken(getToken(0));
2653             }
2654         }
2655         break;
2656         }
2657       case ene:{
2658         jj_consume_token(ene);
2659 ASTNEWNode jjtn010 = new ASTNEWNode(JJTNEWNODE);
2660             boolean jjtc010 = true;
2661             jjtree.openNodeScope(jjtn010);
2662             jjtreeOpenNodeScope(jjtn010);
2663             jjtn010.jjtSetFirstToken(getToken(1));
2664         try {
2665           ShiftExpression();
2666         } catch (Throwable jjte010) {
2667 if (jjtc010) {
2668               jjtree.clearNodeScope(jjtn010);
2669               jjtc010 = false;
2670             } else {
2671               jjtree.popNode();
2672             }
2673             if (jjte010 instanceof ParseException) {
2674               throw (ParseException)jjte010;
2675             }
2676             if (jjte010 instanceof RuntimeException) {
2677               throw (RuntimeException)jjte010;
2678             }
2679             throw (Error)jjte010;
2680         } finally {
2681 if (jjtc010) {
2682               jjtree.closeNodeScope(jjtn010,  2);
2683               if (jjtree.nodeCreated()) {
2684                jjtreeCloseNodeScope(jjtn010);
2685               }
2686               jjtn010.jjtSetLastToken(getToken(0));
2687             }
2688         }
2689         break;
2690         }
2691       default:
2692         jj_consume_token(-1);
2693         throw new ParseException();
2694       }
2695     } else {
2696       ;
2697     }
2698 }
2699 
2700 /***************************************
2701  *      Arithmetic
2702  ***************************************/
2703   final public void ShiftExpression() throws ParseException {
2704     AdditiveExpression();
2705     label_16:
2706     while (true) {
2707       if (jj_2_52(2)) {
2708       } else {
2709         break label_16;
2710       }
2711       switch (jj_nt.kind) {
2712       case lshift:{
2713         jj_consume_token(lshift);
2714 ASTShiftLeftNode jjtn001 = new ASTShiftLeftNode(JJTSHIFTLEFTNODE);
2715                  boolean jjtc001 = true;
2716                  jjtree.openNodeScope(jjtn001);
2717                  jjtreeOpenNodeScope(jjtn001);
2718                  jjtn001.jjtSetFirstToken(getToken(1));
2719         try {
2720           AdditiveExpression();
2721         } catch (Throwable jjte001) {
2722 if (jjtc001) {
2723                    jjtree.clearNodeScope(jjtn001);
2724                    jjtc001 = false;
2725                  } else {
2726                    jjtree.popNode();
2727                  }
2728                  if (jjte001 instanceof ParseException) {
2729                    throw (ParseException)jjte001;
2730                  }
2731                  if (jjte001 instanceof RuntimeException) {
2732                    throw (RuntimeException)jjte001;
2733                  }
2734                  throw (Error)jjte001;
2735         } finally {
2736 if (jjtc001) {
2737                    jjtree.closeNodeScope(jjtn001,  2);
2738                    if (jjtree.nodeCreated()) {
2739                     jjtreeCloseNodeScope(jjtn001);
2740                    }
2741                    jjtn001.jjtSetLastToken(getToken(0));
2742                  }
2743         }
2744         break;
2745         }
2746       case rshift:{
2747         jj_consume_token(rshift);
2748 ASTShiftRightNode jjtn002 = new ASTShiftRightNode(JJTSHIFTRIGHTNODE);
2749                  boolean jjtc002 = true;
2750                  jjtree.openNodeScope(jjtn002);
2751                  jjtreeOpenNodeScope(jjtn002);
2752                  jjtn002.jjtSetFirstToken(getToken(1));
2753         try {
2754           AdditiveExpression();
2755         } catch (Throwable jjte002) {
2756 if (jjtc002) {
2757                    jjtree.clearNodeScope(jjtn002);
2758                    jjtc002 = false;
2759                  } else {
2760                    jjtree.popNode();
2761                  }
2762                  if (jjte002 instanceof ParseException) {
2763                    throw (ParseException)jjte002;
2764                  }
2765                  if (jjte002 instanceof RuntimeException) {
2766                    throw (RuntimeException)jjte002;
2767                  }
2768                  throw (Error)jjte002;
2769         } finally {
2770 if (jjtc002) {
2771                    jjtree.closeNodeScope(jjtn002,  2);
2772                    if (jjtree.nodeCreated()) {
2773                     jjtreeCloseNodeScope(jjtn002);
2774                    }
2775                    jjtn002.jjtSetLastToken(getToken(0));
2776                  }
2777         }
2778         break;
2779         }
2780       case rshiftu:{
2781         jj_consume_token(rshiftu);
2782 ASTShiftRightUnsignedNode jjtn003 = new ASTShiftRightUnsignedNode(JJTSHIFTRIGHTUNSIGNEDNODE);
2783                   boolean jjtc003 = true;
2784                   jjtree.openNodeScope(jjtn003);
2785                   jjtreeOpenNodeScope(jjtn003);
2786                   jjtn003.jjtSetFirstToken(getToken(1));
2787         try {
2788           AdditiveExpression();
2789         } catch (Throwable jjte003) {
2790 if (jjtc003) {
2791                     jjtree.clearNodeScope(jjtn003);
2792                     jjtc003 = false;
2793                   } else {
2794                     jjtree.popNode();
2795                   }
2796                   if (jjte003 instanceof ParseException) {
2797                     throw (ParseException)jjte003;
2798                   }
2799                   if (jjte003 instanceof RuntimeException) {
2800                     throw (RuntimeException)jjte003;
2801                   }
2802                   throw (Error)jjte003;
2803         } finally {
2804 if (jjtc003) {
2805                     jjtree.closeNodeScope(jjtn003,  2);
2806                     if (jjtree.nodeCreated()) {
2807                      jjtreeCloseNodeScope(jjtn003);
2808                     }
2809                     jjtn003.jjtSetLastToken(getToken(0));
2810                   }
2811         }
2812         break;
2813         }
2814       default:
2815         jj_consume_token(-1);
2816         throw new ParseException();
2817       }
2818     }
2819 }
2820 
2821   final public void AdditiveExpression() throws ParseException {
2822     MultiplicativeExpression();
2823     label_17:
2824     while (true) {
2825       if (jj_2_53(2)) {
2826       } else {
2827         break label_17;
2828       }
2829       switch (jj_nt.kind) {
2830       case plus:{
2831         jj_consume_token(plus);
2832 ASTAddNode jjtn001 = new ASTAddNode(JJTADDNODE);
2833              boolean jjtc001 = true;
2834              jjtree.openNodeScope(jjtn001);
2835              jjtreeOpenNodeScope(jjtn001);
2836              jjtn001.jjtSetFirstToken(getToken(1));
2837         try {
2838           MultiplicativeExpression();
2839         } catch (Throwable jjte001) {
2840 if (jjtc001) {
2841                jjtree.clearNodeScope(jjtn001);
2842                jjtc001 = false;
2843              } else {
2844                jjtree.popNode();
2845              }
2846              if (jjte001 instanceof ParseException) {
2847                throw (ParseException)jjte001;
2848              }
2849              if (jjte001 instanceof RuntimeException) {
2850                throw (RuntimeException)jjte001;
2851              }
2852              throw (Error)jjte001;
2853         } finally {
2854 if (jjtc001) {
2855                jjtree.closeNodeScope(jjtn001,  2);
2856                if (jjtree.nodeCreated()) {
2857                 jjtreeCloseNodeScope(jjtn001);
2858                }
2859                jjtn001.jjtSetLastToken(getToken(0));
2860              }
2861         }
2862         break;
2863         }
2864       case minus:{
2865         jj_consume_token(minus);
2866 ASTSubNode jjtn002 = new ASTSubNode(JJTSUBNODE);
2867               boolean jjtc002 = true;
2868               jjtree.openNodeScope(jjtn002);
2869               jjtreeOpenNodeScope(jjtn002);
2870               jjtn002.jjtSetFirstToken(getToken(1));
2871         try {
2872           MultiplicativeExpression();
2873         } catch (Throwable jjte002) {
2874 if (jjtc002) {
2875                 jjtree.clearNodeScope(jjtn002);
2876                 jjtc002 = false;
2877               } else {
2878                 jjtree.popNode();
2879               }
2880               if (jjte002 instanceof ParseException) {
2881                 throw (ParseException)jjte002;
2882               }
2883               if (jjte002 instanceof RuntimeException) {
2884                 throw (RuntimeException)jjte002;
2885               }
2886               throw (Error)jjte002;
2887         } finally {
2888 if (jjtc002) {
2889                 jjtree.closeNodeScope(jjtn002,  2);
2890                 if (jjtree.nodeCreated()) {
2891                  jjtreeCloseNodeScope(jjtn002);
2892                 }
2893                 jjtn002.jjtSetLastToken(getToken(0));
2894               }
2895         }
2896         break;
2897         }
2898       default:
2899         jj_consume_token(-1);
2900         throw new ParseException();
2901       }
2902     }
2903 }
2904 
2905   final public void MultiplicativeExpression() throws ParseException {
2906     UnaryExpression();
2907     label_18:
2908     while (true) {
2909       if (jj_2_54(2)) {
2910       } else {
2911         break label_18;
2912       }
2913       switch (jj_nt.kind) {
2914       case mult:{
2915         jj_consume_token(mult);
2916 ASTMulNode jjtn001 = new ASTMulNode(JJTMULNODE);
2917              boolean jjtc001 = true;
2918              jjtree.openNodeScope(jjtn001);
2919              jjtreeOpenNodeScope(jjtn001);
2920              jjtn001.jjtSetFirstToken(getToken(1));
2921         try {
2922           UnaryExpression();
2923         } catch (Throwable jjte001) {
2924 if (jjtc001) {
2925                jjtree.clearNodeScope(jjtn001);
2926                jjtc001 = false;
2927              } else {
2928                jjtree.popNode();
2929              }
2930              if (jjte001 instanceof ParseException) {
2931                throw (ParseException)jjte001;
2932              }
2933              if (jjte001 instanceof RuntimeException) {
2934                throw (RuntimeException)jjte001;
2935              }
2936              throw (Error)jjte001;
2937         } finally {
2938 if (jjtc001) {
2939                jjtree.closeNodeScope(jjtn001,  2);
2940                if (jjtree.nodeCreated()) {
2941                 jjtreeCloseNodeScope(jjtn001);
2942                }
2943                jjtn001.jjtSetLastToken(getToken(0));
2944              }
2945         }
2946         break;
2947         }
2948       case div:
2949       case DIV:{
2950         switch (jj_nt.kind) {
2951         case div:{
2952           jj_consume_token(div);
2953           break;
2954           }
2955         case DIV:{
2956           jj_consume_token(DIV);
2957           break;
2958           }
2959         default:
2960           jj_consume_token(-1);
2961           throw new ParseException();
2962         }
2963 ASTDivNode jjtn002 = new ASTDivNode(JJTDIVNODE);
2964                     boolean jjtc002 = true;
2965                     jjtree.openNodeScope(jjtn002);
2966                     jjtreeOpenNodeScope(jjtn002);
2967                     jjtn002.jjtSetFirstToken(getToken(1));
2968         try {
2969           UnaryExpression();
2970         } catch (Throwable jjte002) {
2971 if (jjtc002) {
2972                       jjtree.clearNodeScope(jjtn002);
2973                       jjtc002 = false;
2974                     } else {
2975                       jjtree.popNode();
2976                     }
2977                     if (jjte002 instanceof ParseException) {
2978                       throw (ParseException)jjte002;
2979                     }
2980                     if (jjte002 instanceof RuntimeException) {
2981                       throw (RuntimeException)jjte002;
2982                     }
2983                     throw (Error)jjte002;
2984         } finally {
2985 if (jjtc002) {
2986                       jjtree.closeNodeScope(jjtn002,  2);
2987                       if (jjtree.nodeCreated()) {
2988                        jjtreeCloseNodeScope(jjtn002);
2989                       }
2990                       jjtn002.jjtSetLastToken(getToken(0));
2991                     }
2992         }
2993         break;
2994         }
2995       case mod:
2996       case MOD:{
2997         switch (jj_nt.kind) {
2998         case mod:{
2999           jj_consume_token(mod);
3000           break;
3001           }
3002         case MOD:{
3003           jj_consume_token(MOD);
3004           break;
3005           }
3006         default:
3007           jj_consume_token(-1);
3008           throw new ParseException();
3009         }
3010 ASTModNode jjtn003 = new ASTModNode(JJTMODNODE);
3011                     boolean jjtc003 = true;
3012                     jjtree.openNodeScope(jjtn003);
3013                     jjtreeOpenNodeScope(jjtn003);
3014                     jjtn003.jjtSetFirstToken(getToken(1));
3015         try {
3016           UnaryExpression();
3017         } catch (Throwable jjte003) {
3018 if (jjtc003) {
3019                       jjtree.clearNodeScope(jjtn003);
3020                       jjtc003 = false;
3021                     } else {
3022                       jjtree.popNode();
3023                     }
3024                     if (jjte003 instanceof ParseException) {
3025                       throw (ParseException)jjte003;
3026                     }
3027                     if (jjte003 instanceof RuntimeException) {
3028                       throw (RuntimeException)jjte003;
3029                     }
3030                     throw (Error)jjte003;
3031         } finally {
3032 if (jjtc003) {
3033                       jjtree.closeNodeScope(jjtn003,  2);
3034                       if (jjtree.nodeCreated()) {
3035                        jjtreeCloseNodeScope(jjtn003);
3036                       }
3037                       jjtn003.jjtSetLastToken(getToken(0));
3038                     }
3039         }
3040         break;
3041         }
3042       default:
3043         jj_consume_token(-1);
3044         throw new ParseException();
3045       }
3046     }
3047 }
3048 
3049   final public void UnaryExpression() throws ParseException {
3050     switch (jj_nt.kind) {
3051     case minus:{
3052       jj_consume_token(minus);
3053 ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(JJTUNARYMINUSNODE);
3054               boolean jjtc001 = true;
3055               jjtree.openNodeScope(jjtn001);
3056               jjtreeOpenNodeScope(jjtn001);
3057               jjtn001.jjtSetFirstToken(getToken(1));
3058       try {
3059         UnaryExpression();
3060       } catch (Throwable jjte001) {
3061 if (jjtc001) {
3062                 jjtree.clearNodeScope(jjtn001);
3063                 jjtc001 = false;
3064               } else {
3065                 jjtree.popNode();
3066               }
3067               if (jjte001 instanceof ParseException) {
3068                 throw (ParseException)jjte001;
3069               }
3070               if (jjte001 instanceof RuntimeException) {
3071                 throw (RuntimeException)jjte001;
3072               }
3073               throw (Error)jjte001;
3074       } finally {
3075 if (jjtc001) {
3076                 jjtree.closeNodeScope(jjtn001,  1);
3077                 if (jjtree.nodeCreated()) {
3078                  jjtreeCloseNodeScope(jjtn001);
3079                 }
3080                 jjtn001.jjtSetLastToken(getToken(0));
3081               }
3082       }
3083       break;
3084       }
3085     case plus:{
3086       jj_consume_token(plus);
3087 ASTUnaryPlusNode jjtn002 = new ASTUnaryPlusNode(JJTUNARYPLUSNODE);
3088              boolean jjtc002 = true;
3089              jjtree.openNodeScope(jjtn002);
3090              jjtreeOpenNodeScope(jjtn002);
3091              jjtn002.jjtSetFirstToken(getToken(1));
3092       try {
3093         UnaryExpression();
3094       } catch (Throwable jjte002) {
3095 if (jjtc002) {
3096                jjtree.clearNodeScope(jjtn002);
3097                jjtc002 = false;
3098              } else {
3099                jjtree.popNode();
3100              }
3101              if (jjte002 instanceof ParseException) {
3102                throw (ParseException)jjte002;
3103              }
3104              if (jjte002 instanceof RuntimeException) {
3105                throw (RuntimeException)jjte002;
3106              }
3107              throw (Error)jjte002;
3108       } finally {
3109 if (jjtc002) {
3110                jjtree.closeNodeScope(jjtn002,  1);
3111                if (jjtree.nodeCreated()) {
3112                 jjtreeCloseNodeScope(jjtn002);
3113                }
3114                jjtn002.jjtSetLastToken(getToken(0));
3115              }
3116       }
3117       break;
3118       }
3119     case tilda:{
3120       jj_consume_token(tilda);
3121 ASTBitwiseComplNode jjtn003 = new ASTBitwiseComplNode(JJTBITWISECOMPLNODE);
3122               boolean jjtc003 = true;
3123               jjtree.openNodeScope(jjtn003);
3124               jjtreeOpenNodeScope(jjtn003);
3125               jjtn003.jjtSetFirstToken(getToken(1));
3126       try {
3127         UnaryExpression();
3128       } catch (Throwable jjte003) {
3129 if (jjtc003) {
3130                 jjtree.clearNodeScope(jjtn003);
3131                 jjtc003 = false;
3132               } else {
3133                 jjtree.popNode();
3134               }
3135               if (jjte003 instanceof ParseException) {
3136                 throw (ParseException)jjte003;
3137               }
3138               if (jjte003 instanceof RuntimeException) {
3139                 throw (RuntimeException)jjte003;
3140               }
3141               throw (Error)jjte003;
3142       } finally {
3143 if (jjtc003) {
3144                 jjtree.closeNodeScope(jjtn003,  1);
3145                 if (jjtree.nodeCreated()) {
3146                  jjtreeCloseNodeScope(jjtn003);
3147                 }
3148                 jjtn003.jjtSetLastToken(getToken(0));
3149               }
3150       }
3151       break;
3152       }
3153     case not:
3154     case NOT:{
3155       switch (jj_nt.kind) {
3156       case not:{
3157         jj_consume_token(not);
3158         break;
3159         }
3160       case NOT:{
3161         jj_consume_token(NOT);
3162         break;
3163         }
3164       default:
3165         jj_consume_token(-1);
3166         throw new ParseException();
3167       }
3168 ASTNotNode jjtn004 = new ASTNotNode(JJTNOTNODE);
3169                     boolean jjtc004 = true;
3170                     jjtree.openNodeScope(jjtn004);
3171                     jjtreeOpenNodeScope(jjtn004);
3172                     jjtn004.jjtSetFirstToken(getToken(1));
3173       try {
3174         UnaryExpression();
3175       } catch (Throwable jjte004) {
3176 if (jjtc004) {
3177                       jjtree.clearNodeScope(jjtn004);
3178                       jjtc004 = false;
3179                     } else {
3180                       jjtree.popNode();
3181                     }
3182                     if (jjte004 instanceof ParseException) {
3183                       throw (ParseException)jjte004;
3184                     }
3185                     if (jjte004 instanceof RuntimeException) {
3186                       throw (RuntimeException)jjte004;
3187                     }
3188                     throw (Error)jjte004;
3189       } finally {
3190 if (jjtc004) {
3191                       jjtree.closeNodeScope(jjtn004,  1);
3192                       if (jjtree.nodeCreated()) {
3193                        jjtreeCloseNodeScope(jjtn004);
3194                       }
3195                       jjtn004.jjtSetLastToken(getToken(0));
3196                     }
3197       }
3198       break;
3199       }
3200     case EMPTY:{
3201       jj_consume_token(EMPTY);
3202 ASTEmptyFunction jjtn005 = new ASTEmptyFunction(JJTEMPTYFUNCTION);
3203               boolean jjtc005 = true;
3204               jjtree.openNodeScope(jjtn005);
3205               jjtreeOpenNodeScope(jjtn005);
3206               jjtn005.jjtSetFirstToken(getToken(1));
3207       try {
3208         UnaryExpression();
3209       } catch (Throwable jjte005) {
3210 if (jjtc005) {
3211                 jjtree.clearNodeScope(jjtn005);
3212                 jjtc005 = false;
3213               } else {
3214                 jjtree.popNode();
3215               }
3216               if (jjte005 instanceof ParseException) {
3217                 throw (ParseException)jjte005;
3218               }
3219               if (jjte005 instanceof RuntimeException) {
3220                 throw (RuntimeException)jjte005;
3221               }
3222               throw (Error)jjte005;
3223       } finally {
3224 if (jjtc005) {
3225                 jjtree.closeNodeScope(jjtn005,  1);
3226                 if (jjtree.nodeCreated()) {
3227                  jjtreeCloseNodeScope(jjtn005);
3228                 }
3229                 jjtn005.jjtSetLastToken(getToken(0));
3230               }
3231       }
3232       break;
3233       }
3234     case SIZE:{
3235       jj_consume_token(SIZE);
3236 ASTSizeFunction jjtn006 = new ASTSizeFunction(JJTSIZEFUNCTION);
3237              boolean jjtc006 = true;
3238              jjtree.openNodeScope(jjtn006);
3239              jjtreeOpenNodeScope(jjtn006);
3240              jjtn006.jjtSetFirstToken(getToken(1));
3241       try {
3242         UnaryExpression();
3243       } catch (Throwable jjte006) {
3244 if (jjtc006) {
3245                jjtree.clearNodeScope(jjtn006);
3246                jjtc006 = false;
3247              } else {
3248                jjtree.popNode();
3249              }
3250              if (jjte006 instanceof ParseException) {
3251                throw (ParseException)jjte006;
3252              }
3253              if (jjte006 instanceof RuntimeException) {
3254                throw (RuntimeException)jjte006;
3255              }
3256              throw (Error)jjte006;
3257       } finally {
3258 if (jjtc006) {
3259                jjtree.closeNodeScope(jjtn006,  1);
3260                if (jjtree.nodeCreated()) {
3261                 jjtreeCloseNodeScope(jjtn006);
3262                }
3263                jjtn006.jjtSetLastToken(getToken(0));
3264              }
3265       }
3266       break;
3267       }
3268     case minusminus:{
3269       jj_consume_token(minusminus);
3270 ASTDecrementGetNode jjtn007 = new ASTDecrementGetNode(JJTDECREMENTGETNODE);
3271                   boolean jjtc007 = true;
3272                   jjtree.openNodeScope(jjtn007);
3273                   jjtreeOpenNodeScope(jjtn007);
3274                   jjtn007.jjtSetFirstToken(getToken(1));
3275       try {
3276         UnaryExpression();
3277       } catch (Throwable jjte007) {
3278 if (jjtc007) {
3279                     jjtree.clearNodeScope(jjtn007);
3280                     jjtc007 = false;
3281                   } else {
3282                     jjtree.popNode();
3283                   }
3284                   if (jjte007 instanceof ParseException) {
3285                     throw (ParseException)jjte007;
3286                   }
3287                   if (jjte007 instanceof RuntimeException) {
3288                     throw (RuntimeException)jjte007;
3289                   }
3290                   throw (Error)jjte007;
3291       } finally {
3292 if (jjtc007) {
3293                     jjtree.closeNodeScope(jjtn007,  1);
3294                     if (jjtree.nodeCreated()) {
3295                      jjtreeCloseNodeScope(jjtn007);
3296                     }
3297                     jjtn007.jjtSetLastToken(getToken(0));
3298                   }
3299       }
3300       break;
3301       }
3302     case plusplus:{
3303       jj_consume_token(plusplus);
3304 ASTIncrementGetNode jjtn008 = new ASTIncrementGetNode(JJTINCREMENTGETNODE);
3305                 boolean jjtc008 = true;
3306                 jjtree.openNodeScope(jjtn008);
3307                 jjtreeOpenNodeScope(jjtn008);
3308                 jjtn008.jjtSetFirstToken(getToken(1));
3309       try {
3310         UnaryExpression();
3311       } catch (Throwable jjte008) {
3312 if (jjtc008) {
3313                   jjtree.clearNodeScope(jjtn008);
3314                   jjtc008 = false;
3315                 } else {
3316                   jjtree.popNode();
3317                 }
3318                 if (jjte008 instanceof ParseException) {
3319                   throw (ParseException)jjte008;
3320                 }
3321                 if (jjte008 instanceof RuntimeException) {
3322                   throw (RuntimeException)jjte008;
3323                 }
3324                 throw (Error)jjte008;
3325       } finally {
3326 if (jjtc008) {
3327                   jjtree.closeNodeScope(jjtn008,  1);
3328                   if (jjtree.nodeCreated()) {
3329                    jjtreeCloseNodeScope(jjtn008);
3330                   }
3331                   jjtn008.jjtSetLastToken(getToken(0));
3332                 }
3333       }
3334       break;
3335       }
3336     default:
3337       if (jj_2_55(1)) {
3338         PostfixExpression();
3339       } else {
3340         jj_consume_token(-1);
3341         throw new ParseException();
3342       }
3343     }
3344 }
3345 
3346   final public void PostfixOperator() throws ParseException {
3347     switch (jj_nt.kind) {
3348     case plusplus:{
3349 ASTGetIncrementNode jjtn001 = new ASTGetIncrementNode(JJTGETINCREMENTNODE);
3350       boolean jjtc001 = true;
3351       jjtree.openNodeScope(jjtn001);
3352       jjtreeOpenNodeScope(jjtn001);
3353       jjtn001.jjtSetFirstToken(getToken(1));
3354       try {
3355         jj_consume_token(plusplus);
3356       } finally {
3357 if (jjtc001) {
3358         jjtree.closeNodeScope(jjtn001,  1);
3359         if (jjtree.nodeCreated()) {
3360          jjtreeCloseNodeScope(jjtn001);
3361         }
3362         jjtn001.jjtSetLastToken(getToken(0));
3363       }
3364       }
3365       break;
3366       }
3367     case minusminus:{
3368 ASTGetDecrementNode jjtn002 = new ASTGetDecrementNode(JJTGETDECREMENTNODE);
3369       boolean jjtc002 = true;
3370       jjtree.openNodeScope(jjtn002);
3371       jjtreeOpenNodeScope(jjtn002);
3372       jjtn002.jjtSetFirstToken(getToken(1));
3373       try {
3374         jj_consume_token(minusminus);
3375       } finally {
3376 if (jjtc002) {
3377         jjtree.closeNodeScope(jjtn002,  1);
3378         if (jjtree.nodeCreated()) {
3379          jjtreeCloseNodeScope(jjtn002);
3380         }
3381         jjtn002.jjtSetLastToken(getToken(0));
3382       }
3383       }
3384       break;
3385       }
3386     default:
3387       jj_consume_token(-1);
3388       throw new ParseException();
3389     }
3390 }
3391 
3392   final public void PostfixExpression() throws ParseException {
3393     ValueExpression();
3394     switch (jj_nt.kind) {
3395     case plusplus:
3396     case minusminus:{
3397       PostfixOperator();
3398       break;
3399       }
3400     default:
3401       ;
3402     }
3403 }
3404 
3405 /***************************************
3406  *      Identifier & Literals
3407  ***************************************/
3408   final public 
3409 void Identifier(boolean top) throws ParseException {/*@bgen(jjtree) Identifier */
3410     ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER);
3411     boolean jjtc000 = true;
3412     jjtree.openNodeScope(jjtn000);
3413     jjtreeOpenNodeScope(jjtn000);
3414     jjtn000.jjtSetFirstToken(getToken(1));Token t;
3415     try {
3416       switch (jj_nt.kind) {
3417       case IDENTIFIER:{
3418         t = jj_consume_token(IDENTIFIER);
3419 jjtree.closeNodeScope(jjtn000, true);
3420                      jjtc000 = false;
3421                      if (jjtree.nodeCreated()) {
3422                       jjtreeCloseNodeScope(jjtn000);
3423                      }
3424                      jjtn000.jjtSetLastToken(getToken(0));
3425 jjtn000.setSymbol(top? checkVariable(jjtn000, t.image) : t.image);
3426         break;
3427         }
3428       case REGISTER:{
3429         t = jj_consume_token(REGISTER);
3430 jjtree.closeNodeScope(jjtn000, true);
3431                    jjtc000 = false;
3432                    if (jjtree.nodeCreated()) {
3433                     jjtreeCloseNodeScope(jjtn000);
3434                    }
3435                    jjtn000.jjtSetLastToken(getToken(0));
3436 if (!getFeatures().supportsRegister()) throwParsingException(t); jjtn000.setSymbol(t.image);
3437         break;
3438         }
3439       default:
3440         jj_consume_token(-1);
3441         throw new ParseException();
3442       }
3443     } finally {
3444 if (jjtc000) {
3445         jjtree.closeNodeScope(jjtn000, true);
3446         if (jjtree.nodeCreated()) {
3447          jjtreeCloseNodeScope(jjtn000);
3448         }
3449         jjtn000.jjtSetLastToken(getToken(0));
3450       }
3451     }
3452 }
3453 
3454   final public void NamespaceIdentifier() throws ParseException {/*@bgen(jjtree) NamespaceIdentifier */
3455     ASTNamespaceIdentifier jjtn000 = new ASTNamespaceIdentifier(JJTNAMESPACEIDENTIFIER);
3456     boolean jjtc000 = true;
3457     jjtree.openNodeScope(jjtn000);
3458     jjtreeOpenNodeScope(jjtn000);
3459     jjtn000.jjtSetFirstToken(getToken(1));Token ns;
3460     Token id;
3461     try {
3462       ns = jj_consume_token(IDENTIFIER);
3463       jj_consume_token(COLON);
3464       id = jj_consume_token(IDENTIFIER);
3465 jjtree.closeNodeScope(jjtn000, true);
3466                                              jjtc000 = false;
3467                                              if (jjtree.nodeCreated()) {
3468                                               jjtreeCloseNodeScope(jjtn000);
3469                                              }
3470                                              jjtn000.jjtSetLastToken(getToken(0));
3471 jjtn000.setNamespace(ns.image, id.image);
3472     } finally {
3473 if (jjtc000) {
3474        jjtree.closeNodeScope(jjtn000, true);
3475        if (jjtree.nodeCreated()) {
3476         jjtreeCloseNodeScope(jjtn000);
3477        }
3478        jjtn000.jjtSetLastToken(getToken(0));
3479      }
3480     }
3481 }
3482 
3483   final public void Literal() throws ParseException {Token t;
3484     switch (jj_nt.kind) {
3485     case INTEGER_LITERAL:{
3486       IntegerLiteral();
3487       break;
3488       }
3489     case FLOAT_LITERAL:{
3490       FloatLiteral();
3491       break;
3492       }
3493     case TRUE:
3494     case FALSE:{
3495       BooleanLiteral();
3496       break;
3497       }
3498     case JXLT_LITERAL:{
3499       JxltLiteral();
3500       break;
3501       }
3502     case STRING_LITERAL:{
3503       StringLiteral();
3504       break;
3505       }
3506     case REGEX_LITERAL:{
3507       RegexLiteral();
3508       break;
3509       }
3510     case NULL:{
3511       NullLiteral();
3512       break;
3513       }
3514     case NAN_LITERAL:{
3515       NaNLiteral();
3516       break;
3517       }
3518     default:
3519       jj_consume_token(-1);
3520       throw new ParseException();
3521     }
3522 }
3523 
3524   final public void NaNLiteral() throws ParseException {/*@bgen(jjtree) NumberLiteral */
3525   ASTNumberLiteral jjtn000 = new ASTNumberLiteral(JJTNUMBERLITERAL);
3526   boolean jjtc000 = true;
3527   jjtree.openNodeScope(jjtn000);
3528   jjtreeOpenNodeScope(jjtn000);
3529   jjtn000.jjtSetFirstToken(getToken(1));
3530     try {
3531       jj_consume_token(NAN_LITERAL);
3532 jjtree.closeNodeScope(jjtn000, true);
3533                     jjtc000 = false;
3534                     if (jjtree.nodeCreated()) {
3535                      jjtreeCloseNodeScope(jjtn000);
3536                     }
3537                     jjtn000.jjtSetLastToken(getToken(0));
3538 jjtn000.setReal("NaN");
3539     } finally {
3540 if (jjtc000) {
3541         jjtree.closeNodeScope(jjtn000, true);
3542         if (jjtree.nodeCreated()) {
3543          jjtreeCloseNodeScope(jjtn000);
3544         }
3545         jjtn000.jjtSetLastToken(getToken(0));
3546       }
3547     }
3548 }
3549 
3550   final public void NullLiteral() throws ParseException {/*@bgen(jjtree) NullLiteral */
3551   ASTNullLiteral jjtn000 = new ASTNullLiteral(JJTNULLLITERAL);
3552   boolean jjtc000 = true;
3553   jjtree.openNodeScope(jjtn000);
3554   jjtreeOpenNodeScope(jjtn000);
3555   jjtn000.jjtSetFirstToken(getToken(1));
3556     try {
3557       jj_consume_token(NULL);
3558     } finally {
3559 if (jjtc000) {
3560         jjtree.closeNodeScope(jjtn000, true);
3561         if (jjtree.nodeCreated()) {
3562          jjtreeCloseNodeScope(jjtn000);
3563         }
3564         jjtn000.jjtSetLastToken(getToken(0));
3565       }
3566     }
3567 }
3568 
3569   final public void BooleanLiteral() throws ParseException {
3570     switch (jj_nt.kind) {
3571     case TRUE:{
3572 ASTTrueNode jjtn001 = new ASTTrueNode(JJTTRUENODE);
3573     boolean jjtc001 = true;
3574     jjtree.openNodeScope(jjtn001);
3575     jjtreeOpenNodeScope(jjtn001);
3576     jjtn001.jjtSetFirstToken(getToken(1));
3577       try {
3578         jj_consume_token(TRUE);
3579       } finally {
3580 if (jjtc001) {
3581       jjtree.closeNodeScope(jjtn001, true);
3582       if (jjtree.nodeCreated()) {
3583        jjtreeCloseNodeScope(jjtn001);
3584       }
3585       jjtn001.jjtSetLastToken(getToken(0));
3586     }
3587       }
3588       break;
3589       }
3590     case FALSE:{
3591 ASTFalseNode jjtn002 = new ASTFalseNode(JJTFALSENODE);
3592     boolean jjtc002 = true;
3593     jjtree.openNodeScope(jjtn002);
3594     jjtreeOpenNodeScope(jjtn002);
3595     jjtn002.jjtSetFirstToken(getToken(1));
3596       try {
3597         jj_consume_token(FALSE);
3598       } finally {
3599 if (jjtc002) {
3600       jjtree.closeNodeScope(jjtn002, true);
3601       if (jjtree.nodeCreated()) {
3602        jjtreeCloseNodeScope(jjtn002);
3603       }
3604       jjtn002.jjtSetLastToken(getToken(0));
3605     }
3606       }
3607       break;
3608       }
3609     default:
3610       jj_consume_token(-1);
3611       throw new ParseException();
3612     }
3613 }
3614 
3615   final public void IntegerLiteral() throws ParseException {/*@bgen(jjtree) NumberLiteral */
3616   ASTNumberLiteral jjtn000 = new ASTNumberLiteral(JJTNUMBERLITERAL);
3617   boolean jjtc000 = true;
3618   jjtree.openNodeScope(jjtn000);
3619   jjtreeOpenNodeScope(jjtn000);
3620   jjtn000.jjtSetFirstToken(getToken(1));Token t;
3621     try {
3622       t = jj_consume_token(INTEGER_LITERAL);
3623 jjtree.closeNodeScope(jjtn000, true);
3624     jjtc000 = false;
3625     if (jjtree.nodeCreated()) {
3626      jjtreeCloseNodeScope(jjtn000);
3627     }
3628     jjtn000.jjtSetLastToken(getToken(0));
3629 jjtn000.setNatural(t.image);
3630     } finally {
3631 if (jjtc000) {
3632       jjtree.closeNodeScope(jjtn000, true);
3633       if (jjtree.nodeCreated()) {
3634        jjtreeCloseNodeScope(jjtn000);
3635       }
3636       jjtn000.jjtSetLastToken(getToken(0));
3637     }
3638     }
3639 }
3640 
3641   final public void FloatLiteral() throws ParseException {/*@bgen(jjtree) NumberLiteral */
3642   ASTNumberLiteral jjtn000 = new ASTNumberLiteral(JJTNUMBERLITERAL);
3643   boolean jjtc000 = true;
3644   jjtree.openNodeScope(jjtn000);
3645   jjtreeOpenNodeScope(jjtn000);
3646   jjtn000.jjtSetFirstToken(getToken(1));Token t;
3647     try {
3648       t = jj_consume_token(FLOAT_LITERAL);
3649 jjtree.closeNodeScope(jjtn000, true);
3650     jjtc000 = false;
3651     if (jjtree.nodeCreated()) {
3652      jjtreeCloseNodeScope(jjtn000);
3653     }
3654     jjtn000.jjtSetLastToken(getToken(0));
3655 jjtn000.setReal(t.image);
3656     } finally {
3657 if (jjtc000) {
3658       jjtree.closeNodeScope(jjtn000, true);
3659       if (jjtree.nodeCreated()) {
3660        jjtreeCloseNodeScope(jjtn000);
3661       }
3662       jjtn000.jjtSetLastToken(getToken(0));
3663     }
3664     }
3665 }
3666 
3667   final public void StringLiteral() throws ParseException {/*@bgen(jjtree) StringLiteral */
3668    ASTStringLiteral jjtn000 = new ASTStringLiteral(JJTSTRINGLITERAL);
3669    boolean jjtc000 = true;
3670    jjtree.openNodeScope(jjtn000);
3671    jjtreeOpenNodeScope(jjtn000);
3672    jjtn000.jjtSetFirstToken(getToken(1));Token t;
3673     try {
3674       t = jj_consume_token(STRING_LITERAL);
3675 jjtree.closeNodeScope(jjtn000, true);
3676     jjtc000 = false;
3677     if (jjtree.nodeCreated()) {
3678      jjtreeCloseNodeScope(jjtn000);
3679     }
3680     jjtn000.jjtSetLastToken(getToken(0));
3681 jjtn000.setLiteral(Parser.buildString(t.image, true));
3682     } finally {
3683 if (jjtc000) {
3684       jjtree.closeNodeScope(jjtn000, true);
3685       if (jjtree.nodeCreated()) {
3686        jjtreeCloseNodeScope(jjtn000);
3687       }
3688       jjtn000.jjtSetLastToken(getToken(0));
3689     }
3690     }
3691 }
3692 
3693   final public void JxltLiteral() throws ParseException {/*@bgen(jjtree) JxltLiteral */
3694    ASTJxltLiteral jjtn000 = new ASTJxltLiteral(JJTJXLTLITERAL);
3695    boolean jjtc000 = true;
3696    jjtree.openNodeScope(jjtn000);
3697    jjtreeOpenNodeScope(jjtn000);
3698    jjtn000.jjtSetFirstToken(getToken(1));Token t;
3699     try {
3700       t = jj_consume_token(JXLT_LITERAL);
3701 jjtree.closeNodeScope(jjtn000, true);
3702      jjtc000 = false;
3703      if (jjtree.nodeCreated()) {
3704       jjtreeCloseNodeScope(jjtn000);
3705      }
3706      jjtn000.jjtSetLastToken(getToken(0));
3707 jjtn000.setLiteral(Parser.buildString(t.image, true));
3708     } finally {
3709 if (jjtc000) {
3710        jjtree.closeNodeScope(jjtn000, true);
3711        if (jjtree.nodeCreated()) {
3712         jjtreeCloseNodeScope(jjtn000);
3713        }
3714        jjtn000.jjtSetLastToken(getToken(0));
3715      }
3716     }
3717 }
3718 
3719   final public void RegexLiteral() throws ParseException {/*@bgen(jjtree) RegexLiteral */
3720    ASTRegexLiteral jjtn000 = new ASTRegexLiteral(JJTREGEXLITERAL);
3721    boolean jjtc000 = true;
3722    jjtree.openNodeScope(jjtn000);
3723    jjtreeOpenNodeScope(jjtn000);
3724    jjtn000.jjtSetFirstToken(getToken(1));Token t;
3725     try {
3726       t = jj_consume_token(REGEX_LITERAL);
3727 jjtree.closeNodeScope(jjtn000, true);
3728     jjtc000 = false;
3729     if (jjtree.nodeCreated()) {
3730      jjtreeCloseNodeScope(jjtn000);
3731     }
3732     jjtn000.jjtSetLastToken(getToken(0));
3733 jjtn000.setLiteral(Parser.buildRegex(t.image));
3734     } finally {
3735 if (jjtc000) {
3736       jjtree.closeNodeScope(jjtn000, true);
3737       if (jjtree.nodeCreated()) {
3738        jjtreeCloseNodeScope(jjtn000);
3739       }
3740       jjtn000.jjtSetLastToken(getToken(0));
3741     }
3742     }
3743 }
3744 
3745   final public void ExtendedLiteral() throws ParseException {/*@bgen(jjtree) ExtendedLiteral */
3746   ASTExtendedLiteral jjtn000 = new ASTExtendedLiteral(JJTEXTENDEDLITERAL);
3747   boolean jjtc000 = true;
3748   jjtree.openNodeScope(jjtn000);
3749   jjtreeOpenNodeScope(jjtn000);
3750   jjtn000.jjtSetFirstToken(getToken(1));
3751     try {
3752       jj_consume_token(ELIPSIS);
3753     } finally {
3754 if (jjtc000) {
3755        jjtree.closeNodeScope(jjtn000, true);
3756        if (jjtree.nodeCreated()) {
3757         jjtreeCloseNodeScope(jjtn000);
3758        }
3759        jjtn000.jjtSetLastToken(getToken(0));
3760      }
3761     }
3762 }
3763 
3764   final public void ArrayLiteral() throws ParseException {/*@bgen(jjtree) ArrayLiteral */
3765   ASTArrayLiteral jjtn000 = new ASTArrayLiteral(JJTARRAYLITERAL);
3766   boolean jjtc000 = true;
3767   jjtree.openNodeScope(jjtn000);
3768   jjtreeOpenNodeScope(jjtn000);
3769   jjtn000.jjtSetFirstToken(getToken(1));
3770     try {
3771       jj_consume_token(LBRACKET);
3772       switch (jj_nt.kind) {
3773       case ELIPSIS:{
3774         ExtendedLiteral();
3775         break;
3776         }
3777       default:
3778         if (jj_2_57(1)) {
3779           Expression();
3780           label_19:
3781           while (true) {
3782             if (jj_2_56(2)) {
3783             } else {
3784               break label_19;
3785             }
3786             jj_consume_token(COMMA);
3787             Expression();
3788           }
3789         } else {
3790           ;
3791         }
3792         switch (jj_nt.kind) {
3793         case COMMA:{
3794           jj_consume_token(COMMA);
3795           ExtendedLiteral();
3796           break;
3797           }
3798         default:
3799           ;
3800         }
3801       }
3802       jj_consume_token(RBRACKET);
3803     } catch (Throwable jjte000) {
3804 if (jjtc000) {
3805        jjtree.clearNodeScope(jjtn000);
3806        jjtc000 = false;
3807      } else {
3808        jjtree.popNode();
3809      }
3810      if (jjte000 instanceof ParseException) {
3811        throw (ParseException)jjte000;
3812      }
3813      if (jjte000 instanceof RuntimeException) {
3814        throw (RuntimeException)jjte000;
3815      }
3816      throw (Error)jjte000;
3817     } finally {
3818 if (jjtc000) {
3819        jjtree.closeNodeScope(jjtn000, true);
3820        if (jjtree.nodeCreated()) {
3821         jjtreeCloseNodeScope(jjtn000);
3822        }
3823        jjtn000.jjtSetLastToken(getToken(0));
3824      }
3825     }
3826 }
3827 
3828   final public void MapLiteral() throws ParseException {/*@bgen(jjtree) MapLiteral */
3829   ASTMapLiteral jjtn000 = new ASTMapLiteral(JJTMAPLITERAL);
3830   boolean jjtc000 = true;
3831   jjtree.openNodeScope(jjtn000);
3832   jjtreeOpenNodeScope(jjtn000);
3833   jjtn000.jjtSetFirstToken(getToken(1));
3834     try {
3835       jj_consume_token(LCURLY);
3836       if (jj_2_58(1)) {
3837         MapEntry();
3838         label_20:
3839         while (true) {
3840           switch (jj_nt.kind) {
3841           case COMMA:{
3842             break;
3843             }
3844           default:
3845             break label_20;
3846           }
3847           jj_consume_token(COMMA);
3848           MapEntry();
3849         }
3850       } else {
3851         switch (jj_nt.kind) {
3852         case COLON:{
3853           jj_consume_token(COLON);
3854           break;
3855           }
3856         default:
3857           jj_consume_token(-1);
3858           throw new ParseException();
3859         }
3860       }
3861       jj_consume_token(RCURLY);
3862     } catch (Throwable jjte000) {
3863 if (jjtc000) {
3864         jjtree.clearNodeScope(jjtn000);
3865         jjtc000 = false;
3866       } else {
3867         jjtree.popNode();
3868       }
3869       if (jjte000 instanceof ParseException) {
3870         throw (ParseException)jjte000;
3871       }
3872       if (jjte000 instanceof RuntimeException) {
3873         throw (RuntimeException)jjte000;
3874       }
3875       throw (Error)jjte000;
3876     } finally {
3877 if (jjtc000) {
3878         jjtree.closeNodeScope(jjtn000, true);
3879         if (jjtree.nodeCreated()) {
3880          jjtreeCloseNodeScope(jjtn000);
3881         }
3882         jjtn000.jjtSetLastToken(getToken(0));
3883       }
3884     }
3885 }
3886 
3887   final public void MapEntry() throws ParseException {/*@bgen(jjtree) MapEntry */
3888   ASTMapEntry jjtn000 = new ASTMapEntry(JJTMAPENTRY);
3889   boolean jjtc000 = true;
3890   jjtree.openNodeScope(jjtn000);
3891   jjtreeOpenNodeScope(jjtn000);
3892   jjtn000.jjtSetFirstToken(getToken(1));
3893     try {
3894       Expression();
3895       jj_consume_token(COLON);
3896       Expression();
3897     } catch (Throwable jjte000) {
3898 if (jjtc000) {
3899         jjtree.clearNodeScope(jjtn000);
3900         jjtc000 = false;
3901       } else {
3902         jjtree.popNode();
3903       }
3904       if (jjte000 instanceof ParseException) {
3905         throw (ParseException)jjte000;
3906       }
3907       if (jjte000 instanceof RuntimeException) {
3908         throw (RuntimeException)jjte000;
3909       }
3910       throw (Error)jjte000;
3911     } finally {
3912 if (jjtc000) {
3913         jjtree.closeNodeScope(jjtn000, true);
3914         if (jjtree.nodeCreated()) {
3915          jjtreeCloseNodeScope(jjtn000);
3916         }
3917         jjtn000.jjtSetLastToken(getToken(0));
3918       }
3919     }
3920 }
3921 
3922   final public void SetLiteral() throws ParseException {/*@bgen(jjtree) SetLiteral */
3923   ASTSetLiteral jjtn000 = new ASTSetLiteral(JJTSETLITERAL);
3924   boolean jjtc000 = true;
3925   jjtree.openNodeScope(jjtn000);
3926   jjtreeOpenNodeScope(jjtn000);
3927   jjtn000.jjtSetFirstToken(getToken(1));
3928     try {
3929       jj_consume_token(LCURLY);
3930       if (jj_2_59(1)) {
3931         Expression();
3932         label_21:
3933         while (true) {
3934           switch (jj_nt.kind) {
3935           case COMMA:{
3936             break;
3937             }
3938           default:
3939             break label_21;
3940           }
3941           jj_consume_token(COMMA);
3942           Expression();
3943         }
3944       } else {
3945         ;
3946       }
3947       jj_consume_token(RCURLY);
3948     } catch (Throwable jjte000) {
3949 if (jjtc000) {
3950         jjtree.clearNodeScope(jjtn000);
3951         jjtc000 = false;
3952       } else {
3953         jjtree.popNode();
3954       }
3955       if (jjte000 instanceof ParseException) {
3956         throw (ParseException)jjte000;
3957       }
3958       if (jjte000 instanceof RuntimeException) {
3959         throw (RuntimeException)jjte000;
3960       }
3961       throw (Error)jjte000;
3962     } finally {
3963 if (jjtc000) {
3964         jjtree.closeNodeScope(jjtn000, true);
3965         if (jjtree.nodeCreated()) {
3966          jjtreeCloseNodeScope(jjtn000);
3967         }
3968         jjtn000.jjtSetLastToken(getToken(0));
3969       }
3970     }
3971 }
3972 
3973 /***************************************
3974  *      Functions & Methods
3975  ***************************************/
3976   final public 
3977 void Arguments() throws ParseException {/*@bgen(jjtree) Arguments */
3978   ASTArguments jjtn000 = new ASTArguments(JJTARGUMENTS);
3979   boolean jjtc000 = true;
3980   jjtree.openNodeScope(jjtn000);
3981   jjtreeOpenNodeScope(jjtn000);
3982   jjtn000.jjtSetFirstToken(getToken(1));
3983     try {
3984       jj_consume_token(LPAREN);
3985       if (jj_2_60(1)) {
3986         Expression();
3987         label_22:
3988         while (true) {
3989           switch (jj_nt.kind) {
3990           case COMMA:{
3991             break;
3992             }
3993           default:
3994             break label_22;
3995           }
3996           jj_consume_token(COMMA);
3997           Expression();
3998         }
3999       } else {
4000         ;
4001       }
4002       jj_consume_token(RPAREN);
4003     } catch (Throwable jjte000) {
4004 if (jjtc000) {
4005          jjtree.clearNodeScope(jjtn000);
4006          jjtc000 = false;
4007        } else {
4008          jjtree.popNode();
4009        }
4010        if (jjte000 instanceof ParseException) {
4011          throw (ParseException)jjte000;
4012        }
4013        if (jjte000 instanceof RuntimeException) {
4014          throw (RuntimeException)jjte000;
4015        }
4016        throw (Error)jjte000;
4017     } finally {
4018 if (jjtc000) {
4019          jjtree.closeNodeScope(jjtn000, true);
4020          if (jjtree.nodeCreated()) {
4021           jjtreeCloseNodeScope(jjtn000);
4022          }
4023          jjtn000.jjtSetLastToken(getToken(0));
4024        }
4025     }
4026 }
4027 
4028   final public void FunctionCallLookahead() throws ParseException {
4029     if (jj_2_61(2147483647) && (isDeclaredNamespace(getToken(1), getToken(2)))) {
4030       jj_consume_token(IDENTIFIER);
4031       jj_consume_token(COLON);
4032       jj_consume_token(IDENTIFIER);
4033       jj_consume_token(LPAREN);
4034     } else if (jj_2_62(2)) {
4035       jj_consume_token(IDENTIFIER);
4036       jj_consume_token(LPAREN);
4037     } else if (jj_2_63(2)) {
4038       jj_consume_token(REGISTER);
4039       jj_consume_token(LPAREN);
4040     } else {
4041       jj_consume_token(-1);
4042       throw new ParseException();
4043     }
4044 }
4045 
4046   final public void FunctionCall() throws ParseException {
4047     if (jj_2_64(2147483647) && (isDeclaredNamespace(getToken(1), getToken(2)))) {
4048       NamespaceIdentifier();
4049 ASTFunctionNode jjtn001 = new ASTFunctionNode(JJTFUNCTIONNODE);
4050                                                                                                                                        boolean jjtc001 = true;
4051                                                                                                                                        jjtree.openNodeScope(jjtn001);
4052                                                                                                                                        jjtreeOpenNodeScope(jjtn001);
4053                                                                                                                                        jjtn001.jjtSetFirstToken(getToken(1));
4054       try {
4055         Arguments();
4056       } catch (Throwable jjte001) {
4057 if (jjtc001) {
4058                                                                                                                                          jjtree.clearNodeScope(jjtn001);
4059                                                                                                                                          jjtc001 = false;
4060                                                                                                                                        } else {
4061                                                                                                                                          jjtree.popNode();
4062                                                                                                                                        }
4063                                                                                                                                        if (jjte001 instanceof ParseException) {
4064                                                                                                                                          throw (ParseException)jjte001;
4065                                                                                                                                        }
4066                                                                                                                                        if (jjte001 instanceof RuntimeException) {
4067                                                                                                                                          throw (RuntimeException)jjte001;
4068                                                                                                                                        }
4069                                                                                                                                        throw (Error)jjte001;
4070       } finally {
4071 if (jjtc001) {
4072                                                                                                                                          jjtree.closeNodeScope(jjtn001,  2);
4073                                                                                                                                          if (jjtree.nodeCreated()) {
4074                                                                                                                                           jjtreeCloseNodeScope(jjtn001);
4075                                                                                                                                          }
4076                                                                                                                                          jjtn001.jjtSetLastToken(getToken(0));
4077                                                                                                                                        }
4078       }
4079     } else if (jj_2_65(2147483647)) {
4080       Identifier(true);
4081 ASTFunctionNode jjtn002 = new ASTFunctionNode(JJTFUNCTIONNODE);
4082                                                         boolean jjtc002 = true;
4083                                                         jjtree.openNodeScope(jjtn002);
4084                                                         jjtreeOpenNodeScope(jjtn002);
4085                                                         jjtn002.jjtSetFirstToken(getToken(1));
4086       try {
4087         Arguments();
4088       } catch (Throwable jjte002) {
4089 if (jjtc002) {
4090                                                           jjtree.clearNodeScope(jjtn002);
4091                                                           jjtc002 = false;
4092                                                         } else {
4093                                                           jjtree.popNode();
4094                                                         }
4095                                                         if (jjte002 instanceof ParseException) {
4096                                                           throw (ParseException)jjte002;
4097                                                         }
4098                                                         if (jjte002 instanceof RuntimeException) {
4099                                                           throw (RuntimeException)jjte002;
4100                                                         }
4101                                                         throw (Error)jjte002;
4102       } finally {
4103 if (jjtc002) {
4104                                                           jjtree.closeNodeScope(jjtn002,  2);
4105                                                           if (jjtree.nodeCreated()) {
4106                                                            jjtreeCloseNodeScope(jjtn002);
4107                                                           }
4108                                                           jjtn002.jjtSetLastToken(getToken(0));
4109                                                         }
4110       }
4111     } else {
4112       jj_consume_token(-1);
4113       throw new ParseException();
4114     }
4115 }
4116 
4117   final public void QualifiedIdentifier() throws ParseException {/*@bgen(jjtree) QualifiedIdentifier */
4118     ASTQualifiedIdentifier jjtn000 = new ASTQualifiedIdentifier(JJTQUALIFIEDIDENTIFIER);
4119     boolean jjtc000 = true;
4120     jjtree.openNodeScope(jjtn000);
4121     jjtreeOpenNodeScope(jjtn000);
4122     jjtn000.jjtSetFirstToken(getToken(1));LinkedList<String> lstr = new LinkedList<String>();
4123     try {
4124       pragmaKey(lstr);
4125 jjtree.closeNodeScope(jjtn000, true);
4126                       jjtc000 = false;
4127                       if (jjtree.nodeCreated()) {
4128                        jjtreeCloseNodeScope(jjtn000);
4129                       }
4130                       jjtn000.jjtSetLastToken(getToken(0));
4131 jjtn000.setName(stringify(lstr));
4132     } catch (Throwable jjte000) {
4133 if (jjtc000) {
4134         jjtree.clearNodeScope(jjtn000);
4135         jjtc000 = false;
4136       } else {
4137         jjtree.popNode();
4138       }
4139       if (jjte000 instanceof ParseException) {
4140         throw (ParseException)jjte000;
4141       }
4142       if (jjte000 instanceof RuntimeException) {
4143         throw (RuntimeException)jjte000;
4144       }
4145       throw (Error)jjte000;
4146     } finally {
4147 if (jjtc000) {
4148         jjtree.closeNodeScope(jjtn000, true);
4149         if (jjtree.nodeCreated()) {
4150          jjtreeCloseNodeScope(jjtn000);
4151         }
4152         jjtn000.jjtSetLastToken(getToken(0));
4153       }
4154     }
4155 }
4156 
4157   final public void Constructor() throws ParseException {/*@bgen(jjtree) ConstructorNode */
4158   ASTConstructorNode jjtn000 = new ASTConstructorNode(JJTCONSTRUCTORNODE);
4159   boolean jjtc000 = true;
4160   jjtree.openNodeScope(jjtn000);
4161   jjtreeOpenNodeScope(jjtn000);
4162   jjtn000.jjtSetFirstToken(getToken(1));
4163     try {
4164       if (jj_2_67(2)) {
4165         jj_consume_token(NEW);
4166         jj_consume_token(LPAREN);
4167         Expression();
4168         label_23:
4169         while (true) {
4170           switch (jj_nt.kind) {
4171           case COMMA:{
4172             break;
4173             }
4174           default:
4175             break label_23;
4176           }
4177           jj_consume_token(COMMA);
4178           Expression();
4179         }
4180         jj_consume_token(RPAREN);
4181       } else {
4182         switch (jj_nt.kind) {
4183         case NEW:{
4184           jj_consume_token(NEW);
4185           QualifiedIdentifier();
4186           jj_consume_token(LPAREN);
4187           if (jj_2_66(1)) {
4188             Expression();
4189             label_24:
4190             while (true) {
4191               switch (jj_nt.kind) {
4192               case COMMA:{
4193                 break;
4194                 }
4195               default:
4196                 break label_24;
4197               }
4198               jj_consume_token(COMMA);
4199               Expression();
4200             }
4201           } else {
4202             ;
4203           }
4204           jj_consume_token(RPAREN);
4205           break;
4206           }
4207         default:
4208           jj_consume_token(-1);
4209           throw new ParseException();
4210         }
4211       }
4212     } catch (Throwable jjte000) {
4213 if (jjtc000) {
4214       jjtree.clearNodeScope(jjtn000);
4215       jjtc000 = false;
4216     } else {
4217       jjtree.popNode();
4218     }
4219     if (jjte000 instanceof ParseException) {
4220       throw (ParseException)jjte000;
4221     }
4222     if (jjte000 instanceof RuntimeException) {
4223       throw (RuntimeException)jjte000;
4224     }
4225     throw (Error)jjte000;
4226     } finally {
4227 if (jjtc000) {
4228       jjtree.closeNodeScope(jjtn000, true);
4229       if (jjtree.nodeCreated()) {
4230        jjtreeCloseNodeScope(jjtn000);
4231       }
4232       jjtn000.jjtSetLastToken(getToken(0));
4233     }
4234     }
4235 }
4236 
4237   final public void Parameter() throws ParseException {Token t;
4238     switch (jj_nt.kind) {
4239     case VAR:
4240     case IDENTIFIER:{
4241       switch (jj_nt.kind) {
4242       case VAR:{
4243         jj_consume_token(VAR);
4244         break;
4245         }
4246       default:
4247         ;
4248       }
4249       t = jj_consume_token(IDENTIFIER);
4250 declareParameter(t, false, false);
4251       break;
4252       }
4253     case LET:{
4254       jj_consume_token(LET);
4255       t = jj_consume_token(IDENTIFIER);
4256 declareParameter(t, true, false);
4257       break;
4258       }
4259     case CONST:{
4260       jj_consume_token(CONST);
4261       t = jj_consume_token(IDENTIFIER);
4262 declareParameter(t, true, true);
4263       break;
4264       }
4265     default:
4266       jj_consume_token(-1);
4267       throw new ParseException();
4268     }
4269 }
4270 
4271   final public void Parameters() throws ParseException {
4272     jj_consume_token(LPAREN);
4273     switch (jj_nt.kind) {
4274     case VAR:
4275     case LET:
4276     case CONST:
4277     case IDENTIFIER:{
4278       Parameter();
4279       label_25:
4280       while (true) {
4281         switch (jj_nt.kind) {
4282         case COMMA:{
4283           break;
4284           }
4285         default:
4286           break label_25;
4287         }
4288         jj_consume_token(COMMA);
4289         Parameter();
4290       }
4291       break;
4292       }
4293     default:
4294       ;
4295     }
4296     jj_consume_token(RPAREN);
4297 }
4298 
4299   final public void ParametersLookahead() throws ParseException {
4300     jj_consume_token(LPAREN);
4301     switch (jj_nt.kind) {
4302     case VAR:
4303     case LET:
4304     case CONST:
4305     case IDENTIFIER:{
4306       switch (jj_nt.kind) {
4307       case VAR:
4308       case LET:
4309       case CONST:{
4310         switch (jj_nt.kind) {
4311         case VAR:{
4312           jj_consume_token(VAR);
4313           break;
4314           }
4315         case LET:{
4316           jj_consume_token(LET);
4317           break;
4318           }
4319         case CONST:{
4320           jj_consume_token(CONST);
4321           break;
4322           }
4323         default:
4324           jj_consume_token(-1);
4325           throw new ParseException();
4326         }
4327         break;
4328         }
4329       default:
4330         ;
4331       }
4332       jj_consume_token(IDENTIFIER);
4333       label_26:
4334       while (true) {
4335         switch (jj_nt.kind) {
4336         case COMMA:{
4337           break;
4338           }
4339         default:
4340           break label_26;
4341         }
4342         jj_consume_token(COMMA);
4343         switch (jj_nt.kind) {
4344         case VAR:
4345         case LET:
4346         case CONST:{
4347           switch (jj_nt.kind) {
4348           case VAR:{
4349             jj_consume_token(VAR);
4350             break;
4351             }
4352           case LET:{
4353             jj_consume_token(LET);
4354             break;
4355             }
4356           case CONST:{
4357             jj_consume_token(CONST);
4358             break;
4359             }
4360           default:
4361             jj_consume_token(-1);
4362             throw new ParseException();
4363           }
4364           break;
4365           }
4366         default:
4367           ;
4368         }
4369         jj_consume_token(IDENTIFIER);
4370       }
4371       break;
4372       }
4373     default:
4374       ;
4375     }
4376     jj_consume_token(RPAREN);
4377 }
4378 
4379   final public void LambdaLookahead() throws ParseException {
4380     switch (jj_nt.kind) {
4381     case FUNCTION:{
4382       jj_consume_token(FUNCTION);
4383       ParametersLookahead();
4384       break;
4385       }
4386     case LPAREN:{
4387       ParametersLookahead();
4388       switch (jj_nt.kind) {
4389       case LAMBDA:{
4390         jj_consume_token(LAMBDA);
4391         break;
4392         }
4393       case FATARROW:{
4394         jj_consume_token(FATARROW);
4395         break;
4396         }
4397       default:
4398         jj_consume_token(-1);
4399         throw new ParseException();
4400       }
4401       break;
4402       }
4403     case IDENTIFIER:{
4404       jj_consume_token(IDENTIFIER);
4405       switch (jj_nt.kind) {
4406       case LAMBDA:{
4407         jj_consume_token(LAMBDA);
4408         break;
4409         }
4410       case FATARROW:{
4411         jj_consume_token(FATARROW);
4412         break;
4413         }
4414       default:
4415         jj_consume_token(-1);
4416         throw new ParseException();
4417       }
4418       break;
4419       }
4420     default:
4421       jj_consume_token(-1);
4422       throw new ParseException();
4423     }
4424 }
4425 
4426   final public void Lambda() throws ParseException {/*@bgen(jjtree) JexlLambda */
4427    ASTJexlLambda jjtn000 = new ASTJexlLambda(JJTJEXLLAMBDA);
4428    boolean jjtc000 = true;
4429    jjtree.openNodeScope(jjtn000);
4430    jjtreeOpenNodeScope(jjtn000);
4431    jjtn000.jjtSetFirstToken(getToken(1));Token arrow;
4432    Token name;
4433     try {
4434       switch (jj_nt.kind) {
4435       case FUNCTION:{
4436         jj_consume_token(FUNCTION);
4437         if (jj_2_68(2147483647)) {
4438           DeclareFunction();
4439         } else {
4440           ;
4441         }
4442 pushScope(); pushUnit(jjtn000);
4443         Parameters();
4444         if (jj_2_69(3)) {
4445           Block();
4446         } else if (jj_2_70(1)) {
4447           Expression();
4448         } else {
4449           jj_consume_token(-1);
4450           throw new ParseException();
4451         }
4452 jjtree.closeNodeScope(jjtn000, true);
4453                                                                                            jjtc000 = false;
4454                                                                                            if (jjtree.nodeCreated()) {
4455                                                                                             jjtreeCloseNodeScope(jjtn000);
4456                                                                                            }
4457                                                                                            jjtn000.jjtSetLastToken(getToken(0));
4458 popUnit(jjtn000); popScope();
4459         break;
4460         }
4461       case LPAREN:{
4462 pushScope(); pushUnit(jjtn000);
4463         Parameters();
4464         switch (jj_nt.kind) {
4465         case LAMBDA:{
4466           arrow = jj_consume_token(LAMBDA);
4467           break;
4468           }
4469         case FATARROW:{
4470           arrow = jj_consume_token(FATARROW);
4471           break;
4472           }
4473         default:
4474           jj_consume_token(-1);
4475           throw new ParseException();
4476         }
4477         if (jj_2_71(3)) {
4478           Block();
4479         } else if (jj_2_72(1)) {
4480           Expression();
4481         } else {
4482           jj_consume_token(-1);
4483           throw new ParseException();
4484         }
4485 jjtree.closeNodeScope(jjtn000, true);
4486                                                                                                                                 jjtc000 = false;
4487                                                                                                                                 if (jjtree.nodeCreated()) {
4488                                                                                                                                  jjtreeCloseNodeScope(jjtn000);
4489                                                                                                                                 }
4490                                                                                                                                 jjtn000.jjtSetLastToken(getToken(0));
4491 checkLambda(arrow); popUnit(jjtn000); popScope();
4492         break;
4493         }
4494       case VAR:
4495       case LET:
4496       case CONST:
4497       case IDENTIFIER:{
4498 pushScope(); pushUnit(jjtn000);
4499         Parameter();
4500         switch (jj_nt.kind) {
4501         case LAMBDA:{
4502           arrow = jj_consume_token(LAMBDA);
4503           break;
4504           }
4505         case FATARROW:{
4506           arrow = jj_consume_token(FATARROW);
4507           break;
4508           }
4509         default:
4510           jj_consume_token(-1);
4511           throw new ParseException();
4512         }
4513         if (jj_2_73(3)) {
4514           Block();
4515         } else if (jj_2_74(1)) {
4516           Expression();
4517         } else {
4518           jj_consume_token(-1);
4519           throw new ParseException();
4520         }
4521 jjtree.closeNodeScope(jjtn000, true);
4522                                                                                                                               jjtc000 = false;
4523                                                                                                                               if (jjtree.nodeCreated()) {
4524                                                                                                                                jjtreeCloseNodeScope(jjtn000);
4525                                                                                                                               }
4526                                                                                                                               jjtn000.jjtSetLastToken(getToken(0));
4527 checkLambda(arrow); popUnit(jjtn000); popScope();
4528         break;
4529         }
4530       default:
4531         jj_consume_token(-1);
4532         throw new ParseException();
4533       }
4534     } catch (Throwable jjte000) {
4535 if (jjtc000) {
4536       jjtree.clearNodeScope(jjtn000);
4537       jjtc000 = false;
4538     } else {
4539       jjtree.popNode();
4540     }
4541     if (jjte000 instanceof ParseException) {
4542       throw (ParseException)jjte000;
4543     }
4544     if (jjte000 instanceof RuntimeException) {
4545       throw (RuntimeException)jjte000;
4546     }
4547     throw (Error)jjte000;
4548     } finally {
4549 if (jjtc000) {
4550       jjtree.closeNodeScope(jjtn000, true);
4551       if (jjtree.nodeCreated()) {
4552        jjtreeCloseNodeScope(jjtn000);
4553       }
4554       jjtn000.jjtSetLastToken(getToken(0));
4555     }
4556     }
4557 }
4558 
4559 /***************************************
4560  *     References
4561  ***************************************/
4562   final public 
4563 void IdentifierAccess() throws ParseException {Token t;
4564     switch (jj_nt.kind) {
4565     case DOT:{
4566       jj_consume_token(DOT);
4567       switch (jj_nt.kind) {
4568       case DOT_IDENTIFIER:{
4569         t = jj_consume_token(DOT_IDENTIFIER);
4570 ASTIdentifierAccess jjtn001 = new ASTIdentifierAccess(JJTIDENTIFIERACCESS);
4571                              boolean jjtc001 = true;
4572                              jjtree.openNodeScope(jjtn001);
4573                              jjtreeOpenNodeScope(jjtn001);
4574                              jjtn001.jjtSetFirstToken(getToken(1));
4575         try {
4576 jjtree.closeNodeScope(jjtn001, true);
4577                              jjtc001 = false;
4578                              if (jjtree.nodeCreated()) {
4579                               jjtreeCloseNodeScope(jjtn001);
4580                              }
4581                              jjtn001.jjtSetLastToken(getToken(0));
4582 jjtn001.setIdentifier(t.image);
4583         } finally {
4584 if (jjtc001) {
4585                                jjtree.closeNodeScope(jjtn001, true);
4586                                if (jjtree.nodeCreated()) {
4587                                 jjtreeCloseNodeScope(jjtn001);
4588                                }
4589                                jjtn001.jjtSetLastToken(getToken(0));
4590                              }
4591         }
4592         break;
4593         }
4594       case STRING_LITERAL:{
4595         t = jj_consume_token(STRING_LITERAL);
4596 ASTIdentifierAccess jjtn002 = new ASTIdentifierAccess(JJTIDENTIFIERACCESS);
4597                              boolean jjtc002 = true;
4598                              jjtree.openNodeScope(jjtn002);
4599                              jjtreeOpenNodeScope(jjtn002);
4600                              jjtn002.jjtSetFirstToken(getToken(1));
4601         try {
4602 jjtree.closeNodeScope(jjtn002, true);
4603                              jjtc002 = false;
4604                              if (jjtree.nodeCreated()) {
4605                               jjtreeCloseNodeScope(jjtn002);
4606                              }
4607                              jjtn002.jjtSetLastToken(getToken(0));
4608 jjtn002.setIdentifier(Parser.buildString(t.image, true));
4609         } finally {
4610 if (jjtc002) {
4611                                jjtree.closeNodeScope(jjtn002, true);
4612                                if (jjtree.nodeCreated()) {
4613                                 jjtreeCloseNodeScope(jjtn002);
4614                                }
4615                                jjtn002.jjtSetLastToken(getToken(0));
4616                              }
4617         }
4618         break;
4619         }
4620       case JXLT_LITERAL:{
4621         t = jj_consume_token(JXLT_LITERAL);
4622 ASTIdentifierAccessJxlt jjtn003 = new ASTIdentifierAccessJxlt(JJTIDENTIFIERACCESSJXLT);
4623                            boolean jjtc003 = true;
4624                            jjtree.openNodeScope(jjtn003);
4625                            jjtreeOpenNodeScope(jjtn003);
4626                            jjtn003.jjtSetFirstToken(getToken(1));
4627         try {
4628 jjtree.closeNodeScope(jjtn003, true);
4629                            jjtc003 = false;
4630                            if (jjtree.nodeCreated()) {
4631                             jjtreeCloseNodeScope(jjtn003);
4632                            }
4633                            jjtn003.jjtSetLastToken(getToken(0));
4634 jjtn003.setIdentifier(Parser.buildString(t.image, true));
4635         } finally {
4636 if (jjtc003) {
4637                              jjtree.closeNodeScope(jjtn003, true);
4638                              if (jjtree.nodeCreated()) {
4639                               jjtreeCloseNodeScope(jjtn003);
4640                              }
4641                              jjtn003.jjtSetLastToken(getToken(0));
4642                            }
4643         }
4644         break;
4645         }
4646       default:
4647         jj_consume_token(-1);
4648         throw new ParseException();
4649       }
4650       break;
4651       }
4652     case QDOT:{
4653       jj_consume_token(QDOT);
4654       switch (jj_nt.kind) {
4655       case DOT_IDENTIFIER:{
4656         t = jj_consume_token(DOT_IDENTIFIER);
4657 ASTIdentifierAccessSafe jjtn004 = new ASTIdentifierAccessSafe(JJTIDENTIFIERACCESSSAFE);
4658                              boolean jjtc004 = true;
4659                              jjtree.openNodeScope(jjtn004);
4660                              jjtreeOpenNodeScope(jjtn004);
4661                              jjtn004.jjtSetFirstToken(getToken(1));
4662         try {
4663 jjtree.closeNodeScope(jjtn004, true);
4664                              jjtc004 = false;
4665                              if (jjtree.nodeCreated()) {
4666                               jjtreeCloseNodeScope(jjtn004);
4667                              }
4668                              jjtn004.jjtSetLastToken(getToken(0));
4669 jjtn004.setIdentifier(t.image);
4670         } finally {
4671 if (jjtc004) {
4672                                jjtree.closeNodeScope(jjtn004, true);
4673                                if (jjtree.nodeCreated()) {
4674                                 jjtreeCloseNodeScope(jjtn004);
4675                                }
4676                                jjtn004.jjtSetLastToken(getToken(0));
4677                              }
4678         }
4679         break;
4680         }
4681       case STRING_LITERAL:{
4682         t = jj_consume_token(STRING_LITERAL);
4683 ASTIdentifierAccessSafe jjtn005 = new ASTIdentifierAccessSafe(JJTIDENTIFIERACCESSSAFE);
4684                              boolean jjtc005 = true;
4685                              jjtree.openNodeScope(jjtn005);
4686                              jjtreeOpenNodeScope(jjtn005);
4687                              jjtn005.jjtSetFirstToken(getToken(1));
4688         try {
4689 jjtree.closeNodeScope(jjtn005, true);
4690                              jjtc005 = false;
4691                              if (jjtree.nodeCreated()) {
4692                               jjtreeCloseNodeScope(jjtn005);
4693                              }
4694                              jjtn005.jjtSetLastToken(getToken(0));
4695 jjtn005.setIdentifier(Parser.buildString(t.image, true));
4696         } finally {
4697 if (jjtc005) {
4698                                jjtree.closeNodeScope(jjtn005, true);
4699                                if (jjtree.nodeCreated()) {
4700                                 jjtreeCloseNodeScope(jjtn005);
4701                                }
4702                                jjtn005.jjtSetLastToken(getToken(0));
4703                              }
4704         }
4705         break;
4706         }
4707       case JXLT_LITERAL:{
4708         t = jj_consume_token(JXLT_LITERAL);
4709 ASTIdentifierAccessSafeJxlt jjtn006 = new ASTIdentifierAccessSafeJxlt(JJTIDENTIFIERACCESSSAFEJXLT);
4710                            boolean jjtc006 = true;
4711                            jjtree.openNodeScope(jjtn006);
4712                            jjtreeOpenNodeScope(jjtn006);
4713                            jjtn006.jjtSetFirstToken(getToken(1));
4714         try {
4715 jjtree.closeNodeScope(jjtn006, true);
4716                            jjtc006 = false;
4717                            if (jjtree.nodeCreated()) {
4718                             jjtreeCloseNodeScope(jjtn006);
4719                            }
4720                            jjtn006.jjtSetLastToken(getToken(0));
4721 jjtn006.setIdentifier(Parser.buildString(t.image, true));
4722         } finally {
4723 if (jjtc006) {
4724                              jjtree.closeNodeScope(jjtn006, true);
4725                              if (jjtree.nodeCreated()) {
4726                               jjtreeCloseNodeScope(jjtn006);
4727                              }
4728                              jjtn006.jjtSetLastToken(getToken(0));
4729                            }
4730         }
4731         break;
4732         }
4733       default:
4734         jj_consume_token(-1);
4735         throw new ParseException();
4736       }
4737       break;
4738       }
4739     default:
4740       jj_consume_token(-1);
4741       throw new ParseException();
4742     }
4743 }
4744 
4745   final public void ArrayAccess() throws ParseException {/*@bgen(jjtree) ArrayAccess */
4746   ASTArrayAccess jjtn000 = new ASTArrayAccess(JJTARRAYACCESS);
4747   boolean jjtc000 = true;
4748   jjtree.openNodeScope(jjtn000);
4749   jjtreeOpenNodeScope(jjtn000);
4750   jjtn000.jjtSetFirstToken(getToken(1));
4751     try {
4752       label_27:
4753       while (true) {
4754         jj_consume_token(LBRACKET);
4755         Expression();
4756         jj_consume_token(RBRACKET);
4757         switch (jj_nt.kind) {
4758         case LBRACKET:{
4759           break;
4760           }
4761         default:
4762           break label_27;
4763         }
4764       }
4765     } catch (Throwable jjte000) {
4766 if (jjtc000) {
4767         jjtree.clearNodeScope(jjtn000);
4768         jjtc000 = false;
4769       } else {
4770         jjtree.popNode();
4771       }
4772       if (jjte000 instanceof ParseException) {
4773         throw (ParseException)jjte000;
4774       }
4775       if (jjte000 instanceof RuntimeException) {
4776         throw (RuntimeException)jjte000;
4777       }
4778       throw (Error)jjte000;
4779     } finally {
4780 if (jjtc000) {
4781         jjtree.closeNodeScope(jjtn000, true);
4782         if (jjtree.nodeCreated()) {
4783          jjtreeCloseNodeScope(jjtn000);
4784         }
4785         jjtn000.jjtSetLastToken(getToken(0));
4786       }
4787     }
4788 }
4789 
4790   final public void MemberAccess() throws ParseException {
4791     if (jj_2_75(2147483647)) {
4792       ArrayAccess();
4793     } else if (jj_2_76(2147483647)) {
4794       IdentifierAccess();
4795     } else if (jj_2_77(2147483647)) {
4796       IdentifierAccess();
4797     } else {
4798       jj_consume_token(-1);
4799       throw new ParseException();
4800     }
4801 }
4802 
4803   final public void ReferenceExpression() throws ParseException {/*@bgen(jjtree) #MethodNode(> 1) */
4804   ASTMethodNode jjtn000 = new ASTMethodNode(JJTMETHODNODE);
4805   boolean jjtc000 = true;
4806   jjtree.openNodeScope(jjtn000);
4807   jjtreeOpenNodeScope(jjtn000);
4808   jjtn000.jjtSetFirstToken(getToken(1));
4809     try {
4810       jj_consume_token(LPAREN);
4811       Expression();
4812 ASTReferenceExpression jjtn001 = new ASTReferenceExpression(JJTREFERENCEEXPRESSION);
4813                             boolean jjtc001 = true;
4814                             jjtree.openNodeScope(jjtn001);
4815                             jjtreeOpenNodeScope(jjtn001);
4816                             jjtn001.jjtSetFirstToken(getToken(1));
4817       try {
4818         jj_consume_token(RPAREN);
4819       } finally {
4820 if (jjtc001) {
4821                               jjtree.closeNodeScope(jjtn001,  1);
4822                               if (jjtree.nodeCreated()) {
4823                                jjtreeCloseNodeScope(jjtn001);
4824                               }
4825                               jjtn001.jjtSetLastToken(getToken(0));
4826                             }
4827       }
4828       label_28:
4829       while (true) {
4830         if (jj_2_78(2147483647)) {
4831         } else {
4832           break label_28;
4833         }
4834         Arguments();
4835       }
4836     } catch (Throwable jjte000) {
4837 if (jjtc000) {
4838         jjtree.clearNodeScope(jjtn000);
4839         jjtc000 = false;
4840       } else {
4841         jjtree.popNode();
4842       }
4843       if (jjte000 instanceof ParseException) {
4844         throw (ParseException)jjte000;
4845       }
4846       if (jjte000 instanceof RuntimeException) {
4847         throw (RuntimeException)jjte000;
4848       }
4849       throw (Error)jjte000;
4850     } finally {
4851 if (jjtc000) {
4852         jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() >  1);
4853         if (jjtree.nodeCreated()) {
4854          jjtreeCloseNodeScope(jjtn000);
4855         }
4856         jjtn000.jjtSetLastToken(getToken(0));
4857       }
4858     }
4859 }
4860 
4861   final public void PrimaryExpression() throws ParseException {
4862     if (jj_2_79(2147483647)) {
4863       Lambda();
4864     } else if (jj_2_80(2147483647)) {
4865       ReferenceExpression();
4866     } else if (jj_2_81(2147483647)) {
4867       MapLiteral();
4868     } else if (jj_2_82(2147483647)) {
4869       MapLiteral();
4870     } else if (jj_2_83(2147483647)) {
4871       SetLiteral();
4872     } else if (jj_2_84(2147483647)) {
4873       SetLiteral();
4874     } else if (jj_2_85(2147483647)) {
4875       ArrayLiteral();
4876     } else if (jj_2_86(2147483647)) {
4877       Constructor();
4878     } else if (jj_2_87(2147483647)) {
4879       FunctionCall();
4880     } else {
4881       switch (jj_nt.kind) {
4882       case IDENTIFIER:
4883       case REGISTER:{
4884         Identifier(true);
4885         break;
4886         }
4887       case NULL:
4888       case TRUE:
4889       case FALSE:
4890       case NAN_LITERAL:
4891       case INTEGER_LITERAL:
4892       case FLOAT_LITERAL:
4893       case STRING_LITERAL:
4894       case JXLT_LITERAL:
4895       case REGEX_LITERAL:{
4896         Literal();
4897         break;
4898         }
4899       default:
4900         jj_consume_token(-1);
4901         throw new ParseException();
4902       }
4903     }
4904 }
4905 
4906   final public void MethodCall() throws ParseException {
4907 ASTMethodNode jjtn001 = new ASTMethodNode(JJTMETHODNODE);
4908       boolean jjtc001 = true;
4909       jjtree.openNodeScope(jjtn001);
4910       jjtreeOpenNodeScope(jjtn001);
4911       jjtn001.jjtSetFirstToken(getToken(1));
4912     try {
4913       MemberAccess();
4914       label_29:
4915       while (true) {
4916         Arguments();
4917         if (jj_2_88(2147483647)) {
4918         } else {
4919           break label_29;
4920         }
4921       }
4922     } catch (Throwable jjte001) {
4923 if (jjtc001) {
4924         jjtree.clearNodeScope(jjtn001);
4925         jjtc001 = false;
4926       } else {
4927         jjtree.popNode();
4928       }
4929       if (jjte001 instanceof ParseException) {
4930         throw (ParseException)jjte001;
4931       }
4932       if (jjte001 instanceof RuntimeException) {
4933         throw (RuntimeException)jjte001;
4934       }
4935       throw (Error)jjte001;
4936     } finally {
4937 if (jjtc001) {
4938         jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() >  1);
4939         if (jjtree.nodeCreated()) {
4940          jjtreeCloseNodeScope(jjtn001);
4941         }
4942         jjtn001.jjtSetLastToken(getToken(0));
4943       }
4944     }
4945 }
4946 
4947   final public void MemberExpression() throws ParseException {
4948     if (jj_2_89(2147483647)) {
4949       MethodCall();
4950     } else {
4951       switch (jj_nt.kind) {
4952       case LBRACKET:
4953       case DOT:
4954       case QDOT:{
4955         MemberAccess();
4956         break;
4957         }
4958       default:
4959         jj_consume_token(-1);
4960         throw new ParseException();
4961       }
4962     }
4963 }
4964 
4965   final public void ValueExpression() throws ParseException {
4966 ASTReference jjtn001 = new ASTReference(JJTREFERENCE);
4967       boolean jjtc001 = true;
4968       jjtree.openNodeScope(jjtn001);
4969       jjtreeOpenNodeScope(jjtn001);
4970       jjtn001.jjtSetFirstToken(getToken(1));
4971     try {
4972       PrimaryExpression();
4973       label_30:
4974       while (true) {
4975         if (jj_2_90(2)) {
4976         } else {
4977           break label_30;
4978         }
4979         MemberExpression();
4980       }
4981     } catch (Throwable jjte001) {
4982 if (jjtc001) {
4983         jjtree.clearNodeScope(jjtn001);
4984         jjtc001 = false;
4985       } else {
4986         jjtree.popNode();
4987       }
4988       if (jjte001 instanceof ParseException) {
4989         throw (ParseException)jjte001;
4990       }
4991       if (jjte001 instanceof RuntimeException) {
4992         throw (RuntimeException)jjte001;
4993       }
4994       throw (Error)jjte001;
4995     } finally {
4996 if (jjtc001) {
4997         jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() >  1);
4998         if (jjtree.nodeCreated()) {
4999          jjtreeCloseNodeScope(jjtn001);
5000         }
5001         jjtn001.jjtSetLastToken(getToken(0));
5002       }
5003     }
5004 }
5005 
5006   private boolean jj_2_1(int xla)
5007  {
5008     jj_la = xla;
5009     jj_scanpos = token;
5010     jj_lastpos = token;
5011     try { return (!jj_3_1()); }
5012     catch(LookaheadSuccess ls) { return true; }
5013   }
5014 
5015   private boolean jj_2_2(int xla)
5016  {
5017     jj_la = xla;
5018     jj_scanpos = token;
5019     jj_lastpos = token;
5020     try { return (!jj_3_2()); }
5021     catch(LookaheadSuccess ls) { return true; }
5022   }
5023 
5024   private boolean jj_2_3(int xla)
5025  {
5026     jj_la = xla;
5027     jj_scanpos = token;
5028     jj_lastpos = token;
5029     try { return (!jj_3_3()); }
5030     catch(LookaheadSuccess ls) { return true; }
5031   }
5032 
5033   private boolean jj_2_4(int xla)
5034  {
5035     jj_la = xla;
5036     jj_scanpos = token;
5037     jj_lastpos = token;
5038     try { return (!jj_3_4()); }
5039     catch(LookaheadSuccess ls) { return true; }
5040   }
5041 
5042   private boolean jj_2_5(int xla)
5043  {
5044     jj_la = xla;
5045     jj_scanpos = token;
5046     jj_lastpos = token;
5047     try { return (!jj_3_5()); }
5048     catch(LookaheadSuccess ls) { return true; }
5049   }
5050 
5051   private boolean jj_2_6(int xla)
5052  {
5053     jj_la = xla;
5054     jj_scanpos = token;
5055     jj_lastpos = token;
5056     try { return (!jj_3_6()); }
5057     catch(LookaheadSuccess ls) { return true; }
5058   }
5059 
5060   private boolean jj_2_7(int xla)
5061  {
5062     jj_la = xla;
5063     jj_scanpos = token;
5064     jj_lastpos = token;
5065     try { return (!jj_3_7()); }
5066     catch(LookaheadSuccess ls) { return true; }
5067   }
5068 
5069   private boolean jj_2_8(int xla)
5070  {
5071     jj_la = xla;
5072     jj_scanpos = token;
5073     jj_lastpos = token;
5074     try { return (!jj_3_8()); }
5075     catch(LookaheadSuccess ls) { return true; }
5076   }
5077 
5078   private boolean jj_2_9(int xla)
5079  {
5080     jj_la = xla;
5081     jj_scanpos = token;
5082     jj_lastpos = token;
5083     try { return (!jj_3_9()); }
5084     catch(LookaheadSuccess ls) { return true; }
5085   }
5086 
5087   private boolean jj_2_10(int xla)
5088  {
5089     jj_la = xla;
5090     jj_scanpos = token;
5091     jj_lastpos = token;
5092     try { return (!jj_3_10()); }
5093     catch(LookaheadSuccess ls) { return true; }
5094   }
5095 
5096   private boolean jj_2_11(int xla)
5097  {
5098     jj_la = xla;
5099     jj_scanpos = token;
5100     jj_lastpos = token;
5101     try { return (!jj_3_11()); }
5102     catch(LookaheadSuccess ls) { return true; }
5103   }
5104 
5105   private boolean jj_2_12(int xla)
5106  {
5107     jj_la = xla;
5108     jj_scanpos = token;
5109     jj_lastpos = token;
5110     try { return (!jj_3_12()); }
5111     catch(LookaheadSuccess ls) { return true; }
5112   }
5113 
5114   private boolean jj_2_13(int xla)
5115  {
5116     jj_la = xla;
5117     jj_scanpos = token;
5118     jj_lastpos = token;
5119     try { return (!jj_3_13()); }
5120     catch(LookaheadSuccess ls) { return true; }
5121   }
5122 
5123   private boolean jj_2_14(int xla)
5124  {
5125     jj_la = xla;
5126     jj_scanpos = token;
5127     jj_lastpos = token;
5128     try { return (!jj_3_14()); }
5129     catch(LookaheadSuccess ls) { return true; }
5130   }
5131 
5132   private boolean jj_2_15(int xla)
5133  {
5134     jj_la = xla;
5135     jj_scanpos = token;
5136     jj_lastpos = token;
5137     try { return (!jj_3_15()); }
5138     catch(LookaheadSuccess ls) { return true; }
5139   }
5140 
5141   private boolean jj_2_16(int xla)
5142  {
5143     jj_la = xla;
5144     jj_scanpos = token;
5145     jj_lastpos = token;
5146     try { return (!jj_3_16()); }
5147     catch(LookaheadSuccess ls) { return true; }
5148   }
5149 
5150   private boolean jj_2_17(int xla)
5151  {
5152     jj_la = xla;
5153     jj_scanpos = token;
5154     jj_lastpos = token;
5155     try { return (!jj_3_17()); }
5156     catch(LookaheadSuccess ls) { return true; }
5157   }
5158 
5159   private boolean jj_2_18(int xla)
5160  {
5161     jj_la = xla;
5162     jj_scanpos = token;
5163     jj_lastpos = token;
5164     try { return (!jj_3_18()); }
5165     catch(LookaheadSuccess ls) { return true; }
5166   }
5167 
5168   private boolean jj_2_19(int xla)
5169  {
5170     jj_la = xla;
5171     jj_scanpos = token;
5172     jj_lastpos = token;
5173     try { return (!jj_3_19()); }
5174     catch(LookaheadSuccess ls) { return true; }
5175   }
5176 
5177   private boolean jj_2_20(int xla)
5178  {
5179     jj_la = xla;
5180     jj_scanpos = token;
5181     jj_lastpos = token;
5182     try { return (!jj_3_20()); }
5183     catch(LookaheadSuccess ls) { return true; }
5184   }
5185 
5186   private boolean jj_2_21(int xla)
5187  {
5188     jj_la = xla;
5189     jj_scanpos = token;
5190     jj_lastpos = token;
5191     try { return (!jj_3_21()); }
5192     catch(LookaheadSuccess ls) { return true; }
5193   }
5194 
5195   private boolean jj_2_22(int xla)
5196  {
5197     jj_la = xla;
5198     jj_scanpos = token;
5199     jj_lastpos = token;
5200     try { return (!jj_3_22()); }
5201     catch(LookaheadSuccess ls) { return true; }
5202   }
5203 
5204   private boolean jj_2_23(int xla)
5205  {
5206     jj_la = xla;
5207     jj_scanpos = token;
5208     jj_lastpos = token;
5209     try { return (!jj_3_23()); }
5210     catch(LookaheadSuccess ls) { return true; }
5211   }
5212 
5213   private boolean jj_2_24(int xla)
5214  {
5215     jj_la = xla;
5216     jj_scanpos = token;
5217     jj_lastpos = token;
5218     try { return (!jj_3_24()); }
5219     catch(LookaheadSuccess ls) { return true; }
5220   }
5221 
5222   private boolean jj_2_25(int xla)
5223  {
5224     jj_la = xla;
5225     jj_scanpos = token;
5226     jj_lastpos = token;
5227     try { return (!jj_3_25()); }
5228     catch(LookaheadSuccess ls) { return true; }
5229   }
5230 
5231   private boolean jj_2_26(int xla)
5232  {
5233     jj_la = xla;
5234     jj_scanpos = token;
5235     jj_lastpos = token;
5236     try { return (!jj_3_26()); }
5237     catch(LookaheadSuccess ls) { return true; }
5238   }
5239 
5240   private boolean jj_2_27(int xla)
5241  {
5242     jj_la = xla;
5243     jj_scanpos = token;
5244     jj_lastpos = token;
5245     try { return (!jj_3_27()); }
5246     catch(LookaheadSuccess ls) { return true; }
5247   }
5248 
5249   private boolean jj_2_28(int xla)
5250  {
5251     jj_la = xla;
5252     jj_scanpos = token;
5253     jj_lastpos = token;
5254     try { return (!jj_3_28()); }
5255     catch(LookaheadSuccess ls) { return true; }
5256   }
5257 
5258   private boolean jj_2_29(int xla)
5259  {
5260     jj_la = xla;
5261     jj_scanpos = token;
5262     jj_lastpos = token;
5263     try { return (!jj_3_29()); }
5264     catch(LookaheadSuccess ls) { return true; }
5265   }
5266 
5267   private boolean jj_2_30(int xla)
5268  {
5269     jj_la = xla;
5270     jj_scanpos = token;
5271     jj_lastpos = token;
5272     try { return (!jj_3_30()); }
5273     catch(LookaheadSuccess ls) { return true; }
5274   }
5275 
5276   private boolean jj_2_31(int xla)
5277  {
5278     jj_la = xla;
5279     jj_scanpos = token;
5280     jj_lastpos = token;
5281     try { return (!jj_3_31()); }
5282     catch(LookaheadSuccess ls) { return true; }
5283   }
5284 
5285   private boolean jj_2_32(int xla)
5286  {
5287     jj_la = xla;
5288     jj_scanpos = token;
5289     jj_lastpos = token;
5290     try { return (!jj_3_32()); }
5291     catch(LookaheadSuccess ls) { return true; }
5292   }
5293 
5294   private boolean jj_2_33(int xla)
5295  {
5296     jj_la = xla;
5297     jj_scanpos = token;
5298     jj_lastpos = token;
5299     try { return (!jj_3_33()); }
5300     catch(LookaheadSuccess ls) { return true; }
5301   }
5302 
5303   private boolean jj_2_34(int xla)
5304  {
5305     jj_la = xla;
5306     jj_scanpos = token;
5307     jj_lastpos = token;
5308     try { return (!jj_3_34()); }
5309     catch(LookaheadSuccess ls) { return true; }
5310   }
5311 
5312   private boolean jj_2_35(int xla)
5313  {
5314     jj_la = xla;
5315     jj_scanpos = token;
5316     jj_lastpos = token;
5317     try { return (!jj_3_35()); }
5318     catch(LookaheadSuccess ls) { return true; }
5319   }
5320 
5321   private boolean jj_2_36(int xla)
5322  {
5323     jj_la = xla;
5324     jj_scanpos = token;
5325     jj_lastpos = token;
5326     try { return (!jj_3_36()); }
5327     catch(LookaheadSuccess ls) { return true; }
5328   }
5329 
5330   private boolean jj_2_37(int xla)
5331  {
5332     jj_la = xla;
5333     jj_scanpos = token;
5334     jj_lastpos = token;
5335     try { return (!jj_3_37()); }
5336     catch(LookaheadSuccess ls) { return true; }
5337   }
5338 
5339   private boolean jj_2_38(int xla)
5340  {
5341     jj_la = xla;
5342     jj_scanpos = token;
5343     jj_lastpos = token;
5344     try { return (!jj_3_38()); }
5345     catch(LookaheadSuccess ls) { return true; }
5346   }
5347 
5348   private boolean jj_2_39(int xla)
5349  {
5350     jj_la = xla;
5351     jj_scanpos = token;
5352     jj_lastpos = token;
5353     try { return (!jj_3_39()); }
5354     catch(LookaheadSuccess ls) { return true; }
5355   }
5356 
5357   private boolean jj_2_40(int xla)
5358  {
5359     jj_la = xla;
5360     jj_scanpos = token;
5361     jj_lastpos = token;
5362     try { return (!jj_3_40()); }
5363     catch(LookaheadSuccess ls) { return true; }
5364   }
5365 
5366   private boolean jj_2_41(int xla)
5367  {
5368     jj_la = xla;
5369     jj_scanpos = token;
5370     jj_lastpos = token;
5371     try { return (!jj_3_41()); }
5372     catch(LookaheadSuccess ls) { return true; }
5373   }
5374 
5375   private boolean jj_2_42(int xla)
5376  {
5377     jj_la = xla;
5378     jj_scanpos = token;
5379     jj_lastpos = token;
5380     try { return (!jj_3_42()); }
5381     catch(LookaheadSuccess ls) { return true; }
5382   }
5383 
5384   private boolean jj_2_43(int xla)
5385  {
5386     jj_la = xla;
5387     jj_scanpos = token;
5388     jj_lastpos = token;
5389     try { return (!jj_3_43()); }
5390     catch(LookaheadSuccess ls) { return true; }
5391   }
5392 
5393   private boolean jj_2_44(int xla)
5394  {
5395     jj_la = xla;
5396     jj_scanpos = token;
5397     jj_lastpos = token;
5398     try { return (!jj_3_44()); }
5399     catch(LookaheadSuccess ls) { return true; }
5400   }
5401 
5402   private boolean jj_2_45(int xla)
5403  {
5404     jj_la = xla;
5405     jj_scanpos = token;
5406     jj_lastpos = token;
5407     try { return (!jj_3_45()); }
5408     catch(LookaheadSuccess ls) { return true; }
5409   }
5410 
5411   private boolean jj_2_46(int xla)
5412  {
5413     jj_la = xla;
5414     jj_scanpos = token;
5415     jj_lastpos = token;
5416     try { return (!jj_3_46()); }
5417     catch(LookaheadSuccess ls) { return true; }
5418   }
5419 
5420   private boolean jj_2_47(int xla)
5421  {
5422     jj_la = xla;
5423     jj_scanpos = token;
5424     jj_lastpos = token;
5425     try { return (!jj_3_47()); }
5426     catch(LookaheadSuccess ls) { return true; }
5427   }
5428 
5429   private boolean jj_2_48(int xla)
5430  {
5431     jj_la = xla;
5432     jj_scanpos = token;
5433     jj_lastpos = token;
5434     try { return (!jj_3_48()); }
5435     catch(LookaheadSuccess ls) { return true; }
5436   }
5437 
5438   private boolean jj_2_49(int xla)
5439  {
5440     jj_la = xla;
5441     jj_scanpos = token;
5442     jj_lastpos = token;
5443     try { return (!jj_3_49()); }
5444     catch(LookaheadSuccess ls) { return true; }
5445   }
5446 
5447   private boolean jj_2_50(int xla)
5448  {
5449     jj_la = xla;
5450     jj_scanpos = token;
5451     jj_lastpos = token;
5452     try { return (!jj_3_50()); }
5453     catch(LookaheadSuccess ls) { return true; }
5454   }
5455 
5456   private boolean jj_2_51(int xla)
5457  {
5458     jj_la = xla;
5459     jj_scanpos = token;
5460     jj_lastpos = token;
5461     try { return (!jj_3_51()); }
5462     catch(LookaheadSuccess ls) { return true; }
5463   }
5464 
5465   private boolean jj_2_52(int xla)
5466  {
5467     jj_la = xla;
5468     jj_scanpos = token;
5469     jj_lastpos = token;
5470     try { return (!jj_3_52()); }
5471     catch(LookaheadSuccess ls) { return true; }
5472   }
5473 
5474   private boolean jj_2_53(int xla)
5475  {
5476     jj_la = xla;
5477     jj_scanpos = token;
5478     jj_lastpos = token;
5479     try { return (!jj_3_53()); }
5480     catch(LookaheadSuccess ls) { return true; }
5481   }
5482 
5483   private boolean jj_2_54(int xla)
5484  {
5485     jj_la = xla;
5486     jj_scanpos = token;
5487     jj_lastpos = token;
5488     try { return (!jj_3_54()); }
5489     catch(LookaheadSuccess ls) { return true; }
5490   }
5491 
5492   private boolean jj_2_55(int xla)
5493  {
5494     jj_la = xla;
5495     jj_scanpos = token;
5496     jj_lastpos = token;
5497     try { return (!jj_3_55()); }
5498     catch(LookaheadSuccess ls) { return true; }
5499   }
5500 
5501   private boolean jj_2_56(int xla)
5502  {
5503     jj_la = xla;
5504     jj_scanpos = token;
5505     jj_lastpos = token;
5506     try { return (!jj_3_56()); }
5507     catch(LookaheadSuccess ls) { return true; }
5508   }
5509 
5510   private boolean jj_2_57(int xla)
5511  {
5512     jj_la = xla;
5513     jj_scanpos = token;
5514     jj_lastpos = token;
5515     try { return (!jj_3_57()); }
5516     catch(LookaheadSuccess ls) { return true; }
5517   }
5518 
5519   private boolean jj_2_58(int xla)
5520  {
5521     jj_la = xla;
5522     jj_scanpos = token;
5523     jj_lastpos = token;
5524     try { return (!jj_3_58()); }
5525     catch(LookaheadSuccess ls) { return true; }
5526   }
5527 
5528   private boolean jj_2_59(int xla)
5529  {
5530     jj_la = xla;
5531     jj_scanpos = token;
5532     jj_lastpos = token;
5533     try { return (!jj_3_59()); }
5534     catch(LookaheadSuccess ls) { return true; }
5535   }
5536 
5537   private boolean jj_2_60(int xla)
5538  {
5539     jj_la = xla;
5540     jj_scanpos = token;
5541     jj_lastpos = token;
5542     try { return (!jj_3_60()); }
5543     catch(LookaheadSuccess ls) { return true; }
5544   }
5545 
5546   private boolean jj_2_61(int xla)
5547  {
5548     jj_la = xla;
5549     jj_scanpos = token;
5550     jj_lastpos = token;
5551     try { return (!jj_3_61()); }
5552     catch(LookaheadSuccess ls) { return true; }
5553   }
5554 
5555   private boolean jj_2_62(int xla)
5556  {
5557     jj_la = xla;
5558     jj_scanpos = token;
5559     jj_lastpos = token;
5560     try { return (!jj_3_62()); }
5561     catch(LookaheadSuccess ls) { return true; }
5562   }
5563 
5564   private boolean jj_2_63(int xla)
5565  {
5566     jj_la = xla;
5567     jj_scanpos = token;
5568     jj_lastpos = token;
5569     try { return (!jj_3_63()); }
5570     catch(LookaheadSuccess ls) { return true; }
5571   }
5572 
5573   private boolean jj_2_64(int xla)
5574  {
5575     jj_la = xla;
5576     jj_scanpos = token;
5577     jj_lastpos = token;
5578     try { return (!jj_3_64()); }
5579     catch(LookaheadSuccess ls) { return true; }
5580   }
5581 
5582   private boolean jj_2_65(int xla)
5583  {
5584     jj_la = xla;
5585     jj_scanpos = token;
5586     jj_lastpos = token;
5587     try { return (!jj_3_65()); }
5588     catch(LookaheadSuccess ls) { return true; }
5589   }
5590 
5591   private boolean jj_2_66(int xla)
5592  {
5593     jj_la = xla;
5594     jj_scanpos = token;
5595     jj_lastpos = token;
5596     try { return (!jj_3_66()); }
5597     catch(LookaheadSuccess ls) { return true; }
5598   }
5599 
5600   private boolean jj_2_67(int xla)
5601  {
5602     jj_la = xla;
5603     jj_scanpos = token;
5604     jj_lastpos = token;
5605     try { return (!jj_3_67()); }
5606     catch(LookaheadSuccess ls) { return true; }
5607   }
5608 
5609   private boolean jj_2_68(int xla)
5610  {
5611     jj_la = xla;
5612     jj_scanpos = token;
5613     jj_lastpos = token;
5614     try { return (!jj_3_68()); }
5615     catch(LookaheadSuccess ls) { return true; }
5616   }
5617 
5618   private boolean jj_2_69(int xla)
5619  {
5620     jj_la = xla;
5621     jj_scanpos = token;
5622     jj_lastpos = token;
5623     try { return (!jj_3_69()); }
5624     catch(LookaheadSuccess ls) { return true; }
5625   }
5626 
5627   private boolean jj_2_70(int xla)
5628  {
5629     jj_la = xla;
5630     jj_scanpos = token;
5631     jj_lastpos = token;
5632     try { return (!jj_3_70()); }
5633     catch(LookaheadSuccess ls) { return true; }
5634   }
5635 
5636   private boolean jj_2_71(int xla)
5637  {
5638     jj_la = xla;
5639     jj_scanpos = token;
5640     jj_lastpos = token;
5641     try { return (!jj_3_71()); }
5642     catch(LookaheadSuccess ls) { return true; }
5643   }
5644 
5645   private boolean jj_2_72(int xla)
5646  {
5647     jj_la = xla;
5648     jj_scanpos = token;
5649     jj_lastpos = token;
5650     try { return (!jj_3_72()); }
5651     catch(LookaheadSuccess ls) { return true; }
5652   }
5653 
5654   private boolean jj_2_73(int xla)
5655  {
5656     jj_la = xla;
5657     jj_scanpos = token;
5658     jj_lastpos = token;
5659     try { return (!jj_3_73()); }
5660     catch(LookaheadSuccess ls) { return true; }
5661   }
5662 
5663   private boolean jj_2_74(int xla)
5664  {
5665     jj_la = xla;
5666     jj_scanpos = token;
5667     jj_lastpos = token;
5668     try { return (!jj_3_74()); }
5669     catch(LookaheadSuccess ls) { return true; }
5670   }
5671 
5672   private boolean jj_2_75(int xla)
5673  {
5674     jj_la = xla;
5675     jj_scanpos = token;
5676     jj_lastpos = token;
5677     try { return (!jj_3_75()); }
5678     catch(LookaheadSuccess ls) { return true; }
5679   }
5680 
5681   private boolean jj_2_76(int xla)
5682  {
5683     jj_la = xla;
5684     jj_scanpos = token;
5685     jj_lastpos = token;
5686     try { return (!jj_3_76()); }
5687     catch(LookaheadSuccess ls) { return true; }
5688   }
5689 
5690   private boolean jj_2_77(int xla)
5691  {
5692     jj_la = xla;
5693     jj_scanpos = token;
5694     jj_lastpos = token;
5695     try { return (!jj_3_77()); }
5696     catch(LookaheadSuccess ls) { return true; }
5697   }
5698 
5699   private boolean jj_2_78(int xla)
5700  {
5701     jj_la = xla;
5702     jj_scanpos = token;
5703     jj_lastpos = token;
5704     try { return (!jj_3_78()); }
5705     catch(LookaheadSuccess ls) { return true; }
5706   }
5707 
5708   private boolean jj_2_79(int xla)
5709  {
5710     jj_la = xla;
5711     jj_scanpos = token;
5712     jj_lastpos = token;
5713     try { return (!jj_3_79()); }
5714     catch(LookaheadSuccess ls) { return true; }
5715   }
5716 
5717   private boolean jj_2_80(int xla)
5718  {
5719     jj_la = xla;
5720     jj_scanpos = token;
5721     jj_lastpos = token;
5722     try { return (!jj_3_80()); }
5723     catch(LookaheadSuccess ls) { return true; }
5724   }
5725 
5726   private boolean jj_2_81(int xla)
5727  {
5728     jj_la = xla;
5729     jj_scanpos = token;
5730     jj_lastpos = token;
5731     try { return (!jj_3_81()); }
5732     catch(LookaheadSuccess ls) { return true; }
5733   }
5734 
5735   private boolean jj_2_82(int xla)
5736  {
5737     jj_la = xla;
5738     jj_scanpos = token;
5739     jj_lastpos = token;
5740     try { return (!jj_3_82()); }
5741     catch(LookaheadSuccess ls) { return true; }
5742   }
5743 
5744   private boolean jj_2_83(int xla)
5745  {
5746     jj_la = xla;
5747     jj_scanpos = token;
5748     jj_lastpos = token;
5749     try { return (!jj_3_83()); }
5750     catch(LookaheadSuccess ls) { return true; }
5751   }
5752 
5753   private boolean jj_2_84(int xla)
5754  {
5755     jj_la = xla;
5756     jj_scanpos = token;
5757     jj_lastpos = token;
5758     try { return (!jj_3_84()); }
5759     catch(LookaheadSuccess ls) { return true; }
5760   }
5761 
5762   private boolean jj_2_85(int xla)
5763  {
5764     jj_la = xla;
5765     jj_scanpos = token;
5766     jj_lastpos = token;
5767     try { return (!jj_3_85()); }
5768     catch(LookaheadSuccess ls) { return true; }
5769   }
5770 
5771   private boolean jj_2_86(int xla)
5772  {
5773     jj_la = xla;
5774     jj_scanpos = token;
5775     jj_lastpos = token;
5776     try { return (!jj_3_86()); }
5777     catch(LookaheadSuccess ls) { return true; }
5778   }
5779 
5780   private boolean jj_2_87(int xla)
5781  {
5782     jj_la = xla;
5783     jj_scanpos = token;
5784     jj_lastpos = token;
5785     try { return (!jj_3_87()); }
5786     catch(LookaheadSuccess ls) { return true; }
5787   }
5788 
5789   private boolean jj_2_88(int xla)
5790  {
5791     jj_la = xla;
5792     jj_scanpos = token;
5793     jj_lastpos = token;
5794     try { return (!jj_3_88()); }
5795     catch(LookaheadSuccess ls) { return true; }
5796   }
5797 
5798   private boolean jj_2_89(int xla)
5799  {
5800     jj_la = xla;
5801     jj_scanpos = token;
5802     jj_lastpos = token;
5803     try { return (!jj_3_89()); }
5804     catch(LookaheadSuccess ls) { return true; }
5805   }
5806 
5807   private boolean jj_2_90(int xla)
5808  {
5809     jj_la = xla;
5810     jj_scanpos = token;
5811     jj_lastpos = token;
5812     try { return (!jj_3_90()); }
5813     catch(LookaheadSuccess ls) { return true; }
5814   }
5815 
5816   private boolean jj_3R_148()
5817  {
5818     if (jj_3R_168()) return true;
5819     return false;
5820   }
5821 
5822   private boolean jj_3R_149()
5823  {
5824     if (jj_3R_168()) return true;
5825     return false;
5826   }
5827 
5828   private boolean jj_3R_208()
5829  {
5830     if (jj_scan_token(IDENTIFIER)) return true;
5831     return false;
5832   }
5833 
5834   private boolean jj_3R_260()
5835  {
5836     if (jj_scan_token(assign)) return true;
5837     if (jj_3R_33()) return true;
5838     return false;
5839   }
5840 
5841   private boolean jj_3_69()
5842  {
5843     if (jj_3R_36()) return true;
5844     return false;
5845   }
5846 
5847   private boolean jj_3R_88()
5848  {
5849     if (jj_scan_token(PRAGMA)) return true;
5850     if (jj_3R_170()) return true;
5851     if (jj_3R_250()) return true;
5852     return false;
5853   }
5854 
5855   private boolean jj_3R_172()
5856  {
5857     if (jj_scan_token(LPAREN)) return true;
5858     if (jj_3R_33()) return true;
5859     if (jj_scan_token(RPAREN)) return true;
5860     Token xsp;
5861     while (true) {
5862       xsp = jj_scanpos;
5863       if (jj_3R_236()) { jj_scanpos = xsp; break; }
5864     }
5865     return false;
5866   }
5867 
5868   private boolean jj_3R_261()
5869  {
5870     if (jj_scan_token(assign)) return true;
5871     if (jj_3R_33()) return true;
5872     return false;
5873   }
5874 
5875   private boolean jj_3_75()
5876  {
5877     if (jj_scan_token(LBRACKET)) return true;
5878     return false;
5879   }
5880 
5881   private boolean jj_3_76()
5882  {
5883     if (jj_scan_token(DOT)) return true;
5884     return false;
5885   }
5886 
5887   private boolean jj_3_77()
5888  {
5889     if (jj_scan_token(QDOT)) return true;
5890     return false;
5891   }
5892 
5893   private boolean jj_3R_145()
5894  {
5895     Token xsp;
5896     xsp = jj_scanpos;
5897     if (jj_3R_155()) {
5898     jj_scanpos = xsp;
5899     if (jj_3R_156()) {
5900     jj_scanpos = xsp;
5901     if (jj_3R_157()) {
5902     jj_scanpos = xsp;
5903     if (jj_3R_158()) {
5904     jj_scanpos = xsp;
5905     if (jj_3R_159()) {
5906     jj_scanpos = xsp;
5907     if (jj_3R_160()) {
5908     jj_scanpos = xsp;
5909     if (jj_3R_161()) {
5910     jj_scanpos = xsp;
5911     if (jj_3R_162()) {
5912     jj_scanpos = xsp;
5913     if (jj_3R_163()) {
5914     jj_scanpos = xsp;
5915     if (jj_3R_164()) {
5916     jj_scanpos = xsp;
5917     if (jj_3R_165()) return true;
5918     }
5919     }
5920     }
5921     }
5922     }
5923     }
5924     }
5925     }
5926     }
5927     }
5928     return false;
5929   }
5930 
5931   private boolean jj_3R_155()
5932  {
5933     if (jj_3R_171()) return true;
5934     return false;
5935   }
5936 
5937   private boolean jj_3R_156()
5938  {
5939     if (jj_3R_172()) return true;
5940     return false;
5941   }
5942 
5943   private boolean jj_3R_157()
5944  {
5945     if (jj_3R_173()) return true;
5946     return false;
5947   }
5948 
5949   private boolean jj_3R_170()
5950  {
5951     Token xsp;
5952     xsp = jj_scanpos;
5953     if (jj_3R_185()) {
5954     jj_scanpos = xsp;
5955     if (jj_3R_186()) return true;
5956     }
5957     return false;
5958   }
5959 
5960   private boolean jj_3R_185()
5961  {
5962     if (jj_scan_token(IDENTIFIER)) return true;
5963     Token xsp;
5964     while (true) {
5965       xsp = jj_scanpos;
5966       if (jj_3R_249()) { jj_scanpos = xsp; break; }
5967     }
5968     return false;
5969   }
5970 
5971   private boolean jj_3R_158()
5972  {
5973     if (jj_3R_173()) return true;
5974     return false;
5975   }
5976 
5977   private boolean jj_3R_186()
5978  {
5979     if (jj_scan_token(DOT)) return true;
5980     if (jj_scan_token(DOT_IDENTIFIER)) return true;
5981     return false;
5982   }
5983 
5984   private boolean jj_3R_159()
5985  {
5986     if (jj_3R_174()) return true;
5987     return false;
5988   }
5989 
5990   private boolean jj_3R_160()
5991  {
5992     if (jj_3R_174()) return true;
5993     return false;
5994   }
5995 
5996   private boolean jj_3_79()
5997  {
5998     if (jj_3R_84()) return true;
5999     return false;
6000   }
6001 
6002   private boolean jj_3_70()
6003  {
6004     if (jj_3R_33()) return true;
6005     return false;
6006   }
6007 
6008   private boolean jj_3R_161()
6009  {
6010     if (jj_3R_175()) return true;
6011     return false;
6012   }
6013 
6014   private boolean jj_3_80()
6015  {
6016     if (jj_scan_token(LPAREN)) return true;
6017     return false;
6018   }
6019 
6020   private boolean jj_3R_162()
6021  {
6022     if (jj_3R_176()) return true;
6023     return false;
6024   }
6025 
6026   private boolean jj_3_81()
6027  {
6028     if (jj_scan_token(LCURLY)) return true;
6029     if (jj_3R_33()) return true;
6030     if (jj_scan_token(COLON)) return true;
6031     return false;
6032   }
6033 
6034   private boolean jj_3R_250()
6035  {
6036     Token xsp;
6037     xsp = jj_scanpos;
6038     if (jj_3_41()) {
6039     jj_scanpos = xsp;
6040     if (jj_3_42()) {
6041     jj_scanpos = xsp;
6042     if (jj_3R_251()) {
6043     jj_scanpos = xsp;
6044     if (jj_3R_252()) {
6045     jj_scanpos = xsp;
6046     if (jj_3R_253()) {
6047     jj_scanpos = xsp;
6048     if (jj_3R_254()) {
6049     jj_scanpos = xsp;
6050     if (jj_3R_255()) {
6051     jj_scanpos = xsp;
6052     if (jj_3R_256()) return true;
6053     }
6054     }
6055     }
6056     }
6057     }
6058     }
6059     }
6060     return false;
6061   }
6062 
6063   private boolean jj_3R_163()
6064  {
6065     if (jj_3R_177()) return true;
6066     return false;
6067   }
6068 
6069   private boolean jj_3_82()
6070  {
6071     if (jj_scan_token(LCURLY)) return true;
6072     if (jj_scan_token(COLON)) return true;
6073     return false;
6074   }
6075 
6076   private boolean jj_3R_164()
6077  {
6078     if (jj_3R_136()) return true;
6079     return false;
6080   }
6081 
6082   private boolean jj_3_83()
6083  {
6084     if (jj_scan_token(LCURLY)) return true;
6085     if (jj_3R_33()) return true;
6086     Token xsp;
6087     xsp = jj_scanpos;
6088     if (jj_scan_token(17)) {
6089     jj_scanpos = xsp;
6090     if (jj_scan_token(12)) return true;
6091     }
6092     return false;
6093   }
6094 
6095   private boolean jj_3_41()
6096  {
6097     Token xsp;
6098     xsp = jj_scanpos;
6099     if (jj_3R_39()) jj_scanpos = xsp;
6100     if (jj_scan_token(INTEGER_LITERAL)) return true;
6101     return false;
6102   }
6103 
6104   private boolean jj_3R_165()
6105  {
6106     if (jj_3R_178()) return true;
6107     return false;
6108   }
6109 
6110   private boolean jj_3_42()
6111  {
6112     Token xsp;
6113     xsp = jj_scanpos;
6114     if (jj_3R_40()) jj_scanpos = xsp;
6115     if (jj_scan_token(FLOAT_LITERAL)) return true;
6116     return false;
6117   }
6118 
6119   private boolean jj_3_84()
6120  {
6121     if (jj_scan_token(LCURLY)) return true;
6122     if (jj_scan_token(RCURLY)) return true;
6123     return false;
6124   }
6125 
6126   private boolean jj_3R_86()
6127  {
6128     if (jj_3R_117()) return true;
6129     Token xsp;
6130     if (jj_3R_118()) return true;
6131     while (true) {
6132       xsp = jj_scanpos;
6133       if (jj_3R_118()) { jj_scanpos = xsp; break; }
6134     }
6135     return false;
6136   }
6137 
6138   private boolean jj_3R_251()
6139  {
6140     if (jj_scan_token(STRING_LITERAL)) return true;
6141     return false;
6142   }
6143 
6144   private boolean jj_3_85()
6145  {
6146     if (jj_scan_token(LBRACKET)) return true;
6147     return false;
6148   }
6149 
6150   private boolean jj_3R_252()
6151  {
6152     if (jj_3R_170()) return true;
6153     return false;
6154   }
6155 
6156   private boolean jj_3R_253()
6157  {
6158     if (jj_scan_token(TRUE)) return true;
6159     return false;
6160   }
6161 
6162   private boolean jj_3_86()
6163  {
6164     if (jj_scan_token(NEW)) return true;
6165     return false;
6166   }
6167 
6168   private boolean jj_3R_254()
6169  {
6170     if (jj_scan_token(FALSE)) return true;
6171     return false;
6172   }
6173 
6174   private boolean jj_3R_255()
6175  {
6176     if (jj_scan_token(NULL)) return true;
6177     return false;
6178   }
6179 
6180   private boolean jj_3_87()
6181  {
6182     if (jj_3R_85()) return true;
6183     return false;
6184   }
6185 
6186   private boolean jj_3R_87()
6187  {
6188     Token xsp;
6189     xsp = jj_scanpos;
6190     if (jj_3R_119()) {
6191     jj_scanpos = xsp;
6192     if (jj_3R_120()) return true;
6193     }
6194     return false;
6195   }
6196 
6197   private boolean jj_3R_119()
6198  {
6199     if (jj_3R_86()) return true;
6200     return false;
6201   }
6202 
6203   private boolean jj_3R_256()
6204  {
6205     if (jj_scan_token(NAN_LITERAL)) return true;
6206     return false;
6207   }
6208 
6209   private boolean jj_3_71()
6210  {
6211     if (jj_3R_36()) return true;
6212     return false;
6213   }
6214 
6215   private boolean jj_3_73()
6216  {
6217     if (jj_3R_36()) return true;
6218     return false;
6219   }
6220 
6221   private boolean jj_3R_112()
6222  {
6223     if (jj_3R_145()) return true;
6224     Token xsp;
6225     while (true) {
6226       xsp = jj_scanpos;
6227       if (jj_3_90()) { jj_scanpos = xsp; break; }
6228     }
6229     return false;
6230   }
6231 
6232   private boolean jj_3R_39()
6233  {
6234     Token xsp;
6235     xsp = jj_scanpos;
6236     if (jj_scan_token(58)) {
6237     jj_scanpos = xsp;
6238     if (jj_scan_token(60)) return true;
6239     }
6240     return false;
6241   }
6242 
6243   private boolean jj_3R_40()
6244  {
6245     Token xsp;
6246     xsp = jj_scanpos;
6247     if (jj_scan_token(58)) {
6248     jj_scanpos = xsp;
6249     if (jj_scan_token(60)) return true;
6250     }
6251     return false;
6252   }
6253 
6254   private boolean jj_3_89()
6255  {
6256     if (jj_3R_86()) return true;
6257     return false;
6258   }
6259 
6260   private boolean jj_3R_118()
6261  {
6262     if (jj_3R_150()) return true;
6263     return false;
6264   }
6265 
6266   private boolean jj_3R_33()
6267  {
6268     if (jj_3R_91()) return true;
6269     return false;
6270   }
6271 
6272   private boolean jj_3R_91()
6273  {
6274     if (jj_3R_122()) return true;
6275     Token xsp;
6276     xsp = jj_scanpos;
6277     if (jj_3_43()) jj_scanpos = xsp;
6278     return false;
6279   }
6280 
6281   private boolean jj_3_43()
6282  {
6283     Token xsp;
6284     xsp = jj_scanpos;
6285     if (jj_3R_41()) {
6286     jj_scanpos = xsp;
6287     if (jj_3R_42()) {
6288     jj_scanpos = xsp;
6289     if (jj_3R_43()) {
6290     jj_scanpos = xsp;
6291     if (jj_3R_44()) {
6292     jj_scanpos = xsp;
6293     if (jj_3R_45()) {
6294     jj_scanpos = xsp;
6295     if (jj_3R_46()) {
6296     jj_scanpos = xsp;
6297     if (jj_3R_47()) {
6298     jj_scanpos = xsp;
6299     if (jj_3R_48()) {
6300     jj_scanpos = xsp;
6301     if (jj_3R_49()) {
6302     jj_scanpos = xsp;
6303     if (jj_3R_50()) {
6304     jj_scanpos = xsp;
6305     if (jj_3R_51()) {
6306     jj_scanpos = xsp;
6307     if (jj_3R_52()) return true;
6308     }
6309     }
6310     }
6311     }
6312     }
6313     }
6314     }
6315     }
6316     }
6317     }
6318     }
6319     return false;
6320   }
6321 
6322   private boolean jj_3R_249()
6323  {
6324     if (jj_3R_170()) return true;
6325     return false;
6326   }
6327 
6328   private boolean jj_3R_41()
6329  {
6330     if (jj_scan_token(plus_assign)) return true;
6331     if (jj_3R_33()) return true;
6332     return false;
6333   }
6334 
6335   private boolean jj_3R_42()
6336  {
6337     if (jj_scan_token(mult_assign)) return true;
6338     if (jj_3R_33()) return true;
6339     return false;
6340   }
6341 
6342   private boolean jj_3_88()
6343  {
6344     if (jj_scan_token(LPAREN)) return true;
6345     return false;
6346   }
6347 
6348   private boolean jj_3R_236()
6349  {
6350     if (jj_3R_150()) return true;
6351     return false;
6352   }
6353 
6354   private boolean jj_3R_43()
6355  {
6356     if (jj_scan_token(div_assign)) return true;
6357     if (jj_3R_33()) return true;
6358     return false;
6359   }
6360 
6361   private boolean jj_3_72()
6362  {
6363     if (jj_3R_33()) return true;
6364     return false;
6365   }
6366 
6367   private boolean jj_3_74()
6368  {
6369     if (jj_3R_33()) return true;
6370     return false;
6371   }
6372 
6373   private boolean jj_3R_44()
6374  {
6375     if (jj_scan_token(mod_assign)) return true;
6376     if (jj_3R_33()) return true;
6377     return false;
6378   }
6379 
6380   private boolean jj_3R_45()
6381  {
6382     if (jj_scan_token(and_assign)) return true;
6383     if (jj_3R_33()) return true;
6384     return false;
6385   }
6386 
6387   private boolean jj_3_40()
6388  {
6389     if (jj_scan_token(DOT)) return true;
6390     return false;
6391   }
6392 
6393   private boolean jj_3_90()
6394  {
6395     if (jj_3R_87()) return true;
6396     return false;
6397   }
6398 
6399   private boolean jj_3R_46()
6400  {
6401     if (jj_scan_token(or_assign)) return true;
6402     if (jj_3R_33()) return true;
6403     return false;
6404   }
6405 
6406   private boolean jj_3R_47()
6407  {
6408     if (jj_scan_token(xor_assign)) return true;
6409     if (jj_3R_33()) return true;
6410     return false;
6411   }
6412 
6413   private boolean jj_3_78()
6414  {
6415     if (jj_scan_token(LPAREN)) return true;
6416     return false;
6417   }
6418 
6419   private boolean jj_3R_48()
6420  {
6421     if (jj_scan_token(minus_assign)) return true;
6422     if (jj_3R_33()) return true;
6423     return false;
6424   }
6425 
6426   private boolean jj_3R_49()
6427  {
6428     if (jj_scan_token(lshift_assign)) return true;
6429     if (jj_3R_33()) return true;
6430     return false;
6431   }
6432 
6433   private boolean jj_3R_50()
6434  {
6435     if (jj_scan_token(rshift_assign)) return true;
6436     if (jj_3R_33()) return true;
6437     return false;
6438   }
6439 
6440   private boolean jj_3R_51()
6441  {
6442     if (jj_scan_token(rshiftu_assign)) return true;
6443     if (jj_3R_33()) return true;
6444     return false;
6445   }
6446 
6447   private boolean jj_3R_120()
6448  {
6449     if (jj_3R_117()) return true;
6450     return false;
6451   }
6452 
6453   private boolean jj_3R_52()
6454  {
6455     if (jj_scan_token(assign)) return true;
6456     if (jj_3R_33()) return true;
6457     return false;
6458   }
6459 
6460   private boolean jj_3R_122()
6461  {
6462     if (jj_3R_151()) return true;
6463     Token xsp;
6464     xsp = jj_scanpos;
6465     if (jj_3_44()) jj_scanpos = xsp;
6466     return false;
6467   }
6468 
6469   private boolean jj_3_44()
6470  {
6471     Token xsp;
6472     xsp = jj_scanpos;
6473     if (jj_3R_53()) {
6474     jj_scanpos = xsp;
6475     if (jj_3R_54()) {
6476     jj_scanpos = xsp;
6477     if (jj_3R_55()) return true;
6478     }
6479     }
6480     return false;
6481   }
6482 
6483   private boolean jj_3R_53()
6484  {
6485     if (jj_scan_token(QMARK)) return true;
6486     if (jj_3R_33()) return true;
6487     if (jj_scan_token(COLON)) return true;
6488     if (jj_3R_33()) return true;
6489     return false;
6490   }
6491 
6492   private boolean jj_3R_54()
6493  {
6494     if (jj_scan_token(ELVIS)) return true;
6495     if (jj_3R_33()) return true;
6496     return false;
6497   }
6498 
6499   private boolean jj_3R_55()
6500  {
6501     if (jj_scan_token(NULLP)) return true;
6502     if (jj_3R_33()) return true;
6503     return false;
6504   }
6505 
6506   private boolean jj_3R_151()
6507  {
6508     if (jj_3R_56()) return true;
6509     Token xsp;
6510     while (true) {
6511       xsp = jj_scanpos;
6512       if (jj_3_45()) { jj_scanpos = xsp; break; }
6513     }
6514     return false;
6515   }
6516 
6517   private boolean jj_3_45()
6518  {
6519     Token xsp;
6520     xsp = jj_scanpos;
6521     if (jj_scan_token(25)) {
6522     jj_scanpos = xsp;
6523     if (jj_scan_token(27)) return true;
6524     }
6525     if (jj_3R_56()) return true;
6526     return false;
6527   }
6528 
6529   private boolean jj_3R_56()
6530  {
6531     if (jj_3R_57()) return true;
6532     Token xsp;
6533     while (true) {
6534       xsp = jj_scanpos;
6535       if (jj_3_46()) { jj_scanpos = xsp; break; }
6536     }
6537     return false;
6538   }
6539 
6540   private boolean jj_3_46()
6541  {
6542     Token xsp;
6543     xsp = jj_scanpos;
6544     if (jj_scan_token(24)) {
6545     jj_scanpos = xsp;
6546     if (jj_scan_token(26)) return true;
6547     }
6548     if (jj_3R_57()) return true;
6549     return false;
6550   }
6551 
6552   private boolean jj_3R_57()
6553  {
6554     if (jj_3R_58()) return true;
6555     Token xsp;
6556     while (true) {
6557       xsp = jj_scanpos;
6558       if (jj_3_47()) { jj_scanpos = xsp; break; }
6559     }
6560     return false;
6561   }
6562 
6563   private boolean jj_3_47()
6564  {
6565     if (jj_scan_token(or)) return true;
6566     if (jj_3R_58()) return true;
6567     return false;
6568   }
6569 
6570   private boolean jj_3R_58()
6571  {
6572     if (jj_3R_59()) return true;
6573     Token xsp;
6574     while (true) {
6575       xsp = jj_scanpos;
6576       if (jj_3_48()) { jj_scanpos = xsp; break; }
6577     }
6578     return false;
6579   }
6580 
6581   private boolean jj_3_48()
6582  {
6583     if (jj_scan_token(xor)) return true;
6584     if (jj_3R_59()) return true;
6585     return false;
6586   }
6587 
6588   private boolean jj_3R_59()
6589  {
6590     if (jj_3R_60()) return true;
6591     Token xsp;
6592     while (true) {
6593       xsp = jj_scanpos;
6594       if (jj_3_49()) { jj_scanpos = xsp; break; }
6595     }
6596     return false;
6597   }
6598 
6599   private boolean jj_3_49()
6600  {
6601     if (jj_scan_token(and)) return true;
6602     if (jj_3R_60()) return true;
6603     return false;
6604   }
6605 
6606   private boolean jj_3R_60()
6607  {
6608     if (jj_3R_107()) return true;
6609     Token xsp;
6610     xsp = jj_scanpos;
6611     if (jj_3_50()) jj_scanpos = xsp;
6612     return false;
6613   }
6614 
6615   private boolean jj_3_50()
6616  {
6617     Token xsp;
6618     xsp = jj_scanpos;
6619     if (jj_3R_61()) {
6620     jj_scanpos = xsp;
6621     if (jj_3R_62()) {
6622     jj_scanpos = xsp;
6623     if (jj_3R_63()) return true;
6624     }
6625     }
6626     return false;
6627   }
6628 
6629   private boolean jj_3R_61()
6630  {
6631     Token xsp;
6632     xsp = jj_scanpos;
6633     if (jj_scan_token(28)) {
6634     jj_scanpos = xsp;
6635     if (jj_scan_token(40)) return true;
6636     }
6637     if (jj_3R_107()) return true;
6638     return false;
6639   }
6640 
6641   private boolean jj_3R_62()
6642  {
6643     Token xsp;
6644     xsp = jj_scanpos;
6645     if (jj_scan_token(29)) {
6646     jj_scanpos = xsp;
6647     if (jj_scan_token(41)) return true;
6648     }
6649     if (jj_3R_107()) return true;
6650     return false;
6651   }
6652 
6653   private boolean jj_3R_63()
6654  {
6655     if (jj_scan_token(range)) return true;
6656     if (jj_3R_107()) return true;
6657     return false;
6658   }
6659 
6660   private boolean jj_3R_107()
6661  {
6662     if (jj_3R_108()) return true;
6663     Token xsp;
6664     xsp = jj_scanpos;
6665     if (jj_3_51()) jj_scanpos = xsp;
6666     return false;
6667   }
6668 
6669   private boolean jj_3_51()
6670  {
6671     Token xsp;
6672     xsp = jj_scanpos;
6673     if (jj_3R_64()) {
6674     jj_scanpos = xsp;
6675     if (jj_3R_65()) {
6676     jj_scanpos = xsp;
6677     if (jj_3R_66()) {
6678     jj_scanpos = xsp;
6679     if (jj_3R_67()) {
6680     jj_scanpos = xsp;
6681     if (jj_3R_68()) {
6682     jj_scanpos = xsp;
6683     if (jj_3R_69()) {
6684     jj_scanpos = xsp;
6685     if (jj_3R_70()) {
6686     jj_scanpos = xsp;
6687     if (jj_3R_71()) {
6688     jj_scanpos = xsp;
6689     if (jj_3R_72()) {
6690     jj_scanpos = xsp;
6691     if (jj_3R_73()) return true;
6692     }
6693     }
6694     }
6695     }
6696     }
6697     }
6698     }
6699     }
6700     }
6701     return false;
6702   }
6703 
6704   private boolean jj_3R_64()
6705  {
6706     Token xsp;
6707     xsp = jj_scanpos;
6708     if (jj_scan_token(32)) {
6709     jj_scanpos = xsp;
6710     if (jj_scan_token(44)) return true;
6711     }
6712     if (jj_3R_108()) return true;
6713     return false;
6714   }
6715 
6716   private boolean jj_3R_65()
6717  {
6718     Token xsp;
6719     xsp = jj_scanpos;
6720     if (jj_scan_token(30)) {
6721     jj_scanpos = xsp;
6722     if (jj_scan_token(42)) return true;
6723     }
6724     if (jj_3R_108()) return true;
6725     return false;
6726   }
6727 
6728   private boolean jj_3R_66()
6729  {
6730     Token xsp;
6731     xsp = jj_scanpos;
6732     if (jj_scan_token(33)) {
6733     jj_scanpos = xsp;
6734     if (jj_scan_token(45)) return true;
6735     }
6736     if (jj_3R_108()) return true;
6737     return false;
6738   }
6739 
6740   private boolean jj_3R_67()
6741  {
6742     Token xsp;
6743     xsp = jj_scanpos;
6744     if (jj_scan_token(31)) {
6745     jj_scanpos = xsp;
6746     if (jj_scan_token(43)) return true;
6747     }
6748     if (jj_3R_108()) return true;
6749     return false;
6750   }
6751 
6752   private boolean jj_3R_68()
6753  {
6754     if (jj_scan_token(req)) return true;
6755     if (jj_3R_108()) return true;
6756     return false;
6757   }
6758 
6759   private boolean jj_3R_69()
6760  {
6761     if (jj_scan_token(rne)) return true;
6762     if (jj_3R_108()) return true;
6763     return false;
6764   }
6765 
6766   private boolean jj_3R_70()
6767  {
6768     if (jj_scan_token(seq)) return true;
6769     if (jj_3R_108()) return true;
6770     return false;
6771   }
6772 
6773   private boolean jj_3R_71()
6774  {
6775     if (jj_scan_token(sne)) return true;
6776     if (jj_3R_108()) return true;
6777     return false;
6778   }
6779 
6780   private boolean jj_3R_72()
6781  {
6782     if (jj_scan_token(eeq)) return true;
6783     if (jj_3R_108()) return true;
6784     return false;
6785   }
6786 
6787   private boolean jj_3R_73()
6788  {
6789     if (jj_scan_token(ene)) return true;
6790     if (jj_3R_108()) return true;
6791     return false;
6792   }
6793 
6794   private boolean jj_3R_108()
6795  {
6796     if (jj_3R_109()) return true;
6797     Token xsp;
6798     while (true) {
6799       xsp = jj_scanpos;
6800       if (jj_3_52()) { jj_scanpos = xsp; break; }
6801     }
6802     return false;
6803   }
6804 
6805   private boolean jj_3_52()
6806  {
6807     Token xsp;
6808     xsp = jj_scanpos;
6809     if (jj_3R_74()) {
6810     jj_scanpos = xsp;
6811     if (jj_3R_75()) {
6812     jj_scanpos = xsp;
6813     if (jj_3R_76()) return true;
6814     }
6815     }
6816     return false;
6817   }
6818 
6819   private boolean jj_3R_74()
6820  {
6821     if (jj_scan_token(lshift)) return true;
6822     if (jj_3R_109()) return true;
6823     return false;
6824   }
6825 
6826   private boolean jj_3R_75()
6827  {
6828     if (jj_scan_token(rshift)) return true;
6829     if (jj_3R_109()) return true;
6830     return false;
6831   }
6832 
6833   private boolean jj_3R_76()
6834  {
6835     if (jj_scan_token(rshiftu)) return true;
6836     if (jj_3R_109()) return true;
6837     return false;
6838   }
6839 
6840   private boolean jj_3R_109()
6841  {
6842     if (jj_3R_110()) return true;
6843     Token xsp;
6844     while (true) {
6845       xsp = jj_scanpos;
6846       if (jj_3_53()) { jj_scanpos = xsp; break; }
6847     }
6848     return false;
6849   }
6850 
6851   private boolean jj_3_53()
6852  {
6853     Token xsp;
6854     xsp = jj_scanpos;
6855     if (jj_3R_77()) {
6856     jj_scanpos = xsp;
6857     if (jj_3R_78()) return true;
6858     }
6859     return false;
6860   }
6861 
6862   private boolean jj_3R_77()
6863  {
6864     if (jj_scan_token(plus)) return true;
6865     if (jj_3R_110()) return true;
6866     return false;
6867   }
6868 
6869   private boolean jj_3R_78()
6870  {
6871     if (jj_scan_token(minus)) return true;
6872     if (jj_3R_110()) return true;
6873     return false;
6874   }
6875 
6876   private boolean jj_3R_110()
6877  {
6878     if (jj_3R_111()) return true;
6879     Token xsp;
6880     while (true) {
6881       xsp = jj_scanpos;
6882       if (jj_3_54()) { jj_scanpos = xsp; break; }
6883     }
6884     return false;
6885   }
6886 
6887   private boolean jj_3_54()
6888  {
6889     Token xsp;
6890     xsp = jj_scanpos;
6891     if (jj_3R_79()) {
6892     jj_scanpos = xsp;
6893     if (jj_3R_80()) {
6894     jj_scanpos = xsp;
6895     if (jj_3R_81()) return true;
6896     }
6897     }
6898     return false;
6899   }
6900 
6901   private boolean jj_3R_79()
6902  {
6903     if (jj_scan_token(mult)) return true;
6904     if (jj_3R_111()) return true;
6905     return false;
6906   }
6907 
6908   private boolean jj_3R_80()
6909  {
6910     Token xsp;
6911     xsp = jj_scanpos;
6912     if (jj_scan_token(63)) {
6913     jj_scanpos = xsp;
6914     if (jj_scan_token(75)) return true;
6915     }
6916     if (jj_3R_111()) return true;
6917     return false;
6918   }
6919 
6920   private boolean jj_3R_81()
6921  {
6922     Token xsp;
6923     xsp = jj_scanpos;
6924     if (jj_scan_token(64)) {
6925     jj_scanpos = xsp;
6926     if (jj_scan_token(76)) return true;
6927     }
6928     if (jj_3R_111()) return true;
6929     return false;
6930   }
6931 
6932   private boolean jj_3R_111()
6933  {
6934     Token xsp;
6935     xsp = jj_scanpos;
6936     if (jj_3R_137()) {
6937     jj_scanpos = xsp;
6938     if (jj_3R_138()) {
6939     jj_scanpos = xsp;
6940     if (jj_3R_139()) {
6941     jj_scanpos = xsp;
6942     if (jj_3R_140()) {
6943     jj_scanpos = xsp;
6944     if (jj_3R_141()) {
6945     jj_scanpos = xsp;
6946     if (jj_3R_142()) {
6947     jj_scanpos = xsp;
6948     if (jj_3R_143()) {
6949     jj_scanpos = xsp;
6950     if (jj_3R_144()) {
6951     jj_scanpos = xsp;
6952     if (jj_3_55()) return true;
6953     }
6954     }
6955     }
6956     }
6957     }
6958     }
6959     }
6960     }
6961     return false;
6962   }
6963 
6964   private boolean jj_3R_137()
6965  {
6966     if (jj_scan_token(minus)) return true;
6967     if (jj_3R_111()) return true;
6968     return false;
6969   }
6970 
6971   private boolean jj_3R_138()
6972  {
6973     if (jj_scan_token(plus)) return true;
6974     if (jj_3R_111()) return true;
6975     return false;
6976   }
6977 
6978   private boolean jj_3R_139()
6979  {
6980     if (jj_scan_token(tilda)) return true;
6981     if (jj_3R_111()) return true;
6982     return false;
6983   }
6984 
6985   private boolean jj_3R_140()
6986  {
6987     Token xsp;
6988     xsp = jj_scanpos;
6989     if (jj_scan_token(65)) {
6990     jj_scanpos = xsp;
6991     if (jj_scan_token(74)) return true;
6992     }
6993     if (jj_3R_111()) return true;
6994     return false;
6995   }
6996 
6997   private boolean jj_3R_141()
6998  {
6999     if (jj_scan_token(EMPTY)) return true;
7000     if (jj_3R_111()) return true;
7001     return false;
7002   }
7003 
7004   private boolean jj_3R_142()
7005  {
7006     if (jj_scan_token(SIZE)) return true;
7007     if (jj_3R_111()) return true;
7008     return false;
7009   }
7010 
7011   private boolean jj_3R_143()
7012  {
7013     if (jj_scan_token(minusminus)) return true;
7014     if (jj_3R_111()) return true;
7015     return false;
7016   }
7017 
7018   private boolean jj_3R_144()
7019  {
7020     if (jj_scan_token(plusplus)) return true;
7021     if (jj_3R_111()) return true;
7022     return false;
7023   }
7024 
7025   private boolean jj_3_55()
7026  {
7027     if (jj_3R_82()) return true;
7028     return false;
7029   }
7030 
7031   private boolean jj_3R_233()
7032  {
7033     Token xsp;
7034     xsp = jj_scanpos;
7035     if (jj_3R_234()) {
7036     jj_scanpos = xsp;
7037     if (jj_3R_235()) return true;
7038     }
7039     return false;
7040   }
7041 
7042   private boolean jj_3R_234()
7043  {
7044     if (jj_scan_token(plusplus)) return true;
7045     return false;
7046   }
7047 
7048   private boolean jj_3R_235()
7049  {
7050     if (jj_scan_token(minusminus)) return true;
7051     return false;
7052   }
7053 
7054   private boolean jj_3R_82()
7055  {
7056     if (jj_3R_112()) return true;
7057     Token xsp;
7058     xsp = jj_scanpos;
7059     if (jj_3R_232()) jj_scanpos = xsp;
7060     return false;
7061   }
7062 
7063   private boolean jj_3R_136()
7064  {
7065     Token xsp;
7066     xsp = jj_scanpos;
7067     if (jj_3R_153()) {
7068     jj_scanpos = xsp;
7069     if (jj_3R_154()) return true;
7070     }
7071     return false;
7072   }
7073 
7074   private boolean jj_3R_153()
7075  {
7076     if (jj_scan_token(IDENTIFIER)) return true;
7077     return false;
7078   }
7079 
7080   private boolean jj_3R_154()
7081  {
7082     if (jj_scan_token(REGISTER)) return true;
7083     return false;
7084   }
7085 
7086   private boolean jj_3R_232()
7087  {
7088     if (jj_3R_233()) return true;
7089     return false;
7090   }
7091 
7092   private boolean jj_3R_211()
7093  {
7094     if (jj_scan_token(IDENTIFIER)) return true;
7095     if (jj_scan_token(COLON)) return true;
7096     if (jj_scan_token(IDENTIFIER)) return true;
7097     return false;
7098   }
7099 
7100   private boolean jj_3R_178()
7101  {
7102     Token xsp;
7103     xsp = jj_scanpos;
7104     if (jj_3R_193()) {
7105     jj_scanpos = xsp;
7106     if (jj_3R_194()) {
7107     jj_scanpos = xsp;
7108     if (jj_3R_195()) {
7109     jj_scanpos = xsp;
7110     if (jj_3R_196()) {
7111     jj_scanpos = xsp;
7112     if (jj_3R_197()) {
7113     jj_scanpos = xsp;
7114     if (jj_3R_198()) {
7115     jj_scanpos = xsp;
7116     if (jj_3R_199()) {
7117     jj_scanpos = xsp;
7118     if (jj_3R_200()) return true;
7119     }
7120     }
7121     }
7122     }
7123     }
7124     }
7125     }
7126     return false;
7127   }
7128 
7129   private boolean jj_3R_193()
7130  {
7131     if (jj_3R_212()) return true;
7132     return false;
7133   }
7134 
7135   private boolean jj_3R_194()
7136  {
7137     if (jj_3R_213()) return true;
7138     return false;
7139   }
7140 
7141   private boolean jj_3R_195()
7142  {
7143     if (jj_3R_214()) return true;
7144     return false;
7145   }
7146 
7147   private boolean jj_3R_196()
7148  {
7149     if (jj_3R_215()) return true;
7150     return false;
7151   }
7152 
7153   private boolean jj_3R_197()
7154  {
7155     if (jj_3R_216()) return true;
7156     return false;
7157   }
7158 
7159   private boolean jj_3R_198()
7160  {
7161     if (jj_3R_217()) return true;
7162     return false;
7163   }
7164 
7165   private boolean jj_3R_199()
7166  {
7167     if (jj_3R_218()) return true;
7168     return false;
7169   }
7170 
7171   private boolean jj_3R_200()
7172  {
7173     if (jj_3R_219()) return true;
7174     return false;
7175   }
7176 
7177   private boolean jj_3R_219()
7178  {
7179     if (jj_scan_token(NAN_LITERAL)) return true;
7180     return false;
7181   }
7182 
7183   private boolean jj_3R_218()
7184  {
7185     if (jj_scan_token(NULL)) return true;
7186     return false;
7187   }
7188 
7189   private boolean jj_3R_214()
7190  {
7191     Token xsp;
7192     xsp = jj_scanpos;
7193     if (jj_3R_226()) {
7194     jj_scanpos = xsp;
7195     if (jj_3R_227()) return true;
7196     }
7197     return false;
7198   }
7199 
7200   private boolean jj_3R_226()
7201  {
7202     if (jj_scan_token(TRUE)) return true;
7203     return false;
7204   }
7205 
7206   private boolean jj_3R_227()
7207  {
7208     if (jj_scan_token(FALSE)) return true;
7209     return false;
7210   }
7211 
7212   private boolean jj_3R_212()
7213  {
7214     if (jj_scan_token(INTEGER_LITERAL)) return true;
7215     return false;
7216   }
7217 
7218   private boolean jj_3R_213()
7219  {
7220     if (jj_scan_token(FLOAT_LITERAL)) return true;
7221     return false;
7222   }
7223 
7224   private boolean jj_3R_216()
7225  {
7226     if (jj_scan_token(STRING_LITERAL)) return true;
7227     return false;
7228   }
7229 
7230   private boolean jj_3_1()
7231  {
7232     Token xsp;
7233     xsp = jj_scanpos;
7234     if (jj_3R_31()) {
7235     jj_scanpos = xsp;
7236     if (jj_3_3()) return true;
7237     }
7238     return false;
7239   }
7240 
7241   private boolean jj_3R_31()
7242  {
7243     if (jj_3R_88()) return true;
7244     return false;
7245   }
7246 
7247   private boolean jj_3R_215()
7248  {
7249     if (jj_scan_token(JXLT_LITERAL)) return true;
7250     return false;
7251   }
7252 
7253   private boolean jj_3_2()
7254  {
7255     if (jj_scan_token(PRAGMA)) return true;
7256     return false;
7257   }
7258 
7259   private boolean jj_3R_217()
7260  {
7261     if (jj_scan_token(REGEX_LITERAL)) return true;
7262     return false;
7263   }
7264 
7265   private boolean jj_3R_242()
7266  {
7267     if (jj_scan_token(ELIPSIS)) return true;
7268     return false;
7269   }
7270 
7271   private boolean jj_3R_169()
7272  {
7273     if (jj_scan_token(ANNOTATION)) return true;
7274     Token xsp;
7275     xsp = jj_scanpos;
7276     if (jj_3R_231()) jj_scanpos = xsp;
7277     return false;
7278   }
7279 
7280   private boolean jj_3R_175()
7281  {
7282     if (jj_scan_token(LBRACKET)) return true;
7283     Token xsp;
7284     xsp = jj_scanpos;
7285     if (jj_3R_237()) {
7286     jj_scanpos = xsp;
7287     if (jj_3R_238()) return true;
7288     }
7289     if (jj_scan_token(RBRACKET)) return true;
7290     return false;
7291   }
7292 
7293   private boolean jj_3R_123()
7294  {
7295     Token xsp;
7296     if (jj_3R_152()) return true;
7297     while (true) {
7298       xsp = jj_scanpos;
7299       if (jj_3R_152()) { jj_scanpos = xsp; break; }
7300     }
7301     xsp = jj_scanpos;
7302     if (jj_3R_228()) {
7303     jj_scanpos = xsp;
7304     if (jj_3_7()) return true;
7305     }
7306     return false;
7307   }
7308 
7309   private boolean jj_3R_152()
7310  {
7311     if (jj_3R_169()) return true;
7312     return false;
7313   }
7314 
7315   private boolean jj_3R_32()
7316  {
7317     Token xsp;
7318     xsp = jj_scanpos;
7319     if (jj_3R_89()) {
7320     jj_scanpos = xsp;
7321     if (jj_3R_90()) {
7322     jj_scanpos = xsp;
7323     if (jj_3_10()) return true;
7324     }
7325     }
7326     return false;
7327   }
7328 
7329   private boolean jj_3R_89()
7330  {
7331     if (jj_3R_103()) return true;
7332     return false;
7333   }
7334 
7335   private boolean jj_3R_237()
7336  {
7337     if (jj_3R_242()) return true;
7338     return false;
7339   }
7340 
7341   private boolean jj_3_3()
7342  {
7343     if (jj_3R_32()) return true;
7344     return false;
7345   }
7346 
7347   private boolean jj_3R_90()
7348  {
7349     if (jj_3R_121()) return true;
7350     return false;
7351   }
7352 
7353   private boolean jj_3R_238()
7354  {
7355     Token xsp;
7356     xsp = jj_scanpos;
7357     if (jj_3_57()) jj_scanpos = xsp;
7358     xsp = jj_scanpos;
7359     if (jj_3R_243()) jj_scanpos = xsp;
7360     return false;
7361   }
7362 
7363   private boolean jj_3_57()
7364  {
7365     if (jj_3R_33()) return true;
7366     Token xsp;
7367     while (true) {
7368       xsp = jj_scanpos;
7369       if (jj_3_56()) { jj_scanpos = xsp; break; }
7370     }
7371     return false;
7372   }
7373 
7374   private boolean jj_3_10()
7375  {
7376     if (jj_3R_34()) return true;
7377     return false;
7378   }
7379 
7380   private boolean jj_3R_173()
7381  {
7382     if (jj_scan_token(LCURLY)) return true;
7383     Token xsp;
7384     xsp = jj_scanpos;
7385     if (jj_3_58()) {
7386     jj_scanpos = xsp;
7387     if (jj_scan_token(16)) return true;
7388     }
7389     if (jj_scan_token(RCURLY)) return true;
7390     return false;
7391   }
7392 
7393   private boolean jj_3_6()
7394  {
7395     if (jj_scan_token(ANNOTATION)) return true;
7396     return false;
7397   }
7398 
7399   private boolean jj_3R_231()
7400  {
7401     if (jj_3R_150()) return true;
7402     return false;
7403   }
7404 
7405   private boolean jj_3R_34()
7406  {
7407     Token xsp;
7408     xsp = jj_scanpos;
7409     if (jj_scan_token(15)) {
7410     jj_scanpos = xsp;
7411     if (jj_3R_92()) {
7412     jj_scanpos = xsp;
7413     if (jj_3R_93()) {
7414     jj_scanpos = xsp;
7415     if (jj_3R_94()) {
7416     jj_scanpos = xsp;
7417     if (jj_3R_95()) {
7418     jj_scanpos = xsp;
7419     if (jj_3R_96()) {
7420     jj_scanpos = xsp;
7421     if (jj_3R_97()) {
7422     jj_scanpos = xsp;
7423     if (jj_3R_98()) {
7424     jj_scanpos = xsp;
7425     if (jj_3R_99()) {
7426     jj_scanpos = xsp;
7427     if (jj_3R_100()) {
7428     jj_scanpos = xsp;
7429     if (jj_3R_101()) {
7430     jj_scanpos = xsp;
7431     jj_lookingAhead = true;
7432     jj_semLA = !getFeatures().isLexical();
7433     jj_lookingAhead = false;
7434     if (!jj_semLA || jj_3R_102()) return true;
7435     }
7436     }
7437     }
7438     }
7439     }
7440     }
7441     }
7442     }
7443     }
7444     }
7445     }
7446     return false;
7447   }
7448 
7449   private boolean jj_3_8()
7450  {
7451     Token xsp;
7452     xsp = jj_scanpos;
7453     if (jj_scan_token(93)) {
7454     jj_scanpos = xsp;
7455     if (jj_scan_token(94)) {
7456     jj_scanpos = xsp;
7457     if (jj_scan_token(92)) return true;
7458     }
7459     }
7460     return false;
7461   }
7462 
7463   private boolean jj_3_58()
7464  {
7465     if (jj_3R_83()) return true;
7466     Token xsp;
7467     while (true) {
7468       xsp = jj_scanpos;
7469       if (jj_3R_240()) { jj_scanpos = xsp; break; }
7470     }
7471     return false;
7472   }
7473 
7474   private boolean jj_3_9()
7475  {
7476     if (jj_scan_token(FUNCTION)) return true;
7477     if (jj_scan_token(IDENTIFIER)) return true;
7478     return false;
7479   }
7480 
7481   private boolean jj_3R_92()
7482  {
7483     if (jj_3R_123()) return true;
7484     return false;
7485   }
7486 
7487   private boolean jj_3R_93()
7488  {
7489     if (jj_3R_124()) return true;
7490     return false;
7491   }
7492 
7493   private boolean jj_3R_94()
7494  {
7495     if (jj_3R_125()) return true;
7496     return false;
7497   }
7498 
7499   private boolean jj_3R_83()
7500  {
7501     if (jj_3R_33()) return true;
7502     if (jj_scan_token(COLON)) return true;
7503     if (jj_3R_33()) return true;
7504     return false;
7505   }
7506 
7507   private boolean jj_3R_95()
7508  {
7509     if (jj_3R_126()) return true;
7510     return false;
7511   }
7512 
7513   private boolean jj_3_5()
7514  {
7515     if (jj_scan_token(LPAREN)) return true;
7516     return false;
7517   }
7518 
7519   private boolean jj_3R_96()
7520  {
7521     if (jj_3R_127()) return true;
7522     return false;
7523   }
7524 
7525   private boolean jj_3_56()
7526  {
7527     if (jj_scan_token(COMMA)) return true;
7528     if (jj_3R_33()) return true;
7529     return false;
7530   }
7531 
7532   private boolean jj_3R_97()
7533  {
7534     if (jj_3R_128()) return true;
7535     return false;
7536   }
7537 
7538   private boolean jj_3R_98()
7539  {
7540     if (jj_3R_129()) return true;
7541     return false;
7542   }
7543 
7544   private boolean jj_3R_99()
7545  {
7546     if (jj_3R_130()) return true;
7547     return false;
7548   }
7549 
7550   private boolean jj_3R_100()
7551  {
7552     if (jj_3R_131()) return true;
7553     return false;
7554   }
7555 
7556   private boolean jj_3R_174()
7557  {
7558     if (jj_scan_token(LCURLY)) return true;
7559     Token xsp;
7560     xsp = jj_scanpos;
7561     if (jj_3_59()) jj_scanpos = xsp;
7562     if (jj_scan_token(RCURLY)) return true;
7563     return false;
7564   }
7565 
7566   private boolean jj_3R_101()
7567  {
7568     if (jj_3R_36()) return true;
7569     return false;
7570   }
7571 
7572   private boolean jj_3_4()
7573  {
7574     if (jj_3R_33()) return true;
7575     return false;
7576   }
7577 
7578   private boolean jj_3_11()
7579  {
7580     if (jj_scan_token(ANNOTATION)) return true;
7581     return false;
7582   }
7583 
7584   private boolean jj_3R_102()
7585  {
7586     if (jj_3R_103()) return true;
7587     return false;
7588   }
7589 
7590   private boolean jj_3_12()
7591  {
7592     if (jj_scan_token(IF)) return true;
7593     return false;
7594   }
7595 
7596   private boolean jj_3_13()
7597  {
7598     if (jj_scan_token(FOR)) return true;
7599     return false;
7600   }
7601 
7602   private boolean jj_3R_240()
7603  {
7604     if (jj_scan_token(COMMA)) return true;
7605     if (jj_3R_83()) return true;
7606     return false;
7607   }
7608 
7609   private boolean jj_3_14()
7610  {
7611     if (jj_scan_token(WHILE)) return true;
7612     return false;
7613   }
7614 
7615   private boolean jj_3R_36()
7616  {
7617     if (jj_scan_token(LCURLY)) return true;
7618     Token xsp;
7619     while (true) {
7620       xsp = jj_scanpos;
7621       if (jj_3_21()) { jj_scanpos = xsp; break; }
7622     }
7623     if (jj_scan_token(RCURLY)) return true;
7624     return false;
7625   }
7626 
7627   private boolean jj_3_15()
7628  {
7629     if (jj_scan_token(DO)) return true;
7630     return false;
7631   }
7632 
7633   private boolean jj_3R_121()
7634  {
7635     if (jj_scan_token(FUNCTION)) return true;
7636     if (jj_3R_208()) return true;
7637     if (jj_3R_209()) return true;
7638     Token xsp;
7639     xsp = jj_scanpos;
7640     if (jj_3_24()) {
7641     jj_scanpos = xsp;
7642     if (jj_3_25()) return true;
7643     }
7644     return false;
7645   }
7646 
7647   private boolean jj_3_16()
7648  {
7649     if (jj_scan_token(RETURN)) return true;
7650     return false;
7651   }
7652 
7653   private boolean jj_3_17()
7654  {
7655     if (jj_scan_token(CONTINUE)) return true;
7656     return false;
7657   }
7658 
7659   private boolean jj_3_18()
7660  {
7661     if (jj_scan_token(BREAK)) return true;
7662     return false;
7663   }
7664 
7665   private boolean jj_3_19()
7666  {
7667     if (jj_3R_33()) return true;
7668     return false;
7669   }
7670 
7671   private boolean jj_3_59()
7672  {
7673     if (jj_3R_33()) return true;
7674     Token xsp;
7675     while (true) {
7676       xsp = jj_scanpos;
7677       if (jj_3R_241()) { jj_scanpos = xsp; break; }
7678     }
7679     return false;
7680   }
7681 
7682   private boolean jj_3R_150()
7683  {
7684     if (jj_scan_token(LPAREN)) return true;
7685     Token xsp;
7686     xsp = jj_scanpos;
7687     if (jj_3_60()) jj_scanpos = xsp;
7688     if (jj_scan_token(RPAREN)) return true;
7689     return false;
7690   }
7691 
7692   private boolean jj_3_20()
7693  {
7694     if (jj_scan_token(VAR)) return true;
7695     return false;
7696   }
7697 
7698   private boolean jj_3R_85()
7699  {
7700     Token xsp;
7701     xsp = jj_scanpos;
7702     jj_lookingAhead = true;
7703     jj_semLA = isDeclaredNamespace(getToken(1), getToken(2));
7704     jj_lookingAhead = false;
7705     if (!jj_semLA || jj_3R_116()) {
7706     jj_scanpos = xsp;
7707     if (jj_3_62()) {
7708     jj_scanpos = xsp;
7709     if (jj_3_63()) return true;
7710     }
7711     }
7712     return false;
7713   }
7714 
7715   private boolean jj_3R_116()
7716  {
7717     if (jj_scan_token(IDENTIFIER)) return true;
7718     if (jj_scan_token(COLON)) return true;
7719     if (jj_scan_token(IDENTIFIER)) return true;
7720     if (jj_scan_token(LPAREN)) return true;
7721     return false;
7722   }
7723 
7724   private boolean jj_3R_131()
7725  {
7726     if (jj_3R_33()) return true;
7727     Token xsp;
7728     while (true) {
7729       xsp = jj_scanpos;
7730       if (jj_3R_230()) { jj_scanpos = xsp; break; }
7731     }
7732     xsp = jj_scanpos;
7733     if (jj_scan_token(15)) jj_scanpos = xsp;
7734     return false;
7735   }
7736 
7737   private boolean jj_3R_228()
7738  {
7739     if (jj_3R_36()) return true;
7740     return false;
7741   }
7742 
7743   private boolean jj_3_62()
7744  {
7745     if (jj_scan_token(IDENTIFIER)) return true;
7746     if (jj_scan_token(LPAREN)) return true;
7747     return false;
7748   }
7749 
7750   private boolean jj_3_63()
7751  {
7752     if (jj_scan_token(REGISTER)) return true;
7753     if (jj_scan_token(LPAREN)) return true;
7754     return false;
7755   }
7756 
7757   private boolean jj_3_60()
7758  {
7759     if (jj_3R_33()) return true;
7760     Token xsp;
7761     while (true) {
7762       xsp = jj_scanpos;
7763       if (jj_3R_184()) { jj_scanpos = xsp; break; }
7764     }
7765     return false;
7766   }
7767 
7768   private boolean jj_3R_124()
7769  {
7770     if (jj_scan_token(IF)) return true;
7771     if (jj_scan_token(LPAREN)) return true;
7772     if (jj_3R_33()) return true;
7773     if (jj_scan_token(RPAREN)) return true;
7774     Token xsp;
7775     xsp = jj_scanpos;
7776     if (jj_3R_262()) {
7777     jj_scanpos = xsp;
7778     if (jj_3_27()) return true;
7779     }
7780     while (true) {
7781       xsp = jj_scanpos;
7782       if (jj_3_28()) { jj_scanpos = xsp; break; }
7783     }
7784     xsp = jj_scanpos;
7785     if (jj_3R_263()) jj_scanpos = xsp;
7786     return false;
7787   }
7788 
7789   private boolean jj_3_28()
7790  {
7791     if (jj_scan_token(ELSE)) return true;
7792     if (jj_scan_token(IF)) return true;
7793     if (jj_scan_token(LPAREN)) return true;
7794     if (jj_3R_33()) return true;
7795     if (jj_scan_token(RPAREN)) return true;
7796     Token xsp;
7797     xsp = jj_scanpos;
7798     if (jj_3R_266()) {
7799     jj_scanpos = xsp;
7800     if (jj_3_29()) return true;
7801     }
7802     return false;
7803   }
7804 
7805   private boolean jj_3R_177()
7806  {
7807     Token xsp;
7808     xsp = jj_scanpos;
7809     jj_lookingAhead = true;
7810     jj_semLA = isDeclaredNamespace(getToken(1), getToken(2));
7811     jj_lookingAhead = false;
7812     if (!jj_semLA || jj_3R_191()) {
7813     jj_scanpos = xsp;
7814     if (jj_3R_192()) return true;
7815     }
7816     return false;
7817   }
7818 
7819   private boolean jj_3R_191()
7820  {
7821     if (jj_3R_211()) return true;
7822     if (jj_3R_150()) return true;
7823     return false;
7824   }
7825 
7826   private boolean jj_3_61()
7827  {
7828     if (jj_scan_token(IDENTIFIER)) return true;
7829     if (jj_scan_token(COLON)) return true;
7830     if (jj_scan_token(IDENTIFIER)) return true;
7831     if (jj_scan_token(LPAREN)) return true;
7832     return false;
7833   }
7834 
7835   private boolean jj_3R_241()
7836  {
7837     if (jj_scan_token(COMMA)) return true;
7838     if (jj_3R_33()) return true;
7839     return false;
7840   }
7841 
7842   private boolean jj_3R_263()
7843  {
7844     if (jj_scan_token(ELSE)) return true;
7845     Token xsp;
7846     xsp = jj_scanpos;
7847     if (jj_3R_267()) {
7848     jj_scanpos = xsp;
7849     if (jj_3_30()) return true;
7850     }
7851     return false;
7852   }
7853 
7854   private boolean jj_3R_192()
7855  {
7856     if (jj_3R_136()) return true;
7857     if (jj_3R_150()) return true;
7858     return false;
7859   }
7860 
7861   private boolean jj_3R_126()
7862  {
7863     if (jj_scan_token(WHILE)) return true;
7864     if (jj_scan_token(LPAREN)) return true;
7865     if (jj_3R_33()) return true;
7866     if (jj_scan_token(RPAREN)) return true;
7867     Token xsp;
7868     xsp = jj_scanpos;
7869     if (jj_3R_265()) {
7870     jj_scanpos = xsp;
7871     if (jj_3_31()) return true;
7872     }
7873     return false;
7874   }
7875 
7876   private boolean jj_3R_230()
7877  {
7878     if (jj_3R_33()) return true;
7879     return false;
7880   }
7881 
7882   private boolean jj_3R_127()
7883  {
7884     if (jj_scan_token(DO)) return true;
7885     Token xsp;
7886     xsp = jj_scanpos;
7887     if (jj_3R_229()) {
7888     jj_scanpos = xsp;
7889     if (jj_3_32()) return true;
7890     }
7891     if (jj_scan_token(WHILE)) return true;
7892     if (jj_scan_token(LPAREN)) return true;
7893     if (jj_3R_33()) return true;
7894     if (jj_scan_token(RPAREN)) return true;
7895     return false;
7896   }
7897 
7898   private boolean jj_3R_245()
7899  {
7900     if (jj_3R_170()) return true;
7901     return false;
7902   }
7903 
7904   private boolean jj_3_64()
7905  {
7906     if (jj_scan_token(IDENTIFIER)) return true;
7907     if (jj_scan_token(COLON)) return true;
7908     if (jj_scan_token(IDENTIFIER)) return true;
7909     if (jj_scan_token(LPAREN)) return true;
7910     return false;
7911   }
7912 
7913   private boolean jj_3R_184()
7914  {
7915     if (jj_scan_token(COMMA)) return true;
7916     if (jj_3R_33()) return true;
7917     return false;
7918   }
7919 
7920   private boolean jj_3_65()
7921  {
7922     if (jj_scan_token(IDENTIFIER)) return true;
7923     if (jj_scan_token(LPAREN)) return true;
7924     return false;
7925   }
7926 
7927   private boolean jj_3_67()
7928  {
7929     if (jj_scan_token(NEW)) return true;
7930     if (jj_scan_token(LPAREN)) return true;
7931     if (jj_3R_33()) return true;
7932     Token xsp;
7933     while (true) {
7934       xsp = jj_scanpos;
7935       if (jj_3R_244()) { jj_scanpos = xsp; break; }
7936     }
7937     if (jj_scan_token(RPAREN)) return true;
7938     return false;
7939   }
7940 
7941   private boolean jj_3R_176()
7942  {
7943     Token xsp;
7944     xsp = jj_scanpos;
7945     if (jj_3_67()) {
7946     jj_scanpos = xsp;
7947     if (jj_3R_190()) return true;
7948     }
7949     return false;
7950   }
7951 
7952   private boolean jj_3R_243()
7953  {
7954     if (jj_scan_token(COMMA)) return true;
7955     if (jj_3R_242()) return true;
7956     return false;
7957   }
7958 
7959   private boolean jj_3R_128()
7960  {
7961     if (jj_scan_token(RETURN)) return true;
7962     if (jj_3R_131()) return true;
7963     return false;
7964   }
7965 
7966   private boolean jj_3R_190()
7967  {
7968     if (jj_scan_token(NEW)) return true;
7969     if (jj_3R_245()) return true;
7970     if (jj_scan_token(LPAREN)) return true;
7971     Token xsp;
7972     xsp = jj_scanpos;
7973     if (jj_3_66()) jj_scanpos = xsp;
7974     if (jj_scan_token(RPAREN)) return true;
7975     return false;
7976   }
7977 
7978   private boolean jj_3_7()
7979  {
7980     if (jj_3R_32()) return true;
7981     return false;
7982   }
7983 
7984   private boolean jj_3_21()
7985  {
7986     Token xsp;
7987     xsp = jj_scanpos;
7988     if (jj_3R_35()) {
7989     jj_scanpos = xsp;
7990     if (jj_3_23()) return true;
7991     }
7992     return false;
7993   }
7994 
7995   private boolean jj_3_26()
7996  {
7997     if (jj_3R_33()) return true;
7998     return false;
7999   }
8000 
8001   private boolean jj_3R_35()
8002  {
8003     if (jj_3R_88()) return true;
8004     return false;
8005   }
8006 
8007   private boolean jj_3R_129()
8008  {
8009     if (jj_scan_token(CONTINUE)) return true;
8010     return false;
8011   }
8012 
8013   private boolean jj_3R_267()
8014  {
8015     if (jj_3R_36()) return true;
8016     return false;
8017   }
8018 
8019   private boolean jj_3R_210()
8020  {
8021     Token xsp;
8022     xsp = jj_scanpos;
8023     if (jj_3R_223()) {
8024     jj_scanpos = xsp;
8025     if (jj_3R_224()) {
8026     jj_scanpos = xsp;
8027     if (jj_3R_225()) return true;
8028     }
8029     }
8030     return false;
8031   }
8032 
8033   private boolean jj_3R_223()
8034  {
8035     Token xsp;
8036     xsp = jj_scanpos;
8037     if (jj_scan_token(92)) jj_scanpos = xsp;
8038     if (jj_scan_token(IDENTIFIER)) return true;
8039     return false;
8040   }
8041 
8042   private boolean jj_3_22()
8043  {
8044     if (jj_scan_token(PRAGMA)) return true;
8045     return false;
8046   }
8047 
8048   private boolean jj_3R_224()
8049  {
8050     if (jj_scan_token(LET)) return true;
8051     if (jj_scan_token(IDENTIFIER)) return true;
8052     return false;
8053   }
8054 
8055   private boolean jj_3R_130()
8056  {
8057     if (jj_scan_token(BREAK)) return true;
8058     return false;
8059   }
8060 
8061   private boolean jj_3R_225()
8062  {
8063     if (jj_scan_token(CONST)) return true;
8064     if (jj_scan_token(IDENTIFIER)) return true;
8065     return false;
8066   }
8067 
8068   private boolean jj_3R_209()
8069  {
8070     if (jj_scan_token(LPAREN)) return true;
8071     Token xsp;
8072     xsp = jj_scanpos;
8073     if (jj_3R_246()) jj_scanpos = xsp;
8074     if (jj_scan_token(RPAREN)) return true;
8075     return false;
8076   }
8077 
8078   private boolean jj_3R_262()
8079  {
8080     if (jj_3R_36()) return true;
8081     return false;
8082   }
8083 
8084   private boolean jj_3R_125()
8085  {
8086     if (jj_scan_token(FOR)) return true;
8087     if (jj_scan_token(LPAREN)) return true;
8088     Token xsp;
8089     xsp = jj_scanpos;
8090     if (jj_3_37()) {
8091     jj_scanpos = xsp;
8092     if (jj_3_38()) return true;
8093     }
8094     if (jj_scan_token(RPAREN)) return true;
8095     xsp = jj_scanpos;
8096     if (jj_3R_264()) {
8097     jj_scanpos = xsp;
8098     if (jj_3_39()) return true;
8099     }
8100     return false;
8101   }
8102 
8103   private boolean jj_3R_229()
8104  {
8105     if (jj_3R_36()) return true;
8106     return false;
8107   }
8108 
8109   private boolean jj_3R_146()
8110  {
8111     if (jj_scan_token(LPAREN)) return true;
8112     Token xsp;
8113     xsp = jj_scanpos;
8114     if (jj_3R_166()) jj_scanpos = xsp;
8115     if (jj_scan_token(RPAREN)) return true;
8116     return false;
8117   }
8118 
8119   private boolean jj_3R_84()
8120  {
8121     Token xsp;
8122     xsp = jj_scanpos;
8123     if (jj_3R_113()) {
8124     jj_scanpos = xsp;
8125     if (jj_3R_114()) {
8126     jj_scanpos = xsp;
8127     if (jj_3R_115()) return true;
8128     }
8129     }
8130     return false;
8131   }
8132 
8133   private boolean jj_3R_113()
8134  {
8135     if (jj_scan_token(FUNCTION)) return true;
8136     if (jj_3R_146()) return true;
8137     return false;
8138   }
8139 
8140   private boolean jj_3R_114()
8141  {
8142     if (jj_3R_146()) return true;
8143     Token xsp;
8144     xsp = jj_scanpos;
8145     if (jj_scan_token(77)) {
8146     jj_scanpos = xsp;
8147     if (jj_scan_token(78)) return true;
8148     }
8149     return false;
8150   }
8151 
8152   private boolean jj_3_37()
8153  {
8154     if (jj_3R_38()) return true;
8155     if (jj_scan_token(COLON)) return true;
8156     if (jj_3R_33()) return true;
8157     return false;
8158   }
8159 
8160   private boolean jj_3R_246()
8161  {
8162     if (jj_3R_210()) return true;
8163     Token xsp;
8164     while (true) {
8165       xsp = jj_scanpos;
8166       if (jj_3R_248()) { jj_scanpos = xsp; break; }
8167     }
8168     return false;
8169   }
8170 
8171   private boolean jj_3R_115()
8172  {
8173     if (jj_scan_token(IDENTIFIER)) return true;
8174     Token xsp;
8175     xsp = jj_scanpos;
8176     if (jj_scan_token(77)) {
8177     jj_scanpos = xsp;
8178     if (jj_scan_token(78)) return true;
8179     }
8180     return false;
8181   }
8182 
8183   private boolean jj_3_30()
8184  {
8185     if (jj_3R_34()) return true;
8186     return false;
8187   }
8188 
8189   private boolean jj_3_38()
8190  {
8191     Token xsp;
8192     xsp = jj_scanpos;
8193     if (jj_3_34()) jj_scanpos = xsp;
8194     if (jj_scan_token(SEMICOL)) return true;
8195     xsp = jj_scanpos;
8196     if (jj_3_35()) jj_scanpos = xsp;
8197     if (jj_scan_token(SEMICOL)) return true;
8198     xsp = jj_scanpos;
8199     if (jj_3_36()) jj_scanpos = xsp;
8200     return false;
8201   }
8202 
8203   private boolean jj_3_23()
8204  {
8205     if (jj_3R_32()) return true;
8206     return false;
8207   }
8208 
8209   private boolean jj_3_34()
8210  {
8211     Token xsp;
8212     xsp = jj_scanpos;
8213     if (jj_3R_37()) {
8214     jj_scanpos = xsp;
8215     if (jj_3_33()) return true;
8216     }
8217     return false;
8218   }
8219 
8220   private boolean jj_3_35()
8221  {
8222     if (jj_3R_33()) return true;
8223     return false;
8224   }
8225 
8226   private boolean jj_3R_37()
8227  {
8228     if (jj_3R_103()) return true;
8229     return false;
8230   }
8231 
8232   private boolean jj_3_36()
8233  {
8234     if (jj_3R_33()) return true;
8235     return false;
8236   }
8237 
8238   private boolean jj_3R_166()
8239  {
8240     Token xsp;
8241     xsp = jj_scanpos;
8242     if (jj_3R_179()) jj_scanpos = xsp;
8243     if (jj_scan_token(IDENTIFIER)) return true;
8244     while (true) {
8245       xsp = jj_scanpos;
8246       if (jj_3R_180()) { jj_scanpos = xsp; break; }
8247     }
8248     return false;
8249   }
8250 
8251   private boolean jj_3R_179()
8252  {
8253     Token xsp;
8254     xsp = jj_scanpos;
8255     if (jj_scan_token(92)) {
8256     jj_scanpos = xsp;
8257     if (jj_scan_token(93)) {
8258     jj_scanpos = xsp;
8259     if (jj_scan_token(94)) return true;
8260     }
8261     }
8262     return false;
8263   }
8264 
8265   private boolean jj_3_66()
8266  {
8267     if (jj_3R_33()) return true;
8268     Token xsp;
8269     while (true) {
8270       xsp = jj_scanpos;
8271       if (jj_3R_247()) { jj_scanpos = xsp; break; }
8272     }
8273     return false;
8274   }
8275 
8276   private boolean jj_3R_171()
8277  {
8278     Token xsp;
8279     xsp = jj_scanpos;
8280     if (jj_3R_187()) {
8281     jj_scanpos = xsp;
8282     if (jj_3R_188()) {
8283     jj_scanpos = xsp;
8284     if (jj_3R_189()) return true;
8285     }
8286     }
8287     return false;
8288   }
8289 
8290   private boolean jj_3R_187()
8291  {
8292     if (jj_scan_token(FUNCTION)) return true;
8293     Token xsp;
8294     xsp = jj_scanpos;
8295     if (jj_3R_239()) jj_scanpos = xsp;
8296     if (jj_3R_209()) return true;
8297     xsp = jj_scanpos;
8298     if (jj_3_69()) {
8299     jj_scanpos = xsp;
8300     if (jj_3_70()) return true;
8301     }
8302     return false;
8303   }
8304 
8305   private boolean jj_3R_244()
8306  {
8307     if (jj_scan_token(COMMA)) return true;
8308     if (jj_3R_33()) return true;
8309     return false;
8310   }
8311 
8312   private boolean jj_3R_264()
8313  {
8314     if (jj_3R_36()) return true;
8315     return false;
8316   }
8317 
8318   private boolean jj_3_27()
8319  {
8320     if (jj_3R_34()) return true;
8321     return false;
8322   }
8323 
8324   private boolean jj_3R_188()
8325  {
8326     if (jj_3R_209()) return true;
8327     Token xsp;
8328     xsp = jj_scanpos;
8329     if (jj_scan_token(77)) {
8330     jj_scanpos = xsp;
8331     if (jj_scan_token(78)) return true;
8332     }
8333     xsp = jj_scanpos;
8334     if (jj_3_71()) {
8335     jj_scanpos = xsp;
8336     if (jj_3_72()) return true;
8337     }
8338     return false;
8339   }
8340 
8341   private boolean jj_3R_248()
8342  {
8343     if (jj_scan_token(COMMA)) return true;
8344     if (jj_3R_210()) return true;
8345     return false;
8346   }
8347 
8348   private boolean jj_3R_266()
8349  {
8350     if (jj_3R_36()) return true;
8351     return false;
8352   }
8353 
8354   private boolean jj_3_32()
8355  {
8356     if (jj_3R_34()) return true;
8357     return false;
8358   }
8359 
8360   private boolean jj_3R_189()
8361  {
8362     if (jj_3R_210()) return true;
8363     Token xsp;
8364     xsp = jj_scanpos;
8365     if (jj_scan_token(77)) {
8366     jj_scanpos = xsp;
8367     if (jj_scan_token(78)) return true;
8368     }
8369     xsp = jj_scanpos;
8370     if (jj_3_73()) {
8371     jj_scanpos = xsp;
8372     if (jj_3_74()) return true;
8373     }
8374     return false;
8375   }
8376 
8377   private boolean jj_3R_38()
8378  {
8379     Token xsp;
8380     xsp = jj_scanpos;
8381     if (jj_3R_104()) {
8382     jj_scanpos = xsp;
8383     if (jj_3R_105()) {
8384     jj_scanpos = xsp;
8385     if (jj_3R_106()) return true;
8386     }
8387     }
8388     return false;
8389   }
8390 
8391   private boolean jj_3R_104()
8392  {
8393     if (jj_scan_token(VAR)) return true;
8394     if (jj_3R_135()) return true;
8395     return false;
8396   }
8397 
8398   private boolean jj_3_24()
8399  {
8400     if (jj_3R_36()) return true;
8401     return false;
8402   }
8403 
8404   private boolean jj_3R_105()
8405  {
8406     if (jj_scan_token(LET)) return true;
8407     if (jj_3R_135()) return true;
8408     return false;
8409   }
8410 
8411   private boolean jj_3R_106()
8412  {
8413     if (jj_3R_136()) return true;
8414     return false;
8415   }
8416 
8417   private boolean jj_3R_239()
8418  {
8419     if (jj_3R_208()) return true;
8420     return false;
8421   }
8422 
8423   private boolean jj_3R_265()
8424  {
8425     if (jj_3R_36()) return true;
8426     return false;
8427   }
8428 
8429   private boolean jj_3_33()
8430  {
8431     if (jj_3R_33()) return true;
8432     return false;
8433   }
8434 
8435   private boolean jj_3R_103()
8436  {
8437     Token xsp;
8438     xsp = jj_scanpos;
8439     if (jj_3R_132()) {
8440     jj_scanpos = xsp;
8441     if (jj_3R_133()) {
8442     jj_scanpos = xsp;
8443     if (jj_3R_134()) return true;
8444     }
8445     }
8446     return false;
8447   }
8448 
8449   private boolean jj_3R_132()
8450  {
8451     if (jj_scan_token(VAR)) return true;
8452     if (jj_3R_220()) return true;
8453     Token xsp;
8454     while (true) {
8455       xsp = jj_scanpos;
8456       if (jj_3R_257()) { jj_scanpos = xsp; break; }
8457     }
8458     return false;
8459   }
8460 
8461   private boolean jj_3R_247()
8462  {
8463     if (jj_scan_token(COMMA)) return true;
8464     if (jj_3R_33()) return true;
8465     return false;
8466   }
8467 
8468   private boolean jj_3R_133()
8469  {
8470     if (jj_scan_token(LET)) return true;
8471     if (jj_3R_221()) return true;
8472     Token xsp;
8473     while (true) {
8474       xsp = jj_scanpos;
8475       if (jj_3R_258()) { jj_scanpos = xsp; break; }
8476     }
8477     return false;
8478   }
8479 
8480   private boolean jj_3R_134()
8481  {
8482     if (jj_scan_token(CONST)) return true;
8483     if (jj_3R_222()) return true;
8484     Token xsp;
8485     while (true) {
8486       xsp = jj_scanpos;
8487       if (jj_3R_259()) { jj_scanpos = xsp; break; }
8488     }
8489     return false;
8490   }
8491 
8492   private boolean jj_3R_168()
8493  {
8494     Token xsp;
8495     xsp = jj_scanpos;
8496     if (jj_3R_182()) {
8497     jj_scanpos = xsp;
8498     if (jj_3R_183()) return true;
8499     }
8500     return false;
8501   }
8502 
8503   private boolean jj_3R_182()
8504  {
8505     if (jj_scan_token(DOT)) return true;
8506     Token xsp;
8507     xsp = jj_scanpos;
8508     if (jj_3R_202()) {
8509     jj_scanpos = xsp;
8510     if (jj_3R_203()) {
8511     jj_scanpos = xsp;
8512     if (jj_3R_204()) return true;
8513     }
8514     }
8515     return false;
8516   }
8517 
8518   private boolean jj_3_68()
8519  {
8520     if (jj_scan_token(IDENTIFIER)) return true;
8521     return false;
8522   }
8523 
8524   private boolean jj_3_39()
8525  {
8526     if (jj_3R_34()) return true;
8527     return false;
8528   }
8529 
8530   private boolean jj_3R_220()
8531  {
8532     if (jj_3R_135()) return true;
8533     Token xsp;
8534     xsp = jj_scanpos;
8535     if (jj_3R_260()) jj_scanpos = xsp;
8536     return false;
8537   }
8538 
8539   private boolean jj_3_29()
8540  {
8541     if (jj_3R_34()) return true;
8542     return false;
8543   }
8544 
8545   private boolean jj_3R_202()
8546  {
8547     if (jj_scan_token(DOT_IDENTIFIER)) return true;
8548     return false;
8549   }
8550 
8551   private boolean jj_3R_203()
8552  {
8553     if (jj_scan_token(STRING_LITERAL)) return true;
8554     return false;
8555   }
8556 
8557   private boolean jj_3R_183()
8558  {
8559     if (jj_scan_token(QDOT)) return true;
8560     Token xsp;
8561     xsp = jj_scanpos;
8562     if (jj_3R_205()) {
8563     jj_scanpos = xsp;
8564     if (jj_3R_206()) {
8565     jj_scanpos = xsp;
8566     if (jj_3R_207()) return true;
8567     }
8568     }
8569     return false;
8570   }
8571 
8572   private boolean jj_3R_221()
8573  {
8574     if (jj_3R_135()) return true;
8575     Token xsp;
8576     xsp = jj_scanpos;
8577     if (jj_3R_261()) jj_scanpos = xsp;
8578     return false;
8579   }
8580 
8581   private boolean jj_3R_204()
8582  {
8583     if (jj_scan_token(JXLT_LITERAL)) return true;
8584     return false;
8585   }
8586 
8587   private boolean jj_3_25()
8588  {
8589     if (jj_3R_33()) return true;
8590     return false;
8591   }
8592 
8593   private boolean jj_3R_180()
8594  {
8595     if (jj_scan_token(COMMA)) return true;
8596     Token xsp;
8597     xsp = jj_scanpos;
8598     if (jj_3R_201()) jj_scanpos = xsp;
8599     if (jj_scan_token(IDENTIFIER)) return true;
8600     return false;
8601   }
8602 
8603   private boolean jj_3R_205()
8604  {
8605     if (jj_scan_token(DOT_IDENTIFIER)) return true;
8606     return false;
8607   }
8608 
8609   private boolean jj_3R_222()
8610  {
8611     if (jj_3R_135()) return true;
8612     if (jj_scan_token(assign)) return true;
8613     if (jj_3R_33()) return true;
8614     return false;
8615   }
8616 
8617   private boolean jj_3_31()
8618  {
8619     if (jj_3R_34()) return true;
8620     return false;
8621   }
8622 
8623   private boolean jj_3R_257()
8624  {
8625     if (jj_scan_token(COMMA)) return true;
8626     if (jj_3R_220()) return true;
8627     return false;
8628   }
8629 
8630   private boolean jj_3R_206()
8631  {
8632     if (jj_scan_token(STRING_LITERAL)) return true;
8633     return false;
8634   }
8635 
8636   private boolean jj_3R_258()
8637  {
8638     if (jj_scan_token(COMMA)) return true;
8639     if (jj_3R_221()) return true;
8640     return false;
8641   }
8642 
8643   private boolean jj_3R_207()
8644  {
8645     if (jj_scan_token(JXLT_LITERAL)) return true;
8646     return false;
8647   }
8648 
8649   private boolean jj_3R_167()
8650  {
8651     Token xsp;
8652     if (jj_3R_181()) return true;
8653     while (true) {
8654       xsp = jj_scanpos;
8655       if (jj_3R_181()) { jj_scanpos = xsp; break; }
8656     }
8657     return false;
8658   }
8659 
8660   private boolean jj_3R_181()
8661  {
8662     if (jj_scan_token(LBRACKET)) return true;
8663     if (jj_3R_33()) return true;
8664     if (jj_scan_token(RBRACKET)) return true;
8665     return false;
8666   }
8667 
8668   private boolean jj_3R_135()
8669  {
8670     if (jj_scan_token(IDENTIFIER)) return true;
8671     return false;
8672   }
8673 
8674   private boolean jj_3R_201()
8675  {
8676     Token xsp;
8677     xsp = jj_scanpos;
8678     if (jj_scan_token(92)) {
8679     jj_scanpos = xsp;
8680     if (jj_scan_token(93)) {
8681     jj_scanpos = xsp;
8682     if (jj_scan_token(94)) return true;
8683     }
8684     }
8685     return false;
8686   }
8687 
8688   private boolean jj_3R_259()
8689  {
8690     if (jj_scan_token(COMMA)) return true;
8691     if (jj_3R_222()) return true;
8692     return false;
8693   }
8694 
8695   private boolean jj_3R_117()
8696  {
8697     Token xsp;
8698     xsp = jj_scanpos;
8699     if (jj_3R_147()) {
8700     jj_scanpos = xsp;
8701     if (jj_3R_148()) {
8702     jj_scanpos = xsp;
8703     if (jj_3R_149()) return true;
8704     }
8705     }
8706     return false;
8707   }
8708 
8709   private boolean jj_3R_147()
8710  {
8711     if (jj_3R_167()) return true;
8712     return false;
8713   }
8714 
8715   /** Generated Token Manager. */
8716   public ParserTokenManager token_source;
8717   SimpleCharStream jj_input_stream;
8718   /** Current token. */
8719   public Token token;
8720   /** Next token. */
8721   public Token jj_nt;
8722   private Token jj_scanpos, jj_lastpos;
8723   private int jj_la;
8724   /** Whether we are looking ahead. */
8725   private boolean jj_lookingAhead = false;
8726   private boolean jj_semLA;
8727 
8728   /**
8729    * Constructor with InputStream.
8730    * @param stream char stream
8731    */
8732   public Parser(final Provider stream) {
8733 	 jj_input_stream = new SimpleCharStream(stream, 1, 1);
8734 	 token_source = new ParserTokenManager(jj_input_stream);
8735 	 token = new Token();
8736 	 token.next = jj_nt = token_source.getNextToken();
8737   }
8738 
8739   /**
8740    * Constructor with InputStream.
8741    * @param sDSL String representation to be parsed
8742    */
8743   public Parser(final String sDSL) {
8744 	   this(new StringProvider(sDSL));
8745   }
8746 
8747   /**
8748    * Reinitialise.
8749    * @param sDSL String representation to be parsed
8750    */
8751   public void ReInit(final String sDSL) {
8752 	  ReInit(new StringProvider(sDSL));
8753   }
8754   /**
8755    * Reinitialise
8756    * @param stream char stream
8757    */
8758   public void ReInit(final Provider stream) {
8759 	if (jj_input_stream == null) {
8760 	  jj_input_stream = new SimpleCharStream(stream, 1, 1);
8761 	} else {
8762 	  jj_input_stream.reInit(stream, 1, 1);
8763   }
8764 	if (token_source == null) {
8765  token_source = new ParserTokenManager(jj_input_stream);
8766 	}
8767 
8768 	 token_source.ReInit(jj_input_stream);
8769 	 token = new Token();
8770 	 token.next = jj_nt = token_source.getNextToken();
8771   }
8772 
8773   /**
8774    * Constructor with generated Token Manager.
8775    * @param tm Token manager to use
8776    */
8777   public Parser(final ParserTokenManager tm) {
8778 	 token_source = tm;
8779 	 token = new Token();
8780 	 token.next = jj_nt = token_source.getNextToken();
8781   }
8782 
8783   /**
8784    * Reinitialise
8785    * @param tm Token manager to use
8786    */
8787   public void ReInit(final ParserTokenManager tm) {
8788 	 token_source = tm;
8789 	 token = new Token();
8790 	 token.next = jj_nt = token_source.getNextToken();
8791   }
8792 
8793   private Token jj_consume_token(final int kind) throws ParseException {
8794     final Token oldToken = token;
8795     token = jj_nt;
8796     if (token.next != null)
8797       jj_nt = jj_nt.next;
8798     else {
8799       jj_nt.next = token_source.getNextToken();
8800       jj_nt = jj_nt.next;
8801     }
8802     if (token.kind == kind) {
8803       return token;
8804     }
8805     jj_nt = token;
8806     token = oldToken;
8807     throw generateParseException();
8808   }
8809 
8810   private static final class LookaheadSuccess extends IllegalStateException {}
8811   private static final LookaheadSuccess jj_ls = new LookaheadSuccess();
8812   private boolean jj_scan_token(int kind) {
8813 	 if (jj_scanpos == jj_lastpos) {
8814 	   jj_la--;
8815 	   if (jj_scanpos.next == null) {
8816 		   jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
8817 	   } else {
8818 		   jj_lastpos = jj_scanpos = jj_scanpos.next;
8819 	   }
8820 	 } else {
8821 	   jj_scanpos = jj_scanpos.next;
8822 	 }
8823 	 if (jj_scanpos.kind != kind) return true;
8824 	 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
8825 	 return false;
8826   }
8827 
8828 
8829   /**
8830    * @return the next Token.
8831    */
8832   public final Token getNextToken() {
8833    token = jj_nt;
8834    if (token.next != null)
8835      jj_nt = jj_nt.next;
8836    else
8837      jj_nt = jj_nt.next = token_source.getNextToken();
8838 	 return token;
8839   }
8840 
8841   /**
8842    * @param index index to be retrieved
8843    * @return the specific Token.
8844    */
8845   public final Token getToken(final int index) {
8846     Token t = jj_lookingAhead ? jj_scanpos : token;
8847     for (int i = 0; i < index; i++) {
8848       if (t.next == null)
8849         t.next = token_source.getNextToken();
8850       t = t.next;
8851     }
8852     return t;
8853   }
8854 
8855   /** Generate ParseException. */
8856   public ParseException generateParseException() {
8857   final Token errortok = token.next;
8858   final int line = errortok.beginLine;
8859   final int column = errortok.beginColumn;
8860   final String mess = errortok.kind == 0 ? tokenImage[0] : errortok.image;
8861   return new ParseException("Parse error at line " + line + ", column " + column + ".  Encountered: " + mess);
8862   }
8863 
8864   /**
8865    * @return Always <code>false</code>.
8866    */
8867   public final boolean trace_enabled() {
8868     return false;
8869   }
8870 
8871   /** Enable tracing. */
8872   public final void enable_tracing() {}
8873 
8874   /** Disable tracing. */
8875   public final void disable_tracing() {}
8876 
8877 }