1   /* Generated By:JavaCC: Do not edit this line. JavaCCParser.java */
2   package jminusminus;
3   
4   import java.util.ArrayList;
5   
6   /**
7    * Parser generated by JavaCC. It parses a j-- compilation unit 
8    * (program file), taking tokens from the scanner (also generated by 
9    * JavaCC), and produces an abstract syntax tree (AST) for it.
10   */
11  
12  class JavaCCParser implements JavaCCParserConstants {
13      /** Whether a parser error has been found. */
14      private boolean errorHasOccurred;
15  
16      /** Name of the file that is parsed. */
17      private String fileName;
18  
19      /**
20       * Pull out the ambiguous part of a name and return it. 
21       * 
22       * @param name with an ambiguos part (possibly).
23       * @return ambiguous part or null.
24       */
25  
26      private AmbiguousName ambiguousPart( TypeName name ) {
27          String qualifiedName = name.toString();
28          int lastDotIndex = qualifiedName.lastIndexOf( '.' );
29          return lastDotIndex == -1
30              ? null // It was a simple name
31              : new AmbiguousName( name.line(),
32                  qualifiedName.substring( 0, lastDotIndex ) );
33      }
34  
35      /**
36       * Report a syntax error.
37       * 
38       * @param message message identifying the error.
39       * @param args related values.
40       */
41  
42      private void reportParserError( String message, Object... args ) {
43          errorHasOccurred = true;
44          System.err.printf( "%s:%d: ", fileName, token.beginLine );
45          System.err.printf( message, args );
46          System.err.println();
47      }
48  
49      /**
50       * Recover from the parser error that occurred by skipping to 
51       * any of the specified tokens. 
52       *
53       * Current error recovery mechanism is rather simple-minded and is 
54       * based on skipping all the tokens until a SEMI or an EOF is 
55       * encountered. This scheme can be enhanced by passing in the 
56       * FOLLOW-SET of the non-terminal at hand.
57       * 
58       * @param skipTo array of tokens that we could skip to.
59       * @param e exception that is raised by JavaCC in the event 
60       * of a parser error.
61       */
62  
63      private void recoverFromError( int[] skipTo, ParseException e ) {
64          // Get the possible expected tokens
65          StringBuffer expected = new StringBuffer();
66          for ( int i = 0; i < e.expectedTokenSequences.length; i++ ) {
67              for ( int j = 0; j < e.expectedTokenSequences[ i ].length;
68                  j++ ) {
69                  expected.append( "\n" );
70                  expected.append( "    " );
71                  expected.append( tokenImage[
72                      e.expectedTokenSequences[ i ][ j ] ] );
73                  expected.append( "..." );
74              }
75          }
76  
77          // Print error message
78          if ( e.expectedTokenSequences.length == 1 ) {
79              reportParserError( "\"%s\" found where %s sought",
80                  getToken( 1 ), expected );
81          }
82          else {
83              reportParserError( "\"%s\" found where one of %s sought",
84                  getToken( 1 ), expected );
85          }
86  
87          // Recover
88          boolean loop = true;
89          do {
90              token = getNextToken();
91              for ( int i = 0; i < skipTo.length; i++ ) {
92                  if ( token.kind == skipTo[ i ] ) {
93                      loop = false;
94                      break;
95                  }
96              }
97          } while( loop );
98      }
99  
100     /** 
101      * Set the name of the file that is being parsed. 
102      *
103      * @param fileName name of the file.
104      */
105 
106     public void fileName( String fileName ) {
107         this.fileName = fileName;
108     }
109 
110     /**
111      * Has a parser error occurred up to now?
112      * 
113      * @return true or false.
114      */
115 
116     public boolean errorHasOccurred() {
117         return errorHasOccurred;
118     }
119 
120   final public JCompilationUnit compilationUnit() throws ParseException {
121     int line = 0;
122     TypeName packageName = null; // Default
123     TypeName anImport = null;
124     ArrayList<TypeName> imports =
125         new ArrayList<TypeName>();
126     JAST aTypeDeclaration = null;
127     ArrayList<JAST> typeDeclarations = new ArrayList<JAST>();
128     try {
129       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
130       case PACKAGE:
131         jj_consume_token(PACKAGE);
132                         line = token.beginLine;
133         packageName = qualifiedIdentifier();
134         jj_consume_token(SEMI);
135         break;
136       default:
137         jj_la1[0] = jj_gen;
138         ;
139       }
140       label_1:
141       while (true) {
142         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
143         case IMPORT:
144           ;
145           break;
146         default:
147           jj_la1[1] = jj_gen;
148           break label_1;
149         }
150         jj_consume_token(IMPORT);
151                        line = line == 0 ? token.beginLine : line;
152         anImport = qualifiedIdentifier();
153               imports.add( anImport );
154         jj_consume_token(SEMI);
155       }
156       label_2:
157       while (true) {
158         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
159         case ABSTRACT:
160         case CLASS:
161         case PRIVATE:
162         case PROTECTED:
163         case PUBLIC:
164         case STATIC:
165           ;
166           break;
167         default:
168           jj_la1[2] = jj_gen;
169           break label_2;
170         }
171         aTypeDeclaration = typeDeclaration();
172                 line = line == 0 ? aTypeDeclaration.line() : line;
173                 typeDeclarations.add( aTypeDeclaration );
174       }
175       jj_consume_token(0);
176                 line = line == 0 ? token.beginLine : line;
177     } catch (ParseException e) {
178         recoverFromError( new int[] { SEMI, EOF }, e );
179     }
180         {if (true) return new JCompilationUnit( fileName, line,
181             packageName, imports, typeDeclarations );}
182     throw new Error("Missing return statement in function");
183   }
184 
185   final private TypeName qualifiedIdentifier() throws ParseException {
186     int line = 0;
187     String qualifiedIdentifier = "";
188     try {
189       jj_consume_token(IDENTIFIER);
190             line = token.beginLine;
191             qualifiedIdentifier = token.image;
192       label_3:
193       while (true) {
194         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
195         case DOT:
196           ;
197           break;
198         default:
199           jj_la1[3] = jj_gen;
200           break label_3;
201         }
202         jj_consume_token(DOT);
203         jj_consume_token(IDENTIFIER);
204               qualifiedIdentifier += "." + token.image;
205       }
206     } catch (ParseException e) {
207         recoverFromError( new int[] { SEMI, EOF }, e );
208     }
209       {if (true) return
210          new TypeName( line, qualifiedIdentifier );}
211     throw new Error("Missing return statement in function");
212   }
213 
214   final private JAST typeDeclaration() throws ParseException {
215     ArrayList<String> mods = null;
216     JAST classDeclaration = null;
217     try {
218       mods = modifiers();
219       classDeclaration = classDeclaration(mods);
220     } catch (ParseException e) {
221         recoverFromError( new int[] { SEMI, EOF }, e );
222     }
223       {if (true) return classDeclaration;}
224     throw new Error("Missing return statement in function");
225   }
226 
227   final private ArrayList<String> modifiers() throws ParseException {
228     ArrayList<String> mods = new ArrayList<String>();
229     boolean scannedPUBLIC = false;
230     boolean scannedPROTECTED = false;
231     boolean scannedPRIVATE = false;
232     boolean scannedSTATIC = false;
233     boolean scannedABSTRACT = false;
234     try {
235       label_4:
236       while (true) {
237         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
238         case ABSTRACT:
239         case PRIVATE:
240         case PROTECTED:
241         case PUBLIC:
242         case STATIC:
243           ;
244           break;
245         default:
246           jj_la1[4] = jj_gen;
247           break label_4;
248         }
249         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
250         case PUBLIC:
251           jj_consume_token(PUBLIC);
252             mods.add( "public" );
253             if ( scannedPUBLIC ) {
254                 reportParserError( "Repeated modifier: public" );
255             }
256             if ( scannedPROTECTED || scannedPRIVATE ) {
257                 reportParserError( "Access conflict in modifiers" );
258             }
259             scannedPUBLIC = true;
260           break;
261         case PROTECTED:
262           jj_consume_token(PROTECTED);
263             mods.add( "protected" );
264             if ( scannedPROTECTED ) {
265                 reportParserError( "Repeated modifier: protected" );
266             }
267             if ( scannedPUBLIC || scannedPRIVATE ) {
268                 reportParserError( "Access conflict in modifiers" );
269             }
270             scannedPROTECTED = true;
271           break;
272         case PRIVATE:
273           jj_consume_token(PRIVATE);
274             mods.add( "private" );
275             if ( scannedPRIVATE ) {
276                 reportParserError( "Repeated modifier: private" );
277             }
278             if ( scannedPUBLIC || scannedPROTECTED ) {
279                 reportParserError( "Access conflict in modifiers" );
280             }
281             scannedPRIVATE = true;
282           break;
283         case STATIC:
284           jj_consume_token(STATIC);
285             mods.add( "static" );
286             if ( scannedSTATIC ) {
287                 reportParserError( "Repeated modifier: static" );
288             }
289             scannedSTATIC = true;
290           break;
291         case ABSTRACT:
292           jj_consume_token(ABSTRACT);
293             mods.add( "abstract" );
294             if ( scannedABSTRACT ) {
295                 reportParserError( "Repeated modifier: abstract" );
296             }
297             scannedABSTRACT = true;
298           break;
299         default:
300           jj_la1[5] = jj_gen;
301           jj_consume_token(-1);
302           throw new ParseException();
303         }
304       }
305     } catch (ParseException e) {
306         recoverFromError( new int[] { SEMI, EOF }, e );
307     }
308       {if (true) return mods;}
309     throw new Error("Missing return statement in function");
310   }
311 
312   final private JClassDeclaration classDeclaration(ArrayList<String> mods) throws ParseException {
313     int line = 0;
314     String name = "";
315     Type superClass = Type.OBJECT;
316     ArrayList<JMember> classBody = null;
317     try {
318       jj_consume_token(CLASS);
319                   line = token.beginLine;
320       jj_consume_token(IDENTIFIER);
321                        name = token.image;
322       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
323       case EXTENDS:
324         jj_consume_token(EXTENDS);
325         superClass = qualifiedIdentifier();
326         break;
327       default:
328         jj_la1[6] = jj_gen;
329         ;
330       }
331       classBody = classBody();
332     } catch (ParseException e) {
333         recoverFromError( new int[] { SEMI, EOF }, e );
334     }
335         {if (true) return new JClassDeclaration( line, mods,
336             name, superClass, classBody );}
337     throw new Error("Missing return statement in function");
338   }
339 
340   final private ArrayList<JMember> classBody() throws ParseException {
341     ArrayList<String> mods = null;
342     JMember aMember = null;
343     ArrayList<JMember> members = new ArrayList<JMember>();
344     try {
345       jj_consume_token(LCURLY);
346       label_5:
347       while (true) {
348         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
349         case ABSTRACT:
350         case BOOLEAN:
351         case CHAR:
352         case INT:
353         case PRIVATE:
354         case PROTECTED:
355         case PUBLIC:
356         case STATIC:
357         case VOID:
358         case IDENTIFIER:
359           ;
360           break;
361         default:
362           jj_la1[7] = jj_gen;
363           break label_5;
364         }
365         mods = modifiers();
366         aMember = memberDecl(mods);
367                                            members.add( aMember );
368       }
369       jj_consume_token(RCURLY);
370     } catch (ParseException e) {
371         recoverFromError( new int[] { SEMI, EOF }, e );
372     }
373       {if (true) return members;}
374     throw new Error("Missing return statement in function");
375   }
376 
377   final private JMember memberDecl(ArrayList<String>  mods) throws ParseException {
378     int line = 0;
379     Type type = null;
380     String name = "";
381     ArrayList<JFormalParameter> params = null;
382     JBlock body = null;
383     ArrayList<JVariableDeclarator> variableDeclarators = null;
384     JMember memberDecl = null;
385     try {
386       if (jj_2_1(2147483647)) {
387         jj_consume_token(IDENTIFIER);
388                 line = token.beginLine;
389                 name = token.image;
390         params = formalParameters();
391         body = block();
392                 memberDecl =
393                 new JConstructorDeclaration( line, mods,
394                                              name, params, body );
395       } else if (jj_2_2(2147483647)) {
396         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
397         case VOID:
398           jj_consume_token(VOID);
399                          type = Type.VOID;
400           break;
401         case BOOLEAN:
402         case CHAR:
403         case INT:
404         case IDENTIFIER:
405           type = type();
406           break;
407         default:
408           jj_la1[8] = jj_gen;
409           jj_consume_token(-1);
410           throw new ParseException();
411         }
412               line = token.beginLine;
413         jj_consume_token(IDENTIFIER);
414                            name = token.image;
415         params = formalParameters();
416         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
417         case LCURLY:
418           body = block();
419           break;
420         case SEMI:
421           jj_consume_token(SEMI);
422           break;
423         default:
424           jj_la1[9] = jj_gen;
425           jj_consume_token(-1);
426           throw new ParseException();
427         }
428                 memberDecl =
429                    new JMethodDeclaration( line, mods, name,
430                                            type, params, body );
431       } else {
432         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
433         case BOOLEAN:
434         case CHAR:
435         case INT:
436         case IDENTIFIER:
437           type = type();
438                             line = token.beginLine;
439           variableDeclarators = variableDeclarators(type);
440           jj_consume_token(SEMI);
441                 memberDecl = new JFieldDeclaration( line, mods,
442                     variableDeclarators );
443           break;
444         default:
445           jj_la1[10] = jj_gen;
446           jj_consume_token(-1);
447           throw new ParseException();
448         }
449       }
450     } catch (ParseException e) {
451         recoverFromError( new int[] { SEMI, EOF }, e );
452     }
453       {if (true) return memberDecl;}
454     throw new Error("Missing return statement in function");
455   }
456 
457   final private JBlock block() throws ParseException {
458     int line = 0;
459     JStatement aStatement = null;
460     ArrayList<JStatement> statements = new ArrayList<JStatement>();
461     try {
462       jj_consume_token(LCURLY);
463                    line = token.beginLine;
464       label_6:
465       while (true) {
466         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
467         case BOOLEAN:
468         case CHAR:
469         case FALSE:
470         case IF:
471         case INT:
472         case NEW:
473         case NULL:
474         case RETURN:
475         case SUPER:
476         case THIS:
477         case TRUE:
478         case WHILE:
479         case INC:
480         case LNOT:
481         case MINUS:
482         case LPAREN:
483         case LCURLY:
484         case SEMI:
485         case IDENTIFIER:
486         case INT_LITERAL:
487         case CHAR_LITERAL:
488         case STRING_LITERAL:
489           ;
490           break;
491         default:
492           jj_la1[11] = jj_gen;
493           break label_6;
494         }
495         aStatement = blockStatement();
496               statements.add( aStatement );
497       }
498       jj_consume_token(RCURLY);
499     } catch (ParseException e) {
500         recoverFromError( new int[] { SEMI, EOF }, e );
501     }
502       {if (true) return new JBlock( line, statements );}
503     throw new Error("Missing return statement in function");
504   }
505 
506   final private JStatement blockStatement() throws ParseException {
507     JStatement statement = null;
508     try {
509       if (jj_2_3(2147483647)) {
510         statement = localVariableDeclarationStatement();
511       } else {
512         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
513         case FALSE:
514         case IF:
515         case NEW:
516         case NULL:
517         case RETURN:
518         case SUPER:
519         case THIS:
520         case TRUE:
521         case WHILE:
522         case INC:
523         case LNOT:
524         case MINUS:
525         case LPAREN:
526         case LCURLY:
527         case SEMI:
528         case IDENTIFIER:
529         case INT_LITERAL:
530         case CHAR_LITERAL:
531         case STRING_LITERAL:
532           statement = statement();
533           break;
534         default:
535           jj_la1[12] = jj_gen;
536           jj_consume_token(-1);
537           throw new ParseException();
538         }
539       }
540     } catch (ParseException e) {
541         recoverFromError( new int[] { SEMI, EOF }, e );
542     }
543       {if (true) return statement;}
544     throw new Error("Missing return statement in function");
545   }
546 
547   final private JStatement statement() throws ParseException {
548     int line = 0;
549     JStatement statement = null;
550     JExpression test = null;
551     JStatement consequent = null;
552     JStatement alternate = null;
553     JStatement body = null;
554     JExpression expr = null;
555     try {
556       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
557       case LCURLY:
558         statement = block();
559         break;
560       case IF:
561         jj_consume_token(IF);
562                line = token.beginLine;
563         test = parExpression();
564         consequent = statement();
565         if (jj_2_4(2147483647)) {
566           jj_consume_token(ELSE);
567           alternate = statement();
568         } else {
569           ;
570         }
571           statement =
572             new JIfStatement( line, test, consequent, alternate );
573         break;
574       case WHILE:
575         jj_consume_token(WHILE);
576                   line = token.beginLine;
577         test = parExpression();
578         body = statement();
579           statement = new JWhileStatement( line, test, body );
580         break;
581       case RETURN:
582         jj_consume_token(RETURN);
583                    line = token.beginLine;
584         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
585         case FALSE:
586         case NEW:
587         case NULL:
588         case SUPER:
589         case THIS:
590         case TRUE:
591         case INC:
592         case LNOT:
593         case MINUS:
594         case LPAREN:
595         case IDENTIFIER:
596         case INT_LITERAL:
597         case CHAR_LITERAL:
598         case STRING_LITERAL:
599           expr = expression();
600           break;
601         default:
602           jj_la1[13] = jj_gen;
603           ;
604         }
605         jj_consume_token(SEMI);
606           statement = new JReturnStatement( line, expr );
607         break;
608       case SEMI:
609         jj_consume_token(SEMI);
610           statement = new JEmptyStatement( line );
611         break;
612       case FALSE:
613       case NEW:
614       case NULL:
615       case SUPER:
616       case THIS:
617       case TRUE:
618       case INC:
619       case LNOT:
620       case MINUS:
621       case LPAREN:
622       case IDENTIFIER:
623       case INT_LITERAL:
624       case CHAR_LITERAL:
625       case STRING_LITERAL:
626         // Must be a statementExpression
627                 statement = statementExpression();
628         jj_consume_token(SEMI);
629         break;
630       default:
631         jj_la1[14] = jj_gen;
632         jj_consume_token(-1);
633         throw new ParseException();
634       }
635     } catch (ParseException e) {
636         recoverFromError( new int[] { SEMI, EOF }, e );
637     }
638       {if (true) return statement;}
639     throw new Error("Missing return statement in function");
640   }
641 
642   final private ArrayList<JFormalParameter> formalParameters() throws ParseException {
643     ArrayList<JFormalParameter> parameters =
644         new ArrayList<JFormalParameter>();
645     JFormalParameter aParameter = null;
646     try {
647       jj_consume_token(LPAREN);
648       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
649       case BOOLEAN:
650       case CHAR:
651       case INT:
652       case IDENTIFIER:
653         aParameter = formalParameter();
654               parameters.add( aParameter );
655         label_7:
656         while (true) {
657           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
658           case COMMA:
659             ;
660             break;
661           default:
662             jj_la1[15] = jj_gen;
663             break label_7;
664           }
665           jj_consume_token(COMMA);
666           aParameter = formalParameter();
667                   parameters.add( aParameter );
668         }
669         break;
670       default:
671         jj_la1[16] = jj_gen;
672         ;
673       }
674       jj_consume_token(RPAREN);
675     } catch (ParseException e) {
676         recoverFromError( new int[] { SEMI, EOF }, e );
677     }
678       {if (true) return parameters;}
679     throw new Error("Missing return statement in function");
680   }
681 
682   final private JFormalParameter formalParameter() throws ParseException {
683     int line = 0;
684     Type type = null;
685     String name = "";
686     try {
687       type = type();
688                         line = token.beginLine;
689       jj_consume_token(IDENTIFIER);
690                        name = token.image;
691     } catch (ParseException e) {
692         recoverFromError( new int[] { SEMI, EOF }, e );
693     }
694       {if (true) return new JFormalParameter( line, name, type );}
695     throw new Error("Missing return statement in function");
696   }
697 
698   final private JExpression parExpression() throws ParseException {
699     JExpression expr = null;
700     try {
701       jj_consume_token(LPAREN);
702       expr = expression();
703       jj_consume_token(RPAREN);
704     } catch (ParseException e) {
705         recoverFromError( new int[] { SEMI, EOF }, e );
706     }
707       {if (true) return expr;}
708     throw new Error("Missing return statement in function");
709   }
710 
711   final private JVariableDeclaration localVariableDeclarationStatement() throws ParseException {
712     int line = 0;
713     Type type = null;
714     ArrayList<JVariableDeclarator> vdecls = null;
715     ArrayList<String> mods = new ArrayList<String>();
716     try {
717       type = type();
718                         line = token.beginLine;
719       vdecls = variableDeclarators(type);
720       jj_consume_token(SEMI);
721     } catch (ParseException e) {
722         recoverFromError( new int[] { SEMI, EOF }, e );
723     }
724       {if (true) return new JVariableDeclaration( line, mods, vdecls );}
725     throw new Error("Missing return statement in function");
726   }
727 
728   final private ArrayList<JVariableDeclarator> variableDeclarators(Type type) throws ParseException {
729     JVariableDeclarator aVariableDeclarator = null;
730     ArrayList<JVariableDeclarator> variableDeclarators =
731         new ArrayList<JVariableDeclarator>();
732     try {
733       aVariableDeclarator = variableDeclarator(type);
734           variableDeclarators.add( aVariableDeclarator );
735       label_8:
736       while (true) {
737         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
738         case COMMA:
739           ;
740           break;
741         default:
742           jj_la1[17] = jj_gen;
743           break label_8;
744         }
745         jj_consume_token(COMMA);
746         aVariableDeclarator = variableDeclarator(type);
747               variableDeclarators.add( aVariableDeclarator );
748       }
749     } catch (ParseException e) {
750         recoverFromError( new int[] { SEMI, EOF }, e );
751     }
752       {if (true) return variableDeclarators;}
753     throw new Error("Missing return statement in function");
754   }
755 
756   final private JVariableDeclarator variableDeclarator(Type type) throws ParseException {
757     int line = 0;
758     JExpression initial = null;
759     String name = "";
760     try {
761       jj_consume_token(IDENTIFIER);
762                        line = token.beginLine; name = token.image;
763       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
764       case ASSIGN:
765         jj_consume_token(ASSIGN);
766         initial = variableInitializer(type);
767         break;
768       default:
769         jj_la1[18] = jj_gen;
770         ;
771       }
772     } catch (ParseException e) {
773         recoverFromError( new int[] { SEMI, EOF }, e );
774     }
775       {if (true) return new JVariableDeclarator( line, name, type, initial );}
776     throw new Error("Missing return statement in function");
777   }
778 
779   final private JExpression variableInitializer(Type expected) throws ParseException {
780     JExpression initializer = null;
781     try {
782       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
783       case LCURLY:
784         initializer = arrayInitializer(expected);
785         break;
786       case FALSE:
787       case NEW:
788       case NULL:
789       case SUPER:
790       case THIS:
791       case TRUE:
792       case INC:
793       case LNOT:
794       case MINUS:
795       case LPAREN:
796       case IDENTIFIER:
797       case INT_LITERAL:
798       case CHAR_LITERAL:
799       case STRING_LITERAL:
800         initializer = expression();
801         break;
802       default:
803         jj_la1[19] = jj_gen;
804         jj_consume_token(-1);
805         throw new ParseException();
806       }
807     } catch (ParseException e) {
808         recoverFromError( new int[] { SEMI, EOF }, e );
809     }
810       {if (true) return initializer;}
811     throw new Error("Missing return statement in function");
812   }
813 
814   final private JArrayInitializer arrayInitializer(Type expected) throws ParseException {
815     int line = 0;
816     ArrayList<JExpression> initials = new ArrayList<JExpression>();
817     JExpression anInitializer = null;
818     try {
819       jj_consume_token(LCURLY);
820                    line = token.beginLine;
821       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
822       case FALSE:
823       case NEW:
824       case NULL:
825       case SUPER:
826       case THIS:
827       case TRUE:
828       case INC:
829       case LNOT:
830       case MINUS:
831       case LPAREN:
832       case LCURLY:
833       case IDENTIFIER:
834       case INT_LITERAL:
835       case CHAR_LITERAL:
836       case STRING_LITERAL:
837         anInitializer = variableInitializer(expected.componentType());
838               initials.add( anInitializer );
839         label_9:
840         while (true) {
841           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
842           case COMMA:
843             ;
844             break;
845           default:
846             jj_la1[20] = jj_gen;
847             break label_9;
848           }
849           jj_consume_token(COMMA);
850           anInitializer = variableInitializer(expected.componentType());
851                   initials.add( anInitializer );
852         }
853         break;
854       default:
855         jj_la1[21] = jj_gen;
856         ;
857       }
858       jj_consume_token(RCURLY);
859     } catch (ParseException e) {
860         recoverFromError( new int[] { SEMI, EOF }, e );
861     }
862       {if (true) return new JArrayInitializer( line, expected, initials );}
863     throw new Error("Missing return statement in function");
864   }
865 
866   final private ArrayList<JExpression> arguments() throws ParseException {
867     ArrayList<JExpression> args = new ArrayList<JExpression>();
868     JExpression anExpression = null;
869     try {
870       jj_consume_token(LPAREN);
871       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
872       case FALSE:
873       case NEW:
874       case NULL:
875       case SUPER:
876       case THIS:
877       case TRUE:
878       case INC:
879       case LNOT:
880       case MINUS:
881       case LPAREN:
882       case IDENTIFIER:
883       case INT_LITERAL:
884       case CHAR_LITERAL:
885       case STRING_LITERAL:
886         anExpression = expression();
887                                           args.add( anExpression );
888         label_10:
889         while (true) {
890           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
891           case COMMA:
892             ;
893             break;
894           default:
895             jj_la1[22] = jj_gen;
896             break label_10;
897           }
898           jj_consume_token(COMMA);
899           anExpression = expression();
900                   args.add( anExpression );
901         }
902         break;
903       default:
904         jj_la1[23] = jj_gen;
905         ;
906       }
907       jj_consume_token(RPAREN);
908     } catch (ParseException e) {
909         recoverFromError( new int[] { SEMI, EOF }, e );
910     }
911       {if (true) return args;}
912     throw new Error("Missing return statement in function");
913   }
914 
915   final private Type type() throws ParseException {
916     Type type = null;
917     try {
918       if (jj_2_5(2147483647)) {
919         type = referenceType();
920       } else {
921         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
922         case BOOLEAN:
923         case CHAR:
924         case INT:
925           type = basicType();
926           break;
927         default:
928           jj_la1[24] = jj_gen;
929           jj_consume_token(-1);
930           throw new ParseException();
931         }
932       }
933     } catch (ParseException e) {
934        recoverFromError( new int[] { SEMI, EOF }, e );
935     }
936       {if (true) return type;}
937     throw new Error("Missing return statement in function");
938   }
939 
940   final private Type basicType() throws ParseException {
941     Type type = Type.ANY;
942     try {
943       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
944       case BOOLEAN:
945         jj_consume_token(BOOLEAN);
946                     type = Type.BOOLEAN;
947         break;
948       case CHAR:
949         jj_consume_token(CHAR);
950                  type = Type.CHAR;
951         break;
952       case INT:
953         jj_consume_token(INT);
954                 type = Type.INT;
955         break;
956       default:
957         jj_la1[25] = jj_gen;
958         jj_consume_token(-1);
959         throw new ParseException();
960       }
961     } catch (ParseException e) {
962         recoverFromError( new int[] { SEMI, EOF }, e );
963     }
964       {if (true) return type;}
965     throw new Error("Missing return statement in function");
966   }
967 
968   final private Type referenceType() throws ParseException {
969     Type type = Type.ANY;
970     try {
971       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
972       case BOOLEAN:
973       case CHAR:
974       case INT:
975         type = basicType();
976         jj_consume_token(LBRACK);
977         jj_consume_token(RBRACK);
978                             type = new ArrayTypeName( type );
979         label_11:
980         while (true) {
981           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
982           case LBRACK:
983             ;
984             break;
985           default:
986             jj_la1[26] = jj_gen;
987             break label_11;
988           }
989           jj_consume_token(LBRACK);
990           jj_consume_token(RBRACK);
991               type = new ArrayTypeName( type );
992         }
993         break;
994       case IDENTIFIER:
995         type = qualifiedIdentifier();
996         label_12:
997         while (true) {
998           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
999           case LBRACK:
1000            ;
1001            break;
1002          default:
1003            jj_la1[27] = jj_gen;
1004            break label_12;
1005          }
1006          jj_consume_token(LBRACK);
1007          jj_consume_token(RBRACK);
1008              type = new ArrayTypeName( type );
1009        }
1010        break;
1011      default:
1012        jj_la1[28] = jj_gen;
1013        jj_consume_token(-1);
1014        throw new ParseException();
1015      }
1016    } catch (ParseException e) {
1017        recoverFromError( new int[] { SEMI, EOF }, e );
1018    }
1019      {if (true) return type;}
1020    throw new Error("Missing return statement in function");
1021  }
1022
1023  final private JStatement statementExpression() throws ParseException {
1024    int line = 0;
1025    JExpression expr = null;
1026    try {
1027      expr = expression();
1028            line = expr.line();
1029            if ( expr instanceof JAssignment
1030              || expr instanceof JPreIncrementOp
1031              || expr instanceof JPostDecrementOp
1032              || expr instanceof JMessageExpression
1033              || expr instanceof JSuperConstruction
1034              || expr instanceof JThisConstruction
1035              || expr instanceof JNewOp
1036              || expr instanceof JNewArrayOp ) {
1037                // So as not to save on stack
1038                expr.isStatementExpression = true;
1039            }
1040            else {
1041                reportParserError( "Invalid statement expression; " +
1042                    "it does not have a side-effect" );
1043            }
1044    } catch (ParseException e) {
1045        recoverFromError( new int[] { SEMI, EOF }, e );
1046    }
1047      {if (true) return new JStatementExpression( line, expr );}
1048    throw new Error("Missing return statement in function");
1049  }
1050
1051  final private JExpression expression() throws ParseException {
1052    JExpression expr = null;
1053    try {
1054      expr = assignmentExpression();
1055    } catch (ParseException e) {
1056        recoverFromError( new int[] { SEMI, EOF }, e );
1057    }
1058      {if (true) return expr;}
1059    throw new Error("Missing return statement in function");
1060  }
1061
1062  final private JExpression assignmentExpression() throws ParseException {
1063    int line = 0;
1064    JExpression lhs = null, rhs = null;
1065    try {
1066      lhs = conditionalAndExpression();
1067                                           line = lhs.line();
1068      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1069      case ASSIGN:
1070      case PLUS_ASSIGN:
1071        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1072        case ASSIGN:
1073          jj_consume_token(ASSIGN);
1074          rhs = assignmentExpression();
1075              lhs = new JAssignOp( line, lhs, rhs );
1076          break;
1077        case PLUS_ASSIGN:
1078          jj_consume_token(PLUS_ASSIGN);
1079          rhs = assignmentExpression();
1080              lhs = new JPlusAssignOp( line, lhs, rhs );
1081          break;
1082        default:
1083          jj_la1[29] = jj_gen;
1084          jj_consume_token(-1);
1085          throw new ParseException();
1086        }
1087        break;
1088      default:
1089        jj_la1[30] = jj_gen;
1090        ;
1091      }
1092    } catch (ParseException e) {
1093        recoverFromError( new int[] { SEMI, EOF }, e );
1094    }
1095      {if (true) return lhs;}
1096    throw new Error("Missing return statement in function");
1097  }
1098
1099  final private JExpression conditionalAndExpression() throws ParseException {
1100    int line = 0;
1101    JExpression lhs = null, rhs = null;
1102    try {
1103      lhs = equalityExpression();
1104                                     line = lhs.line();
1105      label_13:
1106      while (true) {
1107        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1108        case LAND:
1109          ;
1110          break;
1111        default:
1112          jj_la1[31] = jj_gen;
1113          break label_13;
1114        }
1115        jj_consume_token(LAND);
1116        rhs = equalityExpression();
1117              lhs = new JLogicalAndOp( line, lhs, rhs );
1118      }
1119    } catch (ParseException e) {
1120        recoverFromError( new int[] { SEMI, EOF }, e );
1121    }
1122      {if (true) return lhs;}
1123    throw new Error("Missing return statement in function");
1124  }
1125
1126  final private JExpression equalityExpression() throws ParseException {
1127    int line = 0;
1128    JExpression lhs = null, rhs = null;
1129    try {
1130      lhs = relationalExpression();
1131                                       line = lhs.line();
1132      label_14:
1133      while (true) {
1134        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1135        case EQUAL:
1136          ;
1137          break;
1138        default:
1139          jj_la1[32] = jj_gen;
1140          break label_14;
1141        }
1142        jj_consume_token(EQUAL);
1143        rhs = relationalExpression();
1144              lhs = new JEqualOp( line, lhs, rhs );
1145      }
1146    } catch (ParseException e) {
1147        recoverFromError( new int[] { SEMI, EOF }, e );
1148    }
1149      {if (true) return lhs;}
1150    throw new Error("Missing return statement in function");
1151  }
1152
1153  final private JExpression relationalExpression() throws ParseException {
1154    int line = 0;
1155    JExpression lhs = null, rhs = null;
1156    Type type = null;
1157    try {
1158      lhs = additiveExpression();
1159                                     line = lhs.line();
1160      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1161      case INSTANCEOF:
1162      case GT:
1163      case LE:
1164        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1165        case GT:
1166          jj_consume_token(GT);
1167          rhs = additiveExpression();
1168              lhs = new JGreaterThanOp( line, lhs, rhs );
1169          break;
1170        case LE:
1171          jj_consume_token(LE);
1172          rhs = additiveExpression();
1173              lhs = new JLessEqualOp( line, lhs, rhs );
1174          break;
1175        case INSTANCEOF:
1176          jj_consume_token(INSTANCEOF);
1177          type = referenceType();
1178              lhs = new JInstanceOfOp( line, lhs, type );
1179          break;
1180        default:
1181          jj_la1[33] = jj_gen;
1182          jj_consume_token(-1);
1183          throw new ParseException();
1184        }
1185        break;
1186      default:
1187        jj_la1[34] = jj_gen;
1188        ;
1189      }
1190    } catch (ParseException e) {
1191        recoverFromError( new int[] { SEMI, EOF }, e );
1192    }
1193      {if (true) return lhs;}
1194    throw new Error("Missing return statement in function");
1195  }
1196
1197  final private JExpression additiveExpression() throws ParseException {
1198    int line = 0;
1199    JExpression lhs = null, rhs = null;
1200    try {
1201      lhs = multiplicativeExpression();
1202                                           line = lhs.line();
1203      label_15:
1204      while (true) {
1205        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1206        case PLUS:
1207        case MINUS:
1208          ;
1209          break;
1210        default:
1211          jj_la1[35] = jj_gen;
1212          break label_15;
1213        }
1214        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1215        case PLUS:
1216          jj_consume_token(PLUS);
1217          rhs = multiplicativeExpression();
1218              lhs = new JPlusOp( line, lhs, rhs );
1219          break;
1220        case MINUS:
1221          jj_consume_token(MINUS);
1222          rhs = multiplicativeExpression();
1223              lhs = new JSubtractOp( line, lhs, rhs );
1224          break;
1225        default:
1226          jj_la1[36] = jj_gen;
1227          jj_consume_token(-1);
1228          throw new ParseException();
1229        }
1230      }
1231    } catch (ParseException e) {
1232        recoverFromError( new int[] { SEMI, EOF }, e );
1233    }
1234      {if (true) return lhs;}
1235    throw new Error("Missing return statement in function");
1236  }
1237
1238  final private JExpression multiplicativeExpression() throws ParseException {
1239    int line = 0;
1240    JExpression lhs = null, rhs = null;
1241    try {
1242      lhs = unaryExpression();
1243                                  line = lhs.line();
1244      label_16:
1245      while (true) {
1246        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1247        case STAR:
1248          ;
1249          break;
1250        default:
1251          jj_la1[37] = jj_gen;
1252          break label_16;
1253        }
1254        jj_consume_token(STAR);
1255        rhs = unaryExpression();
1256              lhs = new JMultiplyOp( line, lhs, rhs );
1257      }
1258    } catch (ParseException e) {
1259        recoverFromError( new int[] { SEMI, EOF }, e );
1260    }
1261      {if (true) return lhs;}
1262    throw new Error("Missing return statement in function");
1263  }
1264
1265  final private JExpression unaryExpression() throws ParseException {
1266    int line = 0;
1267    JExpression expr = null, unaryExpr = null;
1268    try {
1269      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1270      case INC:
1271        jj_consume_token(INC);
1272                line = token.beginLine;
1273        unaryExpr = unaryExpression();
1274          expr = new JPreIncrementOp( line, unaryExpr );
1275        break;
1276      case MINUS:
1277        jj_consume_token(MINUS);
1278                  line = token.beginLine;
1279        unaryExpr = unaryExpression();
1280          expr = new JNegateOp( line, unaryExpr );
1281        break;
1282      case FALSE:
1283      case NEW:
1284      case NULL:
1285      case SUPER:
1286      case THIS:
1287      case TRUE:
1288      case LNOT:
1289      case LPAREN:
1290      case IDENTIFIER:
1291      case INT_LITERAL:
1292      case CHAR_LITERAL:
1293      case STRING_LITERAL:
1294        expr = simpleUnaryExpression();
1295        break;
1296      default:
1297        jj_la1[38] = jj_gen;
1298        jj_consume_token(-1);
1299        throw new ParseException();
1300      }
1301    } catch (ParseException e) {
1302        recoverFromError( new int[] { SEMI, EOF }, e );
1303    }
1304      {if (true) return expr;}
1305    throw new Error("Missing return statement in function");
1306  }
1307
1308  final private JExpression simpleUnaryExpression() throws ParseException {
1309    int line = 0;
1310    Type type = null;
1311    JExpression expr = null, unaryExpr = null, simpleUnaryExpr = null;
1312    try {
1313      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1314      case LNOT:
1315        jj_consume_token(LNOT);
1316                 line = token.beginLine;
1317        unaryExpr = unaryExpression();
1318          expr = new JLogicalNotOp( line, unaryExpr );
1319        break;
1320      default:
1321        jj_la1[39] = jj_gen;
1322        if (jj_2_6(2147483647)) {
1323          jj_consume_token(LPAREN);
1324                   line = token.beginLine;
1325          type = basicType();
1326          jj_consume_token(RPAREN);
1327          unaryExpr = unaryExpression();
1328          expr = new JCastOp( line, type, unaryExpr );
1329        } else if (jj_2_7(2147483647)) {
1330          jj_consume_token(LPAREN);
1331                   line = token.beginLine;
1332          type = referenceType();
1333          jj_consume_token(RPAREN);
1334          simpleUnaryExpr = simpleUnaryExpression();
1335          expr = new JCastOp( line, type, simpleUnaryExpr );
1336        } else {
1337          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1338          case FALSE:
1339          case NEW:
1340          case NULL:
1341          case SUPER:
1342          case THIS:
1343          case TRUE:
1344          case LPAREN:
1345          case IDENTIFIER:
1346          case INT_LITERAL:
1347          case CHAR_LITERAL:
1348          case STRING_LITERAL:
1349            expr = postfixExpression();
1350            break;
1351          default:
1352            jj_la1[40] = jj_gen;
1353            jj_consume_token(-1);
1354            throw new ParseException();
1355          }
1356        }
1357      }
1358    } catch (ParseException e) {
1359        recoverFromError( new int[] { SEMI, EOF }, e );
1360    }
1361      {if (true) return expr ;}
1362    throw new Error("Missing return statement in function");
1363  }
1364
1365  final private JExpression postfixExpression() throws ParseException {
1366    int line = 0;
1367    JExpression primaryExpr = null;
1368    try {
1369      primaryExpr = primary();
1370                                  line = primaryExpr.line();
1371      label_17:
1372      while (true) {
1373        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1374        case LBRACK:
1375        case DOT:
1376          ;
1377          break;
1378        default:
1379          jj_la1[41] = jj_gen;
1380          break label_17;
1381        }
1382        primaryExpr = selector(primaryExpr);
1383      }
1384      label_18:
1385      while (true) {
1386        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1387        case DEC:
1388          ;
1389          break;
1390        default:
1391          jj_la1[42] = jj_gen;
1392          break label_18;
1393        }
1394        jj_consume_token(DEC);
1395              primaryExpr =
1396                new JPostDecrementOp( line, primaryExpr );
1397      }
1398    } catch (ParseException e) {
1399        recoverFromError( new int[] { SEMI, EOF }, e );
1400    }
1401      {if (true) return primaryExpr;}
1402    throw new Error("Missing return statement in function");
1403  }
1404
1405  final private JExpression selector(JExpression target) throws ParseException {
1406    int line = 0;
1407    ArrayList<JExpression> args = null;
1408    TypeName id = null;
1409    JExpression expr = null;
1410    try {
1411      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1412      case DOT:
1413        jj_consume_token(DOT);
1414                line = token.beginLine;
1415        id = qualifiedIdentifier();
1416          expr =
1417              new JFieldSelection( line, ambiguousPart( id ),
1418                                   target, id.simpleName() );
1419        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1420        case LPAREN:
1421          args = arguments();
1422              expr = new JMessageExpression( line, target,
1423                  ambiguousPart( id ), id.simpleName(), args );
1424          break;
1425        default:
1426          jj_la1[43] = jj_gen;
1427          ;
1428        }
1429        break;
1430      case LBRACK:
1431        jj_consume_token(LBRACK);
1432                   line = token.beginLine;
1433          expr = new JArrayExpression( line, target, expression() );
1434        jj_consume_token(RBRACK);
1435        break;
1436      default:
1437        jj_la1[44] = jj_gen;
1438        jj_consume_token(-1);
1439        throw new ParseException();
1440      }
1441    } catch (ParseException e) {
1442        recoverFromError( new int[] { SEMI, EOF }, e );
1443    }
1444      {if (true) return expr;}
1445    throw new Error("Missing return statement in function");
1446  }
1447
1448  final private JExpression primary() throws ParseException {
1449    int line = 0;
1450    JExpression expr = null;
1451    JExpression newTarget = null;
1452    ArrayList<JExpression> args = null;
1453    TypeName id = null;
1454    try {
1455      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1456      case LPAREN:
1457        expr = parExpression();
1458        break;
1459      case THIS:
1460        jj_consume_token(THIS);
1461                 line = token.beginLine; expr = new JThis( line );
1462        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1463        case LPAREN:
1464          args = arguments();
1465              expr = new JThisConstruction( line, args );
1466          break;
1467        default:
1468          jj_la1[45] = jj_gen;
1469          ;
1470        }
1471        break;
1472      case SUPER:
1473        jj_consume_token(SUPER);
1474                  line = token.beginLine;
1475        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1476        case LPAREN:
1477          args = arguments();
1478              expr = new JSuperConstruction( line, args );
1479          break;
1480        case DOT:
1481          jj_consume_token(DOT);
1482          jj_consume_token(IDENTIFIER);
1483                newTarget = new JSuper( line );
1484                expr = new JFieldSelection( line, newTarget,
1485                                            token.image );
1486          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1487          case LPAREN:
1488            args = arguments();
1489                  expr = new JMessageExpression( line, newTarget,
1490                      null, token.image, args );
1491            break;
1492          default:
1493            jj_la1[46] = jj_gen;
1494            ;
1495          }
1496          break;
1497        default:
1498          jj_la1[47] = jj_gen;
1499          jj_consume_token(-1);
1500          throw new ParseException();
1501        }
1502        break;
1503      case FALSE:
1504      case NULL:
1505      case TRUE:
1506      case INT_LITERAL:
1507      case CHAR_LITERAL:
1508      case STRING_LITERAL:
1509        expr = literal();
1510        break;
1511      case NEW:
1512        jj_consume_token(NEW);
1513        expr = creator();
1514        break;
1515      case IDENTIFIER:
1516        // Language is ambiguous here. JavaCC warns about not being 
1517                // able to choose between qualifiedIdentifier and selector. 
1518                // Semantic analysis will sort it out.
1519                id = qualifiedIdentifier();
1520            line = id.line();
1521            if ( ambiguousPart( id ) == null ) {
1522                expr = new JVariable( line, id.simpleName() );
1523            }
1524            else {
1525                expr = new JFieldSelection( line, ambiguousPart( id ),
1526                                            null, id.simpleName() );
1527            }
1528        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1529        case LPAREN:
1530          args = arguments();
1531              expr = new JMessageExpression( line, null,
1532                  ambiguousPart( id ), id.simpleName(), args );
1533          break;
1534        default:
1535          jj_la1[48] = jj_gen;
1536          ;
1537        }
1538        break;
1539      default:
1540        jj_la1[49] = jj_gen;
1541        jj_consume_token(-1);
1542        throw new ParseException();
1543      }
1544    } catch (ParseException e) {
1545        recoverFromError( new int[] { SEMI, EOF }, e );
1546    }
1547      {if (true) return expr;}
1548    throw new Error("Missing return statement in function");
1549  }
1550
1551  final private JExpression creator() throws ParseException {
1552    int line = 0;
1553    Type type = null;
1554    ArrayList<JExpression> args = null;
1555    ArrayList<JExpression> dims = null;
1556    JArrayInitializer init =  null;
1557    JExpression expr = null;
1558    Type expected = null;
1559    try {
1560      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1561      case BOOLEAN:
1562      case CHAR:
1563      case INT:
1564      case IDENTIFIER:
1565        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1566        case BOOLEAN:
1567        case CHAR:
1568        case INT:
1569          type = basicType();
1570          break;
1571        case IDENTIFIER:
1572          type = qualifiedIdentifier();
1573          break;
1574        default:
1575          jj_la1[50] = jj_gen;
1576          jj_consume_token(-1);
1577          throw new ParseException();
1578        }
1579          line = token.beginLine; expected = type;
1580        args = arguments();
1581          expr = new JNewOp( line, type, args );
1582        break;
1583      default:
1584        jj_la1[52] = jj_gen;
1585        if (jj_2_9(2147483647)) {
1586          expr = newArrayDeclarator(type);
1587        } else {
1588          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1589          case LBRACK:
1590            jj_consume_token(LBRACK);
1591            jj_consume_token(RBRACK);
1592                            expected = new ArrayTypeName( expected );
1593            label_19:
1594            while (true) {
1595              if (jj_2_8(2147483647)) {
1596                ;
1597              } else {
1598                break label_19;
1599              }
1600              jj_consume_token(LBRACK);
1601              jj_consume_token(RBRACK);
1602              expected = new ArrayTypeName( expected );
1603            }
1604            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1605            case LCURLY:
1606              expr = arrayInitializer(expected);
1607              break;
1608            default:
1609              jj_la1[51] = jj_gen;
1610              ;
1611            }
1612            break;
1613          default:
1614            jj_la1[53] = jj_gen;
1615            jj_consume_token(-1);
1616            throw new ParseException();
1617          }
1618        }
1619      }
1620    } catch (ParseException e) {
1621        expr = new JWildExpression( token.beginLine );
1622        recoverFromError( new int[] { SEMI, EOF }, e );
1623    }
1624      {if (true) return expr;}
1625    throw new Error("Missing return statement in function");
1626  }
1627
1628  final private JNewArrayOp newArrayDeclarator(Type type) throws ParseException {
1629    int line = 0;
1630    ArrayList<JExpression> dimensions = new ArrayList<JExpression>();
1631    JExpression expr = null;
1632    try {
1633      jj_consume_token(LBRACK);
1634                   line = token.beginLine;
1635      expr = expression();
1636          dimensions.add( expr ); type = new ArrayTypeName( type );
1637      jj_consume_token(RBRACK);
1638      label_20:
1639      while (true) {
1640        if (jj_2_10(2147483647)) {
1641          ;
1642        } else {
1643          break label_20;
1644        }
1645        jj_consume_token(LBRACK);
1646        expr = expression();
1647              dimensions.add( expr); type = new ArrayTypeName( type );
1648        jj_consume_token(RBRACK);
1649      }
1650      label_21:
1651      while (true) {
1652        if (jj_2_11(2147483647)) {
1653          ;
1654        } else {
1655          break label_21;
1656        }
1657        jj_consume_token(LBRACK);
1658        jj_consume_token(RBRACK);
1659                                type = new ArrayTypeName( type );
1660      }
1661    } catch (ParseException e) {
1662        recoverFromError( new int[] { SEMI, EOF }, e );
1663    }
1664      {if (true) return new JNewArrayOp( line, type, dimensions );}
1665    throw new Error("Missing return statement in function");
1666  }
1667
1668  final private JExpression literal() throws ParseException {
1669    JExpression expr = null;
1670    try {
1671      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1672      case INT_LITERAL:
1673        jj_consume_token(INT_LITERAL);
1674          expr = new JLiteralInt( token.beginLine, token.image );
1675        break;
1676      case CHAR_LITERAL:
1677        jj_consume_token(CHAR_LITERAL);
1678          expr = new JLiteralChar( token.beginLine, token.image );
1679        break;
1680      case STRING_LITERAL:
1681        jj_consume_token(STRING_LITERAL);
1682          expr =
1683              new JLiteralString( token.beginLine, token.image );
1684        break;
1685      case TRUE:
1686        jj_consume_token(TRUE);
1687          expr = new JLiteralTrue( token.beginLine );
1688        break;
1689      case FALSE:
1690        jj_consume_token(FALSE);
1691          expr = new JLiteralFalse( token.beginLine );
1692        break;
1693      case NULL:
1694        jj_consume_token(NULL);
1695          expr = new JLiteralNull( token.beginLine );
1696        break;
1697      default:
1698        jj_la1[54] = jj_gen;
1699        jj_consume_token(-1);
1700        throw new ParseException();
1701      }
1702    } catch (ParseException e) {
1703        expr = new JWildExpression( token.beginLine );
1704        recoverFromError( new int[] { SEMI, EOF }, e );
1705    }
1706      {if (true) return expr;}
1707    throw new Error("Missing return statement in function");
1708  }
1709
1710  final private boolean jj_2_1(int xla) {
1711    jj_la = xla; jj_lastpos = jj_scanpos = token;
1712    try { return !jj_3_1(); }
1713    catch(LookaheadSuccess ls) { return true; }
1714    finally { jj_save(0, xla); }
1715  }
1716
1717  final private boolean jj_2_2(int xla) {
1718    jj_la = xla; jj_lastpos = jj_scanpos = token;
1719    try { return !jj_3_2(); }
1720    catch(LookaheadSuccess ls) { return true; }
1721    finally { jj_save(1, xla); }
1722  }
1723
1724  final private boolean jj_2_3(int xla) {
1725    jj_la = xla; jj_lastpos = jj_scanpos = token;
1726    try { return !jj_3_3(); }
1727    catch(LookaheadSuccess ls) { return true; }
1728    finally { jj_save(2, xla); }
1729  }
1730
1731  final private boolean jj_2_4(int xla) {
1732    jj_la = xla; jj_lastpos = jj_scanpos = token;
1733    try { return !jj_3_4(); }
1734    catch(LookaheadSuccess ls) { return true; }
1735    finally { jj_save(3, xla); }
1736  }
1737
1738  final private boolean jj_2_5(int xla) {
1739    jj_la = xla; jj_lastpos = jj_scanpos = token;
1740    try { return !jj_3_5(); }
1741    catch(LookaheadSuccess ls) { return true; }
1742    finally { jj_save(4, xla); }
1743  }
1744
1745  final private boolean jj_2_6(int xla) {
1746    jj_la = xla; jj_lastpos = jj_scanpos = token;
1747    try { return !jj_3_6(); }
1748    catch(LookaheadSuccess ls) { return true; }
1749    finally { jj_save(5, xla); }
1750  }
1751
1752  final private boolean jj_2_7(int xla) {
1753    jj_la = xla; jj_lastpos = jj_scanpos = token;
1754    try { return !jj_3_7(); }
1755    catch(LookaheadSuccess ls) { return true; }
1756    finally { jj_save(6, xla); }
1757  }
1758
1759  final private boolean jj_2_8(int xla) {
1760    jj_la = xla; jj_lastpos = jj_scanpos = token;
1761    try { return !jj_3_8(); }
1762    catch(LookaheadSuccess ls) { return true; }
1763    finally { jj_save(7, xla); }
1764  }
1765
1766  final private boolean jj_2_9(int xla) {
1767    jj_la = xla; jj_lastpos = jj_scanpos = token;
1768    try { return !jj_3_9(); }
1769    catch(LookaheadSuccess ls) { return true; }
1770    finally { jj_save(8, xla); }
1771  }
1772
1773  final private boolean jj_2_10(int xla) {
1774    jj_la = xla; jj_lastpos = jj_scanpos = token;
1775    try { return !jj_3_10(); }
1776    catch(LookaheadSuccess ls) { return true; }
1777    finally { jj_save(9, xla); }
1778  }
1779
1780  final private boolean jj_2_11(int xla) {
1781    jj_la = xla; jj_lastpos = jj_scanpos = token;
1782    try { return !jj_3_11(); }
1783    catch(LookaheadSuccess ls) { return true; }
1784    finally { jj_save(10, xla); }
1785  }
1786
1787  final private boolean jj_3R_81() {
1788    if (jj_scan_token(DOT)) return true;
1789    if (jj_scan_token(IDENTIFIER)) return true;
1790    Token xsp;
1791    xsp = jj_scanpos;
1792    if (jj_3R_88()) jj_scanpos = xsp;
1793    return false;
1794  }
1795
1796  final private boolean jj_3R_80() {
1797    if (jj_3R_87()) return true;
1798    return false;
1799  }
1800
1801  final private boolean jj_3R_111() {
1802    if (jj_scan_token(COMMA)) return true;
1803    if (jj_3R_110()) return true;
1804    return false;
1805  }
1806
1807  final private boolean jj_3_2() {
1808    Token xsp;
1809    xsp = jj_scanpos;
1810    if (jj_scan_token(29)) {
1811    jj_scanpos = xsp;
1812    if (jj_3R_22()) return true;
1813    }
1814    if (jj_scan_token(IDENTIFIER)) return true;
1815    if (jj_scan_token(LPAREN)) return true;
1816    return false;
1817  }
1818
1819  final private boolean jj_3R_56() {
1820    if (jj_scan_token(STAR)) return true;
1821    if (jj_3R_55()) return true;
1822    return false;
1823  }
1824
1825  final private boolean jj_3R_79() {
1826    if (jj_3R_87()) return true;
1827    return false;
1828  }
1829
1830  final private boolean jj_3R_73() {
1831    if (jj_scan_token(SUPER)) return true;
1832    Token xsp;
1833    xsp = jj_scanpos;
1834    if (jj_3R_80()) {
1835    jj_scanpos = xsp;
1836    if (jj_3R_81()) return true;
1837    }
1838    return false;
1839  }
1840
1841  final private boolean jj_3R_109() {
1842    if (jj_3R_110()) return true;
1843    Token xsp;
1844    while (true) {
1845      xsp = jj_scanpos;
1846      if (jj_3R_111()) { jj_scanpos = xsp; break; }
1847    }
1848    return false;
1849  }
1850
1851  final private boolean jj_3R_72() {
1852    if (jj_scan_token(THIS)) return true;
1853    Token xsp;
1854    xsp = jj_scanpos;
1855    if (jj_3R_79()) jj_scanpos = xsp;
1856    return false;
1857  }
1858
1859  final private boolean jj_3R_71() {
1860    if (jj_3R_78()) return true;
1861    return false;
1862  }
1863
1864  final private boolean jj_3R_50() {
1865    if (jj_3R_55()) return true;
1866    Token xsp;
1867    while (true) {
1868      xsp = jj_scanpos;
1869      if (jj_3R_56()) { jj_scanpos = xsp; break; }
1870    }
1871    return false;
1872  }
1873
1874  final private boolean jj_3R_68() {
1875    Token xsp;
1876    xsp = jj_scanpos;
1877    if (jj_3R_71()) {
1878    jj_scanpos = xsp;
1879    if (jj_3R_72()) {
1880    jj_scanpos = xsp;
1881    if (jj_3R_73()) {
1882    jj_scanpos = xsp;
1883    if (jj_3R_74()) {
1884    jj_scanpos = xsp;
1885    if (jj_3R_75()) {
1886    jj_scanpos = xsp;
1887    if (jj_3R_76()) return true;
1888    }
1889    }
1890    }
1891    }
1892    }
1893    return false;
1894  }
1895
1896  final private boolean jj_3_1() {
1897    if (jj_scan_token(IDENTIFIER)) return true;
1898    if (jj_scan_token(LPAREN)) return true;
1899    return false;
1900  }
1901
1902  final private boolean jj_3R_27() {
1903    if (jj_3R_35()) return true;
1904    return false;
1905  }
1906
1907  final private boolean jj_3R_108() {
1908    if (jj_scan_token(LCURLY)) return true;
1909    Token xsp;
1910    xsp = jj_scanpos;
1911    if (jj_3R_109()) jj_scanpos = xsp;
1912    if (jj_scan_token(RCURLY)) return true;
1913    return false;
1914  }
1915
1916  final private boolean jj_3R_94() {
1917    if (jj_scan_token(NULL)) return true;
1918    return false;
1919  }
1920
1921  final private boolean jj_3R_93() {
1922    if (jj_scan_token(FALSE)) return true;
1923    return false;
1924  }
1925
1926  final private boolean jj_3R_58() {
1927    if (jj_scan_token(MINUS)) return true;
1928    if (jj_3R_50()) return true;
1929    return false;
1930  }
1931
1932  final private boolean jj_3R_92() {
1933    if (jj_scan_token(TRUE)) return true;
1934    return false;
1935  }
1936
1937  final private boolean jj_3R_51() {
1938    Token xsp;
1939    xsp = jj_scanpos;
1940    if (jj_3R_57()) {
1941    jj_scanpos = xsp;
1942    if (jj_3R_58()) return true;
1943    }
1944    return false;
1945  }
1946
1947  final private boolean jj_3R_57() {
1948    if (jj_scan_token(PLUS)) return true;
1949    if (jj_3R_50()) return true;
1950    return false;
1951  }
1952
1953  final private boolean jj_3R_91() {
1954    if (jj_scan_token(STRING_LITERAL)) return true;
1955    return false;
1956  }
1957
1958  final private boolean jj_3R_90() {
1959    if (jj_scan_token(CHAR_LITERAL)) return true;
1960    return false;
1961  }
1962
1963  final private boolean jj_3R_89() {
1964    if (jj_scan_token(INT_LITERAL)) return true;
1965    return false;
1966  }
1967
1968  final private boolean jj_3R_113() {
1969    if (jj_3R_27()) return true;
1970    return false;
1971  }
1972
1973  final private boolean jj_3R_112() {
1974    if (jj_3R_108()) return true;
1975    return false;
1976  }
1977
1978  final private boolean jj_3R_86() {
1979    if (jj_scan_token(LBRACK)) return true;
1980    if (jj_scan_token(RBRACK)) return true;
1981    return false;
1982  }
1983
1984  final private boolean jj_3R_82() {
1985    Token xsp;
1986    xsp = jj_scanpos;
1987    if (jj_3R_89()) {
1988    jj_scanpos = xsp;
1989    if (jj_3R_90()) {
1990    jj_scanpos = xsp;
1991    if (jj_3R_91()) {
1992    jj_scanpos = xsp;
1993    if (jj_3R_92()) {
1994    jj_scanpos = xsp;
1995    if (jj_3R_93()) {
1996    jj_scanpos = xsp;
1997    if (jj_3R_94()) return true;
1998    }
1999    }
2000    }
2001    }
2002    }
2003    return false;
2004  }
2005
2006  final private boolean jj_3R_98() {
2007    if (jj_3R_87()) return true;
2008    return false;
2009  }
2010
2011  final private boolean jj_3R_48() {
2012    if (jj_3R_50()) return true;
2013    Token xsp;
2014    while (true) {
2015      xsp = jj_scanpos;
2016      if (jj_3R_51()) { jj_scanpos = xsp; break; }
2017    }
2018    return false;
2019  }
2020
2021  final private boolean jj_3R_110() {
2022    Token xsp;
2023    xsp = jj_scanpos;
2024    if (jj_3R_112()) {
2025    jj_scanpos = xsp;
2026    if (jj_3R_113()) return true;
2027    }
2028    return false;
2029  }
2030
2031  final private boolean jj_3R_41() {
2032    if (jj_scan_token(DOT)) return true;
2033    if (jj_scan_token(IDENTIFIER)) return true;
2034    return false;
2035  }
2036
2037  final private boolean jj_3_11() {
2038    if (jj_scan_token(LBRACK)) return true;
2039    if (jj_scan_token(RBRACK)) return true;
2040    return false;
2041  }
2042
2043  final private boolean jj_3R_85() {
2044    if (jj_scan_token(DOT)) return true;
2045    if (jj_3R_37()) return true;
2046    Token xsp;
2047    xsp = jj_scanpos;
2048    if (jj_3R_98()) jj_scanpos = xsp;
2049    return false;
2050  }
2051
2052  final private boolean jj_3_10() {
2053    if (jj_scan_token(LBRACK)) return true;
2054    if (jj_3R_27()) return true;
2055    if (jj_scan_token(RBRACK)) return true;
2056    return false;
2057  }
2058
2059  final private boolean jj_3_4() {
2060    if (jj_scan_token(ELSE)) return true;
2061    return false;
2062  }
2063
2064  final private boolean jj_3R_77() {
2065    Token xsp;
2066    xsp = jj_scanpos;
2067    if (jj_3R_85()) {
2068    jj_scanpos = xsp;
2069    if (jj_3R_86()) return true;
2070    }
2071    return false;
2072  }
2073
2074  final private boolean jj_3R_107() {
2075    if (jj_scan_token(LBRACK)) return true;
2076    if (jj_scan_token(RBRACK)) return true;
2077    return false;
2078  }
2079
2080  final private boolean jj_3R_37() {
2081    if (jj_scan_token(IDENTIFIER)) return true;
2082    Token xsp;
2083    while (true) {
2084      xsp = jj_scanpos;
2085      if (jj_3R_41()) { jj_scanpos = xsp; break; }
2086    }
2087    return false;
2088  }
2089
2090  final private boolean jj_3R_54() {
2091    if (jj_scan_token(INSTANCEOF)) return true;
2092    if (jj_3R_26()) return true;
2093    return false;
2094  }
2095
2096  final private boolean jj_3R_53() {
2097    if (jj_scan_token(LE)) return true;
2098    if (jj_3R_48()) return true;
2099    return false;
2100  }
2101
2102  final private boolean jj_3R_106() {
2103    if (jj_scan_token(LBRACK)) return true;
2104    if (jj_3R_27()) return true;
2105    if (jj_scan_token(RBRACK)) return true;
2106    return false;
2107  }
2108
2109  final private boolean jj_3R_49() {
2110    Token xsp;
2111    xsp = jj_scanpos;
2112    if (jj_3R_52()) {
2113    jj_scanpos = xsp;
2114    if (jj_3R_53()) {
2115    jj_scanpos = xsp;
2116    if (jj_3R_54()) return true;
2117    }
2118    }
2119    return false;
2120  }
2121
2122  final private boolean jj_3R_52() {
2123    if (jj_scan_token(GT)) return true;
2124    if (jj_3R_48()) return true;
2125    return false;
2126  }
2127
2128  final private boolean jj_3R_38() {
2129    if (jj_scan_token(LBRACK)) return true;
2130    if (jj_scan_token(RBRACK)) return true;
2131    return false;
2132  }
2133
2134  final private boolean jj_3R_36() {
2135    if (jj_scan_token(LBRACK)) return true;
2136    if (jj_scan_token(RBRACK)) return true;
2137    return false;
2138  }
2139
2140  final private boolean jj_3R_34() {
2141    if (jj_3R_37()) return true;
2142    Token xsp;
2143    while (true) {
2144      xsp = jj_scanpos;
2145      if (jj_3R_38()) { jj_scanpos = xsp; break; }
2146    }
2147    return false;
2148  }
2149
2150  final private boolean jj_3R_46() {
2151    if (jj_3R_48()) return true;
2152    Token xsp;
2153    xsp = jj_scanpos;
2154    if (jj_3R_49()) jj_scanpos = xsp;
2155    return false;
2156  }
2157
2158  final private boolean jj_3R_102() {
2159    if (jj_scan_token(LBRACK)) return true;
2160    if (jj_3R_27()) return true;
2161    if (jj_scan_token(RBRACK)) return true;
2162    Token xsp;
2163    while (true) {
2164      xsp = jj_scanpos;
2165      if (jj_3R_106()) { jj_scanpos = xsp; break; }
2166    }
2167    while (true) {
2168      xsp = jj_scanpos;
2169      if (jj_3R_107()) { jj_scanpos = xsp; break; }
2170    }
2171    return false;
2172  }
2173
2174  final private boolean jj_3R_70() {
2175    if (jj_scan_token(DEC)) return true;
2176    return false;
2177  }
2178
2179  final private boolean jj_3R_33() {
2180    if (jj_3R_25()) return true;
2181    if (jj_scan_token(LBRACK)) return true;
2182    if (jj_scan_token(RBRACK)) return true;
2183    Token xsp;
2184    while (true) {
2185      xsp = jj_scanpos;
2186      if (jj_3R_36()) { jj_scanpos = xsp; break; }
2187    }
2188    return false;
2189  }
2190
2191  final private boolean jj_3R_69() {
2192    if (jj_3R_77()) return true;
2193    return false;
2194  }
2195
2196  final private boolean jj_3R_26() {
2197    Token xsp;
2198    xsp = jj_scanpos;
2199    if (jj_3R_33()) {
2200    jj_scanpos = xsp;
2201    if (jj_3R_34()) return true;
2202    }
2203    return false;
2204  }
2205
2206  final private boolean jj_3R_67() {
2207    if (jj_3R_68()) return true;
2208    Token xsp;
2209    while (true) {
2210      xsp = jj_scanpos;
2211      if (jj_3R_69()) { jj_scanpos = xsp; break; }
2212    }
2213    while (true) {
2214      xsp = jj_scanpos;
2215      if (jj_3R_70()) { jj_scanpos = xsp; break; }
2216    }
2217    return false;
2218  }
2219
2220  final private boolean jj_3_8() {
2221    if (jj_scan_token(LBRACK)) return true;
2222    if (jj_scan_token(RBRACK)) return true;
2223    return false;
2224  }
2225
2226  final private boolean jj_3R_47() {
2227    if (jj_scan_token(EQUAL)) return true;
2228    if (jj_3R_46()) return true;
2229    return false;
2230  }
2231
2232  final private boolean jj_3R_104() {
2233    if (jj_3R_108()) return true;
2234    return false;
2235  }
2236
2237  final private boolean jj_3_9() {
2238    if (jj_scan_token(LBRACK)) return true;
2239    if (jj_3R_27()) return true;
2240    if (jj_scan_token(RBRACK)) return true;
2241    return false;
2242  }
2243
2244  final private boolean jj_3R_103() {
2245    if (jj_scan_token(LBRACK)) return true;
2246    if (jj_scan_token(RBRACK)) return true;
2247    return false;
2248  }
2249
2250  final private boolean jj_3_3() {
2251    if (jj_3R_23()) return true;
2252    if (jj_scan_token(IDENTIFIER)) return true;
2253    return false;
2254  }
2255
2256  final private boolean jj_3R_32() {
2257    if (jj_scan_token(INT)) return true;
2258    return false;
2259  }
2260
2261  final private boolean jj_3R_31() {
2262    if (jj_scan_token(CHAR)) return true;
2263    return false;
2264  }
2265
2266  final private boolean jj_3R_24() {
2267    if (jj_3R_25()) return true;
2268    if (jj_scan_token(LBRACK)) return true;
2269    if (jj_scan_token(RBRACK)) return true;
2270    return false;
2271  }
2272
2273  final private boolean jj_3_7() {
2274    if (jj_scan_token(LPAREN)) return true;
2275    if (jj_3R_26()) return true;
2276    if (jj_scan_token(RPAREN)) return true;
2277    return false;
2278  }
2279
2280  final private boolean jj_3R_30() {
2281    if (jj_scan_token(BOOLEAN)) return true;
2282    return false;
2283  }
2284
2285  final private boolean jj_3R_42() {
2286    if (jj_3R_46()) return true;
2287    Token xsp;
2288    while (true) {
2289      xsp = jj_scanpos;
2290      if (jj_3R_47()) { jj_scanpos = xsp; break; }
2291    }
2292    return false;
2293  }
2294
2295  final private boolean jj_3R_97() {
2296    if (jj_scan_token(LBRACK)) return true;
2297    if (jj_scan_token(RBRACK)) return true;
2298    Token xsp;
2299    while (true) {
2300      xsp = jj_scanpos;
2301      if (jj_3R_103()) { jj_scanpos = xsp; break; }
2302    }
2303    xsp = jj_scanpos;
2304    if (jj_3R_104()) jj_scanpos = xsp;
2305    return false;
2306  }
2307
2308  final private boolean jj_3R_66() {
2309    if (jj_3R_67()) return true;
2310    return false;
2311  }
2312
2313  final private boolean jj_3R_25() {
2314    Token xsp;
2315    xsp = jj_scanpos;
2316    if (jj_3R_30()) {
2317    jj_scanpos = xsp;
2318    if (jj_3R_31()) {
2319    jj_scanpos = xsp;
2320    if (jj_3R_32()) return true;
2321    }
2322    }
2323    return false;
2324  }
2325
2326  final private boolean jj_3_6() {
2327    if (jj_scan_token(LPAREN)) return true;
2328    if (jj_3R_25()) return true;
2329    if (jj_scan_token(RPAREN)) return true;
2330    return false;
2331  }
2332
2333  final private boolean jj_3R_96() {
2334    if (jj_3R_102()) return true;
2335    return false;
2336  }
2337
2338  final private boolean jj_3R_101() {
2339    if (jj_3R_37()) return true;
2340    return false;
2341  }
2342
2343  final private boolean jj_3R_100() {
2344    if (jj_3R_25()) return true;
2345    return false;
2346  }
2347
2348  final private boolean jj_3R_65() {
2349    if (jj_scan_token(LPAREN)) return true;
2350    if (jj_3R_26()) return true;
2351    if (jj_scan_token(RPAREN)) return true;
2352    if (jj_3R_62()) return true;
2353    return false;
2354  }
2355
2356  final private boolean jj_3R_95() {
2357    Token xsp;
2358    xsp = jj_scanpos;
2359    if (jj_3R_100()) {
2360    jj_scanpos = xsp;
2361    if (jj_3R_101()) return true;
2362    }
2363    if (jj_3R_87()) return true;
2364    return false;
2365  }
2366
2367  final private boolean jj_3_5() {
2368    Token xsp;
2369    xsp = jj_scanpos;
2370    if (jj_scan_token(52)) {
2371    jj_scanpos = xsp;
2372    if (jj_3R_24()) return true;
2373    }
2374    return false;
2375  }
2376
2377  final private boolean jj_3R_83() {
2378    Token xsp;
2379    xsp = jj_scanpos;
2380    if (jj_3R_95()) {
2381    jj_scanpos = xsp;
2382    if (jj_3R_96()) {
2383    jj_scanpos = xsp;
2384    if (jj_3R_97()) return true;
2385    }
2386    }
2387    return false;
2388  }
2389
2390  final private boolean jj_3R_64() {
2391    if (jj_scan_token(LPAREN)) return true;
2392    if (jj_3R_25()) return true;
2393    if (jj_scan_token(RPAREN)) return true;
2394    if (jj_3R_55()) return true;
2395    return false;
2396  }
2397
2398  final private boolean jj_3R_63() {
2399    if (jj_scan_token(LNOT)) return true;
2400    if (jj_3R_55()) return true;
2401    return false;
2402  }
2403
2404  final private boolean jj_3R_43() {
2405    if (jj_scan_token(LAND)) return true;
2406    if (jj_3R_42()) return true;
2407    return false;
2408  }
2409
2410  final private boolean jj_3R_29() {
2411    if (jj_3R_25()) return true;
2412    return false;
2413  }
2414
2415  final private boolean jj_3R_62() {
2416    Token xsp;
2417    xsp = jj_scanpos;
2418    if (jj_3R_63()) {
2419    jj_scanpos = xsp;
2420    if (jj_3R_64()) {
2421    jj_scanpos = xsp;
2422    if (jj_3R_65()) {
2423    jj_scanpos = xsp;
2424    if (jj_3R_66()) return true;
2425    }
2426    }
2427    }
2428    return false;
2429  }
2430
2431  final private boolean jj_3R_28() {
2432    if (jj_3R_26()) return true;
2433    return false;
2434  }
2435
2436  final private boolean jj_3R_23() {
2437    Token xsp;
2438    xsp = jj_scanpos;
2439    if (jj_3R_28()) {
2440    jj_scanpos = xsp;
2441    if (jj_3R_29()) return true;
2442    }
2443    return false;
2444  }
2445
2446  final private boolean jj_3R_39() {
2447    if (jj_3R_42()) return true;
2448    Token xsp;
2449    while (true) {
2450      xsp = jj_scanpos;
2451      if (jj_3R_43()) { jj_scanpos = xsp; break; }
2452    }
2453    return false;
2454  }
2455
2456  final private boolean jj_3R_84() {
2457    if (jj_3R_87()) return true;
2458    return false;
2459  }
2460
2461  final private boolean jj_3R_105() {
2462    if (jj_scan_token(COMMA)) return true;
2463    if (jj_3R_27()) return true;
2464    return false;
2465  }
2466
2467  final private boolean jj_3R_61() {
2468    if (jj_3R_62()) return true;
2469    return false;
2470  }
2471
2472  final private boolean jj_3R_99() {
2473    if (jj_3R_27()) return true;
2474    Token xsp;
2475    while (true) {
2476      xsp = jj_scanpos;
2477      if (jj_3R_105()) { jj_scanpos = xsp; break; }
2478    }
2479    return false;
2480  }
2481
2482  final private boolean jj_3R_45() {
2483    if (jj_scan_token(PLUS_ASSIGN)) return true;
2484    if (jj_3R_35()) return true;
2485    return false;
2486  }
2487
2488  final private boolean jj_3R_78() {
2489    if (jj_scan_token(LPAREN)) return true;
2490    if (jj_3R_27()) return true;
2491    if (jj_scan_token(RPAREN)) return true;
2492    return false;
2493  }
2494
2495  final private boolean jj_3R_60() {
2496    if (jj_scan_token(MINUS)) return true;
2497    if (jj_3R_55()) return true;
2498    return false;
2499  }
2500
2501  final private boolean jj_3R_44() {
2502    if (jj_scan_token(ASSIGN)) return true;
2503    if (jj_3R_35()) return true;
2504    return false;
2505  }
2506
2507  final private boolean jj_3R_40() {
2508    Token xsp;
2509    xsp = jj_scanpos;
2510    if (jj_3R_44()) {
2511    jj_scanpos = xsp;
2512    if (jj_3R_45()) return true;
2513    }
2514    return false;
2515  }
2516
2517  final private boolean jj_3R_59() {
2518    if (jj_scan_token(INC)) return true;
2519    if (jj_3R_55()) return true;
2520    return false;
2521  }
2522
2523  final private boolean jj_3R_76() {
2524    if (jj_3R_37()) return true;
2525    Token xsp;
2526    xsp = jj_scanpos;
2527    if (jj_3R_84()) jj_scanpos = xsp;
2528    return false;
2529  }
2530
2531  final private boolean jj_3R_55() {
2532    Token xsp;
2533    xsp = jj_scanpos;
2534    if (jj_3R_59()) {
2535    jj_scanpos = xsp;
2536    if (jj_3R_60()) {
2537    jj_scanpos = xsp;
2538    if (jj_3R_61()) return true;
2539    }
2540    }
2541    return false;
2542  }
2543
2544  final private boolean jj_3R_87() {
2545    if (jj_scan_token(LPAREN)) return true;
2546    Token xsp;
2547    xsp = jj_scanpos;
2548    if (jj_3R_99()) jj_scanpos = xsp;
2549    if (jj_scan_token(RPAREN)) return true;
2550    return false;
2551  }
2552
2553  final private boolean jj_3R_88() {
2554    if (jj_3R_87()) return true;
2555    return false;
2556  }
2557
2558  final private boolean jj_3R_35() {
2559    if (jj_3R_39()) return true;
2560    Token xsp;
2561    xsp = jj_scanpos;
2562    if (jj_3R_40()) jj_scanpos = xsp;
2563    return false;
2564  }
2565
2566  final private boolean jj_3R_75() {
2567    if (jj_scan_token(NEW)) return true;
2568    if (jj_3R_83()) return true;
2569    return false;
2570  }
2571
2572  final private boolean jj_3R_74() {
2573    if (jj_3R_82()) return true;
2574    return false;
2575  }
2576
2577  final private boolean jj_3R_22() {
2578    if (jj_3R_23()) return true;
2579    return false;
2580  }
2581
2582  public JavaCCParserTokenManager token_source;
2583  SimpleCharStream jj_input_stream;
2584  public Token token, jj_nt;
2585  private int jj_ntk;
2586  private Token jj_scanpos, jj_lastpos;
2587  private int jj_la;
2588  public boolean lookingAhead = false;
2589  private boolean jj_semLA;
2590  private int jj_gen;
2591  final private int[] jj_la1 = new int[55];
2592  static private int[] jj_la1_0;
2593  static private int[] jj_la1_1;
2594  static {
2595      jj_la1_0();
2596      jj_la1_1();
2597   }
2598   private static void jj_la1_0() {
2599      jj_la1_0 = new int[] {0x100000,0x8000,0x2e00480,0x0,0x2e00080,0x2e00080,0x1000,0x22e20380,0x20020300,0x0,0x20300,0x5d0e6300,0x5d0c6000,0x1c0c2000,0x5d0c6000,0x0,0x20300,0x0,0x0,0x1c0c2000,0x0,0x1c0c2000,0x0,0x1c0c2000,0x20300,0x20300,0x0,0x0,0x20300,0x0,0x0,0x0,0x0,0x10000,0x10000,0x80000000,0x80000000,0x0,0x1c0c2000,0x0,0x1c0c2000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0c2000,0x20300,0x0,0x20300,0x0,0x10082000,};
2600   }
2601   private static void jj_la1_1() {
2602      jj_la1_1 = new int[] {0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x100000,0x100000,0x22000,0x100000,0x7122990,0x7122990,0x7100990,0x7122990,0x40000,0x100000,0x40000,0x1,0x7102990,0x40000,0x7102990,0x40000,0x7100990,0x0,0x0,0x8000,0x8000,0x100000,0x201,0x201,0x20,0x4,0x48,0x48,0x100,0x100,0x400,0x7100990,0x80,0x7100800,0x88000,0x2,0x800,0x88000,0x800,0x800,0x80800,0x800,0x7100800,0x100000,0x2000,0x100000,0x8000,0x7000000,};
2603   }
2604  final private JJCalls[] jj_2_rtns = new JJCalls[11];
2605  private boolean jj_rescan = false;
2606  private int jj_gc = 0;
2607
2608  public JavaCCParser(java.io.InputStream stream) {
2609     this(stream, null);
2610  }
2611  public JavaCCParser(java.io.InputStream stream, String encoding) {
2612    try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
2613    token_source = new JavaCCParserTokenManager(jj_input_stream);
2614    token = new Token();
2615    jj_ntk = -1;
2616    jj_gen = 0;
2617    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
2618    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2619  }
2620
2621  public void ReInit(java.io.InputStream stream) {
2622     ReInit(stream, null);
2623  }
2624  public void ReInit(java.io.InputStream stream, String encoding) {
2625    try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
2626    token_source.ReInit(jj_input_stream);
2627    token = new Token();
2628    jj_ntk = -1;
2629    jj_gen = 0;
2630    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
2631    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2632  }
2633
2634  public JavaCCParser(java.io.Reader stream) {
2635    jj_input_stream = new SimpleCharStream(stream, 1, 1);
2636    token_source = new JavaCCParserTokenManager(jj_input_stream);
2637    token = new Token();
2638    jj_ntk = -1;
2639    jj_gen = 0;
2640    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
2641    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2642  }
2643
2644  public void ReInit(java.io.Reader stream) {
2645    jj_input_stream.ReInit(stream, 1, 1);
2646    token_source.ReInit(jj_input_stream);
2647    token = new Token();
2648    jj_ntk = -1;
2649    jj_gen = 0;
2650    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
2651    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2652  }
2653
2654  public JavaCCParser(JavaCCParserTokenManager tm) {
2655    token_source = tm;
2656    token = new Token();
2657    jj_ntk = -1;
2658    jj_gen = 0;
2659    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
2660    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2661  }
2662
2663  public void ReInit(JavaCCParserTokenManager tm) {
2664    token_source = tm;
2665    token = new Token();
2666    jj_ntk = -1;
2667    jj_gen = 0;
2668    for (int i = 0; i < 55; i++) jj_la1[i] = -1;
2669    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2670  }
2671
2672  final private Token jj_consume_token(int kind) throws ParseException {
2673    Token oldToken;
2674    if ((oldToken = token).next != null) token = token.next;
2675    else token = token.next = token_source.getNextToken();
2676    jj_ntk = -1;
2677    if (token.kind == kind) {
2678      jj_gen++;
2679      if (++jj_gc > 100) {
2680        jj_gc = 0;
2681        for (int i = 0; i < jj_2_rtns.length; i++) {
2682          JJCalls c = jj_2_rtns[i];
2683          while (c != null) {
2684            if (c.gen < jj_gen) c.first = null;
2685            c = c.next;
2686          }
2687        }
2688      }
2689      return token;
2690    }
2691    token = oldToken;
2692    jj_kind = kind;
2693    throw generateParseException();
2694  }
2695
2696  static private final class LookaheadSuccess extends java.lang.Error { }
2697  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
2698  final private boolean jj_scan_token(int kind) {
2699    if (jj_scanpos == jj_lastpos) {
2700      jj_la--;
2701      if (jj_scanpos.next == null) {
2702        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
2703      } else {
2704        jj_lastpos = jj_scanpos = jj_scanpos.next;
2705      }
2706    } else {
2707      jj_scanpos = jj_scanpos.next;
2708    }
2709    if (jj_rescan) {
2710      int i = 0; Token tok = token;
2711      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
2712      if (tok != null) jj_add_error_token(kind, i);
2713    }
2714    if (jj_scanpos.kind != kind) return true;
2715    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
2716    return false;
2717  }
2718
2719  final public Token getNextToken() {
2720    if (token.next != null) token = token.next;
2721    else token = token.next = token_source.getNextToken();
2722    jj_ntk = -1;
2723    jj_gen++;
2724    return token;
2725  }
2726
2727  final public Token getToken(int index) {
2728    Token t = lookingAhead ? jj_scanpos : token;
2729    for (int i = 0; i < index; i++) {
2730      if (t.next != null) t = t.next;
2731      else t = t.next = token_source.getNextToken();
2732    }
2733    return t;
2734  }
2735
2736  final private int jj_ntk() {
2737    if ((jj_nt=token.next) == null)
2738      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
2739    else
2740      return (jj_ntk = jj_nt.kind);
2741  }
2742
2743  private java.util.Vector jj_expentries = new java.util.Vector();
2744  private int[] jj_expentry;
2745  private int jj_kind = -1;
2746  private int[] jj_lasttokens = new int[100];
2747  private int jj_endpos;
2748
2749  private void jj_add_error_token(int kind, int pos) {
2750    if (pos >= 100) return;
2751    if (pos == jj_endpos + 1) {
2752      jj_lasttokens[jj_endpos++] = kind;
2753    } else if (jj_endpos != 0) {
2754      jj_expentry = new int[jj_endpos];
2755      for (int i = 0; i < jj_endpos; i++) {
2756        jj_expentry[i] = jj_lasttokens[i];
2757      }
2758      boolean exists = false;
2759      for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
2760        int[] oldentry = (int[])(e.nextElement());
2761        if (oldentry.length == jj_expentry.length) {
2762          exists = true;
2763          for (int i = 0; i < jj_expentry.length; i++) {
2764            if (oldentry[i] != jj_expentry[i]) {
2765              exists = false;
2766              break;
2767            }
2768          }
2769          if (exists) break;
2770        }
2771      }
2772      if (!exists) jj_expentries.addElement(jj_expentry);
2773      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
2774    }
2775  }
2776
2777  public ParseException generateParseException() {
2778    jj_expentries.removeAllElements();
2779    boolean[] la1tokens = new boolean[61];
2780    for (int i = 0; i < 61; i++) {
2781      la1tokens[i] = false;
2782    }
2783    if (jj_kind >= 0) {
2784      la1tokens[jj_kind] = true;
2785      jj_kind = -1;
2786    }
2787    for (int i = 0; i < 55; i++) {
2788      if (jj_la1[i] == jj_gen) {
2789        for (int j = 0; j < 32; j++) {
2790          if ((jj_la1_0[i] & (1<<j)) != 0) {
2791            la1tokens[j] = true;
2792          }
2793          if ((jj_la1_1[i] & (1<<j)) != 0) {
2794            la1tokens[32+j] = true;
2795          }
2796        }
2797      }
2798    }
2799    for (int i = 0; i < 61; i++) {
2800      if (la1tokens[i]) {
2801        jj_expentry = new int[1];
2802        jj_expentry[0] = i;
2803        jj_expentries.addElement(jj_expentry);
2804      }
2805    }
2806    jj_endpos = 0;
2807    jj_rescan_token();
2808    jj_add_error_token(0, 0);
2809    int[][] exptokseq = new int[jj_expentries.size()][];
2810    for (int i = 0; i < jj_expentries.size(); i++) {
2811      exptokseq[i] = (int[])jj_expentries.elementAt(i);
2812    }
2813    return new ParseException(token, exptokseq, tokenImage);
2814  }
2815
2816  final public void enable_tracing() {
2817  }
2818
2819  final public void disable_tracing() {
2820  }
2821
2822  final private void jj_rescan_token() {
2823    jj_rescan = true;
2824    for (int i = 0; i < 11; i++) {
2825    try {
2826      JJCalls p = jj_2_rtns[i];
2827      do {
2828        if (p.gen > jj_gen) {
2829          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
2830          switch (i) {
2831            case 0: jj_3_1(); break;
2832            case 1: jj_3_2(); break;
2833            case 2: jj_3_3(); break;
2834            case 3: jj_3_4(); break;
2835            case 4: jj_3_5(); break;
2836            case 5: jj_3_6(); break;
2837            case 6: jj_3_7(); break;
2838            case 7: jj_3_8(); break;
2839            case 8: jj_3_9(); break;
2840            case 9: jj_3_10(); break;
2841            case 10: jj_3_11(); break;
2842          }
2843        }
2844        p = p.next;
2845      } while (p != null);
2846      } catch(LookaheadSuccess ls) { }
2847    }
2848    jj_rescan = false;
2849  }
2850
2851  final private void jj_save(int index, int xla) {
2852    JJCalls p = jj_2_rtns[index];
2853    while (p.gen > jj_gen) {
2854      if (p.next == null) { p = p.next = new JJCalls(); break; }
2855      p = p.next;
2856    }
2857    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
2858  }
2859
2860  static final class JJCalls {
2861    int gen;
2862    Token first;
2863    int arg;
2864    JJCalls next;
2865  }
2866
2867}
2868