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