Parser


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