1
2
3 package jminusminus;
4
5 import java.util.ArrayList;
6
7
11 class JavaCCParser implements JavaCCParserConstants {
12 private boolean errorHasOccurred;
14
15 private String fileName;
17
18
23 public void fileName(String fileName) {
24 this.fileName = fileName;
25 }
26
27
32 public boolean errorHasOccurred() {
33 return errorHasOccurred;
34 }
35
36 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 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 private void recoverFromError(int[] skipTo, ParseException e) {
56 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 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 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 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 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 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
2676 public JavaCCParserTokenManager token_source;
2677 SimpleCharStream jj_input_stream;
2678
2679 public Token token;
2680
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
2704 public JavaCCParser(java.io.InputStream stream) {
2705 this(stream, null);
2706 }
2707
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
2719 public void ReInit(java.io.InputStream stream) {
2720 ReInit(stream, null);
2721 }
2722
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
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
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
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
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
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
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
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
2947 final public boolean trace_enabled() {
2948 return trace_enabled;
2949 }
2950
2951
2952 final public void enable_tracing() {
2953 }
2954
2955
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