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