View Javadoc
1   /* Generated By:JJTree&JavaCC: Do not edit this line. VmParser.java */
2   package net.sourceforge.pmd.lang.vm.ast;
3   
4   import java.io.IOException;
5   import java.io.Reader;
6   import java.util.ArrayList;
7   import java.util.List;
8   import java.util.HashMap;
9   import java.util.Map;
10  
11  import net.sourceforge.pmd.lang.ast.CharStream;
12  import net.sourceforge.pmd.lang.vm.directive.Directive;
13  import net.sourceforge.pmd.lang.vm.util.VelocityCharStream;
14  import net.sourceforge.pmd.lang.vm.util.DirectiveMapper;
15  
16  /**
17   * This class is responsible for parsing a Velocity
18   * template. This class was generated by JavaCC using
19   * the JJTree extension to produce an Abstract
20   * Syntax Tree (AST) of the template.
21   *
22   * Please look at the Parser.jjt file which is
23   * what controls the generation of this class.
24   *
25   * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
26   * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
27   * @author <a href="hps@intermeta.de">Henning P. Schmiedehausen</a>
28   * @version $Id$
29  */
30  public class VmParser/*@bgen(jjtree)*/implements VmParserTreeConstants, VmParserConstants {/*@bgen(jjtree)*/
31    protected JJTVmParserState jjtree = new JJTVmParserState();/**
32       * Keep track of defined macros, used for escape processing
33       */
34      private Map macroNames = new HashMap();
35  
36      /**
37       * Name of current template we are parsing.  Passed to us in parse()
38       */
39      public String currentTemplateName = "";
40  
41      /**
42       * Set to true if the property
43       * RuntimeConstants.RUNTIME_REFERENCES_STRICT_ESCAPE is set to true
44       */
45      public boolean strictEscape = false;
46  
47      /**
48       *  This method gets a Directive from the directives Hashtable
49       */
50      public Directive getDirective(String directive)
51      {
52          return DirectiveMapper.getDirective(directive);
53      }
54  
55      /**
56       *  This method finds out of the directive exists in the directives Map.
57       */
58      public boolean isDirective(String directive)
59      {
60          return DirectiveMapper.getDirective(directive) != null;
61      }
62  
63  
64      /**
65       * Produces a processed output for an escaped control or
66       * pluggable directive
67       */
68      private String escapedDirective( String strImage )
69      {
70          int iLast = strImage.lastIndexOf("\u005c\u005c");
71  
72          String strDirective = strImage.substring(iLast + 1);
73  
74  //        return ( strImage.substring(0,iLast/2) + strDirective);
75  
76          boolean bRecognizedDirective = false;
77  
78          // we don't have to call substring method all the time in this method
79          String dirTag = strDirective.substring(1);
80          if (dirTag.charAt(0) == '{')
81          {
82              dirTag = dirTag.substring(1, dirTag.length() - 1);
83          }
84  
85          /*
86           *  If this is a predefined derective or if we detect
87           *  a macro definition (this is aproximate at best) then
88           *  we absorb the forward slash.  If in strict reference
89           *  mode then we always absord the forward slash regardless
90           *  if the derective is defined or not.
91           */
92  
93          if (strictEscape
94               || isDirective(dirTag)
95               || macroNames.containsKey(dirTag)
96               || !DirectiveMapper.isDirective(dirTag)) //rsvc.isVelocimacro(dirTag, currentTemplateName))
97          {
98              bRecognizedDirective = true;
99          }
100         else
101         {
102 
103             if ( dirTag.equals("if")
104                 || dirTag.equals("end")
105                 || dirTag.equals("set")
106                 || dirTag.equals("else")
107                 || dirTag.equals("elseif")
108             )
109             {
110                 bRecognizedDirective = true;
111             }
112         }
113 
114         /*
115          *  if so, make the proper prefix string (let the escapes do their thing..)
116          *  otherwise, just return what it is..
117          */
118 
119         if (bRecognizedDirective)
120             return ( strImage.substring(0,iLast/2) + strDirective);
121         else
122             return ( strImage );
123     }
124 
125     /**
126      * Check whether there is a left parenthesis with leading optional
127      * whitespaces. This method is used in the semantic look ahead of
128      * Directive method. This is done in code instead of as a production
129      * for simplicity and efficiency.
130      */
131     private boolean isLeftParenthesis()
132     {
133         char c;
134         int no = 0;
135         try {
136             while(true)
137             {
138                 /**
139                  * Read a character
140                  */
141                 c = token_source.input_stream.readChar();
142                 no++;
143                 if (c == '(')
144                 {
145                     return true;
146                 }
147                 /**
148                  * if not a white space return
149                  */
150                 else if (c != ' ' && c != '\u005cn' && c != '\u005cr' && c != '\u005ct')
151                 {
152                     return false;
153                 }
154             }
155         }
156         catch(IOException e)
157         {
158         }
159         finally
160         {
161             /**
162              * Backup the stream to the initial state
163              */
164             token_source.input_stream.backup(no);
165         }
166         return false;
167     }
168 
169     /**
170      * We use this method in a lookahead to determine if we are in a macro
171      * default value assignment.  The standard lookahead is not smart enough.
172      * here we look for the equals after the reference.
173      */
174     private boolean isAssignment()
175     {
176        // Basically if the last character read was not '$' then false
177        if (token_source.curLexState != REFERENCE) return false;
178 
179        char c = ' ';
180        int backup = 0;
181        try
182        {
183            // Read through any white space
184            while(Character.isWhitespace(c))
185            {
186                 c = token_source.input_stream.readChar();
187                 backup++;
188            }
189 
190            // This is what we are ultimately looking for
191            if (c != '=') return false;
192        }
193        catch (IOException e)
194        {
195        }
196        finally
197        {
198            token_source.input_stream.backup(backup);
199        }
200 
201        return true;
202     }
203 
204 /**
205  * This method is what starts the whole parsing
206  * process. After the parsing is complete and
207  * the template has been turned into an AST,
208  * this method returns the root of AST which
209  * can subsequently be traversed by a visitor
210  * which implements the ParserVisitor interface
211  * which is generated automatically by JavaCC
212  */
213   final public ASTprocess process() throws ParseException {
214                         /*@bgen(jjtree) process */
215   ASTprocess jjtn000 = new ASTprocess(this, JJTPROCESS);
216   boolean jjtc000 = true;
217   jjtree.openNodeScope(jjtn000);
218     try {
219       label_1:
220       while (true) {
221         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
222         case LPAREN:
223         case RPAREN:
224         case ESCAPE_DIRECTIVE:
225         case SET_DIRECTIVE:
226         case SINGLE_LINE_COMMENT_START:
227         case DOUBLE_ESCAPE:
228         case ESCAPE:
229         case TEXT:
230         case FORMAL_COMMENT:
231         case MULTI_LINE_COMMENT:
232         case TEXTBLOCK:
233         case STRING_LITERAL:
234         case FOREACH_DIRECTIVE:
235         case IF_DIRECTIVE:
236         case INTEGER_LITERAL:
237         case FLOATING_POINT_LITERAL:
238         case WORD:
239         case BRACKETED_WORD:
240         case IDENTIFIER:
241         case DOT:
242         case LCURLY:
243         case RCURLY:
244         case EMPTY_INDEX:
245           ;
246           break;
247         default:
248           jj_la1[0] = jj_gen;
249           break label_1;
250         }
251         Statement();
252       }
253       jj_consume_token(0);
254      jjtree.closeNodeScope(jjtn000, true);
255      jjtc000 = false;
256      {if (true) return jjtn000;}
257     } catch (Throwable jjte000) {
258      if (jjtc000) {
259        jjtree.clearNodeScope(jjtn000);
260        jjtc000 = false;
261      } else {
262        jjtree.popNode();
263      }
264      if (jjte000 instanceof RuntimeException) {
265        {if (true) throw (RuntimeException)jjte000;}
266      }
267      if (jjte000 instanceof ParseException) {
268        {if (true) throw (ParseException)jjte000;}
269      }
270      {if (true) throw (Error)jjte000;}
271     } finally {
272      if (jjtc000) {
273        jjtree.closeNodeScope(jjtn000, true);
274      }
275     }
276     throw new RuntimeException("Missing return statement in function");
277   }
278 
279 /**
280  * These are the types of statements that
281  * are acceptable in Velocity templates.
282  */
283   final public void Statement() throws ParseException {
284     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
285     case IF_DIRECTIVE:
286       IfStatement();
287       break;
288     case FOREACH_DIRECTIVE:
289       ForeachStatement();
290       break;
291     default:
292       jj_la1[1] = jj_gen;
293       if (jj_2_1(2)) {
294         Reference();
295       } else {
296         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
297         case SINGLE_LINE_COMMENT_START:
298         case FORMAL_COMMENT:
299         case MULTI_LINE_COMMENT:
300           Comment();
301           break;
302         case TEXTBLOCK:
303           Textblock();
304           break;
305         case SET_DIRECTIVE:
306           SetDirective();
307           break;
308         case ESCAPE_DIRECTIVE:
309           EscapedDirective();
310           break;
311         case DOUBLE_ESCAPE:
312           Escape();
313           break;
314         case WORD:
315         case BRACKETED_WORD:
316           Directive();
317           break;
318         case LPAREN:
319         case RPAREN:
320         case ESCAPE:
321         case TEXT:
322         case STRING_LITERAL:
323         case INTEGER_LITERAL:
324         case FLOATING_POINT_LITERAL:
325         case DOT:
326         case LCURLY:
327         case RCURLY:
328         case EMPTY_INDEX:
329           Text();
330           break;
331         default:
332           jj_la1[2] = jj_gen;
333           jj_consume_token(-1);
334           throw new ParseException();
335         }
336       }
337     }
338   }
339 
340 /**
341  *  used to separate the notion of a valid directive that has been
342  *  escaped, versus something that looks like a directive and
343  *  is just schmoo.  This is important to do as a separate production
344  *  that creates a node, because we want this, in either case, to stop
345  *  the further parsing of the Directive() tree.
346  */
347   final public void EscapedDirective() throws ParseException {
348                            /*@bgen(jjtree) EscapedDirective */
349   ASTEscapedDirective jjtn000 = new ASTEscapedDirective(this, JJTESCAPEDDIRECTIVE);
350   boolean jjtc000 = true;
351   jjtree.openNodeScope(jjtn000);
352     try {
353         Token t = null;
354       t = jj_consume_token(ESCAPE_DIRECTIVE);
355       jjtree.closeNodeScope(jjtn000, true);
356       jjtc000 = false;
357         /*
358          *  churn and burn..
359          */
360         t.image = escapedDirective( t.image );
361     } finally {
362       if (jjtc000) {
363         jjtree.closeNodeScope(jjtn000, true);
364       }
365     }
366   }
367 
368 /**
369  *  Used to catch and process escape sequences in grammatical constructs
370  *  as escapes outside of VTL are just characters.  Right now we have both
371  *  this and the EscapeDirective() construction because in the EscapeDirective()
372  *  case, we want to suck in the #<directive> and here we don't.  We just want
373  *  the escapes to render correctly
374  */
375   final public void Escape() throws ParseException {
376                  /*@bgen(jjtree) Escape */
377   ASTEscape jjtn000 = new ASTEscape(this, JJTESCAPE);
378   boolean jjtc000 = true;
379   jjtree.openNodeScope(jjtn000);
380     try {
381         Token t = null;
382         int count = 0;
383         boolean control = false;
384       label_2:
385       while (true) {
386         t = jj_consume_token(DOUBLE_ESCAPE);
387         count++;
388         if (jj_2_2(2)) {
389           ;
390         } else {
391           break label_2;
392         }
393       }
394       jjtree.closeNodeScope(jjtn000, true);
395       jjtc000 = false;
396         /*
397          * first, check to see if we have a control directive
398          */
399         switch(t.next.kind ) {
400                 case FOREACH_DIRECTIVE :
401             case IF_DIRECTIVE :
402             case ELSE_DIRECTIVE :
403             case ELSEIF_DIRECTIVE :
404             case END :
405                 control = true;
406                 break;
407         }
408 
409         /*
410          * if that failed, lets lookahead to see if we matched a PD or a VM
411          */
412         String nTag = t.next.image.substring(1);
413         if (strictEscape
414             || isDirective(nTag)
415             || macroNames.containsKey(nTag)
416             || !DirectiveMapper.isDirective(nTag)) //rsvc.isVelocimacro(nTag, currentTemplateName)
417         {
418             control = true;
419         }
420 
421         jjtn000.val = "";
422 
423         for( int i = 0; i < count; i++)
424             jjtn000.val += ( control ? "\u005c\u005c" : "\u005c\u005c\u005c\u005c");
425     } finally {
426       if (jjtc000) {
427         jjtree.closeNodeScope(jjtn000, true);
428       }
429     }
430   }
431 
432   final public void Comment() throws ParseException {
433                   /*@bgen(jjtree) Comment */
434   ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
435   boolean jjtc000 = true;
436   jjtree.openNodeScope(jjtn000);
437     try {
438       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
439       case SINGLE_LINE_COMMENT_START:
440         jj_consume_token(SINGLE_LINE_COMMENT_START);
441         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
442         case SINGLE_LINE_COMMENT:
443           jj_consume_token(SINGLE_LINE_COMMENT);
444           break;
445         default:
446           jj_la1[3] = jj_gen;
447           ;
448         }
449         break;
450       case MULTI_LINE_COMMENT:
451         jj_consume_token(MULTI_LINE_COMMENT);
452         break;
453       case FORMAL_COMMENT:
454         jj_consume_token(FORMAL_COMMENT);
455         break;
456       default:
457         jj_la1[4] = jj_gen;
458         jj_consume_token(-1);
459         throw new ParseException();
460       }
461     } finally {
462           if (jjtc000) {
463             jjtree.closeNodeScope(jjtn000, true);
464           }
465     }
466   }
467 
468   final public void Textblock() throws ParseException {
469                     /*@bgen(jjtree) Textblock */
470   ASTTextblock jjtn000 = new ASTTextblock(this, JJTTEXTBLOCK);
471   boolean jjtc000 = true;
472   jjtree.openNodeScope(jjtn000);
473     try {
474       jj_consume_token(TEXTBLOCK);
475     } finally {
476      if (jjtc000) {
477        jjtree.closeNodeScope(jjtn000, true);
478      }
479     }
480   }
481 
482   final public void FloatingPointLiteral() throws ParseException {
483                                /*@bgen(jjtree) FloatingPointLiteral */
484   ASTFloatingPointLiteral jjtn000 = new ASTFloatingPointLiteral(this, JJTFLOATINGPOINTLITERAL);
485   boolean jjtc000 = true;
486   jjtree.openNodeScope(jjtn000);
487     try {
488       jj_consume_token(FLOATING_POINT_LITERAL);
489     } finally {
490       if (jjtc000) {
491         jjtree.closeNodeScope(jjtn000, true);
492       }
493     }
494   }
495 
496   final public void IntegerLiteral() throws ParseException {
497                          /*@bgen(jjtree) IntegerLiteral */
498   ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(this, JJTINTEGERLITERAL);
499   boolean jjtc000 = true;
500   jjtree.openNodeScope(jjtn000);
501     try {
502       jj_consume_token(INTEGER_LITERAL);
503     } finally {
504        if (jjtc000) {
505          jjtree.closeNodeScope(jjtn000, true);
506        }
507     }
508   }
509 
510   final public void StringLiteral() throws ParseException {
511                         /*@bgen(jjtree) StringLiteral */
512   ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
513   boolean jjtc000 = true;
514   jjtree.openNodeScope(jjtn000);
515     try {
516       jj_consume_token(STRING_LITERAL);
517     } finally {
518       if (jjtc000) {
519         jjtree.closeNodeScope(jjtn000, true);
520       }
521     }
522   }
523 
524 /**
525  * This method corresponds to variable
526  * references in Velocity templates.
527  * The following are examples of variable
528  * references that may be found in a
529  * template:
530  *
531  * $foo
532  * $bar
533  *
534  */
535   final public void Identifier() throws ParseException {
536                      /*@bgen(jjtree) Identifier */
537   ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER);
538   boolean jjtc000 = true;
539   jjtree.openNodeScope(jjtn000);
540     try {
541       jj_consume_token(IDENTIFIER);
542     } finally {
543       if (jjtc000) {
544         jjtree.closeNodeScope(jjtn000, true);
545       }
546     }
547   }
548 
549   final public void Word() throws ParseException {
550                /*@bgen(jjtree) Word */
551   ASTWord jjtn000 = new ASTWord(this, JJTWORD);
552   boolean jjtc000 = true;
553   jjtree.openNodeScope(jjtn000);
554     try {
555       jj_consume_token(WORD);
556     } finally {
557       if (jjtc000) {
558         jjtree.closeNodeScope(jjtn000, true);
559       }
560     }
561   }
562 
563 /**
564  *   Supports the arguments for the Pluggable Directives
565  */
566   final public int DirectiveArg() throws ParseException {
567     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
568     case IDENTIFIER:
569     case LCURLY:
570       Reference();
571         {if (true) return VmParserTreeConstants.JJTREFERENCE;}
572       break;
573     case WORD:
574       Word();
575         {if (true) return VmParserTreeConstants.JJTWORD;}
576       break;
577     case STRING_LITERAL:
578       StringLiteral();
579         {if (true) return VmParserTreeConstants.JJTSTRINGLITERAL;}
580       break;
581     case INTEGER_LITERAL:
582       IntegerLiteral();
583         {if (true) return VmParserTreeConstants.JJTINTEGERLITERAL;}
584       break;
585     default:
586       jj_la1[5] = jj_gen;
587       if (jj_2_3(2147483647)) {
588         IntegerRange();
589         {if (true) return VmParserTreeConstants.JJTINTEGERRANGE;}
590       } else {
591         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
592         case FLOATING_POINT_LITERAL:
593           FloatingPointLiteral();
594         {if (true) return VmParserTreeConstants.JJTFLOATINGPOINTLITERAL;}
595           break;
596         case LEFT_CURLEY:
597           Map();
598         {if (true) return VmParserTreeConstants.JJTMAP;}
599           break;
600         case LBRACKET:
601           ObjectArray();
602         {if (true) return VmParserTreeConstants.JJTOBJECTARRAY;}
603           break;
604         case TRUE:
605           True();
606         {if (true) return VmParserTreeConstants.JJTTRUE;}
607           break;
608         case FALSE:
609           False();
610         {if (true) return VmParserTreeConstants.JJTFALSE;}
611           break;
612         default:
613           jj_la1[6] = jj_gen;
614           jj_consume_token(-1);
615           throw new ParseException();
616         }
617       }
618     }
619     throw new RuntimeException("Missing return statement in function");
620   }
621 
622 /**
623  *   Supports the Pluggable Directives
624  *     #foo( arg+ )
625  */
626   final public VmNode Directive() throws ParseException {
627  /*@bgen(jjtree) Directive */
628     ASTDirective jjtn000 = new ASTDirective(this, JJTDIRECTIVE);
629     boolean jjtc000 = true;
630     jjtree.openNodeScope(jjtn000);Token t = null;
631     int argType;
632     int argPos = 0;
633     Directive d;
634     int directiveType;
635     boolean isVM = false;
636     boolean doItNow = false;
637     try {
638       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
639       case WORD:
640         t = jj_consume_token(WORD);
641         break;
642       case BRACKETED_WORD:
643         t = jj_consume_token(BRACKETED_WORD);
644         break;
645       default:
646         jj_la1[7] = jj_gen;
647         jj_consume_token(-1);
648         throw new ParseException();
649       }
650         String directiveName;
651         if (t.kind == VmParserConstants.BRACKETED_WORD)
652         {
653             directiveName = t.image.substring(2, t.image.length() - 1);
654         }
655         else
656         {
657             directiveName = t.image.substring(1);
658         }
659 
660         d = getDirective(directiveName);
661 
662         /*
663          *  Velocimacro support : if the directive is macro directive
664          *   then set the flag so after the block parsing, we add the VM
665          *   right then. (So available if used w/in the current template )
666          */
667 
668         if (directiveName.equals("macro"))
669         {
670              doItNow = true;
671         }
672 
673         /*
674          * set the directive name from here.  No reason for the thing to know
675          * about parser tokens
676          */
677 
678         jjtn000.setDirectiveName(directiveName);
679 
680         if ( d == null)
681         {
682             if( directiveName.startsWith("@") )
683             {
684                 // block macro call of type: #@foobar($arg1 $arg2) astBody #end
685                 directiveType = Directive.BLOCK;
686             }
687             else
688             {
689                 /*
690                  *  if null, then not a real directive, but maybe a Velocimacro
691                  */
692                 isVM = !DirectiveMapper.isDirective(directiveName); //rsvc.isVelocimacro(directiveName, currentTemplateName);
693 
694                 directiveType = Directive.LINE;
695             }
696         }
697         else
698         {
699             directiveType = d.getType();
700         }
701 
702         /*
703          *  now, switch us out of PRE_DIRECTIVE
704          */
705 
706         token_source.SwitchTo(DIRECTIVE);
707 
708         argPos = 0;
709       if (isLeftParenthesis()) {
710         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
711         case WHITESPACE:
712           jj_consume_token(WHITESPACE);
713           break;
714         default:
715           jj_la1[8] = jj_gen;
716           ;
717         }
718         jj_consume_token(LPAREN);
719         label_3:
720         while (true) {
721           if (jj_2_4(2)) {
722             ;
723           } else {
724             break label_3;
725           }
726           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
727           case WHITESPACE:
728             jj_consume_token(WHITESPACE);
729             break;
730           default:
731             jj_la1[9] = jj_gen;
732             ;
733           }
734           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
735           case COMMA:
736             jj_consume_token(COMMA);
737             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
738             case WHITESPACE:
739               jj_consume_token(WHITESPACE);
740               break;
741             default:
742               jj_la1[10] = jj_gen;
743               ;
744             }
745             break;
746           default:
747             jj_la1[11] = jj_gen;
748             ;
749           }
750           argType = DirectiveArg();
751                 if (argType == VmParserTreeConstants.JJTWORD)
752                 {
753                     if (doItNow && argPos == 0)
754                     {
755                         /* if #macro and it's the 0th arg, ok */
756                     }
757                     else if (isVM)
758                     {
759                         {if (true) throw new MacroParseException("Invalid arg #"
760                         + argPos + " in VM " + t.image, currentTemplateName, t);}
761                     }
762                                           /* if #foreach and it's the 2nd arg, ok */
763                     else if (d != null && (!directiveName.equals("foreach") || argPos != 1))
764                     {
765                         {if (true) throw new MacroParseException("Invalid arg #"
766                         + argPos + " in directive " + t.image, currentTemplateName, t);}
767                     }
768                     else
769                     {
770                         /* either schmoo or a late-defined macro,
771                          * VelocimacroProxy will have to check for latter. */
772                     }
773                 }
774                 else
775                 {
776                     if (doItNow && argPos == 0)
777                     {
778                         /* if a VM and it's the 0th arg, not ok */
779 
780                         {if (true) throw new MacroParseException("Invalid first arg"
781                         + " in #macro() directive - must be a"
782                         + " word token (no \u005c' or \u005c" surrounding)", currentTemplateName, t);}
783                     }
784                 }
785 
786                 argPos++;
787         }
788         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
789         case WHITESPACE:
790           jj_consume_token(WHITESPACE);
791           break;
792         default:
793           jj_la1[12] = jj_gen;
794           ;
795         }
796         jj_consume_token(RPAREN);
797         if (directiveType  == Directive.LINE)
798         {
799             {if (true) return jjtn000;}
800         }
801       } else {
802         if (doItNow)  // doItNow is true if the directive is "macro"
803         {
804             // VELOCITY-667 We get here if we have a "#macro" construct
805             // without parenthesis which is a parse error
806             {if (true) throw new MacroParseException("A macro declaration requires at least a name argument"
807               , currentTemplateName, t);}
808         }
809 
810         /**
811          * Not a directive
812          */
813         token_source.stateStackPop();
814         token_source.inDirective = false;
815         {if (true) return jjtn000;}
816       }
817       ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
818       boolean jjtc001 = true;
819       jjtree.openNodeScope(jjtn001);
820       try {
821         label_4:
822         while (true) {
823           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
824           case LPAREN:
825           case RPAREN:
826           case ESCAPE_DIRECTIVE:
827           case SET_DIRECTIVE:
828           case SINGLE_LINE_COMMENT_START:
829           case DOUBLE_ESCAPE:
830           case ESCAPE:
831           case TEXT:
832           case FORMAL_COMMENT:
833           case MULTI_LINE_COMMENT:
834           case TEXTBLOCK:
835           case STRING_LITERAL:
836           case FOREACH_DIRECTIVE:
837           case IF_DIRECTIVE:
838           case INTEGER_LITERAL:
839           case FLOATING_POINT_LITERAL:
840           case WORD:
841           case BRACKETED_WORD:
842           case IDENTIFIER:
843           case DOT:
844           case LCURLY:
845           case RCURLY:
846           case EMPTY_INDEX:
847             ;
848             break;
849           default:
850             jj_la1[13] = jj_gen;
851             break label_4;
852           }
853           Statement();
854         }
855       } catch (Throwable jjte001) {
856       if (jjtc001) {
857         jjtree.clearNodeScope(jjtn001);
858         jjtc001 = false;
859       } else {
860         jjtree.popNode();
861       }
862       if (jjte001 instanceof RuntimeException) {
863         {if (true) throw (RuntimeException)jjte001;}
864       }
865       if (jjte001 instanceof ParseException) {
866         {if (true) throw (ParseException)jjte001;}
867       }
868       {if (true) throw (Error)jjte001;}
869       } finally {
870       if (jjtc001) {
871         jjtree.closeNodeScope(jjtn001, true);
872       }
873       }
874       jj_consume_token(END);
875       jjtree.closeNodeScope(jjtn000, true);
876       jjtc000 = false;
877         /*
878          *  VM : if we are processing a #macro directive, we need to
879          *     process the block.  In truth, I can just register the name
880          *     and do the work later when init-ing.  That would work
881          *     as long as things were always defined before use.  This way
882          *     we don't have to worry about forward references and such...
883          */
884 
885         if (doItNow)
886         {
887             // Add the macro name so that we can peform escape processing
888             // on defined macros
889             String macroName = ((AbstractVmNode)jjtn000.jjtGetChild(0)).getFirstToken().image;
890             macroNames.put(macroName, macroName);
891         }
892 /*
893         if (d != null)
894         {
895             d.checkArgs(argtypes, t, currentTemplateName);
896         }
897 */
898         /*
899          *  VM : end
900          */
901 
902         {if (true) return jjtn000;}
903     } catch (Throwable jjte000) {
904       if (jjtc000) {
905         jjtree.clearNodeScope(jjtn000);
906         jjtc000 = false;
907       } else {
908         jjtree.popNode();
909       }
910       if (jjte000 instanceof RuntimeException) {
911         {if (true) throw (RuntimeException)jjte000;}
912       }
913       if (jjte000 instanceof ParseException) {
914         {if (true) throw (ParseException)jjte000;}
915       }
916       {if (true) throw (Error)jjte000;}
917     } finally {
918       if (jjtc000) {
919         jjtree.closeNodeScope(jjtn000, true);
920       }
921     }
922     throw new RuntimeException("Missing return statement in function");
923   }
924 
925 /**
926  * for creating a map in a #set
927  *
928  *  #set($foo = {$foo : $bar, $blargh : $thingy})
929  */
930   final public void Map() throws ParseException {
931               /*@bgen(jjtree) Map */
932   ASTMap jjtn000 = new ASTMap(this, JJTMAP);
933   boolean jjtc000 = true;
934   jjtree.openNodeScope(jjtn000);
935     try {
936       jj_consume_token(LEFT_CURLEY);
937       if (jj_2_5(2)) {
938         Parameter();
939         jj_consume_token(COLON);
940         Parameter();
941         label_5:
942         while (true) {
943           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
944           case COMMA:
945             ;
946             break;
947           default:
948             jj_la1[14] = jj_gen;
949             break label_5;
950           }
951           jj_consume_token(COMMA);
952           Parameter();
953           jj_consume_token(COLON);
954           Parameter();
955         }
956       } else {
957         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
958         case WHITESPACE:
959           jj_consume_token(WHITESPACE);
960           break;
961         default:
962           jj_la1[15] = jj_gen;
963           ;
964         }
965       }
966       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
967       case RIGHT_CURLEY:
968         jj_consume_token(RIGHT_CURLEY);
969         break;
970       case RCURLY:
971         jj_consume_token(RCURLY);
972         break;
973       default:
974         jj_la1[16] = jj_gen;
975         jj_consume_token(-1);
976         throw new ParseException();
977       }
978     } catch (Throwable jjte000) {
979       if (jjtc000) {
980         jjtree.clearNodeScope(jjtn000);
981         jjtc000 = false;
982       } else {
983         jjtree.popNode();
984       }
985       if (jjte000 instanceof RuntimeException) {
986         {if (true) throw (RuntimeException)jjte000;}
987       }
988       if (jjte000 instanceof ParseException) {
989         {if (true) throw (ParseException)jjte000;}
990       }
991       {if (true) throw (Error)jjte000;}
992     } finally {
993       if (jjtc000) {
994         jjtree.closeNodeScope(jjtn000, true);
995       }
996     }
997   }
998 
999   final public void ObjectArray() throws ParseException {
1000                       /*@bgen(jjtree) ObjectArray */
1001   ASTObjectArray jjtn000 = new ASTObjectArray(this, JJTOBJECTARRAY);
1002   boolean jjtc000 = true;
1003   jjtree.openNodeScope(jjtn000);
1004     try {
1005       jj_consume_token(LBRACKET);
1006       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1007       case LBRACKET:
1008       case LEFT_CURLEY:
1009       case WHITESPACE:
1010       case STRING_LITERAL:
1011       case TRUE:
1012       case FALSE:
1013       case INTEGER_LITERAL:
1014       case FLOATING_POINT_LITERAL:
1015       case IDENTIFIER:
1016       case LCURLY:
1017         Parameter();
1018         label_6:
1019         while (true) {
1020           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1021           case COMMA:
1022             ;
1023             break;
1024           default:
1025             jj_la1[17] = jj_gen;
1026             break label_6;
1027           }
1028           jj_consume_token(COMMA);
1029           Parameter();
1030         }
1031         break;
1032       default:
1033         jj_la1[18] = jj_gen;
1034         ;
1035       }
1036       jj_consume_token(RBRACKET);
1037     } catch (Throwable jjte000) {
1038       if (jjtc000) {
1039         jjtree.clearNodeScope(jjtn000);
1040         jjtc000 = false;
1041       } else {
1042         jjtree.popNode();
1043       }
1044       if (jjte000 instanceof RuntimeException) {
1045         {if (true) throw (RuntimeException)jjte000;}
1046       }
1047       if (jjte000 instanceof ParseException) {
1048         {if (true) throw (ParseException)jjte000;}
1049       }
1050       {if (true) throw (Error)jjte000;}
1051     } finally {
1052       if (jjtc000) {
1053         jjtree.closeNodeScope(jjtn000, true);
1054       }
1055     }
1056   }
1057 
1058 /**
1059  *  supports the [n..m] vector generator for use in
1060  *  the #foreach() to generate measured ranges w/o
1061  *  needing explicit support from the app/servlet
1062  */
1063   final public void IntegerRange() throws ParseException {
1064                        /*@bgen(jjtree) IntegerRange */
1065   ASTIntegerRange jjtn000 = new ASTIntegerRange(this, JJTINTEGERRANGE);
1066   boolean jjtc000 = true;
1067   jjtree.openNodeScope(jjtn000);
1068     try {
1069       jj_consume_token(LBRACKET);
1070       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1071       case WHITESPACE:
1072         jj_consume_token(WHITESPACE);
1073         break;
1074       default:
1075         jj_la1[19] = jj_gen;
1076         ;
1077       }
1078       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1079       case IDENTIFIER:
1080       case LCURLY:
1081         Reference();
1082         break;
1083       case INTEGER_LITERAL:
1084         IntegerLiteral();
1085         break;
1086       default:
1087         jj_la1[20] = jj_gen;
1088         jj_consume_token(-1);
1089         throw new ParseException();
1090       }
1091       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1092       case WHITESPACE:
1093         jj_consume_token(WHITESPACE);
1094         break;
1095       default:
1096         jj_la1[21] = jj_gen;
1097         ;
1098       }
1099       jj_consume_token(DOUBLEDOT);
1100       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1101       case WHITESPACE:
1102         jj_consume_token(WHITESPACE);
1103         break;
1104       default:
1105         jj_la1[22] = jj_gen;
1106         ;
1107       }
1108       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1109       case IDENTIFIER:
1110       case LCURLY:
1111         Reference();
1112         break;
1113       case INTEGER_LITERAL:
1114         IntegerLiteral();
1115         break;
1116       default:
1117         jj_la1[23] = jj_gen;
1118         jj_consume_token(-1);
1119         throw new ParseException();
1120       }
1121       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1122       case WHITESPACE:
1123         jj_consume_token(WHITESPACE);
1124         break;
1125       default:
1126         jj_la1[24] = jj_gen;
1127         ;
1128       }
1129       jj_consume_token(RBRACKET);
1130     } catch (Throwable jjte000) {
1131       if (jjtc000) {
1132         jjtree.clearNodeScope(jjtn000);
1133         jjtc000 = false;
1134       } else {
1135         jjtree.popNode();
1136       }
1137       if (jjte000 instanceof RuntimeException) {
1138         {if (true) throw (RuntimeException)jjte000;}
1139       }
1140       if (jjte000 instanceof ParseException) {
1141         {if (true) throw (ParseException)jjte000;}
1142       }
1143       {if (true) throw (Error)jjte000;}
1144     } finally {
1145       if (jjtc000) {
1146         jjtree.closeNodeScope(jjtn000, true);
1147       }
1148     }
1149   }
1150 
1151 /**
1152  * A Simplified parameter more suitable for an index position: $foo[$index]
1153  */
1154   final public void IndexParameter() throws ParseException {
1155     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1156     case WHITESPACE:
1157       jj_consume_token(WHITESPACE);
1158       break;
1159     default:
1160       jj_la1[25] = jj_gen;
1161       ;
1162     }
1163     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1164     case STRING_LITERAL:
1165       StringLiteral();
1166       break;
1167     case INTEGER_LITERAL:
1168       IntegerLiteral();
1169       break;
1170     case TRUE:
1171       True();
1172       break;
1173     case FALSE:
1174       False();
1175       break;
1176     case IDENTIFIER:
1177     case LCURLY:
1178       Reference();
1179       break;
1180     default:
1181       jj_la1[26] = jj_gen;
1182       jj_consume_token(-1);
1183       throw new ParseException();
1184     }
1185     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1186     case WHITESPACE:
1187       jj_consume_token(WHITESPACE);
1188       break;
1189     default:
1190       jj_la1[27] = jj_gen;
1191       ;
1192     }
1193   }
1194 
1195 /**
1196  * This method has yet to be fully implemented
1197  * but will allow arbitrarily nested method
1198  * calls
1199  */
1200   final public void Parameter() throws ParseException {
1201     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1202     case WHITESPACE:
1203       jj_consume_token(WHITESPACE);
1204       break;
1205     default:
1206       jj_la1[28] = jj_gen;
1207       ;
1208     }
1209     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1210     case STRING_LITERAL:
1211       StringLiteral();
1212       break;
1213     case INTEGER_LITERAL:
1214       IntegerLiteral();
1215       break;
1216     default:
1217       jj_la1[29] = jj_gen;
1218       if (jj_2_6(2147483647)) {
1219         IntegerRange();
1220       } else {
1221         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1222         case LEFT_CURLEY:
1223           Map();
1224           break;
1225         case LBRACKET:
1226           ObjectArray();
1227           break;
1228         case TRUE:
1229           True();
1230           break;
1231         case FALSE:
1232           False();
1233           break;
1234         case IDENTIFIER:
1235         case LCURLY:
1236           Reference();
1237           break;
1238         case FLOATING_POINT_LITERAL:
1239           FloatingPointLiteral();
1240           break;
1241         default:
1242           jj_la1[30] = jj_gen;
1243           jj_consume_token(-1);
1244           throw new ParseException();
1245         }
1246       }
1247     }
1248     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1249     case WHITESPACE:
1250       jj_consume_token(WHITESPACE);
1251       break;
1252     default:
1253       jj_la1[31] = jj_gen;
1254       ;
1255     }
1256   }
1257 
1258 /**
1259  * This method has yet to be fully implemented
1260  * but will allow arbitrarily nested method
1261  * calls
1262  */
1263   final public void Method() throws ParseException {
1264                  /*@bgen(jjtree) Method */
1265   ASTMethod jjtn000 = new ASTMethod(this, JJTMETHOD);
1266   boolean jjtc000 = true;
1267   jjtree.openNodeScope(jjtn000);
1268     try {
1269       Identifier();
1270       jj_consume_token(LPAREN);
1271       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1272       case LBRACKET:
1273       case LEFT_CURLEY:
1274       case WHITESPACE:
1275       case STRING_LITERAL:
1276       case TRUE:
1277       case FALSE:
1278       case INTEGER_LITERAL:
1279       case FLOATING_POINT_LITERAL:
1280       case IDENTIFIER:
1281       case LCURLY:
1282         Parameter();
1283         label_7:
1284         while (true) {
1285           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1286           case COMMA:
1287             ;
1288             break;
1289           default:
1290             jj_la1[32] = jj_gen;
1291             break label_7;
1292           }
1293           jj_consume_token(COMMA);
1294           Parameter();
1295         }
1296         break;
1297       default:
1298         jj_la1[33] = jj_gen;
1299         ;
1300       }
1301       jj_consume_token(REFMOD2_RPAREN);
1302     } catch (Throwable jjte000) {
1303      if (jjtc000) {
1304        jjtree.clearNodeScope(jjtn000);
1305        jjtc000 = false;
1306      } else {
1307        jjtree.popNode();
1308      }
1309      if (jjte000 instanceof RuntimeException) {
1310        {if (true) throw (RuntimeException)jjte000;}
1311      }
1312      if (jjte000 instanceof ParseException) {
1313        {if (true) throw (ParseException)jjte000;}
1314      }
1315      {if (true) throw (Error)jjte000;}
1316     } finally {
1317      if (jjtc000) {
1318        jjtree.closeNodeScope(jjtn000, true);
1319      }
1320     }
1321   }
1322 
1323   final public void Index() throws ParseException {
1324                 /*@bgen(jjtree) Index */
1325   ASTIndex jjtn000 = new ASTIndex(this, JJTINDEX);
1326   boolean jjtc000 = true;
1327   jjtree.openNodeScope(jjtn000);
1328     try {
1329       jj_consume_token(INDEX_LBRACKET);
1330       IndexParameter();
1331       jj_consume_token(INDEX_RBRACKET);
1332     } catch (Throwable jjte000) {
1333      if (jjtc000) {
1334        jjtree.clearNodeScope(jjtn000);
1335        jjtc000 = false;
1336      } else {
1337        jjtree.popNode();
1338      }
1339      if (jjte000 instanceof RuntimeException) {
1340        {if (true) throw (RuntimeException)jjte000;}
1341      }
1342      if (jjte000 instanceof ParseException) {
1343        {if (true) throw (ParseException)jjte000;}
1344      }
1345      {if (true) throw (Error)jjte000;}
1346     } finally {
1347      if (jjtc000) {
1348        jjtree.closeNodeScope(jjtn000, true);
1349      }
1350     }
1351   }
1352 
1353   final public void Reference() throws ParseException {
1354                     /*@bgen(jjtree) Reference */
1355   ASTReference jjtn000 = new ASTReference(this, JJTREFERENCE);
1356   boolean jjtc000 = true;
1357   jjtree.openNodeScope(jjtn000);
1358     try {
1359       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1360       case IDENTIFIER:
1361         jj_consume_token(IDENTIFIER);
1362         label_8:
1363         while (true) {
1364           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1365           case INDEX_LBRACKET:
1366             ;
1367             break;
1368           default:
1369             jj_la1[34] = jj_gen;
1370             break label_8;
1371           }
1372           Index();
1373         }
1374         label_9:
1375         while (true) {
1376           if (jj_2_7(2)) {
1377             ;
1378           } else {
1379             break label_9;
1380           }
1381           jj_consume_token(DOT);
1382           if (jj_2_8(3)) {
1383             Method();
1384           } else {
1385             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1386             case IDENTIFIER:
1387               Identifier();
1388               break;
1389             default:
1390               jj_la1[35] = jj_gen;
1391               jj_consume_token(-1);
1392               throw new ParseException();
1393             }
1394           }
1395           label_10:
1396           while (true) {
1397             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1398             case INDEX_LBRACKET:
1399               ;
1400               break;
1401             default:
1402               jj_la1[36] = jj_gen;
1403               break label_10;
1404             }
1405             Index();
1406           }
1407         }
1408         break;
1409       case LCURLY:
1410         jj_consume_token(LCURLY);
1411         jj_consume_token(IDENTIFIER);
1412         label_11:
1413         while (true) {
1414           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1415           case INDEX_LBRACKET:
1416             ;
1417             break;
1418           default:
1419             jj_la1[37] = jj_gen;
1420             break label_11;
1421           }
1422           Index();
1423         }
1424         label_12:
1425         while (true) {
1426           if (jj_2_9(2)) {
1427             ;
1428           } else {
1429             break label_12;
1430           }
1431           jj_consume_token(DOT);
1432           if (jj_2_10(3)) {
1433             Method();
1434           } else {
1435             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1436             case IDENTIFIER:
1437               Identifier();
1438               break;
1439             default:
1440               jj_la1[38] = jj_gen;
1441               jj_consume_token(-1);
1442               throw new ParseException();
1443             }
1444           }
1445           label_13:
1446           while (true) {
1447             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1448             case INDEX_LBRACKET:
1449               ;
1450               break;
1451             default:
1452               jj_la1[39] = jj_gen;
1453               break label_13;
1454             }
1455             Index();
1456           }
1457         }
1458         jj_consume_token(RCURLY);
1459         break;
1460       default:
1461         jj_la1[40] = jj_gen;
1462         jj_consume_token(-1);
1463         throw new ParseException();
1464       }
1465     } catch (Throwable jjte000) {
1466         if (jjtc000) {
1467           jjtree.clearNodeScope(jjtn000);
1468           jjtc000 = false;
1469         } else {
1470           jjtree.popNode();
1471         }
1472         if (jjte000 instanceof RuntimeException) {
1473           {if (true) throw (RuntimeException)jjte000;}
1474         }
1475         if (jjte000 instanceof ParseException) {
1476           {if (true) throw (ParseException)jjte000;}
1477         }
1478         {if (true) throw (Error)jjte000;}
1479     } finally {
1480         if (jjtc000) {
1481           jjtree.closeNodeScope(jjtn000, true);
1482         }
1483     }
1484   }
1485 
1486   final public void True() throws ParseException {
1487                /*@bgen(jjtree) True */
1488   ASTTrue jjtn000 = new ASTTrue(this, JJTTRUE);
1489   boolean jjtc000 = true;
1490   jjtree.openNodeScope(jjtn000);
1491     try {
1492       jj_consume_token(TRUE);
1493     } finally {
1494       if (jjtc000) {
1495         jjtree.closeNodeScope(jjtn000, true);
1496       }
1497     }
1498   }
1499 
1500   final public void False() throws ParseException {
1501                 /*@bgen(jjtree) False */
1502   ASTFalse jjtn000 = new ASTFalse(this, JJTFALSE);
1503   boolean jjtc000 = true;
1504   jjtree.openNodeScope(jjtn000);
1505     try {
1506       jj_consume_token(FALSE);
1507     } finally {
1508       if (jjtc000) {
1509         jjtree.closeNodeScope(jjtn000, true);
1510       }
1511     }
1512   }
1513 
1514 /**
1515  * This method is responsible for allowing
1516  * all non-grammar text to pass through
1517  * unscathed.
1518  */
1519   final public void Text() throws ParseException {
1520                /*@bgen(jjtree) Text */
1521   ASTText jjtn000 = new ASTText(this, JJTTEXT);
1522   boolean jjtc000 = true;
1523   jjtree.openNodeScope(jjtn000);
1524     try {
1525       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1526       case TEXT:
1527         jj_consume_token(TEXT);
1528         break;
1529       case DOT:
1530         jj_consume_token(DOT);
1531         break;
1532       case RPAREN:
1533         jj_consume_token(RPAREN);
1534         break;
1535       case LPAREN:
1536         jj_consume_token(LPAREN);
1537         break;
1538       case INTEGER_LITERAL:
1539         jj_consume_token(INTEGER_LITERAL);
1540         break;
1541       case FLOATING_POINT_LITERAL:
1542         jj_consume_token(FLOATING_POINT_LITERAL);
1543         break;
1544       case STRING_LITERAL:
1545         jj_consume_token(STRING_LITERAL);
1546         break;
1547       case ESCAPE:
1548         jj_consume_token(ESCAPE);
1549         break;
1550       case LCURLY:
1551         jj_consume_token(LCURLY);
1552         break;
1553       case RCURLY:
1554         jj_consume_token(RCURLY);
1555         break;
1556       case EMPTY_INDEX:
1557         jj_consume_token(EMPTY_INDEX);
1558         break;
1559       default:
1560         jj_la1[41] = jj_gen;
1561         jj_consume_token(-1);
1562         throw new ParseException();
1563       }
1564     } finally {
1565       if (jjtc000) {
1566         jjtree.closeNodeScope(jjtn000, true);
1567       }
1568     }
1569   }
1570 
1571 /* -----------------------------------------------------------------------
1572  *
1573  *  Defined Directive Syntax
1574  *
1575  * ----------------------------------------------------------------------*/
1576   final public void ForeachStatement() throws ParseException {
1577                            /*@bgen(jjtree) ForeachStatement */
1578   ASTForeachStatement jjtn000 = new ASTForeachStatement(this, JJTFOREACHSTATEMENT);
1579   boolean jjtc000 = true;
1580   jjtree.openNodeScope(jjtn000);
1581     try {
1582       jj_consume_token(FOREACH_DIRECTIVE);
1583       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1584       case WHITESPACE:
1585         jj_consume_token(WHITESPACE);
1586         break;
1587       default:
1588         jj_la1[42] = jj_gen;
1589         ;
1590       }
1591       jj_consume_token(LPAREN);
1592       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1593       case WHITESPACE:
1594         jj_consume_token(WHITESPACE);
1595         break;
1596       default:
1597         jj_la1[43] = jj_gen;
1598         ;
1599       }
1600       Reference();
1601       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1602       case WHITESPACE:
1603         jj_consume_token(WHITESPACE);
1604         break;
1605       default:
1606         jj_la1[44] = jj_gen;
1607         ;
1608       }
1609       jj_consume_token(IN);
1610       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1611       case WHITESPACE:
1612         jj_consume_token(WHITESPACE);
1613         break;
1614       default:
1615         jj_la1[45] = jj_gen;
1616         ;
1617       }
1618       PrimaryExpression();
1619       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1620       case WHITESPACE:
1621         jj_consume_token(WHITESPACE);
1622         break;
1623       default:
1624         jj_la1[46] = jj_gen;
1625         ;
1626       }
1627       jj_consume_token(RPAREN);
1628       ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
1629       boolean jjtc001 = true;
1630       jjtree.openNodeScope(jjtn001);
1631       try {
1632         label_14:
1633         while (true) {
1634           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1635           case LPAREN:
1636           case RPAREN:
1637           case ESCAPE_DIRECTIVE:
1638           case SET_DIRECTIVE:
1639           case SINGLE_LINE_COMMENT_START:
1640           case DOUBLE_ESCAPE:
1641           case ESCAPE:
1642           case TEXT:
1643           case FORMAL_COMMENT:
1644           case MULTI_LINE_COMMENT:
1645           case TEXTBLOCK:
1646           case STRING_LITERAL:
1647           case FOREACH_DIRECTIVE:
1648           case IF_DIRECTIVE:
1649           case INTEGER_LITERAL:
1650           case FLOATING_POINT_LITERAL:
1651           case WORD:
1652           case BRACKETED_WORD:
1653           case IDENTIFIER:
1654           case DOT:
1655           case LCURLY:
1656           case RCURLY:
1657           case EMPTY_INDEX:
1658             ;
1659             break;
1660           default:
1661             jj_la1[47] = jj_gen;
1662             break label_14;
1663           }
1664           Statement();
1665         }
1666       } catch (Throwable jjte001) {
1667       if (jjtc001) {
1668         jjtree.clearNodeScope(jjtn001);
1669         jjtc001 = false;
1670       } else {
1671         jjtree.popNode();
1672       }
1673       if (jjte001 instanceof RuntimeException) {
1674         {if (true) throw (RuntimeException)jjte001;}
1675       }
1676       if (jjte001 instanceof ParseException) {
1677         {if (true) throw (ParseException)jjte001;}
1678       }
1679       {if (true) throw (Error)jjte001;}
1680       } finally {
1681       if (jjtc001) {
1682         jjtree.closeNodeScope(jjtn001, true);
1683       }
1684       }
1685       jj_consume_token(END);
1686     } catch (Throwable jjte000) {
1687       if (jjtc000) {
1688         jjtree.clearNodeScope(jjtn000);
1689         jjtc000 = false;
1690       } else {
1691         jjtree.popNode();
1692       }
1693       if (jjte000 instanceof RuntimeException) {
1694         {if (true) throw (RuntimeException)jjte000;}
1695       }
1696       if (jjte000 instanceof ParseException) {
1697         {if (true) throw (ParseException)jjte000;}
1698       }
1699       {if (true) throw (Error)jjte000;}
1700     } finally {
1701       if (jjtc000) {
1702         jjtree.closeNodeScope(jjtn000, true);
1703       }
1704     }
1705   }
1706 
1707   final public void IfStatement() throws ParseException {
1708                       /*@bgen(jjtree) IfStatement */
1709   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
1710   boolean jjtc000 = true;
1711   jjtree.openNodeScope(jjtn000);
1712     try {
1713       jj_consume_token(IF_DIRECTIVE);
1714       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1715       case WHITESPACE:
1716         jj_consume_token(WHITESPACE);
1717         break;
1718       default:
1719         jj_la1[48] = jj_gen;
1720         ;
1721       }
1722       jj_consume_token(LPAREN);
1723       Expression();
1724       jj_consume_token(RPAREN);
1725       ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
1726       boolean jjtc001 = true;
1727       jjtree.openNodeScope(jjtn001);
1728       try {
1729         label_15:
1730         while (true) {
1731           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1732           case LPAREN:
1733           case RPAREN:
1734           case ESCAPE_DIRECTIVE:
1735           case SET_DIRECTIVE:
1736           case SINGLE_LINE_COMMENT_START:
1737           case DOUBLE_ESCAPE:
1738           case ESCAPE:
1739           case TEXT:
1740           case FORMAL_COMMENT:
1741           case MULTI_LINE_COMMENT:
1742           case TEXTBLOCK:
1743           case STRING_LITERAL:
1744           case FOREACH_DIRECTIVE:
1745           case IF_DIRECTIVE:
1746           case INTEGER_LITERAL:
1747           case FLOATING_POINT_LITERAL:
1748           case WORD:
1749           case BRACKETED_WORD:
1750           case IDENTIFIER:
1751           case DOT:
1752           case LCURLY:
1753           case RCURLY:
1754           case EMPTY_INDEX:
1755             ;
1756             break;
1757           default:
1758             jj_la1[49] = jj_gen;
1759             break label_15;
1760           }
1761           Statement();
1762         }
1763       } catch (Throwable jjte001) {
1764       if (jjtc001) {
1765         jjtree.clearNodeScope(jjtn001);
1766         jjtc001 = false;
1767       } else {
1768         jjtree.popNode();
1769       }
1770       if (jjte001 instanceof RuntimeException) {
1771         {if (true) throw (RuntimeException)jjte001;}
1772       }
1773       if (jjte001 instanceof ParseException) {
1774         {if (true) throw (ParseException)jjte001;}
1775       }
1776       {if (true) throw (Error)jjte001;}
1777       } finally {
1778       if (jjtc001) {
1779         jjtree.closeNodeScope(jjtn001, true);
1780       }
1781       }
1782       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1783       case ELSEIF_DIRECTIVE:
1784         label_16:
1785         while (true) {
1786           ElseIfStatement();
1787           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1788           case ELSEIF_DIRECTIVE:
1789             ;
1790             break;
1791           default:
1792             jj_la1[50] = jj_gen;
1793             break label_16;
1794           }
1795         }
1796         break;
1797       default:
1798         jj_la1[51] = jj_gen;
1799         ;
1800       }
1801       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1802       case ELSE_DIRECTIVE:
1803         ElseStatement();
1804         break;
1805       default:
1806         jj_la1[52] = jj_gen;
1807         ;
1808       }
1809       jj_consume_token(END);
1810     } catch (Throwable jjte000) {
1811       if (jjtc000) {
1812         jjtree.clearNodeScope(jjtn000);
1813         jjtc000 = false;
1814       } else {
1815         jjtree.popNode();
1816       }
1817       if (jjte000 instanceof RuntimeException) {
1818         {if (true) throw (RuntimeException)jjte000;}
1819       }
1820       if (jjte000 instanceof ParseException) {
1821         {if (true) throw (ParseException)jjte000;}
1822       }
1823       {if (true) throw (Error)jjte000;}
1824     } finally {
1825       if (jjtc000) {
1826         jjtree.closeNodeScope(jjtn000, true);
1827       }
1828     }
1829   }
1830 
1831   final public void ElseStatement() throws ParseException {
1832                         /*@bgen(jjtree) ElseStatement */
1833   ASTElseStatement jjtn000 = new ASTElseStatement(this, JJTELSESTATEMENT);
1834   boolean jjtc000 = true;
1835   jjtree.openNodeScope(jjtn000);
1836     try {
1837       jj_consume_token(ELSE_DIRECTIVE);
1838       ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
1839       boolean jjtc001 = true;
1840       jjtree.openNodeScope(jjtn001);
1841       try {
1842         label_17:
1843         while (true) {
1844           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1845           case LPAREN:
1846           case RPAREN:
1847           case ESCAPE_DIRECTIVE:
1848           case SET_DIRECTIVE:
1849           case SINGLE_LINE_COMMENT_START:
1850           case DOUBLE_ESCAPE:
1851           case ESCAPE:
1852           case TEXT:
1853           case FORMAL_COMMENT:
1854           case MULTI_LINE_COMMENT:
1855           case TEXTBLOCK:
1856           case STRING_LITERAL:
1857           case FOREACH_DIRECTIVE:
1858           case IF_DIRECTIVE:
1859           case INTEGER_LITERAL:
1860           case FLOATING_POINT_LITERAL:
1861           case WORD:
1862           case BRACKETED_WORD:
1863           case IDENTIFIER:
1864           case DOT:
1865           case LCURLY:
1866           case RCURLY:
1867           case EMPTY_INDEX:
1868             ;
1869             break;
1870           default:
1871             jj_la1[53] = jj_gen;
1872             break label_17;
1873           }
1874           Statement();
1875         }
1876       } catch (Throwable jjte001) {
1877       if (jjtc001) {
1878         jjtree.clearNodeScope(jjtn001);
1879         jjtc001 = false;
1880       } else {
1881         jjtree.popNode();
1882       }
1883       if (jjte001 instanceof RuntimeException) {
1884         {if (true) throw (RuntimeException)jjte001;}
1885       }
1886       if (jjte001 instanceof ParseException) {
1887         {if (true) throw (ParseException)jjte001;}
1888       }
1889       {if (true) throw (Error)jjte001;}
1890       } finally {
1891       if (jjtc001) {
1892         jjtree.closeNodeScope(jjtn001, true);
1893       }
1894       }
1895     } catch (Throwable jjte000) {
1896      if (jjtc000) {
1897        jjtree.clearNodeScope(jjtn000);
1898        jjtc000 = false;
1899      } else {
1900        jjtree.popNode();
1901      }
1902      if (jjte000 instanceof RuntimeException) {
1903        {if (true) throw (RuntimeException)jjte000;}
1904      }
1905      if (jjte000 instanceof ParseException) {
1906        {if (true) throw (ParseException)jjte000;}
1907      }
1908      {if (true) throw (Error)jjte000;}
1909     } finally {
1910      if (jjtc000) {
1911        jjtree.closeNodeScope(jjtn000, true);
1912      }
1913     }
1914   }
1915 
1916   final public void ElseIfStatement() throws ParseException {
1917                           /*@bgen(jjtree) ElseIfStatement */
1918   ASTElseIfStatement jjtn000 = new ASTElseIfStatement(this, JJTELSEIFSTATEMENT);
1919   boolean jjtc000 = true;
1920   jjtree.openNodeScope(jjtn000);
1921     try {
1922       jj_consume_token(ELSEIF_DIRECTIVE);
1923       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1924       case WHITESPACE:
1925         jj_consume_token(WHITESPACE);
1926         break;
1927       default:
1928         jj_la1[54] = jj_gen;
1929         ;
1930       }
1931       jj_consume_token(LPAREN);
1932       Expression();
1933       jj_consume_token(RPAREN);
1934       ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
1935       boolean jjtc001 = true;
1936       jjtree.openNodeScope(jjtn001);
1937       try {
1938         label_18:
1939         while (true) {
1940           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1941           case LPAREN:
1942           case RPAREN:
1943           case ESCAPE_DIRECTIVE:
1944           case SET_DIRECTIVE:
1945           case SINGLE_LINE_COMMENT_START:
1946           case DOUBLE_ESCAPE:
1947           case ESCAPE:
1948           case TEXT:
1949           case FORMAL_COMMENT:
1950           case MULTI_LINE_COMMENT:
1951           case TEXTBLOCK:
1952           case STRING_LITERAL:
1953           case FOREACH_DIRECTIVE:
1954           case IF_DIRECTIVE:
1955           case INTEGER_LITERAL:
1956           case FLOATING_POINT_LITERAL:
1957           case WORD:
1958           case BRACKETED_WORD:
1959           case IDENTIFIER:
1960           case DOT:
1961           case LCURLY:
1962           case RCURLY:
1963           case EMPTY_INDEX:
1964             ;
1965             break;
1966           default:
1967             jj_la1[55] = jj_gen;
1968             break label_18;
1969           }
1970           Statement();
1971         }
1972       } catch (Throwable jjte001) {
1973       if (jjtc001) {
1974         jjtree.clearNodeScope(jjtn001);
1975         jjtc001 = false;
1976       } else {
1977         jjtree.popNode();
1978       }
1979       if (jjte001 instanceof RuntimeException) {
1980         {if (true) throw (RuntimeException)jjte001;}
1981       }
1982       if (jjte001 instanceof ParseException) {
1983         {if (true) throw (ParseException)jjte001;}
1984       }
1985       {if (true) throw (Error)jjte001;}
1986       } finally {
1987       if (jjtc001) {
1988         jjtree.closeNodeScope(jjtn001, true);
1989       }
1990       }
1991     } catch (Throwable jjte000) {
1992       if (jjtc000) {
1993         jjtree.clearNodeScope(jjtn000);
1994         jjtc000 = false;
1995       } else {
1996         jjtree.popNode();
1997       }
1998       if (jjte000 instanceof RuntimeException) {
1999         {if (true) throw (RuntimeException)jjte000;}
2000       }
2001       if (jjte000 instanceof ParseException) {
2002         {if (true) throw (ParseException)jjte000;}
2003       }
2004       {if (true) throw (Error)jjte000;}
2005     } finally {
2006       if (jjtc000) {
2007         jjtree.closeNodeScope(jjtn000, true);
2008       }
2009     }
2010   }
2011 
2012 /**
2013  *  Currently support both types of set :
2014  *   #set( expr )
2015  *   #set expr
2016  */
2017   final public void SetDirective() throws ParseException {
2018                        /*@bgen(jjtree) SetDirective */
2019   ASTSetDirective jjtn000 = new ASTSetDirective(this, JJTSETDIRECTIVE);
2020   boolean jjtc000 = true;
2021   jjtree.openNodeScope(jjtn000);
2022     try {
2023       jj_consume_token(SET_DIRECTIVE);
2024       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2025       case WHITESPACE:
2026         jj_consume_token(WHITESPACE);
2027         break;
2028       default:
2029         jj_la1[56] = jj_gen;
2030         ;
2031       }
2032       Reference();
2033       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2034       case WHITESPACE:
2035         jj_consume_token(WHITESPACE);
2036         break;
2037       default:
2038         jj_la1[57] = jj_gen;
2039         ;
2040       }
2041       jj_consume_token(EQUALS);
2042       Expression();
2043       jj_consume_token(RPAREN);
2044         /*
2045          * ensure that inSet is false.  Leads to some amusing bugs...
2046          */
2047 
2048         token_source.inSet = false;
2049       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2050       case NEWLINE:
2051         jj_consume_token(NEWLINE);
2052         break;
2053       default:
2054         jj_la1[58] = jj_gen;
2055         ;
2056       }
2057     } catch (Throwable jjte000) {
2058       if (jjtc000) {
2059         jjtree.clearNodeScope(jjtn000);
2060         jjtc000 = false;
2061       } else {
2062         jjtree.popNode();
2063       }
2064       if (jjte000 instanceof RuntimeException) {
2065         {if (true) throw (RuntimeException)jjte000;}
2066       }
2067       if (jjte000 instanceof ParseException) {
2068         {if (true) throw (ParseException)jjte000;}
2069       }
2070       {if (true) throw (Error)jjte000;}
2071     } finally {
2072       if (jjtc000) {
2073         jjtree.closeNodeScope(jjtn000, true);
2074       }
2075     }
2076   }
2077 
2078 /* -----------------------------------------------------------------------
2079  *
2080  *  Expression Syntax
2081  *
2082  * ----------------------------------------------------------------------*/
2083   final public void Expression() throws ParseException {
2084                      /*@bgen(jjtree) Expression */
2085   ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
2086   boolean jjtc000 = true;
2087   jjtree.openNodeScope(jjtn000);
2088     try {
2089       ConditionalOrExpression();
2090     } catch (Throwable jjte000) {
2091   if (jjtc000) {
2092     jjtree.clearNodeScope(jjtn000);
2093     jjtc000 = false;
2094   } else {
2095     jjtree.popNode();
2096   }
2097   if (jjte000 instanceof RuntimeException) {
2098     {if (true) throw (RuntimeException)jjte000;}
2099   }
2100   if (jjte000 instanceof ParseException) {
2101     {if (true) throw (ParseException)jjte000;}
2102   }
2103   {if (true) throw (Error)jjte000;}
2104     } finally {
2105   if (jjtc000) {
2106     jjtree.closeNodeScope(jjtn000, true);
2107   }
2108     }
2109   }
2110 
2111   final public void Assignment() throws ParseException {
2112                                     /*@bgen(jjtree) #Assignment( 2) */
2113   ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
2114   boolean jjtc000 = true;
2115   jjtree.openNodeScope(jjtn000);
2116     try {
2117       PrimaryExpression();
2118       jj_consume_token(EQUALS);
2119       Expression();
2120     } catch (Throwable jjte000) {
2121       if (jjtc000) {
2122         jjtree.clearNodeScope(jjtn000);
2123         jjtc000 = false;
2124       } else {
2125         jjtree.popNode();
2126       }
2127       if (jjte000 instanceof RuntimeException) {
2128         {if (true) throw (RuntimeException)jjte000;}
2129       }
2130       if (jjte000 instanceof ParseException) {
2131         {if (true) throw (ParseException)jjte000;}
2132       }
2133       {if (true) throw (Error)jjte000;}
2134     } finally {
2135       if (jjtc000) {
2136         jjtree.closeNodeScope(jjtn000,  2);
2137       }
2138     }
2139   }
2140 
2141   final public void ConditionalOrExpression() throws ParseException {
2142     ConditionalAndExpression();
2143     label_19:
2144     while (true) {
2145       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2146       case LOGICAL_OR:
2147         ;
2148         break;
2149       default:
2150         jj_la1[59] = jj_gen;
2151         break label_19;
2152       }
2153       jj_consume_token(LOGICAL_OR);
2154                      ASTOrNode jjtn001 = new ASTOrNode(this, JJTORNODE);
2155                      boolean jjtc001 = true;
2156                      jjtree.openNodeScope(jjtn001);
2157       try {
2158         ConditionalAndExpression();
2159       } catch (Throwable jjte001) {
2160                      if (jjtc001) {
2161                        jjtree.clearNodeScope(jjtn001);
2162                        jjtc001 = false;
2163                      } else {
2164                        jjtree.popNode();
2165                      }
2166                      if (jjte001 instanceof RuntimeException) {
2167                        {if (true) throw (RuntimeException)jjte001;}
2168                      }
2169                      if (jjte001 instanceof ParseException) {
2170                        {if (true) throw (ParseException)jjte001;}
2171                      }
2172                      {if (true) throw (Error)jjte001;}
2173       } finally {
2174                      if (jjtc001) {
2175                        jjtree.closeNodeScope(jjtn001,  2);
2176                      }
2177       }
2178     }
2179   }
2180 
2181   final public void ConditionalAndExpression() throws ParseException {
2182     EqualityExpression();
2183     label_20:
2184     while (true) {
2185       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2186       case LOGICAL_AND:
2187         ;
2188         break;
2189       default:
2190         jj_la1[60] = jj_gen;
2191         break label_20;
2192       }
2193       jj_consume_token(LOGICAL_AND);
2194                     ASTAndNode jjtn001 = new ASTAndNode(this, JJTANDNODE);
2195                     boolean jjtc001 = true;
2196                     jjtree.openNodeScope(jjtn001);
2197       try {
2198         EqualityExpression();
2199       } catch (Throwable jjte001) {
2200                     if (jjtc001) {
2201                       jjtree.clearNodeScope(jjtn001);
2202                       jjtc001 = false;
2203                     } else {
2204                       jjtree.popNode();
2205                     }
2206                     if (jjte001 instanceof RuntimeException) {
2207                       {if (true) throw (RuntimeException)jjte001;}
2208                     }
2209                     if (jjte001 instanceof ParseException) {
2210                       {if (true) throw (ParseException)jjte001;}
2211                     }
2212                     {if (true) throw (Error)jjte001;}
2213       } finally {
2214                     if (jjtc001) {
2215                       jjtree.closeNodeScope(jjtn001,  2);
2216                     }
2217       }
2218     }
2219   }
2220 
2221   final public void EqualityExpression() throws ParseException {
2222     RelationalExpression();
2223     label_21:
2224     while (true) {
2225       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2226       case LOGICAL_EQUALS:
2227       case LOGICAL_NOT_EQUALS:
2228         ;
2229         break;
2230       default:
2231         jj_la1[61] = jj_gen;
2232         break label_21;
2233       }
2234       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2235       case LOGICAL_EQUALS:
2236         jj_consume_token(LOGICAL_EQUALS);
2237                           ASTEQNode jjtn001 = new ASTEQNode(this, JJTEQNODE);
2238                           boolean jjtc001 = true;
2239                           jjtree.openNodeScope(jjtn001);
2240         try {
2241           RelationalExpression();
2242         } catch (Throwable jjte001) {
2243                           if (jjtc001) {
2244                             jjtree.clearNodeScope(jjtn001);
2245                             jjtc001 = false;
2246                           } else {
2247                             jjtree.popNode();
2248                           }
2249                           if (jjte001 instanceof RuntimeException) {
2250                             {if (true) throw (RuntimeException)jjte001;}
2251                           }
2252                           if (jjte001 instanceof ParseException) {
2253                             {if (true) throw (ParseException)jjte001;}
2254                           }
2255                           {if (true) throw (Error)jjte001;}
2256         } finally {
2257                           if (jjtc001) {
2258                             jjtree.closeNodeScope(jjtn001,  2);
2259                           }
2260         }
2261         break;
2262       case LOGICAL_NOT_EQUALS:
2263         jj_consume_token(LOGICAL_NOT_EQUALS);
2264                               ASTNENode jjtn002 = new ASTNENode(this, JJTNENODE);
2265                               boolean jjtc002 = true;
2266                               jjtree.openNodeScope(jjtn002);
2267         try {
2268           RelationalExpression();
2269         } catch (Throwable jjte002) {
2270                               if (jjtc002) {
2271                                 jjtree.clearNodeScope(jjtn002);
2272                                 jjtc002 = false;
2273                               } else {
2274                                 jjtree.popNode();
2275                               }
2276                               if (jjte002 instanceof RuntimeException) {
2277                                 {if (true) throw (RuntimeException)jjte002;}
2278                               }
2279                               if (jjte002 instanceof ParseException) {
2280                                 {if (true) throw (ParseException)jjte002;}
2281                               }
2282                               {if (true) throw (Error)jjte002;}
2283         } finally {
2284                               if (jjtc002) {
2285                                 jjtree.closeNodeScope(jjtn002,  2);
2286                               }
2287         }
2288         break;
2289       default:
2290         jj_la1[62] = jj_gen;
2291         jj_consume_token(-1);
2292         throw new ParseException();
2293       }
2294     }
2295   }
2296 
2297   final public void RelationalExpression() throws ParseException {
2298     AdditiveExpression();
2299     label_22:
2300     while (true) {
2301       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2302       case LOGICAL_LT:
2303       case LOGICAL_LE:
2304       case LOGICAL_GT:
2305       case LOGICAL_GE:
2306         ;
2307         break;
2308       default:
2309         jj_la1[63] = jj_gen;
2310         break label_22;
2311       }
2312       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2313       case LOGICAL_LT:
2314         jj_consume_token(LOGICAL_LT);
2315                         ASTLTNode jjtn001 = new ASTLTNode(this, JJTLTNODE);
2316                         boolean jjtc001 = true;
2317                         jjtree.openNodeScope(jjtn001);
2318         try {
2319           AdditiveExpression();
2320         } catch (Throwable jjte001) {
2321                         if (jjtc001) {
2322                           jjtree.clearNodeScope(jjtn001);
2323                           jjtc001 = false;
2324                         } else {
2325                           jjtree.popNode();
2326                         }
2327                         if (jjte001 instanceof RuntimeException) {
2328                           {if (true) throw (RuntimeException)jjte001;}
2329                         }
2330                         if (jjte001 instanceof ParseException) {
2331                           {if (true) throw (ParseException)jjte001;}
2332                         }
2333                         {if (true) throw (Error)jjte001;}
2334         } finally {
2335                         if (jjtc001) {
2336                           jjtree.closeNodeScope(jjtn001,  2);
2337                         }
2338         }
2339         break;
2340       case LOGICAL_GT:
2341         jj_consume_token(LOGICAL_GT);
2342                         ASTGTNode jjtn002 = new ASTGTNode(this, JJTGTNODE);
2343                         boolean jjtc002 = true;
2344                         jjtree.openNodeScope(jjtn002);
2345         try {
2346           AdditiveExpression();
2347         } catch (Throwable jjte002) {
2348                         if (jjtc002) {
2349                           jjtree.clearNodeScope(jjtn002);
2350                           jjtc002 = false;
2351                         } else {
2352                           jjtree.popNode();
2353                         }
2354                         if (jjte002 instanceof RuntimeException) {
2355                           {if (true) throw (RuntimeException)jjte002;}
2356                         }
2357                         if (jjte002 instanceof ParseException) {
2358                           {if (true) throw (ParseException)jjte002;}
2359                         }
2360                         {if (true) throw (Error)jjte002;}
2361         } finally {
2362                         if (jjtc002) {
2363                           jjtree.closeNodeScope(jjtn002,  2);
2364                         }
2365         }
2366         break;
2367       case LOGICAL_LE:
2368         jj_consume_token(LOGICAL_LE);
2369                         ASTLENode jjtn003 = new ASTLENode(this, JJTLENODE);
2370                         boolean jjtc003 = true;
2371                         jjtree.openNodeScope(jjtn003);
2372         try {
2373           AdditiveExpression();
2374         } catch (Throwable jjte003) {
2375                         if (jjtc003) {
2376                           jjtree.clearNodeScope(jjtn003);
2377                           jjtc003 = false;
2378                         } else {
2379                           jjtree.popNode();
2380                         }
2381                         if (jjte003 instanceof RuntimeException) {
2382                           {if (true) throw (RuntimeException)jjte003;}
2383                         }
2384                         if (jjte003 instanceof ParseException) {
2385                           {if (true) throw (ParseException)jjte003;}
2386                         }
2387                         {if (true) throw (Error)jjte003;}
2388         } finally {
2389                         if (jjtc003) {
2390                           jjtree.closeNodeScope(jjtn003,  2);
2391                         }
2392         }
2393         break;
2394       case LOGICAL_GE:
2395         jj_consume_token(LOGICAL_GE);
2396                         ASTGENode jjtn004 = new ASTGENode(this, JJTGENODE);
2397                         boolean jjtc004 = true;
2398                         jjtree.openNodeScope(jjtn004);
2399         try {
2400           AdditiveExpression();
2401         } catch (Throwable jjte004) {
2402                         if (jjtc004) {
2403                           jjtree.clearNodeScope(jjtn004);
2404                           jjtc004 = false;
2405                         } else {
2406                           jjtree.popNode();
2407                         }
2408                         if (jjte004 instanceof RuntimeException) {
2409                           {if (true) throw (RuntimeException)jjte004;}
2410                         }
2411                         if (jjte004 instanceof ParseException) {
2412                           {if (true) throw (ParseException)jjte004;}
2413                         }
2414                         {if (true) throw (Error)jjte004;}
2415         } finally {
2416                         if (jjtc004) {
2417                           jjtree.closeNodeScope(jjtn004,  2);
2418                         }
2419         }
2420         break;
2421       default:
2422         jj_la1[64] = jj_gen;
2423         jj_consume_token(-1);
2424         throw new ParseException();
2425       }
2426     }
2427   }
2428 
2429   final public void AdditiveExpression() throws ParseException {
2430     MultiplicativeExpression();
2431     label_23:
2432     while (true) {
2433       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2434       case MINUS:
2435       case PLUS:
2436         ;
2437         break;
2438       default:
2439         jj_la1[65] = jj_gen;
2440         break label_23;
2441       }
2442       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2443       case PLUS:
2444         jj_consume_token(PLUS);
2445                   ASTAddNode jjtn001 = new ASTAddNode(this, JJTADDNODE);
2446                   boolean jjtc001 = true;
2447                   jjtree.openNodeScope(jjtn001);
2448         try {
2449           MultiplicativeExpression();
2450         } catch (Throwable jjte001) {
2451                   if (jjtc001) {
2452                     jjtree.clearNodeScope(jjtn001);
2453                     jjtc001 = false;
2454                   } else {
2455                     jjtree.popNode();
2456                   }
2457                   if (jjte001 instanceof RuntimeException) {
2458                     {if (true) throw (RuntimeException)jjte001;}
2459                   }
2460                   if (jjte001 instanceof ParseException) {
2461                     {if (true) throw (ParseException)jjte001;}
2462                   }
2463                   {if (true) throw (Error)jjte001;}
2464         } finally {
2465                   if (jjtc001) {
2466                     jjtree.closeNodeScope(jjtn001,  2);
2467                   }
2468         }
2469         break;
2470       case MINUS:
2471         jj_consume_token(MINUS);
2472                   ASTSubtractNode jjtn002 = new ASTSubtractNode(this, JJTSUBTRACTNODE);
2473                   boolean jjtc002 = true;
2474                   jjtree.openNodeScope(jjtn002);
2475         try {
2476           MultiplicativeExpression();
2477         } catch (Throwable jjte002) {
2478                   if (jjtc002) {
2479                     jjtree.clearNodeScope(jjtn002);
2480                     jjtc002 = false;
2481                   } else {
2482                     jjtree.popNode();
2483                   }
2484                   if (jjte002 instanceof RuntimeException) {
2485                     {if (true) throw (RuntimeException)jjte002;}
2486                   }
2487                   if (jjte002 instanceof ParseException) {
2488                     {if (true) throw (ParseException)jjte002;}
2489                   }
2490                   {if (true) throw (Error)jjte002;}
2491         } finally {
2492                   if (jjtc002) {
2493                     jjtree.closeNodeScope(jjtn002,  2);
2494                   }
2495         }
2496         break;
2497       default:
2498         jj_la1[66] = jj_gen;
2499         jj_consume_token(-1);
2500         throw new ParseException();
2501       }
2502     }
2503   }
2504 
2505   final public void MultiplicativeExpression() throws ParseException {
2506     UnaryExpression();
2507     label_24:
2508     while (true) {
2509       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2510       case MULTIPLY:
2511       case DIVIDE:
2512       case MODULUS:
2513         ;
2514         break;
2515       default:
2516         jj_la1[67] = jj_gen;
2517         break label_24;
2518       }
2519       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2520       case MULTIPLY:
2521         jj_consume_token(MULTIPLY);
2522                           ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);
2523                           boolean jjtc001 = true;
2524                           jjtree.openNodeScope(jjtn001);
2525         try {
2526           UnaryExpression();
2527         } catch (Throwable jjte001) {
2528                           if (jjtc001) {
2529                             jjtree.clearNodeScope(jjtn001);
2530                             jjtc001 = false;
2531                           } else {
2532                             jjtree.popNode();
2533                           }
2534                           if (jjte001 instanceof RuntimeException) {
2535                             {if (true) throw (RuntimeException)jjte001;}
2536                           }
2537                           if (jjte001 instanceof ParseException) {
2538                             {if (true) throw (ParseException)jjte001;}
2539                           }
2540                           {if (true) throw (Error)jjte001;}
2541         } finally {
2542                           if (jjtc001) {
2543                             jjtree.closeNodeScope(jjtn001,  2);
2544                           }
2545         }
2546         break;
2547       case DIVIDE:
2548         jj_consume_token(DIVIDE);
2549                         ASTDivNode jjtn002 = new ASTDivNode(this, JJTDIVNODE);
2550                         boolean jjtc002 = true;
2551                         jjtree.openNodeScope(jjtn002);
2552         try {
2553           UnaryExpression();
2554         } catch (Throwable jjte002) {
2555                         if (jjtc002) {
2556                           jjtree.clearNodeScope(jjtn002);
2557                           jjtc002 = false;
2558                         } else {
2559                           jjtree.popNode();
2560                         }
2561                         if (jjte002 instanceof RuntimeException) {
2562                           {if (true) throw (RuntimeException)jjte002;}
2563                         }
2564                         if (jjte002 instanceof ParseException) {
2565                           {if (true) throw (ParseException)jjte002;}
2566                         }
2567                         {if (true) throw (Error)jjte002;}
2568         } finally {
2569                         if (jjtc002) {
2570                           jjtree.closeNodeScope(jjtn002,  2);
2571                         }
2572         }
2573         break;
2574       case MODULUS:
2575         jj_consume_token(MODULUS);
2576                          ASTModNode jjtn003 = new ASTModNode(this, JJTMODNODE);
2577                          boolean jjtc003 = true;
2578                          jjtree.openNodeScope(jjtn003);
2579         try {
2580           UnaryExpression();
2581         } catch (Throwable jjte003) {
2582                          if (jjtc003) {
2583                            jjtree.clearNodeScope(jjtn003);
2584                            jjtc003 = false;
2585                          } else {
2586                            jjtree.popNode();
2587                          }
2588                          if (jjte003 instanceof RuntimeException) {
2589                            {if (true) throw (RuntimeException)jjte003;}
2590                          }
2591                          if (jjte003 instanceof ParseException) {
2592                            {if (true) throw (ParseException)jjte003;}
2593                          }
2594                          {if (true) throw (Error)jjte003;}
2595         } finally {
2596                          if (jjtc003) {
2597                            jjtree.closeNodeScope(jjtn003,  2);
2598                          }
2599         }
2600         break;
2601       default:
2602         jj_la1[68] = jj_gen;
2603         jj_consume_token(-1);
2604         throw new ParseException();
2605       }
2606     }
2607   }
2608 
2609   final public void UnaryExpression() throws ParseException {
2610     if (jj_2_11(2)) {
2611       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2612       case WHITESPACE:
2613         jj_consume_token(WHITESPACE);
2614         break;
2615       default:
2616         jj_la1[69] = jj_gen;
2617         ;
2618       }
2619       jj_consume_token(LOGICAL_NOT);
2620                                                     ASTNotNode jjtn001 = new ASTNotNode(this, JJTNOTNODE);
2621                                                     boolean jjtc001 = true;
2622                                                     jjtree.openNodeScope(jjtn001);
2623       try {
2624         UnaryExpression();
2625       } catch (Throwable jjte001) {
2626                                                     if (jjtc001) {
2627                                                       jjtree.clearNodeScope(jjtn001);
2628                                                       jjtc001 = false;
2629                                                     } else {
2630                                                       jjtree.popNode();
2631                                                     }
2632                                                     if (jjte001 instanceof RuntimeException) {
2633                                                       {if (true) throw (RuntimeException)jjte001;}
2634                                                     }
2635                                                     if (jjte001 instanceof ParseException) {
2636                                                       {if (true) throw (ParseException)jjte001;}
2637                                                     }
2638                                                     {if (true) throw (Error)jjte001;}
2639       } finally {
2640                                                     if (jjtc001) {
2641                                                       jjtree.closeNodeScope(jjtn001,  1);
2642                                                     }
2643       }
2644     } else {
2645       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2646       case LBRACKET:
2647       case LEFT_CURLEY:
2648       case LPAREN:
2649       case WHITESPACE:
2650       case STRING_LITERAL:
2651       case TRUE:
2652       case FALSE:
2653       case INTEGER_LITERAL:
2654       case FLOATING_POINT_LITERAL:
2655       case IDENTIFIER:
2656       case LCURLY:
2657         PrimaryExpression();
2658         break;
2659       default:
2660         jj_la1[70] = jj_gen;
2661         jj_consume_token(-1);
2662         throw new ParseException();
2663       }
2664     }
2665   }
2666 
2667   final public void PrimaryExpression() throws ParseException {
2668     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2669     case WHITESPACE:
2670       jj_consume_token(WHITESPACE);
2671       break;
2672     default:
2673       jj_la1[71] = jj_gen;
2674       ;
2675     }
2676     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2677     case STRING_LITERAL:
2678       StringLiteral();
2679       break;
2680     case IDENTIFIER:
2681     case LCURLY:
2682       Reference();
2683       break;
2684     case INTEGER_LITERAL:
2685       IntegerLiteral();
2686       break;
2687     default:
2688       jj_la1[72] = jj_gen;
2689       if (jj_2_12(2147483647)) {
2690         IntegerRange();
2691       } else {
2692         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2693         case FLOATING_POINT_LITERAL:
2694           FloatingPointLiteral();
2695           break;
2696         case LEFT_CURLEY:
2697           Map();
2698           break;
2699         case LBRACKET:
2700           ObjectArray();
2701           break;
2702         case TRUE:
2703           True();
2704           break;
2705         case FALSE:
2706           False();
2707           break;
2708         case LPAREN:
2709           jj_consume_token(LPAREN);
2710           Expression();
2711           jj_consume_token(RPAREN);
2712           break;
2713         default:
2714           jj_la1[73] = jj_gen;
2715           jj_consume_token(-1);
2716           throw new ParseException();
2717         }
2718       }
2719     }
2720     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2721     case WHITESPACE:
2722       jj_consume_token(WHITESPACE);
2723       break;
2724     default:
2725       jj_la1[74] = jj_gen;
2726       ;
2727     }
2728   }
2729 
2730   private boolean jj_2_1(int xla) {
2731     jj_la = xla; jj_lastpos = jj_scanpos = token;
2732     try { return !jj_3_1(); }
2733     catch(LookaheadSuccess ls) { return true; }
2734     finally { jj_save(0, xla); }
2735   }
2736 
2737   private boolean jj_2_2(int xla) {
2738     jj_la = xla; jj_lastpos = jj_scanpos = token;
2739     try { return !jj_3_2(); }
2740     catch(LookaheadSuccess ls) { return true; }
2741     finally { jj_save(1, xla); }
2742   }
2743 
2744   private boolean jj_2_3(int xla) {
2745     jj_la = xla; jj_lastpos = jj_scanpos = token;
2746     try { return !jj_3_3(); }
2747     catch(LookaheadSuccess ls) { return true; }
2748     finally { jj_save(2, xla); }
2749   }
2750 
2751   private boolean jj_2_4(int xla) {
2752     jj_la = xla; jj_lastpos = jj_scanpos = token;
2753     try { return !jj_3_4(); }
2754     catch(LookaheadSuccess ls) { return true; }
2755     finally { jj_save(3, xla); }
2756   }
2757 
2758   private boolean jj_2_5(int xla) {
2759     jj_la = xla; jj_lastpos = jj_scanpos = token;
2760     try { return !jj_3_5(); }
2761     catch(LookaheadSuccess ls) { return true; }
2762     finally { jj_save(4, xla); }
2763   }
2764 
2765   private boolean jj_2_6(int xla) {
2766     jj_la = xla; jj_lastpos = jj_scanpos = token;
2767     try { return !jj_3_6(); }
2768     catch(LookaheadSuccess ls) { return true; }
2769     finally { jj_save(5, xla); }
2770   }
2771 
2772   private boolean jj_2_7(int xla) {
2773     jj_la = xla; jj_lastpos = jj_scanpos = token;
2774     try { return !jj_3_7(); }
2775     catch(LookaheadSuccess ls) { return true; }
2776     finally { jj_save(6, xla); }
2777   }
2778 
2779   private boolean jj_2_8(int xla) {
2780     jj_la = xla; jj_lastpos = jj_scanpos = token;
2781     try { return !jj_3_8(); }
2782     catch(LookaheadSuccess ls) { return true; }
2783     finally { jj_save(7, xla); }
2784   }
2785 
2786   private boolean jj_2_9(int xla) {
2787     jj_la = xla; jj_lastpos = jj_scanpos = token;
2788     try { return !jj_3_9(); }
2789     catch(LookaheadSuccess ls) { return true; }
2790     finally { jj_save(8, xla); }
2791   }
2792 
2793   private boolean jj_2_10(int xla) {
2794     jj_la = xla; jj_lastpos = jj_scanpos = token;
2795     try { return !jj_3_10(); }
2796     catch(LookaheadSuccess ls) { return true; }
2797     finally { jj_save(9, xla); }
2798   }
2799 
2800   private boolean jj_2_11(int xla) {
2801     jj_la = xla; jj_lastpos = jj_scanpos = token;
2802     try { return !jj_3_11(); }
2803     catch(LookaheadSuccess ls) { return true; }
2804     finally { jj_save(10, xla); }
2805   }
2806 
2807   private boolean jj_2_12(int xla) {
2808     jj_la = xla; jj_lastpos = jj_scanpos = token;
2809     try { return !jj_3_12(); }
2810     catch(LookaheadSuccess ls) { return true; }
2811     finally { jj_save(11, xla); }
2812   }
2813 
2814   private boolean jj_3R_46() {
2815     if (jj_3R_67()) return true;
2816     return false;
2817   }
2818 
2819   private boolean jj_3R_35() {
2820     if (jj_3R_61()) return true;
2821     return false;
2822   }
2823 
2824   private boolean jj_3R_45() {
2825     if (jj_3R_41()) return true;
2826     return false;
2827   }
2828 
2829   private boolean jj_3R_33() {
2830     if (jj_3R_61()) return true;
2831     return false;
2832   }
2833 
2834   private boolean jj_3R_44() {
2835     if (jj_3R_66()) return true;
2836     return false;
2837   }
2838 
2839   private boolean jj_3R_37() {
2840     if (jj_3R_25()) return true;
2841     return false;
2842   }
2843 
2844   private boolean jj_3R_28() {
2845     if (jj_scan_token(COMMA)) return true;
2846     Token xsp;
2847     xsp = jj_scanpos;
2848     if (jj_scan_token(32)) jj_scanpos = xsp;
2849     return false;
2850   }
2851 
2852   private boolean jj_3R_43() {
2853     if (jj_3R_65()) return true;
2854     return false;
2855   }
2856 
2857   private boolean jj_3R_42() {
2858     if (jj_3R_25()) return true;
2859     return false;
2860   }
2861 
2862   private boolean jj_3R_29() {
2863     Token xsp;
2864     xsp = jj_scanpos;
2865     if (jj_3R_42()) {
2866     jj_scanpos = xsp;
2867     if (jj_3R_43()) {
2868     jj_scanpos = xsp;
2869     if (jj_3R_44()) {
2870     jj_scanpos = xsp;
2871     if (jj_3R_45()) {
2872     jj_scanpos = xsp;
2873     if (jj_3R_46()) {
2874     jj_scanpos = xsp;
2875     if (jj_3R_47()) {
2876     jj_scanpos = xsp;
2877     if (jj_3R_48()) {
2878     jj_scanpos = xsp;
2879     if (jj_3R_49()) {
2880     jj_scanpos = xsp;
2881     if (jj_3R_50()) {
2882     jj_scanpos = xsp;
2883     if (jj_3R_51()) return true;
2884     }
2885     }
2886     }
2887     }
2888     }
2889     }
2890     }
2891     }
2892     }
2893     return false;
2894   }
2895 
2896   private boolean jj_3_10() {
2897     if (jj_3R_34()) return true;
2898     return false;
2899   }
2900 
2901   private boolean jj_3R_65() {
2902     if (jj_scan_token(WORD)) return true;
2903     return false;
2904   }
2905 
2906   private boolean jj_3R_32() {
2907     if (jj_3R_41()) return true;
2908     return false;
2909   }
2910 
2911   private boolean jj_3_8() {
2912     if (jj_3R_34()) return true;
2913     return false;
2914   }
2915 
2916   private boolean jj_3R_61() {
2917     if (jj_scan_token(IDENTIFIER)) return true;
2918     return false;
2919   }
2920 
2921   private boolean jj_3R_75() {
2922     if (jj_3R_74()) return true;
2923     return false;
2924   }
2925 
2926   private boolean jj_3R_98() {
2927     if (jj_scan_token(COMMA)) return true;
2928     if (jj_3R_30()) return true;
2929     return false;
2930   }
2931 
2932   private boolean jj_3R_72() {
2933     if (jj_scan_token(FALSE)) return true;
2934     return false;
2935   }
2936 
2937   private boolean jj_3R_64() {
2938     if (jj_3R_74()) return true;
2939     return false;
2940   }
2941 
2942   private boolean jj_3_12() {
2943     if (jj_scan_token(LBRACKET)) return true;
2944     Token xsp;
2945     xsp = jj_scanpos;
2946     if (jj_scan_token(32)) jj_scanpos = xsp;
2947     xsp = jj_scanpos;
2948     if (jj_3R_37()) {
2949     jj_scanpos = xsp;
2950     if (jj_3R_38()) return true;
2951     }
2952     xsp = jj_scanpos;
2953     if (jj_scan_token(32)) jj_scanpos = xsp;
2954     if (jj_scan_token(DOUBLEDOT)) return true;
2955     return false;
2956   }
2957 
2958   private boolean jj_3_4() {
2959     Token xsp;
2960     xsp = jj_scanpos;
2961     if (jj_scan_token(32)) jj_scanpos = xsp;
2962     xsp = jj_scanpos;
2963     if (jj_3R_28()) jj_scanpos = xsp;
2964     if (jj_3R_29()) return true;
2965     return false;
2966   }
2967 
2968   private boolean jj_3R_31() {
2969     if (jj_3R_25()) return true;
2970     return false;
2971   }
2972 
2973   private boolean jj_3R_71() {
2974     if (jj_scan_token(TRUE)) return true;
2975     return false;
2976   }
2977 
2978   private boolean jj_3_9() {
2979     if (jj_scan_token(DOT)) return true;
2980     Token xsp;
2981     xsp = jj_scanpos;
2982     if (jj_3_10()) {
2983     jj_scanpos = xsp;
2984     if (jj_3R_35()) return true;
2985     }
2986     while (true) {
2987       xsp = jj_scanpos;
2988       if (jj_3R_91()) { jj_scanpos = xsp; break; }
2989     }
2990     return false;
2991   }
2992 
2993   private boolean jj_3R_89() {
2994     if (jj_scan_token(LPAREN)) return true;
2995     return false;
2996   }
2997 
2998   private boolean jj_3R_66() {
2999     if (jj_scan_token(STRING_LITERAL)) return true;
3000     return false;
3001   }
3002 
3003   private boolean jj_3R_88() {
3004     if (jj_3R_72()) return true;
3005     return false;
3006   }
3007 
3008   private boolean jj_3R_87() {
3009     if (jj_3R_71()) return true;
3010     return false;
3011   }
3012 
3013   private boolean jj_3R_86() {
3014     if (jj_3R_70()) return true;
3015     return false;
3016   }
3017 
3018   private boolean jj_3_7() {
3019     if (jj_scan_token(DOT)) return true;
3020     Token xsp;
3021     xsp = jj_scanpos;
3022     if (jj_3_8()) {
3023     jj_scanpos = xsp;
3024     if (jj_3R_33()) return true;
3025     }
3026     while (true) {
3027       xsp = jj_scanpos;
3028       if (jj_3R_90()) { jj_scanpos = xsp; break; }
3029     }
3030     return false;
3031   }
3032 
3033   private boolean jj_3R_62() {
3034     if (jj_3R_30()) return true;
3035     Token xsp;
3036     while (true) {
3037       xsp = jj_scanpos;
3038       if (jj_3R_98()) { jj_scanpos = xsp; break; }
3039     }
3040     return false;
3041   }
3042 
3043   private boolean jj_3R_85() {
3044     if (jj_3R_69()) return true;
3045     return false;
3046   }
3047 
3048   private boolean jj_3R_41() {
3049     if (jj_scan_token(INTEGER_LITERAL)) return true;
3050     return false;
3051   }
3052 
3053   private boolean jj_3R_40() {
3054     if (jj_scan_token(LCURLY)) return true;
3055     if (jj_scan_token(IDENTIFIER)) return true;
3056     Token xsp;
3057     while (true) {
3058       xsp = jj_scanpos;
3059       if (jj_3R_75()) { jj_scanpos = xsp; break; }
3060     }
3061     while (true) {
3062       xsp = jj_scanpos;
3063       if (jj_3_9()) { jj_scanpos = xsp; break; }
3064     }
3065     if (jj_scan_token(RCURLY)) return true;
3066     return false;
3067   }
3068 
3069   private boolean jj_3R_84() {
3070     if (jj_3R_68()) return true;
3071     return false;
3072   }
3073 
3074   private boolean jj_3R_83() {
3075     if (jj_3R_67()) return true;
3076     return false;
3077   }
3078 
3079   private boolean jj_3R_82() {
3080     if (jj_3R_41()) return true;
3081     return false;
3082   }
3083 
3084   private boolean jj_3R_81() {
3085     if (jj_3R_25()) return true;
3086     return false;
3087   }
3088 
3089   private boolean jj_3R_39() {
3090     if (jj_scan_token(IDENTIFIER)) return true;
3091     Token xsp;
3092     while (true) {
3093       xsp = jj_scanpos;
3094       if (jj_3R_64()) { jj_scanpos = xsp; break; }
3095     }
3096     while (true) {
3097       xsp = jj_scanpos;
3098       if (jj_3_7()) { jj_scanpos = xsp; break; }
3099     }
3100     return false;
3101   }
3102 
3103   private boolean jj_3R_68() {
3104     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
3105     return false;
3106   }
3107 
3108   private boolean jj_3R_80() {
3109     if (jj_3R_66()) return true;
3110     return false;
3111   }
3112 
3113   private boolean jj_3R_25() {
3114     Token xsp;
3115     xsp = jj_scanpos;
3116     if (jj_3R_39()) {
3117     jj_scanpos = xsp;
3118     if (jj_3R_40()) return true;
3119     }
3120     return false;
3121   }
3122 
3123   private boolean jj_3R_73() {
3124     Token xsp;
3125     xsp = jj_scanpos;
3126     if (jj_scan_token(32)) jj_scanpos = xsp;
3127     xsp = jj_scanpos;
3128     if (jj_3R_80()) {
3129     jj_scanpos = xsp;
3130     if (jj_3R_81()) {
3131     jj_scanpos = xsp;
3132     if (jj_3R_82()) {
3133     jj_scanpos = xsp;
3134     if (jj_3R_83()) {
3135     jj_scanpos = xsp;
3136     if (jj_3R_84()) {
3137     jj_scanpos = xsp;
3138     if (jj_3R_85()) {
3139     jj_scanpos = xsp;
3140     if (jj_3R_86()) {
3141     jj_scanpos = xsp;
3142     if (jj_3R_87()) {
3143     jj_scanpos = xsp;
3144     if (jj_3R_88()) {
3145     jj_scanpos = xsp;
3146     if (jj_3R_89()) return true;
3147     }
3148     }
3149     }
3150     }
3151     }
3152     }
3153     }
3154     }
3155     }
3156     return false;
3157   }
3158 
3159   private boolean jj_3R_36() {
3160     Token xsp;
3161     xsp = jj_scanpos;
3162     if (jj_3_11()) {
3163     jj_scanpos = xsp;
3164     if (jj_3R_63()) return true;
3165     }
3166     return false;
3167   }
3168 
3169   private boolean jj_3_11() {
3170     Token xsp;
3171     xsp = jj_scanpos;
3172     if (jj_scan_token(32)) jj_scanpos = xsp;
3173     if (jj_scan_token(LOGICAL_NOT)) return true;
3174     if (jj_3R_36()) return true;
3175     return false;
3176   }
3177 
3178   private boolean jj_3R_63() {
3179     if (jj_3R_73()) return true;
3180     return false;
3181   }
3182 
3183   private boolean jj_3R_74() {
3184     if (jj_scan_token(INDEX_LBRACKET)) return true;
3185     if (jj_3R_92()) return true;
3186     if (jj_scan_token(INDEX_RBRACKET)) return true;
3187     return false;
3188   }
3189 
3190   private boolean jj_3_6() {
3191     if (jj_scan_token(LBRACKET)) return true;
3192     Token xsp;
3193     xsp = jj_scanpos;
3194     if (jj_scan_token(32)) jj_scanpos = xsp;
3195     xsp = jj_scanpos;
3196     if (jj_3R_31()) {
3197     jj_scanpos = xsp;
3198     if (jj_3R_32()) return true;
3199     }
3200     xsp = jj_scanpos;
3201     if (jj_scan_token(32)) jj_scanpos = xsp;
3202     if (jj_scan_token(DOUBLEDOT)) return true;
3203     return false;
3204   }
3205 
3206   private boolean jj_3R_34() {
3207     if (jj_3R_61()) return true;
3208     if (jj_scan_token(LPAREN)) return true;
3209     Token xsp;
3210     xsp = jj_scanpos;
3211     if (jj_3R_62()) jj_scanpos = xsp;
3212     if (jj_scan_token(REFMOD2_RPAREN)) return true;
3213     return false;
3214   }
3215 
3216   private boolean jj_3R_60() {
3217     if (jj_3R_68()) return true;
3218     return false;
3219   }
3220 
3221   private boolean jj_3R_59() {
3222     if (jj_3R_25()) return true;
3223     return false;
3224   }
3225 
3226   private boolean jj_3R_58() {
3227     if (jj_3R_72()) return true;
3228     return false;
3229   }
3230 
3231   private boolean jj_3R_57() {
3232     if (jj_3R_71()) return true;
3233     return false;
3234   }
3235 
3236   private boolean jj_3R_56() {
3237     if (jj_3R_70()) return true;
3238     return false;
3239   }
3240 
3241   private boolean jj_3R_55() {
3242     if (jj_3R_69()) return true;
3243     return false;
3244   }
3245 
3246   private boolean jj_3R_54() {
3247     if (jj_3R_67()) return true;
3248     return false;
3249   }
3250 
3251   private boolean jj_3R_53() {
3252     if (jj_3R_41()) return true;
3253     return false;
3254   }
3255 
3256   private boolean jj_3R_52() {
3257     if (jj_3R_66()) return true;
3258     return false;
3259   }
3260 
3261   private boolean jj_3R_30() {
3262     Token xsp;
3263     xsp = jj_scanpos;
3264     if (jj_scan_token(32)) jj_scanpos = xsp;
3265     xsp = jj_scanpos;
3266     if (jj_3R_52()) {
3267     jj_scanpos = xsp;
3268     if (jj_3R_53()) {
3269     jj_scanpos = xsp;
3270     if (jj_3R_54()) {
3271     jj_scanpos = xsp;
3272     if (jj_3R_55()) {
3273     jj_scanpos = xsp;
3274     if (jj_3R_56()) {
3275     jj_scanpos = xsp;
3276     if (jj_3R_57()) {
3277     jj_scanpos = xsp;
3278     if (jj_3R_58()) {
3279     jj_scanpos = xsp;
3280     if (jj_3R_59()) {
3281     jj_scanpos = xsp;
3282     if (jj_3R_60()) return true;
3283     }
3284     }
3285     }
3286     }
3287     }
3288     }
3289     }
3290     }
3291     xsp = jj_scanpos;
3292     if (jj_scan_token(32)) jj_scanpos = xsp;
3293     return false;
3294   }
3295 
3296   private boolean jj_3R_101() {
3297     if (jj_scan_token(COMMA)) return true;
3298     if (jj_3R_30()) return true;
3299     if (jj_scan_token(COLON)) return true;
3300     if (jj_3R_30()) return true;
3301     return false;
3302   }
3303 
3304   private boolean jj_3R_97() {
3305     if (jj_3R_25()) return true;
3306     return false;
3307   }
3308 
3309   private boolean jj_3R_96() {
3310     if (jj_3R_72()) return true;
3311     return false;
3312   }
3313 
3314   private boolean jj_3R_95() {
3315     if (jj_3R_71()) return true;
3316     return false;
3317   }
3318 
3319   private boolean jj_3R_94() {
3320     if (jj_3R_41()) return true;
3321     return false;
3322   }
3323 
3324   private boolean jj_3R_93() {
3325     if (jj_3R_66()) return true;
3326     return false;
3327   }
3328 
3329   private boolean jj_3R_100() {
3330     if (jj_3R_41()) return true;
3331     return false;
3332   }
3333 
3334   private boolean jj_3_2() {
3335     if (jj_scan_token(DOUBLE_ESCAPE)) return true;
3336     return false;
3337   }
3338 
3339   private boolean jj_3R_77() {
3340     if (jj_3R_41()) return true;
3341     return false;
3342   }
3343 
3344   private boolean jj_3R_102() {
3345     if (jj_scan_token(COMMA)) return true;
3346     if (jj_3R_30()) return true;
3347     return false;
3348   }
3349 
3350   private boolean jj_3R_92() {
3351     Token xsp;
3352     xsp = jj_scanpos;
3353     if (jj_scan_token(32)) jj_scanpos = xsp;
3354     xsp = jj_scanpos;
3355     if (jj_3R_93()) {
3356     jj_scanpos = xsp;
3357     if (jj_3R_94()) {
3358     jj_scanpos = xsp;
3359     if (jj_3R_95()) {
3360     jj_scanpos = xsp;
3361     if (jj_3R_96()) {
3362     jj_scanpos = xsp;
3363     if (jj_3R_97()) return true;
3364     }
3365     }
3366     }
3367     }
3368     xsp = jj_scanpos;
3369     if (jj_scan_token(32)) jj_scanpos = xsp;
3370     return false;
3371   }
3372 
3373   private boolean jj_3R_99() {
3374     if (jj_3R_25()) return true;
3375     return false;
3376   }
3377 
3378   private boolean jj_3R_76() {
3379     if (jj_3R_25()) return true;
3380     return false;
3381   }
3382 
3383   private boolean jj_3R_79() {
3384     if (jj_3R_30()) return true;
3385     Token xsp;
3386     while (true) {
3387       xsp = jj_scanpos;
3388       if (jj_3R_102()) { jj_scanpos = xsp; break; }
3389     }
3390     return false;
3391   }
3392 
3393   private boolean jj_3R_67() {
3394     if (jj_scan_token(LBRACKET)) return true;
3395     Token xsp;
3396     xsp = jj_scanpos;
3397     if (jj_scan_token(32)) jj_scanpos = xsp;
3398     xsp = jj_scanpos;
3399     if (jj_3R_76()) {
3400     jj_scanpos = xsp;
3401     if (jj_3R_77()) return true;
3402     }
3403     xsp = jj_scanpos;
3404     if (jj_scan_token(32)) jj_scanpos = xsp;
3405     if (jj_scan_token(DOUBLEDOT)) return true;
3406     xsp = jj_scanpos;
3407     if (jj_scan_token(32)) jj_scanpos = xsp;
3408     xsp = jj_scanpos;
3409     if (jj_3R_99()) {
3410     jj_scanpos = xsp;
3411     if (jj_3R_100()) return true;
3412     }
3413     xsp = jj_scanpos;
3414     if (jj_scan_token(32)) jj_scanpos = xsp;
3415     if (jj_scan_token(RBRACKET)) return true;
3416     return false;
3417   }
3418 
3419   private boolean jj_3R_27() {
3420     if (jj_3R_41()) return true;
3421     return false;
3422   }
3423 
3424   private boolean jj_3R_70() {
3425     if (jj_scan_token(LBRACKET)) return true;
3426     Token xsp;
3427     xsp = jj_scanpos;
3428     if (jj_3R_79()) jj_scanpos = xsp;
3429     if (jj_scan_token(RBRACKET)) return true;
3430     return false;
3431   }
3432 
3433   private boolean jj_3R_78() {
3434     Token xsp;
3435     xsp = jj_scanpos;
3436     if (jj_scan_token(32)) jj_scanpos = xsp;
3437     return false;
3438   }
3439 
3440   private boolean jj_3_5() {
3441     if (jj_3R_30()) return true;
3442     if (jj_scan_token(COLON)) return true;
3443     if (jj_3R_30()) return true;
3444     Token xsp;
3445     while (true) {
3446       xsp = jj_scanpos;
3447       if (jj_3R_101()) { jj_scanpos = xsp; break; }
3448     }
3449     return false;
3450   }
3451 
3452   private boolean jj_3R_26() {
3453     if (jj_3R_25()) return true;
3454     return false;
3455   }
3456 
3457   private boolean jj_3R_69() {
3458     if (jj_scan_token(LEFT_CURLEY)) return true;
3459     Token xsp;
3460     xsp = jj_scanpos;
3461     if (jj_3_5()) {
3462     jj_scanpos = xsp;
3463     if (jj_3R_78()) return true;
3464     }
3465     xsp = jj_scanpos;
3466     if (jj_scan_token(10)) {
3467     jj_scanpos = xsp;
3468     if (jj_scan_token(71)) return true;
3469     }
3470     return false;
3471   }
3472 
3473   private boolean jj_3_1() {
3474     if (jj_3R_25()) return true;
3475     return false;
3476   }
3477 
3478   private boolean jj_3R_51() {
3479     if (jj_3R_72()) return true;
3480     return false;
3481   }
3482 
3483   private boolean jj_3R_50() {
3484     if (jj_3R_71()) return true;
3485     return false;
3486   }
3487 
3488   private boolean jj_3R_91() {
3489     if (jj_3R_74()) return true;
3490     return false;
3491   }
3492 
3493   private boolean jj_3_3() {
3494     if (jj_scan_token(LBRACKET)) return true;
3495     Token xsp;
3496     xsp = jj_scanpos;
3497     if (jj_scan_token(32)) jj_scanpos = xsp;
3498     xsp = jj_scanpos;
3499     if (jj_3R_26()) {
3500     jj_scanpos = xsp;
3501     if (jj_3R_27()) return true;
3502     }
3503     xsp = jj_scanpos;
3504     if (jj_scan_token(32)) jj_scanpos = xsp;
3505     if (jj_scan_token(DOUBLEDOT)) return true;
3506     return false;
3507   }
3508 
3509   private boolean jj_3R_49() {
3510     if (jj_3R_70()) return true;
3511     return false;
3512   }
3513 
3514   private boolean jj_3R_90() {
3515     if (jj_3R_74()) return true;
3516     return false;
3517   }
3518 
3519   private boolean jj_3R_48() {
3520     if (jj_3R_69()) return true;
3521     return false;
3522   }
3523 
3524   private boolean jj_3R_47() {
3525     if (jj_3R_68()) return true;
3526     return false;
3527   }
3528 
3529   private boolean jj_3R_38() {
3530     if (jj_3R_41()) return true;
3531     return false;
3532   }
3533 
3534   /** Generated Token Manager. */
3535   public VmParserTokenManager token_source;
3536   /** Current token. */
3537   public Token token;
3538   /** Next token. */
3539   public Token jj_nt;
3540   private int jj_ntk;
3541   private Token jj_scanpos, jj_lastpos;
3542   private int jj_la;
3543   private int jj_gen;
3544   final private int[] jj_la1 = new int[75];
3545   static private int[] jj_la1_0;
3546   static private int[] jj_la1_1;
3547   static private int[] jj_la1_2;
3548   static {
3549       jj_la1_init_0();
3550       jj_la1_init_1();
3551       jj_la1_init_2();
3552    }
3553    private static void jj_la1_init_0() {
3554       jj_la1_0 = new int[] {0x3bc0d800,0x0,0x3bc0d800,0x4000000,0x18400000,0x0,0x208,0x0,0x0,0x0,0x0,0x20,0x0,0x3bc0d800,0x20,0x0,0x400,0x20,0x208,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x208,0x0,0x20,0x208,0x2,0x0,0x2,0x2,0x0,0x2,0x0,0x3001800,0x0,0x0,0x0,0x0,0x0,0x3bc0d800,0x0,0x3bc0d800,0x0,0x0,0x0,0x3bc0d800,0x0,0x3bc0d800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa08,0x0,0x0,0xa08,0x0,};
3555    }
3556    private static void jj_la1_init_1() {
3557       jj_la1_1 = new int[] {0x8c600002,0x600000,0x8c000002,0x0,0x0,0x84000002,0x800000c,0x80000000,0x1,0x1,0x1,0x0,0x1,0x8c600002,0x0,0x1,0x0,0x0,0xc00000f,0x1,0x4000000,0x1,0x1,0x4000000,0x1,0x1,0x400000e,0x1,0x1,0x4000002,0x800000c,0x1,0x0,0xc00000f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000002,0x1,0x1,0x1,0x1,0x1,0x8c600002,0x1,0x8c600002,0x800000,0x800000,0x1000000,0x8c600002,0x1,0x8c600002,0x1,0x1,0x10,0x800,0x400,0x30000,0x30000,0xf000,0xf000,0x60,0x60,0x380,0x380,0x1,0xc00000f,0x1,0x4000002,0x800000c,0x1,};
3558    }
3559    private static void jj_la1_init_2() {
3560       jj_la1_2 = new int[] {0x4f1,0x0,0x4e1,0x0,0x0,0x50,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x4f1,0x0,0x0,0x80,0x0,0x50,0x0,0x50,0x0,0x0,0x50,0x0,0x0,0x50,0x0,0x0,0x0,0x50,0x0,0x0,0x50,0x0,0x10,0x0,0x0,0x10,0x0,0x50,0x4e0,0x0,0x0,0x0,0x0,0x0,0x4f1,0x0,0x4f1,0x0,0x0,0x0,0x4f1,0x0,0x4f1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50,0x0,0x50,0x0,0x0,};
3561    }
3562   final private JJCalls[] jj_2_rtns = new JJCalls[12];
3563   private boolean jj_rescan = false;
3564   private int jj_gc = 0;
3565 
3566   /** Constructor with user supplied CharStream. */
3567   public VmParser(CharStream stream) {
3568     token_source = new VmParserTokenManager(stream);
3569     token = new Token();
3570     jj_ntk = -1;
3571     jj_gen = 0;
3572     for (int i = 0; i < 75; i++) jj_la1[i] = -1;
3573     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3574   }
3575 
3576   /** Reinitialise. */
3577   public void ReInit(CharStream stream) {
3578     token_source.ReInit(stream);
3579     token = new Token();
3580     jj_ntk = -1;
3581     jjtree.reset();
3582     jj_gen = 0;
3583     for (int i = 0; i < 75; i++) jj_la1[i] = -1;
3584     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3585   }
3586 
3587   /** Constructor with generated Token Manager. */
3588   public VmParser(VmParserTokenManager tm) {
3589     token_source = tm;
3590     token = new Token();
3591     jj_ntk = -1;
3592     jj_gen = 0;
3593     for (int i = 0; i < 75; i++) jj_la1[i] = -1;
3594     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3595   }
3596 
3597   /** Reinitialise. */
3598   public void ReInit(VmParserTokenManager tm) {
3599     token_source = tm;
3600     token = new Token();
3601     jj_ntk = -1;
3602     jjtree.reset();
3603     jj_gen = 0;
3604     for (int i = 0; i < 75; i++) jj_la1[i] = -1;
3605     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3606   }
3607 
3608   private Token jj_consume_token(int kind) throws ParseException {
3609     Token oldToken;
3610     if ((oldToken = token).next != null) token = token.next;
3611     else token = token.next = token_source.getNextToken();
3612     jj_ntk = -1;
3613     if (token.kind == kind) {
3614       jj_gen++;
3615       if (++jj_gc > 100) {
3616         jj_gc = 0;
3617         for (int i = 0; i < jj_2_rtns.length; i++) {
3618           JJCalls c = jj_2_rtns[i];
3619           while (c != null) {
3620             if (c.gen < jj_gen) c.first = null;
3621             c = c.next;
3622           }
3623         }
3624       }
3625       return token;
3626     }
3627     token = oldToken;
3628     jj_kind = kind;
3629     throw generateParseException();
3630   }
3631 
3632   static private final class LookaheadSuccess extends java.lang.Error { }
3633   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3634   private boolean jj_scan_token(int kind) {
3635     if (jj_scanpos == jj_lastpos) {
3636       jj_la--;
3637       if (jj_scanpos.next == null) {
3638         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3639       } else {
3640         jj_lastpos = jj_scanpos = jj_scanpos.next;
3641       }
3642     } else {
3643       jj_scanpos = jj_scanpos.next;
3644     }
3645     if (jj_rescan) {
3646       int i = 0; Token tok = token;
3647       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3648       if (tok != null) jj_add_error_token(kind, i);
3649     }
3650     if (jj_scanpos.kind != kind) return true;
3651     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
3652     return false;
3653   }
3654 
3655 
3656 /** Get the next Token. */
3657   final public Token getNextToken() {
3658     if (token.next != null) token = token.next;
3659     else token = token.next = token_source.getNextToken();
3660     jj_ntk = -1;
3661     jj_gen++;
3662     return token;
3663   }
3664 
3665 /** Get the specific Token. */
3666   final public Token getToken(int index) {
3667     Token t = token;
3668     for (int i = 0; i < index; i++) {
3669       if (t.next != null) t = t.next;
3670       else t = t.next = token_source.getNextToken();
3671     }
3672     return t;
3673   }
3674 
3675   private int jj_ntk() {
3676     if ((jj_nt=token.next) == null)
3677       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
3678     else
3679       return (jj_ntk = jj_nt.kind);
3680   }
3681 
3682   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
3683   private int[] jj_expentry;
3684   private int jj_kind = -1;
3685   private int[] jj_lasttokens = new int[100];
3686   private int jj_endpos;
3687 
3688   private void jj_add_error_token(int kind, int pos) {
3689     if (pos >= 100) return;
3690     if (pos == jj_endpos + 1) {
3691       jj_lasttokens[jj_endpos++] = kind;
3692     } else if (jj_endpos != 0) {
3693       jj_expentry = new int[jj_endpos];
3694       for (int i = 0; i < jj_endpos; i++) {
3695         jj_expentry[i] = jj_lasttokens[i];
3696       }
3697       jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
3698         int[] oldentry = (int[])(it.next());
3699         if (oldentry.length == jj_expentry.length) {
3700           for (int i = 0; i < jj_expentry.length; i++) {
3701             if (oldentry[i] != jj_expentry[i]) {
3702               continue jj_entries_loop;
3703             }
3704           }
3705           jj_expentries.add(jj_expentry);
3706           break jj_entries_loop;
3707         }
3708       }
3709       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3710     }
3711   }
3712 
3713   /** Generate ParseException. */
3714   public ParseException generateParseException() {
3715     jj_expentries.clear();
3716     boolean[] la1tokens = new boolean[75];
3717     if (jj_kind >= 0) {
3718       la1tokens[jj_kind] = true;
3719       jj_kind = -1;
3720     }
3721     for (int i = 0; i < 75; i++) {
3722       if (jj_la1[i] == jj_gen) {
3723         for (int j = 0; j < 32; j++) {
3724           if ((jj_la1_0[i] & (1<<j)) != 0) {
3725             la1tokens[j] = true;
3726           }
3727           if ((jj_la1_1[i] & (1<<j)) != 0) {
3728             la1tokens[32+j] = true;
3729           }
3730           if ((jj_la1_2[i] & (1<<j)) != 0) {
3731             la1tokens[64+j] = true;
3732           }
3733         }
3734       }
3735     }
3736     for (int i = 0; i < 75; i++) {
3737       if (la1tokens[i]) {
3738         jj_expentry = new int[1];
3739         jj_expentry[0] = i;
3740         jj_expentries.add(jj_expentry);
3741       }
3742     }
3743     jj_endpos = 0;
3744     jj_rescan_token();
3745     jj_add_error_token(0, 0);
3746     int[][] exptokseq = new int[jj_expentries.size()][];
3747     for (int i = 0; i < jj_expentries.size(); i++) {
3748       exptokseq[i] = jj_expentries.get(i);
3749     }
3750     return new ParseException(token, exptokseq, tokenImage);
3751   }
3752 
3753   /** Enable tracing. */
3754   final public void enable_tracing() {
3755   }
3756 
3757   /** Disable tracing. */
3758   final public void disable_tracing() {
3759   }
3760 
3761   private void jj_rescan_token() {
3762     jj_rescan = true;
3763     for (int i = 0; i < 12; i++) {
3764     try {
3765       JJCalls p = jj_2_rtns[i];
3766       do {
3767         if (p.gen > jj_gen) {
3768           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3769           switch (i) {
3770             case 0: jj_3_1(); break;
3771             case 1: jj_3_2(); break;
3772             case 2: jj_3_3(); break;
3773             case 3: jj_3_4(); break;
3774             case 4: jj_3_5(); break;
3775             case 5: jj_3_6(); break;
3776             case 6: jj_3_7(); break;
3777             case 7: jj_3_8(); break;
3778             case 8: jj_3_9(); break;
3779             case 9: jj_3_10(); break;
3780             case 10: jj_3_11(); break;
3781             case 11: jj_3_12(); break;
3782           }
3783         }
3784         p = p.next;
3785       } while (p != null);
3786       } catch(LookaheadSuccess ls) { }
3787     }
3788     jj_rescan = false;
3789   }
3790 
3791   private void jj_save(int index, int xla) {
3792     JJCalls p = jj_2_rtns[index];
3793     while (p.gen > jj_gen) {
3794       if (p.next == null) { p = p.next = new JJCalls(); break; }
3795       p = p.next;
3796     }
3797     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3798   }
3799 
3800   static final class JJCalls {
3801     int gen;
3802     Token first;
3803     int arg;
3804     JJCalls next;
3805   }
3806 
3807 }