|
1
2 package org.jboss.aop.pointcut.ast;
3
4 import java.lang.reflect.Modifier  ;
5
6 public class TypeExpressionParserimplements TypeExpressionParserTreeConstants, TypeExpressionParserConstants {
7 protected JJTTypeExpressionParserState jjtree = new JJTTypeExpressionParserState();
8
9 final public ASTStart Start() throws ParseException {
10
11 ASTStart jjtn000 = new ASTStart(JJTSTART);
12 boolean jjtc000 = true;
13 jjtree.openNodeScope(jjtn000);
14 try {
15 Expression();
16 jj_consume_token(0);
17 jjtree.closeNodeScope(jjtn000, true);
18 jjtc000 = false;
19 {if (true) return jjtn000;}
20 } catch (Throwable jjte000) {
21 if (jjtc000) {
22 jjtree.clearNodeScope(jjtn000);
23 jjtc000 = false;
24 } else {
25 jjtree.popNode();
26 }
27 if (jjte000 instanceof RuntimeException ) {
28 {if (true) throw (RuntimeException )jjte000;}
29 }
30 if (jjte000 instanceof ParseException) {
31 {if (true) throw (ParseException)jjte000;}
32 }
33 {if (true) throw (Error )jjte000;}
34 } finally {
35 if (jjtc000) {
36 jjtree.closeNodeScope(jjtn000, true);
37 }
38 }
39 throw new Error ("Missing return statement in function");
40 }
41
42 final public void Expression() throws ParseException {
43 if (jj_2_1(234234234)) {
44 BooleanExpression();
45 } else {
46 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
47 case HAS:
48 case HAS_FIELD:
49 case FIELD:
50 case CLASS_EXPR:
51 case METHOD_EXPR:
52 case CONSTRUCTOR_EXPR:
53 Concrete();
54 break;
55 case NOT:
56 Not();
57 break;
58 default:
59 jj_la1[0] = jj_gen;
60 jj_consume_token(-1);
61 throw new ParseException();
62 }
63 }
64 }
65
66 final public void BooleanExpression() throws ParseException {
67
68 ASTBoolean jjtn000 = new ASTBoolean(JJTBOOLEAN);
69 boolean jjtc000 = true;
70 jjtree.openNodeScope(jjtn000);
71 try {
72 if (jj_2_2(3)) {
73 SubExpression();
74 } else if (jj_2_3(3)) {
75 CompositeExpression();
76 } else {
77 jj_consume_token(-1);
78 throw new ParseException();
79 }
80 } catch (Throwable jjte000) {
81 if (jjtc000) {
82 jjtree.clearNodeScope(jjtn000);
83 jjtc000 = false;
84 } else {
85 jjtree.popNode();
86 }
87 if (jjte000 instanceof RuntimeException ) {
88 {if (true) throw (RuntimeException )jjte000;}
89 }
90 if (jjte000 instanceof ParseException) {
91 {if (true) throw (ParseException)jjte000;}
92 }
93 {if (true) throw (Error )jjte000;}
94 } finally {
95 if (jjtc000) {
96 jjtree.closeNodeScope(jjtn000, true);
97 }
98 }
99 }
100
101 final public void CompositeExpression() throws ParseException {
102
103 ASTComposite jjtn000 = new ASTComposite(JJTCOMPOSITE);
104 boolean jjtc000 = true;
105 jjtree.openNodeScope(jjtn000);
106 try {
107 jj_consume_token(75);
108 SubExpression();
109 jj_consume_token(76);
110 } catch (Throwable jjte000) {
111 if (jjtc000) {
112 jjtree.clearNodeScope(jjtn000);
113 jjtc000 = false;
114 } else {
115 jjtree.popNode();
116 }
117 if (jjte000 instanceof RuntimeException ) {
118 {if (true) throw (RuntimeException )jjte000;}
119 }
120 if (jjte000 instanceof ParseException) {
121 {if (true) throw (ParseException)jjte000;}
122 }
123 {if (true) throw (Error )jjte000;}
124 } finally {
125 if (jjtc000) {
126 jjtree.closeNodeScope(jjtn000, true);
127 }
128 }
129 }
130
131 final public void Not() throws ParseException {
132
133 ASTNot jjtn000 = new ASTNot(JJTNOT);
134 boolean jjtc000 = true;
135 jjtree.openNodeScope(jjtn000);
136 try {
137 jj_consume_token(NOT);
138 if (jj_2_4(3)) {
139 ConcreteExpression();
140 } else if (jj_2_5(3)) {
141 CompositeExpression();
142 } else {
143 jj_consume_token(-1);
144 throw new ParseException();
145 }
146 } catch (Throwable jjte000) {
147 if (jjtc000) {
148 jjtree.clearNodeScope(jjtn000);
149 jjtc000 = false;
150 } else {
151 jjtree.popNode();
152 }
153 if (jjte000 instanceof RuntimeException ) {
154 {if (true) throw (RuntimeException )jjte000;}
155 }
156 if (jjte000 instanceof ParseException) {
157 {if (true) throw (ParseException)jjte000;}
158 }
159 {if (true) throw (Error )jjte000;}
160 } finally {
161 if (jjtc000) {
162 jjtree.closeNodeScope(jjtn000, true);
163 }
164 }
165 }
166
167 final public void SubExpression() throws ParseException {
168
169 ASTSub jjtn000 = new ASTSub(JJTSUB);
170 boolean jjtc000 = true;
171 jjtree.openNodeScope(jjtn000);
172 try {
173 if (jj_2_6(3)) {
174 Not();
175 } else if (jj_2_7(3)) {
176 ConcreteExpression();
177 } else if (jj_2_8(3)) {
178 CompositeExpression();
179 } else {
180 jj_consume_token(-1);
181 throw new ParseException();
182 }
183 label_1:
184 while (true) {
185 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
186 case AND:
187 And();
188 break;
189 case OR:
190 Or();
191 break;
192 default:
193 jj_la1[1] = jj_gen;
194 jj_consume_token(-1);
195 throw new ParseException();
196 }
197 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
198 case AND:
199 case OR:
200 ;
201 break;
202 default:
203 jj_la1[2] = jj_gen;
204 break label_1;
205 }
206 }
207 } catch (Throwable jjte000) {
208 if (jjtc000) {
209 jjtree.clearNodeScope(jjtn000);
210 jjtc000 = false;
211 } else {
212 jjtree.popNode();
213 }
214 if (jjte000 instanceof RuntimeException ) {
215 {if (true) throw (RuntimeException )jjte000;}
216 }
217 if (jjte000 instanceof ParseException) {
218 {if (true) throw (ParseException)jjte000;}
219 }
220 {if (true) throw (Error )jjte000;}
221 } finally {
222 if (jjtc000) {
223 jjtree.closeNodeScope(jjtn000, true);
224 }
225 }
226 }
227
228 final public void And() throws ParseException {
229
230 ASTAnd jjtn000 = new ASTAnd(JJTAND);
231 boolean jjtc000 = true;
232 jjtree.openNodeScope(jjtn000);
233 try {
234 jj_consume_token(AND);
235 if (jj_2_9(3)) {
236 ConcreteExpression();
237 } else if (jj_2_10(3)) {
238 CompositeExpression();
239 } else if (jj_2_11(3)) {
240 Not();
241 } else {
242 jj_consume_token(-1);
243 throw new ParseException();
244 }
245 } catch (Throwable jjte000) {
246 if (jjtc000) {
247 jjtree.clearNodeScope(jjtn000);
248 jjtc000 = false;
249 } else {
250 jjtree.popNode();
251 }
252 if (jjte000 instanceof RuntimeException ) {
253 {if (true) throw (RuntimeException )jjte000;}
254 }
255 if (jjte000 instanceof ParseException) {
256 {if (true) throw (ParseException)jjte000;}
257 }
258 {if (true) throw (Error )jjte000;}
259 } finally {
260 if (jjtc000) {
261 jjtree.closeNodeScope(jjtn000, true);
262 }
263 }
264 }
265
266 final public void Or() throws ParseException {
267
268 ASTOr jjtn000 = new ASTOr(JJTOR);
269 boolean jjtc000 = true;
270 jjtree.openNodeScope(jjtn000);
271 try {
272 jj_consume_token(OR);
273 if (jj_2_12(3)) {
274 ConcreteExpression();
275 } else if (jj_2_13(3)) {
276 CompositeExpression();
277 } else if (jj_2_14(3)) {
278 Not();
279 } else {
280 jj_consume_token(-1);
281 throw new ParseException();
282 }
283 } catch (Throwable jjte000) {
284 if (jjtc000) {
285 jjtree.clearNodeScope(jjtn000);
286 jjtc000 = false;
287 } else {
288 jjtree.popNode();
289 }
290 if (jjte000 instanceof RuntimeException ) {
291 {if (true) throw (RuntimeException )jjte000;}
292 }
293 if (jjte000 instanceof ParseException) {
294 {if (true) throw (ParseException)jjte000;}
295 }
296 {if (true) throw (Error )jjte000;}
297 } finally {
298 if (jjtc000) {
299 jjtree.closeNodeScope(jjtn000, true);
300 }
301 }
302 }
303
304 final public void ConcreteExpression() throws ParseException {
305 Concrete();
306 }
307
308 final public void Concrete() throws ParseException {
309 if (jj_2_15(4)) {
310 Class();
311 } else if (jj_2_16(4)) {
312 MethodWrapper();
313 } else if (jj_2_17(4)) {
314 FieldWrapper();
315 } else if (jj_2_18(4)) {
316 ConstructorWrapper();
317 } else if (jj_2_19(4)) {
318 Has();
319 } else if (jj_2_20(4)) {
320 HasField();
321 } else {
322 jj_consume_token(-1);
323 throw new ParseException();
324 }
325 }
326
327 final public void Has() throws ParseException {
328
329 ASTHas jjtn000 = new ASTHas(JJTHAS);
330 boolean jjtc000 = true;
331 jjtree.openNodeScope(jjtn000);
332 try {
333 jj_consume_token(HAS);
334 if (jj_2_21(4)) {
335 Method();
336 } else if (jj_2_22(4)) {
337 Constructor();
338 } else {
339 jj_consume_token(-1);
340 throw new ParseException();
341 }
342 jj_consume_token(BEHAVIOR_CLOSE);
343 } catch (Throwable jjte000) {
344 if (jjtc000) {
345 jjtree.clearNodeScope(jjtn000);
346 jjtc000 = false;
347 } else {
348 jjtree.popNode();
349 }
350 if (jjte000 instanceof RuntimeException ) {
351 {if (true) throw (RuntimeException )jjte000;}
352 }
353 if (jjte000 instanceof ParseException) {
354 {if (true) throw (ParseException)jjte000;}
355 }
356 {if (true) throw (Error )jjte000;}
357 } finally {
358 if (jjtc000) {
359 jjtree.closeNodeScope(jjtn000, true);
360 }
361 }
362 }
363
364 final public void HasField() throws ParseException {
365
366 ASTHasField jjtn000 = new ASTHasField(JJTHASFIELD);
367 boolean jjtc000 = true;
368 jjtree.openNodeScope(jjtn000);
369 try {
370 jj_consume_token(HAS_FIELD);
371 Field();
372 jj_consume_token(FIELD_CLOSE);
373 } catch (Throwable jjte000) {
374 if (jjtc000) {
375 jjtree.clearNodeScope(jjtn000);
376 jjtc000 = false;
377 } else {
378 jjtree.popNode();
379 }
380 if (jjte000 instanceof RuntimeException ) {
381 {if (true) throw (RuntimeException )jjte000;}
382 }
383 if (jjte000 instanceof ParseException) {
384 {if (true) throw (ParseException)jjte000;}
385 }
386 {if (true) throw (Error )jjte000;}
387 } finally {
388 if (jjtc000) {
389 jjtree.closeNodeScope(jjtn000, true);
390 }
391 }
392 }
393
394 final public void FieldWrapper() throws ParseException {
395 jj_consume_token(FIELD);
396 Field();
397 jj_consume_token(FIELD_CLOSE);
398 }
399
400 final public void MethodWrapper() throws ParseException {
401 jj_consume_token(METHOD_EXPR);
402 Method();
403 jj_consume_token(BEHAVIOR_CLOSE);
404 }
405
406 final public void ConstructorWrapper() throws ParseException {
407 jj_consume_token(CONSTRUCTOR_EXPR);
408 Constructor();
409 jj_consume_token(BEHAVIOR_CLOSE);
410 }
411
412 final public void Method() throws ParseException {
413
414 ASTMethod jjtn000 = new ASTMethod(JJTMETHOD);
415 boolean jjtc000 = true;
416 jjtree.openNodeScope(jjtn000);Token ret, clazz, body;
417 try {
418 label_2:
419 while (true) {
420 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
421 case ABSTRACT:
422 case FINAL:
423 case PRIVATE:
424 case PROTECTED:
425 case PUBLIC:
426 case STATIC:
427 case NATIVE:
428 case SYNCHRONIZED:
429 case BEHAVIOR_NOT:
430 ;
431 break;
432 default:
433 jj_la1[3] = jj_gen;
434 break label_2;
435 }
436 Attribute();
437 }
438 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
439 case CLASS:
440 ret = jj_consume_token(CLASS);
441 break;
442 case IDENTIFIER:
443 ret = jj_consume_token(IDENTIFIER);
444 break;
445 case ANNOTATION:
446 ret = jj_consume_token(ANNOTATION);
447 break;
448 case ARRAY_CLASS:
449 ret = jj_consume_token(ARRAY_CLASS);
450 break;
451 case INSTANCEOF:
452 ret = jj_consume_token(INSTANCEOF);
453 break;
454 case TYPEDEF:
455 ret = jj_consume_token(TYPEDEF);
456 break;
457 default:
458 jj_la1[4] = jj_gen;
459 jj_consume_token(-1);
460 throw new ParseException();
461 }
462 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
463 case CLASS:
464 clazz = jj_consume_token(CLASS);
465 break;
466 case IDENTIFIER:
467 clazz = jj_consume_token(IDENTIFIER);
468 break;
469 case ANNOTATION:
470 clazz = jj_consume_token(ANNOTATION);
471 break;
472 case INSTANCEOF:
473 clazz = jj_consume_token(INSTANCEOF);
474 break;
475 case TYPEDEF:
476 clazz = jj_consume_token(TYPEDEF);
477 break;
478 default:
479 jj_la1[5] = jj_gen;
480 jj_consume_token(-1);
481 throw new ParseException();
482 }
483 jj_consume_token(SEPARATOR);
484 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
485 case IDENTIFIER:
486 body = jj_consume_token(IDENTIFIER);
487 break;
488 case ANNOTATION:
489 body = jj_consume_token(ANNOTATION);
490 break;
491 default:
492 jj_la1[6] = jj_gen;
493 jj_consume_token(-1);
494 throw new ParseException();
495 }
496 Parameters();
497 Throws();
498 jjtree.closeNodeScope(jjtn000, true);
499 jjtc000 = false;
500 jjtn000.setReturnTypeExpression(ret.image);
501 jjtn000.setClassExpression(clazz.image);
502 jjtn000.setMethodExpression(body.image);
503 } catch (Throwable jjte000) {
504 if (jjtc000) {
505 jjtree.clearNodeScope(jjtn000);
506 jjtc000 = false;
507 } else {
508 jjtree.popNode();
509 }
510 if (jjte000 instanceof RuntimeException ) {
511 {if (true) throw (RuntimeException )jjte000;}
512 }
513 if (jjte000 instanceof ParseException) {
514 {if (true) throw (ParseException)jjte000;}
515 }
516 {if (true) throw (Error )jjte000;}
517 } finally {
518 if (jjtc000) {
519 jjtree.closeNodeScope(jjtn000, true);
520 }
521 }
522 }
523
524 final public void Attribute() throws ParseException {
525
526 ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
527 boolean jjtc000 = true;
528 jjtree.openNodeScope(jjtn000);
529 try {
530 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
531 case BEHAVIOR_NOT:
532 jj_consume_token(BEHAVIOR_NOT);
533 jjtn000.not=true;
534 break;
535 default:
536 jj_la1[7] = jj_gen;
537 ;
538 }
539 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
540 case PUBLIC:
541 jj_consume_token(PUBLIC);
542 jjtree.closeNodeScope(jjtn000, true);
543 jjtc000 = false;
544 jjtn000.setValue(Modifier.PUBLIC);
545 break;
546 case PROTECTED:
547 jj_consume_token(PROTECTED);
548 jjtree.closeNodeScope(jjtn000, true);
549 jjtc000 = false;
550 jjtn000.setValue(Modifier.PROTECTED);
551 break;
552 case PRIVATE:
553 jj_consume_token(PRIVATE);
554 jjtree.closeNodeScope(jjtn000, true);
555 jjtc000 = false;
556 jjtn000.setValue(Modifier.PRIVATE);
557 break;
558 case STATIC:
559 jj_consume_token(STATIC);
560 jjtree.closeNodeScope(jjtn000, true);
561 jjtc000 = false;
562 jjtn000.setValue(Modifier.STATIC);
563 break;
564 case ABSTRACT:
565 jj_consume_token(ABSTRACT);
566 jjtree.closeNodeScope(jjtn000, true);
567 jjtc000 = false;
568 jjtn000.setValue(Modifier.ABSTRACT);
569 break;
570 case FINAL:
571 jj_consume_token(FINAL);
572 jjtree.closeNodeScope(jjtn000, true);
573 jjtc000 = false;
574 jjtn000.setValue(Modifier.FINAL);
575 break;
576 case NATIVE:
577 jj_consume_token(NATIVE);
578 jjtree.closeNodeScope(jjtn000, true);
579 jjtc000 = false;
580 jjtn000.setValue(Modifier.NATIVE);
581 break;
582 case SYNCHRONIZED:
583 jj_consume_token(SYNCHRONIZED);
584 jjtree.closeNodeScope(jjtn000, true);
585 jjtc000 = false;
586 jjtn000.setValue(Modifier.SYNCHRONIZED);
587 break;
588 default:
589 jj_la1[8] = jj_gen;
590 jj_consume_token(-1);
591 throw new ParseException();
592 }
593 } finally {
594 if (jjtc000) {
595 jjtree.closeNodeScope(jjtn000, true);
596 }
597 }
598 }
599
600 final public void Constructor() throws ParseException {
601
602 ASTConstructor jjtn000 = new ASTConstructor(JJTCONSTRUCTOR);
603 boolean jjtc000 = true;
604 jjtree.openNodeScope(jjtn000);Token clazz, danew;
605 try {
606 label_3:
607 while (true) {
608 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
609 case PRIVATE:
610 case PROTECTED:
611 case PUBLIC:
612 ;
613 break;
614 default:
615 jj_la1[9] = jj_gen;
616 break label_3;
617 }
618 ConstructorAttribute();
619 }
620 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
621 case CLASS:
622 clazz = jj_consume_token(CLASS);
623 break;
624 case IDENTIFIER:
625 clazz = jj_consume_token(IDENTIFIER);
626 break;
627 case ANNOTATION:
628 clazz = jj_consume_token(ANNOTATION);
629 break;
630 case INSTANCEOF:
631 clazz = jj_consume_token(INSTANCEOF);
632 break;
633 case TYPEDEF:
634 clazz = jj_consume_token(TYPEDEF);
635 break;
636 default:
637 jj_la1[10] = jj_gen;
638 jj_consume_token(-1);
639 throw new ParseException();
640 }
641 jjtn000.setClassExpression(clazz.image);
642 jj_consume_token(SEPARATOR);
643 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
644 case NEW:
645 danew = jj_consume_token(NEW);
646 break;
647 case ANNOTATION:
648 danew = jj_consume_token(ANNOTATION);
649 break;
650 default:
651 jj_la1[11] = jj_gen;
652 jj_consume_token(-1);
653 throw new ParseException();
654 }
655 Parameters();
656 Throws();
657 jjtree.closeNodeScope(jjtn000, true);
658 jjtc000 = false;
659 jjtn000.setNewExpression(danew.image);
660 } catch (Throwable jjte000) {
661 if (jjtc000) {
662 jjtree.clearNodeScope(jjtn000);
663 jjtc000 = false;
664 } else {
665 jjtree.popNode();
666 }
667 if (jjte000 instanceof RuntimeException ) {
668 {if (true) throw (RuntimeException )jjte000;}
669 }
670 if (jjte000 instanceof ParseException) {
671 {if (true) throw (ParseException)jjte000;}
672 }
673 {if (true) throw (Error )jjte000;}
674 } finally {
675 if (jjtc000) {
676 jjtree.closeNodeScope(jjtn000, true);
677 }
678 }
679 }
680
681 final public void ConstructorAttribute() throws ParseException {
682
683 ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
684 boolean jjtc000 = true;
685 jjtree.openNodeScope(jjtn000);
686 try {
687 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
688 case PUBLIC:
689 jj_consume_token(PUBLIC);
690 jjtree.closeNodeScope(jjtn000, true);
691 jjtc000 = false;
692 jjtn000.setValue(Modifier.PUBLIC);
693 break;
694 case PROTECTED:
695 jj_consume_token(PROTECTED);
696 jjtree.closeNodeScope(jjtn000, true);
697 jjtc000 = false;
698 jjtn000.setValue(Modifier.PROTECTED);
699 break;
700 case PRIVATE:
701 jj_consume_token(PRIVATE);
702 jjtree.closeNodeScope(jjtn000, true);
703 jjtc000 = false;
704 jjtn000.setValue(Modifier.PRIVATE);
705 break;
706 default:
707 jj_la1[12] = jj_gen;
708 jj_consume_token(-1);
709 throw new ParseException();
710 }
711 } finally {
712 if (jjtc000) {
713 jjtree.closeNodeScope(jjtn000, true);
714 }
715 }
716 }
717
718 final public void Parameters() throws ParseException {
719 if (jj_2_23(3)) {
720 jj_consume_token(PARAMS_OPEN);
721 AllParams();
722 jj_consume_token(PARAMS_CLOSE);
723 } else if (jj_2_24(3)) {
724 jj_consume_token(PARAMS_OPEN);
725 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
726 case ALL_PARAMS:
727 case PARAM_INSTANCEOF:
728 case PARAM_TYPEDEF:
729 case PARAM_CLASS:
730 case PARAM_ARRAY_CLASS:
731 case PARAM_ANNOTATION:
732 case PARAM_IDENTIFIER:
733 Parameter();
734 label_4:
735 while (true) {
736 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
737 case COMMA:
738 ;
739 break;
740 default:
741 jj_la1[13] = jj_gen;
742 break label_4;
743 }
744 jj_consume_token(COMMA);
745 Parameter();
746 }
747 break;
748 default:
749 jj_la1[14] = jj_gen;
750 ;
751 }
752 jj_consume_token(PARAMS_CLOSE);
753 } else {
754 jj_consume_token(-1);
755 throw new ParseException();
756 }
757 }
758
759 final public void Parameter() throws ParseException {
760
761 ASTParameter jjtn000 = new ASTParameter(JJTPARAMETER);
762 boolean jjtc000 = true;
763 jjtree.openNodeScope(jjtn000);Token t;
764 try {
765 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
766 case ALL_PARAMS:
767 t = jj_consume_token(ALL_PARAMS);
768 break;
769 case PARAM_CLASS:
770 t = jj_consume_token(PARAM_CLASS);
771 break;
772 case PARAM_IDENTIFIER:
773 t = jj_consume_token(PARAM_IDENTIFIER);
774 break;
775 case PARAM_ARRAY_CLASS:
776 t = jj_consume_token(PARAM_ARRAY_CLASS);
777 break;
778 case PARAM_ANNOTATION:
779 t = jj_consume_token(PARAM_ANNOTATION);
780 break;
781 case PARAM_TYPEDEF:
782 t = jj_consume_token(PARAM_TYPEDEF);
783 break;
784 case PARAM_INSTANCEOF:
785 t = jj_consume_token(PARAM_INSTANCEOF);
786 break;
787 default:
788 jj_la1[15] = jj_gen;
789 jj_consume_token(-1);
790 throw new ParseException();
791 }
792 jjtree.closeNodeScope(jjtn000, true);
793 jjtc000 = false;
794 jjtn000.setTypeExpression(t.image);
795 } finally {
796 if (jjtc000) {
797 jjtree.closeNodeScope(jjtn000, true);
798 }
799 }
800 }
801
802 final public void AllParams() throws ParseException {
803
804 ASTAllParameter jjtn000 = new ASTAllParameter(JJTALLPARAMETER);
805 boolean jjtc000 = true;
806 jjtree.openNodeScope(jjtn000);
807 try {
808 jj_consume_token(ALL_PARAMS);
809 } finally {
810 if (jjtc000) {
811 jjtree.closeNodeScope(jjtn000, true);
812 }
813 }
814 }
815
816 final public void Field() throws ParseException {
817
818 ASTField jjtn000 = new ASTField(JJTFIELD);
819 boolean jjtc000 = true;
820 jjtree.openNodeScope(jjtn000);Token type, clazz, body;
821 try {
822 label_5:
823 while (true) {
824 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
825 case FIELD_FINAL:
826 case FIELD_PRIVATE:
827 case FIELD_PROTECTED:
828 case FIELD_PUBLIC:
829 case FIELD_STATIC:
830 case FIELD_TRANSIENT:
831 case FIELD_NOT:
832 ;
833 break;
834 default:
835 jj_la1[16] = jj_gen;
836 break label_5;
837 }
838 FieldAttribute();
839 }
840 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
841 case FIELD_CLASS:
842 type = jj_consume_token(FIELD_CLASS);
843 break;
844 case FIELD_IDENTIFIER:
845 type = jj_consume_token(FIELD_IDENTIFIER);
846 break;
847 case FIELD_ANNOTATION:
848 type = jj_consume_token(FIELD_ANNOTATION);
849 break;
850 case FIELD_ARRAY_CLASS:
851 type = jj_consume_token(FIELD_ARRAY_CLASS);
852 break;
853 case FIELD_INSTANCEOF:
854 type = jj_consume_token(FIELD_INSTANCEOF);
855 break;
856 case FIELD_TYPEDEF:
857 type = jj_consume_token(FIELD_TYPEDEF);
858 break;
859 default:
860 jj_la1[17] = jj_gen;
861 jj_consume_token(-1);
862 throw new ParseException();
863 }
864 jjtn000.setTypeExpression(type.image);
865 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
866 case FIELD_CLASS:
867 clazz = jj_consume_token(FIELD_CLASS);
868 break;
869 case FIELD_IDENTIFIER:
870 clazz = jj_consume_token(FIELD_IDENTIFIER);
871 break;
872 case FIELD_ANNOTATION:
873 clazz = jj_consume_token(FIELD_ANNOTATION);
874 break;
875 case FIELD_INSTANCEOF:
876 clazz = jj_consume_token(FIELD_INSTANCEOF);
877 break;
878 case FIELD_TYPEDEF:
879 clazz = jj_consume_token(FIELD_TYPEDEF);
880 break;
881 default:
882 jj_la1[18] = jj_gen;
883 jj_consume_token(-1);
884 throw new ParseException();
885 }
886 jjtn000.setClassExpr(clazz.image);
887 jj_consume_token(FIELD_SEPARATOR);
888 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
889 case FIELD_IDENTIFIER:
890 body = jj_consume_token(FIELD_IDENTIFIER);
891 break;
892 case FIELD_ANNOTATION:
893 body = jj_consume_token(FIELD_ANNOTATION);
894 break;
895 default:
896 jj_la1[19] = jj_gen;
897 jj_consume_token(-1);
898 throw new ParseException();
899 }
900 jjtree.closeNodeScope(jjtn000, true);
901 jjtc000 = false;
902 jjtn000.setFieldExpr(body.image);
903 } catch (Throwable jjte000) {
904 if (jjtc000) {
905 jjtree.clearNodeScope(jjtn000);
906 jjtc000 = false;
907 } else {
908 jjtree.popNode();
909 }
910 if (jjte000 instanceof RuntimeException ) {
911 {if (true) throw (RuntimeException )jjte000;}
912 }
913 if (jjte000 instanceof ParseException) {
914 {if (true) throw (ParseException)jjte000;}
915 }
916 {if (true) throw (Error )jjte000;}
917 } finally {
918 if (jjtc000) {
919 jjtree.closeNodeScope(jjtn000, true);
920 }
921 }
922 }
923
924 final public void FieldAttribute() throws ParseException {
925
926 ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
927 boolean jjtc000 = true;
928 jjtree.openNodeScope(jjtn000);
929 try {
930 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
931 case FIELD_NOT:
932 jj_consume_token(FIELD_NOT);
933 jjtn000.not = true;
934 break;
935 default:
936 jj_la1[20] = jj_gen;
937 ;
938 }
939 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
940 case FIELD_PUBLIC:
941 jj_consume_token(FIELD_PUBLIC);
942 jjtree.closeNodeScope(jjtn000, true);
943 jjtc000 = false;
944 jjtn000.setValue(Modifier.PUBLIC);
945 break;
946 case FIELD_PROTECTED:
947 jj_consume_token(FIELD_PROTECTED);
948 jjtree.closeNodeScope(jjtn000, true);
949 jjtc000 = false;
950 jjtn000.setValue(Modifier.PROTECTED);
951 break;
952 case FIELD_PRIVATE:
953 jj_consume_token(FIELD_PRIVATE);
954 jjtree.closeNodeScope(jjtn000, true);
955 jjtc000 = false;
956 jjtn000.setValue(Modifier.PRIVATE);
957 break;
958 case FIELD_STATIC:
959 jj_consume_token(FIELD_STATIC);
960 jjtree.closeNodeScope(jjtn000, true);
961 jjtc000 = false;
962 jjtn000.setValue(Modifier.STATIC);
963 break;
964 case FIELD_FINAL:
965 jj_consume_token(FIELD_FINAL);
966 jjtree.closeNodeScope(jjtn000, true);
967 jjtc000 = false;
968 jjtn000.setValue(Modifier.FINAL);
969 break;
970 case FIELD_TRANSIENT:
971 jj_consume_token(FIELD_TRANSIENT);
972 jjtree.closeNodeScope(jjtn000, true);
973 jjtc000 = false;
974 jjtn000.setValue(Modifier.TRANSIENT);
975 break;
976 default:
977 jj_la1[21] = jj_gen;
978 jj_consume_token(-1);
979 throw new ParseException();
980 }
981 } finally {
982 if (jjtc000) {
983 jjtree.closeNodeScope(jjtn000, true);
984 }
985 }
986 }
987
988 final public void Class() throws ParseException {
989
990 ASTClass jjtn000 = new ASTClass(JJTCLASS);
991 boolean jjtc000 = true;
992 jjtree.openNodeScope(jjtn000);Token clazz;
993 try {
994 jj_consume_token(CLASS_EXPR);
995 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
996 case FIELD_CLASS:
997 clazz = jj_consume_token(FIELD_CLASS);
998 break;
999 case FIELD_IDENTIFIER:
1000 clazz = jj_consume_token(FIELD_IDENTIFIER);
1001 break;
1002 case FIELD_ANNOTATION:
1003 clazz = jj_consume_token(FIELD_ANNOTATION);
1004 break;
1005 case FIELD_INSTANCEOF:
1006 clazz = jj_consume_token(FIELD_INSTANCEOF);
1007 break;
1008 case FIELD_TYPEDEF:
1009 clazz = jj_consume_token(FIELD_TYPEDEF);
1010 break;
1011 default:
1012 jj_la1[22] = jj_gen;
1013 jj_consume_token(-1);
1014 throw new ParseException();
1015 }
1016 jjtn000.setClassExpr(clazz.image);
1017 jj_consume_token(FIELD_CLOSE);
1018 } finally {
1019 if (jjtc000) {
1020 jjtree.closeNodeScope(jjtn000, true);
1021 }
1022 }
1023 }
1024
1025 final public void Throws() throws ParseException {
1026 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1027 case THROWS:
1028 jj_consume_token(THROWS);
1029 Exception();
1030 label_6:
1031 while (true) {
1032 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1033 case EXCEPTION_SEPERATOR:
1034 ;
1035 break;
1036 default:
1037 jj_la1[23] = jj_gen;
1038 break label_6;
1039 }
1040 jj_consume_token(EXCEPTION_SEPERATOR);
1041 Exception();
1042 }
1043 break;
1044 default:
1045 jj_la1[24] = jj_gen;
1046 ;
1047 }
1048 }
1049
1050 final public void Exception() throws ParseException {
1051
1052 ASTException jjtn000 = new ASTException(JJTEXCEPTION);
1053 boolean jjtc000 = true;
1054 jjtree.openNodeScope(jjtn000);Token ex;
1055 try {
1056 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1057 case CLASS:
1058 ex = jj_consume_token(CLASS);
1059 break;
1060 case IDENTIFIER:
1061 ex = jj_consume_token(IDENTIFIER);
1062 break;
1063 default:
1064 jj_la1[25] = jj_gen;
1065 jj_consume_token(-1);
1066 throw new ParseException();
1067 }
1068 jjtree.closeNodeScope(jjtn000, true);
1069 jjtc000 = false;
1070 jjtn000.setTypeExpression(ex.image);
1071 } finally {
1072 if (jjtc000) {
1073 jjtree.closeNodeScope(jjtn000, true);
1074 }
1075 }
1076 }
1077
1078 final private boolean jj_2_1(int xla) {
1079 jj_la = xla; jj_lastpos = jj_scanpos = token;
1080 try { return !jj_3_1(); }
1081 catch(LookaheadSuccess ls) { return true; }
1082 finally { jj_save(0, xla); }
1083 }
1084
1085 final private boolean jj_2_2(int xla) {
1086 jj_la = xla; jj_lastpos = jj_scanpos = token;
1087 try { return !jj_3_2(); }
1088 catch(LookaheadSuccess ls) { return true; }
1089 finally { jj_save(1, xla); }
1090 }
1091
1092 final private boolean jj_2_3(int xla) {
1093 jj_la = xla; jj_lastpos = jj_scanpos = token;
1094 try { return !jj_3_3(); }
1095 catch(LookaheadSuccess ls) { return true; }
1096 finally { jj_save(2, xla); }
1097 }
1098
1099 final private boolean jj_2_4(int xla) {
1100 jj_la = xla; jj_lastpos = jj_scanpos = token;
1101 try { return !jj_3_4(); }
1102 catch(LookaheadSuccess ls) { return true; }
1103 finally { jj_save(3, xla); }
1104 }
1105
1106 final private boolean jj_2_5(int xla) {
1107 jj_la = xla; jj_lastpos = jj_scanpos = token;
1108 try { return !jj_3_5(); }
1109 catch(LookaheadSuccess ls) { return true; }
1110 finally { jj_save(4, xla); }
1111 }
1112
1113 final private boolean jj_2_6(int xla) {
1114 jj_la = xla; jj_lastpos = jj_scanpos = token;
1115 try { return !jj_3_6(); }
1116 catch(LookaheadSuccess ls) { return true; }
1117 finally { jj_save(5, xla); }
1118 }
1119
1120 final private boolean jj_2_7(int xla) {
1121 jj_la = xla; jj_lastpos = jj_scanpos = token;
1122 try { return !jj_3_7(); }
1123 catch(LookaheadSuccess ls) { return true; }
1124 finally { jj_save(6, xla); }
1125 }
1126
1127 final private boolean jj_2_8(int xla) {
1128 jj_la = xla; jj_lastpos = jj_scanpos = token;
1129 try { return !jj_3_8(); }
1130 catch(LookaheadSuccess ls) { return true; }
1131 finally { jj_save(7, xla); }
1132 }
1133
1134 final private boolean jj_2_9(int xla) {
1135 jj_la = xla; jj_lastpos = jj_scanpos = token;
1136 try { return !jj_3_9(); }
1137 catch(LookaheadSuccess ls) { return true; }
1138 finally { jj_save(8, xla); }
1139 }
1140
1141 final private boolean jj_2_10(int xla) {
1142 jj_la = xla; jj_lastpos = jj_scanpos = token;
1143 try { return !jj_3_10(); }
1144 catch(LookaheadSuccess ls) { return true; }
1145 finally { jj_save(9, xla); }
1146 }
1147
1148 final private boolean jj_2_11(int xla) {
1149 jj_la = xla; jj_lastpos = jj_scanpos = token;
1150 try { return !jj_3_11(); }
1151 catch(LookaheadSuccess ls) { return true; }
1152 finally { jj_save(10, xla); }
1153 }
1154
1155 final private boolean jj_2_12(int xla) {
1156 jj_la = xla; jj_lastpos = jj_scanpos = token;
1157 try { return !jj_3_12(); }
1158 catch(LookaheadSuccess ls) { return true; }
1159 finally { jj_save(11, xla); }
1160 }
1161
1162 final private boolean jj_2_13(int xla) {
1163 jj_la = xla; jj_lastpos = jj_scanpos = token;
1164 try { return !jj_3_13(); }
1165 catch(LookaheadSuccess ls) { return true; }
1166 finally { jj_save(12, xla); }
1167 }
1168
1169 final private boolean jj_2_14(int xla) {
1170 jj_la = xla; jj_lastpos = jj_scanpos = token;
1171 try { return !jj_3_14(); }
1172 catch(LookaheadSuccess ls) { return true; }
1173 finally { jj_save(13, xla); }
1174 }
1175
1176 final private boolean jj_2_15(int xla) {
1177 jj_la = xla; jj_lastpos = jj_scanpos = token;
1178 try { return !jj_3_15(); }
1179 catch(LookaheadSuccess ls) { return true; }
1180 finally { jj_save(14, xla); }
1181 }
1182
1183 final private boolean jj_2_16(int xla) {
1184 jj_la = xla; jj_lastpos = jj_scanpos = token;
1185 try { return !jj_3_16(); }
1186 catch(LookaheadSuccess ls) { return true; }
1187 finally { jj_save(15, xla); }
1188 }
1189
1190 final private boolean jj_2_17(int xla) {
1191 jj_la = xla; jj_lastpos = jj_scanpos = token;
1192 try { return !jj_3_17(); }
1193 catch(LookaheadSuccess ls) { return true; }
1194 finally { jj_save(16, xla); }
1195 }
1196
1197 final private boolean jj_2_18(int xla) {
1198 jj_la = xla; jj_lastpos = jj_scanpos = token;
1199 try { return !jj_3_18(); }
1200 catch(LookaheadSuccess ls) { return true; }
1201 finally { jj_save(17, xla); }
1202 }
1203
1204 final private boolean jj_2_19(int xla) {
1205 jj_la = xla; jj_lastpos = jj_scanpos = token;
1206 try { return !jj_3_19(); }
1207 catch(LookaheadSuccess ls) { return true; }
1208 finally { jj_save(18, xla); }
1209 }
1210
1211 final private boolean jj_2_20(int xla) {
1212 jj_la = xla; jj_lastpos = jj_scanpos = token;
1213 try { return !jj_3_20(); }
1214 catch(LookaheadSuccess ls) { return true; }
1215 finally { jj_save(19, xla); }
1216 }
1217
1218 final private boolean jj_2_21(int xla) {
1219 jj_la = xla; jj_lastpos = jj_scanpos = token;
1220 try { return !jj_3_21(); }
1221 catch(LookaheadSuccess ls) { return true; }
1222 finally { jj_save(20, xla); }
1223 }
1224
1225 final private boolean jj_2_22(int xla) {
1226 jj_la = xla; jj_lastpos = jj_scanpos = token;
1227 try { return !jj_3_22(); }
1228 catch(LookaheadSuccess ls) { return true; }
1229 finally { jj_save(21, xla); }
1230 }
1231
1232 final private boolean jj_2_23(int xla) {
1233 jj_la = xla; jj_lastpos = jj_scanpos = token;
1234 try { return !jj_3_23(); }
1235 catch(LookaheadSuccess ls) { return true; }
1236 finally { jj_save(22, xla); }
1237 }
1238
1239 final private boolean jj_2_24(int xla) {
1240 jj_la = xla; jj_lastpos = jj_scanpos = token;
1241 try { return !jj_3_24(); }
1242 catch(LookaheadSuccess ls) { return true; }
1243 finally { jj_save(23, xla); }
1244 }
1245
1246 final private boolean jj_3R_28() {
1247 if (jj_scan_token(COMMA)) return true;
1248 if (jj_3R_27()) return true;
1249 return false;
1250 }
1251
1252 final private boolean jj_3R_45() {
1253 if (jj_scan_token(PRIVATE)) return true;
1254 return false;
1255 }
1256
1257 final private boolean jj_3_4() {
1258 if (jj_3R_10()) return true;
1259 return false;
1260 }
1261
1262 final private boolean jj_3_6() {
1263 if (jj_3R_11()) return true;
1264 return false;
1265 }
1266
1267 final private boolean jj_3R_8() {
1268 Token xsp;
1269 xsp = jj_scanpos;
1270 if (jj_3_6()) {
1271 jj_scanpos = xsp;
1272 if (jj_3_7()) {
1273 jj_scanpos = xsp;
1274 if (jj_3_8()) return true;
1275 }
1276 }
1277 if (jj_3R_32()) return true;
1278 while (true) {
1279 xsp = jj_scanpos;
1280 if (jj_3R_32()) { jj_scanpos = xsp; break; }
1281 }
1282 return false;
1283 }
1284
1285 final private boolean jj_3R_11() {
1286 if (jj_scan_token(NOT)) return true;
1287 Token xsp;
1288 xsp = jj_scanpos;
1289 if (jj_3_4()) {
1290 jj_scanpos = xsp;
1291 if (jj_3_5()) return true;
1292 }
1293 return false;
1294 }
1295
1296 final private boolean jj_3R_41() {
1297 if (jj_scan_token(NATIVE)) return true;
1298 return false;
1299 }
1300
1301 final private boolean jj_3R_60() {
1302 if (jj_scan_token(EXCEPTION_SEPERATOR)) return true;
1303 if (jj_3R_59()) return true;
1304 return false;
1305 }
1306
1307 final private boolean jj_3R_53() {
1308 if (jj_scan_token(FIELD_FINAL)) return true;
1309 return false;
1310 }
1311
1312 final private boolean jj_3R_9() {
1313 if (jj_scan_token(75)) return true;
1314 if (jj_3R_8()) return true;
1315 if (jj_scan_token(76)) return true;
1316 return false;
1317 }
1318
1319 final private boolean jj_3R_21() {
1320 if (jj_3R_27()) return true;
1321 Token xsp;
1322 while (true) {
1323 xsp = jj_scanpos;
1324 if (jj_3R_28()) { jj_scanpos = xsp; break; }
1325 }
1326 return false;
1327 }
1328
1329 final private boolean jj_3R_7() {
1330 Token xsp;
1331 xsp = jj_scanpos;
1332 if (jj_3_2()) {
1333 jj_scanpos = xsp;
1334 if (jj_3_3()) return true;
1335 }
1336 return false;
1337 }
1338
1339 final private boolean jj_3_2() {
1340 if (jj_3R_8()) return true;
1341 return false;
1342 }
1343
1344 final private boolean jj_3R_59() {
1345 Token xsp;
1346 xsp = jj_scanpos;
1347 if (jj_scan_token(40)) {
1348 jj_scanpos = xsp;
1349 if (jj_scan_token(43)) return true;
1350 }
1351 return false;
1352 }
1353
1354 final private boolean jj_3R_37() {
1355 if (jj_scan_token(PRIVATE)) return true;
1356 return false;
1357 }
1358
1359 final private boolean jj_3_1() {
1360 if (jj_3R_7()) return true;
1361 return false;
1362 }
1363
1364 final private boolean jj_3R_58() {
1365 if (jj_scan_token(THROWS)) return true;
1366 if (jj_3R_59()) return true;
1367 Token xsp;
1368 while (true) {
1369 xsp = jj_scanpos;
1370 if (jj_3R_60()) { jj_scanpos = xsp; break; }
1371 }
1372 return false;
1373 }
1374
1375 final private boolean jj_3_20() {
1376 if (jj_3R_17()) return true;
1377 return false;
1378 }
1379
1380 final private boolean jj_3R_57() {
1381 Token xsp;
1382 xsp = jj_scanpos;
1383 if (jj_3R_58()) jj_scanpos = xsp;
1384 return false;
1385 }
1386
1387 final private boolean jj_3_24() {
1388 if (jj_scan_token(PARAMS_OPEN)) return true;
1389 Token xsp;
1390 xsp = jj_scanpos;
1391 if (jj_3R_21()) jj_scanpos = xsp;
1392 if (jj_scan_token(PARAMS_CLOSE)) return true;
1393 return false;
1394 }
1395
1396 final private boolean jj_3R_12() {
1397 if (jj_scan_token(CLASS_EXPR)) return true;
1398 Token xsp;
1399 xsp = jj_scanpos;
1400 if (jj_scan_token(65)) {
1401 jj_scanpos = xsp;
1402 if (jj_scan_token(68)) {
1403 jj_scanpos = xsp;
1404 if (jj_scan_token(67)) {
1405 jj_scanpos = xsp;
1406 if (jj_scan_token(63)) {
1407 jj_scanpos = xsp;
1408 if (jj_scan_token(64)) return true;
1409 }
1410 }
1411 }
1412 }
1413 if (jj_scan_token(FIELD_CLOSE)) return true;
1414 return false;
1415 }
1416
1417 final private boolean jj_3R_49() {
1418 if (jj_scan_token(FIELD_PUBLIC)) return true;
1419 return false;
1420 }
1421
1422 final private boolean jj_3R_48() {
1423 if (jj_scan_token(FIELD_NOT)) return true;
1424 return false;
1425 }
1426
1427 final private boolean jj_3_19() {
1428 if (jj_3R_16()) return true;
1429 return false;
1430 }
1431
1432 final private boolean jj_3R_33() {
1433 Token xsp;
1434 xsp = jj_scanpos;
1435 if (jj_3R_48()) jj_scanpos = xsp;
1436 xsp = jj_scanpos;
1437 if (jj_3R_49()) {
1438 jj_scanpos = xsp;
1439 if (jj_3R_50()) {
1440 jj_scanpos = xsp;
1441 if (jj_3R_51()) {
1442 jj_scanpos = xsp;
1443 if (jj_3R_52()) {
1444 jj_scanpos = xsp;
1445 if (jj_3R_53()) {
1446 jj_scanpos = xsp;
1447 if (jj_3R_54()) return true;
1448 }
1449 }
1450 }
1451 }
1452 }
1453 return false;
1454 }
1455
1456 final private boolean jj_3R_44() {
1457 if (jj_scan_token(PROTECTED)) return true;
1458 return false;
1459 }
1460
1461 final private boolean jj_3R_40() {
1462 if (jj_scan_token(FINAL)) return true;
1463 return false;
1464 }
1465
1466 final private boolean jj_3R_52() {
1467 if (jj_scan_token(FIELD_STATIC)) return true;
1468 return false;
1469 }
1470
1471 final private boolean jj_3R_29() {
1472 if (jj_3R_33()) return true;
1473 return false;
1474 }
1475
1476 final private boolean jj_3R_23() {
1477 Token xsp;
1478 while (true) {
1479 xsp = jj_scanpos;
1480 if (jj_3R_29()) { jj_scanpos = xsp; break; }
1481 }
1482 xsp = jj_scanpos;
1483 if (jj_scan_token(65)) {
1484 jj_scanpos = xsp;
1485 if (jj_scan_token(68)) {
1486 jj_scanpos = xsp;
1487 if (jj_scan_token(67)) {
1488 jj_scanpos = xsp;
1489 if (jj_scan_token(66)) {
1490 jj_scanpos = xsp;
1491 if (jj_scan_token(63)) {
1492 jj_scanpos = xsp;
1493 if (jj_scan_token(64)) return true;
1494 }
1495 }
1496 }
1497 }
1498 }
1499 xsp = jj_scanpos;
1500 if (jj_scan_token(65)) {
1501 jj_scanpos = xsp;
1502 if (jj_scan_token(68)) {
1503 jj_scanpos = xsp;
1504 if (jj_scan_token(67)) {
1505 jj_scanpos = xsp;
1506 if (jj_scan_token(63)) {
1507 jj_scanpos = xsp;
1508 if (jj_scan_token(64)) return true;
1509 }
1510 }
1511 }
1512 }
1513 if (jj_scan_token(FIELD_SEPARATOR)) return true;
1514 xsp = jj_scanpos;
1515 if (jj_scan_token(68)) {
1516 jj_scanpos = xsp;
1517 if (jj_scan_token(67)) return true;
1518 }
1519 return false;
1520 }
1521
1522 final private boolean jj_3R_36() {
1523 if (jj_scan_token(PROTECTED)) return true;
1524 return false;
1525 }
1526
1527 final private boolean jj_3R_20() {
1528 if (jj_scan_token(ALL_PARAMS)) return true;
1529 return false;
1530 }
1531
1532 final private boolean jj_3_18() {
1533 if (jj_3R_15()) return true;
1534 return false;
1535 }
1536
1537 final private boolean jj_3R_47() {
1538 if (jj_3R_56()) return true;
1539 return false;
1540 }
1541
1542 final private boolean jj_3R_27() {
1543 Token xsp;
1544 xsp = jj_scanpos;
1545 if (jj_scan_token(14)) {
1546 jj_scanpos = xsp;
1547 if (jj_scan_token(17)) {
1548 jj_scanpos = xsp;
1549 if (jj_scan_token(20)) {
1550 jj_scanpos = xsp;
1551 if (jj_scan_token(18)) {
1552 jj_scanpos = xsp;
1553 if (jj_scan_token(19)) {
1554 jj_scanpos = xsp;
1555 if (jj_scan_token(16)) {
1556 jj_scanpos = xsp;
1557 if (jj_scan_token(15)) return true;
1558 }
1559 }
1560 }
1561 }
1562 }
1563 }
1564 return false;
1565 }
1566
1567 final private boolean jj_3_23() {
1568 if (jj_scan_token(PARAMS_OPEN)) return true;
1569 if (jj_3R_20()) return true;
1570 if (jj_scan_token(PARAMS_CLOSE)) return true;
1571 return false;
1572 }
1573
1574 final private boolean jj_3R_26() {
1575 Token xsp;
1576 xsp = jj_scanpos;
1577 if (jj_3_23()) {
1578 jj_scanpos = xsp;
1579 if (jj_3_24()) return true;
1580 }
1581 return false;
1582 }
1583
1584 final private boolean jj_3R_32() {
1585 Token xsp;
1586 xsp = jj_scanpos;
1587 if (jj_3R_46()) {
1588 jj_scanpos = xsp;
1589 if (jj_3R_47()) return true;
1590 }
1591 return false;
1592 }
1593
1594 final private boolean jj_3R_46() {
1595 if (jj_3R_55()) return true;
1596 return false;
1597 }
1598
1599 final private boolean jj_3_14() {
1600 if (jj_3R_11()) return true;
1601 return false;
1602 }
1603
1604 final private boolean jj_3R_31() {
1605 Token xsp;
1606 xsp = jj_scanpos;
1607 if (jj_3R_43()) {
1608 jj_scanpos = xsp;
1609 if (jj_3R_44()) {
1610 jj_scanpos = xsp;
1611 if (jj_3R_45()) return true;
1612 }
1613 }
1614 return false;
1615 }
1616
1617 final private boolean jj_3R_43() {
1618 if (jj_scan_token(PUBLIC)) return true;
1619 return false;
1620 }
1621
1622 final private boolean jj_3_11() {
1623 if (jj_3R_11()) return true;
1624 return false;
1625 }
1626
1627 final private boolean jj_3R_39() {
1628 if (jj_scan_token(ABSTRACT)) return true;
1629 return false;
1630 }
1631
1632 final private boolean jj_3_17() {
1633 if (jj_3R_14()) return true;
1634 return false;
1635 }
1636
1637 final private boolean jj_3R_25() {
1638 if (jj_3R_31()) return true;
1639 return false;
1640 }
1641
1642 final private boolean jj_3R_19() {
1643 Token xsp;
1644 while (true) {
1645 xsp = jj_scanpos;
1646 if (jj_3R_25()) { jj_scanpos = xsp; break; }
1647 }
1648 xsp = jj_scanpos;
1649 if (jj_scan_token(40)) {
1650 jj_scanpos = xsp;
1651 if (jj_scan_token(43)) {
1652 jj_scanpos = xsp;
1653 if (jj_scan_token(42)) {
1654 jj_scanpos = xsp;
1655 if (jj_scan_token(38)) {
1656 jj_scanpos = xsp;
1657 if (jj_scan_token(39)) return true;
1658 }
1659 }
1660 }
1661 }
1662 if (jj_scan_token(SEPARATOR)) return true;
1663 xsp = jj_scanpos;
1664 if (jj_scan_token(36)) {
1665 jj_scanpos = xsp;
1666 if (jj_scan_token(42)) return true;
1667 }
1668 if (jj_3R_26()) return true;
1669 if (jj_3R_57()) return true;
1670 return false;
1671 }
1672
1673 final private boolean jj_3R_51() {
1674 if (jj_scan_token(FIELD_PRIVATE)) return true;
1675 return false;
1676 }
1677
1678 final private boolean jj_3R_35() {
1679 if (jj_scan_token(PUBLIC)) return true;
1680 return false;
1681 }
1682
1683 final private boolean jj_3R_34() {
1684 if (jj_scan_token(BEHAVIOR_NOT)) return true;
1685 return false;
1686 }
1687
1688 final private boolean jj_3R_30() {
1689 Token xsp;
1690 xsp = jj_scanpos;
1691 if (jj_3R_34()) jj_scanpos = xsp;
1692 xsp = jj_scanpos;
1693 if (jj_3R_35()) {
1694 jj_scanpos = xsp;
1695 if (jj_3R_36()) {
1696 jj_scanpos = xsp;
1697 if (jj_3R_37()) {
1698 jj_scanpos = xsp;
1699 if (jj_3R_38()) {
1700 jj_scanpos = xsp;
1701 if (jj_3R_39()) {
1702 jj_scanpos = xsp;
1703 if (jj_3R_40()) {
1704 jj_scanpos = xsp;
1705 if (jj_3R_41()) {
1706 jj_scanpos = xsp;
1707 if (jj_3R_42()) return true;
1708 }
1709 }
1710 }
1711 }
1712 }
1713 }
1714 }
1715 return false;
1716 }
1717
1718 final private boolean jj_3_8() {
1719 if (jj_3R_9()) return true;
1720 return false;
1721 }
1722
1723 final private boolean jj_3_22() {
1724 if (jj_3R_19()) return true;
1725 return false;
1726 }
1727
1728 final private boolean jj_3R_24() {
1729 if (jj_3R_30()) return true;
1730 return false;
1731 }
1732
1733 final private boolean jj_3R_18() {
1734 Token xsp;
1735 while (true) {
1736 xsp = jj_scanpos;
1737 if (jj_3R_24()) { jj_scanpos = xsp; break; }
1738 }
1739 xsp = jj_scanpos;
1740 if (jj_scan_token(40)) {
1741 jj_scanpos = xsp;
1742 if (jj_scan_token(43)) {
1743 jj_scanpos = xsp;
1744 if (jj_scan_token(42)) {
1745 jj_scanpos = xsp;
1746 if (jj_scan_token(41)) {
1747 jj_scanpos = xsp;
1748 if (jj_scan_token(38)) {
1749 jj_scanpos = xsp;
1750 if (jj_scan_token(39)) return true;
1751 }
1752 }
1753 }
1754 }
1755 }
1756 xsp = jj_scanpos;
1757 if (jj_scan_token(40)) {
1758 jj_scanpos = xsp;
1759 if (jj_scan_token(43)) {
1760 jj_scanpos = xsp;
1761 if (jj_scan_token(42)) {
1762 jj_scanpos = xsp;
1763 if (jj_scan_token(38)) {
1764 jj_scanpos = xsp;
1765 if (jj_scan_token(39)) return true;
1766 }
1767 }
1768 }
1769 }
1770 if (jj_scan_token(SEPARATOR)) return true;
1771 xsp = jj_scanpos;
1772 if (jj_scan_token(43)) {
1773 jj_scanpos = xsp;
1774 if (jj_scan_token(42)) return true;
1775 }
1776 if (jj_3R_26()) return true;
1777 if (jj_3R_57()) return true;
1778 return false;
1779 }
1780
1781 final private boolean jj_3_13() {
1782 if (jj_3R_9()) return true;
1783 return false;
1784 }
1785
1786 final private boolean jj_3R_54() {
1787 if (jj_scan_token(FIELD_TRANSIENT)) return true;
1788 return false;
1789 }
1790
1791 final private boolean jj_3_10() {
1792 if (jj_3R_9()) return true;
1793 return false;
1794 }
1795
1796 final private boolean jj_3R_15() {
1797 if (jj_scan_token(CONSTRUCTOR_EXPR)) return true;
1798 if (jj_3R_19()) return true;
1799 if (jj_scan_token(BEHAVIOR_CLOSE)) return true;
1800 return false;
1801 }
1802
1803 final private boolean jj_3_16() {
1804 if (jj_3R_13()) return true;
1805 return false;
1806 }
1807
1808 final private boolean jj_3R_42() {
1809 if (jj_scan_token(SYNCHRONIZED)) return true;
1810 return false;
1811 }
1812
1813 final private boolean jj_3R_13() {
1814 if (jj_scan_token(METHOD_EXPR)) return true;
1815 if (jj_3R_18()) return true;
1816 if (jj_scan_token(BEHAVIOR_CLOSE)) return true;
1817 return false;
1818 }
1819
1820 final private boolean jj_3_5() {
1821 if (jj_3R_9()) return true;
1822 return false;
1823 }
1824
1825 final private boolean jj_3R_14() {
1826 if (jj_scan_token(FIELD)) return true;
1827 if (jj_3R_23()) return true;
1828 if (jj_scan_token(FIELD_CLOSE)) return true;
1829 return false;
1830 }
1831
1832 final private boolean jj_3R_38() {
1833 if (jj_scan_token(STATIC)) return true;
1834 return false;
1835 }
1836
1837 final private boolean jj_3_21() {
1838 if (jj_3R_18()) return true;
1839 return false;
1840 }
1841
1842 final private boolean jj_3R_17() {
1843 if (jj_scan_token(HAS_FIELD)) return true;
1844 if (jj_3R_23()) return true;
1845 if (jj_scan_token(FIELD_CLOSE)) return true;
1846 return false;
1847 }
1848
1849 final private boolean jj_3R_16() {
1850 if (jj_scan_token(HAS)) return true;
1851 Token xsp;
1852 xsp = jj_scanpos;
1853 if (jj_3_21()) {
1854 jj_scanpos = xsp;
1855 if (jj_3_22()) return true;
1856 }
1857 if (jj_scan_token(BEHAVIOR_CLOSE)) return true;
1858 return false;
1859 }
1860
1861 final private boolean jj_3_7() {
1862 if (jj_3R_10()) return true;
1863 return false;
1864 }
1865
1866 final private boolean jj_3_15() {
1867 if (jj_3R_12()) return true;
1868 return false;
1869 }
1870
1871 final private boolean jj_3R_22() {
1872 Token xsp;
1873 xsp = jj_scanpos;
1874 if (jj_3_15()) {
1875 jj_scanpos = xsp;
1876 if (jj_3_16()) {
1877 jj_scanpos = xsp;
1878 if (jj_3_17()) {
1879 jj_scanpos = xsp;
1880 if (jj_3_18()) {
1881 jj_scanpos = xsp;
1882 if (jj_3_19()) {
1883 jj_scanpos = xsp;
1884 if (jj_3_20()) return true;
1885 }
1886 }
1887 }
1888 }
1889 }
1890 return false;
1891 }
1892
1893 final private boolean jj_3_3() {
1894 if (jj_3R_9()) return true;
1895 return false;
1896 }
1897
1898 final private boolean jj_3_12() {
1899 if (jj_3R_10()) return true;
1900 return false;
1901 }
1902
1903 final private boolean jj_3R_10() {
1904 if (jj_3R_22()) return true;
1905 return false;
1906 }
1907
1908 final private boolean jj_3_9() {
1909 if (jj_3R_10()) return true;
1910 return false;
1911 }
1912
1913 final private boolean jj_3R_56() {
1914 if (jj_scan_token(OR)) return true;
1915 Token xsp;
1916 xsp = jj_scanpos;
1917 if (jj_3_12()) {
1918 jj_scanpos = xsp;
1919 if (jj_3_13()) {
1920 jj_scanpos = xsp;
1921 if (jj_3_14()) return true;
1922 }
1923 }
1924 return false;
1925 }
1926
1927 final private boolean jj_3R_50() {
1928 if (jj_scan_token(FIELD_PROTECTED)) return true;
1929 return false;
1930 }
1931
1932 final private boolean jj_3R_55() {
1933 if (jj_scan_token(AND)) return true;
1934 Token xsp;
1935 xsp = jj_scanpos;
1936 if (jj_3_9()) {
1937 jj_scanpos = xsp;
1938 if (jj_3_10()) {
1939 jj_scanpos = xsp;
1940 if (jj_3_11()) return true;
1941 }
1942 }
1943 return false;
1944 }
1945
1946 public TypeExpressionParserTokenManager token_source;
1947 SimpleCharStream jj_input_stream;
1948 public Token token, jj_nt;
1949 private int jj_ntk;
1950 private Token jj_scanpos, jj_lastpos;
1951 private int jj_la;
1952 public boolean lookingAhead = false;
1953 private boolean jj_semLA;
1954 private int jj_gen;
1955 final private int[] jj_la1 = new int[26];
1956 static private int[] jj_la1_0;
1957 static private int[] jj_la1_1;
1958 static private int[] jj_la1_2;
1959 static {
1960 jj_la1_0();
1961 jj_la1_1();
1962 jj_la1_2();
1963 }
1964 private static void jj_la1_0() {
1965 jj_la1_0 = new int[] {0xfe0,0x18,0x18,0xf0000000,0x0,0x0,0x0,0x0,0xf0000000,0xc0000000,0x0,0x0,0xc0000000,0x200000,0x1fc000,0x1fc000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
1966 }
1967 private static void jj_la1_1() {
1968 jj_la1_1 = new int[] {0x0,0x0,0x0,0x2000f,0xfc0,0xdc0,0xc00,0x20000,0xf,0x1,0xdc0,0x410,0x1,0x0,0x0,0x0,0x1f800000,0x80000000,0x80000000,0x0,0x0,0x1f800000,0x80000000,0x4000,0x20,0x900,};
1969 }
1970 private static void jj_la1_2() {
1971 jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x1f,0x1b,0x18,0x200,0x0,0x1b,0x0,0x0,0x0,};
1972 }
1973 final private JJCalls[] jj_2_rtns = new JJCalls[24];
1974 private boolean jj_rescan = false;
1975 private int jj_gc = 0;
1976
1977 public TypeExpressionParser(java.io.InputStream stream) {
1978 jj_input_stream = new SimpleCharStream(stream, 1, 1);
1979 token_source = new TypeExpressionParserTokenManager(jj_input_stream);
1980 token = new Token();
1981 jj_ntk = -1;
1982 jj_gen = 0;
1983 for (int i = 0; i < 26; i++) jj_la1[i] = -1;
1984 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1985 }
1986
1987 public void ReInit(java.io.InputStream stream) {
1988 jj_input_stream.ReInit(stream, 1, 1);
1989 token_source.ReInit(jj_input_stream);
1990 token = new Token();
1991 jj_ntk = -1;
1992 jjtree.reset();
1993 jj_gen = 0;
1994 for (int i = 0; i < 26; i++) jj_la1[i] = -1;
1995 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1996 }
1997
1998 public TypeExpressionParser(java.io.Reader stream) {
1999 jj_input_stream = new SimpleCharStream(stream, 1, 1);
2000 token_source = new TypeExpressionParserTokenManager(jj_input_stream);
2001 token = new Token();
2002 jj_ntk = -1;
2003 jj_gen = 0;
2004 for (int i = 0; i < 26; i++) jj_la1[i] = -1;
2005 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2006 }
2007
2008 public void ReInit(java.io.Reader stream) {
2009 jj_input_stream.ReInit(stream, 1, 1);
2010 token_source.ReInit(jj_input_stream);
2011 token = new Token();
2012 jj_ntk = -1;
2013 jjtree.reset();
2014 jj_gen = 0;
2015 for (int i = 0; i < 26; i++) jj_la1[i] = -1;
2016 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2017 }
2018
2019 public TypeExpressionParser(TypeExpressionParserTokenManager tm) {
2020 token_source = tm;
2021 token = new Token();
2022 jj_ntk = -1;
2023 jj_gen = 0;
2024 for (int i = 0; i < 26; i++) jj_la1[i] = -1;
2025 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2026 }
2027
2028 public void ReInit(TypeExpressionParserTokenManager tm) {
2029 token_source = tm;
2030 token = new Token();
2031 jj_ntk = -1;
2032 jjtree.reset();
2033 jj_gen = 0;
2034 for (int i = 0; i < 26; i++) jj_la1[i] = -1;
2035 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
2036 }
2037
2038 final private Token jj_consume_token(int kind) throws ParseException {
2039 Token oldToken;
2040 if ((oldToken = token).next != null) token = token.next;
2041 else token = token.next = token_source.getNextToken();
2042 jj_ntk = -1;
2043 if (token.kind == kind) {
2044 jj_gen++;
2045 if (++jj_gc > 100) {
2046 jj_gc = 0;
2047 for (int i = 0; i < jj_2_rtns.length; i++) {
2048 JJCalls c = jj_2_rtns[i];
2049 while (c != null) {
2050 if (c.gen < jj_gen) c.first = null;
2051 c = c.next;
2052 }
2053 }
2054 }
2055 return token;
2056 }
2057 token = oldToken;
2058 jj_kind = kind;
2059 throw generateParseException();
2060 }
2061
2062 static private final class LookaheadSuccess extends java.lang.Error { }
2063 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
2064 final private boolean jj_scan_token(int kind) {
2065 if (jj_scanpos == jj_lastpos) {
2066 jj_la--;
2067 if (jj_scanpos.next == null) {
2068 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
2069 } else {
2070 jj_lastpos = jj_scanpos = jj_scanpos.next;
2071 }
2072 } else {
2073 jj_scanpos = jj_scanpos.next;
2074 }
2075 if (jj_rescan) {
2076 int i = 0; Token tok = token;
2077 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
2078 if (tok != null) jj_add_error_token(kind, i);
2079 }
2080 if (jj_scanpos.kind != kind) return true;
2081 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
2082 return false;
2083 }
2084
2085 final public Token getNextToken() {
2086 if (token.next != null) token = token.next;
2087 else token = token.next = token_source.getNextToken();
2088 jj_ntk = -1;
2089 jj_gen++;
2090 return token;
2091 }
2092
2093 final public Token getToken(int index) {
2094 Token t = lookingAhead ? jj_scanpos : token;
2095 for (int i = 0; i < index; i++) {
2096 if (t.next != null) t = t.next;
2097 else t = t.next = token_source.getNextToken();
2098 }
2099 return t;
2100 }
2101
2102 final private int jj_ntk() {
2103 if ((jj_nt=token.next) == null)
2104 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
2105 else
2106 return (jj_ntk = jj_nt.kind);
2107 }
2108
2109 private java.util.Vector jj_expentries = new java.util.Vector ();
2110 private int[] jj_expentry;
2111 private int jj_kind = -1;
2112 private int[] jj_lasttokens = new int[100];
2113 private int jj_endpos;
2114
2115 private void jj_add_error_token(int kind, int pos) {
2116 if (pos >= 100) return;
2117 if (pos == jj_endpos + 1) {
2118 jj_lasttokens[jj_endpos++] = kind;
2119 } else if (jj_endpos != 0) {
2120 jj_expentry = new int[jj_endpos];
2121 for (int i = 0; i < jj_endpos; i++) {
2122 jj_expentry[i] = jj_lasttokens[i];
2123 }
2124 boolean exists = false;
2125 for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
2126 int[] oldentry = (int[])(e.nextElement());
2127 if (oldentry.length == jj_expentry.length) {
2128 exists = true;
2129 for (int i = 0; i < jj_expentry.length; i++) {
2130 if (oldentry[i] != jj_expentry[i]) {
2131 exists = false;
2132 break;
2133 }
2134 }
2135 if (exists) break;
2136 }
2137 }
2138 if (!exists) jj_expentries.addElement(jj_expentry);
2139 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
2140 }
2141 }
2142
2143 public ParseException generateParseException() {
2144 jj_expentries.removeAllElements();
2145 boolean[] la1tokens = new boolean[77];
2146 for (int i = 0; i < 77; i++) {
2147 la1tokens[i] = false;
2148 }
2149 if (jj_kind >= 0) {
2150 la1tokens[jj_kind] = true;
2151 jj_kind = -1;
2152 }
2153 for (int i = 0; i < 26; i++) {
2154 if (jj_la1[i] == jj_gen) {
2155 for (int j = 0; j < 32; j++) {
2156 if ((jj_la1_0[i] & (1<<j)) != 0) {
2157 la1tokens[j] = true;
2158 }
2159 if ((jj_la1_1[i] & (1<<j)) != 0) {
2160 la1tokens[32+j] = true;
2161 }
2162 if ((jj_la1_2[i] & (1<<j)) != 0) {
2163 la1tokens[64+j] = true;
2164 }
2165 }
2166 }
2167 }
2168 for (int i = 0; i < 77; i++) {
2169 if (la1tokens[i]) {
2170 jj_expentry = new int[1];
2171 jj_expentry[0] = i;
2172 jj_expentries.addElement(jj_expentry);
2173 }
2174 }
2175 jj_endpos = 0;
2176 jj_rescan_token();
2177 jj_add_error_token(0, 0);
2178 int[][] exptokseq = new int[jj_expentries.size()][];
2179 for (int i = 0; i < jj_expentries.size(); i++) {
2180 exptokseq[i] = (int[])jj_expentries.elementAt(i);
2181 }
2182 return new ParseException(token, exptokseq, tokenImage);
2183 }
2184
2185 final public void enable_tracing() {
2186 }
2187
2188 final public void disable_tracing() {
2189 }
2190
2191 final private void jj_rescan_token() {
2192 jj_rescan = true;
2193 for (int i = 0; i < 24; i++) {
2194 JJCalls p = jj_2_rtns[i];
2195 do {
2196 if (p.gen > jj_gen) {
2197 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
2198 switch (i) {
2199 case 0: jj_3_1(); break;
2200 case 1: jj_3_2(); break;
2201 case 2: jj_3_3(); break;
2202 case 3: jj_3_4(); break;
2203 case 4: jj_3_5(); break;
2204 case 5: jj_3_6(); break;
2205 case 6: jj_3_7(); break;
2206 case 7: jj_3_8(); break;
2207 case 8: jj_3_9(); break;
2208 case 9: jj_3_10(); break;
2209 case 10: jj_3_11(); break;
2210 case 11: jj_3_12(); break;
2211 case 12: jj_3_13(); break;
2212 case 13: jj_3_14(); break;
2213 case 14: jj_3_15(); break;
2214 case 15: jj_3_16(); break;
2215 case 16: jj_3_17(); break;
2216 case 17: jj_3_18(); break;
2217 case 18: jj_3_19(); break;
2218 case 19: jj_3_20(); break;
2219 case 20: jj_3_21(); break;
2220 case 21: jj_3_22(); break;
2221 case 22: jj_3_23(); break;
2222 case 23: jj_3_24(); break;
2223 }
2224 }
2225 p = p.next;
2226 } while (p != null);
2227 }
2228 jj_rescan = false;
2229 }
2230
2231 final private void jj_save(int index, int xla) {
2232 JJCalls p = jj_2_rtns[index];
2233 while (p.gen > jj_gen) {
2234 if (p.next == null) { p = p.next = new JJCalls(); break; }
2235 p = p.next;
2236 }
2237 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
2238 }
2239
2240 static final class JJCalls {
2241 int gen;
2242 Token first;
2243 int arg;
2244 JJCalls next;
2245 }
2246
2247}
2248 |
Popular Tags |
Java API By Example, From Geeks To Geeks.