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