|
1
23 package com.sun.el.parser;
24 import java.io.StringReader  ;
25 import javax.el.ELException;
26 public class ELParserimplements ELParserTreeConstants, ELParserConstants {
27 protected JJTELParserState jjtree = new JJTELParserState();public static Node parse(String ref) throws ELException
28 {
29 try {
30 return (new ELParser(new StringReader (ref))).CompositeExpression();
31 } catch (ParseException pe) {
32 throw new ELException(pe.getMessage());
33 }
34 }
35
36
41 final public AstCompositeExpression CompositeExpression() throws ParseException {
42
43 AstCompositeExpression jjtn000 = new AstCompositeExpression(JJTCOMPOSITEEXPRESSION);
44 boolean jjtc000 = true;
45 jjtree.openNodeScope(jjtn000);
46 try {
47 label_1:
48 while (true) {
49 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
50 case LITERAL_EXPRESSION:
51 case START_DYNAMIC_EXPRESSION:
52 case START_DEFERRED_EXPRESSION:
53 ;
54 break;
55 default:
56 jj_la1[0] = jj_gen;
57 break label_1;
58 }
59 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
60 case START_DEFERRED_EXPRESSION:
61 DeferredExpression();
62 break;
63 case START_DYNAMIC_EXPRESSION:
64 DynamicExpression();
65 break;
66 case LITERAL_EXPRESSION:
67 LiteralExpression();
68 break;
69 default:
70 jj_la1[1] = jj_gen;
71 jj_consume_token(-1);
72 throw new ParseException();
73 }
74 }
75 jj_consume_token(0);
76 jjtree.closeNodeScope(jjtn000, true);
77 jjtc000 = false;
78 {if (true) return jjtn000;}
79 } catch (Throwable jjte000) {
80 if (jjtc000) {
81 jjtree.clearNodeScope(jjtn000);
82 jjtc000 = false;
83 } else {
84 jjtree.popNode();
85 }
86 if (jjte000 instanceof RuntimeException ) {
87 {if (true) throw (RuntimeException )jjte000;}
88 }
89 if (jjte000 instanceof ParseException) {
90 {if (true) throw (ParseException)jjte000;}
91 }
92 {if (true) throw (Error )jjte000;}
93 } finally {
94 if (jjtc000) {
95 jjtree.closeNodeScope(jjtn000, true);
96 }
97 }
98 throw new Error ("Missing return statement in function");
99 }
100
101
105 final public void LiteralExpression() throws ParseException {
106
107 AstLiteralExpression jjtn000 = new AstLiteralExpression(JJTLITERALEXPRESSION);
108 boolean jjtc000 = true;
109 jjtree.openNodeScope(jjtn000);Token t = null;
110 try {
111 t = jj_consume_token(LITERAL_EXPRESSION);
112 jjtree.closeNodeScope(jjtn000, true);
113 jjtc000 = false;
114 jjtn000.setImage(t.image);
115 } finally {
116 if (jjtc000) {
117 jjtree.closeNodeScope(jjtn000, true);
118 }
119 }
120 }
121
122
126 final public void DeferredExpression() throws ParseException {
127
128 AstDeferredExpression jjtn000 = new AstDeferredExpression(JJTDEFERREDEXPRESSION);
129 boolean jjtc000 = true;
130 jjtree.openNodeScope(jjtn000);
131 try {
132 jj_consume_token(START_DEFERRED_EXPRESSION);
133 Expression();
134 jj_consume_token(END_EXPRESSION);
135 } catch (Throwable jjte000) {
136 if (jjtc000) {
137 jjtree.clearNodeScope(jjtn000);
138 jjtc000 = false;
139 } else {
140 jjtree.popNode();
141 }
142 if (jjte000 instanceof RuntimeException ) {
143 {if (true) throw (RuntimeException )jjte000;}
144 }
145 if (jjte000 instanceof ParseException) {
146 {if (true) throw (ParseException)jjte000;}
147 }
148 {if (true) throw (Error )jjte000;}
149 } finally {
150 if (jjtc000) {
151 jjtree.closeNodeScope(jjtn000, true);
152 }
153 }
154 }
155
156
160 final public void DynamicExpression() throws ParseException {
161
162 AstDynamicExpression jjtn000 = new AstDynamicExpression(JJTDYNAMICEXPRESSION);
163 boolean jjtc000 = true;
164 jjtree.openNodeScope(jjtn000);
165 try {
166 jj_consume_token(START_DYNAMIC_EXPRESSION);
167 Expression();
168 jj_consume_token(END_EXPRESSION);
169 } catch (Throwable jjte000) {
170 if (jjtc000) {
171 jjtree.clearNodeScope(jjtn000);
172 jjtc000 = false;
173 } else {
174 jjtree.popNode();
175 }
176 if (jjte000 instanceof RuntimeException ) {
177 {if (true) throw (RuntimeException )jjte000;}
178 }
179 if (jjte000 instanceof ParseException) {
180 {if (true) throw (ParseException)jjte000;}
181 }
182 {if (true) throw (Error )jjte000;}
183 } finally {
184 if (jjtc000) {
185 jjtree.closeNodeScope(jjtn000, true);
186 }
187 }
188 }
189
190
194 final public void Expression() throws ParseException {
195 Choice();
196 }
197
198
202 final public void Choice() throws ParseException {
203 Or();
204 label_2:
205 while (true) {
206 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
207 case QUESTIONMARK:
208 ;
209 break;
210 default:
211 jj_la1[2] = jj_gen;
212 break label_2;
213 }
214 jj_consume_token(QUESTIONMARK);
215 Or();
216 jj_consume_token(COLON);
217 AstChoice jjtn001 = new AstChoice(JJTCHOICE);
218 boolean jjtc001 = true;
219 jjtree.openNodeScope(jjtn001);
220 try {
221 Choice();
222 } catch (Throwable jjte001) {
223 if (jjtc001) {
224 jjtree.clearNodeScope(jjtn001);
225 jjtc001 = false;
226 } else {
227 jjtree.popNode();
228 }
229 if (jjte001 instanceof RuntimeException ) {
230 {if (true) throw (RuntimeException )jjte001;}
231 }
232 if (jjte001 instanceof ParseException) {
233 {if (true) throw (ParseException)jjte001;}
234 }
235 {if (true) throw (Error )jjte001;}
236 } finally {
237 if (jjtc001) {
238 jjtree.closeNodeScope(jjtn001, 3);
239 }
240 }
241 }
242 }
243
244
248 final public void Or() throws ParseException {
249 And();
250 label_3:
251 while (true) {
252 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
253 case OR0:
254 case OR1:
255 ;
256 break;
257 default:
258 jj_la1[3] = jj_gen;
259 break label_3;
260 }
261 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
262 case OR0:
263 jj_consume_token(OR0);
264 break;
265 case OR1:
266 jj_consume_token(OR1);
267 break;
268 default:
269 jj_la1[4] = jj_gen;
270 jj_consume_token(-1);
271 throw new ParseException();
272 }
273 AstOr jjtn001 = new AstOr(JJTOR);
274 boolean jjtc001 = true;
275 jjtree.openNodeScope(jjtn001);
276 try {
277 And();
278 } catch (Throwable jjte001) {
279 if (jjtc001) {
280 jjtree.clearNodeScope(jjtn001);
281 jjtc001 = false;
282 } else {
283 jjtree.popNode();
284 }
285 if (jjte001 instanceof RuntimeException ) {
286 {if (true) throw (RuntimeException )jjte001;}
287 }
288 if (jjte001 instanceof ParseException) {
289 {if (true) throw (ParseException)jjte001;}
290 }
291 {if (true) throw (Error )jjte001;}
292 } finally {
293 if (jjtc001) {
294 jjtree.closeNodeScope(jjtn001, 2);
295 }
296 }
297 }
298 }
299
300
304 final public void And() throws ParseException {
305 Equality();
306 label_4:
307 while (true) {
308 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
309 case AND0:
310 case AND1:
311 ;
312 break;
313 default:
314 jj_la1[5] = jj_gen;
315 break label_4;
316 }
317 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
318 case AND0:
319 jj_consume_token(AND0);
320 break;
321 case AND1:
322 jj_consume_token(AND1);
323 break;
324 default:
325 jj_la1[6] = jj_gen;
326 jj_consume_token(-1);
327 throw new ParseException();
328 }
329 AstAnd jjtn001 = new AstAnd(JJTAND);
330 boolean jjtc001 = true;
331 jjtree.openNodeScope(jjtn001);
332 try {
333 Equality();
334 } catch (Throwable jjte001) {
335 if (jjtc001) {
336 jjtree.clearNodeScope(jjtn001);
337 jjtc001 = false;
338 } else {
339 jjtree.popNode();
340 }
341 if (jjte001 instanceof RuntimeException ) {
342 {if (true) throw (RuntimeException )jjte001;}
343 }
344 if (jjte001 instanceof ParseException) {
345 {if (true) throw (ParseException)jjte001;}
346 }
347 {if (true) throw (Error )jjte001;}
348 } finally {
349 if (jjtc001) {
350 jjtree.closeNodeScope(jjtn001, 2);
351 }
352 }
353 }
354 }
355
356
360 final public void Equality() throws ParseException {
361 Compare();
362 label_5:
363 while (true) {
364 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
365 case EQ0:
366 case EQ1:
367 case NE0:
368 case NE1:
369 ;
370 break;
371 default:
372 jj_la1[7] = jj_gen;
373 break label_5;
374 }
375 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
376 case EQ0:
377 case EQ1:
378 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
379 case EQ0:
380 jj_consume_token(EQ0);
381 break;
382 case EQ1:
383 jj_consume_token(EQ1);
384 break;
385 default:
386 jj_la1[8] = jj_gen;
387 jj_consume_token(-1);
388 throw new ParseException();
389 }
390 AstEqual jjtn001 = new AstEqual(JJTEQUAL);
391 boolean jjtc001 = true;
392 jjtree.openNodeScope(jjtn001);
393 try {
394 Compare();
395 } catch (Throwable jjte001) {
396 if (jjtc001) {
397 jjtree.clearNodeScope(jjtn001);
398 jjtc001 = false;
399 } else {
400 jjtree.popNode();
401 }
402 if (jjte001 instanceof RuntimeException ) {
403 {if (true) throw (RuntimeException )jjte001;}
404 }
405 if (jjte001 instanceof ParseException) {
406 {if (true) throw (ParseException)jjte001;}
407 }
408 {if (true) throw (Error )jjte001;}
409 } finally {
410 if (jjtc001) {
411 jjtree.closeNodeScope(jjtn001, 2);
412 }
413 }
414 break;
415 case NE0:
416 case NE1:
417 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
418 case NE0:
419 jj_consume_token(NE0);
420 break;
421 case NE1:
422 jj_consume_token(NE1);
423 break;
424 default:
425 jj_la1[9] = jj_gen;
426 jj_consume_token(-1);
427 throw new ParseException();
428 }
429 AstNotEqual jjtn002 = new AstNotEqual(JJTNOTEQUAL);
430 boolean jjtc002 = true;
431 jjtree.openNodeScope(jjtn002);
432 try {
433 Compare();
434 } catch (Throwable jjte002) {
435 if (jjtc002) {
436 jjtree.clearNodeScope(jjtn002);
437 jjtc002 = false;
438 } else {
439 jjtree.popNode();
440 }
441 if (jjte002 instanceof RuntimeException ) {
442 {if (true) throw (RuntimeException )jjte002;}
443 }
444 if (jjte002 instanceof ParseException) {
445 {if (true) throw (ParseException)jjte002;}
446 }
447 {if (true) throw (Error )jjte002;}
448 } finally {
449 if (jjtc002) {
450 jjtree.closeNodeScope(jjtn002, 2);
451 }
452 }
453 break;
454 default:
455 jj_la1[10] = jj_gen;
456 jj_consume_token(-1);
457 throw new ParseException();
458 }
459 }
460 }
461
462
466 final public void Compare() throws ParseException {
467 Math();
468 label_6:
469 while (true) {
470 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
471 case GT0:
472 case GT1:
473 case LT0:
474 case LT1:
475 case GE0:
476 case GE1:
477 case LE0:
478 case LE1:
479 ;
480 break;
481 default:
482 jj_la1[11] = jj_gen;
483 break label_6;
484 }
485 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
486 case LT0:
487 case LT1:
488 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
489 case LT0:
490 jj_consume_token(LT0);
491 break;
492 case LT1:
493 jj_consume_token(LT1);
494 break;
495 default:
496 jj_la1[12] = jj_gen;
497 jj_consume_token(-1);
498 throw new ParseException();
499 }
500 AstLessThan jjtn001 = new AstLessThan(JJTLESSTHAN);
501 boolean jjtc001 = true;
502 jjtree.openNodeScope(jjtn001);
503 try {
504 Math();
505 } catch (Throwable jjte001) {
506 if (jjtc001) {
507 jjtree.clearNodeScope(jjtn001);
508 jjtc001 = false;
509 } else {
510 jjtree.popNode();
511 }
512 if (jjte001 instanceof RuntimeException ) {
513 {if (true) throw (RuntimeException )jjte001;}
514 }
515 if (jjte001 instanceof ParseException) {
516 {if (true) throw (ParseException)jjte001;}
517 }
518 {if (true) throw (Error )jjte001;}
519 } finally {
520 if (jjtc001) {
521 jjtree.closeNodeScope(jjtn001, 2);
522 }
523 }
524 break;
525 case GT0:
526 case GT1:
527 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
528 case GT0:
529 jj_consume_token(GT0);
530 break;
531 case GT1:
532 jj_consume_token(GT1);
533 break;
534 default:
535 jj_la1[13] = jj_gen;
536 jj_consume_token(-1);
537 throw new ParseException();
538 }
539 AstGreaterThan jjtn002 = new AstGreaterThan(JJTGREATERTHAN);
540 boolean jjtc002 = true;
541 jjtree.openNodeScope(jjtn002);
542 try {
543 Math();
544 } catch (Throwable jjte002) {
545 if (jjtc002) {
546 jjtree.clearNodeScope(jjtn002);
547 jjtc002 = false;
548 } else {
549 jjtree.popNode();
550 }
551 if (jjte002 instanceof RuntimeException ) {
552 {if (true) throw (RuntimeException )jjte002;}
553 }
554 if (jjte002 instanceof ParseException) {
555 {if (true) throw (ParseException)jjte002;}
556 }
557 {if (true) throw (Error )jjte002;}
558 } finally {
559 if (jjtc002) {
560 jjtree.closeNodeScope(jjtn002, 2);
561 }
562 }
563 break;
564 case LE0:
565 case LE1:
566 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
567 case LE0:
568 jj_consume_token(LE0);
569 break;
570 case LE1:
571 jj_consume_token(LE1);
572 break;
573 default:
574 jj_la1[14] = jj_gen;
575 jj_consume_token(-1);
576 throw new ParseException();
577 }
578 AstLessThanEqual jjtn003 = new AstLessThanEqual(JJTLESSTHANEQUAL);
579 boolean jjtc003 = true;
580 jjtree.openNodeScope(jjtn003);
581 try {
582 Math();
583 } catch (Throwable jjte003) {
584 if (jjtc003) {
585 jjtree.clearNodeScope(jjtn003);
586 jjtc003 = false;
587 } else {
588 jjtree.popNode();
589 }
590 if (jjte003 instanceof RuntimeException ) {
591 {if (true) throw (RuntimeException )jjte003;}
592 }
593 if (jjte003 instanceof ParseException) {
594 {if (true) throw (ParseException)jjte003;}
595 }
596 {if (true) throw (Error )jjte003;}
597 } finally {
598 if (jjtc003) {
599 jjtree.closeNodeScope(jjtn003, 2);
600 }
601 }
602 break;
603 case GE0:
604 case GE1:
605 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
606 case GE0:
607 jj_consume_token(GE0);
608 break;
609 case GE1:
610 jj_consume_token(GE1);
611 break;
612 default:
613 jj_la1[15] = jj_gen;
614 jj_consume_token(-1);
615 throw new ParseException();
616 }
617 AstGreaterThanEqual jjtn004 = new AstGreaterThanEqual(JJTGREATERTHANEQUAL);
618 boolean jjtc004 = true;
619 jjtree.openNodeScope(jjtn004);
620 try {
621 Math();
622 } catch (Throwable jjte004) {
623 if (jjtc004) {
624 jjtree.clearNodeScope(jjtn004);
625 jjtc004 = false;
626 } else {
627 jjtree.popNode();
628 }
629 if (jjte004 instanceof RuntimeException ) {
630 {if (true) throw (RuntimeException )jjte004;}
631 }
632 if (jjte004 instanceof ParseException) {
633 {if (true) throw (ParseException)jjte004;}
634 }
635 {if (true) throw (Error )jjte004;}
636 } finally {
637 if (jjtc004) {
638 jjtree.closeNodeScope(jjtn004, 2);
639 }
640 }
641 break;
642 default:
643 jj_la1[16] = jj_gen;
644 jj_consume_token(-1);
645 throw new ParseException();
646 }
647 }
648 }
649
650
654 final public void Math() throws ParseException {
655 Multiplication();
656 label_7:
657 while (true) {
658 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
659 case PLUS:
660 case MINUS:
661 ;
662 break;
663 default:
664 jj_la1[17] = jj_gen;
665 break label_7;
666 }
667 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
668 case PLUS:
669 jj_consume_token(PLUS);
670 AstPlus jjtn001 = new AstPlus(JJTPLUS);
671 boolean jjtc001 = true;
672 jjtree.openNodeScope(jjtn001);
673 try {
674 Multiplication();
675 } catch (Throwable jjte001) {
676 if (jjtc001) {
677 jjtree.clearNodeScope(jjtn001);
678 jjtc001 = false;
679 } else {
680 jjtree.popNode();
681 }
682 if (jjte001 instanceof RuntimeException ) {
683 {if (true) throw (RuntimeException )jjte001;}
684 }
685 if (jjte001 instanceof ParseException) {
686 {if (true) throw (ParseException)jjte001;}
687 }
688 {if (true) throw (Error )jjte001;}
689 } finally {
690 if (jjtc001) {
691 jjtree.closeNodeScope(jjtn001, 2);
692 }
693 }
694 break;
695 case MINUS:
696 jj_consume_token(MINUS);
697 AstMinus jjtn002 = new AstMinus(JJTMINUS);
698 boolean jjtc002 = true;
699 jjtree.openNodeScope(jjtn002);
700 try {
701 Multiplication();
702 } catch (Throwable jjte002) {
703 if (jjtc002) {
704 jjtree.clearNodeScope(jjtn002);
705 jjtc002 = false;
706 } else {
707 jjtree.popNode();
708 }
709 if (jjte002 instanceof RuntimeException ) {
710 {if (true) throw (RuntimeException )jjte002;}
711 }
712 if (jjte002 instanceof ParseException) {
713 {if (true) throw (ParseException)jjte002;}
714 }
715 {if (true) throw (Error )jjte002;}
716 } finally {
717 if (jjtc002) {
718 jjtree.closeNodeScope(jjtn002, 2);
719 }
720 }
721 break;
722 default:
723 jj_la1[18] = jj_gen;
724 jj_consume_token(-1);
725 throw new ParseException();
726 }
727 }
728 }
729
730
734 final public void Multiplication() throws ParseException {
735 Unary();
736 label_8:
737 while (true) {
738 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
739 case MULT:
740 case DIV0:
741 case DIV1:
742 case MOD0:
743 case MOD1:
744 ;
745 break;
746 default:
747 jj_la1[19] = jj_gen;
748 break label_8;
749 }
750 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
751 case MULT:
752 jj_consume_token(MULT);
753 AstMult jjtn001 = new AstMult(JJTMULT);
754 boolean jjtc001 = true;
755 jjtree.openNodeScope(jjtn001);
756 try {
757 Unary();
758 } catch (Throwable jjte001) {
759 if (jjtc001) {
760 jjtree.clearNodeScope(jjtn001);
761 jjtc001 = false;
762 } else {
763 jjtree.popNode();
764 }
765 if (jjte001 instanceof RuntimeException ) {
766 {if (true) throw (RuntimeException )jjte001;}
767 }
768 if (jjte001 instanceof ParseException) {
769 {if (true) throw (ParseException)jjte001;}
770 }
771 {if (true) throw (Error )jjte001;}
772 } finally {
773 if (jjtc001) {
774 jjtree.closeNodeScope(jjtn001, 2);
775 }
776 }
777 break;
778 case DIV0:
779 case DIV1:
780 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
781 case DIV0:
782 jj_consume_token(DIV0);
783 break;
784 case DIV1:
785 jj_consume_token(DIV1);
786 break;
787 default:
788 jj_la1[20] = jj_gen;
789 jj_consume_token(-1);
790 throw new ParseException();
791 }
792 AstDiv jjtn002 = new AstDiv(JJTDIV);
793 boolean jjtc002 = true;
794 jjtree.openNodeScope(jjtn002);
795 try {
796 Unary();
797 } catch (Throwable jjte002) {
798 if (jjtc002) {
799 jjtree.clearNodeScope(jjtn002);
800 jjtc002 = false;
801 } else {
802 jjtree.popNode();
803 }
804 if (jjte002 instanceof RuntimeException ) {
805 {if (true) throw (RuntimeException )jjte002;}
806 }
807 if (jjte002 instanceof ParseException) {
808 {if (true) throw (ParseException)jjte002;}
809 }
810 {if (true) throw (Error )jjte002;}
811 } finally {
812 if (jjtc002) {
813 jjtree.closeNodeScope(jjtn002, 2);
814 }
815 }
816 break;
817 case MOD0:
818 case MOD1:
819 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
820 case MOD0:
821 jj_consume_token(MOD0);
822 break;
823 case MOD1:
824 jj_consume_token(MOD1);
825 break;
826 default:
827 jj_la1[21] = jj_gen;
828 jj_consume_token(-1);
829 throw new ParseException();
830 }
831 AstMod jjtn003 = new AstMod(JJTMOD);
832 boolean jjtc003 = true;
833 jjtree.openNodeScope(jjtn003);
834 try {
835 Unary();
836 } catch (Throwable jjte003) {
837 if (jjtc003) {
838 jjtree.clearNodeScope(jjtn003);
839 jjtc003 = false;
840 } else {
841 jjtree.popNode();
842 }
843 if (jjte003 instanceof RuntimeException ) {
844 {if (true) throw (RuntimeException )jjte003;}
845 }
846 if (jjte003 instanceof ParseException) {
847 {if (true) throw (ParseException)jjte003;}
848 }
849 {if (true) throw (Error )jjte003;}
850 } finally {
851 if (jjtc003) {
852 jjtree.closeNodeScope(jjtn003, 2);
853 }
854 }
855 break;
856 default:
857 jj_la1[22] = jj_gen;
858 jj_consume_token(-1);
859 throw new ParseException();
860 }
861 }
862 }
863
864
868 final public void Unary() throws ParseException {
869 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
870 case MINUS:
871 jj_consume_token(MINUS);
872 AstNegative jjtn001 = new AstNegative(JJTNEGATIVE);
873 boolean jjtc001 = true;
874 jjtree.openNodeScope(jjtn001);
875 try {
876 Unary();
877 } catch (Throwable jjte001) {
878 if (jjtc001) {
879 jjtree.clearNodeScope(jjtn001);
880 jjtc001 = false;
881 } else {
882 jjtree.popNode();
883 }
884 if (jjte001 instanceof RuntimeException ) {
885 {if (true) throw (RuntimeException )jjte001;}
886 }
887 if (jjte001 instanceof ParseException) {
888 {if (true) throw (ParseException)jjte001;}
889 }
890 {if (true) throw (Error )jjte001;}
891 } finally {
892 if (jjtc001) {
893 jjtree.closeNodeScope(jjtn001, true);
894 }
895 }
896 break;
897 case NOT0:
898 case NOT1:
899 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
900 case NOT0:
901 jj_consume_token(NOT0);
902 break;
903 case NOT1:
904 jj_consume_token(NOT1);
905 break;
906 default:
907 jj_la1[23] = jj_gen;
908 jj_consume_token(-1);
909 throw new ParseException();
910 }
911 AstNot jjtn002 = new AstNot(JJTNOT);
912 boolean jjtc002 = true;
913 jjtree.openNodeScope(jjtn002);
914 try {
915 Unary();
916 } catch (Throwable jjte002) {
917 if (jjtc002) {
918 jjtree.clearNodeScope(jjtn002);
919 jjtc002 = false;
920 } else {
921 jjtree.popNode();
922 }
923 if (jjte002 instanceof RuntimeException ) {
924 {if (true) throw (RuntimeException )jjte002;}
925 }
926 if (jjte002 instanceof ParseException) {
927 {if (true) throw (ParseException)jjte002;}
928 }
929 {if (true) throw (Error )jjte002;}
930 } finally {
931 if (jjtc002) {
932 jjtree.closeNodeScope(jjtn002, true);
933 }
934 }
935 break;
936 case EMPTY:
937 jj_consume_token(EMPTY);
938 AstEmpty jjtn003 = new AstEmpty(JJTEMPTY);
939 boolean jjtc003 = true;
940 jjtree.openNodeScope(jjtn003);
941 try {
942 Unary();
943 } catch (Throwable jjte003) {
944 if (jjtc003) {
945 jjtree.clearNodeScope(jjtn003);
946 jjtc003 = false;
947 } else {
948 jjtree.popNode();
949 }
950 if (jjte003 instanceof RuntimeException ) {
951 {if (true) throw (RuntimeException )jjte003;}
952 }
953 if (jjte003 instanceof ParseException) {
954 {if (true) throw (ParseException)jjte003;}
955 }
956 {if (true) throw (Error )jjte003;}
957 } finally {
958 if (jjtc003) {
959 jjtree.closeNodeScope(jjtn003, true);
960 }
961 }
962 break;
963 case INTEGER_LITERAL:
964 case FLOATING_POINT_LITERAL:
965 case STRING_LITERAL:
966 case TRUE:
967 case FALSE:
968 case NULL:
969 case LPAREN:
970 case IDENTIFIER:
971 Value();
972 break;
973 default:
974 jj_la1[24] = jj_gen;
975 jj_consume_token(-1);
976 throw new ParseException();
977 }
978 }
979
980
984 final public void Value() throws ParseException {
985 AstValue jjtn001 = new AstValue(JJTVALUE);
986 boolean jjtc001 = true;
987 jjtree.openNodeScope(jjtn001);
988 try {
989 ValuePrefix();
990 label_9:
991 while (true) {
992 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
993 case DOT:
994 case LBRACK:
995 ;
996 break;
997 default:
998 jj_la1[25] = jj_gen;
999 break label_9;
1000 }
1001 ValueSuffix();
1002 }
1003 } catch (Throwable jjte001) {
1004 if (jjtc001) {
1005 jjtree.clearNodeScope(jjtn001);
1006 jjtc001 = false;
1007 } else {
1008 jjtree.popNode();
1009 }
1010 if (jjte001 instanceof RuntimeException ) {
1011 {if (true) throw (RuntimeException )jjte001;}
1012 }
1013 if (jjte001 instanceof ParseException) {
1014 {if (true) throw (ParseException)jjte001;}
1015 }
1016 {if (true) throw (Error )jjte001;}
1017 } finally {
1018 if (jjtc001) {
1019 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1020 }
1021 }
1022 }
1023
1024
1028 final public void ValuePrefix() throws ParseException {
1029 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1030 case INTEGER_LITERAL:
1031 case FLOATING_POINT_LITERAL:
1032 case STRING_LITERAL:
1033 case TRUE:
1034 case FALSE:
1035 case NULL:
1036 Literal();
1037 break;
1038 case LPAREN:
1039 case IDENTIFIER:
1040 NonLiteral();
1041 break;
1042 default:
1043 jj_la1[26] = jj_gen;
1044 jj_consume_token(-1);
1045 throw new ParseException();
1046 }
1047 }
1048
1049
1053 final public void ValueSuffix() throws ParseException {
1054 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1055 case DOT:
1056 DotSuffix();
1057 break;
1058 case LBRACK:
1059 BracketSuffix();
1060 break;
1061 default:
1062 jj_la1[27] = jj_gen;
1063 jj_consume_token(-1);
1064 throw new ParseException();
1065 }
1066 }
1067
1068
1072 final public void DotSuffix() throws ParseException {
1073
1074 AstDotSuffix jjtn000 = new AstDotSuffix(JJTDOTSUFFIX);
1075 boolean jjtc000 = true;
1076 jjtree.openNodeScope(jjtn000);Token t = null;
1077 try {
1078 jj_consume_token(DOT);
1079 t = jj_consume_token(IDENTIFIER);
1080 jjtree.closeNodeScope(jjtn000, true);
1081 jjtc000 = false;
1082 jjtn000.setImage(t.image);
1083 } finally {
1084 if (jjtc000) {
1085 jjtree.closeNodeScope(jjtn000, true);
1086 }
1087 }
1088 }
1089
1090
1094 final public void BracketSuffix() throws ParseException {
1095
1096 AstBracketSuffix jjtn000 = new AstBracketSuffix(JJTBRACKETSUFFIX);
1097 boolean jjtc000 = true;
1098 jjtree.openNodeScope(jjtn000);
1099 try {
1100 jj_consume_token(LBRACK);
1101 Expression();
1102 jj_consume_token(RBRACK);
1103 } catch (Throwable jjte000) {
1104 if (jjtc000) {
1105 jjtree.clearNodeScope(jjtn000);
1106 jjtc000 = false;
1107 } else {
1108 jjtree.popNode();
1109 }
1110 if (jjte000 instanceof RuntimeException ) {
1111 {if (true) throw (RuntimeException )jjte000;}
1112 }
1113 if (jjte000 instanceof ParseException) {
1114 {if (true) throw (ParseException)jjte000;}
1115 }
1116 {if (true) throw (Error )jjte000;}
1117 } finally {
1118 if (jjtc000) {
1119 jjtree.closeNodeScope(jjtn000, true);
1120 }
1121 }
1122 }
1123
1124
1128 final public void NonLiteral() throws ParseException {
1129 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1130 case LPAREN:
1131 jj_consume_token(LPAREN);
1132 Expression();
1133 jj_consume_token(RPAREN);
1134 break;
1135 default:
1136 jj_la1[28] = jj_gen;
1137 if (jj_2_1(2)) {
1138 Function();
1139 } else {
1140 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1141 case IDENTIFIER:
1142 Identifier();
1143 break;
1144 default:
1145 jj_la1[29] = jj_gen;
1146 jj_consume_token(-1);
1147 throw new ParseException();
1148 }
1149 }
1150 }
1151 }
1152
1153
1157 final public void Identifier() throws ParseException {
1158
1159 AstIdentifier jjtn000 = new AstIdentifier(JJTIDENTIFIER);
1160 boolean jjtc000 = true;
1161 jjtree.openNodeScope(jjtn000);Token t = null;
1162 try {
1163 t = jj_consume_token(IDENTIFIER);
1164 jjtree.closeNodeScope(jjtn000, true);
1165 jjtc000 = false;
1166 jjtn000.setImage(t.image);
1167 } finally {
1168 if (jjtc000) {
1169 jjtree.closeNodeScope(jjtn000, true);
1170 }
1171 }
1172 }
1173
1174
1178 final public void Function() throws ParseException {
1179
1180 AstFunction jjtn000 = new AstFunction(JJTFUNCTION);
1181 boolean jjtc000 = true;
1182 jjtree.openNodeScope(jjtn000);Token t0 = null;
1183 Token t1 = null;
1184 try {
1185 t0 = jj_consume_token(IDENTIFIER);
1186 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1187 case FUNCTIONSUFFIX:
1188 t1 = jj_consume_token(FUNCTIONSUFFIX);
1189 break;
1190 default:
1191 jj_la1[30] = jj_gen;
1192 ;
1193 }
1194 if (t1 != null) {
1195 jjtn000.setPrefix(t0.image);
1196 jjtn000.setLocalName(t1.image.substring(1));
1197 } else {
1198 jjtn000.setLocalName(t0.image);
1199 }
1200 jj_consume_token(LPAREN);
1201 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1202 case INTEGER_LITERAL:
1203 case FLOATING_POINT_LITERAL:
1204 case STRING_LITERAL:
1205 case TRUE:
1206 case FALSE:
1207 case NULL:
1208 case LPAREN:
1209 case NOT0:
1210 case NOT1:
1211 case EMPTY:
1212 case MINUS:
1213 case IDENTIFIER:
1214 Expression();
1215 label_10:
1216 while (true) {
1217 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1218 case COMMA:
1219 ;
1220 break;
1221 default:
1222 jj_la1[31] = jj_gen;
1223 break label_10;
1224 }
1225 jj_consume_token(COMMA);
1226 Expression();
1227 }
1228 break;
1229 default:
1230 jj_la1[32] = jj_gen;
1231 ;
1232 }
1233 jj_consume_token(RPAREN);
1234 } catch (Throwable jjte000) {
1235 if (jjtc000) {
1236 jjtree.clearNodeScope(jjtn000);
1237 jjtc000 = false;
1238 } else {
1239 jjtree.popNode();
1240 }
1241 if (jjte000 instanceof RuntimeException ) {
1242 {if (true) throw (RuntimeException )jjte000;}
1243 }
1244 if (jjte000 instanceof ParseException) {
1245 {if (true) throw (ParseException)jjte000;}
1246 }
1247 {if (true) throw (Error )jjte000;}
1248 } finally {
1249 if (jjtc000) {
1250 jjtree.closeNodeScope(jjtn000, true);
1251 }
1252 }
1253 }
1254
1255
1259 final public void Literal() throws ParseException {
1260 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1261 case TRUE:
1262 case FALSE:
1263 Boolean();
1264 break;
1265 case FLOATING_POINT_LITERAL:
1266 FloatingPoint();
1267 break;
1268 case INTEGER_LITERAL:
1269 Integer();
1270 break;
1271 case STRING_LITERAL:
1272 String();
1273 break;
1274 case NULL:
1275 Null();
1276 break;
1277 default:
1278 jj_la1[33] = jj_gen;
1279 jj_consume_token(-1);
1280 throw new ParseException();
1281 }
1282 }
1283
1284
1288 final public void Boolean() throws ParseException {
1289 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1290 case TRUE:
1291 AstTrue jjtn001 = new AstTrue(JJTTRUE);
1292 boolean jjtc001 = true;
1293 jjtree.openNodeScope(jjtn001);
1294 try {
1295 jj_consume_token(TRUE);
1296 } finally {
1297 if (jjtc001) {
1298 jjtree.closeNodeScope(jjtn001, true);
1299 }
1300 }
1301 break;
1302 case FALSE:
1303 AstFalse jjtn002 = new AstFalse(JJTFALSE);
1304 boolean jjtc002 = true;
1305 jjtree.openNodeScope(jjtn002);
1306 try {
1307 jj_consume_token(FALSE);
1308 } finally {
1309 if (jjtc002) {
1310 jjtree.closeNodeScope(jjtn002, true);
1311 }
1312 }
1313 break;
1314 default:
1315 jj_la1[34] = jj_gen;
1316 jj_consume_token(-1);
1317 throw new ParseException();
1318 }
1319 }
1320
1321
1325 final public void FloatingPoint() throws ParseException {
1326
1327 AstFloatingPoint jjtn000 = new AstFloatingPoint(JJTFLOATINGPOINT);
1328 boolean jjtc000 = true;
1329 jjtree.openNodeScope(jjtn000);Token t = null;
1330 try {
1331 t = jj_consume_token(FLOATING_POINT_LITERAL);
1332 jjtree.closeNodeScope(jjtn000, true);
1333 jjtc000 = false;
1334 jjtn000.setImage(t.image);
1335 } finally {
1336 if (jjtc000) {
1337 jjtree.closeNodeScope(jjtn000, true);
1338 }
1339 }
1340 }
1341
1342
1346 final public void Integer() throws ParseException {
1347
1348 AstInteger jjtn000 = new AstInteger(JJTINTEGER);
1349 boolean jjtc000 = true;
1350 jjtree.openNodeScope(jjtn000);Token t = null;
1351 try {
1352 t = jj_consume_token(INTEGER_LITERAL);
1353 jjtree.closeNodeScope(jjtn000, true);
1354 jjtc000 = false;
1355 jjtn000.setImage(t.image);
1356 } finally {
1357 if (jjtc000) {
1358 jjtree.closeNodeScope(jjtn000, true);
1359 }
1360 }
1361 }
1362
1363
1367 final public void String() throws ParseException {
1368
1369 AstString jjtn000 = new AstString(JJTSTRING);
1370 boolean jjtc000 = true;
1371 jjtree.openNodeScope(jjtn000);Token t = null;
1372 try {
1373 t = jj_consume_token(STRING_LITERAL);
1374 jjtree.closeNodeScope(jjtn000, true);
1375 jjtc000 = false;
1376 jjtn000.setImage(t.image);
1377 } finally {
1378 if (jjtc000) {
1379 jjtree.closeNodeScope(jjtn000, true);
1380 }
1381 }
1382 }
1383
1384
1388 final public void Null() throws ParseException {
1389
1390 AstNull jjtn000 = new AstNull(JJTNULL);
1391 boolean jjtc000 = true;
1392 jjtree.openNodeScope(jjtn000);
1393 try {
1394 jj_consume_token(NULL);
1395 } finally {
1396 if (jjtc000) {
1397 jjtree.closeNodeScope(jjtn000, true);
1398 }
1399 }
1400 }
1401
1402 final private boolean jj_2_1(int xla) {
1403 jj_la = xla; jj_lastpos = jj_scanpos = token;
1404 try { return !jj_3_1(); }
1405 catch(LookaheadSuccess ls) { return true; }
1406 finally { jj_save(0, xla); }
1407 }
1408
1409 final private boolean jj_3_1() {
1410 if (jj_3R_11()) return true;
1411 return false;
1412 }
1413
1414 final private boolean jj_3R_11() {
1415 if (jj_scan_token(IDENTIFIER)) return true;
1416 Token xsp;
1417 xsp = jj_scanpos;
1418 if (jj_scan_token(54)) jj_scanpos = xsp;
1419 if (jj_scan_token(LPAREN)) return true;
1420 return false;
1421 }
1422
1423 public ELParserTokenManager token_source;
1424 SimpleCharStream jj_input_stream;
1425 public Token token, jj_nt;
1426 private int jj_ntk;
1427 private Token jj_scanpos, jj_lastpos;
1428 private int jj_la;
1429 public boolean lookingAhead = false;
1430 private boolean jj_semLA;
1431 private int jj_gen;
1432 final private int[] jj_la1 = new int[35];
1433 static private int[] jj_la1_0;
1434 static private int[] jj_la1_1;
1435 static {
1436 jj_la1_0();
1437 jj_la1_1();
1438 }
1439 private static void jj_la1_0() {
1440 jj_la1_0 = new int[] {0xe,0xe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfe000000,0x18000000,0x6000000,0x80000000,0x60000000,0xfe000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9d600,0x240000,0x9d600,0x240000,0x80000,0x0,0x0,0x1000000,0x9d600,0x1d600,0xc000,};
1441 }
1442 private static void jj_la1_1() {
1443 jj_la1_1 = new int[] {0x0,0x0,0x10000,0x600,0x600,0x180,0x180,0x1e,0x6,0x18,0x1e,0x1,0x0,0x0,0x1,0x0,0x1,0xc000,0xc000,0x1e2000,0x60000,0x180000,0x1e2000,0x60,0x208860,0x0,0x200000,0x0,0x0,0x200000,0x400000,0x0,0x208860,0x0,0x0,};
1444 }
1445 final private JJCalls[] jj_2_rtns = new JJCalls[1];
1446 private boolean jj_rescan = false;
1447 private int jj_gc = 0;
1448
1449 public ELParser(java.io.InputStream stream) {
1450 jj_input_stream = new SimpleCharStream(stream, 1, 1);
1451 token_source = new ELParserTokenManager(jj_input_stream);
1452 token = new Token();
1453 jj_ntk = -1;
1454 jj_gen = 0;
1455 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1456 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1457 }
1458
1459 public void ReInit(java.io.InputStream stream) {
1460 jj_input_stream.ReInit(stream, 1, 1);
1461 token_source.ReInit(jj_input_stream);
1462 token = new Token();
1463 jj_ntk = -1;
1464 jjtree.reset();
1465 jj_gen = 0;
1466 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1467 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1468 }
1469
1470 public ELParser(java.io.Reader stream) {
1471 jj_input_stream = new SimpleCharStream(stream, 1, 1);
1472 token_source = new ELParserTokenManager(jj_input_stream);
1473 token = new Token();
1474 jj_ntk = -1;
1475 jj_gen = 0;
1476 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1477 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1478 }
1479
1480 public void ReInit(java.io.Reader stream) {
1481 jj_input_stream.ReInit(stream, 1, 1);
1482 token_source.ReInit(jj_input_stream);
1483 token = new Token();
1484 jj_ntk = -1;
1485 jjtree.reset();
1486 jj_gen = 0;
1487 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1488 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1489 }
1490
1491 public ELParser(ELParserTokenManager tm) {
1492 token_source = tm;
1493 token = new Token();
1494 jj_ntk = -1;
1495 jj_gen = 0;
1496 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1497 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1498 }
1499
1500 public void ReInit(ELParserTokenManager tm) {
1501 token_source = tm;
1502 token = new Token();
1503 jj_ntk = -1;
1504 jjtree.reset();
1505 jj_gen = 0;
1506 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1507 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1508 }
1509
1510 final private Token jj_consume_token(int kind) throws ParseException {
1511 Token oldToken;
1512 if ((oldToken = token).next != null) token = token.next;
1513 else token = token.next = token_source.getNextToken();
1514 jj_ntk = -1;
1515 if (token.kind == kind) {
1516 jj_gen++;
1517 if (++jj_gc > 100) {
1518 jj_gc = 0;
1519 for (int i = 0; i < jj_2_rtns.length; i++) {
1520 JJCalls c = jj_2_rtns[i];
1521 while (c != null) {
1522 if (c.gen < jj_gen) c.first = null;
1523 c = c.next;
1524 }
1525 }
1526 }
1527 return token;
1528 }
1529 token = oldToken;
1530 jj_kind = kind;
1531 throw generateParseException();
1532 }
1533
1534 static private final class LookaheadSuccess extends java.lang.Error { }
1535 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
1536 final private boolean jj_scan_token(int kind) {
1537 if (jj_scanpos == jj_lastpos) {
1538 jj_la--;
1539 if (jj_scanpos.next == null) {
1540 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
1541 } else {
1542 jj_lastpos = jj_scanpos = jj_scanpos.next;
1543 }
1544 } else {
1545 jj_scanpos = jj_scanpos.next;
1546 }
1547 if (jj_rescan) {
1548 int i = 0; Token tok = token;
1549 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
1550 if (tok != null) jj_add_error_token(kind, i);
1551 }
1552 if (jj_scanpos.kind != kind) return true;
1553 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
1554 return false;
1555 }
1556
1557 final public Token getNextToken() {
1558 if (token.next != null) token = token.next;
1559 else token = token.next = token_source.getNextToken();
1560 jj_ntk = -1;
1561 jj_gen++;
1562 return token;
1563 }
1564
1565 final public Token getToken(int index) {
1566 Token t = lookingAhead ? jj_scanpos : token;
1567 for (int i = 0; i < index; i++) {
1568 if (t.next != null) t = t.next;
1569 else t = t.next = token_source.getNextToken();
1570 }
1571 return t;
1572 }
1573
1574 final private int jj_ntk() {
1575 if ((jj_nt=token.next) == null)
1576 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
1577 else
1578 return (jj_ntk = jj_nt.kind);
1579 }
1580
1581 private java.util.Vector jj_expentries = new java.util.Vector ();
1582 private int[] jj_expentry;
1583 private int jj_kind = -1;
1584 private int[] jj_lasttokens = new int[100];
1585 private int jj_endpos;
1586
1587 private void jj_add_error_token(int kind, int pos) {
1588 if (pos >= 100) return;
1589 if (pos == jj_endpos + 1) {
1590 jj_lasttokens[jj_endpos++] = kind;
1591 } else if (jj_endpos != 0) {
1592 jj_expentry = new int[jj_endpos];
1593 for (int i = 0; i < jj_endpos; i++) {
1594 jj_expentry[i] = jj_lasttokens[i];
1595 }
1596 boolean exists = false;
1597 for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
1598 int[] oldentry = (int[])(e.nextElement());
1599 if (oldentry.length == jj_expentry.length) {
1600 exists = true;
1601 for (int i = 0; i < jj_expentry.length; i++) {
1602 if (oldentry[i] != jj_expentry[i]) {
1603 exists = false;
1604 break;
1605 }
1606 }
1607 if (exists) break;
1608 }
1609 }
1610 if (!exists) jj_expentries.addElement(jj_expentry);
1611 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
1612 }
1613 }
1614
1615 public ParseException generateParseException() {
1616 jj_expentries.removeAllElements();
1617 boolean[] la1tokens = new boolean[59];
1618 for (int i = 0; i < 59; i++) {
1619 la1tokens[i] = false;
1620 }
1621 if (jj_kind >= 0) {
1622 la1tokens[jj_kind] = true;
1623 jj_kind = -1;
1624 }
1625 for (int i = 0; i < 35; i++) {
1626 if (jj_la1[i] == jj_gen) {
1627 for (int j = 0; j < 32; j++) {
1628 if ((jj_la1_0[i] & (1<<j)) != 0) {
1629 la1tokens[j] = true;
1630 }
1631 if ((jj_la1_1[i] & (1<<j)) != 0) {
1632 la1tokens[32+j] = true;
1633 }
1634 }
1635 }
1636 }
1637 for (int i = 0; i < 59; i++) {
1638 if (la1tokens[i]) {
1639 jj_expentry = new int[1];
1640 jj_expentry[0] = i;
1641 jj_expentries.addElement(jj_expentry);
1642 }
1643 }
1644 jj_endpos = 0;
1645 jj_rescan_token();
1646 jj_add_error_token(0, 0);
1647 int[][] exptokseq = new int[jj_expentries.size()][];
1648 for (int i = 0; i < jj_expentries.size(); i++) {
1649 exptokseq[i] = (int[])jj_expentries.elementAt(i);
1650 }
1651 return new ParseException(token, exptokseq, tokenImage);
1652 }
1653
1654 final public void enable_tracing() {
1655 }
1656
1657 final public void disable_tracing() {
1658 }
1659
1660 final private void jj_rescan_token() {
1661 jj_rescan = true;
1662 for (int i = 0; i < 1; i++) {
1663 JJCalls p = jj_2_rtns[i];
1664 do {
1665 if (p.gen > jj_gen) {
1666 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
1667 switch (i) {
1668 case 0: jj_3_1(); break;
1669 }
1670 }
1671 p = p.next;
1672 } while (p != null);
1673 }
1674 jj_rescan = false;
1675 }
1676
1677 final private void jj_save(int index, int xla) {
1678 JJCalls p = jj_2_rtns[index];
1679 while (p.gen > jj_gen) {
1680 if (p.next == null) { p = p.next = new JJCalls(); break; }
1681 p = p.next;
1682 }
1683 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
1684 }
1685
1686 static final class JJCalls {
1687 int gen;
1688 Token first;
1689 int arg;
1690 JJCalls next;
1691 }
1692
1693}
1694 |
Popular Tags |
Java API By Example, From Geeks To Geeks.