|
1
2 package org.apache.commons.el.parser;
3
4 import org.apache.commons.el.*;
5 import java.util.ArrayList;
6 import java.util.List;
7
8
14
15 public class ELParser implements ELParserConstants {
16
17 public static void main(String args[])
18 throws ParseException
19 {
20 ELParser parser = new ELParser (System.in);
21 parser.ExpressionString ();
22 }
23
24
27
28
34 final public Object ExpressionString() throws ParseException {
35 Object ret = "";
36 List elems = null;
37 Object elem;
38 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
39 case NON_EXPRESSION_TEXT:
40 ret = AttrValueString();
41 break;
42 case START_EXPRESSION:
43 ret = AttrValueExpression();
44 break;
45 default:
46 jj_la1[0] = jj_gen;
47 jj_consume_token(-1);
48 throw new ParseException();
49 }
50 label_1:
51 while (true) {
52 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
53 case NON_EXPRESSION_TEXT:
54 case START_EXPRESSION:
55 ;
56 break;
57 default:
58 jj_la1[1] = jj_gen;
59 break label_1;
60 }
61 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
62 case NON_EXPRESSION_TEXT:
63 elem = AttrValueString();
64 break;
65 case START_EXPRESSION:
66 elem = AttrValueExpression();
67 break;
68 default:
69 jj_la1[2] = jj_gen;
70 jj_consume_token(-1);
71 throw new ParseException();
72 }
73 if (elems == null) {
74 elems = new ArrayList ();
75 elems.add (ret);
76 }
77 elems.add (elem);
78 }
79 if (elems != null) {
80 ret = new ExpressionString (elems.toArray ());
81 }
82 {if (true) return ret;}
83 throw new Error("Missing return statement in function");
84 }
85
86 final public String AttrValueString() throws ParseException {
87 Token t;
88 t = jj_consume_token(NON_EXPRESSION_TEXT);
89 {if (true) return t.image;}
90 throw new Error("Missing return statement in function");
91 }
92
93 final public Expression AttrValueExpression() throws ParseException {
94 Expression exp;
95 jj_consume_token(START_EXPRESSION);
96 exp = Expression();
97 jj_consume_token(END_EXPRESSION);
98 {if (true) return exp;}
99 throw new Error("Missing return statement in function");
100 }
101
102 final public Expression Expression() throws ParseException {
103 Expression ret;
104 if (jj_2_1(2147483647)) {
105 ret = ConditionalExpression();
106 } else {
107 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
108 case INTEGER_LITERAL:
109 case FLOATING_POINT_LITERAL:
110 case STRING_LITERAL:
111 case TRUE:
112 case FALSE:
113 case NULL:
114 case LPAREN:
115 case MINUS:
116 case NOT1:
117 case NOT2:
118 case EMPTY:
119 case IDENTIFIER:
120 ret = OrExpression();
121 break;
122 default:
123 jj_la1[3] = jj_gen;
124 jj_consume_token(-1);
125 throw new ParseException();
126 }
127 }
128 {if (true) return ret;}
129 throw new Error("Missing return statement in function");
130 }
131
132 final public Expression OrExpression() throws ParseException {
133 Expression startExpression;
134 BinaryOperator operator;
135 Expression expression;
136 List operators = null;
137 List expressions = null;
138 startExpression = AndExpression();
139 label_2:
140 while (true) {
141 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
142 case OR1:
143 case OR2:
144 ;
145 break;
146 default:
147 jj_la1[4] = jj_gen;
148 break label_2;
149 }
150 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
151 case OR1:
152 jj_consume_token(OR1);
153 break;
154 case OR2:
155 jj_consume_token(OR2);
156 break;
157 default:
158 jj_la1[5] = jj_gen;
159 jj_consume_token(-1);
160 throw new ParseException();
161 }
162 operator = OrOperator.SINGLETON;
163 expression = AndExpression();
164 if (operators == null) {
165 operators = new ArrayList ();
166 expressions = new ArrayList ();
167 }
168 operators.add (operator);
169 expressions.add (expression);
170 }
171 if (operators != null) {
172 {if (true) return new BinaryOperatorExpression (startExpression,
173 operators,
174 expressions);}
175 }
176 else {
177 {if (true) return startExpression;}
178 }
179 throw new Error("Missing return statement in function");
180 }
181
182 final public Expression AndExpression() throws ParseException {
183 Expression startExpression;
184 BinaryOperator operator;
185 Expression expression;
186 List operators = null;
187 List expressions = null;
188 startExpression = EqualityExpression();
189 label_3:
190 while (true) {
191 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
192 case AND1:
193 case AND2:
194 ;
195 break;
196 default:
197 jj_la1[6] = jj_gen;
198 break label_3;
199 }
200 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
201 case AND1:
202 jj_consume_token(AND1);
203 break;
204 case AND2:
205 jj_consume_token(AND2);
206 break;
207 default:
208 jj_la1[7] = jj_gen;
209 jj_consume_token(-1);
210 throw new ParseException();
211 }
212 operator = AndOperator.SINGLETON;
213 expression = EqualityExpression();
214 if (operators == null) {
215 operators = new ArrayList ();
216 expressions = new ArrayList ();
217 }
218 operators.add (operator);
219 expressions.add (expression);
220 }
221 if (operators != null) {
222 {if (true) return new BinaryOperatorExpression (startExpression,
223 operators,
224 expressions);}
225 }
226 else {
227 {if (true) return startExpression;}
228 }
229 throw new Error("Missing return statement in function");
230 }
231
232 final public Expression EqualityExpression() throws ParseException {
233 Expression startExpression;
234 BinaryOperator operator;
235 Expression expression;
236 List operators = null;
237 List expressions = null;
238 startExpression = RelationalExpression();
239 label_4:
240 while (true) {
241 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
242 case EQ1:
243 case EQ2:
244 case NE1:
245 case NE2:
246 ;
247 break;
248 default:
249 jj_la1[8] = jj_gen;
250 break label_4;
251 }
252 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
253 case EQ1:
254 case EQ2:
255 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
256 case EQ1:
257 jj_consume_token(EQ1);
258 break;
259 case EQ2:
260 jj_consume_token(EQ2);
261 break;
262 default:
263 jj_la1[9] = jj_gen;
264 jj_consume_token(-1);
265 throw new ParseException();
266 }
267 operator = EqualsOperator.SINGLETON;
268 break;
269 case NE1:
270 case NE2:
271 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
272 case NE1:
273 jj_consume_token(NE1);
274 break;
275 case NE2:
276 jj_consume_token(NE2);
277 break;
278 default:
279 jj_la1[10] = jj_gen;
280 jj_consume_token(-1);
281 throw new ParseException();
282 }
283 operator = NotEqualsOperator.SINGLETON;
284 break;
285 default:
286 jj_la1[11] = jj_gen;
287 jj_consume_token(-1);
288 throw new ParseException();
289 }
290 expression = RelationalExpression();
291 if (operators == null) {
292 operators = new ArrayList ();
293 expressions = new ArrayList ();
294 }
295 operators.add (operator);
296 expressions.add (expression);
297 }
298 if (operators != null) {
299 {if (true) return new BinaryOperatorExpression (startExpression,
300 operators,
301 expressions);}
302 }
303 else {
304 {if (true) return startExpression;}
305 }
306 throw new Error("Missing return statement in function");
307 }
308
309 final public Expression RelationalExpression() throws ParseException {
310 Expression startExpression;
311 BinaryOperator operator;
312 Expression expression;
313 List operators = null;
314 List expressions = null;
315 startExpression = AddExpression();
316 label_5:
317 while (true) {
318 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
319 case GT1:
320 case GT2:
321 case LT1:
322 case LT2:
323 case LE1:
324 case LE2:
325 case GE1:
326 case GE2:
327 ;
328 break;
329 default:
330 jj_la1[12] = jj_gen;
331 break label_5;
332 }
333 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
334 case LT1:
335 case LT2:
336 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
337 case LT1:
338 jj_consume_token(LT1);
339 break;
340 case LT2:
341 jj_consume_token(LT2);
342 break;
343 default:
344 jj_la1[13] = jj_gen;
345 jj_consume_token(-1);
346 throw new ParseException();
347 }
348 operator = LessThanOperator.SINGLETON;
349 break;
350 case GT1:
351 case GT2:
352 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
353 case GT1:
354 jj_consume_token(GT1);
355 break;
356 case GT2:
357 jj_consume_token(GT2);
358 break;
359 default:
360 jj_la1[14] = jj_gen;
361 jj_consume_token(-1);
362 throw new ParseException();
363 }
364 operator = GreaterThanOperator.SINGLETON;
365 break;
366 case GE1:
367 case GE2:
368 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
369 case GE1:
370 jj_consume_token(GE1);
371 break;
372 case GE2:
373 jj_consume_token(GE2);
374 break;
375 default:
376 jj_la1[15] = jj_gen;
377 jj_consume_token(-1);
378 throw new ParseException();
379 }
380 operator = GreaterThanOrEqualsOperator.SINGLETON;
381 break;
382 case LE1:
383 case LE2:
384 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
385 case LE1:
386 jj_consume_token(LE1);
387 break;
388 case LE2:
389 jj_consume_token(LE2);
390 break;
391 default:
392 jj_la1[16] = jj_gen;
393 jj_consume_token(-1);
394 throw new ParseException();
395 }
396 operator = LessThanOrEqualsOperator.SINGLETON;
397 break;
398 default:
399 jj_la1[17] = jj_gen;
400 jj_consume_token(-1);
401 throw new ParseException();
402 }
403 expression = AddExpression();
404 if (operators == null) {
405 operators = new ArrayList ();
406 expressions = new ArrayList ();
407 }
408 operators.add (operator);
409 expressions.add (expression);
410 }
411 if (operators != null) {
412 {if (true) return new BinaryOperatorExpression (startExpression,
413 operators,
414 expressions);}
415 }
416 else {
417 {if (true) return startExpression;}
418 }
419 throw new Error("Missing return statement in function");
420 }
421
422 final public Expression AddExpression() throws ParseException {
423 Expression startExpression;
424 BinaryOperator operator;
425 Expression expression;
426 List operators = null;
427 List expressions = null;
428 startExpression = MultiplyExpression();
429 label_6:
430 while (true) {
431 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
432 case PLUS:
433 case MINUS:
434 ;
435 break;
436 default:
437 jj_la1[18] = jj_gen;
438 break label_6;
439 }
440 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
441 case PLUS:
442 jj_consume_token(PLUS);
443 operator = PlusOperator.SINGLETON;
444 break;
445 case MINUS:
446 jj_consume_token(MINUS);
447 operator = MinusOperator.SINGLETON;
448 break;
449 default:
450 jj_la1[19] = jj_gen;
451 jj_consume_token(-1);
452 throw new ParseException();
453 }
454 expression = MultiplyExpression();
455 if (operators == null) {
456 operators = new ArrayList ();
457 expressions = new ArrayList ();
458 }
459 operators.add (operator);
460 expressions.add (expression);
461 }
462 if (operators != null) {
463 {if (true) return new BinaryOperatorExpression (startExpression,
464 operators,
465 expressions);}
466 }
467 else {
468 {if (true) return startExpression;}
469 }
470 throw new Error("Missing return statement in function");
471 }
472
473 final public Expression MultiplyExpression() throws ParseException {
474 Expression startExpression;
475 BinaryOperator operator;
476 Expression expression;
477 List operators = null;
478 List expressions = null;
479 startExpression = UnaryExpression();
480 label_7:
481 while (true) {
482 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
483 case MULTIPLY:
484 case DIVIDE1:
485 case DIVIDE2:
486 case MODULUS1:
487 case MODULUS2:
488 ;
489 break;
490 default:
491 jj_la1[20] = jj_gen;
492 break label_7;
493 }
494 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
495 case MULTIPLY:
496 jj_consume_token(MULTIPLY);
497 operator = MultiplyOperator.SINGLETON;
498 break;
499 case DIVIDE1:
500 case DIVIDE2:
501 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
502 case DIVIDE1:
503 jj_consume_token(DIVIDE1);
504 break;
505 case DIVIDE2:
506 jj_consume_token(DIVIDE2);
507 break;
508 default:
509 jj_la1[21] = jj_gen;
510 jj_consume_token(-1);
511 throw new ParseException();
512 }
513 operator = DivideOperator.SINGLETON;
514 break;
515 case MODULUS1:
516 case MODULUS2:
517 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
518 case MODULUS1:
519 jj_consume_token(MODULUS1);
520 break;
521 case MODULUS2:
522 jj_consume_token(MODULUS2);
523 break;
524 default:
525 jj_la1[22] = jj_gen;
526 jj_consume_token(-1);
527 throw new ParseException();
528 }
529 operator = ModulusOperator.SINGLETON;
530 break;
531 default:
532 jj_la1[23] = jj_gen;
533 jj_consume_token(-1);
534 throw new ParseException();
535 }
536 expression = UnaryExpression();
537 if (operators == null) {
538 operators = new ArrayList ();
539 expressions = new ArrayList ();
540 }
541 operators.add (operator);
542 expressions.add (expression);
543 }
544 if (operators != null) {
545 {if (true) return new BinaryOperatorExpression (startExpression,
546 operators,
547 expressions);}
548 }
549 else {
550 {if (true) return startExpression;}
551 }
552 throw new Error("Missing return statement in function");
553 }
554
555 final public Expression ConditionalExpression() throws ParseException {
556 Expression condition, trueBranch, falseBranch;
557 condition = OrExpression();
558 jj_consume_token(COND);
559 trueBranch = Expression();
560 jj_consume_token(COLON);
561 falseBranch = Expression();
562 {if (true) return new ConditionalExpression(condition, trueBranch, falseBranch);}
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[24] = 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[25] = 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[26] = 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[27] = 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[28] = jj_gen;
691 if (jj_2_2(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[29] = 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[30] = 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[31] = jj_gen;
754 ;
755 }
756 jj_consume_token(RPAREN);
757 {if (true) return new FunctionInvocation(qualifiedName, argumentList);}
758 throw new Error("Missing return statement in function");
759 }
760
761 final public ValueSuffix ValueSuffix() throws ParseException {
762 ValueSuffix suffix;
763 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
764 case DOT:
765 suffix = PropertySuffix();
766 break;
767 case LBRACKET:
768 suffix = ArraySuffix();
769 break;
770 default:
771 jj_la1[32] = jj_gen;
772 jj_consume_token(-1);
773 throw new ParseException();
774 }
775 {if (true) return suffix;}
776 throw new Error("Missing return statement in function");
777 }
778
779 final public PropertySuffix PropertySuffix() throws ParseException {
780 Token t;
781 String property;
782 jj_consume_token(DOT);
783 property = Identifier();
784 {if (true) return new PropertySuffix (property);}
785 throw new Error("Missing return statement in function");
786 }
787
788 final public ArraySuffix ArraySuffix() throws ParseException {
789 Expression index;
790 jj_consume_token(LBRACKET);
791 index = Expression();
792 jj_consume_token(RBRACKET);
793 {if (true) return new ArraySuffix (index);}
794 throw new Error("Missing return statement in function");
795 }
796
797 final public Literal Literal() throws ParseException {
798 Literal ret;
799 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
800 case TRUE:
801 case FALSE:
802 ret = BooleanLiteral();
803 break;
804 case INTEGER_LITERAL:
805 ret = IntegerLiteral();
806 break;
807 case FLOATING_POINT_LITERAL:
808 ret = FloatingPointLiteral();
809 break;
810 case STRING_LITERAL:
811 ret = StringLiteral();
812 break;
813 case NULL:
814 ret = NullLiteral();
815 break;
816 default:
817 jj_la1[33] = jj_gen;
818 jj_consume_token(-1);
819 throw new ParseException();
820 }
821 {if (true) return ret;}
822 throw new Error("Missing return statement in function");
823 }
824
825 final public BooleanLiteral BooleanLiteral() throws ParseException {
826 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
827 case TRUE:
828 jj_consume_token(TRUE);
829 {if (true) return BooleanLiteral.TRUE;}
830 break;
831 case FALSE:
832 jj_consume_token(FALSE);
833 {if (true) return BooleanLiteral.FALSE;}
834 break;
835 default:
836 jj_la1[34] = jj_gen;
837 jj_consume_token(-1);
838 throw new ParseException();
839 }
840 throw new Error("Missing return statement in function");
841 }
842
843 final public StringLiteral StringLiteral() throws ParseException {
844 Token t;
845 t = jj_consume_token(STRING_LITERAL);
846 {if (true) return StringLiteral.fromToken (t.image);}
847 throw new Error("Missing return statement in function");
848 }
849
850 final public IntegerLiteral IntegerLiteral() throws ParseException {
851 Token t;
852 t = jj_consume_token(INTEGER_LITERAL);
853 {if (true) return new IntegerLiteral (t.image);}
854 throw new Error("Missing return statement in function");
855 }
856
857 final public FloatingPointLiteral FloatingPointLiteral() throws ParseException {
858 Token t;
859 t = jj_consume_token(FLOATING_POINT_LITERAL);
860 {if (true) return new FloatingPointLiteral (t.image);}
861 throw new Error("Missing return statement in function");
862 }
863
864 final public NullLiteral NullLiteral() throws ParseException {
865 jj_consume_token(NULL);
866 {if (true) return NullLiteral.SINGLETON;}
867 throw new Error("Missing return statement in function");
868 }
869
870 final public String Identifier() throws ParseException {
871 Token t;
872 t = jj_consume_token(IDENTIFIER);
873 {if (true) return t.image;}
874 throw new Error("Missing return statement in function");
875 }
876
877 final public String QualifiedName() throws ParseException {
878 String prefix = null, localPart = null;
879 if (jj_2_3(2147483647)) {
880 prefix = Identifier();
881 jj_consume_token(COLON);
882 } else {
883 ;
884 }
885 localPar
|
Java API By Example, From Geeks To Geeks.