Parser xref

View Javadoc

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