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