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