|
1
2
9 package org.codehaus.aspectwerkz.annotation.expression.ast;
10
11 import java.lang.reflect.Modifier  ;
12 import java.io.Reader ;
13 import java.io.StringReader ;
14
15
20 public class AnnotationParserimplements AnnotationParserTreeConstants, AnnotationParserConstants {
21 protected static JJTAnnotationParserState jjtree = new JJTAnnotationParserState();
22 public ASTRoot parse(String annotation) throws ParseException {
23 return parse(new StringReader (annotation));
24 }
25
26 public ASTRoot parse(Reader reader) throws ParseException {
27 ReInit(reader);
28 return Root();
29 }
30
31
34 static final public ASTRoot Root() throws ParseException {
35
36 ASTRoot jjtn000 = new ASTRoot(JJTROOT);
37 boolean jjtc000 = true;
38 jjtree.openNodeScope(jjtn000);
39 try {
40 Annotation();
41 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
42 case 0:
43 jj_consume_token(0);
44 break;
45 case 26:
46 jj_consume_token(26);
47 break;
48 case NEWLINE:
49 jj_consume_token(NEWLINE);
50 break;
51 default:
52 jj_la1[0] = jj_gen;
53 jj_consume_token(-1);
54 throw new ParseException();
55 }
56 jjtree.closeNodeScope(jjtn000, true);
57 jjtc000 = false;
58 {if (true) return jjtn000;}
59 } catch (Throwable jjte000) {
60 if (jjtc000) {
61 jjtree.clearNodeScope(jjtn000);
62 jjtc000 = false;
63 } else {
64 jjtree.popNode();
65 }
66 if (jjte000 instanceof RuntimeException ) {
67 {if (true) throw (RuntimeException )jjte000;}
68 }
69 if (jjte000 instanceof ParseException) {
70 {if (true) throw (ParseException)jjte000;}
71 }
72 {if (true) throw (Error )jjte000;}
73 } finally {
74 if (jjtc000) {
75 jjtree.closeNodeScope(jjtn000, true);
76 }
77 }
78 throw new Error ("Missing return statement in function");
79 }
80
81
84 static final public void Annotation() throws ParseException {
85
86 ASTAnnotation jjtn000 = new ASTAnnotation(JJTANNOTATION);
87 boolean jjtc000 = true;
88 jjtree.openNodeScope(jjtn000);
89 try {
90 if (jj_2_2(3)) {
91 jj_consume_token(ANNOTATION);
92 jj_consume_token(LEFT_PARENTHEZIS);
93 if (jj_2_1(4)) {
94 KeyValuePairList();
95 } else {
96 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
97 case INTEGER:
98 case HEXNUMBER:
99 case OCTNUMBER:
100 case FLOAT:
101 case BOOLEAN:
102 case STRING:
103 case CHAR:
104 case LEFT_BRACKET:
105 case ANNOTATION:
106 case JAVA_TYPE_MAYBEARRAY:
107 Value();
108 break;
109 default:
110 jj_la1[1] = jj_gen;
111 jj_consume_token(-1);
112 throw new ParseException();
113 }
114 }
115 jj_consume_token(RIGHT_PARENTHEZIS);
116 } else if (jj_2_3(2)) {
117 jj_consume_token(ANNOTATION);
118 jj_consume_token(LEFT_PARENTHEZIS);
119 jj_consume_token(RIGHT_PARENTHEZIS);
120 } else {
121 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
122 case ANNOTATION:
123 jj_consume_token(ANNOTATION);
124 break;
125 default:
126 jj_la1[2] = jj_gen;
127 jj_consume_token(-1);
128 throw new ParseException();
129 }
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
155 static final public void KeyValuePairList() throws ParseException {
156 KeyValuePair();
157 label_1:
158 while (true) {
159 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
160 case COMMA:
161 ;
162 break;
163 default:
164 jj_la1[3] = jj_gen;
165 break label_1;
166 }
167 jj_consume_token(COMMA);
168 KeyValuePair();
169 }
170 }
171
172
175 static final public void KeyValuePair() throws ParseException {
176
177 ASTKeyValuePair jjtn000 = new ASTKeyValuePair(JJTKEYVALUEPAIR);
178 boolean jjtc000 = true;
179 jjtree.openNodeScope(jjtn000);Token key, value;
180 try {
181 key = jj_consume_token(JAVA_NAME);
182 jjtn000.setKey(key.image);
183 jj_consume_token(EQUALS);
184 Value();
185 } catch (Throwable jjte000) {
186 if (jjtc000) {
187 jjtree.clearNodeScope(jjtn000);
188 jjtc000 = false;
189 } else {
190 jjtree.popNode();
191 }
192 if (jjte000 instanceof RuntimeException ) {
193 {if (true) throw (RuntimeException )jjte000;}
194 }
195 if (jjte000 instanceof ParseException) {
196 {if (true) throw (ParseException)jjte000;}
197 }
198 {if (true) throw (Error )jjte000;}
199 } finally {
200 if (jjtc000) {
201 jjtree.closeNodeScope(jjtn000, true);
202 }
203 }
204 }
205
206
211 static final public void Value() throws ParseException {
212 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
213 case ANNOTATION:
214 Annotation();
215 break;
216 case CHAR:
217 Char();
218 break;
219 case STRING:
220 String();
221 break;
222 case LEFT_BRACKET:
223 Array();
224 break;
225 case JAVA_TYPE_MAYBEARRAY:
226 Identifier();
227 break;
228 case BOOLEAN:
229 Boolean();
230 break;
231 case INTEGER:
232 Integer();
233 break;
234 case FLOAT:
235 Float();
236 break;
237 case HEXNUMBER:
238 Hex();
239 break;
240 case OCTNUMBER:
241 Oct();
242 break;
243 default:
244 jj_la1[4] = jj_gen;
245 jj_consume_token(-1);
246 throw new ParseException();
247 }
248 }
249
250
253 static final public void Identifier() throws ParseException {
254
255 ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER);
256 boolean jjtc000 = true;
257 jjtree.openNodeScope(jjtn000);Token value;
258 try {
259 value = jj_consume_token(JAVA_TYPE_MAYBEARRAY);
260 jjtree.closeNodeScope(jjtn000, true);
261 jjtc000 = false;
262 jjtn000.setValue(value.image);
263 } finally {
264 if (jjtc000) {
265 jjtree.closeNodeScope(jjtn000, true);
266 }
267 }
268 }
269
270
273 static final public void Boolean() throws ParseException {
274
275 ASTBoolean jjtn000 = new ASTBoolean(JJTBOOLEAN);
276 boolean jjtc000 = true;
277 jjtree.openNodeScope(jjtn000);Token value;
278 try {
279 value = jj_consume_token(BOOLEAN);
280 jjtree.closeNodeScope(jjtn000, true);
281 jjtc000 = false;
282 jjtn000.setValue(value.image);
283 } finally {
284 if (jjtc000) {
285 jjtree.closeNodeScope(jjtn000, true);
286 }
287 }
288 }
289
290
293 static final public void Char() throws ParseException {
294
295 ASTChar jjtn000 = new ASTChar(JJTCHAR);
296 boolean jjtc000 = true;
297 jjtree.openNodeScope(jjtn000);Token value;
298 try {
299 value = jj_consume_token(CHAR);
300 jjtree.closeNodeScope(jjtn000, true);
301 jjtc000 = false;
302 jjtn000.setValue(value.image);
303 } finally {
304 if (jjtc000) {
305 jjtree.closeNodeScope(jjtn000, true);
306 }
307 }
308 }
309
310
313 static final public void String() throws ParseException {
314
315 ASTString jjtn000 = new ASTString(JJTSTRING);
316 boolean jjtc000 = true;
317 jjtree.openNodeScope(jjtn000);Token value;
318 try {
319 value = jj_consume_token(STRING);
320 jjtree.closeNodeScope(jjtn000, true);
321 jjtc000 = false;
322 jjtn000.setValue(value.image);
323 } finally {
324 if (jjtc000) {
325 jjtree.closeNodeScope(jjtn000, true);
326 }
327 }
328 }
329
330
333 static final public void Array() throws ParseException {
334
335 ASTArray jjtn000 = new ASTArray(JJTARRAY);
336 boolean jjtc000 = true;
337 jjtree.openNodeScope(jjtn000);
338 try {
339 jj_consume_token(LEFT_BRACKET);
340 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
341 case INTEGER:
342 case HEXNUMBER:
343 case OCTNUMBER:
344 case FLOAT:
345 case BOOLEAN:
346 case STRING:
347 case CHAR:
348 case LEFT_BRACKET:
349 case ANNOTATION:
350 case JAVA_TYPE_MAYBEARRAY:
351 Value();
352 label_2:
353 while (true) {
354 if (jj_2_4(2)) {
355 ;
356 } else {
357 break label_2;
358 }
359 jj_consume_token(COMMA);
360 Value();
361 }
362 break;
363 default:
364 jj_la1[5] = jj_gen;
365 ;
366 }
367 jj_consume_token(RIGHT_BRACKET);
368 } catch (Throwable jjte000) {
369 if (jjtc000) {
370 jjtree.clearNodeScope(jjtn000);
371 jjtc000 = false;
372 } else {
373 jjtree.popNode();
374 }
375 if (jjte000 instanceof RuntimeException ) {
376 {if (true) throw (RuntimeException )jjte000;}
377 }
378 if (jjte000 instanceof ParseException) {
379 {if (true) throw (ParseException)jjte000;}
380 }
381 {if (true) throw (Error )jjte000;}
382 } finally {
383 if (jjtc000) {
384 jjtree.closeNodeScope(jjtn000, true);
385 }
386 }
387 }
388
389
392 static final public void Integer() throws ParseException {
393
394 ASTInteger jjtn000 = new ASTInteger(JJTINTEGER);
395 boolean jjtc000 = true;
396 jjtree.openNodeScope(jjtn000);Token value;
397 try {
398 value = jj_consume_token(INTEGER);
399 jjtree.closeNodeScope(jjtn000, true);
400 jjtc000 = false;
401 jjtn000.setValue(value.image);
402 } finally {
403 if (jjtc000) {
404 jjtree.closeNodeScope(jjtn000, true);
405 }
406 }
407 }
408
409
412 static final public void Float() throws ParseException {
413
414 ASTFloat jjtn000 = new ASTFloat(JJTFLOAT);
415 boolean jjtc000 = true;
416 jjtree.openNodeScope(jjtn000);Token value;
417 try {
418 value = jj_consume_token(FLOAT);
419 jjtree.closeNodeScope(jjtn000, true);
420 jjtc000 = false;
421 jjtn000.setValue(value.image);
422 } finally {
423 if (jjtc000) {
424 jjtree.closeNodeScope(jjtn000, true);
425 }
426 }
427 }
428
429
432 static final public void Hex() throws ParseException {
433
434 ASTHex jjtn000 = new ASTHex(JJTHEX);
435 boolean jjtc000 = true;
436 jjtree.openNodeScope(jjtn000);Token value;
437 try {
438 value = jj_consume_token(HEXNUMBER);
439 jjtree.closeNodeScope(jjtn000, true);
440 jjtc000 = false;
441 jjtn000.setValue(value.image);
442 } finally {
443 if (jjtc000) {
444 jjtree.closeNodeScope(jjtn000, true);
445 }
446 }
447 }
448
449
452 static final public void Oct() throws ParseException {
453
454 ASTOct jjtn000 = new ASTOct(JJTOCT);
455 boolean jjtc000 = true;
456 jjtree.openNodeScope(jjtn000);Token value;
457 try {
458 value = jj_consume_token(OCTNUMBER);
459 jjtree.closeNodeScope(jjtn000, true);
460 jjtc000 = false;
461 jjtn000.setValue(value.image);
462 } finally {
463 if (jjtc000) {
464 jjtree.closeNodeScope(jjtn000, true);
465 }
466 }
467 }
468
469 static final private boolean jj_2_1(int xla) {
470 jj_la = xla; jj_lastpos = jj_scanpos = token;
471 try { return !jj_3_1(); }
472 catch(LookaheadSuccess ls) { return true; }
473 finally { jj_save(0, xla); }
474 }
475
476 static final private boolean jj_2_2(int xla) {
477 jj_la = xla; jj_lastpos = jj_scanpos = token;
478 try { return !jj_3_2(); }
479 catch(LookaheadSuccess ls) { return true; }
480 finally { jj_save(1, xla); }
481 }
482
483 static final private boolean jj_2_3(int xla) {
484 jj_la = xla; jj_lastpos = jj_scanpos = token;
485 try { return !jj_3_3(); }
486 catch(LookaheadSuccess ls) { return true; }
487 finally { jj_save(2, xla); }
488 }
489
490 static final private boolean jj_2_4(int xla) {
491 jj_la = xla; jj_lastpos = jj_scanpos = token;
492 try { return !jj_3_4(); }
493 catch(LookaheadSuccess ls) { return true; }
494 finally { jj_save(3, xla); }
495 }
496
497 static final private boolean jj_3R_7() {
498 if (jj_scan_token(COMMA)) return true;
499 return false;
500 }
501
502 static final private boolean jj_3R_22() {
503 if (jj_scan_token(JAVA_TYPE_MAYBEARRAY)) return true;
504 return false;
505 }
506
507 static final private boolean jj_3R_3() {
508 if (jj_3R_6()) return true;
509 Token xsp;
510 while (true) {
511 xsp = jj_scanpos;
512 if (jj_3R_7()) { jj_scanpos = xsp; break; }
513 }
514 return false;
515 }
516
517 static final private boolean jj_3R_26() {
518 if (jj_scan_token(HEXNUMBER)) return true;
519 return false;
520 }
521
522 static final private boolean jj_3R_20() {
523 if (jj_scan_token(STRING)) return true;
524 return false;
525 }
526
527 static final private boolean jj_3R_17() {
528 if (jj_3R_27()) return true;
529 return false;
530 }
531
532 static final private boolean jj_3R_16() {
533 if (jj_3R_26()) return true;
534 return false;
535 }
536
537 static final private boolean jj_3R_15() {
538 if (jj_3R_25()) return true;
539 return false;
540 }
541
542 static final private boolean jj_3_3() {
543 if (jj_scan_token(ANNOTATION)) return true;
544 if (jj_scan_token(LEFT_PARENTHEZIS)) return true;
545 return false;
546 }
547
548 static final private boolean jj_3R_14() {
549 if (jj_3R_24()) return true;
550 return false;
551 }
552
553 static final private boolean jj_3R_13() {
554 if (jj_3R_23()) return true;
555 return false;
556 }
557
558 static final private boolean jj_3R_12() {
559 if (jj_3R_22()) return true;
560 return false;
561 }
562
563 static final private boolean jj_3R_18() {
564 Token xsp;
565 xsp = jj_scanpos;
566 if (jj_3_2()) {
567 jj_scanpos = xsp;
568 if (jj_3_3()) {
569 jj_scanpos = xsp;
570 if (jj_scan_token(21)) return true;
571 }
572 }
573 return false;
574 }
575
576 static final private boolean jj_3_2() {
577 if (jj_scan_token(ANNOTATION)) return true;
578 if (jj_scan_token(LEFT_PARENTHEZIS)) return true;
579 Token xsp;
580 xsp = jj_scanpos;
581 if (jj_3_1()) {
582 jj_scanpos = xsp;
583 if (jj_3R_4()) return true;
584 }
585 return false;
586 }
587
588 static final private boolean jj_3R_11() {
589 if (jj_3R_21()) return true;
590 return false;
591 }
592
593 static final private boolean jj_3R_25() {
594 if (jj_scan_token(FLOAT)) return true;
595 return false;
596 }
597
598 static final private boolean jj_3R_10() {
599 if (jj_3R_20()) return true;
600 return false;
601 }
602
603 static final private boolean jj_3_4() {
604 if (jj_scan_token(COMMA)) return true;
605 if (jj_3R_5()) return true;
606 return false;
607 }
608
609 static final private boolean jj_3R_9() {
610 if (jj_3R_19()) return true;
611 return false;
612 }
613
614 static final private boolean jj_3R_19() {
615 if (jj_scan_token(CHAR)) return true;
616 return false;
617 }
618
619 static final private boolean jj_3R_5() {
620 Token xsp;
621 xsp = jj_scanpos;
622 if (jj_3R_8()) {
623 jj_scanpos = xsp;
624 if (jj_3R_9()) {
625 jj_scanpos = xsp;
626 if (jj_3R_10()) {
627 jj_scanpos = xsp;
628 if (jj_3R_11()) {
629 jj_scanpos = xsp;
630 if (jj_3R_12()) {
631 jj_scanpos = xsp;
632 if (jj_3R_13()) {
633 jj_scanpos = xsp;
634 if (jj_3R_14()) {
635 jj_scanpos = xsp;
636 if (jj_3R_15()) {
637 jj_scanpos = xsp;
638 if (jj_3R_16()) {
639 jj_scanpos = xsp;
640 if (jj_3R_17()) return true;
641 }
642 }
643 }
644 }
645 }
646 }
647 }
648 }
649 }
650 return false;
651 }
652
653 static final private boolean jj_3R_8() {
654 if (jj_3R_18()) return true;
655 return false;
656 }
657
658 static final private boolean jj_3R_28() {
659 if (jj_3R_5()) return true;
660 return false;
661 }
662
663 static final private boolean jj_3_1() {
664 if (jj_3R_3()) return true;
665 return false;
666 }
667
668 static final private boolean jj_3R_24() {
669 if (jj_scan_token(INTEGER)) return true;
670 return false;
671 }
672
673 static final private boolean jj_3R_23() {
674 if (jj_scan_token(BOOLEAN)) return true;
675 return false;
676 }
677
678 static final private boolean jj_3R_27() {
679 if (jj_scan_token(OCTNUMBER)) return true;
680 return false;
681 }
682
683 static final private boolean jj_3R_6() {
684 if (jj_scan_token(JAVA_NAME)) return true;
685 if (jj_scan_token(EQUALS)) return true;
686 if (jj_3R_5()) return true;
687 return false;
688 }
689
690 static final private boolean jj_3R_21() {
691 if (jj_scan_token(LEFT_BRACKET)) return true;
692 Token xsp;
693 xsp = jj_scanpos;
694 if (jj_3R_28()) jj_scanpos = xsp;
695 if (jj_scan_token(RIGHT_BRACKET)) return true;
696 return false;
697 }
698
699 static final private boolean jj_3R_4() {
700 if (jj_3R_5()) return true;
701 return false;
702 }
703
704 static private boolean jj_initialized_once = false;
705 static public AnnotationParserTokenManager token_source;
706 static SimpleCharStream jj_input_stream;
707 static public Token token, jj_nt;
708 static private int jj_ntk;
709 static private Token jj_scanpos, jj_lastpos;
710 static private int jj_la;
711 static public boolean lookingAhead = false;
712 static private boolean jj_semLA;
713 static private int jj_gen;
714 static final private int[] jj_la1 = new int[6];
715 static private int[] jj_la1_0;
716 static {
717 jj_la1_0();
718 }
719 private static void jj_la1_0() {
720 jj_la1_0 = new int[] {0x4002001,0xa11cf0,0x200000,0x40000,0xa11cf0,0xa11cf0,};
721 }
722 static final private JJCalls[] jj_2_rtns = new JJCalls[4];
723 static private boolean jj_rescan = false;
724 static private int jj_gc = 0;
725
726 public AnnotationParser(java.io.InputStream stream) {
727 if (jj_initialized_once) {
728 System.out.println("ERROR: Second call to constructor of static parser. You must");
729 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
730 System.out.println(" during parser generation.");
731 throw new Error ();
732 }
733 jj_initialized_once = true;
734 jj_input_stream = new SimpleCharStream(stream, 1, 1);
735 token_source = new AnnotationParserTokenManager(jj_input_stream);
736 token = new Token();
737 jj_ntk = -1;
738 jj_gen = 0;
739 for (int i = 0; i < 6; i++) jj_la1[i] = -1;
740 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
741 }
742
743 static public void ReInit(java.io.InputStream stream) {
744 jj_input_stream.ReInit(stream, 1, 1);
745 token_source.ReInit(jj_input_stream);
746 token = new Token();
747 jj_ntk = -1;
748 jjtree.reset();
749 jj_gen = 0;
750 for (int i = 0; i < 6; i++) jj_la1[i] = -1;
751 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
752 }
753
754 public AnnotationParser(java.io.Reader stream) {
755 if (jj_initialized_once) {
756 System.out.println("ERROR: Second call to constructor of static parser. You must");
757 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
758 System.out.println(" during parser generation.");
759 throw new Error ();
760 }
761 jj_initialized_once = true;
762 jj_input_stream = new SimpleCharStream(stream, 1, 1);
763 token_source = new AnnotationParserTokenManager(jj_input_stream);
764 token = new Token();
765 jj_ntk = -1;
766 jj_gen = 0;
767 for (int i = 0; i < 6; i++) jj_la1[i] = -1;
768 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
769 }
770
771 static public void ReInit(java.io.Reader stream) {
772 jj_input_stream.ReInit(stream, 1, 1);
773 token_source.ReInit(jj_input_stream);
774 token = new Token();
775 jj_ntk = -1;
776 jjtree.reset();
777 jj_gen = 0;
778 for (int i = 0; i < 6; i++) jj_la1[i] = -1;
779 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
780 }
781
782 public AnnotationParser(AnnotationParserTokenManager tm) {
783 if (jj_initialized_once) {
784 System.out.println("ERROR: Second call to constructor of static parser. You must");
785 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
786 System.out.println(" during parser generation.");
787 throw new Error ();
788 }
789 jj_initialized_once = true;
790 token_source = tm;
791 token = new Token();
792 jj_ntk = -1;
793 jj_gen = 0;
794 for (int i = 0; i < 6; i++) jj_la1[i] = -1;
795 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
796 }
797
798 public void ReInit(AnnotationParserTokenManager tm) {
799 token_source = tm;
800 token = new Token();
801 jj_ntk = -1;
802 jjtree.reset();
803 jj_gen = 0;
804 for (int i = 0; i < 6; i++) jj_la1[i] = -1;
805 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
806 }
807
808 static final private Token jj_consume_token(int kind) throws ParseException {
809 Token oldToken;
810 if ((oldToken = token).next != null) token = token.next;
811 else token = token.next = token_source.getNextToken();
812 jj_ntk = -1;
813 if (token.kind == kind) {
814 jj_gen++;
815 if (++jj_gc > 100) {
816 jj_gc = 0;
817 for (int i = 0; i < jj_2_rtns.length; i++) {
818 JJCalls c = jj_2_rtns[i];
819 while (c != null) {
820 if (c.gen < jj_gen) c.first = null;
821 c = c.next;
822 }
823 }
824 }
825 return token;
826 }
827 token = oldToken;
828 jj_kind = kind;
829 throw generateParseException();
830 }
831
832 static private final class LookaheadSuccess extends java.lang.Error { }
833 static final private LookaheadSuccess jj_ls = new LookaheadSuccess();
834 static final private boolean jj_scan_token(int kind) {
835 if (jj_scanpos == jj_lastpos) {
836 jj_la--;
837 if (jj_scanpos.next == null) {
838 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
839 } else {
840 jj_lastpos = jj_scanpos = jj_scanpos.next;
841 }
842 } else {
843 jj_scanpos = jj_scanpos.next;
844 }
845 if (jj_rescan) {
846 int i = 0; Token tok = token;
847 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
848 if (tok != null) jj_add_error_token(kind, i);
849 }
850 if (jj_scanpos.kind != kind) return true;
851 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
852 return false;
853 }
854
855 static final public Token getNextToken() {
856 if (token.next != null) token = token.next;
857 else token = token.next = token_source.getNextToken();
858 jj_ntk = -1;
859 jj_gen++;
860 return token;
861 }
862
863 static final public Token getToken(int index) {
864 Token t = lookingAhead ? jj_scanpos : token;
865 for (int i = 0; i < index; i++) {
866 if (t.next != null) t = t.next;
867 else t = t.next = token_source.getNextToken();
868 }
869 return t;
870 }
871
872 static final private int jj_ntk() {
873 if ((jj_nt=token.next) == null)
874 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
875 else
876 return (jj_ntk = jj_nt.kind);
877 }
878
879 static private java.util.Vector jj_expentries = new java.util.Vector ();
880 static private int[] jj_expentry;
881 static private int jj_kind = -1;
882 static private int[] jj_lasttokens = new int[100];
883 static private int jj_endpos;
884
885 static private void jj_add_error_token(int kind, int pos) {
886 if (pos >= 100) return;
887 if (pos == jj_endpos + 1) {
888 jj_lasttokens[jj_endpos++] = kind;
889 } else if (jj_endpos != 0) {
890 jj_expentry = new int[jj_endpos];
891 for (int i = 0; i < jj_endpos; i++) {
892 jj_expentry[i] = jj_lasttokens[i];
893 }
894 boolean exists = false;
895 for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
896 int[] oldentry = (int[])(e.nextElement());
897 if (oldentry.length == jj_expentry.length) {
898 exists = true;
899 for (int i = 0; i < jj_expentry.length; i++) {
900 if (oldentry[i] != jj_expentry[i]) {
901 exists = false;
902 break;
903 }
904 }
905 if (exists) break;
906 }
907 }
908 if (!exists) jj_expentries.addElement(jj_expentry);
909 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
910 }
911 }
912
913 static public ParseException generateParseException() {
914 jj_expentries.removeAllElements();
915 boolean[] la1tokens = new boolean[27];
916 for (int i = 0; i < 27; i++) {
917 la1tokens[i] = false;
918 }
919 if (jj_kind >= 0) {
920 la1tokens[jj_kind] = true;
921 jj_kind = -1;
922 }
923 for (int i = 0; i < 6; i++) {
924 if (jj_la1[i] == jj_gen) {
925 for (int j = 0; j < 32; j++) {
926 if ((jj_la1_0[i] & (1<<j)) != 0) {
927 la1tokens[j] = true;
928 }
929 }
930 }
931 }
932 for (int i = 0; i < 27; i++) {
933 if (la1tokens[i]) {
934 jj_expentry = new int[1];
935 jj_expentry[0] = i;
936 jj_expentries.addElement(jj_expentry);
937 }
938 }
939 jj_endpos = 0;
940 jj_rescan_token();
941 jj_add_error_token(0, 0);
942 int[][] exptokseq = new int[jj_expentries.size()][];
943 for (int i = 0; i < jj_expentries.size(); i++) {
944 exptokseq[i] = (int[])jj_expentries.elementAt(i);
945 }
946 return new ParseException(token, exptokseq, tokenImage);
947 }
948
949 static final public void enable_tracing() {
950 }
951
952 static final public void disable_tracing() {
953 }
954
955 static final private void jj_rescan_token() {
956 jj_rescan = true;
957 for (int i = 0; i < 4; i++) {
958 JJCalls p = jj_2_rtns[i];
959 do {
960 if (p.gen > jj_gen) {
961 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
962 switch (i) {
963 case 0: jj_3_1(); break;
964 case 1: jj_3_2(); break;
965 case 2: jj_3_3(); break;
966 case 3: jj_3_4(); break;
967 }
968 }
969 p = p.next;
970 } while (p != null);
971 }
972 jj_rescan = false;
973 }
974
975 static final private void jj_save(int index, int xla) {
976 JJCalls p = jj_2_rtns[index];
977 while (p.gen > jj_gen) {
978 if (p.next == null) { p = p.next = new JJCalls(); break; }
979 p = p.next;
980 }
981 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
982 }
983
984 static final class JJCalls {
985 int gen;
986 Token first;
987 int arg;
988 JJCalls next;
989 }
990
991 }
992 |
Popular Tags |
Java API By Example, From Geeks To Geeks.