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