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