|
1
2 package org.apache.taglibs.standard.lang.jstl.parser;
3
4 import java.util.ArrayList  ;
5 import java.util.List ;
6
7 import org.apache.taglibs.standard.lang.jstl.AndOperator;
8 import org.apache.taglibs.standard.lang.jstl.ArraySuffix;
9 import org.apache.taglibs.standard.lang.jstl.BinaryOperator;
10 import org.apache.taglibs.standard.lang.jstl.BinaryOperatorExpression;
11 import org.apache.taglibs.standard.lang.jstl.BooleanLiteral;
12 import org.apache.taglibs.standard.lang.jstl.ComplexValue;
13 import org.apache.taglibs.standard.lang.jstl.DivideOperator;
14 import org.apache.taglibs.standard.lang.jstl.EmptyOperator;
15 import org.apache.taglibs.standard.lang.jstl.EqualsOperator;
16 import org.apache.taglibs.standard.lang.jstl.Expression;
17 import org.apache.taglibs.standard.lang.jstl.ExpressionString;
18 import org.apache.taglibs.standard.lang.jstl.FloatingPointLiteral;
19 import org.apache.taglibs.standard.lang.jstl.FunctionInvocation;
20 import org.apache.taglibs.standard.lang.jstl.GreaterThanOperator;
21 import org.apache.taglibs.standard.lang.jstl.GreaterThanOrEqualsOperator;
22 import org.apache.taglibs.standard.lang.jstl.IntegerLiteral;
23 import org.apache.taglibs.standard.lang.jstl.LessThanOperator;
24 import org.apache.taglibs.standard.lang.jstl.LessThanOrEqualsOperator;
25 import org.apache.taglibs.standard.lang.jstl.Literal;
26 import org.apache.taglibs.standard.lang.jstl.MinusOperator;
27 import org.apache.taglibs.standard.lang.jstl.ModulusOperator;
28 import org.apache.taglibs.standard.lang.jstl.MultiplyOperator;
29 import org.apache.taglibs.standard.lang.jstl.NamedValue;
30 import org.apache.taglibs.standard.lang.jstl.NotEqualsOperator;
31 import org.apache.taglibs.standard.lang.jstl.NotOperator;
32 import org.apache.taglibs.standard.lang.jstl.NullLiteral;
33 import org.apache.taglibs.standard.lang.jstl.OrOperator;
34 import org.apache.taglibs.standard.lang.jstl.PlusOperator;
35 import org.apache.taglibs.standard.lang.jstl.PropertySuffix;
36 import org.apache.taglibs.standard.lang.jstl.StringLiteral;
37 import org.apache.taglibs.standard.lang.jstl.UnaryMinusOperator;
38 import org.apache.taglibs.standard.lang.jstl.UnaryOperator;
39 import org.apache.taglibs.standard.lang.jstl.UnaryOperatorExpression;
40 import org.apache.taglibs.standard.lang.jstl.ValueSuffix;
41
42
48
49 public class ELParser implements ELParserConstants {
50
51 public static void main(String args[])
52 throws ParseException
53 {
54 ELParser parser = new ELParser (System.in);
55 parser.ExpressionString ();
56 }
57
58
61
62
68 final public Object ExpressionString() throws ParseException {
69 Object ret = "";
70 List elems = null;
71 Object elem;
72 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
73 case NON_EXPRESSION_TEXT:
74 ret = AttrValueString();
75 break;
76 case START_EXPRESSION:
77 ret = AttrValueExpression();
78 break;
79 default:
80 jj_la1[0] = jj_gen;
81 jj_consume_token(-1);
82 throw new ParseException();
83 }
84 label_1:
85 while (true) {
86 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
87 case NON_EXPRESSION_TEXT:
88 case START_EXPRESSION:
89 ;
90 break;
91 default:
92 jj_la1[1] = jj_gen;
93 break label_1;
94 }
95 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
96 case NON_EXPRESSION_TEXT:
97 elem = AttrValueString();
98 break;
99 case START_EXPRESSION:
100 elem = AttrValueExpression();
101 break;
102 default:
103 jj_la1[2] = jj_gen;
104 jj_consume_token(-1);
105 throw new ParseException();
106 }
107 if (elems == null) {
108 elems = new ArrayList ();
109 elems.add (ret);
110 }
111 elems.add (elem);
112 }
113 if (elems != null) {
114 ret = new ExpressionString (elems.toArray ());
115 }
116 {if (true) return ret;}
117 throw new Error ("Missing return statement in function");
118 }
119
120 final public String AttrValueString() throws ParseException {
121 Token t;
122 t = jj_consume_token(NON_EXPRESSION_TEXT);
123 {if (true) return t.image;}
124 throw new Error ("Missing return statement in function");
125 }
126
127 final public Expression AttrValueExpression() throws ParseException {
128 Expression exp;
129 jj_consume_token(START_EXPRESSION);
130 exp = Expression();
131 jj_consume_token(END_EXPRESSION);
132 {if (true) return exp;}
133 throw new Error ("Missing return statement in function");
134 }
135
136 final public Expression Expression() throws ParseException {
137 Expression ret;
138 ret = OrExpression();
139 {if (true) return ret;}
140 throw new Error ("Missing return statement in function");
141 }
142
143 final public Expression OrExpression() throws ParseException {
144 Expression startExpression;
145 BinaryOperator operator;
146 Expression expression;
147 List operators = null;
148 List expressions = null;
149 startExpression = AndExpression();
150 label_2:
151 while (true) {
152 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
153 case OR1:
154 case OR2:
155 ;
156 break;
157 default:
158 jj_la1[3] = jj_gen;
159 break label_2;
160 }
161 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
162 case OR1:
163 jj_consume_token(OR1);
164 break;
165 case OR2:
166 jj_consume_token(OR2);
167 break;
168 default:
169 jj_la1[4] = jj_gen;
170 jj_consume_token(-1);
171 throw new ParseException();
172 }
173 operator = OrOperator.SINGLETON;
174 expression = AndExpression();
175 if (operators == null) {
176 operators = new ArrayList ();
177 expressions = new ArrayList ();
178 }
179 operators.add (operator);
180 expressions.add (expression);
181 }
182 if (operators != null) {
183 {if (true) return new BinaryOperatorExpression (startExpression,
184 operators,
185 expressions);}
186 }
187 else {
188 {if (true) return startExpression;}
189 }
190 throw new Error ("Missing return statement in function");
191 }
192
193 final public Expression AndExpression() throws ParseException {
194 Expression startExpression;
195 BinaryOperator operator;
196 Expression expression;
197 List operators = null;
198 List expressions = null;
199 startExpression = EqualityExpression();
200 label_3:
201 while (true) {
202 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
203 case AND1:
204 case AND2:
205 ;
206 break;
207 default:
208 jj_la1[5] = jj_gen;
209 break label_3;
210 }
211 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
212 case AND1:
213 jj_consume_token(AND1);
214 break;
215 case AND2:
216 jj_consume_token(AND2);
217 break;
218 default:
219 jj_la1[6] = jj_gen;
220 jj_consume_token(-1);
221 throw new ParseException();
222 }
223 operator = AndOperator.SINGLETON;
224 expression = EqualityExpression();
225 if (operators == null) {
226 operators = new ArrayList ();
227 expressions = new ArrayList ();
228 }
229 operators.add (operator);
230 expressions.add (expression);
231 }
232 if (operators != null) {
233 {if (true) return new BinaryOperatorExpression (startExpression,
234 operators,
235 expressions);}
236 }
237 else {
238 {if (true) return startExpression;}
239 }
240 throw new Error ("Missing return statement in function");
241 }
242
243 final public Expression EqualityExpression() throws ParseException {
244 Expression startExpression;
245 BinaryOperator operator;
246 Expression expression;
247 List operators = null;
248 List expressions = null;
249 startExpression = RelationalExpression();
250 label_4:
251 while (true) {
252 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
253 case EQ1:
254 case EQ2:
255 case NE1:
256 case NE2:
257 ;
258 break;
259 default:
260 jj_la1[7] = jj_gen;
261 break label_4;
262 }
263 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
264 case EQ1:
265 case EQ2:
266 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
267 case EQ1:
268 jj_consume_token(EQ1);
269 break;
270 case EQ2:
271 jj_consume_token(EQ2);
272 break;
273 default:
274 jj_la1[8] = jj_gen;
275 jj_consume_token(-1);
276 throw new ParseException();
277 }
278 operator = EqualsOperator.SINGLETON;
279 break;
280 case NE1:
281 case NE2:
282 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
283 case NE1:
284 jj_consume_token(NE1);
285 break;
286 case NE2:
287 jj_consume_token(NE2);
288 break;
289 default:
290 jj_la1[9] = jj_gen;
291 jj_consume_token(-1);
292 throw new ParseException();
293 }
294 operator = NotEqualsOperator.SINGLETON;
295 break;
296 default:
297 jj_la1[10] = jj_gen;
298 jj_consume_token(-1);
299 throw new ParseException();
300 }
301 expression = RelationalExpression();
302 if (operators == null) {
303 operators = new ArrayList ();
304 expressions = new ArrayList ();
305 }
306 operators.add (operator);
307 expressions.add (expression);
308 }
309 if (operators != null) {
310 {if (true) return new BinaryOperatorExpression (startExpression,
311 operators,
312 expressions);}
313 }
314 else {
315 {if (true) return startExpression;}
316 }
317 throw new Error ("Missing return statement in function");
318 }
319
320 final public Expression RelationalExpression() throws ParseException {
321 Expression startExpression;
322 BinaryOperator operator;
323 Expression expression;
324 List operators = null;
325 List expressions = null;
326 startExpression = AddExpression();
327 label_5:
328 while (true) {
329 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
330 case GT1:
331 case GT2:
332 case LT1:
333 case LT2:
334 case LE1:
335 case LE2:
336 case GE1:
337 case GE2:
338 ;
339 break;
340 default:
341 jj_la1[11] = jj_gen;
342 break label_5;
343 }
344 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
345 case LT1:
346 case LT2:
347 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
348 case LT1:
349 jj_consume_token(LT1);
350 break;
351 case LT2:
352 jj_consume_token(LT2);
353 break;
354 default:
355 jj_la1[12] = jj_gen;
356 jj_consume_token(-1);
357 throw new ParseException();
358 }
359 operator = LessThanOperator.SINGLETON;
360 break;
361 case GT1:
362 case GT2:
363 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
364 case GT1:
365 jj_consume_token(GT1);
366 break;
367 case GT2:
368 jj_consume_token(GT2);
369 break;
370 default:
371 jj_la1[13] = jj_gen;
372 jj_consume_token(-1);
373 throw new ParseException();
374 }
375 operator = GreaterThanOperator.SINGLETON;
376 break;
377 case GE1:
378 case GE2:
379 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
380 case GE1:
381 jj_consume_token(GE1);
382 break;
383 case GE2:
384 jj_consume_token(GE2);
385 break;
386 default:
387 jj_la1[14] = jj_gen;
388 jj_consume_token(-1);
389 throw new ParseException();
390 }
391 operator = GreaterThanOrEqualsOperator.SINGLETON;
392 break;
393 case LE1:
394 case LE2:
395 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
396 case LE1:
397 jj_consume_token(LE1);
398 break;
399 case LE2:
400 jj_consume_token(LE2);
401 break;
402 default:
403 jj_la1[15] = jj_gen;
404 jj_consume_token(-1);
405 throw new ParseException();
406 }
407 operator = LessThanOrEqualsOperator.SINGLETON;
408 break;
409 default:
410 jj_la1[16] = jj_gen;
411 jj_consume_token(-1);
412 throw new ParseException();
413 }
414 expression = AddExpression();
415 if (operators == null) {
416 operators = new ArrayList ();
417 expressions = new ArrayList ();
418 }
419 operators.add (operator);
420 expressions.add (expression);
421 }
422 if (operators != null) {
423 {if (true) return new BinaryOperatorExpression (startExpression,
424 operators,
425 expressions);}
426 }
427 else {
428 {if (true) return startExpression;}
429 }
430 throw new Error ("Missing return statement in function");
431 }
432
433 final public Expression AddExpression() throws ParseException {
434 Expression startExpression;
435 BinaryOperator operator;
436 Expression expression;
437 List operators = null;
438 List expressions = null;
439 startExpression = MultiplyExpression();
440 label_6:
441 while (true) {
442 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
443 case PLUS:
444 case MINUS:
445 ;
446 break;
447 default:
448 jj_la1[17] = jj_gen;
449 break label_6;
450 }
451 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
452 case PLUS:
453 jj_consume_token(PLUS);
454 operator = PlusOperator.SINGLETON;
455 break;
456 case MINUS:
457 jj_consume_token(MINUS);
458 operator = MinusOperator.SINGLETON;
459 break;
460 default:
461 jj_la1[18] = jj_gen;
462 jj_consume_token(-1);
463 throw new ParseException();
464 }
465 expression = MultiplyExpression();
466 if (operators == null) {
467 operators = new ArrayList ();
468 expressions = new ArrayList ();
469 }
470 operators.add (operator);
471 expressions.add (expression);
472 }
473 if (operators != null) {
474 {if (true) return new BinaryOperatorExpression (startExpression,
475 operators,
476 expressions);}
477 }
478 else {
479 {if (true) return startExpression;}
480 }
481 throw new Error ("Missing return statement in function");
482 }
483
484 final public Expression MultiplyExpression() throws ParseException {
485 Expression startExpression;
486 BinaryOperator operator;
487 Expression expression;
488 List operators = null;
489 List expressions = null;
490 startExpression = UnaryExpression();
491 label_7:
492 while (true) {
493 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
494 case MULTIPLY:
495 case DIVIDE1:
496 case DIVIDE2:
497 case MODULUS1:
498 case MODULUS2:
499 ;
500 break;
501 default:
502 jj_la1[19] = jj_gen;
503 break label_7;
504 }
505 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
506 case MULTIPLY:
507 jj_consume_token(MULTIPLY);
508 operator = MultiplyOperator.SINGLETON;
509 break;
510 case DIVIDE1:
511 case DIVIDE2:
512 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
513 case DIVIDE1:
514 jj_consume_token(DIVIDE1);
515 break;
516 case DIVIDE2:
517 jj_consume_token(DIVIDE2);
518 break;
519 default:
520 jj_la1[20] = jj_gen;
521 jj_consume_token(-1);
522 throw new ParseException();
523 }
524 operator = DivideOperator.SINGLETON;
525 break;
526 case MODULUS1:
527 case MODULUS2:
528 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
529 case MODULUS1:
530 jj_consume_token(MODULUS1);
531 break;
532 case MODULUS2:
533 jj_consume_token(MODULUS2);
534 break;
535 default:
536 jj_la1[21] = jj_gen;
537 jj_consume_token(-1);
538 throw new ParseException();
539 }
540 operator = ModulusOperator.SINGLETON;
541 break;
542 default:
543 jj_la1[22] = jj_gen;
544 jj_consume_token(-1);
545 throw new ParseException();
546 }
547 expression = UnaryExpression();
548 if (operators == null) {
549 operators = new ArrayList ();
550 expressions = new ArrayList ();
551 }
552 operators.add (operator);
553 expressions.add (expression);
554 }
555 if (operators != null) {
556 {if (true) return new BinaryOperatorExpression (startExpression,
557 operators,
558 expressions);}
559 }
560 else {
561 {if (true) return startExpression;}
562 }
563 throw new Error ("Missing return statement in function");
564 }
565
566 final public Expression UnaryExpression() throws ParseException {
567 Expression expression;
568 UnaryOperator singleOperator = null;
569 UnaryOperator operator;
570 List operators = null;
571 label_8:
572 while (true) {
573 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
574 case MINUS:
575 case NOT1:
576 case NOT2:
577 case EMPTY:
578 ;
579 break;
580 default:
581 jj_la1[23] = jj_gen;
582 break label_8;
583 }
584 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
585 case NOT1:
586 case NOT2:
587 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
588 case NOT1:
589 jj_consume_token(NOT1);
590 break;
591 case NOT2:
592 jj_consume_token(NOT2);
593 break;
594 default:
595 jj_la1[24] = jj_gen;
596 jj_consume_token(-1);
597 throw new ParseException();
598 }
599 operator = NotOperator.SINGLETON;
600 break;
601 case MINUS:
602 jj_consume_token(MINUS);
603 operator = UnaryMinusOperator.SINGLETON;
604 break;
605 case EMPTY:
606 jj_consume_token(EMPTY);
607 operator = EmptyOperator.SINGLETON;
608 break;
609 default:
610 jj_la1[25] = jj_gen;
611 jj_consume_token(-1);
612 throw new ParseException();
613 }
614 if (singleOperator == null) {
615 singleOperator = operator;
616 }
617 else if (operators == null) {
618 operators = new ArrayList ();
619 operators.add (singleOperator);
620 operators.add (operator);
621 }
622 else {
623 operators.add (operator);
624 }
625 }
626 expression = Value();
627 if (operators != null) {
628 {if (true) return new UnaryOperatorExpression (null, operators, expression);}
629 }
630 else if (singleOperator != null) {
631 {if (true) return new UnaryOperatorExpression (singleOperator, null, expression);}
632 }
633 else {
634 {if (true) return expression;}
635 }
636 throw new Error ("Missing return statement in function");
637 }
638
639 final public Expression Value() throws ParseException {
640 Expression prefix;
641 ValueSuffix suffix;
642 List suffixes = null;
643 prefix = ValuePrefix();
644 label_9:
645 while (true) {
646 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
647 case DOT:
648 case LBRACKET:
649 ;
650 break;
651 default:
652 jj_la1[26] = jj_gen;
653 break label_9;
654 }
655 suffix = ValueSuffix();
656 if (suffixes == null) {
657 suffixes = new ArrayList ();
658 }
659 suffixes.add (suffix);
660 }
661 if (suffixes == null) {
662 {if (true) return prefix;}
663 }
664 else {
665 {if (true) return new ComplexValue (prefix, suffixes);}
666 }
667 throw new Error ("Missing return statement in function");
668 }
669
670
673 final public Expression ValuePrefix() throws ParseException {
674 Expression ret;
675 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
676 case INTEGER_LITERAL:
677 case FLOATING_POINT_LITERAL:
678 case STRING_LITERAL:
679 case TRUE:
680 case FALSE:
681 case NULL:
682 ret = Literal();
683 break;
684 case LPAREN:
685 jj_consume_token(LPAREN);
686 ret = Expression();
687 jj_consume_token(RPAREN);
688 break;
689 default:
690 jj_la1[27] = jj_gen;
691 if (jj_2_1(2147483647)) {
692 ret = FunctionInvocation();
693 } else {
694 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
695 case IDENTIFIER:
696 ret = NamedValue();
697 break;
698 default:
699 jj_la1[28] = jj_gen;
700 jj_consume_token(-1);
701 throw new ParseException();
702 }
703 }
704 }
705 {if (true) return ret;}
706 throw new Error ("Missing return statement in function");
707 }
708
709 final public NamedValue NamedValue() throws ParseException {
710 Token t;
711 t = jj_consume_token(IDENTIFIER);
712 {if (true) return new NamedValue (t.image);}
713 throw new Error ("Missing return statement in function");
714 }
715
716 final public FunctionInvocation FunctionInvocation() throws ParseException {
717 String qualifiedName;
718 List argumentList = new ArrayList ();
719 Expression exp;
720 qualifiedName = QualifiedName();
721 jj_consume_token(LPAREN);
722 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
723 case INTEGER_LITERAL:
724 case FLOATING_POINT_LITERAL:
725 case STRING_LITERAL:
726 case TRUE:
727 case FALSE:
728 case NULL:
729 case LPAREN:
730 case MINUS:
731 case NOT1:
732 case NOT2:
733 case EMPTY:
734 case IDENTIFIER:
735 exp = Expression();
736 argumentList.add(exp);
737 label_10:
738 while (true) {
739 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
740 case COMMA:
741 ;
742 break;
743 default:
744 jj_la1[29] = jj_gen;
745 break label_10;
746 }
747 jj_consume_token(COMMA);
748 exp = Expression();
749 argumentList.add(exp);
750 }
751 break;
752 default:
753 jj_la1[30] = jj_gen;
754 ;
755 }
756 jj_consume_token(RPAREN);
757 String allowed = System.getProperty("javax.servlet.jsp.functions.allowed");
758 if (allowed == null || !allowed.equalsIgnoreCase("true"))
759 {if (true) throw new ParseException("EL functions are not supported.");}
760 {if (true) return new FunctionInvocation(qualifiedName, argumentList);}
761 throw new Error ("Missing return statement in function");
762 }
763
764 final public ValueSuffix ValueSuffix() throws ParseException {
765 ValueSuffix suffix;
766 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
767 case DOT:
768 suffix = PropertySuffix();
769 break;
770 case LBRACKET:
771 suffix = ArraySuffix();
772 break;
773 default:
774 jj_la1[31] = jj_gen;
775 jj_consume_token(-1);
776 throw new ParseException();
777 }
778 {if (true) return suffix;}
779 throw new Error ("Missing return statement in function");
780 }
781
782 final public PropertySuffix PropertySuffix() throws ParseException {
783 Token t;
784 String property;
785 jj_consume_token(DOT);
786 property = Identifier();
787 {if (true) return new PropertySuffix (property);}
788 throw new Error ("Missing return statement in function");
789 }
790
791 final public ArraySuffix ArraySuffix() throws ParseException {
792 Expression index;
793 jj_consume_token(LBRACKET);
794 index = Expression();
795 jj_consume_token(RBRACKET);
796 {if (true) return new ArraySuffix (index);}
797 throw new Error ("Missing return statement in function");
798 }
799
800 final public Literal Literal() throws ParseException {
801 Literal ret;
802 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
803 case TRUE:
804 case FALSE:
805 ret = BooleanLiteral();
806 break;
807 case INTEGER_LITERAL:
808 ret = IntegerLiteral();
809 break;
810 case FLOATING_POINT_LITERAL:
811 ret = FloatingPointLiteral();
812 break;
813 case STRING_LITERAL:
814 ret = StringLiteral();
815 break;
816 case NULL:
817 ret = NullLiteral();
818 break;
819 default:
820 jj_la1[32] = jj_gen;
821 jj_consume_token(-1);
822 throw new ParseException();
823 }
824 {if (true) return ret;}
825 throw new Error ("Missing return statement in function");
826 }
827
828 final public BooleanLiteral BooleanLiteral() throws ParseException {
829 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
830 case TRUE:
831 jj_consume_token(TRUE);
832 {if (true) return BooleanLiteral.TRUE;}
833 break;
834 case FALSE:
835 jj_consume_token(FALSE);
836 {if (true) return BooleanLiteral.FALSE;}
837 break;
838 default:
839 jj_la1[33] = jj_gen;
840 jj_consume_token(-1);
841 throw new ParseException();
842 }
843 throw new Error ("Missing return statement in function");
844 }
845
846 final public StringLiteral StringLiteral() throws ParseException {
847 Token t;
848 t = jj_consume_token(STRING_LITERAL);
849 {if (true) return StringLiteral.fromToken (t.image);}
850 throw new Error ("Missing return statement in function");
851 }
852
853 final public IntegerLiteral IntegerLiteral() throws ParseException {
854 Token t;
855 t = jj_consume_token(INTEGER_LITERAL);
856 {if (true) return new IntegerLiteral (t.image);}
857 throw new Error ("Missing return statement in function");
858 }
859
860 final public FloatingPointLiteral FloatingPointLiteral() throws ParseException {
861 Token t;
862 t = jj_consume_token(FLOATING_POINT_LITERAL);
863 {if (true) return new FloatingPointLiteral (t.image);}
864 throw new Error ("Missing return statement in function");
865 }
866
867 final public NullLiteral NullLiteral() throws ParseException {
868 jj_consume_token(NULL);
869 {if (true) return NullLiteral.SINGLETON;}
870 throw new Error ("Missing return statement in function");
871 }
872
873 final public String Identifier() throws ParseException {
874 Token t;
875 t = jj_consume_token(IDENTIFIER);
876 {if (true) return t.image;}
877 throw new Error ("Missing return statement in function");
878 }
879
880 final public String QualifiedName() throws ParseException {
881 String prefix = null, localPart = null;
882 if (jj_2_2(2147483647)) {
883 prefix = Identifier();
884 jj_consume_token(COLON);
885 } else {
886 ;
887 }
888 localPart = Identifier();
889 if (prefix == null)
890 {if (true) return localPart;}
891 else
892 {if (true) return prefix + ":" + localPart;}
893 throw new Error ("Missing return statement in function");
894 }
895
896 final private boolean jj_2_1(int xla) {
897 jj_la = xla; jj_lastpos = jj_scanpos = token;
898 boolean retval = !jj_3_1();
899 jj_save(0, xla);
900 return retval;
901 }
902
903 final private boolean jj_2_2(int xla) {
904 jj_la = xla; jj_lastpos = jj_scanpos = token;
905 boolean retval = !jj_3_2();
906 jj_save(1, xla);
907 return retval;
908 }
909
910 final private boolean jj_3R_13() {
911 if (jj_3R_12()) return true;
912 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
913 if (jj_scan_token(COLON)) return true;
914 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
915 return false;
916 }
917
918 final private boolean jj_3_2() {
919 if (jj_3R_12()) return true;
920 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
921 if (jj_scan_token(COLON)) return true;
922 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
923 return false;
924 }
925
926 final private boolean jj_3_1() {
927 if (jj_3R_11()) return true;
928 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
929 if (jj_scan_token(LPAREN)) return true;
930 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
931 return false;
932 }
933
934 final private boolean jj_3R_12() {
935 if (jj_scan_token(IDENTIFIER)) return true;
936 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
937 return false;
938 }
939
940 final private boolean jj_3R_11() {
941 Token xsp;
942 xsp = jj_scanpos;
943 if (jj_3R_13()) jj_scanpos = xsp;
944 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
945 if (jj_3R_12()) return true;
946 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
947 return false;
948 }
949
950 public ELParserTokenManager token_source;
951 SimpleCharStream jj_input_stream;
952 public Token token, jj_nt;
953 private int jj_ntk;
954 private Token jj_scanpos, jj_lastpos;
955 private int jj_la;
956 public boolean lookingAhead = false;
957 private boolean jj_semLA;
958 private int jj_gen;
959 final private int[] jj_la1 = new int[34];
960 final private int[] jj_la1_0 = {0x6,0x6,0x6,0x0,0x0,0x0,0x0,0x18600000,0x600000,0x18000000,0x18600000,0x79e0000,0x180000,0x60000,0x6000000,0x1800000,0x79e0000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x20007580,0x0,0x80000000,0x20007580,0x10000,0x7580,0x3000,};
961 final private int[] jj_la1_1 = {0x0,0x0,0x0,0xc000,0xc000,0x3000,0x3000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x18,0x3e0,0xc0,0x300,0x3e0,0x10c10,0xc00,0x10c10,0x2,0x0,0x20000,0x0,0x30c10,0x2,0x0,0x0,};
962 final private JJCalls[] jj_2_rtns = new JJCalls[2];
963 private boolean jj_rescan = false;
964 private int jj_gc = 0;
965
966 public ELParser(java.io.InputStream stream) {
967 jj_input_stream = new SimpleCharStream(stream, 1, 1);
968 token_source = new ELParserTokenManager(jj_input_stream);
969 token = new Token();
970 jj_ntk = -1;
971 jj_gen = 0;
972 for (int i = 0; i < 34; i++) jj_la1[i] = -1;
973 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
974 }
975
976 public void ReInit(java.io.InputStream stream) {
977 jj_input_stream.ReInit(stream, 1, 1);
978 token_source.ReInit(jj_input_stream);
979 token = new Token();
980 jj_ntk = -1;
981 jj_gen = 0;
982 for (int i = 0; i < 34; i++) jj_la1[i] = -1;
983 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
984 }
985
986 public ELParser(java.io.Reader stream) {
987 jj_input_stream = new SimpleCharStream(stream, 1, 1);
988 token_source = new ELParserTokenManager(jj_input_stream);
989 token = new Token();
990 jj_ntk = -1;
991 jj_gen = 0;
992 for (int i = 0; i < 34; i++) jj_la1[i] = -1;
993 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
994 }
995
996 public void ReInit(java.io.Reader stream) {
997 jj_input_stream.ReInit(stream, 1, 1);
998 token_source.ReInit(jj_input_stream);
999 token = new Token();
1000 jj_ntk = -1;
1001 jj_gen = 0;
1002 for (int i = 0; i < 34; i++) jj_la1[i] = -1;
1003 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1004 }
1005
1006 public ELParser(ELParserTokenManager tm) {
1007 token_source = tm;
1008 token = new Token();
1009 jj_ntk = -1;
1010 jj_gen = 0;
1011 for (int i = 0; i < 34; i++) jj_la1[i] = -1;
1012 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1013 }
1014
1015 public void ReInit(ELParserTokenManager tm) {
1016 token_source = tm;
1017 token = new Token();
1018 jj_ntk = -1;
1019 jj_gen = 0;
1020 for (int i = 0; i < 34; i++) jj_la1[i] = -1;
1021 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1022 }
1023
1024 final private Token jj_consume_token(int kind) throws ParseException {
1025 Token oldToken;
1026 if ((oldToken = token).next != null) token = token.next;
1027 else token = token.next = token_source.getNextToken();
1028 jj_ntk = -1;
1029 if (token.kind == kind) {
1030 jj_gen++;
1031 if (++jj_gc > 100) {
1032 jj_gc = 0;
1033 for (int i = 0; i < jj_2_rtns.length; i++) {
1034 JJCalls c = jj_2_rtns[i];
1035 while (c != null) {
1036 if (c.gen < jj_gen) c.first = null;
1037 c = c.next;
1038 }
1039 }
1040 }
1041 return token;
1042 }
1043 token = oldToken;
1044 jj_kind = kind;
1045 throw generateParseException();
1046 }
1047
1048 final private boolean jj_scan_token(int kind) {
1049 if (jj_scanpos == jj_lastpos) {
1050 jj_la--;
1051 if (jj_scanpos.next == null) {
1052 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
1053 } else {
1054 jj_lastpos = jj_scanpos = jj_scanpos.next;
1055 }
1056 } else {
1057 jj_scanpos = jj_scanpos.next;
1058 }
1059 if (jj_rescan) {
1060 int i = 0; Token tok = token;
1061 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
1062 if (tok != null) jj_add_error_token(kind, i);
1063 }
1064 return (jj_scanpos.kind != kind);
1065 }
1066
1067 final public Token getNextToken() {
1068 if (token.next != null) token = token.next;
1069 else token = token.next = token_source.getNextToken();
1070 jj_ntk = -1;
1071 jj_gen++;
1072 return token;
1073 }
1074
1075 final public Token getToken(int index) {
1076 Token t = lookingAhead ? jj_scanpos : token;
1077 for (int i = 0; i < index; i++) {
1078 if (t.next != null) t = t.next;
1079 else t = t.next = token_source.getNextToken();
1080 }
1081 return t;
1082 }
1083
1084 final private int jj_ntk() {
1085 if ((jj_nt=token.next) == null)
1086 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
1087 else
1088 return (jj_ntk = jj_nt.kind);
1089 }
1090
1091 private java.util.Vector jj_expentries = new java.util.Vector ();
1092 private int[] jj_expentry;
1093 private int jj_kind = -1;
1094 private int[] jj_lasttokens = new int[100];
1095 private int jj_endpos;
1096
1097 private void jj_add_error_token(int kind, int pos) {
1098 if (pos >= 100) return;
1099 if (pos == jj_endpos + 1) {
1100 jj_lasttokens[jj_endpos++] = kind;
1101 } else if (jj_endpos != 0) {
1102 jj_expentry = new int[jj_endpos];
1103 for (int i = 0; i < jj_endpos; i++) {
1104 jj_expentry[i] = jj_lasttokens[i];
1105 }
1106 boolean exists = false;
1107 for (java.util.Enumeration enum_ = jj_expentries.elements(); enum_.hasMoreElements();) {
1108 int[] oldentry = (int[])(enum_.nextElement());
1109 if (oldentry.length == jj_expentry.length) {
1110 exists = true;
1111 for (int i = 0; i < jj_expentry.length; i++) {
1112 if (oldentry[i] != jj_expentry[i]) {
1113 exists = false;
1114 break;
1115 }
1116 }
1117 if (exists) break;
1118 }
1119 }
1120 if (!exists) jj_expentries.addElement(jj_expentry);
1121 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
1122 }
1123 }
1124
1125 final public ParseException generateParseException() {
1126 jj_expentries.removeAllElements();
1127 boolean[] la1tokens = new boolean[54];
1128 for (int i = 0; i < 54; i++) {
1129 la1tokens[i] = false;
1130 }
1131 if (jj_kind >= 0) {
1132 la1tokens[jj_kind] = true;
1133 jj_kind = -1;
1134 }
1135 for (int i = 0; i < 34; i++) {
1136 if (jj_la1[i] == jj_gen) {
1137 for (int j = 0; j < 32; j++) {
1138 if ((jj_la1_0[i] & (1<<j)) != 0) {
1139 la1tokens[j] = true;
1140 }
1141 if ((jj_la1_1[i] & (1<<j)) != 0) {
1142 la1tokens[32+j] = true;
1143 }
1144 }
1145 }
1146 }
1147 for (int i = 0; i < 54; i++) {
1148 if (la1tokens[i]) {
1149 jj_expentry = new int[1];
1150 jj_expentry[0] = i;
1151 jj_expentries.addElement(jj_expentry);
1152 }
1153 }
1154 jj_endpos = 0;
1155 jj_rescan_token();
1156 jj_add_error_token(0, 0);
1157 int[][] exptokseq = new int[jj_expentries.size()][];
1158 for (int i = 0; i < jj_expentries.size(); i++) {
1159 exptokseq[i] = (int[])jj_expentries.elementAt(i);
1160 }
1161 return new ParseException(token, exptokseq, tokenImage);
1162 }
1163
1164 final public void enable_tracing() {
1165 }
1166
1167 final public void disable_tracing() {
1168 }
1169
1170 final private void jj_rescan_token() {
1171 jj_rescan = true;
1172 for (int i = 0; i < 2; i++) {
1173 JJCalls p = jj_2_rtns[i];
1174 do {
1175 if (p.gen > jj_gen) {
1176 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
1177 switch (i) {
1178 case 0: jj_3_1(); break;
1179 case 1: jj_3_2(); break;
1180 }
1181 }
1182 p = p.next;
1183 } while (p != null);
1184 }
1185 jj_rescan = false;
1186 }
1187
1188 final private void jj_save(int index, int xla) {
1189 JJCalls p = jj_2_rtns[index];
1190 while (p.gen > jj_gen) {
1191 if (p.next == null) { p = p.next = new JJCalls(); break; }
1192 p = p.next;
1193 }
1194 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
1195 }
1196
1197 static final class JJCalls {
1198 int gen;
1199 Token first;
1200 int arg;
1201 JJCalls next;
1202 }
1203
1204}
1205 |
Popular Tags |
Java API By Example, From Geeks To Geeks.