001    /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
002    package bsh;
003    
004    import java.io.*;
005    import java.util.Vector;
006    
007    /**
008            This is the BeanShell parser.  It is used internally by the Interpreter
009            class (which is probably what you are looking for).  The parser knows
010            only how to parse the structure of the language, it does not understand
011            names, commands, etc.
012            <p>
013            You can use the Parser from the command line to do basic structural 
014            validation of BeanShell files without actually executing them. e.g.
015            <code><pre>
016                    java bsh.Parser [ -p ] file [ file ] [ ... ]
017            </pre></code>
018            <p>
019            The -p option causes the abstract syntax to be printed.
020            <p>
021    
022            From code you'd use the Parser like this:
023            <p
024            <code><pre>
025                    Parser parser = new Parser(in);
026                    while( !(eof=parser.Line()) ) {
027                            SimpleNode node = parser.popNode();
028                            // use the node, etc. (See bsh.BSH* classes)
029                    }
030            </pre></code>
031    */
032    public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/
033      protected JJTParserState jjtree = new JJTParserState();boolean retainComments = false;
034    
035            public void setRetainComments( boolean b ) {
036                    retainComments = b;
037            }
038    
039            void jjtreeOpenNodeScope(Node n) {
040                    ((SimpleNode)n).firstToken = getToken(1);
041            }
042    
043            void jjtreeCloseNodeScope(Node n) {
044                    ((SimpleNode)n).lastToken = getToken(0);
045            }
046    
047            /**
048                    Re-initialize the input stream and token source.
049            */
050            void reInitInput( Reader in ) {
051                    ReInit(in);
052            }
053    
054            public SimpleNode popNode()
055            {
056                    if ( jjtree.nodeArity() > 0)  // number of child nodes 
057                            return (SimpleNode)jjtree.popNode();
058                    else
059                            return null;
060            }
061    
062            /**
063                    Explicitly re-initialize just the token reader.
064                    This seems to be necessary to avoid certain looping errors when
065                    reading bogus input.  See Interpreter.
066            */
067            void reInitTokenInput( Reader in ) {
068                    jj_input_stream.ReInit( in,
069                            jj_input_stream.getEndLine(),
070                            jj_input_stream.getEndColumn() );
071            }
072    
073            public static void main( String [] args )
074                    throws IOException, ParseException
075            {
076                    boolean print = false;
077                    int i=0;
078                    if ( args[0].equals("-p") ) {
079                            i++;
080                            print=true;
081                    }
082                    for(; i< args.length; i++) {
083                            Reader in = new FileReader(args[i]);
084                            Parser parser = new Parser(in);
085                            parser.setRetainComments(true);
086                            while( !parser.Line()/*eof*/ )
087                                    if ( print )
088                                            System.out.println( parser.popNode() );
089                    }
090            }
091    
092            /**
093                    Lookahead for the enhanced for statement.  
094                    Expect "for" "(" and then see whether we hit ":" or a ";" first.
095            */
096            boolean isRegularForStatement()
097            {
098                    int curTok = 1;
099                    Token tok;
100                    tok = getToken(curTok++);
101                    if ( tok.kind != FOR ) return false;
102                    tok = getToken(curTok++);
103                    if ( tok.kind != LPAREN ) return false;
104                    while (true)
105                    {
106                            tok = getToken(curTok++);
107                            switch (tok.kind) {
108                                    case COLON:
109                                            return false;
110                                    case SEMICOLON:
111                                            return true;
112                                    case EOF:
113                                            return false;
114                            }
115                    }
116            }
117    
118            /**
119                    Generate a ParseException with the specified message, pointing to the
120                    current token.
121                    The auto-generated Parser.generateParseException() method does not
122                    provide line number info, therefore we do this.
123            */
124            ParseException createParseException( String message )
125            {
126                    Token errortok = token;
127                    int line = errortok.beginLine, column = errortok.beginColumn;
128                    String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
129                    return new ParseException( "Parse error at line " + line
130                            + ", column " + column + " : " + message );
131            }
132    
133    /*
134            Thanks to Sreenivasa Viswanadha for suggesting how to get rid of expensive
135            lookahead here.
136    */
137      final public boolean Line() throws ParseException {
138        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
139        case 0:
140          jj_consume_token(0);
141            Interpreter.debug("End of File!");
142            {if (true) return true;}
143          break;
144        default:
145          if (jj_2_1(1)) {
146            BlockStatement();
147            {if (true) return false;}
148          } else {
149            jj_consume_token(-1);
150            throw new ParseException();
151          }
152        }
153        throw new Error("Missing return statement in function");
154      }
155    
156    /*****************************************
157     * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
158     *****************************************/
159    
160    /*
161            Gather modifiers for a class, method, or field.
162            I lookahead is true then we are being called as part of a lookahead and we
163            should not enforce any rules.  Otherwise we validate based on context
164            (field, method, class)
165    */
166      final public Modifiers Modifiers(int context, boolean lookahead) throws ParseException {
167            Modifiers mods = null;
168        label_1:
169        while (true) {
170          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
171          case ABSTRACT:
172          case FINAL:
173          case NATIVE:
174          case PRIVATE:
175          case PROTECTED:
176          case PUBLIC:
177          case STATIC:
178          case STRICTFP:
179          case SYNCHRONIZED:
180          case TRANSIENT:
181          case VOLATILE:
182            ;
183            break;
184          default:
185            break label_1;
186          }
187          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
188          case PRIVATE:
189            jj_consume_token(PRIVATE);
190            break;
191          case PROTECTED:
192            jj_consume_token(PROTECTED);
193            break;
194          case PUBLIC:
195            jj_consume_token(PUBLIC);
196            break;
197          case SYNCHRONIZED:
198            jj_consume_token(SYNCHRONIZED);
199            break;
200          case FINAL:
201            jj_consume_token(FINAL);
202            break;
203          case NATIVE:
204            jj_consume_token(NATIVE);
205            break;
206          case TRANSIENT:
207            jj_consume_token(TRANSIENT);
208            break;
209          case VOLATILE:
210            jj_consume_token(VOLATILE);
211            break;
212          case ABSTRACT:
213            jj_consume_token(ABSTRACT);
214            break;
215          case STATIC:
216            jj_consume_token(STATIC);
217            break;
218          case STRICTFP:
219            jj_consume_token(STRICTFP);
220            break;
221          default:
222            jj_consume_token(-1);
223            throw new ParseException();
224          }
225                    if ( !lookahead )
226                            try {
227                                    if ( mods == null ) mods = new Modifiers();
228                                    mods.addModifier( context, getToken(0).image );
229                            } catch ( IllegalStateException e ) {
230                                    {if (true) throw createParseException( e.getMessage() );}
231                            }
232        }
233            {if (true) return mods;}
234        throw new Error("Missing return statement in function");
235      }
236    
237    /**
238    */
239      final public void ClassDeclaration() throws ParseException {
240     /*@bgen(jjtree) ClassDeclaration */
241            BSHClassDeclaration jjtn000 = new BSHClassDeclaration(JJTCLASSDECLARATION);
242            boolean jjtc000 = true;
243            jjtree.openNodeScope(jjtn000);
244            jjtreeOpenNodeScope(jjtn000);Modifiers mods;
245            Token name;
246            int numInterfaces;
247        try {
248          mods = Modifiers(Modifiers.CLASS, false);
249          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
250          case CLASS:
251            jj_consume_token(CLASS);
252            break;
253          case INTERFACE:
254            jj_consume_token(INTERFACE);
255                                      jjtn000.isInterface=true;
256            break;
257          default:
258            jj_consume_token(-1);
259            throw new ParseException();
260          }
261          name = jj_consume_token(IDENTIFIER);
262          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
263          case EXTENDS:
264            jj_consume_token(EXTENDS);
265            AmbiguousName();
266                                          jjtn000.extend = true;
267            break;
268          default:
269            ;
270          }
271          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
272          case IMPLEMENTS:
273            jj_consume_token(IMPLEMENTS);
274            numInterfaces = NameList();
275                      jjtn000.numInterfaces=numInterfaces;
276            break;
277          default:
278            ;
279          }
280          Block();
281              jjtree.closeNodeScope(jjtn000, true);
282              jjtc000 = false;
283              jjtreeCloseNodeScope(jjtn000);
284                    jjtn000.modifiers = mods;
285                    jjtn000.name = name.image;
286        } catch (Throwable jjte000) {
287              if (jjtc000) {
288                jjtree.clearNodeScope(jjtn000);
289                jjtc000 = false;
290              } else {
291                jjtree.popNode();
292              }
293              if (jjte000 instanceof RuntimeException) {
294                {if (true) throw (RuntimeException)jjte000;}
295              }
296              if (jjte000 instanceof ParseException) {
297                {if (true) throw (ParseException)jjte000;}
298              }
299              {if (true) throw (Error)jjte000;}
300        } finally {
301              if (jjtc000) {
302                jjtree.closeNodeScope(jjtn000, true);
303                jjtreeCloseNodeScope(jjtn000);
304              }
305        }
306      }
307    
308      final public void MethodDeclaration() throws ParseException {
309     /*@bgen(jjtree) MethodDeclaration */
310            BSHMethodDeclaration jjtn000 = new BSHMethodDeclaration(JJTMETHODDECLARATION);
311            boolean jjtc000 = true;
312            jjtree.openNodeScope(jjtn000);
313            jjtreeOpenNodeScope(jjtn000);Token t = null;
314            Modifiers mods;
315            int count;
316        try {
317          mods = Modifiers(Modifiers.METHOD, false);
318                                                          jjtn000.modifiers = mods;
319          if (jj_2_2(2147483647)) {
320            t = jj_consume_token(IDENTIFIER);
321                               jjtn000.name = t.image;
322          } else {
323            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
324            case BOOLEAN:
325            case BYTE:
326            case CHAR:
327            case DOUBLE:
328            case FLOAT:
329            case INT:
330            case LONG:
331            case SHORT:
332            case VOID:
333            case IDENTIFIER:
334              ReturnType();
335              t = jj_consume_token(IDENTIFIER);
336                               jjtn000.name = t.image;
337              break;
338            default:
339              jj_consume_token(-1);
340              throw new ParseException();
341            }
342          }
343          FormalParameters();
344          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
345          case THROWS:
346            jj_consume_token(THROWS);
347            count = NameList();
348                                          jjtn000.numThrows=count;
349            break;
350          default:
351            ;
352          }
353          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
354          case LBRACE:
355            Block();
356            break;
357          case SEMICOLON:
358            jj_consume_token(SEMICOLON);
359            break;
360          default:
361            jj_consume_token(-1);
362            throw new ParseException();
363          }
364        } catch (Throwable jjte000) {
365              if (jjtc000) {
366                jjtree.clearNodeScope(jjtn000);
367                jjtc000 = false;
368              } else {
369                jjtree.popNode();
370              }
371              if (jjte000 instanceof RuntimeException) {
372                {if (true) throw (RuntimeException)jjte000;}
373              }
374              if (jjte000 instanceof ParseException) {
375                {if (true) throw (ParseException)jjte000;}
376              }
377              {if (true) throw (Error)jjte000;}
378        } finally {
379              if (jjtc000) {
380                jjtree.closeNodeScope(jjtn000, true);
381                jjtreeCloseNodeScope(jjtn000);
382              }
383        }
384      }
385    
386      final public void PackageDeclaration() throws ParseException {
387     /*@bgen(jjtree) PackageDeclaration */
388      BSHPackageDeclaration jjtn000 = new BSHPackageDeclaration(JJTPACKAGEDECLARATION);
389      boolean jjtc000 = true;
390      jjtree.openNodeScope(jjtn000);
391      jjtreeOpenNodeScope(jjtn000);
392        try {
393          jj_consume_token(PACKAGE);
394          AmbiguousName();
395        } catch (Throwable jjte000) {
396              if (jjtc000) {
397                jjtree.clearNodeScope(jjtn000);
398                jjtc000 = false;
399              } else {
400                jjtree.popNode();
401              }
402              if (jjte000 instanceof RuntimeException) {
403                {if (true) throw (RuntimeException)jjte000;}
404              }
405              if (jjte000 instanceof ParseException) {
406                {if (true) throw (ParseException)jjte000;}
407              }
408              {if (true) throw (Error)jjte000;}
409        } finally {
410              if (jjtc000) {
411                jjtree.closeNodeScope(jjtn000, true);
412                jjtreeCloseNodeScope(jjtn000);
413              }
414        }
415      }
416    
417      final public void ImportDeclaration() throws ParseException {
418     /*@bgen(jjtree) ImportDeclaration */
419        BSHImportDeclaration jjtn000 = new BSHImportDeclaration(JJTIMPORTDECLARATION);
420        boolean jjtc000 = true;
421        jjtree.openNodeScope(jjtn000);
422        jjtreeOpenNodeScope(jjtn000);Token s = null;
423            Token t = null;
424        try {
425          if (jj_2_3(3)) {
426            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
427            case STATIC:
428              s = jj_consume_token(STATIC);
429              break;
430            default:
431              ;
432            }
433            jj_consume_token(IMPORT);
434            AmbiguousName();
435            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
436            case DOT:
437              t = jj_consume_token(DOT);
438              jj_consume_token(STAR);
439              break;
440            default:
441              ;
442            }
443            jj_consume_token(SEMICOLON);
444        jjtree.closeNodeScope(jjtn000, true);
445        jjtc000 = false;
446        jjtreeCloseNodeScope(jjtn000);
447                    if ( s != null ) jjtn000.staticImport = true;
448                    if ( t != null ) jjtn000.importPackage = true;
449          } else {
450            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
451            case IMPORT:
452              jj_consume_token(IMPORT);
453              jj_consume_token(STAR);
454              jj_consume_token(SEMICOLON);
455                         jjtree.closeNodeScope(jjtn000, true);
456                         jjtc000 = false;
457                         jjtreeCloseNodeScope(jjtn000);
458                    jjtn000.superImport = true;
459              break;
460            default:
461              jj_consume_token(-1);
462              throw new ParseException();
463            }
464          }
465        } catch (Throwable jjte000) {
466        if (jjtc000) {
467          jjtree.clearNodeScope(jjtn000);
468          jjtc000 = false;
469        } else {
470          jjtree.popNode();
471        }
472        if (jjte000 instanceof RuntimeException) {
473          {if (true) throw (RuntimeException)jjte000;}
474        }
475        if (jjte000 instanceof ParseException) {
476          {if (true) throw (ParseException)jjte000;}
477        }
478        {if (true) throw (Error)jjte000;}
479        } finally {
480        if (jjtc000) {
481          jjtree.closeNodeScope(jjtn000, true);
482          jjtreeCloseNodeScope(jjtn000);
483        }
484        }
485      }
486    
487      final public void VariableDeclarator() throws ParseException {
488     /*@bgen(jjtree) VariableDeclarator */
489            BSHVariableDeclarator jjtn000 = new BSHVariableDeclarator(JJTVARIABLEDECLARATOR);
490            boolean jjtc000 = true;
491            jjtree.openNodeScope(jjtn000);
492            jjtreeOpenNodeScope(jjtn000);Token t;
493        try {
494          t = jj_consume_token(IDENTIFIER);
495          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
496          case ASSIGN:
497            jj_consume_token(ASSIGN);
498            VariableInitializer();
499            break;
500          default:
501            ;
502          }
503              jjtree.closeNodeScope(jjtn000, true);
504              jjtc000 = false;
505              jjtreeCloseNodeScope(jjtn000);
506                    jjtn000.name = t.image;
507        } catch (Throwable jjte000) {
508              if (jjtc000) {
509                jjtree.clearNodeScope(jjtn000);
510                jjtc000 = false;
511              } else {
512                jjtree.popNode();
513              }
514              if (jjte000 instanceof RuntimeException) {
515                {if (true) throw (RuntimeException)jjte000;}
516              }
517              if (jjte000 instanceof ParseException) {
518                {if (true) throw (ParseException)jjte000;}
519              }
520              {if (true) throw (Error)jjte000;}
521        } finally {
522              if (jjtc000) {
523                jjtree.closeNodeScope(jjtn000, true);
524                jjtreeCloseNodeScope(jjtn000);
525              }
526        }
527      }
528    
529    /*
530    this originally handled postfix array dimensions...
531    
532    void VariableDeclaratorId() #VariableDeclaratorId :
533    { Token t; }
534    {
535      t=<IDENTIFIER> { jjtThis.name = t.image; }
536      ( "[" "]" { jjtThis.addUndefinedDimension(); } )*
537    }
538    */
539      final public void VariableInitializer() throws ParseException {
540        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
541        case LBRACE:
542          ArrayInitializer();
543          break;
544        case BOOLEAN:
545        case BYTE:
546        case CHAR:
547        case DOUBLE:
548        case FALSE:
549        case FLOAT:
550        case INT:
551        case LONG:
552        case NEW:
553        case NULL:
554        case SHORT:
555        case TRUE:
556        case VOID:
557        case INTEGER_LITERAL:
558        case FLOATING_POINT_LITERAL:
559        case CHARACTER_LITERAL:
560        case STRING_LITERAL:
561        case IDENTIFIER:
562        case LPAREN:
563        case BANG:
564        case TILDE:
565        case INCR:
566        case DECR:
567        case PLUS:
568        case MINUS:
569          Expression();
570          break;
571        default:
572          jj_consume_token(-1);
573          throw new ParseException();
574        }
575      }
576    
577      final public void ArrayInitializer() throws ParseException {
578     /*@bgen(jjtree) ArrayInitializer */
579      BSHArrayInitializer jjtn000 = new BSHArrayInitializer(JJTARRAYINITIALIZER);
580      boolean jjtc000 = true;
581      jjtree.openNodeScope(jjtn000);
582      jjtreeOpenNodeScope(jjtn000);
583        try {
584          jj_consume_token(LBRACE);
585          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
586          case BOOLEAN:
587          case BYTE:
588          case CHAR:
589          case DOUBLE:
590          case FALSE:
591          case FLOAT:
592          case INT:
593          case LONG:
594          case NEW:
595          case NULL:
596          case SHORT:
597          case TRUE:
598          case VOID:
599          case INTEGER_LITERAL:
600          case FLOATING_POINT_LITERAL:
601          case CHARACTER_LITERAL:
602          case STRING_LITERAL:
603          case IDENTIFIER:
604          case LPAREN:
605          case LBRACE:
606          case BANG:
607          case TILDE:
608          case INCR:
609          case DECR:
610          case PLUS:
611          case MINUS:
612            VariableInitializer();
613            label_2:
614            while (true) {
615              if (jj_2_4(2)) {
616                ;
617              } else {
618                break label_2;
619              }
620              jj_consume_token(COMMA);
621              VariableInitializer();
622            }
623            break;
624          default:
625            ;
626          }
627          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
628          case COMMA:
629            jj_consume_token(COMMA);
630            break;
631          default:
632            ;
633          }
634          jj_consume_token(RBRACE);
635        } catch (Throwable jjte000) {
636        if (jjtc000) {
637          jjtree.clearNodeScope(jjtn000);
638          jjtc000 = false;
639        } else {
640          jjtree.popNode();
641        }
642        if (jjte000 instanceof RuntimeException) {
643          {if (true) throw (RuntimeException)jjte000;}
644        }
645        if (jjte000 instanceof ParseException) {
646          {if (true) throw (ParseException)jjte000;}
647        }
648        {if (true) throw (Error)jjte000;}
649        } finally {
650        if (jjtc000) {
651          jjtree.closeNodeScope(jjtn000, true);
652          jjtreeCloseNodeScope(jjtn000);
653        }
654        }
655      }
656    
657      final public void FormalParameters() throws ParseException {
658     /*@bgen(jjtree) FormalParameters */
659      BSHFormalParameters jjtn000 = new BSHFormalParameters(JJTFORMALPARAMETERS);
660      boolean jjtc000 = true;
661      jjtree.openNodeScope(jjtn000);
662      jjtreeOpenNodeScope(jjtn000);
663        try {
664          jj_consume_token(LPAREN);
665          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
666          case BOOLEAN:
667          case BYTE:
668          case CHAR:
669          case DOUBLE:
670          case FLOAT:
671          case INT:
672          case LONG:
673          case SHORT:
674          case IDENTIFIER:
675            FormalParameter();
676            label_3:
677            while (true) {
678              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
679              case COMMA:
680                ;
681                break;
682              default:
683                break label_3;
684              }
685              jj_consume_token(COMMA);
686              FormalParameter();
687            }
688            break;
689          default:
690            ;
691          }
692          jj_consume_token(RPAREN);
693        } catch (Throwable jjte000) {
694        if (jjtc000) {
695          jjtree.clearNodeScope(jjtn000);
696          jjtc000 = false;
697        } else {
698          jjtree.popNode();
699        }
700        if (jjte000 instanceof RuntimeException) {
701          {if (true) throw (RuntimeException)jjte000;}
702        }
703        if (jjte000 instanceof ParseException) {
704          {if (true) throw (ParseException)jjte000;}
705        }
706        {if (true) throw (Error)jjte000;}
707        } finally {
708        if (jjtc000) {
709          jjtree.closeNodeScope(jjtn000, true);
710          jjtreeCloseNodeScope(jjtn000);
711        }
712        }
713      }
714    
715      final public void FormalParameter() throws ParseException {
716     /*@bgen(jjtree) FormalParameter */
717      BSHFormalParameter jjtn000 = new BSHFormalParameter(JJTFORMALPARAMETER);
718      boolean jjtc000 = true;
719      jjtree.openNodeScope(jjtn000);
720      jjtreeOpenNodeScope(jjtn000);Token t;
721        try {
722          if (jj_2_5(2)) {
723            Type();
724            t = jj_consume_token(IDENTIFIER);
725                                           jjtree.closeNodeScope(jjtn000, true);
726                                           jjtc000 = false;
727                                           jjtreeCloseNodeScope(jjtn000);
728                                           jjtn000.name = t.image;
729          } else {
730            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
731            case IDENTIFIER:
732              t = jj_consume_token(IDENTIFIER);
733                       jjtree.closeNodeScope(jjtn000, true);
734                       jjtc000 = false;
735                       jjtreeCloseNodeScope(jjtn000);
736                       jjtn000.name = t.image;
737              break;
738            default:
739              jj_consume_token(-1);
740              throw new ParseException();
741            }
742          }
743        } catch (Throwable jjte000) {
744        if (jjtc000) {
745          jjtree.clearNodeScope(jjtn000);
746          jjtc000 = false;
747        } else {
748          jjtree.popNode();
749        }
750        if (jjte000 instanceof RuntimeException) {
751          {if (true) throw (RuntimeException)jjte000;}
752        }
753        if (jjte000 instanceof ParseException) {
754          {if (true) throw (ParseException)jjte000;}
755        }
756        {if (true) throw (Error)jjte000;}
757        } finally {
758        if (jjtc000) {
759          jjtree.closeNodeScope(jjtn000, true);
760          jjtreeCloseNodeScope(jjtn000);
761        }
762        }
763      }
764    
765    /*
766            Type, name and expression syntax follows.
767    */
768      final public void Type() throws ParseException {
769     /*@bgen(jjtree) Type */
770      BSHType jjtn000 = new BSHType(JJTTYPE);
771      boolean jjtc000 = true;
772      jjtree.openNodeScope(jjtn000);
773      jjtreeOpenNodeScope(jjtn000);
774        try {
775          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
776          case BOOLEAN:
777          case BYTE:
778          case CHAR:
779          case DOUBLE:
780          case FLOAT:
781          case INT:
782          case LONG:
783          case SHORT:
784            PrimitiveType();
785            break;
786          case IDENTIFIER:
787            AmbiguousName();
788            break;
789          default:
790            jj_consume_token(-1);
791            throw new ParseException();
792          }
793          label_4:
794          while (true) {
795            if (jj_2_6(2)) {
796              ;
797            } else {
798              break label_4;
799            }
800            jj_consume_token(LBRACKET);
801            jj_consume_token(RBRACKET);
802                                     jjtn000.addArrayDimension();
803          }
804        } catch (Throwable jjte000) {
805        if (jjtc000) {
806          jjtree.clearNodeScope(jjtn000);
807          jjtc000 = false;
808        } else {
809          jjtree.popNode();
810        }
811        if (jjte000 instanceof RuntimeException) {
812          {if (true) throw (RuntimeException)jjte000;}
813        }
814        if (jjte000 instanceof ParseException) {
815          {if (true) throw (ParseException)jjte000;}
816        }
817        {if (true) throw (Error)jjte000;}
818        } finally {
819        if (jjtc000) {
820          jjtree.closeNodeScope(jjtn000, true);
821          jjtreeCloseNodeScope(jjtn000);
822        }
823        }
824      }
825    
826    /*
827            Originally called ResultType in the grammar
828    */
829      final public void ReturnType() throws ParseException {
830     /*@bgen(jjtree) ReturnType */
831      BSHReturnType jjtn000 = new BSHReturnType(JJTRETURNTYPE);
832      boolean jjtc000 = true;
833      jjtree.openNodeScope(jjtn000);
834      jjtreeOpenNodeScope(jjtn000);
835        try {
836          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
837          case VOID:
838            jj_consume_token(VOID);
839               jjtree.closeNodeScope(jjtn000, true);
840               jjtc000 = false;
841               jjtreeCloseNodeScope(jjtn000);
842               jjtn000.isVoid = true;
843            break;
844          case BOOLEAN:
845          case BYTE:
846          case CHAR:
847          case DOUBLE:
848          case FLOAT:
849          case INT:
850          case LONG:
851          case SHORT:
852          case IDENTIFIER:
853            Type();
854            break;
855          default:
856            jj_consume_token(-1);
857            throw new ParseException();
858          }
859        } catch (Throwable jjte000) {
860        if (jjtc000) {
861          jjtree.clearNodeScope(jjtn000);
862          jjtc000 = false;
863        } else {
864          jjtree.popNode();
865        }
866        if (jjte000 instanceof RuntimeException) {
867          {if (true) throw (RuntimeException)jjte000;}
868        }
869        if (jjte000 instanceof ParseException) {
870          {if (true) throw (ParseException)jjte000;}
871        }
872        {if (true) throw (Error)jjte000;}
873        } finally {
874        if (jjtc000) {
875          jjtree.closeNodeScope(jjtn000, true);
876          jjtreeCloseNodeScope(jjtn000);
877        }
878        }
879      }
880    
881      final public void PrimitiveType() throws ParseException {
882     /*@bgen(jjtree) PrimitiveType */
883      BSHPrimitiveType jjtn000 = new BSHPrimitiveType(JJTPRIMITIVETYPE);
884      boolean jjtc000 = true;
885      jjtree.openNodeScope(jjtn000);
886      jjtreeOpenNodeScope(jjtn000);
887        try {
888          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
889          case BOOLEAN:
890            jj_consume_token(BOOLEAN);
891                  jjtree.closeNodeScope(jjtn000, true);
892                  jjtc000 = false;
893                  jjtreeCloseNodeScope(jjtn000);
894                  jjtn000.type = Boolean.TYPE;
895            break;
896          case CHAR:
897            jj_consume_token(CHAR);
898               jjtree.closeNodeScope(jjtn000, true);
899               jjtc000 = false;
900               jjtreeCloseNodeScope(jjtn000);
901               jjtn000.type =  Character.TYPE;
902            break;
903          case BYTE:
904            jj_consume_token(BYTE);
905               jjtree.closeNodeScope(jjtn000, true);
906               jjtc000 = false;
907               jjtreeCloseNodeScope(jjtn000);
908               jjtn000.type =  Byte.TYPE;
909            break;
910          case SHORT:
911            jj_consume_token(SHORT);
912                jjtree.closeNodeScope(jjtn000, true);
913                jjtc000 = false;
914                jjtreeCloseNodeScope(jjtn000);
915                jjtn000.type =  Short.TYPE;
916            break;
917          case INT:
918            jj_consume_token(INT);
919              jjtree.closeNodeScope(jjtn000, true);
920              jjtc000 = false;
921              jjtreeCloseNodeScope(jjtn000);
922              jjtn000.type =  Integer.TYPE;
923            break;
924          case LONG:
925            jj_consume_token(LONG);
926               jjtree.closeNodeScope(jjtn000, true);
927               jjtc000 = false;
928               jjtreeCloseNodeScope(jjtn000);
929               jjtn000.type =  Long.TYPE;
930            break;
931          case FLOAT:
932            jj_consume_token(FLOAT);
933                jjtree.closeNodeScope(jjtn000, true);
934                jjtc000 = false;
935                jjtreeCloseNodeScope(jjtn000);
936                jjtn000.type =  Float.TYPE;
937            break;
938          case DOUBLE:
939            jj_consume_token(DOUBLE);
940                 jjtree.closeNodeScope(jjtn000, true);
941                 jjtc000 = false;
942                 jjtreeCloseNodeScope(jjtn000);
943                 jjtn000.type =  Double.TYPE;
944            break;
945          default:
946            jj_consume_token(-1);
947            throw new ParseException();
948          }
949        } finally {
950        if (jjtc000) {
951          jjtree.closeNodeScope(jjtn000, true);
952          jjtreeCloseNodeScope(jjtn000);
953        }
954        }
955      }
956    
957      final public void AmbiguousName() throws ParseException {
958     /*@bgen(jjtree) AmbiguousName */
959        BSHAmbiguousName jjtn000 = new BSHAmbiguousName(JJTAMBIGUOUSNAME);
960        boolean jjtc000 = true;
961        jjtree.openNodeScope(jjtn000);
962        jjtreeOpenNodeScope(jjtn000);Token t;
963        StringBuffer s;
964        try {
965          t = jj_consume_token(IDENTIFIER);
966            s = new StringBuffer(t.image);
967          label_5:
968          while (true) {
969            if (jj_2_7(2)) {
970              ;
971            } else {
972              break label_5;
973            }
974            jj_consume_token(DOT);
975            t = jj_consume_token(IDENTIFIER);
976                                            s.append("."+t.image);
977          }
978                                                                          jjtree.closeNodeScope(jjtn000, true);
979                                                                          jjtc000 = false;
980                                                                          jjtreeCloseNodeScope(jjtn000);
981            jjtn000.text = s.toString();
982        } finally {
983        if (jjtc000) {
984          jjtree.closeNodeScope(jjtn000, true);
985          jjtreeCloseNodeScope(jjtn000);
986        }
987        }
988      }
989    
990      final public int NameList() throws ParseException {
991      int count = 0;
992        AmbiguousName();
993                        ++count;
994        label_6:
995        while (true) {
996          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
997          case COMMA:
998            ;
999            break;
1000          default:
1001            break label_6;
1002          }
1003          jj_consume_token(COMMA);
1004          AmbiguousName();
1005                                                           ++count;
1006        }
1007        {if (true) return count;}
1008        throw new Error("Missing return statement in function");
1009      }
1010    
1011    /*
1012     * Expression syntax follows.
1013     */
1014      final public void Expression() throws ParseException {
1015        if (jj_2_8(2147483647)) {
1016          Assignment();
1017        } else {
1018          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1019          case BOOLEAN:
1020          case BYTE:
1021          case CHAR:
1022          case DOUBLE:
1023          case FALSE:
1024          case FLOAT:
1025          case INT:
1026          case LONG:
1027          case NEW:
1028          case NULL:
1029          case SHORT:
1030          case TRUE:
1031          case VOID:
1032          case INTEGER_LITERAL:
1033          case FLOATING_POINT_LITERAL:
1034          case CHARACTER_LITERAL:
1035          case STRING_LITERAL:
1036          case IDENTIFIER:
1037          case LPAREN:
1038          case BANG:
1039          case TILDE:
1040          case INCR:
1041          case DECR:
1042          case PLUS:
1043          case MINUS:
1044            ConditionalExpression();
1045            break;
1046          default:
1047            jj_consume_token(-1);
1048            throw new ParseException();
1049          }
1050        }
1051      }
1052    
1053      final public void Assignment() throws ParseException {
1054     /*@bgen(jjtree) Assignment */
1055      BSHAssignment jjtn000 = new BSHAssignment(JJTASSIGNMENT);
1056      boolean jjtc000 = true;
1057      jjtree.openNodeScope(jjtn000);
1058      jjtreeOpenNodeScope(jjtn000);int op ;
1059        try {
1060          PrimaryExpression();
1061          op = AssignmentOperator();
1062                                        jjtn000.operator = op;
1063          Expression();
1064        } catch (Throwable jjte000) {
1065        if (jjtc000) {
1066          jjtree.clearNodeScope(jjtn000);
1067          jjtc000 = false;
1068        } else {
1069          jjtree.popNode();
1070        }
1071        if (jjte000 instanceof RuntimeException) {
1072          {if (true) throw (RuntimeException)jjte000;}
1073        }
1074        if (jjte000 instanceof ParseException) {
1075          {if (true) throw (ParseException)jjte000;}
1076        }
1077        {if (true) throw (Error)jjte000;}
1078        } finally {
1079        if (jjtc000) {
1080          jjtree.closeNodeScope(jjtn000, true);
1081          jjtreeCloseNodeScope(jjtn000);
1082        }
1083        }
1084      }
1085    
1086      final public int AssignmentOperator() throws ParseException {
1087      Token t;
1088        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1089        case ASSIGN:
1090          jj_consume_token(ASSIGN);
1091          break;
1092        case STARASSIGN:
1093          jj_consume_token(STARASSIGN);
1094          break;
1095        case SLASHASSIGN:
1096          jj_consume_token(SLASHASSIGN);
1097          break;
1098        case MODASSIGN:
1099          jj_consume_token(MODASSIGN);
1100          break;
1101        case PLUSASSIGN:
1102          jj_consume_token(PLUSASSIGN);
1103          break;
1104        case MINUSASSIGN:
1105          jj_consume_token(MINUSASSIGN);
1106          break;
1107        case ANDASSIGN:
1108          jj_consume_token(ANDASSIGN);
1109          break;
1110        case XORASSIGN:
1111          jj_consume_token(XORASSIGN);
1112          break;
1113        case ORASSIGN:
1114          jj_consume_token(ORASSIGN);
1115          break;
1116        case LSHIFTASSIGN:
1117          jj_consume_token(LSHIFTASSIGN);
1118          break;
1119        case LSHIFTASSIGNX:
1120          jj_consume_token(LSHIFTASSIGNX);
1121          break;
1122        case RSIGNEDSHIFTASSIGN:
1123          jj_consume_token(RSIGNEDSHIFTASSIGN);
1124          break;
1125        case RSIGNEDSHIFTASSIGNX:
1126          jj_consume_token(RSIGNEDSHIFTASSIGNX);
1127          break;
1128        case RUNSIGNEDSHIFTASSIGN:
1129          jj_consume_token(RUNSIGNEDSHIFTASSIGN);
1130          break;
1131        case RUNSIGNEDSHIFTASSIGNX:
1132          jj_consume_token(RUNSIGNEDSHIFTASSIGNX);
1133          break;
1134        default:
1135          jj_consume_token(-1);
1136          throw new ParseException();
1137        }
1138            t = getToken(0);
1139            {if (true) return t.kind;}
1140        throw new Error("Missing return statement in function");
1141      }
1142    
1143      final public void ConditionalExpression() throws ParseException {
1144        ConditionalOrExpression();
1145        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1146        case HOOK:
1147          jj_consume_token(HOOK);
1148          Expression();
1149          jj_consume_token(COLON);
1150                                                         BSHTernaryExpression jjtn001 = new BSHTernaryExpression(JJTTERNARYEXPRESSION);
1151                                                         boolean jjtc001 = true;
1152                                                         jjtree.openNodeScope(jjtn001);
1153                                                         jjtreeOpenNodeScope(jjtn001);
1154          try {
1155            ConditionalExpression();
1156          } catch (Throwable jjte001) {
1157                                                         if (jjtc001) {
1158                                                           jjtree.clearNodeScope(jjtn001);
1159                                                           jjtc001 = false;
1160                                                         } else {
1161                                                           jjtree.popNode();
1162                                                         }
1163                                                         if (jjte001 instanceof RuntimeException) {
1164                                                           {if (true) throw (RuntimeException)jjte001;}
1165                                                         }
1166                                                         if (jjte001 instanceof ParseException) {
1167                                                           {if (true) throw (ParseException)jjte001;}
1168                                                         }
1169                                                         {if (true) throw (Error)jjte001;}
1170          } finally {
1171                                                         if (jjtc001) {
1172                                                           jjtree.closeNodeScope(jjtn001,  3);
1173                                                           jjtreeCloseNodeScope(jjtn001);
1174                                                         }
1175          }
1176          break;
1177        default:
1178          ;
1179        }
1180      }
1181    
1182      final public void ConditionalOrExpression() throws ParseException {
1183      Token t=null;
1184        ConditionalAndExpression();
1185        label_7:
1186        while (true) {
1187          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1188          case BOOL_OR:
1189          case BOOL_ORX:
1190            ;
1191            break;
1192          default:
1193            break label_7;
1194          }
1195          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1196          case BOOL_OR:
1197            t = jj_consume_token(BOOL_OR);
1198            break;
1199          case BOOL_ORX:
1200            t = jj_consume_token(BOOL_ORX);
1201            break;
1202          default:
1203            jj_consume_token(-1);
1204            throw new ParseException();
1205          }
1206          ConditionalAndExpression();
1207          BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1208          boolean jjtc001 = true;
1209          jjtree.openNodeScope(jjtn001);
1210          jjtreeOpenNodeScope(jjtn001);
1211          try {
1212          jjtree.closeNodeScope(jjtn001,  2);
1213          jjtc001 = false;
1214          jjtreeCloseNodeScope(jjtn001);
1215          jjtn001.kind = t.kind;
1216          } finally {
1217          if (jjtc001) {
1218            jjtree.closeNodeScope(jjtn001,  2);
1219            jjtreeCloseNodeScope(jjtn001);
1220          }
1221          }
1222        }
1223      }
1224    
1225      final public void ConditionalAndExpression() throws ParseException {
1226      Token t=null;
1227        InclusiveOrExpression();
1228        label_8:
1229        while (true) {
1230          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1231          case BOOL_AND:
1232          case BOOL_ANDX:
1233            ;
1234            break;
1235          default:
1236            break label_8;
1237          }
1238          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1239          case BOOL_AND:
1240            t = jj_consume_token(BOOL_AND);
1241            break;
1242          case BOOL_ANDX:
1243            t = jj_consume_token(BOOL_ANDX);
1244            break;
1245          default:
1246            jj_consume_token(-1);
1247            throw new ParseException();
1248          }
1249          InclusiveOrExpression();
1250          BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1251          boolean jjtc001 = true;
1252          jjtree.openNodeScope(jjtn001);
1253          jjtreeOpenNodeScope(jjtn001);
1254          try {
1255          jjtree.closeNodeScope(jjtn001,  2);
1256          jjtc001 = false;
1257          jjtreeCloseNodeScope(jjtn001);
1258          jjtn001.kind = t.kind;
1259          } finally {
1260          if (jjtc001) {
1261            jjtree.closeNodeScope(jjtn001,  2);
1262            jjtreeCloseNodeScope(jjtn001);
1263          }
1264          }
1265        }
1266      }
1267    
1268      final public void InclusiveOrExpression() throws ParseException {
1269      Token t=null;
1270        ExclusiveOrExpression();
1271        label_9:
1272        while (true) {
1273          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1274          case BIT_OR:
1275          case BIT_ORX:
1276            ;
1277            break;
1278          default:
1279            break label_9;
1280          }
1281          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1282          case BIT_OR:
1283            t = jj_consume_token(BIT_OR);
1284            break;
1285          case BIT_ORX:
1286            t = jj_consume_token(BIT_ORX);
1287            break;
1288          default:
1289            jj_consume_token(-1);
1290            throw new ParseException();
1291          }
1292          ExclusiveOrExpression();
1293          BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1294          boolean jjtc001 = true;
1295          jjtree.openNodeScope(jjtn001);
1296          jjtreeOpenNodeScope(jjtn001);
1297          try {
1298          jjtree.closeNodeScope(jjtn001,  2);
1299          jjtc001 = false;
1300          jjtreeCloseNodeScope(jjtn001);
1301          jjtn001.kind = t.kind;
1302          } finally {
1303          if (jjtc001) {
1304            jjtree.closeNodeScope(jjtn001,  2);
1305            jjtreeCloseNodeScope(jjtn001);
1306          }
1307          }
1308        }
1309      }
1310    
1311      final public void ExclusiveOrExpression() throws ParseException {
1312      Token t=null;
1313        AndExpression();
1314        label_10:
1315        while (true) {
1316          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1317          case XOR:
1318            ;
1319            break;
1320          default:
1321            break label_10;
1322          }
1323          t = jj_consume_token(XOR);
1324          AndExpression();
1325          BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1326          boolean jjtc001 = true;
1327          jjtree.openNodeScope(jjtn001);
1328          jjtreeOpenNodeScope(jjtn001);
1329          try {
1330          jjtree.closeNodeScope(jjtn001,  2);
1331          jjtc001 = false;
1332          jjtreeCloseNodeScope(jjtn001);
1333          jjtn001.kind = t.kind;
1334          } finally {
1335          if (jjtc001) {
1336            jjtree.closeNodeScope(jjtn001,  2);
1337            jjtreeCloseNodeScope(jjtn001);
1338          }
1339          }
1340        }
1341      }
1342    
1343      final public void AndExpression() throws ParseException {
1344      Token t=null;
1345        EqualityExpression();
1346        label_11:
1347        while (true) {
1348          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1349          case BIT_AND:
1350          case BIT_ANDX:
1351            ;
1352            break;
1353          default:
1354            break label_11;
1355          }
1356          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1357          case BIT_AND:
1358            t = jj_consume_token(BIT_AND);
1359            break;
1360          case BIT_ANDX:
1361            t = jj_consume_token(BIT_ANDX);
1362            break;
1363          default:
1364            jj_consume_token(-1);
1365            throw new ParseException();
1366          }
1367          EqualityExpression();
1368          BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1369          boolean jjtc001 = true;
1370          jjtree.openNodeScope(jjtn001);
1371          jjtreeOpenNodeScope(jjtn001);
1372          try {
1373          jjtree.closeNodeScope(jjtn001,  2);
1374          jjtc001 = false;
1375          jjtreeCloseNodeScope(jjtn001);
1376          jjtn001.kind = t.kind;
1377          } finally {
1378          if (jjtc001) {
1379            jjtree.closeNodeScope(jjtn001,  2);
1380            jjtreeCloseNodeScope(jjtn001);
1381          }
1382          }
1383        }
1384      }
1385    
1386      final public void EqualityExpression() throws ParseException {
1387      Token t = null;
1388        InstanceOfExpression();
1389        label_12:
1390        while (true) {
1391          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1392          case EQ:
1393          case NE:
1394            ;
1395            break;
1396          default:
1397            break label_12;
1398          }
1399          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1400          case EQ:
1401            t = jj_consume_token(EQ);
1402            break;
1403          case NE:
1404            t = jj_consume_token(NE);
1405            break;
1406          default:
1407            jj_consume_token(-1);
1408            throw new ParseException();
1409          }
1410          InstanceOfExpression();
1411          BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1412          boolean jjtc001 = true;
1413          jjtree.openNodeScope(jjtn001);
1414          jjtreeOpenNodeScope(jjtn001);
1415          try {
1416          jjtree.closeNodeScope(jjtn001,  2);
1417          jjtc001 = false;
1418          jjtreeCloseNodeScope(jjtn001);
1419          jjtn001.kind = t.kind;
1420          } finally {
1421          if (jjtc001) {
1422            jjtree.closeNodeScope(jjtn001,  2);
1423            jjtreeCloseNodeScope(jjtn001);
1424          }
1425          }
1426        }
1427      }
1428    
1429      final public void InstanceOfExpression() throws ParseException {
1430      Token t = null;
1431        RelationalExpression();
1432        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1433        case INSTANCEOF:
1434          t = jj_consume_token(INSTANCEOF);
1435          Type();
1436                                  BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1437                                  boolean jjtc001 = true;
1438                                  jjtree.openNodeScope(jjtn001);
1439                                  jjtreeOpenNodeScope(jjtn001);
1440          try {
1441                                  jjtree.closeNodeScope(jjtn001,  2);
1442                                  jjtc001 = false;
1443                                  jjtreeCloseNodeScope(jjtn001);
1444                                  jjtn001.kind = t.kind;
1445          } finally {
1446                                  if (jjtc001) {
1447                                    jjtree.closeNodeScope(jjtn001,  2);
1448                                    jjtreeCloseNodeScope(jjtn001);
1449                                  }
1450          }
1451          break;
1452        default:
1453          ;
1454        }
1455      }
1456    
1457      final public void RelationalExpression() throws ParseException {
1458      Token t = null;
1459        ShiftExpression();
1460        label_13:
1461        while (true) {
1462          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1463          case GT:
1464          case GTX:
1465          case LT:
1466          case LTX:
1467          case LE:
1468          case LEX:
1469          case GE:
1470          case GEX:
1471            ;
1472            break;
1473          default:
1474            break label_13;
1475          }
1476          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1477          case LT:
1478            t = jj_consume_token(LT);
1479            break;
1480          case LTX:
1481            t = jj_consume_token(LTX);
1482            break;
1483          case GT:
1484            t = jj_consume_token(GT);
1485            break;
1486          case GTX:
1487            t = jj_consume_token(GTX);
1488            break;
1489          case LE:
1490            t = jj_consume_token(LE);
1491            break;
1492          case LEX:
1493            t = jj_consume_token(LEX);
1494            break;
1495          case GE:
1496            t = jj_consume_token(GE);
1497            break;
1498          case GEX:
1499            t = jj_consume_token(GEX);
1500            break;
1501          default:
1502            jj_consume_token(-1);
1503            throw new ParseException();
1504          }
1505          ShiftExpression();
1506        BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1507        boolean jjtc001 = true;
1508        jjtree.openNodeScope(jjtn001);
1509        jjtreeOpenNodeScope(jjtn001);
1510          try {
1511        jjtree.closeNodeScope(jjtn001,  2);
1512        jjtc001 = false;
1513        jjtreeCloseNodeScope(jjtn001);
1514        jjtn001.kind = t.kind;
1515          } finally {
1516        if (jjtc001) {
1517          jjtree.closeNodeScope(jjtn001,  2);
1518          jjtreeCloseNodeScope(jjtn001);
1519        }
1520          }
1521        }
1522      }
1523    
1524      final public void ShiftExpression() throws ParseException {
1525      Token t = null;
1526        AdditiveExpression();
1527        label_14:
1528        while (true) {
1529          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1530          case LSHIFT:
1531          case LSHIFTX:
1532          case RSIGNEDSHIFT:
1533          case RSIGNEDSHIFTX:
1534          case RUNSIGNEDSHIFT:
1535          case RUNSIGNEDSHIFTX:
1536            ;
1537            break;
1538          default:
1539            break label_14;
1540          }
1541          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1542          case LSHIFT:
1543            t = jj_consume_token(LSHIFT);
1544            break;
1545          case LSHIFTX:
1546            t = jj_consume_token(LSHIFTX);
1547            break;
1548          case RSIGNEDSHIFT:
1549            t = jj_consume_token(RSIGNEDSHIFT);
1550            break;
1551          case RSIGNEDSHIFTX:
1552            t = jj_consume_token(RSIGNEDSHIFTX);
1553            break;
1554          case RUNSIGNEDSHIFT:
1555            t = jj_consume_token(RUNSIGNEDSHIFT);
1556            break;
1557          case RUNSIGNEDSHIFTX:
1558            t = jj_consume_token(RUNSIGNEDSHIFTX);
1559            break;
1560          default:
1561            jj_consume_token(-1);
1562            throw new ParseException();
1563          }
1564          AdditiveExpression();
1565        BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1566        boolean jjtc001 = true;
1567        jjtree.openNodeScope(jjtn001);
1568        jjtreeOpenNodeScope(jjtn001);
1569          try {
1570        jjtree.closeNodeScope(jjtn001,  2);
1571        jjtc001 = false;
1572        jjtreeCloseNodeScope(jjtn001);
1573        jjtn001.kind = t.kind;
1574          } finally {
1575        if (jjtc001) {
1576          jjtree.closeNodeScope(jjtn001,  2);
1577          jjtreeCloseNodeScope(jjtn001);
1578        }
1579          }
1580        }
1581      }
1582    
1583      final public void AdditiveExpression() throws ParseException {
1584      Token t = null;
1585        MultiplicativeExpression();
1586        label_15:
1587        while (true) {
1588          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1589          case PLUS:
1590          case MINUS:
1591            ;
1592            break;
1593          default:
1594            break label_15;
1595          }
1596          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1597          case PLUS:
1598            t = jj_consume_token(PLUS);
1599            break;
1600          case MINUS:
1601            t = jj_consume_token(MINUS);
1602            break;
1603          default:
1604            jj_consume_token(-1);
1605            throw new ParseException();
1606          }
1607          MultiplicativeExpression();
1608                                                         BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1609                                                         boolean jjtc001 = true;
1610                                                         jjtree.openNodeScope(jjtn001);
1611                                                         jjtreeOpenNodeScope(jjtn001);
1612          try {
1613                                                         jjtree.closeNodeScope(jjtn001,  2);
1614                                                         jjtc001 = false;
1615                                                         jjtreeCloseNodeScope(jjtn001);
1616                                                         jjtn001.kind = t.kind;
1617          } finally {
1618                                                         if (jjtc001) {
1619                                                           jjtree.closeNodeScope(jjtn001,  2);
1620                                                           jjtreeCloseNodeScope(jjtn001);
1621                                                         }
1622          }
1623        }
1624      }
1625    
1626      final public void MultiplicativeExpression() throws ParseException {
1627      Token t = null;
1628        UnaryExpression();
1629        label_16:
1630        while (true) {
1631          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1632          case STAR:
1633          case SLASH:
1634          case MOD:
1635            ;
1636            break;
1637          default:
1638            break label_16;
1639          }
1640          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1641          case STAR:
1642            t = jj_consume_token(STAR);
1643            break;
1644          case SLASH:
1645            t = jj_consume_token(SLASH);
1646            break;
1647          case MOD:
1648            t = jj_consume_token(MOD);
1649            break;
1650          default:
1651            jj_consume_token(-1);
1652            throw new ParseException();
1653          }
1654          UnaryExpression();
1655                          BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
1656                          boolean jjtc001 = true;
1657                          jjtree.openNodeScope(jjtn001);
1658                          jjtreeOpenNodeScope(jjtn001);
1659          try {
1660                          jjtree.closeNodeScope(jjtn001,  2);
1661                          jjtc001 = false;
1662                          jjtreeCloseNodeScope(jjtn001);
1663                          jjtn001.kind = t.kind;
1664          } finally {
1665                          if (jjtc001) {
1666                            jjtree.closeNodeScope(jjtn001,  2);
1667                            jjtreeCloseNodeScope(jjtn001);
1668                          }
1669          }
1670        }
1671      }
1672    
1673      final public void UnaryExpression() throws ParseException {
1674      Token t = null;
1675        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1676        case PLUS:
1677        case MINUS:
1678          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1679          case PLUS:
1680            t = jj_consume_token(PLUS);
1681            break;
1682          case MINUS:
1683            t = jj_consume_token(MINUS);
1684            break;
1685          default:
1686            jj_consume_token(-1);
1687            throw new ParseException();
1688          }
1689          UnaryExpression();
1690          BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1691          boolean jjtc001 = true;
1692          jjtree.openNodeScope(jjtn001);
1693          jjtreeOpenNodeScope(jjtn001);
1694          try {
1695          jjtree.closeNodeScope(jjtn001,  1);
1696          jjtc001 = false;
1697          jjtreeCloseNodeScope(jjtn001);
1698          jjtn001.kind = t.kind;
1699          } finally {
1700          if (jjtc001) {
1701            jjtree.closeNodeScope(jjtn001,  1);
1702            jjtreeCloseNodeScope(jjtn001);
1703          }
1704          }
1705          break;
1706        case INCR:
1707          PreIncrementExpression();
1708          break;
1709        case DECR:
1710          PreDecrementExpression();
1711          break;
1712        case BOOLEAN:
1713        case BYTE:
1714        case CHAR:
1715        case DOUBLE:
1716        case FALSE:
1717        case FLOAT:
1718        case INT:
1719        case LONG:
1720        case NEW:
1721        case NULL:
1722        case SHORT:
1723        case TRUE:
1724        case VOID:
1725        case INTEGER_LITERAL:
1726        case FLOATING_POINT_LITERAL:
1727        case CHARACTER_LITERAL:
1728        case STRING_LITERAL:
1729        case IDENTIFIER:
1730        case LPAREN:
1731        case BANG:
1732        case TILDE:
1733          UnaryExpressionNotPlusMinus();
1734          break;
1735        default:
1736          jj_consume_token(-1);
1737          throw new ParseException();
1738        }
1739      }
1740    
1741      final public void PreIncrementExpression() throws ParseException {
1742      Token t = null;
1743        t = jj_consume_token(INCR);
1744        PrimaryExpression();
1745          BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1746          boolean jjtc001 = true;
1747          jjtree.openNodeScope(jjtn001);
1748          jjtreeOpenNodeScope(jjtn001);
1749        try {
1750          jjtree.closeNodeScope(jjtn001,  1);
1751          jjtc001 = false;
1752          jjtreeCloseNodeScope(jjtn001);
1753          jjtn001.kind = t.kind;
1754        } finally {
1755          if (jjtc001) {
1756            jjtree.closeNodeScope(jjtn001,  1);
1757            jjtreeCloseNodeScope(jjtn001);
1758          }
1759        }
1760      }
1761    
1762      final public void PreDecrementExpression() throws ParseException {
1763      Token t = null;
1764        t = jj_consume_token(DECR);
1765        PrimaryExpression();
1766          BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1767          boolean jjtc001 = true;
1768          jjtree.openNodeScope(jjtn001);
1769          jjtreeOpenNodeScope(jjtn001);
1770        try {
1771          jjtree.closeNodeScope(jjtn001,  1);
1772          jjtc001 = false;
1773          jjtreeCloseNodeScope(jjtn001);
1774          jjtn001.kind = t.kind;
1775        } finally {
1776          if (jjtc001) {
1777            jjtree.closeNodeScope(jjtn001,  1);
1778            jjtreeCloseNodeScope(jjtn001);
1779          }
1780        }
1781      }
1782    
1783      final public void UnaryExpressionNotPlusMinus() throws ParseException {
1784      Token t = null;
1785        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1786        case BANG:
1787        case TILDE:
1788          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1789          case TILDE:
1790            t = jj_consume_token(TILDE);
1791            break;
1792          case BANG:
1793            t = jj_consume_token(BANG);
1794            break;
1795          default:
1796            jj_consume_token(-1);
1797            throw new ParseException();
1798          }
1799          UnaryExpression();
1800          BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1801          boolean jjtc001 = true;
1802          jjtree.openNodeScope(jjtn001);
1803          jjtreeOpenNodeScope(jjtn001);
1804          try {
1805          jjtree.closeNodeScope(jjtn001,  1);
1806          jjtc001 = false;
1807          jjtreeCloseNodeScope(jjtn001);
1808          jjtn001.kind = t.kind;
1809          } finally {
1810          if (jjtc001) {
1811            jjtree.closeNodeScope(jjtn001,  1);
1812            jjtreeCloseNodeScope(jjtn001);
1813          }
1814          }
1815          break;
1816        default:
1817          if (jj_2_9(2147483647)) {
1818            CastExpression();
1819          } else {
1820            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1821            case BOOLEAN:
1822            case BYTE:
1823            case CHAR:
1824            case DOUBLE:
1825            case FALSE:
1826            case FLOAT:
1827            case INT:
1828            case LONG:
1829            case NEW:
1830            case NULL:
1831            case SHORT:
1832            case TRUE:
1833            case VOID:
1834            case INTEGER_LITERAL:
1835            case FLOATING_POINT_LITERAL:
1836            case CHARACTER_LITERAL:
1837            case STRING_LITERAL:
1838            case IDENTIFIER:
1839            case LPAREN:
1840              PostfixExpression();
1841              break;
1842            default:
1843              jj_consume_token(-1);
1844              throw new ParseException();
1845            }
1846          }
1847        }
1848      }
1849    
1850    // This production is to determine lookahead only.
1851      final public void CastLookahead() throws ParseException {
1852        if (jj_2_10(2)) {
1853          jj_consume_token(LPAREN);
1854          PrimitiveType();
1855        } else if (jj_2_11(2147483647)) {
1856          jj_consume_token(LPAREN);
1857          AmbiguousName();
1858          jj_consume_token(LBRACKET);
1859          jj_consume_token(RBRACKET);
1860        } else {
1861          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1862          case LPAREN:
1863            jj_consume_token(LPAREN);
1864            AmbiguousName();
1865            jj_consume_token(RPAREN);
1866            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1867            case TILDE:
1868              jj_consume_token(TILDE);
1869              break;
1870            case BANG:
1871              jj_consume_token(BANG);
1872              break;
1873            case LPAREN:
1874              jj_consume_token(LPAREN);
1875              break;
1876            case IDENTIFIER:
1877              jj_consume_token(IDENTIFIER);
1878              break;
1879            case NEW:
1880              jj_consume_token(NEW);
1881              break;
1882            case FALSE:
1883            case NULL:
1884            case TRUE:
1885            case VOID:
1886            case INTEGER_LITERAL:
1887            case FLOATING_POINT_LITERAL:
1888            case CHARACTER_LITERAL:
1889            case STRING_LITERAL:
1890              Literal();
1891              break;
1892            default:
1893              jj_consume_token(-1);
1894              throw new ParseException();
1895            }
1896            break;
1897          default:
1898            jj_consume_token(-1);
1899            throw new ParseException();
1900          }
1901        }
1902      }
1903    
1904      final public void PostfixExpression() throws ParseException {
1905      Token t = null;
1906        if (jj_2_12(2147483647)) {
1907          PrimaryExpression();
1908          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1909          case INCR:
1910            t = jj_consume_token(INCR);
1911            break;
1912          case DECR:
1913            t = jj_consume_token(DECR);
1914            break;
1915          default:
1916            jj_consume_token(-1);
1917            throw new ParseException();
1918          }
1919                                    BSHUnaryExpression jjtn001 = new BSHUnaryExpression(JJTUNARYEXPRESSION);
1920                                    boolean jjtc001 = true;
1921                                    jjtree.openNodeScope(jjtn001);
1922                                    jjtreeOpenNodeScope(jjtn001);
1923          try {
1924                                    jjtree.closeNodeScope(jjtn001,  1);
1925                                    jjtc001 = false;
1926                                    jjtreeCloseNodeScope(jjtn001);
1927                    jjtn001.kind = t.kind; jjtn001.postfix = true;
1928          } finally {
1929                                    if (jjtc001) {
1930                                      jjtree.closeNodeScope(jjtn001,  1);
1931                                      jjtreeCloseNodeScope(jjtn001);
1932                                    }
1933          }
1934        } else {
1935          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1936          case BOOLEAN:
1937          case BYTE:
1938          case CHAR:
1939          case DOUBLE:
1940          case FALSE:
1941          case FLOAT:
1942          case INT:
1943          case LONG:
1944          case NEW:
1945          case NULL:
1946          case SHORT:
1947          case TRUE:
1948          case VOID:
1949          case INTEGER_LITERAL:
1950          case FLOATING_POINT_LITERAL:
1951          case CHARACTER_LITERAL:
1952          case STRING_LITERAL:
1953          case IDENTIFIER:
1954          case LPAREN:
1955            PrimaryExpression();
1956            break;
1957          default:
1958            jj_consume_token(-1);
1959            throw new ParseException();
1960          }
1961        }
1962      }
1963    
1964      final public void CastExpression() throws ParseException {
1965     /*@bgen(jjtree) CastExpression */
1966      BSHCastExpression jjtn000 = new BSHCastExpression(JJTCASTEXPRESSION);
1967      boolean jjtc000 = true;
1968      jjtree.openNodeScope(jjtn000);
1969      jjtreeOpenNodeScope(jjtn000);
1970        try {
1971          if (jj_2_13(2147483647)) {
1972            jj_consume_token(LPAREN);
1973            Type();
1974            jj_consume_token(RPAREN);
1975            UnaryExpression();
1976          } else {
1977            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1978            case LPAREN:
1979              jj_consume_token(LPAREN);
1980              Type();
1981              jj_consume_token(RPAREN);
1982              UnaryExpressionNotPlusMinus();
1983              break;
1984            default:
1985              jj_consume_token(-1);
1986              throw new ParseException();
1987            }
1988          }
1989        } catch (Throwable jjte000) {
1990        if (jjtc000) {
1991          jjtree.clearNodeScope(jjtn000);
1992          jjtc000 = false;
1993        } else {
1994          jjtree.popNode();
1995        }
1996        if (jjte000 instanceof RuntimeException) {
1997          {if (true) throw (RuntimeException)jjte000;}
1998        }
1999        if (jjte000 instanceof ParseException) {
2000          {if (true) throw (ParseException)jjte000;}
2001        }
2002        {if (true) throw (Error)jjte000;}
2003        } finally {
2004        if (jjtc000) {
2005          jjtree.closeNodeScope(jjtn000, true);
2006          jjtreeCloseNodeScope(jjtn000);
2007        }
2008        }
2009      }
2010    
2011      final public void PrimaryExpression() throws ParseException {
2012                                                   /*@bgen(jjtree) PrimaryExpression */
2013      BSHPrimaryExpression jjtn000 = new BSHPrimaryExpression(JJTPRIMARYEXPRESSION);
2014      boolean jjtc000 = true;
2015      jjtree.openNodeScope(jjtn000);
2016      jjtreeOpenNodeScope(jjtn000);
2017        try {
2018          PrimaryPrefix();
2019          label_17:
2020          while (true) {
2021            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2022            case LBRACE:
2023            case LBRACKET:
2024            case DOT:
2025              ;
2026              break;
2027            default:
2028              break label_17;
2029            }
2030            PrimarySuffix();
2031          }
2032        } catch (Throwable jjte000) {
2033        if (jjtc000) {
2034          jjtree.clearNodeScope(jjtn000);
2035          jjtc000 = false;
2036        } else {
2037          jjtree.popNode();
2038        }
2039        if (jjte000 instanceof RuntimeException) {
2040          {if (true) throw (RuntimeException)jjte000;}
2041        }
2042        if (jjte000 instanceof ParseException) {
2043          {if (true) throw (ParseException)jjte000;}
2044        }
2045        {if (true) throw (Error)jjte000;}
2046        } finally {
2047        if (jjtc000) {
2048          jjtree.closeNodeScope(jjtn000, true);
2049          jjtreeCloseNodeScope(jjtn000);
2050        }
2051        }
2052      }
2053    
2054      final public void MethodInvocation() throws ParseException {
2055                                                 /*@bgen(jjtree) MethodInvocation */
2056      BSHMethodInvocation jjtn000 = new BSHMethodInvocation(JJTMETHODINVOCATION);
2057      boolean jjtc000 = true;
2058      jjtree.openNodeScope(jjtn000);
2059      jjtreeOpenNodeScope(jjtn000);
2060        try {
2061          AmbiguousName();
2062          Arguments();
2063        } catch (Throwable jjte000) {
2064         if (jjtc000) {
2065           jjtree.clearNodeScope(jjtn000);
2066           jjtc000 = false;
2067         } else {
2068           jjtree.popNode();
2069         }
2070         if (jjte000 instanceof RuntimeException) {
2071           {if (true) throw (RuntimeException)jjte000;}
2072         }
2073         if (jjte000 instanceof ParseException) {
2074           {if (true) throw (ParseException)jjte000;}
2075         }
2076         {if (true) throw (Error)jjte000;}
2077        } finally {
2078         if (jjtc000) {
2079           jjtree.closeNodeScope(jjtn000, true);
2080           jjtreeCloseNodeScope(jjtn000);
2081         }
2082        }
2083      }
2084    
2085      final public void PrimaryPrefix() throws ParseException {
2086        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2087        case FALSE:
2088        case NULL:
2089        case TRUE:
2090        case VOID:
2091        case INTEGER_LITERAL:
2092        case FLOATING_POINT_LITERAL:
2093        case CHARACTER_LITERAL:
2094        case STRING_LITERAL:
2095          Literal();
2096          break;
2097        case LPAREN:
2098          jj_consume_token(LPAREN);
2099          Expression();
2100          jj_consume_token(RPAREN);
2101          break;
2102        case NEW:
2103          AllocationExpression();
2104          break;
2105        default:
2106          if (jj_2_14(2147483647)) {
2107            MethodInvocation();
2108          } else if (jj_2_15(2147483647)) {
2109            Type();
2110          } else {
2111            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2112            case IDENTIFIER:
2113              AmbiguousName();
2114              break;
2115            default:
2116              jj_consume_token(-1);
2117              throw new ParseException();
2118            }
2119          }
2120        }
2121      }
2122    
2123      final public void PrimarySuffix() throws ParseException {
2124     /*@bgen(jjtree) PrimarySuffix */
2125        BSHPrimarySuffix jjtn000 = new BSHPrimarySuffix(JJTPRIMARYSUFFIX);
2126        boolean jjtc000 = true;
2127        jjtree.openNodeScope(jjtn000);
2128        jjtreeOpenNodeScope(jjtn000);Token t = null;
2129        try {
2130          if (jj_2_16(2)) {
2131            jj_consume_token(DOT);
2132            jj_consume_token(CLASS);
2133                    jjtree.closeNodeScope(jjtn000, true);
2134                    jjtc000 = false;
2135                    jjtreeCloseNodeScope(jjtn000);
2136            jjtn000.operation = BSHPrimarySuffix.CLASS;
2137          } else {
2138            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2139            case LBRACKET:
2140              jj_consume_token(LBRACKET);
2141              Expression();
2142              jj_consume_token(RBRACKET);
2143                             jjtree.closeNodeScope(jjtn000, true);
2144                             jjtc000 = false;
2145                             jjtreeCloseNodeScope(jjtn000);
2146            jjtn000.operation = BSHPrimarySuffix.INDEX;
2147              break;
2148            case DOT:
2149              jj_consume_token(DOT);
2150              t = jj_consume_token(IDENTIFIER);
2151              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2152              case LPAREN:
2153                Arguments();
2154                break;
2155              default:
2156                ;
2157              }
2158                                             jjtree.closeNodeScope(jjtn000, true);
2159                                             jjtc000 = false;
2160                                             jjtreeCloseNodeScope(jjtn000);
2161            jjtn000.operation = BSHPrimarySuffix.NAME;
2162            jjtn000.field = t.image;
2163              break;
2164            case LBRACE:
2165              jj_consume_token(LBRACE);
2166              Expression();
2167              jj_consume_token(RBRACE);
2168                             jjtree.closeNodeScope(jjtn000, true);
2169                             jjtc000 = false;
2170                             jjtreeCloseNodeScope(jjtn000);
2171            jjtn000.operation = BSHPrimarySuffix.PROPERTY;
2172              break;
2173            default:
2174              jj_consume_token(-1);
2175              throw new ParseException();
2176            }
2177          }
2178        } catch (Throwable jjte000) {
2179        if (jjtc000) {
2180          jjtree.clearNodeScope(jjtn000);
2181          jjtc000 = false;
2182        } else {
2183          jjtree.popNode();
2184        }
2185        if (jjte000 instanceof RuntimeException) {
2186          {if (true) throw (RuntimeException)jjte000;}
2187        }
2188        if (jjte000 instanceof ParseException) {
2189          {if (true) throw (ParseException)jjte000;}
2190        }
2191        {if (true) throw (Error)jjte000;}
2192        } finally {
2193        if (jjtc000) {
2194          jjtree.closeNodeScope(jjtn000, true);
2195          jjtreeCloseNodeScope(jjtn000);
2196        }
2197        }
2198      }
2199    
2200      final public void Literal() throws ParseException {
2201     /*@bgen(jjtree) Literal */
2202        BSHLiteral jjtn000 = new BSHLiteral(JJTLITERAL);
2203        boolean jjtc000 = true;
2204        jjtree.openNodeScope(jjtn000);
2205        jjtreeOpenNodeScope(jjtn000);Token x;
2206        boolean b;
2207        String literal;
2208        char ch;
2209        try {
2210          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2211          case INTEGER_LITERAL:
2212            x = jj_consume_token(INTEGER_LITERAL);
2213        jjtree.closeNodeScope(jjtn000, true);
2214        jjtc000 = false;
2215        jjtreeCloseNodeScope(jjtn000);
2216        literal = x.image;
2217        ch = literal.charAt(literal.length()-1);
2218        if(ch == 'l' || ch == 'L')
2219        {
2220            literal = literal.substring(0,literal.length()-1);
2221    
2222            // This really should be Long.decode, but there isn't one. As a result,
2223            // hex and octal literals ending in 'l' or 'L' don't work.
2224            jjtn000.value = new Primitive( new Long( literal ).longValue() );
2225        }
2226        else
2227                    try {
2228                    jjtn000.value = new Primitive(
2229                                    Integer.decode( literal ).intValue() );
2230                    } catch ( NumberFormatException e ) {
2231                            {if (true) throw createParseException(
2232                                    "Error or number too big for integer type: "+ literal );}
2233                    }
2234            break;
2235          case FLOATING_POINT_LITERAL:
2236            x = jj_consume_token(FLOATING_POINT_LITERAL);
2237        jjtree.closeNodeScope(jjtn000, true);
2238        jjtc000 = false;
2239        jjtreeCloseNodeScope(jjtn000);
2240        literal = x.image;
2241        ch = literal.charAt(literal.length()-1);
2242        if(ch == 'f' || ch == 'F')
2243        {
2244            literal = literal.substring(0,literal.length()-1);
2245            jjtn000.value = new Primitive( new Float( literal ).floatValue() );
2246        }
2247        else
2248        {
2249            if(ch == 'd' || ch == 'D')
2250                literal = literal.substring(0,literal.length()-1);
2251    
2252            jjtn000.value = new Primitive( new Double( literal ).doubleValue() );
2253        }
2254            break;
2255          case CHARACTER_LITERAL:
2256            x = jj_consume_token(CHARACTER_LITERAL);
2257                                jjtree.closeNodeScope(jjtn000, true);
2258                                jjtc000 = false;
2259                                jjtreeCloseNodeScope(jjtn000);
2260                    try {
2261                    jjtn000.charSetup( x.image.substring(1, x.image.length() - 1) );
2262                    } catch ( Exception e ) {
2263                            {if (true) throw createParseException("Error parsing character: "+x.image);}
2264                    }
2265            break;
2266          case STRING_LITERAL:
2267            x = jj_consume_token(STRING_LITERAL);
2268                             jjtree.closeNodeScope(jjtn000, true);
2269                             jjtc000 = false;
2270                             jjtreeCloseNodeScope(jjtn000);
2271                    try {
2272                            jjtn000.stringSetup( x.image.substring(1, x.image.length() - 1) );
2273                    } catch ( Exception e ) {
2274                            {if (true) throw createParseException("Error parsing string: "+x.image);}
2275                    }
2276            break;
2277          case FALSE:
2278          case TRUE:
2279            b = BooleanLiteral();
2280                              jjtree.closeNodeScope(jjtn000, true);
2281                              jjtc000 = false;
2282                              jjtreeCloseNodeScope(jjtn000);
2283        jjtn000.value = new Primitive( b );
2284            break;
2285          case NULL:
2286            NullLiteral();
2287                      jjtree.closeNodeScope(jjtn000, true);
2288                      jjtc000 = false;
2289                      jjtreeCloseNodeScope(jjtn000);
2290        jjtn000.value = Primitive.NULL;
2291            break;
2292          case VOID:
2293            VoidLiteral();
2294                     jjtree.closeNodeScope(jjtn000, true);
2295                     jjtc000 = false;
2296                     jjtreeCloseNodeScope(jjtn000);
2297        jjtn000.value = Primitive.VOID;
2298            break;
2299          default:
2300            jj_consume_token(-1);
2301            throw new ParseException();
2302          }
2303        } catch (Throwable jjte000) {
2304        if (jjtc000) {
2305          jjtree.clearNodeScope(jjtn000);
2306          jjtc000 = false;
2307        } else {
2308          jjtree.popNode();
2309        }
2310        if (jjte000 instanceof RuntimeException) {
2311          {if (true) throw (RuntimeException)jjte000;}
2312        }
2313        if (jjte000 instanceof ParseException) {
2314          {if (true) throw (ParseException)jjte000;}
2315        }
2316        {if (true) throw (Error)jjte000;}
2317        } finally {
2318        if (jjtc000) {
2319          jjtree.closeNodeScope(jjtn000, true);
2320          jjtreeCloseNodeScope(jjtn000);
2321        }
2322        }
2323      }
2324    
2325      final public boolean BooleanLiteral() throws ParseException {
2326        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2327        case TRUE:
2328          jj_consume_token(TRUE);
2329               {if (true) return true;}
2330          break;
2331        case FALSE:
2332          jj_consume_token(FALSE);
2333                {if (true) return false;}
2334          break;
2335        default:
2336          jj_consume_token(-1);
2337          throw new ParseException();
2338        }
2339        throw new Error("Missing return statement in function");
2340      }
2341    
2342      final public void NullLiteral() throws ParseException {
2343        jj_consume_token(NULL);
2344      }
2345    
2346      final public void VoidLiteral() throws ParseException {
2347        jj_consume_token(VOID);
2348      }
2349    
2350      final public void Arguments() throws ParseException {
2351     /*@bgen(jjtree) Arguments */
2352      BSHArguments jjtn000 = new BSHArguments(JJTARGUMENTS);
2353      boolean jjtc000 = true;
2354      jjtree.openNodeScope(jjtn000);
2355      jjtreeOpenNodeScope(jjtn000);
2356        try {
2357          jj_consume_token(LPAREN);
2358          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2359          case BOOLEAN:
2360          case BYTE:
2361          case CHAR:
2362          case DOUBLE:
2363          case FALSE:
2364          case FLOAT:
2365          case INT:
2366          case LONG:
2367          case NEW:
2368          case NULL:
2369          case SHORT:
2370          case TRUE:
2371          case VOID:
2372          case INTEGER_LITERAL:
2373          case FLOATING_POINT_LITERAL:
2374          case CHARACTER_LITERAL:
2375          case STRING_LITERAL:
2376          case IDENTIFIER:
2377          case LPAREN:
2378          case BANG:
2379          case TILDE:
2380          case INCR:
2381          case DECR:
2382          case PLUS:
2383          case MINUS:
2384            ArgumentList();
2385            break;
2386          default:
2387            ;
2388          }
2389          jj_consume_token(RPAREN);
2390        } catch (Throwable jjte000) {
2391        if (jjtc000) {
2392          jjtree.clearNodeScope(jjtn000);
2393          jjtc000 = false;
2394        } else {
2395          jjtree.popNode();
2396        }
2397        if (jjte000 instanceof RuntimeException) {
2398          {if (true) throw (RuntimeException)jjte000;}
2399        }
2400        if (jjte000 instanceof ParseException) {
2401          {if (true) throw (ParseException)jjte000;}
2402        }
2403        {if (true) throw (Error)jjte000;}
2404        } finally {
2405        if (jjtc000) {
2406          jjtree.closeNodeScope(jjtn000, true);
2407          jjtreeCloseNodeScope(jjtn000);
2408        }
2409        }
2410      }
2411    
2412    // leave these on the stack for Arguments() to handle
2413      final public void ArgumentList() throws ParseException {
2414        Expression();
2415        label_18:
2416        while (true) {
2417          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2418          case COMMA:
2419            ;
2420            break;
2421          default:
2422            break label_18;
2423          }
2424          jj_consume_token(COMMA);
2425          Expression();
2426        }
2427      }
2428    
2429      final public void AllocationExpression() throws ParseException {
2430     /*@bgen(jjtree) AllocationExpression */
2431      BSHAllocationExpression jjtn000 = new BSHAllocationExpression(JJTALLOCATIONEXPRESSION);
2432      boolean jjtc000 = true;
2433      jjtree.openNodeScope(jjtn000);
2434      jjtreeOpenNodeScope(jjtn000);
2435        try {
2436          if (jj_2_18(2)) {
2437            jj_consume_token(NEW);
2438            PrimitiveType();
2439            ArrayDimensions();
2440          } else {
2441            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2442            case NEW:
2443              jj_consume_token(NEW);
2444              AmbiguousName();
2445              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2446              case LBRACKET:
2447                ArrayDimensions();
2448                break;
2449              case LPAREN:
2450                Arguments();
2451                if (jj_2_17(2)) {
2452                  Block();
2453                } else {
2454                  ;
2455                }
2456                break;
2457              default:
2458                jj_consume_token(-1);
2459                throw new ParseException();
2460              }
2461              break;
2462            default:
2463              jj_consume_token(-1);
2464              throw new ParseException();
2465            }
2466          }
2467        } catch (Throwable jjte000) {
2468        if (jjtc000) {
2469          jjtree.clearNodeScope(jjtn000);
2470          jjtc000 = false;
2471        } else {
2472          jjtree.popNode();
2473        }
2474        if (jjte000 instanceof RuntimeException) {
2475          {if (true) throw (RuntimeException)jjte000;}
2476        }
2477        if (jjte000 instanceof ParseException) {
2478          {if (true) throw (ParseException)jjte000;}
2479        }
2480        {if (true) throw (Error)jjte000;}
2481        } finally {
2482        if (jjtc000) {
2483          jjtree.closeNodeScope(jjtn000, true);
2484          jjtreeCloseNodeScope(jjtn000);
2485        }
2486        }
2487      }
2488    
2489      final public void ArrayDimensions() throws ParseException {
2490     /*@bgen(jjtree) ArrayDimensions */
2491      BSHArrayDimensions jjtn000 = new BSHArrayDimensions(JJTARRAYDIMENSIONS);
2492      boolean jjtc000 = true;
2493      jjtree.openNodeScope(jjtn000);
2494      jjtreeOpenNodeScope(jjtn000);
2495        try {
2496          if (jj_2_21(2)) {
2497            label_19:
2498            while (true) {
2499              jj_consume_token(LBRACKET);
2500              Expression();
2501              jj_consume_token(RBRACKET);
2502                                            jjtn000.addDefinedDimension();
2503              if (jj_2_19(2)) {
2504                ;
2505              } else {
2506                break label_19;
2507              }
2508            }
2509            label_20:
2510            while (true) {
2511              if (jj_2_20(2)) {
2512                ;
2513              } else {
2514                break label_20;
2515              }
2516              jj_consume_token(LBRACKET);
2517              jj_consume_token(RBRACKET);
2518                               jjtn000.addUndefinedDimension();
2519            }
2520          } else {
2521            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2522            case LBRACKET:
2523              label_21:
2524              while (true) {
2525                jj_consume_token(LBRACKET);
2526                jj_consume_token(RBRACKET);
2527                  jjtn000.addUndefinedDimension();
2528                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2529                case LBRACKET:
2530                  ;
2531                  break;
2532                default:
2533                  break label_21;
2534                }
2535              }
2536              ArrayInitializer();
2537              break;
2538            default:
2539              jj_consume_token(-1);
2540              throw new ParseException();
2541            }
2542          }
2543        } catch (Throwable jjte000) {
2544        if (jjtc000) {
2545          jjtree.clearNodeScope(jjtn000);
2546          jjtc000 = false;
2547        } else {
2548          jjtree.popNode();
2549        }
2550        if (jjte000 instanceof RuntimeException) {
2551          {if (true) throw (RuntimeException)jjte000;}
2552        }
2553        if (jjte000 instanceof ParseException) {
2554          {if (true) throw (ParseException)jjte000;}
2555        }
2556        {if (true) throw (Error)jjte000;}
2557        } finally {
2558        if (jjtc000) {
2559          jjtree.closeNodeScope(jjtn000, true);
2560          jjtreeCloseNodeScope(jjtn000);
2561        }
2562        }
2563      }
2564    
2565    /*
2566     * Statement syntax follows.
2567     */
2568      final public void Statement() throws ParseException {
2569        if (jj_2_22(2)) {
2570          LabeledStatement();
2571        } else {
2572          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2573          case LBRACE:
2574            Block();
2575            break;
2576          case SEMICOLON:
2577            EmptyStatement();
2578            break;
2579          case BOOLEAN:
2580          case BYTE:
2581          case CHAR:
2582          case DOUBLE:
2583          case FALSE:
2584          case FLOAT:
2585          case INT:
2586          case LONG:
2587          case NEW:
2588          case NULL:
2589          case SHORT:
2590          case TRUE:
2591          case VOID:
2592          case INTEGER_LITERAL:
2593          case FLOATING_POINT_LITERAL:
2594          case CHARACTER_LITERAL:
2595          case STRING_LITERAL:
2596          case IDENTIFIER:
2597          case LPAREN:
2598          case BANG:
2599          case TILDE:
2600          case INCR:
2601          case DECR:
2602          case PLUS:
2603          case MINUS:
2604            StatementExpression();
2605            jj_consume_token(SEMICOLON);
2606            break;
2607          case SWITCH:
2608            SwitchStatement();
2609            break;
2610          case IF:
2611            IfStatement();
2612            break;
2613          case WHILE:
2614            WhileStatement();
2615            break;
2616          case DO:
2617            DoStatement();
2618            break;
2619          default:
2620            if (isRegularForStatement()) {
2621              ForStatement();
2622            } else {
2623              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2624              case FOR:
2625                EnhancedForStatement();
2626                break;
2627              case BREAK:
2628                BreakStatement();
2629                break;
2630              case CONTINUE:
2631                ContinueStatement();
2632                break;
2633              case RETURN:
2634                ReturnStatement();
2635                break;
2636              case SYNCHRONIZED:
2637                SynchronizedStatement();
2638                break;
2639              case THROW:
2640                ThrowStatement();
2641                break;
2642              case TRY:
2643                TryStatement();
2644                break;
2645              default:
2646                jj_consume_token(-1);
2647                throw new ParseException();
2648              }
2649            }
2650          }
2651        }
2652      }
2653    
2654      final public void LabeledStatement() throws ParseException {
2655        jj_consume_token(IDENTIFIER);
2656        jj_consume_token(COLON);
2657        Statement();
2658      }
2659    
2660      final public void Block() throws ParseException {
2661     /*@bgen(jjtree) Block */
2662      BSHBlock jjtn000 = new BSHBlock(JJTBLOCK);
2663      boolean jjtc000 = true;
2664      jjtree.openNodeScope(jjtn000);
2665      jjtreeOpenNodeScope(jjtn000);
2666        try {
2667          jj_consume_token(LBRACE);
2668          label_22:
2669          while (true) {
2670            if (jj_2_23(1)) {
2671              ;
2672            } else {
2673              break label_22;
2674            }
2675            BlockStatement();
2676          }
2677          jj_consume_token(RBRACE);
2678        } catch (Throwable jjte000) {
2679        if (jjtc000) {
2680          jjtree.clearNodeScope(jjtn000);
2681          jjtc000 = false;
2682        } else {
2683          jjtree.popNode();
2684        }
2685        if (jjte000 instanceof RuntimeException) {
2686          {if (true) throw (RuntimeException)jjte000;}
2687        }
2688        if (jjte000 instanceof ParseException) {
2689          {if (true) throw (ParseException)jjte000;}
2690        }
2691        {if (true) throw (Error)jjte000;}
2692        } finally {
2693        if (jjtc000) {
2694          jjtree.closeNodeScope(jjtn000, true);
2695          jjtreeCloseNodeScope(jjtn000);
2696        }
2697        }
2698      }
2699    
2700      final public void BlockStatement() throws ParseException {
2701        if (jj_2_24(2147483647)) {
2702          ClassDeclaration();
2703        } else if (jj_2_25(2147483647)) {
2704          MethodDeclaration();
2705        } else if (jj_2_26(2147483647)) {
2706          MethodDeclaration();
2707        } else if (jj_2_27(2147483647)) {
2708          TypedVariableDeclaration();
2709          jj_consume_token(SEMICOLON);
2710        } else if (jj_2_28(1)) {
2711          Statement();
2712        } else {
2713          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2714          case IMPORT:
2715          case STATIC:
2716            ImportDeclaration();
2717            break;
2718          case PACKAGE:
2719            PackageDeclaration();
2720            break;
2721          case FORMAL_COMMENT:
2722            FormalComment();
2723            break;
2724          default:
2725            jj_consume_token(-1);
2726            throw new ParseException();
2727          }
2728        }
2729      }
2730    
2731      final public void FormalComment() throws ParseException {
2732     /*@bgen(jjtree) #FormalComment( retainComments) */
2733            BSHFormalComment jjtn000 = new BSHFormalComment(JJTFORMALCOMMENT);
2734            boolean jjtc000 = true;
2735            jjtree.openNodeScope(jjtn000);
2736            jjtreeOpenNodeScope(jjtn000);Token t;
2737        try {
2738          t = jj_consume_token(FORMAL_COMMENT);
2739                                  jjtree.closeNodeScope(jjtn000,  retainComments);
2740                                  jjtc000 = false;
2741                                  jjtreeCloseNodeScope(jjtn000);
2742                    jjtn000.text=t.image;
2743        } finally {
2744              if (jjtc000) {
2745                jjtree.closeNodeScope(jjtn000,  retainComments);
2746                jjtreeCloseNodeScope(jjtn000);
2747              }
2748        }
2749      }
2750    
2751      final public void EmptyStatement() throws ParseException {
2752        jj_consume_token(SEMICOLON);
2753      }
2754    
2755      final public void StatementExpression() throws ParseException {
2756        Expression();
2757      }
2758    
2759      final public void SwitchStatement() throws ParseException {
2760     /*@bgen(jjtree) SwitchStatement */
2761      BSHSwitchStatement jjtn000 = new BSHSwitchStatement(JJTSWITCHSTATEMENT);
2762      boolean jjtc000 = true;
2763      jjtree.openNodeScope(jjtn000);
2764      jjtreeOpenNodeScope(jjtn000);
2765        try {
2766          jj_consume_token(SWITCH);
2767          jj_consume_token(LPAREN);
2768          Expression();
2769          jj_consume_token(RPAREN);
2770          jj_consume_token(LBRACE);
2771          label_23:
2772          while (true) {
2773            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2774            case CASE:
2775            case _DEFAULT:
2776              ;
2777              break;
2778            default:
2779              break label_23;
2780            }
2781            SwitchLabel();
2782            label_24:
2783            while (true) {
2784              if (jj_2_29(1)) {
2785                ;
2786              } else {
2787                break label_24;
2788              }
2789              BlockStatement();
2790            }
2791          }
2792          jj_consume_token(RBRACE);
2793        } catch (Throwable jjte000) {
2794        if (jjtc000) {
2795          jjtree.clearNodeScope(jjtn000);
2796          jjtc000 = false;
2797        } else {
2798          jjtree.popNode();
2799        }
2800        if (jjte000 instanceof RuntimeException) {
2801          {if (true) throw (RuntimeException)jjte000;}
2802        }
2803        if (jjte000 instanceof ParseException) {
2804          {if (true) throw (ParseException)jjte000;}
2805        }
2806        {if (true) throw (Error)jjte000;}
2807        } finally {
2808        if (jjtc000) {
2809          jjtree.closeNodeScope(jjtn000, true);
2810          jjtreeCloseNodeScope(jjtn000);
2811        }
2812        }
2813      }
2814    
2815      final public void SwitchLabel() throws ParseException {
2816     /*@bgen(jjtree) SwitchLabel */
2817      BSHSwitchLabel jjtn000 = new BSHSwitchLabel(JJTSWITCHLABEL);
2818      boolean jjtc000 = true;
2819      jjtree.openNodeScope(jjtn000);
2820      jjtreeOpenNodeScope(jjtn000);
2821        try {
2822          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2823          case CASE:
2824            jj_consume_token(CASE);
2825            Expression();
2826            jj_consume_token(COLON);
2827            break;
2828          case _DEFAULT:
2829            jj_consume_token(_DEFAULT);
2830            jj_consume_token(COLON);
2831                      jjtree.closeNodeScope(jjtn000, true);
2832                      jjtc000 = false;
2833                      jjtreeCloseNodeScope(jjtn000);
2834                      jjtn000.isDefault = true;
2835            break;
2836          default:
2837            jj_consume_token(-1);
2838            throw new ParseException();
2839          }
2840        } catch (Throwable jjte000) {
2841        if (jjtc000) {
2842          jjtree.clearNodeScope(jjtn000);
2843          jjtc000 = false;
2844        } else {
2845          jjtree.popNode();
2846        }
2847        if (jjte000 instanceof RuntimeException) {
2848          {if (true) throw (RuntimeException)jjte000;}
2849        }
2850        if (jjte000 instanceof ParseException) {
2851          {if (true) throw (ParseException)jjte000;}
2852        }
2853        {if (true) throw (Error)jjte000;}
2854        } finally {
2855        if (jjtc000) {
2856          jjtree.closeNodeScope(jjtn000, true);
2857          jjtreeCloseNodeScope(jjtn000);
2858        }
2859        }
2860      }
2861    
2862      final public void IfStatement() throws ParseException {
2863     /*@bgen(jjtree) IfStatement */
2864      BSHIfStatement jjtn000 = new BSHIfStatement(JJTIFSTATEMENT);
2865      boolean jjtc000 = true;
2866      jjtree.openNodeScope(jjtn000);
2867      jjtreeOpenNodeScope(jjtn000);
2868        try {
2869          jj_consume_token(IF);
2870          jj_consume_token(LPAREN);
2871          Expression();
2872          jj_consume_token(RPAREN);
2873          Statement();
2874          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2875          case ELSE:
2876            jj_consume_token(ELSE);
2877            Statement();
2878            break;
2879          default:
2880            ;
2881          }
2882        } catch (Throwable jjte000) {
2883        if (jjtc000) {
2884          jjtree.clearNodeScope(jjtn000);
2885          jjtc000 = false;
2886        } else {
2887          jjtree.popNode();
2888        }
2889        if (jjte000 instanceof RuntimeException) {
2890          {if (true) throw (RuntimeException)jjte000;}
2891        }
2892        if (jjte000 instanceof ParseException) {
2893          {if (true) throw (ParseException)jjte000;}
2894        }
2895        {if (true) throw (Error)jjte000;}
2896        } finally {
2897        if (jjtc000) {
2898          jjtree.closeNodeScope(jjtn000, true);
2899          jjtreeCloseNodeScope(jjtn000);
2900        }
2901        }
2902      }
2903    
2904      final public void WhileStatement() throws ParseException {
2905     /*@bgen(jjtree) WhileStatement */
2906      BSHWhileStatement jjtn000 = new BSHWhileStatement(JJTWHILESTATEMENT);
2907      boolean jjtc000 = true;
2908      jjtree.openNodeScope(jjtn000);
2909      jjtreeOpenNodeScope(jjtn000);
2910        try {
2911          jj_consume_token(WHILE);
2912          jj_consume_token(LPAREN);
2913          Expression();
2914          jj_consume_token(RPAREN);
2915          Statement();
2916        } catch (Throwable jjte000) {
2917        if (jjtc000) {
2918          jjtree.clearNodeScope(jjtn000);
2919          jjtc000 = false;
2920        } else {
2921          jjtree.popNode();
2922        }
2923        if (jjte000 instanceof RuntimeException) {
2924          {if (true) throw (RuntimeException)jjte000;}
2925        }
2926        if (jjte000 instanceof ParseException) {
2927          {if (true) throw (ParseException)jjte000;}
2928        }
2929        {if (true) throw (Error)jjte000;}
2930        } finally {
2931        if (jjtc000) {
2932          jjtree.closeNodeScope(jjtn000, true);
2933          jjtreeCloseNodeScope(jjtn000);
2934        }
2935        }
2936      }
2937    
2938    /*
2939            Do statement is just a While statement with a special hook to execute
2940            at least once.
2941    */
2942      final public void DoStatement() throws ParseException {
2943     /*@bgen(jjtree) WhileStatement */
2944      BSHWhileStatement jjtn000 = new BSHWhileStatement(JJTWHILESTATEMENT);
2945      boolean jjtc000 = true;
2946      jjtree.openNodeScope(jjtn000);
2947      jjtreeOpenNodeScope(jjtn000);
2948        try {
2949          jj_consume_token(DO);
2950          Statement();
2951          jj_consume_token(WHILE);
2952          jj_consume_token(LPAREN);
2953          Expression();
2954          jj_consume_token(RPAREN);
2955          jj_consume_token(SEMICOLON);
2956              jjtree.closeNodeScope(jjtn000, true);
2957              jjtc000 = false;
2958              jjtreeCloseNodeScope(jjtn000);
2959              jjtn000.isDoStatement=true;
2960        } catch (Throwable jjte000) {
2961        if (jjtc000) {
2962          jjtree.clearNodeScope(jjtn000);
2963          jjtc000 = false;
2964        } else {
2965          jjtree.popNode();
2966        }
2967        if (jjte000 instanceof RuntimeException) {
2968          {if (true) throw (RuntimeException)jjte000;}
2969        }
2970        if (jjte000 instanceof ParseException) {
2971          {if (true) throw (ParseException)jjte000;}
2972        }
2973        {if (true) throw (Error)jjte000;}
2974        } finally {
2975        if (jjtc000) {
2976          jjtree.closeNodeScope(jjtn000, true);
2977          jjtreeCloseNodeScope(jjtn000);
2978        }
2979        }
2980      }
2981    
2982      final public void ForStatement() throws ParseException {
2983     /*@bgen(jjtree) ForStatement */
2984      BSHForStatement jjtn000 = new BSHForStatement(JJTFORSTATEMENT);
2985      boolean jjtc000 = true;
2986      jjtree.openNodeScope(jjtn000);
2987      jjtreeOpenNodeScope(jjtn000);Token t = null;
2988        try {
2989          jj_consume_token(FOR);
2990          jj_consume_token(LPAREN);
2991          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2992          case ABSTRACT:
2993          case BOOLEAN:
2994          case BYTE:
2995          case CHAR:
2996          case DOUBLE:
2997          case FALSE:
2998          case FINAL:
2999          case FLOAT:
3000          case INT:
3001          case LONG:
3002          case NATIVE:
3003          case NEW:
3004          case NULL:
3005          case PRIVATE:
3006          case PROTECTED:
3007          case PUBLIC:
3008          case SHORT:
3009          case STATIC:
3010          case STRICTFP:
3011          case SYNCHRONIZED:
3012          case TRANSIENT:
3013          case TRUE:
3014          case VOID:
3015          case VOLATILE:
3016          case INTEGER_LITERAL:
3017          case FLOATING_POINT_LITERAL:
3018          case CHARACTER_LITERAL:
3019          case STRING_LITERAL:
3020          case IDENTIFIER:
3021          case LPAREN:
3022          case BANG:
3023          case TILDE:
3024          case INCR:
3025          case DECR:
3026          case PLUS:
3027          case MINUS:
3028            ForInit();
3029                              jjtn000.hasForInit=true;
3030            break;
3031          default:
3032            ;
3033          }
3034          jj_consume_token(SEMICOLON);
3035          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3036          case BOOLEAN:
3037          case BYTE:
3038          case CHAR:
3039          case DOUBLE:
3040          case FALSE:
3041          case FLOAT:
3042          case INT:
3043          case LONG:
3044          case NEW:
3045          case NULL:
3046          case SHORT:
3047          case TRUE:
3048          case VOID:
3049          case INTEGER_LITERAL:
3050          case FLOATING_POINT_LITERAL:
3051          case CHARACTER_LITERAL:
3052          case STRING_LITERAL:
3053          case IDENTIFIER:
3054          case LPAREN:
3055          case BANG:
3056          case TILDE:
3057          case INCR:
3058          case DECR:
3059          case PLUS:
3060          case MINUS:
3061            Expression();
3062                             jjtn000.hasExpression=true;
3063            break;
3064          default:
3065            ;
3066          }
3067          jj_consume_token(SEMICOLON);
3068          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3069          case BOOLEAN:
3070          case BYTE:
3071          case CHAR:
3072          case DOUBLE:
3073          case FALSE:
3074          case FLOAT:
3075          case INT:
3076          case LONG:
3077          case NEW:
3078          case NULL:
3079          case SHORT:
3080          case TRUE:
3081          case VOID:
3082          case INTEGER_LITERAL:
3083          case FLOATING_POINT_LITERAL:
3084          case CHARACTER_LITERAL:
3085          case STRING_LITERAL:
3086          case IDENTIFIER:
3087          case LPAREN:
3088          case BANG:
3089          case TILDE:
3090          case INCR:
3091          case DECR:
3092          case PLUS:
3093          case MINUS:
3094            ForUpdate();
3095                            jjtn000.hasForUpdate=true;
3096            break;
3097          default:
3098            ;
3099          }
3100          jj_consume_token(RPAREN);
3101          Statement();
3102        } catch (Throwable jjte000) {
3103        if (jjtc000) {
3104          jjtree.clearNodeScope(jjtn000);
3105          jjtc000 = false;
3106        } else {
3107          jjtree.popNode();
3108        }
3109        if (jjte000 instanceof RuntimeException) {
3110          {if (true) throw (RuntimeException)jjte000;}
3111        }
3112        if (jjte000 instanceof ParseException) {
3113          {if (true) throw (ParseException)jjte000;}
3114        }
3115        {if (true) throw (Error)jjte000;}
3116        } finally {
3117        if (jjtc000) {
3118          jjtree.closeNodeScope(jjtn000, true);
3119          jjtreeCloseNodeScope(jjtn000);
3120        }
3121        }
3122      }
3123    
3124    /*
3125            The new JDK1.5 enhanced for statement.
3126            e.g. for( int a : arrayOfInts ) { }
3127            We also support loose typing of the iterator var for BeanShell
3128            e.g. for( a : arrayOfInts ) { }
3129    */
3130      final public void EnhancedForStatement() throws ParseException {
3131     /*@bgen(jjtree) EnhancedForStatement */
3132      BSHEnhancedForStatement jjtn000 = new BSHEnhancedForStatement(JJTENHANCEDFORSTATEMENT);
3133      boolean jjtc000 = true;
3134      jjtree.openNodeScope(jjtn000);
3135      jjtreeOpenNodeScope(jjtn000);Token t = null;
3136        try {
3137          if (jj_2_30(4)) {
3138            jj_consume_token(FOR);
3139            jj_consume_token(LPAREN);
3140            t = jj_consume_token(IDENTIFIER);
3141            jj_consume_token(COLON);
3142            Expression();
3143            jj_consume_token(RPAREN);
3144            Statement();
3145                      jjtree.closeNodeScope(jjtn000, true);
3146                      jjtc000 = false;
3147                      jjtreeCloseNodeScope(jjtn000);
3148                      jjtn000.varName = t.image;
3149          } else {
3150            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3151            case FOR:
3152              jj_consume_token(FOR);
3153              jj_consume_token(LPAREN);
3154              Type();
3155              t = jj_consume_token(IDENTIFIER);
3156              jj_consume_token(COLON);
3157              Expression();
3158              jj_consume_token(RPAREN);
3159              Statement();
3160                      jjtree.closeNodeScope(jjtn000, true);
3161                      jjtc000 = false;
3162                      jjtreeCloseNodeScope(jjtn000);
3163                      jjtn000.varName = t.image;
3164              break;
3165            default:
3166              jj_consume_token(-1);
3167              throw new ParseException();
3168            }
3169          }
3170        } catch (Throwable jjte000) {
3171        if (jjtc000) {
3172          jjtree.clearNodeScope(jjtn000);
3173          jjtc000 = false;
3174        } else {
3175          jjtree.popNode();
3176        }
3177        if (jjte000 instanceof RuntimeException) {
3178          {if (true) throw (RuntimeException)jjte000;}
3179        }
3180        if (jjte000 instanceof ParseException) {
3181          {if (true) throw (ParseException)jjte000;}
3182        }
3183        {if (true) throw (Error)jjte000;}
3184        } finally {
3185        if (jjtc000) {
3186          jjtree.closeNodeScope(jjtn000, true);
3187          jjtreeCloseNodeScope(jjtn000);
3188        }
3189        }
3190      }
3191    
3192      final public void ForInit() throws ParseException {
3193      Token t = null;
3194        if (jj_2_31(2147483647)) {
3195          TypedVariableDeclaration();
3196        } else {
3197          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3198          case BOOLEAN:
3199          case BYTE:
3200          case CHAR:
3201          case DOUBLE:
3202          case FALSE:
3203          case FLOAT:
3204          case INT:
3205          case LONG:
3206          case NEW:
3207          case NULL:
3208          case SHORT:
3209          case TRUE:
3210          case VOID:
3211          case INTEGER_LITERAL:
3212          case FLOATING_POINT_LITERAL:
3213          case CHARACTER_LITERAL:
3214          case STRING_LITERAL:
3215          case IDENTIFIER:
3216          case LPAREN:
3217          case BANG:
3218          case TILDE:
3219          case INCR:
3220          case DECR:
3221          case PLUS:
3222          case MINUS:
3223            StatementExpressionList();
3224            break;
3225          default:
3226            jj_consume_token(-1);
3227            throw new ParseException();
3228          }
3229        }
3230      }
3231    
3232    /**
3233            Declared a typed variable.
3234            Untyped variables are not declared per-se but are handled by the part
3235            of the grammar that deals with assignments.
3236    */
3237      final public void TypedVariableDeclaration() throws ParseException {
3238     /*@bgen(jjtree) TypedVariableDeclaration */
3239            BSHTypedVariableDeclaration jjtn000 = new BSHTypedVariableDeclaration(JJTTYPEDVARIABLEDECLARATION);
3240            boolean jjtc000 = true;
3241            jjtree.openNodeScope(jjtn000);
3242            jjtreeOpenNodeScope(jjtn000);Token t = null;
3243            Modifiers mods;
3244        try {
3245          mods = Modifiers(Modifiers.FIELD, false);
3246          Type();
3247          VariableDeclarator();
3248          label_25:
3249          while (true) {
3250            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3251            case COMMA:
3252              ;
3253              break;
3254            default:
3255              break label_25;
3256            }
3257            jj_consume_token(COMMA);
3258            VariableDeclarator();
3259          }
3260              jjtree.closeNodeScope(jjtn000, true);
3261              jjtc000 = false;
3262              jjtreeCloseNodeScope(jjtn000);
3263            jjtn000.modifiers = mods;
3264        } catch (Throwable jjte000) {
3265              if (jjtc000) {
3266                jjtree.clearNodeScope(jjtn000);
3267                jjtc000 = false;
3268              } else {
3269                jjtree.popNode();
3270              }
3271              if (jjte000 instanceof RuntimeException) {
3272                {if (true) throw (RuntimeException)jjte000;}
3273              }
3274              if (jjte000 instanceof ParseException) {
3275                {if (true) throw (ParseException)jjte000;}
3276              }
3277              {if (true) throw (Error)jjte000;}
3278        } finally {
3279              if (jjtc000) {
3280                jjtree.closeNodeScope(jjtn000, true);
3281                jjtreeCloseNodeScope(jjtn000);
3282              }
3283        }
3284      }
3285    
3286      final public void StatementExpressionList() throws ParseException {
3287     /*@bgen(jjtree) StatementExpressionList */
3288      BSHStatementExpressionList jjtn000 = new BSHStatementExpressionList(JJTSTATEMENTEXPRESSIONLIST);
3289      boolean jjtc000 = true;
3290      jjtree.openNodeScope(jjtn000);
3291      jjtreeOpenNodeScope(jjtn000);
3292        try {
3293          StatementExpression();
3294          label_26:
3295          while (true) {
3296            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3297            case COMMA:
3298              ;
3299              break;
3300            default:
3301              break label_26;
3302            }
3303            jj_consume_token(COMMA);
3304            StatementExpression();
3305          }
3306        } catch (Throwable jjte000) {
3307        if (jjtc000) {
3308          jjtree.clearNodeScope(jjtn000);
3309          jjtc000 = false;
3310        } else {
3311          jjtree.popNode();
3312        }
3313        if (jjte000 instanceof RuntimeException) {
3314          {if (true) throw (RuntimeException)jjte000;}
3315        }
3316        if (jjte000 instanceof ParseException) {
3317          {if (true) throw (ParseException)jjte000;}
3318        }
3319        {if (true) throw (Error)jjte000;}
3320        } finally {
3321        if (jjtc000) {
3322          jjtree.closeNodeScope(jjtn000, true);
3323          jjtreeCloseNodeScope(jjtn000);
3324        }
3325        }
3326      }
3327    
3328      final public void ForUpdate() throws ParseException {
3329        StatementExpressionList();
3330      }
3331    
3332      final public void BreakStatement() throws ParseException {
3333     /*@bgen(jjtree) ReturnStatement */
3334      BSHReturnStatement jjtn000 = new BSHReturnStatement(JJTRETURNSTATEMENT);
3335      boolean jjtc000 = true;
3336      jjtree.openNodeScope(jjtn000);
3337      jjtreeOpenNodeScope(jjtn000);
3338        try {
3339          jj_consume_token(BREAK);
3340          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3341          case IDENTIFIER:
3342            jj_consume_token(IDENTIFIER);
3343            break;
3344          default:
3345            ;
3346          }
3347          jj_consume_token(SEMICOLON);
3348                                     jjtree.closeNodeScope(jjtn000, true);
3349                                     jjtc000 = false;
3350                                     jjtreeCloseNodeScope(jjtn000);
3351                                     jjtn000.kind = BREAK;
3352        } finally {
3353        if (jjtc000) {
3354          jjtree.closeNodeScope(jjtn000, true);
3355          jjtreeCloseNodeScope(jjtn000);
3356        }
3357        }
3358      }
3359    
3360      final public void ContinueStatement() throws ParseException {
3361     /*@bgen(jjtree) ReturnStatement */
3362      BSHReturnStatement jjtn000 = new BSHReturnStatement(JJTRETURNSTATEMENT);
3363      boolean jjtc000 = true;
3364      jjtree.openNodeScope(jjtn000);
3365      jjtreeOpenNodeScope(jjtn000);
3366        try {
3367          jj_consume_token(CONTINUE);
3368          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3369          case IDENTIFIER:
3370            jj_consume_token(IDENTIFIER);
3371            break;
3372          default:
3373            ;
3374          }
3375          jj_consume_token(SEMICOLON);
3376                                        jjtree.closeNodeScope(jjtn000, true);
3377                                        jjtc000 = false;
3378                                        jjtreeCloseNodeScope(jjtn000);
3379                                        jjtn000.kind = CONTINUE;
3380        } finally {
3381        if (jjtc000) {
3382          jjtree.closeNodeScope(jjtn000, true);
3383          jjtreeCloseNodeScope(jjtn000);
3384        }
3385        }
3386      }
3387    
3388      final public void ReturnStatement() throws ParseException {
3389     /*@bgen(jjtree) ReturnStatement */
3390      BSHReturnStatement jjtn000 = new BSHReturnStatement(JJTRETURNSTATEMENT);
3391      boolean jjtc000 = true;
3392      jjtree.openNodeScope(jjtn000);
3393      jjtreeOpenNodeScope(jjtn000);
3394        try {
3395          jj_consume_token(RETURN);
3396          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3397          case BOOLEAN:
3398          case BYTE:
3399          case CHAR:
3400          case DOUBLE:
3401          case FALSE:
3402          case FLOAT:
3403          case INT:
3404          case LONG:
3405          case NEW:
3406          case NULL:
3407          case SHORT:
3408          case TRUE:
3409          case VOID:
3410          case INTEGER_LITERAL:
3411          case FLOATING_POINT_LITERAL:
3412          case CHARACTER_LITERAL:
3413          case STRING_LITERAL:
3414          case IDENTIFIER:
3415          case LPAREN:
3416          case BANG:
3417          case TILDE:
3418          case INCR:
3419          case DECR:
3420          case PLUS:
3421          case MINUS:
3422            Expression();
3423            break;
3424          default:
3425            ;
3426          }
3427          jj_consume_token(SEMICOLON);
3428                                      jjtree.closeNodeScope(jjtn000, true);
3429                                      jjtc000 = false;
3430                                      jjtreeCloseNodeScope(jjtn000);
3431                                      jjtn000.kind = RETURN;
3432        } catch (Throwable jjte000) {
3433        if (jjtc000) {
3434          jjtree.clearNodeScope(jjtn000);
3435          jjtc000 = false;
3436        } else {
3437          jjtree.popNode();
3438        }
3439        if (jjte000 instanceof RuntimeException) {
3440          {if (true) throw (RuntimeException)jjte000;}
3441        }
3442        if (jjte000 instanceof ParseException) {
3443          {if (true) throw (ParseException)jjte000;}
3444        }
3445        {if (true) throw (Error)jjte000;}
3446        } finally {
3447        if (jjtc000) {
3448          jjtree.closeNodeScope(jjtn000, true);
3449          jjtreeCloseNodeScope(jjtn000);
3450        }
3451        }
3452      }
3453    
3454      final public void SynchronizedStatement() throws ParseException {
3455     /*@bgen(jjtree) Block */
3456      BSHBlock jjtn000 = new BSHBlock(JJTBLOCK);
3457      boolean jjtc000 = true;
3458      jjtree.openNodeScope(jjtn000);
3459      jjtreeOpenNodeScope(jjtn000);
3460        try {
3461          jj_consume_token(SYNCHRONIZED);
3462          jj_consume_token(LPAREN);
3463          Expression();
3464          jj_consume_token(RPAREN);
3465          Block();
3466                                                    jjtree.closeNodeScope(jjtn000, true);
3467                                                    jjtc000 = false;
3468                                                    jjtreeCloseNodeScope(jjtn000);
3469                    jjtn000.isSynchronized=true;
3470        } catch (Throwable jjte000) {
3471        if (jjtc000) {
3472          jjtree.clearNodeScope(jjtn000);
3473          jjtc000 = false;
3474        } else {
3475          jjtree.popNode();
3476        }
3477        if (jjte000 instanceof RuntimeException) {
3478          {if (true) throw (RuntimeException)jjte000;}
3479        }
3480        if (jjte000 instanceof ParseException) {
3481          {if (true) throw (ParseException)jjte000;}
3482        }
3483        {if (true) throw (Error)jjte000;}
3484        } finally {
3485        if (jjtc000) {
3486          jjtree.closeNodeScope(jjtn000, true);
3487          jjtreeCloseNodeScope(jjtn000);
3488        }
3489        }
3490      }
3491    
3492      final public void ThrowStatement() throws ParseException {
3493     /*@bgen(jjtree) ThrowStatement */
3494      BSHThrowStatement jjtn000 = new BSHThrowStatement(JJTTHROWSTATEMENT);
3495      boolean jjtc000 = true;
3496      jjtree.openNodeScope(jjtn000);
3497      jjtreeOpenNodeScope(jjtn000);
3498        try {
3499          jj_consume_token(THROW);
3500          Expression();
3501          jj_consume_token(SEMICOLON);
3502        } catch (Throwable jjte000) {
3503        if (jjtc000) {
3504          jjtree.clearNodeScope(jjtn000);
3505          jjtc000 = false;
3506        } else {
3507          jjtree.popNode();
3508        }
3509        if (jjte000 instanceof RuntimeException) {
3510          {if (true) throw (RuntimeException)jjte000;}
3511        }
3512        if (jjte000 instanceof ParseException) {
3513          {if (true) throw (ParseException)jjte000;}
3514        }
3515        {if (true) throw (Error)jjte000;}
3516        } finally {
3517        if (jjtc000) {
3518          jjtree.closeNodeScope(jjtn000, true);
3519          jjtreeCloseNodeScope(jjtn000);
3520        }
3521        }
3522      }
3523    
3524      final public void TryStatement() throws ParseException {
3525     /*@bgen(jjtree) TryStatement */
3526      BSHTryStatement jjtn000 = new BSHTryStatement(JJTTRYSTATEMENT);
3527      boolean jjtc000 = true;
3528      jjtree.openNodeScope(jjtn000);
3529      jjtreeOpenNodeScope(jjtn000);boolean closed = false;
3530        try {
3531          jj_consume_token(TRY);
3532          Block();
3533          label_27:
3534          while (true) {
3535            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3536            case CATCH:
3537              ;
3538              break;
3539            default:
3540              break label_27;
3541            }
3542            jj_consume_token(CATCH);
3543            jj_consume_token(LPAREN);
3544            FormalParameter();
3545            jj_consume_token(RPAREN);
3546            Block();
3547                                                          closed = true;
3548          }
3549          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3550          case FINALLY:
3551            jj_consume_token(FINALLY);
3552            Block();
3553                                  closed = true;
3554            break;
3555          default:
3556            ;
3557          }
3558              jjtree.closeNodeScope(jjtn000, true);
3559              jjtc000 = false;
3560              jjtreeCloseNodeScope(jjtn000);
3561                    if ( !closed ) {if (true) throw generateParseException();}
3562        } catch (Throwable jjte000) {
3563              if (jjtc000) {
3564                jjtree.clearNodeScope(jjtn000);
3565                jjtc000 = false;
3566              } else {
3567                jjtree.popNode();
3568              }
3569              if (jjte000 instanceof RuntimeException) {
3570                {if (true) throw (RuntimeException)jjte000;}
3571              }
3572              if (jjte000 instanceof ParseException) {
3573                {if (true) throw (ParseException)jjte000;}
3574              }
3575              {if (true) throw (Error)jjte000;}
3576        } finally {
3577              if (jjtc000) {
3578                jjtree.closeNodeScope(jjtn000, true);
3579                jjtreeCloseNodeScope(jjtn000);
3580              }
3581        }
3582      }
3583    
3584      final private boolean jj_2_1(int xla) {
3585        jj_la = xla; jj_lastpos = jj_scanpos = token;
3586        try { return !jj_3_1(); }
3587        catch(LookaheadSuccess ls) { return true; }
3588      }
3589    
3590      final private boolean jj_2_2(int xla) {
3591        jj_la = xla; jj_lastpos = jj_scanpos = token;
3592        try { return !jj_3_2(); }
3593        catch(LookaheadSuccess ls) { return true; }
3594      }
3595    
3596      final private boolean jj_2_3(int xla) {
3597        jj_la = xla; jj_lastpos = jj_scanpos = token;
3598        try { return !jj_3_3(); }
3599        catch(LookaheadSuccess ls) { return true; }
3600      }
3601    
3602      final private boolean jj_2_4(int xla) {
3603        jj_la = xla; jj_lastpos = jj_scanpos = token;
3604        try { return !jj_3_4(); }
3605        catch(LookaheadSuccess ls) { return true; }
3606      }
3607    
3608      final private boolean jj_2_5(int xla) {
3609        jj_la = xla; jj_lastpos = jj_scanpos = token;
3610        try { return !jj_3_5(); }
3611        catch(LookaheadSuccess ls) { return true; }
3612      }
3613    
3614      final private boolean jj_2_6(int xla) {
3615        jj_la = xla; jj_lastpos = jj_scanpos = token;
3616        try { return !jj_3_6(); }
3617        catch(LookaheadSuccess ls) { return true; }
3618      }
3619    
3620      final private boolean jj_2_7(int xla) {
3621        jj_la = xla; jj_lastpos = jj_scanpos = token;
3622        try { return !jj_3_7(); }
3623        catch(LookaheadSuccess ls) { return true; }
3624      }
3625    
3626      final private boolean jj_2_8(int xla) {
3627        jj_la = xla; jj_lastpos = jj_scanpos = token;
3628        try { return !jj_3_8(); }
3629        catch(LookaheadSuccess ls) { return true; }
3630      }
3631    
3632      final private boolean jj_2_9(int xla) {
3633        jj_la = xla; jj_lastpos = jj_scanpos = token;
3634        try { return !jj_3_9(); }
3635        catch(LookaheadSuccess ls) { return true; }
3636      }
3637    
3638      final private boolean jj_2_10(int xla) {
3639        jj_la = xla; jj_lastpos = jj_scanpos = token;
3640        try { return !jj_3_10(); }
3641        catch(LookaheadSuccess ls) { return true; }
3642      }
3643    
3644      final private boolean jj_2_11(int xla) {
3645        jj_la = xla; jj_lastpos = jj_scanpos = token;
3646        try { return !jj_3_11(); }
3647        catch(LookaheadSuccess ls) { return true; }
3648      }
3649    
3650      final private boolean jj_2_12(int xla) {
3651        jj_la = xla; jj_lastpos = jj_scanpos = token;
3652        try { return !jj_3_12(); }
3653        catch(LookaheadSuccess ls) { return true; }
3654      }
3655    
3656      final private boolean jj_2_13(int xla) {
3657        jj_la = xla; jj_lastpos = jj_scanpos = token;
3658        try { return !jj_3_13(); }
3659        catch(LookaheadSuccess ls) { return true; }
3660      }
3661    
3662      final private boolean jj_2_14(int xla) {
3663        jj_la = xla; jj_lastpos = jj_scanpos = token;
3664        try { return !jj_3_14(); }
3665        catch(LookaheadSuccess ls) { return true; }
3666      }
3667    
3668      final private boolean jj_2_15(int xla) {
3669        jj_la = xla; jj_lastpos = jj_scanpos = token;
3670        try { return !jj_3_15(); }
3671        catch(LookaheadSuccess ls) { return true; }
3672      }
3673    
3674      final private boolean jj_2_16(int xla) {
3675        jj_la = xla; jj_lastpos = jj_scanpos = token;
3676        try { return !jj_3_16(); }
3677        catch(LookaheadSuccess ls) { return true; }
3678      }
3679    
3680      final private boolean jj_2_17(int xla) {
3681        jj_la = xla; jj_lastpos = jj_scanpos = token;
3682        try { return !jj_3_17(); }
3683        catch(LookaheadSuccess ls) { return true; }
3684      }
3685    
3686      final private boolean jj_2_18(int xla) {
3687        jj_la = xla; jj_lastpos = jj_scanpos = token;
3688        try { return !jj_3_18(); }
3689        catch(LookaheadSuccess ls) { return true; }
3690      }
3691    
3692      final private boolean jj_2_19(int xla) {
3693        jj_la = xla; jj_lastpos = jj_scanpos = token;
3694        try { return !jj_3_19(); }
3695        catch(LookaheadSuccess ls) { return true; }
3696      }
3697    
3698      final private boolean jj_2_20(int xla) {
3699        jj_la = xla; jj_lastpos = jj_scanpos = token;
3700        try { return !jj_3_20(); }
3701        catch(LookaheadSuccess ls) { return true; }
3702      }
3703    
3704      final private boolean jj_2_21(int xla) {
3705        jj_la = xla; jj_lastpos = jj_scanpos = token;
3706        try { return !jj_3_21(); }
3707        catch(LookaheadSuccess ls) { return true; }
3708      }
3709    
3710      final private boolean jj_2_22(int xla) {
3711        jj_la = xla; jj_lastpos = jj_scanpos = token;
3712        try { return !jj_3_22(); }
3713        catch(LookaheadSuccess ls) { return true; }
3714      }
3715    
3716      final private boolean jj_2_23(int xla) {
3717        jj_la = xla; jj_lastpos = jj_scanpos = token;
3718        try { return !jj_3_23(); }
3719        catch(LookaheadSuccess ls) { return true; }
3720      }
3721    
3722      final private boolean jj_2_24(int xla) {
3723        jj_la = xla; jj_lastpos = jj_scanpos = token;
3724        try { return !jj_3_24(); }
3725        catch(LookaheadSuccess ls) { return true; }
3726      }
3727    
3728      final private boolean jj_2_25(int xla) {
3729        jj_la = xla; jj_lastpos = jj_scanpos = token;
3730        try { return !jj_3_25(); }
3731        catch(LookaheadSuccess ls) { return true; }
3732      }
3733    
3734      final private boolean jj_2_26(int xla) {
3735        jj_la = xla; jj_lastpos = jj_scanpos = token;
3736        try { return !jj_3_26(); }
3737        catch(LookaheadSuccess ls) { return true; }
3738      }
3739    
3740      final private boolean jj_2_27(int xla) {
3741        jj_la = xla; jj_lastpos = jj_scanpos = token;
3742        try { return !jj_3_27(); }
3743        catch(LookaheadSuccess ls) { return true; }
3744      }
3745    
3746      final private boolean jj_2_28(int xla) {
3747        jj_la = xla; jj_lastpos = jj_scanpos = token;
3748        try { return !jj_3_28(); }
3749        catch(LookaheadSuccess ls) { return true; }
3750      }
3751    
3752      final private boolean jj_2_29(int xla) {
3753        jj_la = xla; jj_lastpos = jj_scanpos = token;
3754        try { return !jj_3_29(); }
3755        catch(LookaheadSuccess ls) { return true; }
3756      }
3757    
3758      final private boolean jj_2_30(int xla) {
3759        jj_la = xla; jj_lastpos = jj_scanpos = token;
3760        try { return !jj_3_30(); }
3761        catch(LookaheadSuccess ls) { return true; }
3762      }
3763    
3764      final private boolean jj_2_31(int xla) {
3765        jj_la = xla; jj_lastpos = jj_scanpos = token;
3766        try { return !jj_3_31(); }
3767        catch(LookaheadSuccess ls) { return true; }
3768      }
3769    
3770      final private boolean jj_3R_46() {
3771        if (jj_3R_91()) return true;
3772        return false;
3773      }
3774    
3775      final private boolean jj_3R_28() {
3776        Token xsp;
3777        xsp = jj_scanpos;
3778        if (jj_3R_46()) {
3779        jj_scanpos = xsp;
3780        if (jj_3R_47()) {
3781        jj_scanpos = xsp;
3782        if (jj_3R_48()) {
3783        jj_scanpos = xsp;
3784        if (jj_3R_49()) {
3785        jj_scanpos = xsp;
3786        if (jj_3_28()) {
3787        jj_scanpos = xsp;
3788        if (jj_3R_50()) {
3789        jj_scanpos = xsp;
3790        if (jj_3R_51()) {
3791        jj_scanpos = xsp;
3792        if (jj_3R_52()) return true;
3793        }
3794        }
3795        }
3796        }
3797        }
3798        }
3799        }
3800        return false;
3801      }
3802    
3803      final private boolean jj_3_23() {
3804        if (jj_3R_28()) return true;
3805        return false;
3806      }
3807    
3808      final private boolean jj_3R_161() {
3809        if (jj_3R_164()) return true;
3810        Token xsp;
3811        while (true) {
3812          xsp = jj_scanpos;
3813          if (jj_3R_169()) { jj_scanpos = xsp; break; }
3814        }
3815        return false;
3816      }
3817    
3818      final private boolean jj_3R_38() {
3819        if (jj_scan_token(LBRACE)) return true;
3820        Token xsp;
3821        while (true) {
3822          xsp = jj_scanpos;
3823          if (jj_3_23()) { jj_scanpos = xsp; break; }
3824        }
3825        if (jj_scan_token(RBRACE)) return true;
3826        return false;
3827      }
3828    
3829      final private boolean jj_3R_158() {
3830        if (jj_3R_161()) return true;
3831        Token xsp;
3832        while (true) {
3833          xsp = jj_scanpos;
3834          if (jj_3R_167()) { jj_scanpos = xsp; break; }
3835        }
3836        return false;
3837      }
3838    
3839      final private boolean jj_3R_40() {
3840        if (jj_scan_token(IDENTIFIER)) return true;
3841        if (jj_scan_token(COLON)) return true;
3842        if (jj_3R_45()) return true;
3843        return false;
3844      }
3845    
3846      final private boolean jj_3R_156() {
3847        if (jj_scan_token(HOOK)) return true;
3848        if (jj_3R_39()) return true;
3849        if (jj_scan_token(COLON)) return true;
3850        if (jj_3R_108()) return true;
3851        return false;
3852      }
3853    
3854      final private boolean jj_3R_165() {
3855        Token xsp;
3856        xsp = jj_scanpos;
3857        if (jj_scan_token(108)) {
3858        jj_scanpos = xsp;
3859        if (jj_scan_token(109)) return true;
3860        }
3861        if (jj_3R_158()) return true;
3862        return false;
3863      }
3864    
3865      final private boolean jj_3R_153() {
3866        if (jj_3R_158()) return true;
3867        Token xsp;
3868        while (true) {
3869          xsp = jj_scanpos;
3870          if (jj_3R_165()) { jj_scanpos = xsp; break; }
3871        }
3872        return false;
3873      }
3874    
3875      final private boolean jj_3R_90() {
3876        if (jj_3R_124()) return true;
3877        return false;
3878      }
3879    
3880      final private boolean jj_3R_89() {
3881        if (jj_3R_123()) return true;
3882        return false;
3883      }
3884    
3885      final private boolean jj_3R_88() {
3886        if (jj_3R_122()) return true;
3887        return false;
3888      }
3889    
3890      final private boolean jj_3R_162() {
3891        Token xsp;
3892        xsp = jj_scanpos;
3893        if (jj_scan_token(98)) {
3894        jj_scanpos = xsp;
3895        if (jj_scan_token(99)) return true;
3896        }
3897        if (jj_3R_153()) return true;
3898        return false;
3899      }
3900    
3901      final private boolean jj_3R_87() {
3902        if (jj_3R_121()) return true;
3903        return false;
3904      }
3905    
3906      final private boolean jj_3R_148() {
3907        if (jj_3R_153()) return true;
3908        Token xsp;
3909        while (true) {
3910          xsp = jj_scanpos;
3911          if (jj_3R_162()) { jj_scanpos = xsp; break; }
3912        }
3913        return false;
3914      }
3915    
3916      final private boolean jj_3R_86() {
3917        if (jj_3R_120()) return true;
3918        return false;
3919      }
3920    
3921      final private boolean jj_3R_85() {
3922        if (jj_3R_119()) return true;
3923        return false;
3924      }
3925    
3926      final private boolean jj_3R_84() {
3927        if (jj_3R_118()) return true;
3928        return false;
3929      }
3930    
3931      final private boolean jj_3R_159() {
3932        Token xsp;
3933        xsp = jj_scanpos;
3934        if (jj_scan_token(96)) {
3935        jj_scanpos = xsp;
3936        if (jj_scan_token(97)) return true;
3937        }
3938        if (jj_3R_148()) return true;
3939        return false;
3940      }
3941    
3942      final private boolean jj_3R_83() {
3943        if (jj_3R_117()) return true;
3944        return false;
3945      }
3946    
3947      final private boolean jj_3R_135() {
3948        if (jj_3R_148()) return true;
3949        Token xsp;
3950        while (true) {
3951          xsp = jj_scanpos;
3952          if (jj_3R_159()) { jj_scanpos = xsp; break; }
3953        }
3954        return false;
3955      }
3956    
3957      final private boolean jj_3R_82() {
3958        if (jj_3R_116()) return true;
3959        return false;
3960      }
3961    
3962      final private boolean jj_3R_81() {
3963        if (jj_3R_115()) return true;
3964        return false;
3965      }
3966    
3967      final private boolean jj_3R_80() {
3968        if (jj_3R_114()) return true;
3969        return false;
3970      }
3971    
3972      final private boolean jj_3R_108() {
3973        if (jj_3R_135()) return true;
3974        Token xsp;
3975        xsp = jj_scanpos;
3976        if (jj_3R_156()) jj_scanpos = xsp;
3977        return false;
3978      }
3979    
3980      final private boolean jj_3R_79() {
3981        if (jj_3R_113()) return true;
3982        return false;
3983      }
3984    
3985      final private boolean jj_3R_78() {
3986        if (jj_3R_112()) return true;
3987        if (jj_scan_token(SEMICOLON)) return true;
3988        return false;
3989      }
3990    
3991      final private boolean jj_3_17() {
3992        if (jj_3R_38()) return true;
3993        return false;
3994      }
3995    
3996      final private boolean jj_3R_77() {
3997        if (jj_3R_38()) return true;
3998        return false;
3999      }
4000    
4001      final private boolean jj_3R_45() {
4002        Token xsp;
4003        xsp = jj_scanpos;
4004        if (jj_3_22()) {
4005        jj_scanpos = xsp;
4006        if (jj_3R_77()) {
4007        jj_scanpos = xsp;
4008        if (jj_scan_token(78)) {
4009        jj_scanpos = xsp;
4010        if (jj_3R_78()) {
4011        jj_scanpos = xsp;
4012        if (jj_3R_79()) {
4013        jj_scanpos = xsp;
4014        if (jj_3R_80()) {
4015        jj_scanpos = xsp;
4016        if (jj_3R_81()) {
4017        jj_scanpos = xsp;
4018        if (jj_3R_82()) {
4019        jj_scanpos = xsp;
4020        lookingAhead = true;
4021        jj_semLA = isRegularForStatement();
4022        lookingAhead = false;
4023        if (!jj_semLA || jj_3R_83()) {
4024        jj_scanpos = xsp;
4025        if (jj_3R_84()) {
4026        jj_scanpos = xsp;
4027        if (jj_3R_85()) {
4028        jj_scanpos = xsp;
4029        if (jj_3R_86()) {
4030        jj_scanpos = xsp;
4031        if (jj_3R_87()) {
4032        jj_scanpos = xsp;
4033        if (jj_3R_88()) {
4034        jj_scanpos = xsp;
4035        if (jj_3R_89()) {
4036        jj_scanpos = xsp;
4037        if (jj_3R_90()) return true;
4038        }
4039        }
4040        }
4041        }
4042        }
4043        }
4044        }
4045        }
4046        }
4047        }
4048        }
4049        }
4050        }
4051        }
4052        }
4053        return false;
4054      }
4055    
4056      final private boolean jj_3_22() {
4057        if (jj_3R_40()) return true;
4058        return false;
4059      }
4060    
4061      final private boolean jj_3R_34() {
4062        Token xsp;
4063        xsp = jj_scanpos;
4064        if (jj_scan_token(81)) {
4065        jj_scanpos = xsp;
4066        if (jj_scan_token(120)) {
4067        jj_scanpos = xsp;
4068        if (jj_scan_token(121)) {
4069        jj_scanpos = xsp;
4070        if (jj_scan_token(127)) {
4071        jj_scanpos = xsp;
4072        if (jj_scan_token(118)) {
4073        jj_scanpos = xsp;
4074        if (jj_scan_token(119)) {
4075        jj_scanpos = xsp;
4076        if (jj_scan_token(122)) {
4077        jj_scanpos = xsp;
4078        if (jj_scan_token(126)) {
4079        jj_scanpos = xsp;
4080        if (jj_scan_token(124)) {
4081        jj_scanpos = xsp;
4082        if (jj_scan_token(128)) {
4083        jj_scanpos = xsp;
4084        if (jj_scan_token(129)) {
4085        jj_scanpos = xsp;
4086        if (jj_scan_token(130)) {
4087        jj_scanpos = xsp;
4088        if (jj_scan_token(131)) {
4089        jj_scanpos = xsp;
4090        if (jj_scan_token(132)) {
4091        jj_scanpos = xsp;
4092        if (jj_scan_token(133)) return true;
4093        }
4094        }
4095        }
4096        }
4097        }
4098        }
4099        }
4100        }
4101        }
4102        }
4103        }
4104        }
4105        }
4106        }
4107        return false;
4108      }
4109    
4110      final private boolean jj_3R_111() {
4111        if (jj_scan_token(COMMA)) return true;
4112        if (jj_3R_29()) return true;
4113        return false;
4114      }
4115    
4116      final private boolean jj_3R_160() {
4117        if (jj_scan_token(LBRACKET)) return true;
4118        if (jj_scan_token(RBRACKET)) return true;
4119        return false;
4120      }
4121    
4122      final private boolean jj_3R_152() {
4123        if (jj_3R_69()) return true;
4124        Token xsp;
4125        xsp = jj_scanpos;
4126        if (jj_3_17()) jj_scanpos = xsp;
4127        return false;
4128      }
4129    
4130      final private boolean jj_3R_157() {
4131        Token xsp;
4132        if (jj_3R_160()) return true;
4133        while (true) {
4134          xsp = jj_scanpos;
4135          if (jj_3R_160()) { jj_scanpos = xsp; break; }
4136        }
4137        if (jj_3R_97()) return true;
4138        return false;
4139      }
4140    
4141      final private boolean jj_3_8() {
4142        if (jj_3R_33()) return true;
4143        if (jj_3R_34()) return true;
4144        return false;
4145      }
4146    
4147      final private boolean jj_3_20() {
4148        if (jj_scan_token(LBRACKET)) return true;
4149        if (jj_scan_token(RBRACKET)) return true;
4150        return false;
4151      }
4152    
4153      final private boolean jj_3R_151() {
4154        if (jj_3R_150()) return true;
4155        return false;
4156      }
4157    
4158      final private boolean jj_3_19() {
4159        if (jj_scan_token(LBRACKET)) return true;
4160        if (jj_3R_39()) return true;
4161        if (jj_scan_token(RBRACKET)) return true;
4162        return false;
4163      }
4164    
4165      final private boolean jj_3R_107() {
4166        if (jj_3R_33()) return true;
4167        if (jj_3R_34()) return true;
4168        if (jj_3R_39()) return true;
4169        return false;
4170      }
4171    
4172      final private boolean jj_3_21() {
4173        Token xsp;
4174        if (jj_3_19()) return true;
4175        while (true) {
4176          xsp = jj_scanpos;
4177          if (jj_3_19()) { jj_scanpos = xsp; break; }
4178        }
4179        while (true) {
4180          xsp = jj_scanpos;
4181          if (jj_3_20()) { jj_scanpos = xsp; break; }
4182        }
4183        return false;
4184      }
4185    
4186      final private boolean jj_3R_150() {
4187        Token xsp;
4188        xsp = jj_scanpos;
4189        if (jj_3_21()) {
4190        jj_scanpos = xsp;
4191        if (jj_3R_157()) return true;
4192        }
4193        return false;
4194      }
4195    
4196      final private boolean jj_3R_71() {
4197        if (jj_3R_108()) return true;
4198        return false;
4199      }
4200    
4201      final private boolean jj_3R_39() {
4202        Token xsp;
4203        xsp = jj_scanpos;
4204        if (jj_3R_70()) {
4205        jj_scanpos = xsp;
4206        if (jj_3R_71()) return true;
4207        }
4208        return false;
4209      }
4210    
4211      final private boolean jj_3R_70() {
4212        if (jj_3R_107()) return true;
4213        return false;
4214      }
4215    
4216      final private boolean jj_3R_145() {
4217        if (jj_scan_token(NEW)) return true;
4218        if (jj_3R_29()) return true;
4219        Token xsp;
4220        xsp = jj_scanpos;
4221        if (jj_3R_151()) {
4222        jj_scanpos = xsp;
4223        if (jj_3R_152()) return true;
4224        }
4225        return false;
4226      }
4227    
4228      final private boolean jj_3_18() {
4229        if (jj_scan_token(NEW)) return true;
4230        if (jj_3R_36()) return true;
4231        if (jj_3R_150()) return true;
4232        return false;
4233      }
4234    
4235      final private boolean jj_3R_130() {
4236        Token xsp;
4237        xsp = jj_scanpos;
4238        if (jj_3_18()) {
4239        jj_scanpos = xsp;
4240        if (jj_3R_145()) return true;
4241        }
4242        return false;
4243      }
4244    
4245      final private boolean jj_3R_147() {
4246        if (jj_scan_token(COMMA)) return true;
4247        if (jj_3R_39()) return true;
4248        return false;
4249      }
4250    
4251      final private boolean jj_3R_76() {
4252        if (jj_3R_29()) return true;
4253        Token xsp;
4254        while (true) {
4255          xsp = jj_scanpos;
4256          if (jj_3R_111()) { jj_scanpos = xsp; break; }
4257        }
4258        return false;
4259      }
4260    
4261      final private boolean jj_3R_134() {
4262        if (jj_3R_39()) return true;
4263        Token xsp;
4264        while (true) {
4265          xsp = jj_scanpos;
4266          if (jj_3R_147()) { jj_scanpos = xsp; break; }
4267        }
4268        return false;
4269      }
4270    
4271      final private boolean jj_3R_106() {
4272        if (jj_3R_134()) return true;
4273        return false;
4274      }
4275    
4276      final private boolean jj_3_7() {
4277        if (jj_scan_token(DOT)) return true;
4278        if (jj_scan_token(IDENTIFIER)) return true;
4279        return false;
4280      }
4281    
4282      final private boolean jj_3R_69() {
4283        if (jj_scan_token(LPAREN)) return true;
4284        Token xsp;
4285        xsp = jj_scanpos;
4286        if (jj_3R_106()) jj_scanpos = xsp;
4287        if (jj_scan_token(RPAREN)) return true;
4288        return false;
4289      }
4290    
4291      final private boolean jj_3R_29() {
4292        if (jj_scan_token(IDENTIFIER)) return true;
4293        Token xsp;
4294        while (true) {
4295          xsp = jj_scanpos;
4296          if (jj_3_7()) { jj_scanpos = xsp; break; }
4297        }
4298        return false;
4299      }
4300    
4301      final private boolean jj_3R_68() {
4302        if (jj_scan_token(DOUBLE)) return true;
4303        return false;
4304      }
4305    
4306      final private boolean jj_3R_67() {
4307        if (jj_scan_token(FLOAT)) return true;
4308        return false;
4309      }
4310    
4311      final private boolean jj_3R_155() {
4312        if (jj_scan_token(FALSE)) return true;
4313        return false;
4314      }
4315    
4316      final private boolean jj_3R_66() {
4317        if (jj_scan_token(LONG)) return true;
4318        return false;
4319      }
4320    
4321      final private boolean jj_3R_65() {
4322        if (jj_scan_token(INT)) return true;
4323        return false;
4324      }
4325    
4326      final private boolean jj_3R_154() {
4327        if (jj_scan_token(TRUE)) return true;
4328        return false;
4329      }
4330    
4331      final private boolean jj_3R_149() {
4332        Token xsp;
4333        xsp = jj_scanpos;
4334        if (jj_3R_154()) {
4335        jj_scanpos = xsp;
4336        if (jj_3R_155()) return true;
4337        }
4338        return false;
4339      }
4340    
4341      final private boolean jj_3R_64() {
4342        if (jj_scan_token(SHORT)) return true;
4343        return false;
4344      }
4345    
4346      final private boolean jj_3R_56() {
4347        if (jj_3R_29()) return true;
4348        return false;
4349      }
4350    
4351      final private boolean jj_3R_63() {
4352        if (jj_scan_token(BYTE)) return true;
4353        return false;
4354      }
4355    
4356      final private boolean jj_3R_62() {
4357        if (jj_scan_token(CHAR)) return true;
4358        return false;
4359      }
4360    
4361      final private boolean jj_3R_61() {
4362        if (jj_scan_token(BOOLEAN)) return true;
4363        return false;
4364      }
4365    
4366      final private boolean jj_3R_36() {
4367        Token xsp;
4368        xsp = jj_scanpos;
4369        if (jj_3R_61()) {
4370        jj_scanpos = xsp;
4371        if (jj_3R_62()) {
4372        jj_scanpos = xsp;
4373        if (jj_3R_63()) {
4374        jj_scanpos = xsp;
4375        if (jj_3R_64()) {
4376        jj_scanpos = xsp;
4377        if (jj_3R_65()) {
4378        jj_scanpos = xsp;
4379        if (jj_3R_66()) {
4380        jj_scanpos = xsp;
4381        if (jj_3R_67()) {
4382        jj_scanpos = xsp;
4383        if (jj_3R_68()) return true;
4384        }
4385        }
4386        }
4387        }
4388        }
4389        }
4390        }
4391        return false;
4392      }
4393    
4394      final private boolean jj_3R_144() {
4395        if (jj_scan_token(57)) return true;
4396        return false;
4397      }
4398    
4399      final private boolean jj_3R_74() {
4400        if (jj_3R_32()) return true;
4401        return false;
4402      }
4403    
4404      final private boolean jj_3R_42() {
4405        Token xsp;
4406        xsp = jj_scanpos;
4407        if (jj_3R_73()) {
4408        jj_scanpos = xsp;
4409        if (jj_3R_74()) return true;
4410        }
4411        return false;
4412      }
4413    
4414      final private boolean jj_3R_73() {
4415        if (jj_scan_token(VOID)) return true;
4416        return false;
4417      }
4418    
4419      final private boolean jj_3R_143() {
4420        if (jj_scan_token(41)) return true;
4421        return false;
4422      }
4423    
4424      final private boolean jj_3_6() {
4425        if (jj_scan_token(LBRACKET)) return true;
4426        if (jj_scan_token(RBRACKET)) return true;
4427        return false;
4428      }
4429    
4430      final private boolean jj_3R_142() {
4431        if (jj_3R_149()) return true;
4432        return false;
4433      }
4434    
4435      final private boolean jj_3R_55() {
4436        if (jj_3R_36()) return true;
4437        return false;
4438      }
4439    
4440      final private boolean jj_3R_110() {
4441        if (jj_scan_token(COMMA)) return true;
4442        if (jj_3R_109()) return true;
4443        return false;
4444      }
4445    
4446      final private boolean jj_3R_141() {
4447        if (jj_scan_token(STRING_LITERAL)) return true;
4448        return false;
4449      }
4450    
4451      final private boolean jj_3R_32() {
4452        Token xsp;
4453        xsp = jj_scanpos;
4454        if (jj_3R_55()) {
4455        jj_scanpos = xsp;
4456        if (jj_3R_56()) return true;
4457        }
4458        while (true) {
4459          xsp = jj_scanpos;
4460          if (jj_3_6()) { jj_scanpos = xsp; break; }
4461        }
4462        return false;
4463      }
4464    
4465      final private boolean jj_3R_140() {
4466        if (jj_scan_token(CHARACTER_LITERAL)) return true;
4467        return false;
4468      }
4469    
4470      final private boolean jj_3R_190() {
4471        if (jj_scan_token(FINALLY)) return true;
4472        if (jj_3R_38()) return true;
4473        return false;
4474      }
4475    
4476      final private boolean jj_3_4() {
4477        if (jj_scan_token(COMMA)) return true;
4478        if (jj_3R_31()) return true;
4479        return false;
4480      }
4481    
4482      final private boolean jj_3R_189() {
4483        if (jj_scan_token(CATCH)) return true;
4484        if (jj_scan_token(LPAREN)) return true;
4485        if (jj_3R_109()) return true;
4486        if (jj_scan_token(RPAREN)) return true;
4487        if (jj_3R_38()) return true;
4488        return false;
4489      }
4490    
4491      final private boolean jj_3R_136() {
4492        if (jj_scan_token(IDENTIFIER)) return true;
4493        return false;
4494      }
4495    
4496      final private boolean jj_3_5() {
4497        if (jj_3R_32()) return true;
4498        if (jj_scan_token(IDENTIFIER)) return true;
4499        return false;
4500      }
4501    
4502      final private boolean jj_3R_75() {
4503        if (jj_3R_109()) return true;
4504        Token xsp;
4505        while (true) {
4506          xsp = jj_scanpos;
4507          if (jj_3R_110()) { jj_scanpos = xsp; break; }
4508        }
4509        return false;
4510      }
4511    
4512      final private boolean jj_3R_109() {
4513        Token xsp;
4514        xsp = jj_scanpos;
4515        if (jj_3_5()) {
4516        jj_scanpos = xsp;
4517        if (jj_3R_136()) return true;
4518        }
4519        return false;
4520      }
4521    
4522      final private boolean jj_3R_124() {
4523        if (jj_scan_token(TRY)) return true;
4524        if (jj_3R_38()) return true;
4525        Token xsp;
4526        while (true) {
4527          xsp = jj_scanpos;
4528          if (jj_3R_189()) { jj_scanpos = xsp; break; }
4529        }
4530        xsp = jj_scanpos;
4531        if (jj_3R_190()) jj_scanpos = xsp;
4532        return false;
4533      }
4534    
4535      final private boolean jj_3R_43() {
4536        if (jj_scan_token(LPAREN)) return true;
4537        Token xsp;
4538        xsp = jj_scanpos;
4539        if (jj_3R_75()) jj_scanpos = xsp;
4540        if (jj_scan_token(RPAREN)) return true;
4541        return false;
4542      }
4543    
4544      final private boolean jj_3R_163() {
4545        if (jj_3R_31()) return true;
4546        Token xsp;
4547        while (true) {
4548          xsp = jj_scanpos;
4549          if (jj_3_4()) { jj_scanpos = xsp; break; }
4550        }
4551        return false;
4552      }
4553    
4554      final private boolean jj_3R_139() {
4555        if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
4556        return false;
4557      }
4558    
4559      final private boolean jj_3R_97() {
4560        if (jj_scan_token(LBRACE)) return true;
4561        Token xsp;
4562        xsp = jj_scanpos;
4563        if (jj_3R_163()) jj_scanpos = xsp;
4564        xsp = jj_scanpos;
4565        if (jj_scan_token(79)) jj_scanpos = xsp;
4566        if (jj_scan_token(RBRACE)) return true;
4567        return false;
4568      }
4569    
4570      final private boolean jj_3R_30() {
4571        if (jj_scan_token(DOT)) return true;
4572        if (jj_scan_token(STAR)) return true;
4573        return false;
4574      }
4575    
4576      final private boolean jj_3R_123() {
4577        if (jj_scan_token(THROW)) return true;
4578        if (jj_3R_39()) return true;
4579        if (jj_scan_token(SEMICOLON)) return true;
4580        return false;
4581      }
4582    
4583      final private boolean jj_3R_180() {
4584        if (jj_scan_token(ASSIGN)) return true;
4585        if (jj_3R_31()) return true;
4586        return false;
4587      }
4588    
4589      final private boolean jj_3R_54() {
4590        if (jj_3R_39()) return true;
4591        return false;
4592      }
4593    
4594      final private boolean jj_3R_188() {
4595        if (jj_3R_39()) return true;
4596        return false;
4597      }
4598    
4599      final private boolean jj_3R_53() {
4600        if (jj_3R_97()) return true;
4601        return false;
4602      }
4603    
4604      final private boolean jj_3R_31() {
4605        Token xsp;
4606        xsp = jj_scanpos;
4607        if (jj_3R_53()) {
4608        jj_scanpos = xsp;
4609        if (jj_3R_54()) return true;
4610        }
4611        return false;
4612      }
4613    
4614      final private boolean jj_3R_122() {
4615        if (jj_scan_token(SYNCHRONIZED)) return true;
4616        if (jj_scan_token(LPAREN)) return true;
4617        if (jj_3R_39()) return true;
4618        if (jj_scan_token(RPAREN)) return true;
4619        if (jj_3R_38()) return true;
4620        return false;
4621      }
4622    
4623      final private boolean jj_3R_177() {
4624        if (jj_scan_token(COMMA)) return true;
4625        if (jj_3R_176()) return true;
4626        return false;
4627      }
4628    
4629      final private boolean jj_3R_210() {
4630        if (jj_scan_token(COMMA)) return true;
4631        if (jj_3R_112()) return true;
4632        return false;
4633      }
4634    
4635      final private boolean jj_3R_121() {
4636        if (jj_scan_token(RETURN)) return true;
4637        Token xsp;
4638        xsp = jj_scanpos;
4639        if (jj_3R_188()) jj_scanpos = xsp;
4640        if (jj_scan_token(SEMICOLON)) return true;
4641        return false;
4642      }
4643    
4644      final private boolean jj_3R_129() {
4645        Token xsp;
4646        xsp = jj_scanpos;
4647        if (jj_3R_138()) {
4648        jj_scanpos = xsp;
4649        if (jj_3R_139()) {
4650        jj_scanpos = xsp;
4651        if (jj_3R_140()) {
4652        jj_scanpos = xsp;
4653        if (jj_3R_141()) {
4654        jj_scanpos = xsp;
4655        if (jj_3R_142()) {
4656        jj_scanpos = xsp;
4657        if (jj_3R_143()) {
4658        jj_scanpos = xsp;
4659        if (jj_3R_144()) return true;
4660        }
4661        }
4662        }
4663        }
4664        }
4665        }
4666        return false;
4667      }
4668    
4669      final private boolean jj_3R_138() {
4670        if (jj_scan_token(INTEGER_LITERAL)) return true;
4671        return false;
4672      }
4673    
4674      final private boolean jj_3R_146() {
4675        if (jj_3R_69()) return true;
4676        return false;
4677      }
4678    
4679      final private boolean jj_3R_176() {
4680        if (jj_scan_token(IDENTIFIER)) return true;
4681        Token xsp;
4682        xsp = jj_scanpos;
4683        if (jj_3R_180()) jj_scanpos = xsp;
4684        return false;
4685      }
4686    
4687      final private boolean jj_3R_105() {
4688        if (jj_3R_129()) return true;
4689        return false;
4690      }
4691    
4692      final private boolean jj_3R_120() {
4693        if (jj_scan_token(CONTINUE)) return true;
4694        Token xsp;
4695        xsp = jj_scanpos;
4696        if (jj_scan_token(69)) jj_scanpos = xsp;
4697        if (jj_scan_token(SEMICOLON)) return true;
4698        return false;
4699      }
4700    
4701      final private boolean jj_3R_119() {
4702        if (jj_scan_token(BREAK)) return true;
4703        Token xsp;
4704        xsp = jj_scanpos;
4705        if (jj_scan_token(69)) jj_scanpos = xsp;
4706        if (jj_scan_token(SEMICOLON)) return true;
4707        return false;
4708      }
4709    
4710      final private boolean jj_3R_195() {
4711        if (jj_3R_205()) return true;
4712        return false;
4713      }
4714    
4715      final private boolean jj_3R_128() {
4716        if (jj_scan_token(IMPORT)) return true;
4717        if (jj_scan_token(STAR)) return true;
4718        if (jj_scan_token(SEMICOLON)) return true;
4719        return false;
4720      }
4721    
4722      final private boolean jj_3R_133() {
4723        if (jj_scan_token(LBRACE)) return true;
4724        if (jj_3R_39()) return true;
4725        if (jj_scan_token(RBRACE)) return true;
4726        return false;
4727      }
4728    
4729      final private boolean jj_3R_205() {
4730        if (jj_3R_112()) return true;
4731        Token xsp;
4732        while (true) {
4733          xsp = jj_scanpos;
4734          if (jj_3R_210()) { jj_scanpos = xsp; break; }
4735        }
4736        return false;
4737      }
4738    
4739      final private boolean jj_3R_132() {
4740        if (jj_scan_token(DOT)) return true;
4741        if (jj_scan_token(IDENTIFIER)) return true;
4742        Token xsp;
4743        xsp = jj_scanpos;
4744        if (jj_3R_146()) jj_scanpos = xsp;
4745        return false;
4746      }
4747    
4748      final private boolean jj_3_3() {
4749        Token xsp;
4750        xsp = jj_scanpos;
4751        if (jj_scan_token(48)) jj_scanpos = xsp;
4752        if (jj_scan_token(IMPORT)) return true;
4753        if (jj_3R_29()) return true;
4754        xsp = jj_scanpos;
4755        if (jj_3R_30()) jj_scanpos = xsp;
4756        if (jj_scan_token(SEMICOLON)) return true;
4757        return false;
4758      }
4759    
4760      final private boolean jj_3R_94() {
4761        Token xsp;
4762        xsp = jj_scanpos;
4763        if (jj_3_3()) {
4764        jj_scanpos = xsp;
4765        if (jj_3R_128()) return true;
4766        }
4767        return false;
4768      }
4769    
4770      final private boolean jj_3R_93() {
4771        if (jj_3R_41()) return true;
4772        if (jj_3R_32()) return true;
4773        if (jj_3R_176()) return true;
4774        Token xsp;
4775        while (true) {
4776          xsp = jj_scanpos;
4777          if (jj_3R_177()) { jj_scanpos = xsp; break; }
4778        }
4779        return false;
4780      }
4781    
4782      final private boolean jj_3R_131() {
4783        if (jj_scan_token(LBRACKET)) return true;
4784        if (jj_3R_39()) return true;
4785        if (jj_scan_token(RBRACKET)) return true;
4786        return false;
4787      }
4788    
4789      final private boolean jj_3R_95() {
4790        if (jj_scan_token(PACKAGE)) return true;
4791        if (jj_3R_29()) return true;
4792        return false;
4793      }
4794    
4795      final private boolean jj_3_2() {
4796        if (jj_scan_token(IDENTIFIER)) return true;
4797        if (jj_scan_token(LPAREN)) return true;
4798        return false;
4799      }
4800    
4801      final private boolean jj_3R_175() {
4802        if (jj_3R_38()) return true;
4803        return false;
4804      }
4805    
4806      final private boolean jj_3_16() {
4807        if (jj_scan_token(DOT)) return true;
4808        if (jj_scan_token(CLASS)) return true;
4809        return false;
4810      }
4811    
4812      final private boolean jj_3R_104() {
4813        Token xsp;
4814        xsp = jj_scanpos;
4815        if (jj_3_16()) {
4816        jj_scanpos = xsp;
4817        if (jj_3R_131()) {
4818        jj_scanpos = xsp;
4819        if (jj_3R_132()) {
4820        jj_scanpos = xsp;
4821        if (jj_3R_133()) return true;
4822        }
4823        }
4824        }
4825        return false;
4826      }
4827    
4828      final private boolean jj_3R_174() {
4829        if (jj_scan_token(THROWS)) return true;
4830        if (jj_3R_76()) return true;
4831        return false;
4832      }
4833    
4834      final private boolean jj_3_15() {
4835        if (jj_3R_32()) return true;
4836        if (jj_scan_token(DOT)) return true;
4837        if (jj_scan_token(CLASS)) return true;
4838        return false;
4839      }
4840    
4841      final private boolean jj_3_31() {
4842        if (jj_3R_41()) return true;
4843        if (jj_3R_32()) return true;
4844        if (jj_scan_token(IDENTIFIER)) return true;
4845        return false;
4846      }
4847    
4848      final private boolean jj_3_14() {
4849        if (jj_3R_37()) return true;
4850        return false;
4851      }
4852    
4853      final private boolean jj_3R_126() {
4854        if (jj_scan_token(IDENTIFIER)) return true;
4855        return false;
4856      }
4857    
4858      final private boolean jj_3R_127() {
4859        if (jj_3R_42()) return true;
4860        if (jj_scan_token(IDENTIFIER)) return true;
4861        return false;
4862      }
4863    
4864      final private boolean jj_3R_92() {
4865        if (jj_3R_41()) return true;
4866        Token xsp;
4867        xsp = jj_scanpos;
4868        if (jj_3R_126()) {
4869        jj_scanpos = xsp;
4870        if (jj_3R_127()) return true;
4871        }
4872        if (jj_3R_43()) return true;
4873        xsp = jj_scanpos;
4874        if (jj_3R_174()) jj_scanpos = xsp;
4875        xsp = jj_scanpos;
4876        if (jj_3R_175()) {
4877        jj_scanpos = xsp;
4878        if (jj_scan_token(78)) return true;
4879        }
4880        return false;
4881      }
4882    
4883      final private boolean jj_3R_204() {
4884        if (jj_3R_205()) return true;
4885        return false;
4886      }
4887    
4888      final private boolean jj_3R_103() {
4889        if (jj_3R_29()) return true;
4890        return false;
4891      }
4892    
4893      final private boolean jj_3R_203() {
4894        if (jj_3R_93()) return true;
4895        return false;
4896      }
4897    
4898      final private boolean jj_3R_194() {
4899        Token xsp;
4900        xsp = jj_scanpos;
4901        if (jj_3R_203()) {
4902        jj_scanpos = xsp;
4903        if (jj_3R_204()) return true;
4904        }
4905        return false;
4906      }
4907    
4908      final private boolean jj_3R_102() {
4909        if (jj_3R_32()) return true;
4910        return false;
4911      }
4912    
4913      final private boolean jj_3R_58() {
4914        if (jj_3R_104()) return true;
4915        return false;
4916      }
4917    
4918      final private boolean jj_3R_125() {
4919        if (jj_scan_token(INTERFACE)) return true;
4920        return false;
4921      }
4922    
4923      final private boolean jj_3R_101() {
4924        if (jj_3R_37()) return true;
4925        return false;
4926      }
4927    
4928      final private boolean jj_3R_100() {
4929        if (jj_3R_130()) return true;
4930        return false;
4931      }
4932    
4933      final private boolean jj_3R_99() {
4934        if (jj_scan_token(LPAREN)) return true;
4935        if (jj_3R_39()) return true;
4936        if (jj_scan_token(RPAREN)) return true;
4937        return false;
4938      }
4939    
4940      final private boolean jj_3R_137() {
4941        if (jj_scan_token(FOR)) return true;
4942        if (jj_scan_token(LPAREN)) return true;
4943        if (jj_3R_32()) return true;
4944        if (jj_scan_token(IDENTIFIER)) return true;
4945        if (jj_scan_token(COLON)) return true;
4946        if (jj_3R_39()) return true;
4947        if (jj_scan_token(RPAREN)) return true;
4948        if (jj_3R_45()) return true;
4949        return false;
4950      }
4951    
4952      final private boolean jj_3R_184() {
4953        if (jj_scan_token(ELSE)) return true;
4954        if (jj_3R_45()) return true;
4955        return false;
4956      }
4957    
4958      final private boolean jj_3R_173() {
4959        if (jj_scan_token(IMPLEMENTS)) return true;
4960        if (jj_3R_76()) return true;
4961        return false;
4962      }
4963    
4964      final private boolean jj_3R_57() {
4965        Token xsp;
4966        xsp = jj_scanpos;
4967        if (jj_3R_98()) {
4968        jj_scanpos = xsp;
4969        if (jj_3R_99()) {
4970        jj_scanpos = xsp;
4971        if (jj_3R_100()) {
4972        jj_scanpos = xsp;
4973        if (jj_3R_101()) {
4974        jj_scanpos = xsp;
4975        if (jj_3R_102()) {
4976        jj_scanpos = xsp;
4977        if (jj_3R_103()) return true;
4978        }
4979        }
4980        }
4981        }
4982        }
4983        return false;
4984      }
4985    
4986      final private boolean jj_3R_98() {
4987        if (jj_3R_129()) return true;
4988        return false;
4989      }
4990    
4991      final private boolean jj_3R_172() {
4992        if (jj_scan_token(EXTENDS)) return true;
4993        if (jj_3R_29()) return true;
4994        return false;
4995      }
4996    
4997      final private boolean jj_3_30() {
4998        if (jj_scan_token(FOR)) return true;
4999        if (jj_scan_token(LPAREN)) return true;
5000        if (jj_scan_token(IDENTIFIER)) return true;
5001        if (jj_scan_token(COLON)) return true;
5002        if (jj_3R_39()) return true;
5003        if (jj_scan_token(RPAREN)) return true;
5004        if (jj_3R_45()) return true;
5005        return false;
5006      }
5007    
5008      final private boolean jj_3R_118() {
5009        Token xsp;
5010        xsp = jj_scanpos;
5011        if (jj_3_30()) {
5012        jj_scanpos = xsp;
5013        if (jj_3R_137()) return true;
5014        }
5015        return false;
5016      }
5017    
5018      final private boolean jj_3R_37() {
5019        if (jj_3R_29()) return true;
5020        if (jj_3R_69()) return true;
5021        return false;
5022      }
5023    
5024      final private boolean jj_3R_185() {
5025        if (jj_3R_194()) return true;
5026        return false;
5027      }
5028    
5029      final private boolean jj_3R_91() {
5030        if (jj_3R_41()) return true;
5031        Token xsp;
5032        xsp = jj_scanpos;
5033        if (jj_scan_token(13)) {
5034        jj_scanpos = xsp;
5035        if (jj_3R_125()) return true;
5036        }
5037        if (jj_scan_token(IDENTIFIER)) return true;
5038        xsp = jj_scanpos;
5039        if (jj_3R_172()) jj_scanpos = xsp;
5040        xsp = jj_scanpos;
5041        if (jj_3R_173()) jj_scanpos = xsp;
5042        if (jj_3R_38()) return true;
5043        return false;
5044      }
5045    
5046      final private boolean jj_3_13() {
5047        if (jj_scan_token(LPAREN)) return true;
5048        if (jj_3R_36()) return true;
5049        return false;
5050      }
5051    
5052      final private boolean jj_3R_187() {
5053        if (jj_3R_195()) return true;
5054        return false;
5055      }
5056    
5057      final private boolean jj_3R_186() {
5058        if (jj_3R_39()) return true;
5059        return false;
5060      }
5061    
5062      final private boolean jj_3R_33() {
5063        if (jj_3R_57()) return true;
5064        Token xsp;
5065        while (true) {
5066          xsp = jj_scanpos;
5067          if (jj_3R_58()) { jj_scanpos = xsp; break; }
5068        }
5069        return false;
5070      }
5071    
5072      final private boolean jj_3R_217() {
5073        if (jj_scan_token(LPAREN)) return true;
5074        if (jj_3R_32()) return true;
5075        if (jj_scan_token(RPAREN)) return true;
5076        if (jj_3R_208()) return true;
5077        return false;
5078      }
5079    
5080      final private boolean jj_3R_216() {
5081        if (jj_scan_token(LPAREN)) return true;
5082        if (jj_3R_32()) return true;
5083        if (jj_scan_token(RPAREN)) return true;
5084        if (jj_3R_191()) return true;
5085        return false;
5086      }
5087    
5088      final private boolean jj_3R_117() {
5089        if (jj_scan_token(FOR)) return true;
5090        if (jj_scan_token(LPAREN)) return true;
5091        Token xsp;
5092        xsp = jj_scanpos;
5093        if (jj_3R_185()) jj_scanpos = xsp;
5094        if (jj_scan_token(SEMICOLON)) return true;
5095        xsp = jj_scanpos;
5096        if (jj_3R_186()) jj_scanpos = xsp;
5097        if (jj_scan_token(SEMICOLON)) return true;
5098        xsp = jj_scanpos;
5099        if (jj_3R_187()) jj_scanpos = xsp;
5100        if (jj_scan_token(RPAREN)) return true;
5101        if (jj_3R_45()) return true;
5102        return false;
5103      }
5104    
5105      final private boolean jj_3R_214() {
5106        Token xsp;
5107        xsp = jj_scanpos;
5108        if (jj_3R_216()) {
5109        jj_scanpos = xsp;
5110        if (jj_3R_217()) return true;
5111        }
5112        return false;
5113      }
5114    
5115      final private boolean jj_3_12() {
5116        if (jj_3R_33()) return true;
5117        Token xsp;
5118        xsp = jj_scanpos;
5119        if (jj_scan_token(100)) {
5120        jj_scanpos = xsp;
5121        if (jj_scan_token(101)) return true;
5122        }
5123        return false;
5124      }
5125    
5126      final private boolean jj_3R_219() {
5127        if (jj_3R_33()) return true;
5128        return false;
5129      }
5130    
5131      final private boolean jj_3R_116() {
5132        if (jj_scan_token(DO)) return true;
5133        if (jj_3R_45()) return true;
5134        if (jj_scan_token(WHILE)) return true;
5135        if (jj_scan_token(LPAREN)) return true;
5136        if (jj_3R_39()) return true;
5137        if (jj_scan_token(RPAREN)) return true;
5138        if (jj_scan_token(SEMICOLON)) return true;
5139        return false;
5140      }
5141    
5142      final private boolean jj_3_11() {
5143        if (jj_scan_token(LPAREN)) return true;
5144        if (jj_3R_29()) return true;
5145        if (jj_scan_token(LBRACKET)) return true;
5146        return false;
5147      }
5148    
5149      final private boolean jj_3R_218() {
5150        if (jj_3R_33()) return true;
5151        Token xsp;
5152        xsp = jj_scanpos;
5153        if (jj_scan_token(100)) {
5154        jj_scanpos = xsp;
5155        if (jj_scan_token(101)) return true;
5156        }
5157        return false;
5158      }
5159    
5160      final private boolean jj_3R_215() {
5161        Token xsp;
5162        xsp = jj_scanpos;
5163        if (jj_3R_218()) {
5164        jj_scanpos = xsp;
5165        if (jj_3R_219()) return true;
5166        }
5167        return false;
5168      }
5169    
5170      final private boolean jj_3R_72() {
5171        Token xsp;
5172        xsp = jj_scanpos;
5173        if (jj_scan_token(43)) {
5174        jj_scanpos = xsp;
5175        if (jj_scan_token(44)) {
5176        jj_scanpos = xsp;
5177        if (jj_scan_token(45)) {
5178        jj_scanpos = xsp;
5179        if (jj_scan_token(51)) {
5180        jj_scanpos = xsp;
5181        if (jj_scan_token(27)) {
5182        jj_scanpos = xsp;
5183        if (jj_scan_token(39)) {
5184        jj_scanpos = xsp;
5185        if (jj_scan_token(52)) {
5186        jj_scanpos = xsp;
5187        if (jj_scan_token(58)) {
5188        jj_scanpos = xsp;
5189        if (jj_scan_token(10)) {
5190        jj_scanpos = xsp;
5191        if (jj_scan_token(48)) {
5192        jj_scanpos = xsp;
5193        if (jj_scan_token(49)) return true;
5194        }
5195        }
5196        }
5197        }
5198        }
5199        }
5200        }
5201        }
5202        }
5203        }
5204        return false;
5205      }
5206    
5207      final private boolean jj_3R_115() {
5208        if (jj_scan_token(WHILE)) return true;
5209        if (jj_scan_token(LPAREN)) return true;
5210        if (jj_3R_39()) return true;
5211        if (jj_scan_token(RPAREN)) return true;
5212        if (jj_3R_45()) return true;
5213        return false;
5214      }
5215    
5216      final private boolean jj_3R_60() {
5217        if (jj_scan_token(LPAREN)) return true;
5218        if (jj_3R_29()) return true;
5219        if (jj_scan_token(RPAREN)) return true;
5220        Token xsp;
5221        xsp = jj_scanpos;
5222        if (jj_scan_token(87)) {
5223        jj_scanpos = xsp;
5224        if (jj_scan_token(86)) {
5225        jj_scanpos = xsp;
5226        if (jj_scan_token(72)) {
5227        jj_scanpos = xsp;
5228        if (jj_scan_token(69)) {
5229        jj_scanpos = xsp;
5230        if (jj_scan_token(40)) {
5231        jj_scanpos = xsp;
5232        if (jj_3R_105()) return true;
5233        }
5234        }
5235        }
5236        }
5237        }
5238        return false;
5239      }
5240    
5241      final private boolean jj_3R_59() {
5242        if (jj_scan_token(LPAREN)) return true;
5243        if (jj_3R_29()) return true;
5244        if (jj_scan_token(LBRACKET)) return true;
5245        if (jj_scan_token(RBRACKET)) return true;
5246        return false;
5247      }
5248    
5249      final private boolean jj_3_9() {
5250        if (jj_3R_35()) return true;
5251        return false;
5252      }
5253    
5254      final private boolean jj_3_29() {
5255        if (jj_3R_28()) return true;
5256        return false;
5257      }
5258    
5259      final private boolean jj_3R_114() {
5260        if (jj_scan_token(IF)) return true;
5261        if (jj_scan_token(LPAREN)) return true;
5262        if (jj_3R_39()) return true;
5263        if (jj_scan_token(RPAREN)) return true;
5264        if (jj_3R_45()) return true;
5265        Token xsp;
5266        xsp = jj_scanpos;
5267        if (jj_3R_184()) jj_scanpos = xsp;
5268        return false;
5269      }
5270    
5271      final private boolean jj_3R_41() {
5272        Token xsp;
5273        while (true) {
5274          xsp = jj_scanpos;
5275          if (jj_3R_72()) { jj_scanpos = xsp; break; }
5276        }
5277        return false;
5278      }
5279    
5280      final private boolean jj_3R_35() {
5281        Token xsp;
5282        xsp = jj_scanpos;
5283        if (jj_3_10()) {
5284        jj_scanpos = xsp;
5285        if (jj_3R_59()) {
5286        jj_scanpos = xsp;
5287        if (jj_3R_60()) return true;
5288        }
5289        }
5290        return false;
5291      }
5292    
5293      final private boolean jj_3_10() {
5294        if (jj_scan_token(LPAREN)) return true;
5295        if (jj_3R_36()) return true;
5296        return false;
5297      }
5298    
5299      final private boolean jj_3R_213() {
5300        if (jj_3R_215()) return true;
5301        return false;
5302      }
5303    
5304      final private boolean jj_3R_212() {
5305        if (jj_3R_214()) return true;
5306        return false;
5307      }
5308    
5309      final private boolean jj_3R_202() {
5310        if (jj_scan_token(_DEFAULT)) return true;
5311        if (jj_scan_token(COLON)) return true;
5312        return false;
5313      }
5314    
5315      final private boolean jj_3R_211() {
5316        Token xsp;
5317        xsp = jj_scanpos;
5318        if (jj_scan_token(87)) {
5319        jj_scanpos = xsp;
5320        if (jj_scan_token(86)) return true;
5321        }
5322        if (jj_3R_191()) return true;
5323        return false;
5324      }
5325    
5326      final private boolean jj_3R_208() {
5327        Token xsp;
5328        xsp = jj_scanpos;
5329        if (jj_3R_211()) {
5330        jj_scanpos = xsp;
5331        if (jj_3R_212()) {
5332        jj_scanpos = xsp;
5333        if (jj_3R_213()) return true;
5334        }
5335        }
5336        return false;
5337      }
5338    
5339      final private boolean jj_3R_201() {
5340        if (jj_scan_token(CASE)) return true;
5341        if (jj_3R_39()) return true;
5342        if (jj_scan_token(COLON)) return true;
5343        return false;
5344      }
5345    
5346      final private boolean jj_3R_193() {
5347        Token xsp;
5348        xsp = jj_scanpos;
5349        if (jj_3R_201()) {
5350        jj_scanpos = xsp;
5351        if (jj_3R_202()) return true;
5352        }
5353        return false;
5354      }
5355    
5356      final private boolean jj_3R_183() {
5357        if (jj_3R_193()) return true;
5358        Token xsp;
5359        while (true) {
5360          xsp = jj_scanpos;
5361          if (jj_3_29()) { jj_scanpos = xsp; break; }
5362        }
5363        return false;
5364      }
5365    
5366      final private boolean jj_3R_207() {
5367        if (jj_scan_token(DECR)) return true;
5368        if (jj_3R_33()) return true;
5369        return false;
5370      }
5371    
5372      final private boolean jj_3_1() {
5373        if (jj_3R_28()) return true;
5374        return false;
5375      }
5376    
5377      final private boolean jj_3R_113() {
5378        if (jj_scan_token(SWITCH)) return true;
5379        if (jj_scan_token(LPAREN)) return true;
5380        if (jj_3R_39()) return true;
5381        if (jj_scan_token(RPAREN)) return true;
5382        if (jj_scan_token(LBRACE)) return true;
5383        Token xsp;
5384        while (true) {
5385          xsp = jj_scanpos;
5386          if (jj_3R_183()) { jj_scanpos = xsp; break; }
5387        }
5388        if (jj_scan_token(RBRACE)) return true;
5389        return false;
5390      }
5391    
5392      final private boolean jj_3R_209() {
5393        Token xsp;
5394        xsp = jj_scanpos;
5395        if (jj_scan_token(104)) {
5396        jj_scanpos = xsp;
5397        if (jj_scan_token(105)) {
5398        jj_scanpos = xsp;
5399        if (jj_scan_token(111)) return true;
5400        }
5401        }
5402        if (jj_3R_191()) return true;
5403        return false;
5404      }
5405    
5406      final private boolean jj_3R_206() {
5407        if (jj_scan_token(INCR)) return true;
5408        if (jj_3R_33()) return true;
5409        return false;
5410      }
5411    
5412      final private boolean jj_3R_199() {
5413        if (jj_3R_208()) return true;
5414        return false;
5415      }
5416    
5417      final private boolean jj_3R_198() {
5418        if (jj_3R_207()) return true;
5419        return false;
5420      }
5421    
5422      final private boolean jj_3R_197() {
5423        if (jj_3R_206()) return true;
5424        return false;
5425      }
5426    
5427      final private boolean jj_3R_196() {
5428        Token xsp;
5429        xsp = jj_scanpos;
5430        if (jj_scan_token(102)) {
5431        jj_scanpos = xsp;
5432        if (jj_scan_token(103)) return true;
5433        }
5434        if (jj_3R_191()) return true;
5435        return false;
5436      }
5437    
5438      final private boolean jj_3R_191() {
5439        Token xsp;
5440        xsp = jj_scanpos;
5441        if (jj_3R_196()) {
5442        jj_scanpos = xsp;
5443        if (jj_3R_197()) {
5444        jj_scanpos = xsp;
5445        if (jj_3R_198()) {
5446        jj_scanpos = xsp;
5447        if (jj_3R_199()) return true;
5448        }
5449        }
5450        }
5451        return false;
5452      }
5453    
5454      final private boolean jj_3R_44() {
5455        if (jj_scan_token(THROWS)) return true;
5456        if (jj_3R_76()) return true;
5457        return false;
5458      }
5459    
5460      final private boolean jj_3R_112() {
5461        if (jj_3R_39()) return true;
5462        return false;
5463      }
5464    
5465      final private boolean jj_3R_181() {
5466        if (jj_3R_191()) return true;
5467        Token xsp;
5468        while (true) {
5469          xsp = jj_scanpos;
5470          if (jj_3R_209()) { jj_scanpos = xsp; break; }
5471        }
5472        return false;
5473      }
5474    
5475      final private boolean jj_3R_200() {
5476        Token xsp;
5477        xsp = jj_scanpos;
5478        if (jj_scan_token(102)) {
5479        jj_scanpos = xsp;
5480        if (jj_scan_token(103)) return true;
5481        }
5482        if (jj_3R_181()) return true;
5483        return false;
5484      }
5485    
5486      final private boolean jj_3R_178() {
5487        if (jj_3R_181()) return true;
5488        Token xsp;
5489        while (true) {
5490          xsp = jj_scanpos;
5491          if (jj_3R_200()) { jj_scanpos = xsp; break; }
5492        }
5493        return false;
5494      }
5495    
5496      final private boolean jj_3R_96() {
5497        if (jj_scan_token(FORMAL_COMMENT)) return true;
5498        return false;
5499      }
5500    
5501      final private boolean jj_3R_192() {
5502        Token xsp;
5503        xsp = jj_scanpos;
5504        if (jj_scan_token(112)) {
5505        jj_scanpos = xsp;
5506        if (jj_scan_token(113)) {
5507        jj_scanpos = xsp;
5508        if (jj_scan_token(114)) {
5509        jj_scanpos = xsp;
5510        if (jj_scan_token(115)) {
5511        jj_scanpos = xsp;
5512        if (jj_scan_token(116)) {
5513        jj_scanpos = xsp;
5514        if (jj_scan_token(117)) return true;
5515        }
5516        }
5517        }
5518        }
5519        }
5520        if (jj_3R_178()) return true;
5521        return false;
5522      }
5523    
5524      final private boolean jj_3R_171() {
5525        Token xsp;
5526        xsp = jj_scanpos;
5527        if (jj_scan_token(90)) {
5528        jj_scanpos = xsp;
5529        if (jj_scan_token(95)) return true;
5530        }
5531        if (jj_3R_166()) return true;
5532        return false;
5533      }
5534    
5535      final private boolean jj_3R_170() {
5536        if (jj_3R_178()) return true;
5537        Token xsp;
5538        while (true) {
5539          xsp = jj_scanpos;
5540          if (jj_3R_192()) { jj_scanpos = xsp; break; }
5541        }
5542        return false;
5543      }
5544    
5545      final private boolean jj_3R_52() {
5546        if (jj_3R_96()) return true;
5547        return false;
5548      }
5549    
5550      final private boolean jj_3R_182() {
5551        Token xsp;
5552        xsp = jj_scanpos;
5553        if (jj_scan_token(84)) {
5554        jj_scanpos = xsp;
5555        if (jj_scan_token(85)) {
5556        jj_scanpos = xsp;
5557        if (jj_scan_token(82)) {
5558        jj_scanpos = xsp;
5559        if (jj_scan_token(83)) {
5560        jj_scanpos = xsp;
5561        if (jj_scan_token(91)) {
5562        jj_scanpos = xsp;
5563        if (jj_scan_token(92)) {
5564        jj_scanpos = xsp;
5565        if (jj_scan_token(93)) {
5566        jj_scanpos = xsp;
5567        if (jj_scan_token(94)) return true;
5568        }
5569        }
5570        }
5571        }
5572        }
5573        }
5574        }
5575        if (jj_3R_170()) return true;
5576        return false;
5577      }
5578    
5579      final private boolean jj_3_27() {
5580        if (jj_3R_41()) return true;
5581        if (jj_3R_32()) return true;
5582        if (jj_scan_token(IDENTIFIER)) return true;
5583        return false;
5584      }
5585    
5586      final private boolean jj_3R_51() {
5587        if (jj_3R_95()) return true;
5588        return false;
5589      }
5590    
5591      final private boolean jj_3R_168() {
5592        if (jj_3R_170()) return true;
5593        Token xsp;
5594        while (true) {
5595          xsp = jj_scanpos;
5596          if (jj_3R_182()) { jj_scanpos = xsp; break; }
5597        }
5598        return false;
5599      }
5600    
5601      final private boolean jj_3R_50() {
5602        if (jj_3R_94()) return true;
5603        return false;
5604      }
5605    
5606      final private boolean jj_3_26() {
5607        if (jj_3R_41()) return true;
5608        if (jj_scan_token(IDENTIFIER)) return true;
5609        if (jj_3R_43()) return true;
5610        Token xsp;
5611        xsp = jj_scanpos;
5612        if (jj_3R_44()) jj_scanpos = xsp;
5613        if (jj_scan_token(LBRACE)) return true;
5614        return false;
5615      }
5616    
5617      final private boolean jj_3R_179() {
5618        if (jj_scan_token(INSTANCEOF)) return true;
5619        if (jj_3R_32()) return true;
5620        return false;
5621      }
5622    
5623      final private boolean jj_3_28() {
5624        if (jj_3R_45()) return true;
5625        return false;
5626      }
5627    
5628      final private boolean jj_3R_166() {
5629        if (jj_3R_168()) return true;
5630        Token xsp;
5631        xsp = jj_scanpos;
5632        if (jj_3R_179()) jj_scanpos = xsp;
5633        return false;
5634      }
5635    
5636      final private boolean jj_3_25() {
5637        if (jj_3R_41()) return true;
5638        if (jj_3R_42()) return true;
5639        if (jj_scan_token(IDENTIFIER)) return true;
5640        if (jj_scan_token(LPAREN)) return true;
5641        return false;
5642      }
5643    
5644      final private boolean jj_3R_49() {
5645        if (jj_3R_93()) return true;
5646        if (jj_scan_token(SEMICOLON)) return true;
5647        return false;
5648      }
5649    
5650      final private boolean jj_3_24() {
5651        if (jj_3R_41()) return true;
5652        Token xsp;
5653        xsp = jj_scanpos;
5654        if (jj_scan_token(13)) {
5655        jj_scanpos = xsp;
5656        if (jj_scan_token(37)) return true;
5657        }
5658        return false;
5659      }
5660    
5661      final private boolean jj_3R_167() {
5662        if (jj_scan_token(XOR)) return true;
5663        if (jj_3R_161()) return true;
5664        return false;
5665      }
5666    
5667      final private boolean jj_3R_48() {
5668        if (jj_3R_92()) return true;
5669        return false;
5670      }
5671    
5672      final private boolean jj_3R_164() {
5673        if (jj_3R_166()) return true;
5674        Token xsp;
5675        while (true) {
5676          xsp = jj_scanpos;
5677          if (jj_3R_171()) { jj_scanpos = xsp; break; }
5678        }
5679        return false;
5680      }
5681    
5682      final private boolean jj_3R_47() {
5683        if (jj_3R_92()) return true;
5684        return false;
5685      }
5686    
5687      final private boolean jj_3R_169() {
5688        Token xsp;
5689        xsp = jj_scanpos;
5690        if (jj_scan_token(106)) {
5691        jj_scanpos = xsp;
5692        if (jj_scan_token(107)) return true;
5693        }
5694        if (jj_3R_164()) return true;
5695        return false;
5696      }
5697    
5698      public ParserTokenManager token_source;
5699      JavaCharStream jj_input_stream;
5700      public Token token, jj_nt;
5701      private int jj_ntk;
5702      private Token jj_scanpos, jj_lastpos;
5703      private int jj_la;
5704      public boolean lookingAhead = false;
5705      private boolean jj_semLA;
5706    
5707      public Parser(java.io.InputStream stream) {
5708        jj_input_stream = new JavaCharStream(stream, 1, 1);
5709        token_source = new ParserTokenManager(jj_input_stream);
5710        token = new Token();
5711        jj_ntk = -1;
5712      }
5713    
5714      public void ReInit(java.io.InputStream stream) {
5715        jj_input_stream.ReInit(stream, 1, 1);
5716        token_source.ReInit(jj_input_stream);
5717        token = new Token();
5718        jj_ntk = -1;
5719        jjtree.reset();
5720      }
5721    
5722      public Parser(java.io.Reader stream) {
5723        jj_input_stream = new JavaCharStream(stream, 1, 1);
5724        token_source = new ParserTokenManager(jj_input_stream);
5725        token = new Token();
5726        jj_ntk = -1;
5727      }
5728    
5729      public void ReInit(java.io.Reader stream) {
5730        jj_input_stream.ReInit(stream, 1, 1);
5731        token_source.ReInit(jj_input_stream);
5732        token = new Token();
5733        jj_ntk = -1;
5734        jjtree.reset();
5735      }
5736    
5737      public Parser(ParserTokenManager tm) {
5738        token_source = tm;
5739        token = new Token();
5740        jj_ntk = -1;
5741      }
5742    
5743      public void ReInit(ParserTokenManager tm) {
5744        token_source = tm;
5745        token = new Token();
5746        jj_ntk = -1;
5747        jjtree.reset();
5748      }
5749    
5750      final private Token jj_consume_token(int kind) throws ParseException {
5751        Token oldToken;
5752        if ((oldToken = token).next != null) token = token.next;
5753        else token = token.next = token_source.getNextToken();
5754        jj_ntk = -1;
5755        if (token.kind == kind) {
5756          return token;
5757        }
5758        token = oldToken;
5759        throw generateParseException();
5760      }
5761    
5762      static private final class LookaheadSuccess extends java.lang.Error { }
5763      final private LookaheadSuccess jj_ls = new LookaheadSuccess();
5764      final private boolean jj_scan_token(int kind) {
5765        if (jj_scanpos == jj_lastpos) {
5766          jj_la--;
5767          if (jj_scanpos.next == null) {
5768            jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
5769          } else {
5770            jj_lastpos = jj_scanpos = jj_scanpos.next;
5771          }
5772        } else {
5773          jj_scanpos = jj_scanpos.next;
5774        }
5775        if (jj_scanpos.kind != kind) return true;
5776        if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
5777        return false;
5778      }
5779    
5780      final public Token getNextToken() {
5781        if (token.next != null) token = token.next;
5782        else token = token.next = token_source.getNextToken();
5783        jj_ntk = -1;
5784        return token;
5785      }
5786    
5787      final public Token getToken(int index) {
5788        Token t = lookingAhead ? jj_scanpos : token;
5789        for (int i = 0; i < index; i++) {
5790          if (t.next != null) t = t.next;
5791          else t = t.next = token_source.getNextToken();
5792        }
5793        return t;
5794      }
5795    
5796      final private int jj_ntk() {
5797        if ((jj_nt=token.next) == null)
5798          return (jj_ntk = (token.next=token_source.getNextToken()).kind);
5799        else
5800          return (jj_ntk = jj_nt.kind);
5801      }
5802    
5803      public ParseException generateParseException() {
5804        Token errortok = token.next;
5805        int line = errortok.beginLine, column = errortok.beginColumn;
5806        String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
5807        ParseException ex = new ParseException("Parse error at line " + line + ", column " + column + ".  Encountered: " + mess);
5808        ex.currentToken = token;
5809        return ex;
5810      }
5811    
5812      final public void enable_tracing() {
5813      }
5814    
5815      final public void disable_tracing() {
5816      }
5817    
5818    }