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