|
1
2
9 package org.codehaus.aspectwerkz.expression.ast;
10
11 import java.lang.reflect.Modifier  ;
12 import java.io.Reader ;
13 import java.io.StringReader ;
14
15
31 public class ExpressionParserimplements ExpressionParserTreeConstants, ExpressionParserConstants {
32 protected static JJTExpressionParserState jjtree = new JJTExpressionParserState();
33 public ASTRoot parse(String expression) throws ParseException {
34 return parse(new StringReader (expression));
35 }
36
37 public ASTRoot parse(Reader reader) throws ParseException {
38 ReInit(reader);
39 return Root();
40 }
41
42
44
47 static final public ASTRoot Root() throws ParseException {
48
49 ASTRoot jjtn000 = new ASTRoot(JJTROOT);
50 boolean jjtc000 = true;
51 jjtree.openNodeScope(jjtn000);
52 try {
53 Expression();
54 jj_consume_token(0);
55 jjtree.closeNodeScope(jjtn000, true);
56 jjtc000 = false;
57 {if (true) return jjtn000;}
58 } catch (Throwable jjte000) {
59 if (jjtc000) {
60 jjtree.clearNodeScope(jjtn000);
61 jjtc000 = false;
62 } else {
63 jjtree.popNode();
64 }
65 if (jjte000 instanceof RuntimeException ) {
66 {if (true) throw (RuntimeException )jjte000;}
67 }
68 if (jjte000 instanceof ParseException) {
69 {if (true) throw (ParseException)jjte000;}
70 }
71 {if (true) throw (Error )jjte000;}
72 } finally {
73 if (jjtc000) {
74 jjtree.closeNodeScope(jjtn000, true);
75 }
76 }
77 throw new Error ("Missing return statement in function");
78 }
79
80
83 static final public void Expression() throws ParseException {
84
85 ASTExpression jjtn000 = new ASTExpression(JJTEXPRESSION);
86 boolean jjtc000 = true;
87 jjtree.openNodeScope(jjtn000);
88 try {
89 AndExpression();
90 } catch (Throwable jjte000) {
91 if (jjtc000) {
92 jjtree.clearNodeScope(jjtn000);
93 jjtc000 = false;
94 } else {
95 jjtree.popNode();
96 }
97 if (jjte000 instanceof RuntimeException ) {
98 {if (true) throw (RuntimeException )jjte000;}
99 }
100 if (jjte000 instanceof ParseException) {
101 {if (true) throw (ParseException)jjte000;}
102 }
103 {if (true) throw (Error )jjte000;}
104 } finally {
105 if (jjtc000) {
106 jjtree.closeNodeScope(jjtn000, true);
107 }
108 }
109 }
110
111
113
116 static final public void AndExpression() throws ParseException {
117 ASTAnd jjtn001 = new ASTAnd(JJTAND);
118 boolean jjtc001 = true;
119 jjtree.openNodeScope(jjtn001);
120 try {
121 OrExpression();
122 label_1:
123 while (true) {
124 if (jj_2_1(2)) {
125 ;
126 } else {
127 break label_1;
128 }
129 jj_consume_token(AND);
130 OrExpression();
131 }
132 } catch (Throwable jjte001) {
133 if (jjtc001) {
134 jjtree.clearNodeScope(jjtn001);
135 jjtc001 = false;
136 } else {
137 jjtree.popNode();
138 }
139 if (jjte001 instanceof RuntimeException ) {
140 {if (true) throw (RuntimeException )jjte001;}
141 }
142 if (jjte001 instanceof ParseException) {
143 {if (true) throw (ParseException)jjte001;}
144 }
145 {if (true) throw (Error )jjte001;}
146 } finally {
147 if (jjtc001) {
148 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
149 }
150 }
151 }
152
153
156 static final public void OrExpression() throws ParseException {
157 ASTOr jjtn001 = new ASTOr(JJTOR);
158 boolean jjtc001 = true;
159 jjtree.openNodeScope(jjtn001);
160 try {
161 UnaryExpression();
162 label_2:
163 while (true) {
164 if (jj_2_2(2)) {
165 ;
166 } else {
167 break label_2;
168 }
169 jj_consume_token(OR);
170 AndExpression();
171 }
172 } catch (Throwable jjte001) {
173 if (jjtc001) {
174 jjtree.clearNodeScope(jjtn001);
175 jjtc001 = false;
176 } else {
177 jjtree.popNode();
178 }
179 if (jjte001 instanceof RuntimeException ) {
180 {if (true) throw (RuntimeException )jjte001;}
181 }
182 if (jjte001 instanceof ParseException) {
183 {if (true) throw (ParseException)jjte001;}
184 }
185 {if (true) throw (Error )jjte001;}
186 } finally {
187 if (jjtc001) {
188 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
189 }
190 }
191 }
192
193
196 static final public void UnaryExpression() throws ParseException {
197 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
198 case NOT:
199 NotExpression();
200 break;
201 case 86:
202 jj_consume_token(86);
203 Expression();
204 jj_consume_token(87);
205 break;
206 case EXECUTION:
207 case CALL:
208 case SET:
209 case GET:
210 case HANDLER:
211 case WITHIN:
212 case WITHIN_CODE:
213 case STATIC_INITIALIZATION:
214 case CFLOW:
215 case CFLOW_BELOW:
216 case ARGS:
217 case TARGET:
218 case THIS:
219 case HAS_METHOD:
220 case HAS_FIELD:
221 case POINTCUT_REFERENCE_WITH_ARGS:
222 case POINTCUT_REFERENCE:
223 Pointcut();
224 break;
225 default:
226 jj_la1[0] = jj_gen;
227 jj_consume_token(-1);
228 throw new ParseException();
229 }
230 }
231
232
235 static final public void NotExpression() throws ParseException {
236 jj_consume_token(NOT);
237 ASTNot jjtn001 = new ASTNot(JJTNOT);
238 boolean jjtc001 = true;
239 jjtree.openNodeScope(jjtn001);
240 try {
241 UnaryExpression();
242 } catch (Throwable jjte001) {
243 if (jjtc001) {
244 jjtree.clearNodeScope(jjtn001);
245 jjtc001 = false;
246 } else {
247 jjtree.popNode();
248 }
249 if (jjte001 instanceof RuntimeException ) {
250 {if (true) throw (RuntimeException )jjte001;}
251 }
252 if (jjte001 instanceof ParseException) {
253 {if (true) throw (ParseException)jjte001;}
254 }
255 {if (true) throw (Error )jjte001;}
256 } finally {
257 if (jjtc001) {
258 jjtree.closeNodeScope(jjtn001, true);
259 }
260 }
261 }
262
263
265
268 static final public void Pointcut() throws ParseException {
269 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
270 case CALL:
271 Call();
272 break;
273 case EXECUTION:
274 Execution();
275 break;
276 case WITHIN_CODE:
277 WithinCode();
278 break;
279 case HAS_METHOD:
280 HasMethod();
281 break;
282 case SET:
283 Set();
284 break;
285 case GET:
286 Get();
287 break;
288 case HAS_FIELD:
289 HasField();
290 break;
291 case WITHIN:
292 Within();
293 break;
294 case HANDLER:
295 Handler();
296 break;
297 case ARGS:
298 Args();
299 break;
300 case TARGET:
301 Target();
302 break;
303 case THIS:
304 This();
305 break;
306 case CFLOW:
307 Cflow();
308 break;
309 case CFLOW_BELOW:
310 CflowBelow();
311 break;
312 case STATIC_INITIALIZATION:
313 StaticInitialization();
314 break;
315 case POINTCUT_REFERENCE_WITH_ARGS:
316 case POINTCUT_REFERENCE:
317 PointcutReference();
318 break;
319 default:
320 jj_la1[1] = jj_gen;
321 jj_consume_token(-1);
322 throw new ParseException();
323 }
324 }
325
326
329 static final public void PointcutReference() throws ParseException {
330
331 ASTPointcutReference jjtn000 = new ASTPointcutReference(JJTPOINTCUTREFERENCE);
332 boolean jjtc000 = true;
333 jjtree.openNodeScope(jjtn000);Token name;
334 try {
335 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
336 case POINTCUT_REFERENCE_WITH_ARGS:
337 name = jj_consume_token(POINTCUT_REFERENCE_WITH_ARGS);
338 break;
339 case POINTCUT_REFERENCE:
340 name = jj_consume_token(POINTCUT_REFERENCE);
341 break;
342 default:
343 jj_la1[2] = jj_gen;
344 jj_consume_token(-1);
345 throw new ParseException();
346 }
347 jjtn000.setName(name.image);
348 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
349 case COMMA:
350 case EAGER_WILDCARD:
351 case ARG_PATTERN:
352 case ARG_ARRAY_PATTERN:
353 case ARGS_END:
354 ArgsParameters();
355 jj_consume_token(ARGS_END);
356 break;
357 default:
358 jj_la1[3] = jj_gen;
359 ;
360 }
361 } catch (Throwable jjte000) {
362 if (jjtc000) {
363 jjtree.clearNodeScope(jjtn000);
364 jjtc000 = false;
365 } else {
366 jjtree.popNode();
367 }
368 if (jjte000 instanceof RuntimeException ) {
369 {if (true) throw (RuntimeException )jjte000;}
370 }
371 if (jjte000 instanceof ParseException) {
372 {if (true) throw (ParseException)jjte000;}
373 }
374 {if (true) throw (Error )jjte000;}
375 } finally {
376 if (jjtc000) {
377 jjtree.closeNodeScope(jjtn000, true);
378 }
379 }
380 }
381
382
385 static final public void Execution() throws ParseException {
386
387 ASTExecution jjtn000 = new ASTExecution(JJTEXECUTION);
388 boolean jjtc000 = true;
389 jjtree.openNodeScope(jjtn000);
390 try {
391 jj_consume_token(EXECUTION);
392 label_3:
393 while (true) {
394 if (jj_2_3(2)) {
395 ;
396 } else {
397 break label_3;
398 }
399 MethodAttribute();
400 }
401 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
402 case METHOD_PARAMETER_END:
403 jj_consume_token(METHOD_PARAMETER_END);
404 break;
405 case METHOD_PUBLIC:
406 case METHOD_PROTECTED:
407 case METHOD_PRIVATE:
408 case METHOD_STATIC:
409 case METHOD_ABSTRACT:
410 case METHOD_FINAL:
411 case METHOD_NATIVE:
412 case METHOD_SYNCHRONIZED:
413 case METHOD_NOT:
414 case METHOD_CLASS_PATTERN:
415 case METHOD_ARRAY_CLASS_PATTERN:
416 case 87:
417 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
418 case METHOD_PUBLIC:
419 case METHOD_PROTECTED:
420 case METHOD_PRIVATE:
421 case METHOD_STATIC:
422 case METHOD_ABSTRACT:
423 case METHOD_FINAL:
424 case METHOD_NATIVE:
425 case METHOD_SYNCHRONIZED:
426 case METHOD_NOT:
427 case METHOD_CLASS_PATTERN:
428 case METHOD_ARRAY_CLASS_PATTERN:
429 if (jj_2_4(4)) {
430 ConstructorPattern();
431 } else {
432 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
433 case METHOD_PUBLIC:
434 case METHOD_PROTECTED:
435 case METHOD_PRIVATE:
436 case METHOD_STATIC:
437 case METHOD_ABSTRACT:
438 case METHOD_FINAL:
439 case METHOD_NATIVE:
440 case METHOD_SYNCHRONIZED:
441 case METHOD_NOT:
442 case METHOD_CLASS_PATTERN:
443 case METHOD_ARRAY_CLASS_PATTERN:
444 MethodPattern();
445 break;
446 default:
447 jj_la1[4] = jj_gen;
448 jj_consume_token(-1);
449 throw new ParseException();
450 }
451 }
452 break;
453 default:
454 jj_la1[5] = jj_gen;
455 ;
456 }
457 jj_consume_token(87);
458 break;
459 default:
460 jj_la1[6] = jj_gen;
461 jj_consume_token(-1);
462 throw new ParseException();
463 }
464 } catch (Throwable jjte000) {
465 if (jjtc000) {
466 jjtree.clearNodeScope(jjtn000);
467 jjtc000 = false;
468 } else {
469 jjtree.popNode();
470 }
471 if (jjte000 instanceof RuntimeException ) {
472 {if (true) throw (RuntimeException )jjte000;}
473 }
474 if (jjte000 instanceof ParseException) {
475 {if (true) throw (ParseException)jjte000;}
476 }
477 {if (true) throw (Error )jjte000;}
478 } finally {
479 if (jjtc000) {
480 jjtree.closeNodeScope(jjtn000, true);
481 }
482 }
483 }
484
485
488 static final public void Call() throws ParseException {
489
490 ASTCall jjtn000 = new ASTCall(JJTCALL);
491 boolean jjtc000 = true;
492 jjtree.openNodeScope(jjtn000);
493 try {
494 jj_consume_token(CALL);
495 label_4:
496 while (true) {
497 if (jj_2_5(2)) {
498 ;
499 } else {
500 break label_4;
501 }
502 MethodAttribute();
503 }
504 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
505 case METHOD_PARAMETER_END:
506 jj_consume_token(METHOD_PARAMETER_END);
507 break;
508 case METHOD_PUBLIC:
509 case METHOD_PROTECTED:
510 case METHOD_PRIVATE:
511 case METHOD_STATIC:
512 case METHOD_ABSTRACT:
513 case METHOD_FINAL:
514 case METHOD_NATIVE:
515 case METHOD_SYNCHRONIZED:
516 case METHOD_NOT:
517 case METHOD_CLASS_PATTERN:
518 case METHOD_ARRAY_CLASS_PATTERN:
519 case 87:
520 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
521 case METHOD_PUBLIC:
522 case METHOD_PROTECTED:
523 case METHOD_PRIVATE:
524 case METHOD_STATIC:
525 case METHOD_ABSTRACT:
526 case METHOD_FINAL:
527 case METHOD_NATIVE:
528 case METHOD_SYNCHRONIZED:
529 case METHOD_NOT:
530 case METHOD_CLASS_PATTERN:
531 case METHOD_ARRAY_CLASS_PATTERN:
532 if (jj_2_6(4)) {
533 ConstructorPattern();
534 } else {
535 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
536 case METHOD_PUBLIC:
537 case METHOD_PROTECTED:
538 case METHOD_PRIVATE:
539 case METHOD_STATIC:
540 case METHOD_ABSTRACT:
541 case METHOD_FINAL:
542 case METHOD_NATIVE:
543 case METHOD_SYNCHRONIZED:
544 case METHOD_NOT:
545 case METHOD_CLASS_PATTERN:
546 case METHOD_ARRAY_CLASS_PATTERN:
547 MethodPattern();
548 break;
549 default:
550 jj_la1[7] = jj_gen;
551 jj_consume_token(-1);
552 throw new ParseException();
553 }
554 }
555 break;
556 default:
557 jj_la1[8] = jj_gen;
558 ;
559 }
560 jj_consume_token(87);
561 break;
562 default:
563 jj_la1[9] = jj_gen;
564 jj_consume_token(-1);
565 throw new ParseException();
566 }
567 } catch (Throwable jjte000) {
568 if (jjtc000) {
569 jjtree.clearNodeScope(jjtn000);
570 jjtc000 = false;
571 } else {
572 jjtree.popNode();
573 }
574 if (jjte000 instanceof RuntimeException ) {
575 {if (true) throw (RuntimeException )jjte000;}
576 }
577 if (jjte000 instanceof ParseException) {
578 {if (true) throw (ParseException)jjte000;}
579 }
580 {if (true) throw (Error )jjte000;}
581 } finally {
582 if (jjtc000) {
583 jjtree.closeNodeScope(jjtn000, true);
584 }
585 }
586 }
587
588
591 static final public void Set() throws ParseException {
592
593 ASTSet jjtn000 = new ASTSet(JJTSET);
594 boolean jjtc000 = true;
595 jjtree.openNodeScope(jjtn000);
596 try {
597 jj_consume_token(SET);
598 label_5:
599 while (true) {
600 if (jj_2_7(2)) {
601 ;
602 } else {
603 break label_5;
604 }
605 FieldAttribute();
606 }
607 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
608 case FIELD_PRIVATE:
609 case FIELD_PROTECTED:
610 case FIELD_PUBLIC:
611 case FIELD_STATIC:
612 case FIELD_ABSTRACT:
613 case FIELD_FINAL:
614 case FIELD_TRANSIENT:
615 case FIELD_NOT:
616 case FIELD_CLASS_PATTERN:
617 case FIELD_ARRAY_CLASS_PATTERN:
618 FieldPattern();
619 break;
620 default:
621 jj_la1[10] = jj_gen;
622 ;
623 }
624 jj_consume_token(FIELD_POINTCUT_END);
625 } catch (Throwable jjte000) {
626 if (jjtc000) {
627 jjtree.clearNodeScope(jjtn000);
628 jjtc000 = false;
629 } else {
630 jjtree.popNode();
631 }
632 if (jjte000 instanceof RuntimeException ) {
633 {if (true) throw (RuntimeException )jjte000;}
634 }
635 if (jjte000 instanceof ParseException) {
636 {if (true) throw (ParseException)jjte000;}
637 }
638 {if (true) throw (Error )jjte000;}
639 } finally {
640 if (jjtc000) {
641 jjtree.closeNodeScope(jjtn000, true);
642 }
643 }
644 }
645
646
649 static final public void Get() throws ParseException {
650
651 ASTGet jjtn000 = new ASTGet(JJTGET);
652 boolean jjtc000 = true;
653 jjtree.openNodeScope(jjtn000);
654 try {
655 jj_consume_token(GET);
656 label_6:
657 while (true) {
658 if (jj_2_8(2)) {
659 ;
660 } else {
661 break label_6;
662 }
663 FieldAttribute();
664 }
665 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
666 case FIELD_PRIVATE:
667 case FIELD_PROTECTED:
668 case FIELD_PUBLIC:
669 case FIELD_STATIC:
670 case FIELD_ABSTRACT:
671 case FIELD_FINAL:
672 case FIELD_TRANSIENT:
673 case FIELD_NOT:
674 case FIELD_CLASS_PATTERN:
675 case FIELD_ARRAY_CLASS_PATTERN:
676 FieldPattern();
677 break;
678 default:
679 jj_la1[11] = jj_gen;
680 ;
681 }
682 jj_consume_token(FIELD_POINTCUT_END);
683 } catch (Throwable jjte000) {
684 if (jjtc000) {
685 jjtree.clearNodeScope(jjtn000);
686 jjtc000 = false;
687 } else {
688 jjtree.popNode();
689 }
690 if (jjte000 instanceof RuntimeException ) {
691 {if (true) throw (RuntimeException )jjte000;}
692 }
693 if (jjte000 instanceof ParseException) {
694 {if (true) throw (ParseException)jjte000;}
695 }
696 {if (true) throw (Error )jjte000;}
697 } finally {
698 if (jjtc000) {
699 jjtree.closeNodeScope(jjtn000, true);
700 }
701 }
702 }
703
704
707 static final public void Handler() throws ParseException {
708
709 ASTHandler jjtn000 = new ASTHandler(JJTHANDLER);
710 boolean jjtc000 = true;
711 jjtree.openNodeScope(jjtn000);
712 try {
713 jj_consume_token(HANDLER);
714 ClassPattern();
715 jj_consume_token(CLASS_POINTCUT_END);
716 } catch (Throwable jjte000) {
717 if (jjtc000) {
718 jjtree.clearNodeScope(jjtn000);
719 jjtc000 = false;
720 } else {
721 jjtree.popNode();
722 }
723 if (jjte000 instanceof RuntimeException ) {
724 {if (true) throw (RuntimeException )jjte000;}
725 }
726 if (jjte000 instanceof ParseException) {
727 {if (true) throw (ParseException)jjte000;}
728 }
729 {if (true) throw (Error )jjte000;}
730 } finally {
731 if (jjtc000) {
732 jjtree.closeNodeScope(jjtn000, true);
733 }
734 }
735 }
736
737
740 static final public void Within() throws ParseException {
741
742 ASTWithin jjtn000 = new ASTWithin(JJTWITHIN);
743 boolean jjtc000 = true;
744 jjtree.openNodeScope(jjtn000);
745 try {
746 jj_consume_token(WITHIN);
747 label_7:
748 while (true) {
749 if (jj_2_9(2)) {
750 ;
751 } else {
752 break label_7;
753 }
754 ClassAttribute();
755 }
756 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
757 case EAGER_WILDCARD:
758 case CLASS_PRIVATE:
759 case CLASS_PROTECTED:
760 case CLASS_PUBLIC:
761 case CLASS_STATIC:
762 case CLASS_ABSTRACT:
763 case CLASS_FINAL:
764 case CLASS_NOT:
765 case CLASS_PATTERN:
766 ClassPattern();
767 break;
768 default:
769 jj_la1[12] = jj_gen;
770 ;
771 }
772 jj_consume_token(CLASS_POINTCUT_END);
773 } catch (Throwable jjte000) {
774 if (jjtc000) {
775 jjtree.clearNodeScope(jjtn000);
776 jjtc000 = false;
777 } else {
778 jjtree.popNode();
779 }
780 if (jjte000 instanceof RuntimeException ) {
781 {if (true) throw (RuntimeException )jjte000;}
782 }
783 if (jjte000 instanceof ParseException) {
784 {if (true) throw (ParseException)jjte000;}
785 }
786 {if (true) throw (Error )jjte000;}
787 } finally {
788 if (jjtc000) {
789 jjtree.closeNodeScope(jjtn000, true);
790 }
791 }
792 }
793
794
797 static final public void WithinCode() throws ParseException {
798
799 ASTWithinCode jjtn000 = new ASTWithinCode(JJTWITHINCODE);
800 boolean jjtc000 = true;
801 jjtree.openNodeScope(jjtn000);Token tkn = null;
802 try {
803 jj_consume_token(WITHIN_CODE);
804 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
805 case TYPE_STATICINITIALIZATION:
806 WithinStaticInitialization();
807 jj_consume_token(87);
808 jjtree.closeNodeScope(jjtn000, true);
809 jjtc000 = false;
810 jjtn000.setStaticInitializer(true);
811 break;
812 case METHOD_PUBLIC:
813 case METHOD_PROTECTED:
814 case METHOD_PRIVATE:
815 case METHOD_STATIC:
816 case METHOD_ABSTRACT:
817 case METHOD_FINAL:
818 case METHOD_NATIVE:
819 case METHOD_SYNCHRONIZED:
820 case METHOD_NOT:
821 case METHOD_ANNOTATION:
822 case METHOD_CLASS_PATTERN:
823 case METHOD_ARRAY_CLASS_PATTERN:
824 case METHOD_PARAMETER_END:
825 case 87:
826 label_8:
827 while (true) {
828 if (jj_2_10(2)) {
829 ;
830 } else {
831 break label_8;
832 }
833 MethodAttribute();
834 }
835 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
836 case METHOD_PARAMETER_END:
837 jj_consume_token(METHOD_PARAMETER_END);
838 break;
839 case METHOD_PUBLIC:
840 case METHOD_PROTECTED:
841 case METHOD_PRIVATE:
842 case METHOD_STATIC:
843 case METHOD_ABSTRACT:
844 case METHOD_FINAL:
845 case METHOD_NATIVE:
846 case METHOD_SYNCHRONIZED:
847 case METHOD_NOT:
848 case METHOD_CLASS_PATTERN:
849 case METHOD_ARRAY_CLASS_PATTERN:
850 case 87:
851 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
852 case METHOD_PUBLIC:
853 case METHOD_PROTECTED:
854 case METHOD_PRIVATE:
855 case METHOD_STATIC:
856 case METHOD_ABSTRACT:
857 case METHOD_FINAL:
858 case METHOD_NATIVE:
859 case METHOD_SYNCHRONIZED:
860 case METHOD_NOT:
861 case METHOD_CLASS_PATTERN:
862 case METHOD_ARRAY_CLASS_PATTERN:
863 if (jj_2_11(4)) {
864 ConstructorPattern();
865 } else {
866 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
867 case METHOD_PUBLIC:
868 case METHOD_PROTECTED:
869 case METHOD_PRIVATE:
870 case METHOD_STATIC:
871 case METHOD_ABSTRACT:
872 case METHOD_FINAL:
873 case METHOD_NATIVE:
874 case METHOD_SYNCHRONIZED:
875 case METHOD_NOT:
876 case METHOD_CLASS_PATTERN:
877 case METHOD_ARRAY_CLASS_PATTERN:
878 MethodPattern();
879 break;
880 default:
881 jj_la1[13] = jj_gen;
882 jj_consume_token(-1);
883 throw new ParseException();
884 }
885 }
886 break;
887 default:
888 jj_la1[14] = jj_gen;
889 ;
890 }
891 jj_consume_token(87);
892 break;
893 default:
894 jj_la1[15] = jj_gen;
895 jj_consume_token(-1);
896 throw new ParseException();
897 }
898 break;
899 default:
900 jj_la1[16] = jj_gen;
901 jj_consume_token(-1);
902 throw new ParseException();
903 }
904 } catch (Throwable jjte000) {
905 if (jjtc000) {
906 jjtree.clearNodeScope(jjtn000);
907 jjtc000 = false;
908 } else {
909 jjtree.popNode();
910 }
911 if (jjte000 instanceof RuntimeException ) {
912 {if (true) throw (RuntimeException )jjte000;}
913 }
914 if (jjte000 instanceof ParseException) {
915 {if (true) throw (ParseException)jjte000;}
916 }
917 {if (true) throw (Error )jjte000;}
918 } finally {
919 if (jjtc000) {
920 jjtree.closeNodeScope(jjtn000, true);
921 }
922 }
923 }
924
925 static final public void WithinStaticInitialization() throws ParseException {
926
927 ASTStaticInitialization jjtn000 = new ASTStaticInitialization(JJTSTATICINITIALIZATION);
928 boolean jjtc000 = true;
929 jjtree.openNodeScope(jjtn000);
930 try {
931 jj_consume_token(TYPE_STATICINITIALIZATION);
932 jj_consume_token(METHOD_PARAMETER_START);
933 label_9:
934 while (true) {
935 if (jj_2_12(2)) {
936 ;
937 } else {
938 break label_9;
939 }
940 MethodAttribute();
941 }
942 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
943 case METHOD_PUBLIC:
944 case METHOD_PROTECTED:
945 case METHOD_PRIVATE:
946 case METHOD_STATIC:
947 case METHOD_ABSTRACT:
948 case METHOD_FINAL:
949 case METHOD_NOT:
950 case METHOD_CLASS_PATTERN:
951 StaticInitializationPattern();
952 break;
953 default:
954 jj_la1[17] = jj_gen;
955 ;
956 }
957 jj_consume_token(METHOD_PARAMETER_END);
958 } catch (Throwable jjte000) {
959 if (jjtc000) {
960 jjtree.clearNodeScope(jjtn000);
961 jjtc000 = false;
962 } else {
963 jjtree.popNode();
964 }
965 if (jjte000 instanceof RuntimeException ) {
966 {if (true) throw (RuntimeException )jjte000;}
967 }
968 if (jjte000 instanceof ParseException) {
969 {if (true) throw (ParseException)jjte000;}
970 }
971 {if (true) throw (Error )jjte000;}
972 } finally {
973 if (jjtc000) {
974 jjtree.closeNodeScope(jjtn000, true);
975 }
976 }
977 }
978
979 static final public void StaticInitializationPattern() throws ParseException {
980
981 ASTClassPattern jjtn000 = new ASTClassPattern(JJTCLASSPATTERN);
982 boolean jjtc000 = true;
983 jjtree.openNodeScope(jjtn000);Token tkn = null;
984 try {
985 label_10:
986 while (true) {
987 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
988 case METHOD_PUBLIC:
989 case METHOD_PROTECTED:
990 case METHOD_PRIVATE:
991 case METHOD_STATIC:
992 case METHOD_ABSTRACT:
993 case METHOD_FINAL:
994 case METHOD_NOT:
995 ;
996 break;
997 default:
998 jj_la1[18] = jj_gen;
999 break label_10;
1000 }
1001 StaticInitializationPatternModifier();
1002 }
1003 tkn = jj_consume_token(METHOD_CLASS_PATTERN);
1004 jjtree.closeNodeScope(jjtn000, true);
1005 jjtc000 = false;
1006 jjtn000.setTypePattern(tkn.image);
1007 } catch (Throwable jjte000) {
1008 if (jjtc000) {
1009 jjtree.clearNodeScope(jjtn000);
1010 jjtc000 = false;
1011 } else {
1012 jjtree.popNode();
1013 }
1014 if (jjte000 instanceof RuntimeException ) {
1015 {if (true) throw (RuntimeException )jjte000;}
1016 }
1017 if (jjte000 instanceof ParseException) {
1018 {if (true) throw (ParseException)jjte000;}
1019 }
1020 {if (true) throw (Error )jjte000;}
1021 } finally {
1022 if (jjtc000) {
1023 jjtree.closeNodeScope(jjtn000, true);
1024 }
1025 }
1026 }
1027
1028
1031 static final public void StaticInitialization() throws ParseException {
1032
1033 ASTStaticInitialization jjtn000 = new ASTStaticInitialization(JJTSTATICINITIALIZATION);
1034 boolean jjtc000 = true;
1035 jjtree.openNodeScope(jjtn000);
1036 try {
1037 jj_consume_token(STATIC_INITIALIZATION);
1038 label_11:
1039 while (true) {
1040 if (jj_2_13(2)) {
1041 ;
1042 } else {
1043 break label_11;
1044 }
1045 ClassAttribute();
1046 }
1047 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1048 case EAGER_WILDCARD:
1049 case CLASS_PRIVATE:
1050 case CLASS_PROTECTED:
1051 case CLASS_PUBLIC:
1052 case CLASS_STATIC:
1053 case CLASS_ABSTRACT:
1054 case CLASS_FINAL:
1055 case CLASS_NOT:
1056 case CLASS_PATTERN:
1057 ClassPattern();
1058 break;
1059 default:
1060 jj_la1[19] = jj_gen;
1061 ;
1062 }
1063 jj_consume_token(CLASS_POINTCUT_END);
1064 } catch (Throwable jjte000) {
1065 if (jjtc000) {
1066 jjtree.clearNodeScope(jjtn000);
1067 jjtc000 = false;
1068 } else {
1069 jjtree.popNode();
1070 }
1071 if (jjte000 instanceof RuntimeException ) {
1072 {if (true) throw (RuntimeException )jjte000;}
1073 }
1074 if (jjte000 instanceof ParseException) {
1075 {if (true) throw (ParseException)jjte000;}
1076 }
1077 {if (true) throw (Error )jjte000;}
1078 } finally {
1079 if (jjtc000) {
1080 jjtree.closeNodeScope(jjtn000, true);
1081 }
1082 }
1083 }
1084
1085
1088 static final public void Cflow() throws ParseException {
1089
1090 ASTCflow jjtn000 = new ASTCflow(JJTCFLOW);
1091 boolean jjtc000 = true;
1092 jjtree.openNodeScope(jjtn000);
1093 try {
1094 jj_consume_token(CFLOW);
1095 Expression();
1096 jj_consume_token(87);
1097 } catch (Throwable jjte000) {
1098 if (jjtc000) {
1099 jjtree.clearNodeScope(jjtn000);
1100 jjtc000 = false;
1101 } else {
1102 jjtree.popNode();
1103 }
1104 if (jjte000 instanceof RuntimeException ) {
1105 {if (true) throw (RuntimeException )jjte000;}
1106 }
1107 if (jjte000 instanceof ParseException) {
1108 {if (true) throw (ParseException)jjte000;}
1109 }
1110 {if (true) throw (Error )jjte000;}
1111 } finally {
1112 if (jjtc000) {
1113 jjtree.closeNodeScope(jjtn000, true);
1114 }
1115 }
1116 }
1117
1118
1121 static final public void CflowBelow() throws ParseException {
1122
1123 ASTCflowBelow jjtn000 = new ASTCflowBelow(JJTCFLOWBELOW);
1124 boolean jjtc000 = true;
1125 jjtree.openNodeScope(jjtn000);
1126 try {
1127 jj_consume_token(CFLOW_BELOW);
1128 Expression();
1129 jj_consume_token(87);
1130 } catch (Throwable jjte000) {
1131 if (jjtc000) {
1132 jjtree.clearNodeScope(jjtn000);
1133 jjtc000 = false;
1134 } else {
1135 jjtree.popNode();
1136 }
1137 if (jjte000 instanceof RuntimeException ) {
1138 {if (true) throw (RuntimeException )jjte000;}
1139 }
1140 if (jjte000 instanceof ParseException) {
1141 {if (true) throw (ParseException)jjte000;}
1142 }
1143 {if (true) throw (Error )jjte000;}
1144 } finally {
1145 if (jjtc000) {
1146 jjtree.closeNodeScope(jjtn000, true);
1147 }
1148 }
1149 }
1150
1151
1154 static final public void Args() throws ParseException {
1155
1156 ASTArgs jjtn000 = new ASTArgs(JJTARGS);
1157 boolean jjtc000 = true;
1158 jjtree.openNodeScope(jjtn000);
1159 try {
1160 if (jj_2_14(2)) {
1161 jj_consume_token(ARGS);
1162 jj_consume_token(ARGS_END);
1163 } else {
1164 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1165 case ARGS:
1166 jj_consume_token(ARGS);
1167 ArgsParameters();
1168 jj_consume_token(ARGS_END);
1169 break;
1170 default:
1171 jj_la1[20] = jj_gen;
1172 jj_consume_token(-1);
1173 throw new ParseException();
1174 }
1175 }
1176 } catch (Throwable jjte000) {
1177 if (jjtc000) {
1178 jjtree.clearNodeScope(jjtn000);
1179 jjtc000 = false;
1180 } else {
1181 jjtree.popNode();
1182 }
1183 if (jjte000 instanceof RuntimeException ) {
1184 {if (true) throw (RuntimeException )jjte000;}
1185 }
1186 if (jjte000 instanceof ParseException) {
1187 {if (true) throw (ParseException)jjte000;}
1188 }
1189 {if (true) throw (Error )jjte000;}
1190 } finally {
1191 if (jjtc000) {
1192 jjtree.closeNodeScope(jjtn000, true);
1193 }
1194 }
1195 }
1196
1197
1200 static final public void HasMethod() throws ParseException {
1201
1202 ASTHasMethod jjtn000 = new ASTHasMethod(JJTHASMETHOD);
1203 boolean jjtc000 = true;
1204 jjtree.openNodeScope(jjtn000);
1205 try {
1206 jj_consume_token(HAS_METHOD);
1207 label_12:
1208 while (true) {
1209 if (jj_2_15(2)) {
1210 ;
1211 } else {
1212 break label_12;
1213 }
1214 MethodAttribute();
1215 }
1216 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1217 case METHOD_PARAMETER_END:
1218 jj_consume_token(METHOD_PARAMETER_END);
1219 break;
1220 case METHOD_PUBLIC:
1221 case METHOD_PROTECTED:
1222 case METHOD_PRIVATE:
1223 case METHOD_STATIC:
1224 case METHOD_ABSTRACT:
1225 case METHOD_FINAL:
1226 case METHOD_NATIVE:
1227 case METHOD_SYNCHRONIZED:
1228 case METHOD_NOT:
1229 case METHOD_CLASS_PATTERN:
1230 case METHOD_ARRAY_CLASS_PATTERN:
1231 case 87:
1232 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1233 case METHOD_PUBLIC:
1234 case METHOD_PROTECTED:
1235 case METHOD_PRIVATE:
1236 case METHOD_STATIC:
1237 case METHOD_ABSTRACT:
1238 case METHOD_FINAL:
1239 case METHOD_NATIVE:
1240 case METHOD_SYNCHRONIZED:
1241 case METHOD_NOT:
1242 case METHOD_CLASS_PATTERN:
1243 case METHOD_ARRAY_CLASS_PATTERN:
1244 if (jj_2_16(4)) {
1245 ConstructorPattern();
1246 } else {
1247 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1248 case METHOD_PUBLIC:
1249 case METHOD_PROTECTED:
1250 case METHOD_PRIVATE:
1251 case METHOD_STATIC:
1252 case METHOD_ABSTRACT:
1253 case METHOD_FINAL:
1254 case METHOD_NATIVE:
1255 case METHOD_SYNCHRONIZED:
1256 case METHOD_NOT:
1257 case METHOD_CLASS_PATTERN:
1258 case METHOD_ARRAY_CLASS_PATTERN:
1259 MethodPattern();
1260 break;
1261 default:
1262 jj_la1[21] = jj_gen;
1263 jj_consume_token(-1);
1264 throw new ParseException();
1265 }
1266 }
1267 break;
1268 default:
1269 jj_la1[22] = jj_gen;
1270 ;
1271 }
1272 jj_consume_token(87);
1273 break;
1274 default:
1275 jj_la1[23] = jj_gen;
1276 jj_consume_token(-1);
1277 throw new ParseException();
1278 }
1279 } catch (Throwable jjte000) {
1280 if (jjtc000) {
1281 jjtree.clearNodeScope(jjtn000);
1282 jjtc000 = false;
1283 } else {
1284 jjtree.popNode();
1285 }
1286 if (jjte000 instanceof RuntimeException ) {
1287 {if (true) throw (RuntimeException )jjte000;}
1288 }
1289 if (jjte000 instanceof ParseException) {
1290 {if (true) throw (ParseException)jjte000;}
1291 }
1292 {if (true) throw (Error )jjte000;}
1293 } finally {
1294 if (jjtc000) {
1295 jjtree.closeNodeScope(jjtn000, true);
1296 }
1297 }
1298 }
1299
1300
1303 static final public void HasField() throws ParseException {
1304
1305 ASTHasField jjtn000 = new ASTHasField(JJTHASFIELD);
1306 boolean jjtc000 = true;
1307 jjtree.openNodeScope(jjtn000);
1308 try {
1309 jj_consume_token(HAS_FIELD);
1310 label_13:
1311 while (true) {
1312 if (jj_2_17(2)) {
1313 ;
1314 } else {
1315 break label_13;
1316 }
1317 FieldAttribute();
1318 }
1319 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1320 case FIELD_PRIVATE:
1321 case FIELD_PROTECTED:
1322 case FIELD_PUBLIC:
1323 case FIELD_STATIC:
1324 case FIELD_ABSTRACT:
1325 case FIELD_FINAL:
1326 case FIELD_TRANSIENT:
1327 case FIELD_NOT:
1328 case FIELD_CLASS_PATTERN:
1329 case FIELD_ARRAY_CLASS_PATTERN:
1330 FieldPattern();
1331 break;
1332 default:
1333 jj_la1[24] = jj_gen;
1334 ;
1335 }
1336 jj_consume_token(FIELD_POINTCUT_END);
1337 } catch (Throwable jjte000) {
1338 if (jjtc000) {
1339 jjtree.clearNodeScope(jjtn000);
1340 jjtc000 = false;
1341 } else {
1342 jjtree.popNode();
1343 }
1344 if (jjte000 instanceof RuntimeException ) {
1345 {if (true) throw (RuntimeException )jjte000;}
1346 }
1347 if (jjte000 instanceof ParseException) {
1348 {if (true) throw (ParseException)jjte000;}
1349 }
1350 {if (true) throw (Error )jjte000;}
1351 } finally {
1352 if (jjtc000) {
1353 jjtree.closeNodeScope(jjtn000, true);
1354 }
1355 }
1356 }
1357
1358
1361 static final public void Target() throws ParseException {
1362
1363 ASTTarget jjtn000 = new ASTTarget(JJTTARGET);
1364 boolean jjtc000 = true;
1365 jjtree.openNodeScope(jjtn000);Token identifier;
1366 try {
1367 jj_consume_token(TARGET);
1368 identifier = jj_consume_token(CLASS_PATTERN);
1369 jjtn000.setIdentifier(identifier.image);
1370 jj_consume_token(CLASS_POINTCUT_END);
1371 } finally {
1372 if (jjtc000) {
1373 jjtree.closeNodeScope(jjtn000, true);
1374 }
1375 }
1376 }
1377
1378
1381 static final public void This() throws ParseException {
1382
1383 ASTThis jjtn000 = new ASTThis(JJTTHIS);
1384 boolean jjtc000 = true;
1385 jjtree.openNodeScope(jjtn000);Token identifier;
1386 try {
1387 jj_consume_token(THIS);
1388 identifier = jj_consume_token(CLASS_PATTERN);
1389 jjtn000.setIdentifier(identifier.image);
1390 jj_consume_token(CLASS_POINTCUT_END);
1391 } finally {
1392 if (jjtc000) {
1393 jjtree.closeNodeScope(jjtn000, true);
1394 }
1395 }
1396 }
1397
1398
1400
1403 static final public void ClassPattern() throws ParseException {
1404
1405 ASTClassPattern jjtn000 = new ASTClassPattern(JJTCLASSPATTERN);
1406 boolean jjtc000 = true;
1407 jjtree.openNodeScope(jjtn000);Token pattern;
1408 try {
1409 label_14:
1410 while (true) {
1411 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1412 case CLASS_PRIVATE:
1413 case CLASS_PROTECTED:
1414 case CLASS_PUBLIC:
1415 case CLASS_STATIC:
1416 case CLASS_ABSTRACT:
1417 case CLASS_FINAL:
1418 case CLASS_NOT:
1419 ;
1420 break;
1421 default:
1422 jj_la1[25] = jj_gen;
1423 break label_14;
1424 }
1425 ClassModifier();
1426 }
1427 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1428 case CLASS_PATTERN:
1429 pattern = jj_consume_token(CLASS_PATTERN);
1430 break;
1431 case EAGER_WILDCARD:
1432 pattern = jj_consume_token(EAGER_WILDCARD);
1433 break;
1434 default:
1435 jj_la1[26] = jj_gen;
1436 jj_consume_token(-1);
1437 throw new ParseException();
1438 }
1439 jjtree.closeNodeScope(jjtn000, true);
1440 jjtc000 = false;
1441 jjtn000.setTypePattern(pattern.image);
1442 } catch (Throwable jjte000) {
1443 if (jjtc000) {
1444 jjtree.clearNodeScope(jjtn000);
1445 jjtc000 = false;
1446 } else {
1447 jjtree.popNode();
1448 }
1449 if (jjte000 instanceof RuntimeException ) {
1450 {if (true) throw (RuntimeException )jjte000;}
1451 }
1452 if (jjte000 instanceof ParseException) {
1453 {if (true) throw (ParseException)jjte000;}
1454 }
1455 {if (true) throw (Error )jjte000;}
1456 } finally {
1457 if (jjtc000) {
1458 jjtree.closeNodeScope(jjtn000, true);
1459 }
1460 }
1461 }
1462
1463
1470 static final public void MethodPattern() throws ParseException {
1471
1472 ASTMethodPattern jjtn000 = new ASTMethodPattern(JJTMETHODPATTERN);
1473 boolean jjtc000 = true;
1474 jjtree.openNodeScope(jjtn000);Token returnType, name;
1475 try {
1476 label_15:
1477 while (true) {
1478 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1479 case METHOD_PUBLIC:
1480 case METHOD_PROTECTED:
1481 case METHOD_PRIVATE:
1482 case METHOD_STATIC:
1483 case METHOD_ABSTRACT:
1484 case METHOD_FINAL:
1485 case METHOD_NATIVE:
1486 case METHOD_SYNCHRONIZED:
1487 case METHOD_NOT:
1488 ;
1489 break;
1490 default:
1491 jj_la1[27] = jj_gen;
1492 break label_15;
1493 }
1494 MethodModifier();
1495 }
1496 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1497 case METHOD_CLASS_PATTERN:
1498 returnType = jj_consume_token(METHOD_CLASS_PATTERN);
1499 break;
1500 case METHOD_ARRAY_CLASS_PATTERN:
1501 returnType = jj_consume_token(METHOD_ARRAY_CLASS_PATTERN);
1502 break;
1503 default:
1504 jj_la1[28] = jj_gen;
1505 jj_consume_token(-1);
1506 throw new ParseException();
1507 }
1508 jjtn000.setReturnTypePattern(returnType.image);
1509 name = jj_consume_token(METHOD_CLASS_PATTERN);
1510 jjtn000.setFullNamePattern(name.image);
1511 Parameters();
1512 } catch (Throwable jjte000) {
1513 if (jjtc000) {
1514 jjtree.clearNodeScope(jjtn000);
1515 jjtc000 = false;
1516 } else {
1517 jjtree.popNode();
1518 }
1519 if (jjte000 instanceof RuntimeException ) {
1520 {if (true) throw (RuntimeException )jjte000;}
1521 }
1522 if (jjte000 instanceof ParseException) {
1523 {if (true) throw (ParseException)jjte000;}
1524 }
1525 {if (true) throw (Error )jjte000;}
1526 } finally {
1527 if (jjtc000) {
1528 jjtree.closeNodeScope(jjtn000, true);
1529 }
1530 }
1531 }
1532
1533
1540 static final public void ConstructorPattern() throws ParseException {
1541
1542 ASTConstructorPattern jjtn000 = new ASTConstructorPattern(JJTCONSTRUCTORPATTERN);
1543 boolean jjtc000 = true;
1544 jjtree.openNodeScope(jjtn000);Token name;
1545 try {
1546 label_16:
1547 while (true) {
1548 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1549 case METHOD_PUBLIC:
1550 case METHOD_PROTECTED:
1551 case METHOD_PRIVATE:
1552 case METHOD_SYNCHRONIZED:
1553 case METHOD_NOT:
1554 ;
1555 break;
1556 default:
1557 jj_la1[29] = jj_gen;
1558 break label_16;
1559 }
1560 ConstructorModifier();
1561 }
1562 name = jj_consume_token(METHOD_CLASS_PATTERN);
1563 if (!name.image.endsWith("new")) {
1564 {if (true) throw new RuntimeException ("constructor pattern must have 'new' as method name");}
1565 }
1566 jjtn000.setFullNamePattern(name.image);
1567 Parameters();
1568 } catch (Throwable jjte000) {
1569 if (jjtc000) {
1570 jjtree.clearNodeScope(jjtn000);
1571 jjtc000 = false;
1572 } else {
1573 jjtree.popNode();
1574 }
1575 if (jjte000 instanceof RuntimeException ) {
1576 {if (true) throw (RuntimeException )jjte000;}
1577 }
1578 if (jjte000 instanceof ParseException) {
1579 {if (true) throw (ParseException)jjte000;}
1580 }
1581 {if (true) throw (Error )jjte000;}
1582 } finally {
1583 if (jjtc000) {
1584 jjtree.closeNodeScope(jjtn000, true);
1585 }
1586 }
1587 }
1588
1589
1596 static final public void FieldPattern() throws ParseException {
1597
1598 ASTFieldPattern jjtn000 = new ASTFieldPattern(JJTFIELDPATTERN);
1599 boolean jjtc000 = true;
1600 jjtree.openNodeScope(jjtn000);Token type, name;
1601 try {
1602 label_17:
1603 while (true) {
1604 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1605 case FIELD_PRIVATE:
1606 case FIELD_PROTECTED:
1607 case FIELD_PUBLIC:
1608 case FIELD_STATIC:
1609 case FIELD_ABSTRACT:
1610 case FIELD_FINAL:
1611 case FIELD_TRANSIENT:
1612 case FIELD_NOT:
1613 ;
1614 break;
1615 default:
1616 jj_la1[30] = jj_gen;
1617 break label_17;
1618 }
1619 FieldModifier();
1620 }
1621 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1622 case FIELD_CLASS_PATTERN:
1623 type = jj_consume_token(FIELD_CLASS_PATTERN);
1624 break;
1625 case FIELD_ARRAY_CLASS_PATTERN:
1626 type = jj_consume_token(FIELD_ARRAY_CLASS_PATTERN);
1627 break;
1628 default:
1629 jj_la1[31] = jj_gen;
1630 jj_consume_token(-1);
1631 throw new ParseException();
1632 }
1633 jjtn000.setFieldTypePattern(type.image);
1634 name = jj_consume_token(FIELD_CLASS_PATTERN);
1635 jjtree.closeNodeScope(jjtn000, true);
1636 jjtc000 = false;
1637 jjtn000.setFullNamePattern(name.image);
1638 } catch (Throwable jjte000) {
1639 if (jjtc000) {
1640 jjtree.clearNodeScope(jjtn000);
1641 jjtc000 = false;
1642 } else {
1643 jjtree.popNode();
1644 }
1645 if (jjte000 instanceof RuntimeException ) {
1646 {if (true) throw (RuntimeException )jjte000;}
1647 }
1648 if (jjte000 instanceof ParseException) {
1649 {if (true) throw (ParseException)jjte000;}
1650 }
1651 {if (true) throw (Error )jjte000;}
1652 } finally {
1653 if (jjtc000) {
1654 jjtree.closeNodeScope(jjtn000, true);
1655 }
1656 }
1657 }
1658
1659
1662 static final public void Parameters() throws ParseException {
1663 jj_consume_token(METHOD_PARAMETER_START);
1664 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1665 case EAGER_WILDCARD:
1666 case METHOD_CLASS_PATTERN:
1667 case METHOD_ARRAY_CLASS_PATTERN:
1668 Parameter();
1669 label_18:
1670 while (true) {
1671 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1672 case COMMA:
1673 ;
1674 break;
1675 default:
1676 jj_la1[32] = jj_gen;
1677 break label_18;
1678 }
1679 jj_consume_token(COMMA);
1680 Parameter();
1681 }
1682 break;
1683 default:
1684 jj_la1[33] = jj_gen;
1685 ;
1686 }
1687 jj_consume_token(METHOD_PARAMETER_END);
1688 }
1689
1690
1693 static final public void Parameter() throws ParseException {
1694
1695 ASTParameter jjtn000 = new ASTParameter(JJTPARAMETER);
1696 boolean jjtc000 = true;
1697 jjtree.openNodeScope(jjtn000);Token parameter;
1698 try {
1699 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1700 case METHOD_CLASS_PATTERN:
1701 parameter = jj_consume_token(METHOD_CLASS_PATTERN);
1702 break;
1703 case METHOD_ARRAY_CLASS_PATTERN:
1704 parameter = jj_consume_token(METHOD_ARRAY_CLASS_PATTERN);
1705 break;
1706 case EAGER_WILDCARD:
1707 parameter = jj_consume_token(EAGER_WILDCARD);
1708 break;
1709 default:
1710 jj_la1[34] = jj_gen;
1711 jj_consume_token(-1);
1712 throw new ParseException();
1713 }
1714 jjtree.closeNodeScope(jjtn000, true);
1715 jjtc000 = false;
1716 jjtn000.setTypePattern(parameter.image);
1717 } finally {
1718 if (jjtc000) {
1719 jjtree.closeNodeScope(jjtn000, true);
1720 }
1721 }
1722 }
1723
1724
1727 static final public void ArgsParameters() throws ParseException {
1728 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1729 case EAGER_WILDCARD:
1730 case ARG_PATTERN:
1731 case ARG_ARRAY_PATTERN:
1732 ArgParameter();
1733 break;
1734 default:
1735 jj_la1[35] = jj_gen;
1736 ;
1737 }
1738 label_19:
1739 while (true) {
1740 if (jj_2_18(2)) {
1741 ;
1742 } else {
1743 break label_19;
1744 }
1745 jj_consume_token(COMMA);
1746 ArgsParameters();
1747 }
1748 }
1749
1750
1753 static final public void ArgParameter() throws ParseException {
1754
1755 ASTArgParameter jjtn000 = new ASTArgParameter(JJTARGPARAMETER);
1756 boolean jjtc000 = true;
1757 jjtree.openNodeScope(jjtn000);Token t;
1758 try {
1759 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1760 case ARG_PATTERN:
1761 t = jj_consume_token(ARG_PATTERN);
1762 break;
1763 case ARG_ARRAY_PATTERN:
1764 t = jj_consume_token(ARG_ARRAY_PATTERN);
1765 break;
1766 case EAGER_WILDCARD:
1767 t = jj_consume_token(EAGER_WILDCARD);
1768 break;
1769 default:
1770 jj_la1[36] = jj_gen;
1771 jj_consume_token(-1);
1772 throw new ParseException();
1773 }
1774 jjtree.closeNodeScope(jjtn000, true);
1775 jjtc000 = false;
1776 jjtn000.setTypePattern(t.image);
1777 } finally {
1778 if (jjtc000) {
1779 jjtree.closeNodeScope(jjtn000, true);
1780 }
1781 }
1782 }
1783
1784
1787 static final public void ClassAttribute() throws ParseException {
1788
1789 ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
1790 boolean jjtc000 = true;
1791 jjtree.openNodeScope(jjtn000);Token annotation;
1792 try {
1793 label_20:
1794 while (true) {
1795 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1796 case CLASS_NOT:
1797 ;
1798 break;
1799 default:
1800 jj_la1[37] = jj_gen;
1801 break label_20;
1802 }
1803 jj_consume_token(CLASS_NOT);
1804 jjtn000.toggleNot();
1805 }
1806 annotation = jj_consume_token(CLASS_ATTRIBUTE);
1807 jjtree.closeNodeScope(jjtn000, true);
1808 jjtc000 = false;
1809 jjtn000.setName(annotation.image);
1810 } finally {
1811 if (jjtc000) {
1812 jjtree.closeNodeScope(jjtn000, true);
1813 }
1814 }
1815 }
1816
1817
1820 static final public void MethodAttribute() throws ParseException {
1821
1822 ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
1823 boolean jjtc000 = true;
1824 jjtree.openNodeScope(jjtn000);Token annotation;
1825 try {
1826 label_21:
1827 while (true) {
1828 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1829 case METHOD_NOT:
1830 ;
1831 break;
1832 default:
1833 jj_la1[38] = jj_gen;
1834 break label_21;
1835 }
1836 jj_consume_token(METHOD_NOT);
1837 jjtn000.toggleNot();
1838 }
1839 annotation = jj_consume_token(METHOD_ANNOTATION);
1840 jjtree.closeNodeScope(jjtn000, true);
1841 jjtc000 = false;
1842 jjtn000.setName(annotation.image);
1843 } finally {
1844 if (jjtc000) {
1845 jjtree.closeNodeScope(jjtn000, true);
1846 }
1847 }
1848 }
1849
1850
1853 static final public void FieldAttribute() throws ParseException {
1854
1855 ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
1856 boolean jjtc000 = true;
1857 jjtree.openNodeScope(jjtn000);Token annotation;
1858 try {
1859 label_22:
1860 while (true) {
1861 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1862 case FIELD_NOT:
1863 ;
1864 break;
1865 default:
1866 jj_la1[39] = jj_gen;
1867 break label_22;
1868 }
1869 jj_consume_token(FIELD_NOT);
1870 jjtn000.toggleNot();
1871 }
1872 annotation = jj_consume_token(FIELD_ANNOTATION);
1873 jjtree.closeNodeScope(jjtn000, true);
1874 jjtc000 = false;
1875 jjtn000.setName(annotation.image);
1876 } finally {
1877 if (jjtc000) {
1878 jjtree.closeNodeScope(jjtn000, true);
1879 }
1880 }
1881 }
1882
1883
1886 static final public void ClassModifier() throws ParseException {
1887
1888 ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
1889 boolean jjtc000 = true;
1890 jjtree.openNodeScope(jjtn000);
1891 try {
1892 label_23:
1893 while (true) {
1894 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1895 case CLASS_NOT:
1896 ;
1897 break;
1898 default:
1899 jj_la1[40] = jj_gen;
1900 break label_23;
1901 }
1902 jj_consume_token(CLASS_NOT);
1903 jjtn000.toggleNot();
1904 }
1905 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1906 case CLASS_PUBLIC:
1907 jj_consume_token(CLASS_PUBLIC);
1908 jjtree.closeNodeScope(jjtn000, true);
1909 jjtc000 = false;
1910 jjtn000.setModifier(Modifier.PUBLIC);
1911 break;
1912 case CLASS_PROTECTED:
1913 jj_consume_token(CLASS_PROTECTED);
1914 jjtree.closeNodeScope(jjtn000, true);
1915 jjtc000 = false;
1916 jjtn000.setModifier(Modifier.PROTECTED);
1917 break;
1918 case CLASS_PRIVATE:
1919 jj_consume_token(CLASS_PRIVATE);
1920 jjtree.closeNodeScope(jjtn000, true);
1921 jjtc000 = false;
1922 jjtn000.setModifier(Modifier.PRIVATE);
1923 break;
1924 case CLASS_STATIC:
1925 jj_consume_token(CLASS_STATIC);
1926 jjtree.closeNodeScope(jjtn000, true);
1927 jjtc000 = false;
1928 jjtn000.setModifier(Modifier.STATIC);
1929 break;
1930 case CLASS_ABSTRACT:
1931 jj_consume_token(CLASS_ABSTRACT);
1932 jjtree.closeNodeScope(jjtn000, true);
1933 jjtc000 = false;
1934 jjtn000.setModifier(Modifier.ABSTRACT);
1935 break;
1936 case CLASS_FINAL:
1937 jj_consume_token(CLASS_FINAL);
1938 jjtree.closeNodeScope(jjtn000, true);
1939 jjtc000 = false;
1940 jjtn000.setModifier(Modifier.FINAL);
1941 break;
1942 default:
1943 jj_la1[41] = jj_gen;
1944 jj_consume_token(-1);
1945 throw new ParseException();
1946 }
1947 } finally {
1948 if (jjtc000) {
1949 jjtree.closeNodeScope(jjtn000, true);
1950 }
1951 }
1952 }
1953
1954
1957 static final public void StaticInitializationPatternModifier() throws ParseException {
1958
1959 ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
1960 boolean jjtc000 = true;
1961 jjtree.openNodeScope(jjtn000);
1962 try {
1963 label_24:
1964 while (true) {
1965 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1966 case METHOD_NOT:
1967 ;
1968 break;
1969 default:
1970 jj_la1[42] = jj_gen;
1971 break label_24;
1972 }
1973 jj_consume_token(METHOD_NOT);
1974 jjtn000.toggleNot();
1975 }
1976 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1977 case METHOD_PUBLIC:
1978 jj_consume_token(METHOD_PUBLIC);
1979 jjtree.closeNodeScope(jjtn000, true);
1980 jjtc000 = false;
1981 jjtn000.setModifier(Modifier.PUBLIC);
1982 break;
1983 case METHOD_PROTECTED:
1984 jj_consume_token(METHOD_PROTECTED);
1985 jjtree.closeNodeScope(jjtn000, true);
1986 jjtc000 = false;
1987 jjtn000.setModifier(Modifier.PROTECTED);
1988 break;
1989 case METHOD_PRIVATE:
1990 jj_consume_token(METHOD_PRIVATE);
1991 jjtree.closeNodeScope(jjtn000, true);
1992 jjtc000 = false;
1993 jjtn000.setModifier(Modifier.PRIVATE);
1994 break;
1995 case METHOD_STATIC:
1996 jj_consume_token(METHOD_STATIC);
1997 jjtree.closeNodeScope(jjtn000, true);
1998 jjtc000 = false;
1999 jjtn000.setModifier(Modifier.STATIC);
2000 break;
2001 case METHOD_ABSTRACT:
2002 jj_consume_token(METHOD_ABSTRACT);
2003 jjtree.closeNodeScope(jjtn000, true);
2004 jjtc000 = false;
2005 jjtn000.setModifier(Modifier.ABSTRACT);
2006 break;
2007 case METHOD_FINAL:
2008 jj_consume_token(METHOD_FINAL);
2009 jjtree.closeNodeScope(jjtn000, true);
2010 jjtc000 = false;
2011 jjtn000.setModifier(Modifier.FINAL);
2012 break;
2013 default:
2014 jj_la1[43] = jj_gen;
2015 jj_consume_token(-1);
2016 throw new ParseException();
2017 }
2018 } finally {
2019 if (jjtc000) {
2020 jjtree.closeNodeScope(jjtn000, true);
2021 }
2022 }
2023 }
2024
2025
2028 static final public void MethodModifier() throws ParseException {
2029
2030 ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
2031 boolean jjtc000 = true;
2032 jjtree.openNodeScope(jjtn000);
2033 try {
2034 label_25:
2035 while (true) {
2036 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2037 case METHOD_NOT:
2038 ;
2039 break;
2040 default:
2041 jj_la1[44] = jj_gen;
2042 break label_25;
2043 }
2044 jj_consume_token(METHOD_NOT);
2045 jjtn000.toggleNot();
2046 }
2047 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2048 case METHOD_PUBLIC:
2049 jj_consume_token(METHOD_PUBLIC);
2050 jjtree.closeNodeScope(jjtn000, true);
2051 jjtc000 = false;
2052 jjtn000.setModifier(Modifier.PUBLIC);
2053 break;
2054 case METHOD_PROTECTED:
2055 jj_consume_token(METHOD_PROTECTED);
2056 jjtree.closeNodeScope(jjtn000, true);
2057 jjtc000 = false;
2058 jjtn000.setModifier(Modifier.PROTECTED);
2059 break;
2060 case METHOD_PRIVATE:
2061 jj_consume_token(METHOD_PRIVATE);
2062 jjtree.closeNodeScope(jjtn000, true);
2063 jjtc000 = false;
2064 jjtn000.setModifier(Modifier.PRIVATE);
2065 break;
2066 case METHOD_STATIC:
2067 jj_consume_token(METHOD_STATIC);
2068 jjtree.closeNodeScope(jjtn000, true);
2069 jjtc000 = false;
2070 jjtn000.setModifier(Modifier.STATIC);
2071 break;
2072 case METHOD_ABSTRACT:
2073 jj_consume_token(METHOD_ABSTRACT);
2074 jjtree.closeNodeScope(jjtn000, true);
2075 jjtc000 = false;
2076 jjtn000.setModifier(Modifier.ABSTRACT);
2077 break;
2078 case METHOD_FINAL:
2079 jj_consume_token(METHOD_FINAL);
2080 jjtree.closeNodeScope(jjtn000, true);
2081 jjtc000 = false;
2082 jjtn000.setModifier(Modifier.FINAL);
2083 break;
2084 case METHOD_NATIVE:
2085 jj_consume_token(METHOD_NATIVE);
2086 jjtree.closeNodeScope(jjtn000, true);
2087 jjtc000 = false;
2088 jjtn000.setModifier(Modifier.NATIVE);
2089 break;
2090 case METHOD_SYNCHRONIZED:
2091 jj_consume_token(METHOD_SYNCHRONIZED);
2092 jjtree.closeNodeScope(jjtn000, true);
2093 jjtc000 = false;
2094 jjtn000.setModifier(Modifier.SYNCHRONIZED);
2095 break;
2096 default:
2097 jj_la1[45] = jj_gen;
2098 jj_consume_token(-1);
2099 throw new ParseException();
2100 }
2101 } finally {
2102 if (jjtc000) {
2103 jjtree.closeNodeScope(jjtn000, true);
2104 }
2105 }
2106 }
2107
2108
2111 static final public void ConstructorModifier() throws ParseException {
2112
2113 ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
2114 boolean jjtc000 = true;
2115 jjtree.openNodeScope(jjtn000);
2116 try {
2117 label_26:
2118 while (true) {
2119 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2120 case METHOD_NOT:
2121 ;
2122 break;
2123 default:
2124 jj_la1[46] = jj_gen;
2125 break label_26;
2126 }
2127 jj_consume_token(METHOD_NOT);
2128 jjtn000.toggleNot();
2129 }
2130 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2131 case METHOD_PUBLIC:
2132 jj_consume_token(METHOD_PUBLIC);
2133 jjtree.closeNodeScope(jjtn000, true);
2134 jjtc000 = false;
2135 jjtn000.setModifier(Modifier.PUBLIC);
2136 break;
2137 case METHOD_PROTECTED:
2138 jj_consume_token(METHOD_PROTECTED);
2139 jjtree.closeNodeScope(jjtn000, true);
2140 jjtc000 = false;
2141 jjtn000.setModifier(Modifier.PROTECTED);
2142 break;
2143 case METHOD_PRIVATE:
2144 jj_consume_token(METHOD_PRIVATE);
2145 jjtree.closeNodeScope(jjtn000, true);
2146 jjtc000 = false;
2147 jjtn000.setModifier(Modifier.PRIVATE);
2148 break;
2149 case METHOD_SYNCHRONIZED:
2150 jj_consume_token(METHOD_SYNCHRONIZED);
2151 jjtree.closeNodeScope(jjtn000, true);
2152 jjtc000 = false;
2153 jjtn000.setModifier(Modifier.SYNCHRONIZED);
2154 break;
2155 default:
2156 jj_la1[47] = jj_gen;
2157 jj_consume_token(-1);
2158 throw new ParseException();
2159 }
2160 } finally {
2161 if (jjtc000) {
2162 jjtree.closeNodeScope(jjtn000, true);
2163 }
2164 }
2165 }
2166
2167
2170 static final public void FieldModifier() throws ParseException {
2171
2172 ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
2173 boolean jjtc000 = true;
2174 jjtree.openNodeScope(jjtn000);
2175 try {
2176 label_27:
2177 while (true) {
2178 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2179 case FIELD_NOT:
2180 ;
2181 break;
2182 default:
2183 jj_la1[48] = jj_gen;
2184 break label_27;
2185 }
2186 jj_consume_token(FIELD_NOT);
2187 jjtn000.toggleNot();
2188 }
2189 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2190 case FIELD_PUBLIC:
2191 jj_consume_token(FIELD_PUBLIC);
2192 jjtree.closeNodeScope(jjtn000, true);
2193 jjtc000 = false;
2194 jjtn000.setModifier(Modifier.PUBLIC);
2195 break;
2196 case FIELD_PROTECTED:
2197 jj_consume_token(FIELD_PROTECTED);
2198 jjtree.closeNodeScope(jjtn000, true);
2199 jjtc000 = false;
2200 jjtn000.setModifier(Modifier.PROTECTED);
2201 break;
2202 case FIELD_PRIVATE:
2203 jj_consume_token(FIELD_PRIVATE);
2204 jjtree.closeNodeScope(jjtn000, true);
2205 jjtc000 = false;
2206 jjtn000.setModifier(Modifier.PRIVATE);
2207 break;
2208 case FIELD_STATIC:
2209 jj_consume_token(FIELD_STATIC);
2210 jjtree.closeNodeScope(jjtn000, true);
2211 jjtc000 = false;
2212 jjtn000.setModifier(Modifier.STATIC);
2213 break;
2214 case FIELD_ABSTRACT:
2215 jj_consume_token(FIELD_ABSTRACT);
2216 jjtree.closeNodeScope(jjtn000, true);
2217 jjtc000 = false;
2218 jjtn000.setModifier(Modifier.ABSTRACT);
2219 break;
2220 case FIELD_FINAL:
2221 jj_consume_token(FIELD_FINAL);
2222 jjtree.closeNodeScope(jjtn000, true);
2223 jjtc000 = false;
2224 jjtn000.setModifier(Modifier.FINAL);
2225 break;
2226 case FIELD_TRANSIENT:
2227 jj_consume_token(FIELD_TRANSIENT);
2228 jjtree.closeNodeScope(jjtn000, true);
2229 jjtc000 = false;
2230 jjtn000.setModifier(Modifier.TRANSIENT);
2231 break;
2232 default:
2233 jj_la1[49] = jj_gen;
2234 jj_consume_token(-1);
2235 throw new ParseException();
2236 }
2237 } finally {
2238 if (jjtc000) {
2239 jjtree.closeNodeScope(jjtn000, true);
2240 }
2241 }
2242 }
2243
2244 static final private boolean jj_2_1(int xla) {
2245 jj_la = xla; jj_lastpos = jj_scanpos = token;
2246 try { return !jj_3_1(); }
2247 catch(LookaheadSuccess ls) { return true; }
2248 finally { jj_save(0, xla); }
2249 }
2250
2251 static final private boolean jj_2_2(int xla) {
2252 jj_la = xla; jj_lastpos = jj_scanpos = token;
2253 try { return !jj_3_2(); }
2254 catch(LookaheadSuccess ls) { return true; }
2255 finally { jj_save(1, xla); }
2256 }
2257
2258 static final private boolean jj_2_3(int xla) {
2259 jj_la = xla; jj_lastpos = jj_scanpos = token;
2260 try { return !jj_3_3(); }
2261 catch(LookaheadSuccess ls) { return true; }
2262 finally { jj_save(2, xla); }
2263 }
2264
2265 static final private boolean jj_2_4(int xla) {
2266 jj_la = xla; jj_lastpos = jj_scanpos = token;
2267 try { return !jj_3_4(); }
2268 catch(LookaheadSuccess ls) { return true; }
2269 finally { jj_save(3, xla); }
2270 }
2271
2272 static final private boolean jj_2_5(int xla) {
2273 jj_la = xla; jj_lastpos = jj_scanpos = token;
2274 try { return !jj_3_5(); }
2275 catch(LookaheadSuccess ls) { return true; }
2276 finally { jj_save(4, xla); }
2277 }
2278
2279 static final private boolean jj_2_6(int xla) {
2280 jj_la = xla; jj_lastpos = jj_scanpos = token;
2281 try { return !jj_3_6(); }
2282 catch(LookaheadSuccess ls) { return true; }
2283 finally { jj_save(5, xla); }
2284 }
2285
2286 static final private boolean jj_2_7(int xla) {
2287 jj_la = xla; jj_lastpos = jj_scanpos = token;
2288 try { return !jj_3_7(); }
2289 catch(LookaheadSuccess ls) { return true; }
2290 finally { jj_save(6, xla); }
2291 }
2292
2293 static final private boolean jj_2_8(int xla) {
2294 jj_la = xla; jj_lastpos = jj_scanpos = token;
2295 try { return !jj_3_8(); }
2296 catch(LookaheadSuccess ls) { return true; }
2297 finally { jj_save(7, xla); }
2298 }
2299
2300 static final private boolean jj_2_9(int xla) {
2301 jj_la = xla; jj_lastpos = jj_scanpos = token;
2302 try { return !jj_3_9(); }
2303 catch(LookaheadSuccess ls) { return true; }
2304 finally { jj_save(8, xla); }
2305 }
2306
2307 static final private boolean jj_2_10(int xla) {
2308 jj_la = xla; jj_lastpos = jj_scanpos = token;
2309 try { return !jj_3_10(); }
2310 catch(LookaheadSuccess ls) { return true; }
2311 finally { jj_save(9, xla); }
2312 }
2313
2314 static final private boolean jj_2_11(int xla) {
2315 jj_la = xla; jj_lastpos = jj_scanpos = token;
2316 try { return !jj_3_11(); }
2317 catch(LookaheadSuccess ls) { return true; }
2318 finally { jj_save(10, xla); }
2319 }
2320
2321 static final private boolean jj_2_12(int xla) {
2322 jj_la = xla; jj_lastpos = jj_scanpos = token;
2323 try { return !jj_3_12(); }
2324 catch(LookaheadSuccess ls) { return true; }
2325 finally { jj_save(11, xla); }
2326 }
2327
2328 static final private boolean jj_2_13(int xla) {
2329 jj_la = xla; jj_lastpos = jj_scanpos = token;
2330 try { return !jj_3_13(); }
2331 catch(LookaheadSuccess ls) { return true; }
2332 finally { jj_save(12, xla); }
2333 }
2334
2335 static final private boolean jj_2_14(int xla) {
2336 jj_la = xla; jj_lastpos = jj_scanpos = token;
2337 try { return !jj_3_14(); }
2338 catch(LookaheadSuccess ls) { return true; }
2339 finally { jj_save(13, xla); }
2340 }
2341
2342 static final private boolean jj_2_15(int xla) {
2343 jj_la = xla; jj_lastpos = jj_scanpos = token;
2344 try { return !jj_3_15(); }
2345 catch(LookaheadSuccess ls) { return true; }
2346 finally { jj_save(14, xla); }
2347 }
2348
2349 static final private boolean jj_2_16(int xla) {
2350 jj_la = xla; jj_lastpos = jj_scanpos = token;
2351 try { return !jj_3_16(); }
2352 catch(LookaheadSuccess ls) { return true; }
2353 finally { jj_save(15, xla); }
2354 }
2355
2356 static final private boolean jj_2_17(int xla) {
2357 jj_la = xla; jj_lastpos = jj_scanpos = token;
2358 try { return !jj_3_17(); }
2359 catch(LookaheadSuccess ls) { return true; }
2360 finally { jj_save(16, xla); }
2361 }
2362
2363 static final private boolean jj_2_18(int xla) {
2364 jj_la = xla; jj_lastpos = jj_scanpos = token;
2365 try { return !jj_3_18(); }
2366 catch(LookaheadSuccess ls) { return true; }
2367 finally { jj_save(17, xla); }
2368 }
2369
2370 static final private boolean jj_3_18() {
2371 if (jj_scan_token(COMMA)) return true;
2372 if (jj_3R_34()) return true;
2373 return false;
2374 }
2375
2376 static final private boolean jj_3R_56() {
2377 if (jj_scan_token(COMMA)) return true;
2378 return false;
2379 }
2380
2381 static final private boolean jj_3R_76() {
2382 if (jj_scan_token(HAS_METHOD)) return true;
2383 return false;
2384 }
2385
2386 static final private boolean jj_3_3() {
2387 if (jj_3R_30()) return true;
2388 return false;
2389 }
2390
2391 static final private boolean jj_3_15() {
2392 if (jj_3R_30()) return true;
2393 return false;
2394 }
2395
2396 static final private boolean jj_3R_74() {
2397 if (jj_scan_token(EXECUTION)) return true;
2398 return false;
2399 }
2400
2401 static final private boolean jj_3R_47() {
2402 Token xsp;
2403 xsp = jj_scanpos;
2404 if (jj_scan_token(82)) {
2405 jj_scanpos = xsp;
2406 if (jj_scan_token(83)) {
2407 jj_scanpos = xsp;
2408 if (jj_scan_token(7)) return true;
2409 }
2410 }
2411 return false;
2412 }
2413
2414 static final private boolean jj_3R_46() {
2415 if (jj_3R_55()) return true;
2416 Token xsp;
2417 while (true) {
2418 xsp = jj_scanpos;
2419 if (jj_3R_56()) { jj_scanpos = xsp; break; }
2420 }
2421 return false;
2422 }
2423
2424 static final private boolean jj_3R_89() {
2425 if (jj_scan_token(ARGS)) return true;
2426 return false;
2427 }
2428
2429 static final private boolean jj_3R_41() {
2430 if (jj_3R_47()) return true;
2431 return false;
2432 }
2433
2434 static final private boolean jj_3R_34() {
2435 Token xsp;
2436 xsp = jj_scanpos;
2437 if (jj_3R_41()) jj_scanpos = xsp;
2438 while (true) {
2439 xsp = jj_scanpos;
2440 if (jj_3_18()) { jj_scanpos = xsp; break; }
2441 }
2442 return false;
2443 }
2444
2445 static final private boolean jj_3R_88() {
2446 Token xsp;
2447 xsp = jj_scanpos;
2448 if (jj_scan_token(27)) {
2449 jj_scanpos = xsp;
2450 if (jj_scan_token(28)) return true;
2451 }
2452 return false;
2453 }
2454
2455 static final private boolean jj_3R_82() {
2456 Token xsp;
2457 xsp = jj_scanpos;
2458 if (jj_3_14()) {
2459 jj_scanpos = xsp;
2460 if (jj_3R_89()) return true;
2461 }
2462 return false;
2463 }
2464
2465 static final private boolean jj_3_14() {
2466 if (jj_scan_token(ARGS)) return true;
2467 if (jj_scan_token(ARGS_END)) return true;
2468 return false;
2469 }
2470
2471 static final private boolean jj_3R_71() {
2472 if (jj_3R_87()) return true;
2473 return false;
2474 }
2475
2476 static final private boolean jj_3R_70() {
2477 if (jj_3R_86()) return true;
2478 return false;
2479 }
2480
2481 static final private boolean jj_3R_69() {
2482 if (jj_3R_85()) return true;
2483 return false;
2484 }
2485
2486 static final private boolean jj_3R_68() {
2487 if (jj_3R_84()) return true;
2488 return false;
2489 }
2490
2491 static final private boolean jj_3R_72() {
2492 if (jj_3R_88()) return true;
2493 return false;
2494 }
2495
2496 static final private boolean jj_3R_86() {
2497 if (jj_scan_token(CFLOW_BELOW)) return true;
2498 return false;
2499 }
2500
2501 static final private boolean jj_3R_67() {
2502 if (jj_3R_83()) return true;
2503 return false;
2504 }
2505
2506 static final private boolean jj_3R_55() {
2507 Token xsp;
2508 xsp = jj_scanpos;
2509 if (jj_scan_token(54)) {
2510 jj_scanpos = xsp;
2511 if (jj_scan_token(55)) {
2512 jj_scanpos = xsp;
2513 if (jj_scan_token(7)) return true;
2514 }
2515 }
2516 return false;
2517 }
2518
2519 static final private boolean jj_3R_66() {
2520 if (jj_3R_82()) return true;
2521 return false;
2522 }
2523
2524 static final private boolean jj_3R_65() {
2525 if (jj_3R_81()) return true;
2526 return false;
2527 }
2528
2529 static final private boolean jj_3R_64() {
2530 if (jj_3R_80()) return true;
2531 return false;
2532 }
2533
2534 static final private boolean jj_3R_85() {
2535 if (jj_scan_token(CFLOW)) return true;
2536 return false;
2537 }
2538
2539 static final private boolean jj_3R_63() {
2540 if (jj_3R_79()) return true;
2541 return false;
2542 }
2543
2544 static final private boolean jj_3R_44() {
2545 if (jj_3R_49()) return true;
2546 return false;
2547 }
2548
2549 static final private boolean jj_3R_62() {
2550 if (jj_3R_78()) return true;
2551 return false;
2552 }
2553
2554 static final private boolean jj_3R_61() {
2555 if (jj_3R_77()) return true;
2556 return false;
2557 }
2558
2559 static final private boolean jj_3R_38() {
2560 if (jj_scan_token(METHOD_PARAMETER_START)) return true;
2561 Token xsp;
2562 xsp = jj_scanpos;
2563 if (jj_3R_46()) jj_scanpos = xsp;
2564 if (jj_scan_token(METHOD_PARAMETER_END)) return true;
2565 return false;
2566 }
2567
2568 static final private boolean jj_3R_60() {
2569 if (jj_3R_76()) return true;
2570 return false;
2571 }
2572
2573 static final private boolean jj_3R_59() {
2574 if (jj_3R_75()) return true;
2575 return false;
2576 }
2577
2578 static final private boolean jj_3R_58() {
2579 if (jj_3R_74()) return true;
2580 return false;
2581 }
2582
2583 static final private boolean jj_3_13() {
2584 if (jj_3R_33()) return true;
2585 return false;
2586 }
2587
2588 static final private boolean jj_3R_87() {
2589 if (jj_scan_token(STATIC_INITIALIZATION)) return true;
2590 return false;
2591 }
2592
2593 static final private boolean jj_3R_49() {
2594 Token xsp;
2595 xsp = jj_scanpos;
2596 if (jj_3R_57()) {
2597 jj_scanpos = xsp;
2598 if (jj_3R_58()) {
2599 jj_scanpos = xsp;
2600 if (jj_3R_59()) {
2601 jj_scanpos = xsp;
2602 if (jj_3R_60()) {
2603 jj_scanpos = xsp;
2604 if (jj_3R_61()) {
2605 jj_scanpos = xsp;
2606 if (jj_3R_62()) {
2607 jj_scanpos = xsp;
2608 if (jj_3R_63()) {
2609 jj_scanpos = xsp;
2610 if (jj_3R_64()) {
2611 jj_scanpos = xsp;
2612 if (jj_3R_65()) {
2613 jj_scanpos = xsp;
2614 if (jj_3R_66()) {
2615 jj_scanpos = xsp;
2616 if (jj_3R_67()) {
2617 jj_scanpos = xsp;
2618 if (jj_3R_68()) {
2619 jj_scanpos = xsp;
2620 if (jj_3R_69()) {
2621 jj_scanpos = xsp;
2622 if (jj_3R_70()) {
2623 jj_scanpos = xsp;
2624 if (jj_3R_71()) {
2625 jj_scanpos = xsp;
2626 if (jj_3R_72()) return true;
2627 }
2628 }
2629 }
2630 }
2631 }
2632 }
2633 }
2634 }
2635 }
2636 }
2637 }
2638 }
2639 }
2640 }
2641 }
2642 return false;
2643 }
2644
2645 static final private boolean jj_3R_57() {
2646 if (jj_3R_73()) return true;
2647 return false;
2648 }
2649
2650 static final private boolean jj_3_11() {
2651 if (jj_3R_31()) return true;
2652 return false;
2653 }
2654
2655 static final private boolean jj_3_12() {
2656 if (jj_3R_30()) return true;
2657 return false;
2658 }
2659
2660 static final private boolean jj_3R_43() {
2661 if (jj_scan_token(86)) return true;
2662 return false;
2663 }
2664
2665 static final private boolean jj_3_2() {
2666 if (jj_scan_token(OR)) return true;
2667 if (jj_3R_29()) return true;
2668 return false;
2669 }
2670
2671 static final private boolean jj_3R_48() {
2672 if (jj_scan_token(NOT)) return true;
2673 return false;
2674 }
2675
2676 static final private boolean jj_3_1() {
2677 if (jj_scan_token(AND)) return true;
2678 if (jj_3R_28()) return true;
2679 return false;
2680 }
2681
2682 static final private boolean jj_3R_37() {
2683 if (jj_3R_45()) return true;
2684 return false;
2685 }
2686
2687 static final private boolean jj_3R_42() {
2688 if (jj_3R_48()) return true;
2689 return false;
2690 }
2691
2692 static final private boolean jj_3R_35() {
2693 Token xsp;
2694 xsp = jj_scanpos;
2695 if (jj_3R_42()) {
2696 jj_scanpos = xsp;
2697 if (jj_3R_43()) {
2698 jj_scanpos = xsp;
2699 if (jj_3R_44()) return true;
2700 }
2701 }
2702 return false;
2703 }
2704
2705 static final private boolean jj_3R_31() {
2706 Token xsp;
2707 while (true) {
2708 xsp = jj_scanpos;
2709 if (jj_3R_37()) { jj_scanpos = xsp; break; }
2710 }
2711 if (jj_scan_token(METHOD_CLASS_PATTERN)) return true;
2712 if (jj_3R_38()) return true;
2713 return false;
2714 }
2715
2716 static final private boolean jj_3_10() {
2717 if (jj_3R_30()) return true;
2718 return false;
2719 }
2720
2721 static final private boolean jj_3R_28() {
2722 if (jj_3R_35()) return true;
2723 return false;
2724 }
2725
2726 static final private boolean jj_3R_29() {
2727 if (jj_3R_28()) return true;
2728 return false;
2729 }
2730
2731 static final private boolean jj_3R_75() {
2732 if (jj_scan_token(WITHIN_CODE)) return true;
2733 return false;
2734 }
2735
2736 static final private boolean jj_3_9() {
2737 if (jj_3R_33()) return true;
2738 return false;
2739 }
2740
2741 static final private boolean jj_3R_80() {
2742 if (jj_scan_token(WITHIN)) return true;
2743 return false;
2744 }
2745
2746 static final private boolean jj_3R_81() {
2747 if (jj_scan_token(HANDLER)) return true;
2748 return false;
2749 }
2750
2751 static final private boolean jj_3_8() {
2752 if (jj_3R_32()) return true;
2753 return false;
2754 }
2755
2756 static final private boolean jj_3R_78() {
2757 if (jj_scan_token(GET)) return true;
2758 return false;
2759 }
2760
2761 static final private boolean jj_3R_84() {
2762 if (jj_scan_token(THIS)) return true;
2763 return false;
2764 }
2765
2766 static final private boolean jj_3R_39() {
2767 if (jj_scan_token(FIELD_NOT)) return true;
2768 return false;
2769 }
2770
2771 static final private boolean jj_3R_32() {
2772 Token xsp;
2773 while (true) {
2774 xsp = jj_scanpos;
2775 if (jj_3R_39()) { jj_scanpos = xsp; break; }
2776 }
2777 if (jj_scan_token(FIELD_ANNOTATION)) return true;
2778 return false;
2779 }
2780
2781 static final private boolean jj_3_7() {
2782 if (jj_3R_32()) return true;
2783 return false;
2784 }
2785
2786 static final private boolean jj_3R_77() {
2787 if (jj_scan_token(SET)) return true;
2788 return false;
2789 }
2790
2791 static final private boolean jj_3_6() {
2792 if (jj_3R_31()) return true;
2793 return false;
2794 }
2795
2796 static final private boolean jj_3R_83() {
2797 if (jj_scan_token(TARGET)) return true;
2798 return false;
2799 }
2800
2801 static final private boolean jj_3R_36() {
2802 if (jj_scan_token(METHOD_NOT)) return true;
2803 return false;
2804 }
2805
2806 static final private boolean jj_3R_30() {
2807 Token xsp;
2808 while (true) {
2809 xsp = jj_scanpos;
2810 if (jj_3R_36()) { jj_scanpos = xsp; break; }
2811 }
2812 if (jj_scan_token(METHOD_ANNOTATION)) return true;
2813 return false;
2814 }
2815
2816 static final private boolean jj_3R_54() {
2817 if (jj_scan_token(METHOD_SYNCHRONIZED)) return true;
2818 return false;
2819 }
2820
2821 static final private boolean jj_3R_53() {
2822 if (jj_scan_token(METHOD_PRIVATE)) return true;
2823 return false;
2824 }
2825
2826 static final private boolean jj_3_5() {
2827 if (jj_3R_30()) return true;
2828 return false;
2829 }
2830
2831 static final private boolean jj_3R_73() {
2832 if (jj_scan_token(CALL)) return true;
2833 return false;
2834 }
2835
2836 static final private boolean jj_3_17() {
2837 if (jj_3R_32()) return true;
2838 return false;
2839 }
2840
2841 static final private boolean jj_3R_52() {
2842 if (jj_scan_token(METHOD_PROTECTED)) return true;
2843 return false;
2844 }
2845
2846 static final private boolean jj_3R_79() {
2847 if (jj_scan_token(HAS_FIELD)) return true;
2848 return false;
2849 }
2850
2851 static final private boolean jj_3_4() {
2852 if (jj_3R_31()) return true;
2853 return false;
2854 }
2855
2856 static final private boolean jj_3_16() {
2857 if (jj_3R_31()) return true;
2858 return false;
2859 }
2860
2861 static final private boolean jj_3R_51() {
2862 if (jj_scan_token(METHOD_PUBLIC)) return true;
2863 return false;
2864 }
2865
2866 static final private boolean jj_3R_40() {
2867 if (jj_scan_token(CLASS_NOT)) return true;
2868 return false;
2869 }
2870
2871 static final private boolean jj_3R_33() {
2872 Token xsp;
2873 while (true) {
2874 xsp = jj_scanpos;
2875 if (jj_3R_40()) { jj_scanpos = xsp; break; }
2876 }
2877 if (jj_scan_token(CLASS_ATTRIBUTE)) return true;
2878 return false;
2879 }
2880
2881 static final private boolean jj_3R_50() {
2882 if (jj_scan_token(METHOD_NOT)) return true;
2883 return false;
2884 }
2885
2886 static final private boolean jj_3R_45() {
2887 Token xsp;
2888 while (true) {
2889 xsp = jj_scanpos;
2890 if (jj_3R_50()) { jj_scanpos = xsp; break; }
2891 }
2892 xsp = jj_scanpos;
2893 if (jj_3R_51()) {
2894 jj_scanpos = xsp;
2895 if (jj_3R_52()) {
2896 jj_scanpos = xsp;
2897 if (jj_3R_53()) {
2898 jj_scanpos = xsp;
2899 if (jj_3R_54()) return true;
2900 }
2901 }
2902 }
2903 return false;
2904 }
2905
2906 static private boolean jj_initialized_once = false;
2907 static public ExpressionParserTokenManager token_source;
2908 static SimpleCharStream jj_input_stream;
2909 static public Token token, jj_nt;
2910 static private int jj_ntk;
2911 static private Token jj_scanpos, jj_lastpos;
2912 static private int jj_la;
2913 static public boolean lookingAhead = false;
2914 static private boolean jj_semLA;
2915 static private int jj_gen;
2916 static final private int[] jj_la1 = new int[50];
2917 static private int[] jj_la1_0;
2918 static private int[] jj_la1_1;
2919 static private int[] jj_la1_2;
2920 static {
2921 jj_la1_0();
2922 jj_la1_1();
2923 jj_la1_2();
2924 }
2925 private static void jj_la1_0() {
2926 jj_la1_0 = new int[] {0x1efffc00,0x1efff800,0x18000000,0x88,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe0000080,0x0,0x0,0x0,0x0,0x0,0x0,0xe0000080,0x200000,0x0,0x0,0x0,0x0,0xe0000000,0x80,0x0,0x0,0x0,0x0,0x0,0x8,0x80,0x80,0x80,0x80,0x0,0x0,0x0,0x0,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
2927 }
2928 private static void jj_la1_1() {
2929 jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0xcbfc00,0xcbfc00,0x4cbfc00,0xcbfc00,0xcbfc00,0x4cbfc00,0xf0000000,0xf0000000,0x2f,0xcbfc00,0xcbfc00,0x4cbfc00,0x4dffc00,0x48fc00,0x8fc00,0x2f,0x0,0xcbfc00,0xcbfc00,0x4cbfc00,0xf0000000,0xf,0x20,0xbfc00,0xc00000,0xa1c00,0xf0000000,0x0,0x0,0xc00000,0xc00000,0x0,0x0,0x8,0x80000,0x0,0x8,0x7,0x80000,0xfc00,0x80000,0x3fc00,0x80000,0x21c00,0x0,0xf0000000,};
2930 }
2931 private static void jj_la1_2() {
2932 jj_la1_2 = new int[] {0x400000,0x0,0x0,0x2c0000,0x0,0x0,0x800000,0x0,0x0,0x800000,0xcf,0xcf,0x0,0x0,0x0,0x800000,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0xcf,0x0,0x0,0x0,0x0,0x0,0xf,0xc0,0x0,0x0,0x0,0xc0000,0xc0000,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x7,};
2933 }
2934 static final private JJCalls[] jj_2_rtns = new JJCalls[18];
2935 static private boolean jj_rescan = false;
2936 static private int jj_gc = 0;
2937
2938 public ExpressionParser(java.io.InputStream stream) {
2939 if (jj_initialized_once) {
2940 System.out.println("ERROR: Second call to constructor of static parser. You must");
2941 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
2942 System.out.println(" during parser generation.");
2943 throw new Error ();
2944 }
2945 jj_initialized_once = true;
2946 jj_input_stream = new SimpleCharStream(stream, 1, 1);
2947 token_source = new ExpressionParserTokenManager(jj_input_stream);
2948 token = new Token();
2949 jj_ntk = -1;
2950 jj_gen = 0;
2951 for (int i = 0; i < 50; i++) jj_la1[i] = -1;
2952 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2953 }
2954
2955 static public void ReInit(java.io.InputStream stream) {
2956 jj_input_stream.ReInit(stream, 1, 1);
2957 token_source.ReInit(jj_input_stream);
2958 token = new Token();
2959 jj_ntk = -1;
2960 jjtree.reset();
2961 jj_gen = 0;
2962 for (int i = 0; i < 50; i++) jj_la1[i] = -1;
2963 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2964 }
2965
2966 public ExpressionParser(java.io.Reader stream) {
2967 if (jj_initialized_once) {
2968 System.out.println("ERROR: Second call to constructor of static parser. You must");
2969 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
2970 System.out.println(" during parser generation.");
2971 throw new Error ();
2972 }
2973 jj_initialized_once = true;
2974 jj_input_stream = new SimpleCharStream(stream, 1, 1);
2975 token_source = new ExpressionParserTokenManager(jj_input_stream);
2976 token = new Token();
2977 jj_ntk = -1;
2978 jj_gen = 0;
2979 for (int i = 0; i < 50; i++) jj_la1[i] = -1;
2980 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2981 }
2982
2983 static public void ReInit(java.io.Reader stream) {
2984 jj_input_stream.ReInit(stream, 1, 1);
2985 token_source.ReInit(jj_input_stream);
2986 token = new Token();
2987 jj_ntk = -1;
2988 jjtree.reset();
2989 jj_gen = 0;
2990 for (int i = 0; i < 50; i++) jj_la1[i] = -1;
2991 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2992 }
2993
2994 public ExpressionParser(ExpressionParserTokenManager tm) {
2995 if (jj_initialized_once) {
2996 System.out.println("ERROR: Second call to constructor of static parser. You must");
2997 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
2998 System.out.println(" during parser generation.");
2999 throw new Error ();
3000 }
3001 jj_initialized_once = true;
3002 token_source = tm;
3003 token = new Token();
3004 jj_ntk = -1;
3005 jj_gen = 0;
3006 for (int i = 0; i < 50; i++) jj_la1[i] = -1;
3007 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3008 }
3009
3010 public void ReInit(ExpressionParserTokenManager tm) {
3011 token_source = tm;
3012 token = new Token();
3013 jj_ntk = -1;
3014 jjtree.reset();
3015 jj_gen = 0;
3016 for (int i = 0; i < 50; i++) jj_la1[i] = -1;
3017 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
3018 }
3019
3020 static final private Token jj_consume_token(int kind) throws ParseException {
3021 Token oldToken;
3022 if ((oldToken = token).next != null) token = token.next;
3023 else token = token.next = token_source.getNextToken();
3024 jj_ntk = -1;
3025 if (token.kind == kind) {
3026 jj_gen++;
3027 if (++jj_gc > 100) {
3028 jj_gc = 0;
3029 for (int i = 0; i < jj_2_rtns.length; i++) {
3030 JJCalls c = jj_2_rtns[i];
3031 while (c != null) {
3032 if (c.gen < jj_gen) c.first = null;
3033 c = c.next;
3034 }
3035 }
3036 }
3037 return token;
3038 }
3039 token = oldToken;
3040 jj_kind = kind;
3041 throw generateParseException();
3042 }
3043
3044 static private final class LookaheadSuccess extends java.lang.Error { }
3045 static final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3046 static final private boolean jj_scan_token(int kind) {
3047 if (jj_scanpos == jj_lastpos) {
3048 jj_la--;
3049 if (jj_scanpos.next == null) {
3050 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
3051 } else {
3052 jj_lastpos = jj_scanpos = jj_scanpos.next;
3053 }
3054 } else {
3055 jj_scanpos = jj_scanpos.next;
3056 }
3057 if (jj_rescan) {
3058 int i = 0; Token tok = token;
3059 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
3060 if (tok != null) jj_add_error_token(kind, i);
3061 }
3062 if (jj_scanpos.kind != kind) return true;
3063 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
3064 return false;
3065 }
3066
3067 static final public Token getNextToken() {
3068 if (token.next != null) token = token.next;
3069 else token = token.next = token_source.getNextToken();
3070 jj_ntk = -1;
3071 jj_gen++;
3072 return token;
3073 }
3074
3075 static final public Token getToken(int index) {
3076 Token t = lookingAhead ? jj_scanpos : token;
3077 for (int i = 0; i < index; i++) {
3078 if (t.next != null) t = t.next;
3079 else t = t.next = token_source.getNextToken();
3080 }
3081 return t;
3082 }
3083
3084 static final private int jj_ntk() {
3085 if ((jj_nt=token.next) == null)
3086 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
3087 else
3088 return (jj_ntk = jj_nt.kind);
3089 }
3090
3091 static private java.util.Vector jj_expentries = new java.util.Vector ();
3092 static private int[] jj_expentry;
3093 static private int jj_kind = -1;
3094 static private int[] jj_lasttokens = new int[100];
3095 static private int jj_endpos;
3096
3097 static private void jj_add_error_token(int kind, int pos) {
3098 if (pos >= 100) return;
3099 if (pos == jj_endpos + 1) {
3100 jj_lasttokens[jj_endpos++] = kind;
3101 } else if (jj_endpos != 0) {
3102 jj_expentry = new int[jj_endpos];
3103 for (int i = 0; i < jj_endpos; i++) {
3104 jj_expentry[i] = jj_lasttokens[i];
3105 }
3106 boolean exists = false;
3107 for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
3108 int[] oldentry = (int[])(e.nextElement());
3109 if (oldentry.length == jj_expentry.length) {
3110 exists = true;
3111 for (int i = 0; i < jj_expentry.length; i++) {
3112 if (oldentry[i] != jj_expentry[i]) {
3113 exists = false;
3114 break;
3115 }
3116 }
3117 if (exists) break;
3118 }
3119 }
3120 if (!exists) jj_expentries.addElement(jj_expentry);
3121 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3122 }
3123 }
3124
3125 static public ParseException generateParseException() {
3126 jj_expentries.removeAllElements();
3127 boolean[] la1tokens = new boolean[88];
3128 for (int i = 0; i < 88; i++) {
3129 la1tokens[i] = false;
3130 }
3131 if (jj_kind >= 0) {
3132 la1tokens[jj_kind] = true;
3133 jj_kind = -1;
3134 }
3135 for (int i = 0; i < 50; i++) {
3136 if (jj_la1[i] == jj_gen) {
3137 for (int j = 0; j < 32; j++) {
3138 if ((jj_la1_0[i] & (1<<j)) != 0) {
3139 la1tokens[j] = true;
3140 }
3141 if ((jj_la1_1[i] & (1<<j)) != 0) {
3142 la1tokens[32+j] = true;
3143 }
3144 if ((jj_la1_2[i] & (1<<j)) != 0) {
3145 la1tokens[64+j] = true;
3146 }
3147 }
3148 }
3149 }
3150 for (int i = 0; i < 88; i++) {
3151 if (la1tokens[i]) {
3152 jj_expentry = new int[1];
3153 jj_expentry[0] = i;
3154 jj_expentries.addElement(jj_expentry);
3155 }
3156 }
3157 jj_endpos = 0;
3158 jj_rescan_token();
3159 jj_add_error_token(0, 0);
3160 int[][] exptokseq = new int[jj_expentries.size()][];
3161 for (int i = 0; i < jj_expentries.size(); i++) {
3162 exptokseq[i] = (int[])jj_expentries.elementAt(i);
3163 }
3164 return new ParseException(token, exptokseq, tokenImage);
3165 }
3166
3167 static final public void enable_tracing() {
3168 }
3169
3170 static final public void disable_tracing() {
3171 }
3172
3173 static final private void jj_rescan_token() {
3174 jj_rescan = true;
3175 for (int i = 0; i < 18; i++) {
3176 JJCalls p = jj_2_rtns[i];
3177 do {
3178 if (p.gen > jj_gen) {
3179 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
3180 switch (i) {
3181 case 0: jj_3_1(); break;
3182 case 1: jj_3_2(); break;
3183 case 2: jj_3_3(); break;
3184 case 3: jj_3_4(); break;
3185 case 4: jj_3_5(); break;
3186 case 5: jj_3_6(); break;
3187 case 6: jj_3_7(); break;
3188 case 7: jj_3_8(); break;
3189 case 8: jj_3_9(); break;
3190 case 9: jj_3_10(); break;
3191 case 10: jj_3_11(); break;
3192 case 11: jj_3_12(); break;
3193 case 12: jj_3_13(); break;
3194 case 13: jj_3_14(); break;
3195 case 14: jj_3_15(); break;
3196 case 15: jj_3_16(); break;
3197 case 16: jj_3_17(); break;
3198 case 17: jj_3_18(); break;
3199 }
3200 }
3201 p = p.next;
3202 } while (p != null);
3203 }
3204 jj_rescan = false;
3205 }
3206
3207 static final private void jj_save(int index, int xla) {
3208 JJCalls p = jj_2_rtns[index];
3209 while (p.gen > jj_gen) {
3210 if (p.next == null) { p = p.next = new JJCalls(); break; }
3211 p = p.next;
3212 }
3213 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
3214 }
3215
3216 static final class JJCalls {
3217 int gen;
3218 Token first;
3219 int arg;
3220 JJCalls next;
3221 }
3222
3223}
3224 |
Popular Tags |
Java API By Example, From Geeks To Geeks.