|
1
2 package com.genimen.djeneric.repository.oql.core;
3
4 import java.io.ByteArrayInputStream  ;
5 import java.io.UnsupportedEncodingException ;
6
7 import com.genimen.djeneric.repository.oql.core.nodes.AndOrNode;
8 import com.genimen.djeneric.repository.oql.core.nodes.ArgumentsNode;
9 import com.genimen.djeneric.repository.oql.core.nodes.BoolNode;
10 import com.genimen.djeneric.repository.oql.core.nodes.BracketNode;
11 import com.genimen.djeneric.repository.oql.core.nodes.CalculatedExpressionNode;
12 import com.genimen.djeneric.repository.oql.core.nodes.CharNode;
13 import com.genimen.djeneric.repository.oql.core.nodes.ExpressionNode;
14 import com.genimen.djeneric.repository.oql.core.nodes.FloatNode;
15 import com.genimen.djeneric.repository.oql.core.nodes.IntegerNode;
16 import com.genimen.djeneric.repository.oql.core.nodes.NullNode;
17 import com.genimen.djeneric.repository.oql.core.nodes.OperatorNode;
18 import com.genimen.djeneric.repository.oql.core.nodes.ParameterNode;
19 import com.genimen.djeneric.repository.oql.core.nodes.PropertyNode;
20 import com.genimen.djeneric.repository.oql.core.nodes.PropertyOrFunctionNode;
21 import com.genimen.djeneric.repository.oql.core.nodes.StringNode;
22 import com.genimen.djeneric.repository.oql.core.nodes.SubExpressionNode;
23 import com.genimen.djeneric.repository.oql.core.util.TreeNormalizer;
24
25 public class DjOqlParserEngineimplements DjOqlParserEngineTreeConstants, DjOqlParserEngineConstants
26 {
27 protected JJTDjOqlParserEngineState jjtree = new JJTDjOqlParserEngineState();
28
29 public DjOqlParserEngine()
30 {
31 }
32
33 public static SimpleNode parseExpression(String src) throws UnsupportedEncodingException , ParseException
34 {
35 ByteArrayInputStream sr = new ByteArrayInputStream (src.getBytes("UTF8"));
36 DjOqlParserEngine parser = new DjOqlParserEngine(sr);
37
38 ExpressionNode tree = parser.buildExpressionTree();
39 TreeNormalizer norm = new TreeNormalizer();
40 SimpleNode root = new SimpleNode(0);
41 root.addChild(tree);
42 norm.normalize(root);
43 return root.getChild(0);
44 }
45
46
49 final public ExpressionNode buildExpressionTree() throws ParseException
50 {
51 ExpressionNode node;
52 node = Expression();
53 jj_consume_token(0);
54 {
55 if (true) return node;
56 }
57 throw new Error ("Missing return statement in function");
58 }
59
60 final public PropertyNode Objectpath() throws ParseException
61 {
62
63 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTOBJECTPATH);
64 boolean jjtc000 = true;
65 jjtree.openNodeScope(jjtn000);
66 Token token;
67 PropertyNode pathNode = (PropertyNode) jjtn000;
68 String rs;
69 try
70 {
71 token = jj_consume_token(IDENTIFIER);
72 pathNode.setLineInfo(token);
73 rs = token.image;
74 label_1 : while (true)
75 {
76 if (jj_2_1(2))
77 {
78 ;
79 }
80 else
81 {
82 break label_1;
83 }
84 jj_consume_token(DOT);
85 token = jj_consume_token(IDENTIFIER);
86 rs += "." + token.image;
87 }
88 jjtree.closeNodeScope(jjtn000, true);
89 jjtc000 = false;
90 pathNode.setPath(rs);
91 {
92 if (true) return pathNode;
93 }
94 }
95 finally
96 {
97 if (jjtc000)
98 {
99 jjtree.closeNodeScope(jjtn000, true);
100 }
101 }
102 throw new Error ("Missing return statement in function");
103 }
104
105 final public ExpressionNode Expression() throws ParseException
106 {
107
108 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTEXPRESSION);
109 boolean jjtc000 = true;
110 jjtree.openNodeScope(jjtn000);
111 ExpressionNode expressionNode = (ExpressionNode) jjtn000;
112 SubExpressionNode subExpressionNode;
113 try
114 {
115 subExpressionNode = SubExpression();
116 expressionNode.setLineInfo(subExpressionNode);
117 label_2 : while (true)
118 {
119 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
120 {
121 case SC_OR2 :
122 case SC_AND2 :
123 case SC_OR :
124 case SC_AND :
125 ;
126 break;
127 default :
128 jj_la1[0] = jj_gen;
129 break label_2;
130 }
131 AndOr();
132 SubExpression();
133 }
134 jjtree.closeNodeScope(jjtn000, true);
135 jjtc000 = false;
136 {
137 if (true) return expressionNode;
138 }
139 }
140 catch (Throwable jjte000)
141 {
142 if (jjtc000)
143 {
144 jjtree.clearNodeScope(jjtn000);
145 jjtc000 = false;
146 }
147 else
148 {
149 jjtree.popNode();
150 }
151 if (jjte000 instanceof RuntimeException )
152 {
153 {
154 if (true) throw (RuntimeException ) jjte000;
155 }
156 }
157 if (jjte000 instanceof ParseException)
158 {
159 {
160 if (true) throw (ParseException) jjte000;
161 }
162 }
163 {
164 if (true) throw (Error ) jjte000;
165 }
166 }
167 finally
168 {
169 if (jjtc000)
170 {
171 jjtree.closeNodeScope(jjtn000, true);
172 }
173 }
174 throw new Error ("Missing return statement in function");
175 }
176
177 final public AndOrNode AndOr() throws ParseException
178 {
179
180 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTANDOR);
181 boolean jjtc000 = true;
182 jjtree.openNodeScope(jjtn000);
183 Token token;
184 AndOrNode node = (AndOrNode) jjtn000;
185 try
186 {
187 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
188 {
189 case SC_OR :
190 token = jj_consume_token(SC_OR);
191 break;
192 case SC_AND :
193 token = jj_consume_token(SC_AND);
194 break;
195 case SC_OR2 :
196 token = jj_consume_token(SC_OR2);
197 break;
198 case SC_AND2 :
199 token = jj_consume_token(SC_AND2);
200 break;
201 default :
202 jj_la1[1] = jj_gen;
203 jj_consume_token(-1);
204 throw new ParseException();
205 }
206 jjtree.closeNodeScope(jjtn000, true);
207 jjtc000 = false;
208 node.setOperator(token.image.toString());
209 {
210 if (true) return node;
211 }
212 }
213 finally
214 {
215 if (jjtc000)
216 {
217 jjtree.closeNodeScope(jjtn000, true);
218 }
219 }
220 throw new Error ("Missing return statement in function");
221 }
222
223 final public SubExpressionNode SubExpression() throws ParseException
224 {
225
226 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTSUBEXPRESSION);
227 boolean jjtc000 = true;
228 jjtree.openNodeScope(jjtn000);
229 Token token = null;
230 SubExpressionNode subExpressionNode = (SubExpressionNode) jjtn000;
231 CalculatedExpressionNode calcNode;
232 Token not = null;
233 try
234 {
235 calcNode = CalculatedExpression();
236 subExpressionNode.setLineInfo(calcNode);
237 label_3 : while (true)
238 {
239 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
240 {
241 case LIKE :
242 case IS :
243 case GT :
244 case LT :
245 case EQ :
246 case EQ2 :
247 case LE :
248 case GE :
249 case NE :
250 ;
251 break;
252 default :
253 jj_la1[2] = jj_gen;
254 break label_3;
255 }
256 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
257 {
258 case EQ :
259 token = jj_consume_token(EQ);
260 break;
261 case NE :
262 token = jj_consume_token(NE);
263 break;
264 case LIKE :
265 token = jj_consume_token(LIKE);
266 break;
267 case EQ2 :
268 token = jj_consume_token(EQ2);
269 break;
270 case LT :
271 token = jj_consume_token(LT);
272 break;
273 case GT :
274 token = jj_consume_token(GT);
275 break;
276 case IS :
277 token = jj_consume_token(IS);
278 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
279 {
280 case NOT :
281 not = jj_consume_token(NOT);
282 break;
283 default :
284 jj_la1[3] = jj_gen;
285 ;
286 }
287 break;
288 case LE :
289 token = jj_consume_token(LE);
290 break;
291 case GE :
292 token = jj_consume_token(GE);
293 break;
294 default :
295 jj_la1[4] = jj_gen;
296 jj_consume_token(-1);
297 throw new ParseException();
298 }
299 CalculatedExpression();
300 }
301 jjtree.closeNodeScope(jjtn000, true);
302 jjtc000 = false;
303 if (token != null) subExpressionNode.setOperator(token.image);
304 if (not != null) subExpressionNode.setNegated(true);
305 {
306 if (true) return subExpressionNode;
307 }
308 }
309 catch (Throwable jjte000)
310 {
311 if (jjtc000)
312 {
313 jjtree.clearNodeScope(jjtn000);
314 jjtc000 = false;
315 }
316 else
317 {
318 jjtree.popNode();
319 }
320 if (jjte000 instanceof RuntimeException )
321 {
322 {
323 if (true) throw (RuntimeException ) jjte000;
324 }
325 }
326 if (jjte000 instanceof ParseException)
327 {
328 {
329 if (true) throw (ParseException) jjte000;
330 }
331 }
332 {
333 if (true) throw (Error ) jjte000;
334 }
335 }
336 finally
337 {
338 if (jjtc000)
339 {
340 jjtree.closeNodeScope(jjtn000, true);
341 }
342 }
343 throw new Error ("Missing return statement in function");
344 }
345
346 final public CalculatedExpressionNode CalculatedExpression() throws ParseException
347 {
348
349 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTCALCULATEDEXPRESSION);
350 boolean jjtc000 = true;
351 jjtree.openNodeScope(jjtn000);
352 CalculatedExpressionNode expressionNode = (CalculatedExpressionNode) jjtn000;
353 SimpleNode primNode;
354 try
355 {
356 primNode = PrimaryExpression();
357 expressionNode.setLineInfo(primNode);
358 label_4 : while (true)
359 {
360 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
361 {
362 case DOT :
363 case PLUS :
364 case MINUS :
365 case STAR :
366 case SLASH :
367 case 51 :
368 ;
369 break;
370 default :
371 jj_la1[5] = jj_gen;
372 break label_4;
373 }
374 Operator();
375 PrimaryExpression();
376 }
377 jjtree.closeNodeScope(jjtn000, true);
378 jjtc000 = false;
379 {
380 if (true) return expressionNode;
381 }
382 }
383 catch (Throwable jjte000)
384 {
385 if (jjtc000)
386 {
387 jjtree.clearNodeScope(jjtn000);
388 jjtc000 = false;
389 }
390 else
391 {
392 jjtree.popNode();
393 }
394 if (jjte000 instanceof RuntimeException )
395 {
396 {
397 if (true) throw (RuntimeException ) jjte000;
398 }
399 }
400 if (jjte000 instanceof ParseException)
401 {
402 {
403 if (true) throw (ParseException) jjte000;
404 }
405 }
406 {
407 if (true) throw (Error ) jjte000;
408 }
409 }
410 finally
411 {
412 if (jjtc000)
413 {
414 jjtree.closeNodeScope(jjtn000, true);
415 }
416 }
417 throw new Error ("Missing return statement in function");
418 }
419
420 final public void Operator() throws ParseException
421 {
422
423 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTOPERATOR);
424 boolean jjtc000 = true;
425 jjtree.openNodeScope(jjtn000);
426 OperatorNode opNode = (OperatorNode) jjtn000;
427 try
428 {
429 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
430 {
431 case PLUS :
432 jj_consume_token(PLUS);
433 opNode.setOperator("+");
434 break;
435 case MINUS :
436 jj_consume_token(MINUS);
437 opNode.setOperator("-");
438 break;
439 case STAR :
440 jj_consume_token(STAR);
441 opNode.setOperator("*");
442 break;
443 case SLASH :
444 jj_consume_token(SLASH);
445 opNode.setOperator("/");
446 break;
447 case 51 :
448 jj_consume_token(51);
449 opNode.setOperator("%");
450 break;
451 case DOT :
452 jj_consume_token(DOT);
453 opNode.setOperator(".");
454 break;
455 default :
456 jj_la1[6] = jj_gen;
457 jj_consume_token(-1);
458 throw new ParseException();
459 }
460 jjtree.closeNodeScope(jjtn000, true);
461 jjtc000 = false;
462 opNode.setLineInfo(token);
463 }
464 finally
465 {
466 if (jjtc000)
467 {
468 jjtree.closeNodeScope(jjtn000, true);
469 }
470 }
471 }
472
473 final public SimpleNode PrimaryExpression() throws ParseException
474 {
475 SimpleNode subNode;
476 if (jj_2_3(3))
477 {
478 subNode = boolLiteral();
479 }
480 else
481 {
482 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
483 {
484 case COLON :
485 subNode = Parameter();
486 break;
487 case IDENTIFIER :
488 case BANG :
489 subNode = PropertyOrFunction();
490 break;
491 default :
492 jj_la1[7] = jj_gen;
493 if (jj_2_4(2))
494 {
495 subNode = integerLiteral();
496 }
497 else
498 {
499 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
500 {
501 case FLOATING_POINT_LITERAL :
502 case MINUS :
503 subNode = floatLiteral();
504 break;
505 case CHARACTER_LITERAL :
506 subNode = charLiteral();
507 break;
508 case STRING_LITERAL :
509 subNode = stringLiteral();
510 break;
511 case NULL :
512 subNode = nullLiteral();
513 break;
514 case LPAREN :
515 BracketOpen();
516 subNode = Expression();
517 BracketClose();
518 label_5 : while (true)
519 {
520 if (jj_2_2(2))
521 {
522 ;
523 }
524 else
525 {
526 break label_5;
527 }
528 Arguments();
529 }
530 break;
531 default :
532 jj_la1[8] = jj_gen;
533 jj_consume_token(-1);
534 throw new ParseException();
535 }
536 }
537 }
538 }
539 {
540 if (true) return subNode;
541 }
542 throw new Error ("Missing return statement in function");
543 }
544
545 final public BracketNode BracketOpen() throws ParseException
546 {
547
548 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTBRACKETOPEN);
549 boolean jjtc000 = true;
550 jjtree.openNodeScope(jjtn000);
551 BracketNode bnode = (BracketNode) jjtn000;
552 Token token;
553 try
554 {
555 token = jj_consume_token(LPAREN);
556 jjtree.closeNodeScope(jjtn000, true);
557 jjtc000 = false;
558 bnode.setLineInfo(token);
559 bnode.setBracket("(");
560 {
561 if (true) return bnode;
562 }
563 }
564 finally
565 {
566 if (jjtc000)
567 {
568 jjtree.closeNodeScope(jjtn000, true);
569 }
570 }
571 throw new Error ("Missing return statement in function");
572 }
573
574 final public BracketNode BracketClose() throws ParseException
575 {
576
577 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTBRACKETCLOSE);
578 boolean jjtc000 = true;
579 jjtree.openNodeScope(jjtn000);
580 BracketNode bnode = (BracketNode) jjtn000;
581 Token token;
582 try
583 {
584 token = jj_consume_token(RPAREN);
585 jjtree.closeNodeScope(jjtn000, true);
586 jjtc000 = false;
587 bnode.setLineInfo(token);
588 bnode.setBracket(")");
589 {
590 if (true) return bnode;
591 }
592 }
593 finally
594 {
595 if (jjtc000)
596 {
597 jjtree.closeNodeScope(jjtn000, true);
598 }
599 }
600 throw new Error ("Missing return statement in function");
601 }
602
603 final public PropertyOrFunctionNode PropertyOrFunction() throws ParseException
604 {
605
606 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTPROPERTYORFUNCTION);
607 boolean jjtc000 = true;
608 jjtree.openNodeScope(jjtn000);
609 PropertyOrFunctionNode pfnode = (PropertyOrFunctionNode) jjtn000;
610 PropertyNode path;
611 Token not = null;
612 try
613 {
614 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
615 {
616 case BANG :
617 not = jj_consume_token(BANG);
618 break;
619 default :
620 jj_la1[9] = jj_gen;
621 ;
622 }
623 path = Objectpath();
624 pfnode.setLineInfo(path);
625 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
626 {
627 case LPAREN :
628 BracketOpen();
629 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
630 {
631 case INTEGER_LITERAL :
632 case FLOATING_POINT_LITERAL :
633 case CHARACTER_LITERAL :
634 case STRING_LITERAL :
635 case NULL :
636 case TRUE :
637 case FALSE :
638 case IDENTIFIER :
639 case LPAREN :
640 case BANG :
641 case COLON :
642 case MINUS :
643 Expression();
644 label_6 : while (true)
645 {
646 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
647 {
648 case COMMA :
649 ;
650 break;
651 default :
652 jj_la1[10] = jj_gen;
653 break label_6;
654 }
655 jj_consume_token(COMMA);
656 Expression();
657 }
658 break;
659 default :
660 jj_la1[11] = jj_gen;
661 ;
662 }
663 BracketClose();
664 pfnode.setFunction(true);
665 break;
666 default :
667 jj_la1[12] = jj_gen;
668 ;
669 }
670 jjtree.closeNodeScope(jjtn000, true);
671 jjtc000 = false;
672 if (not != null) path.setNegated(true);
673 {
674 if (true) return pfnode;
675 }
676 }
677 catch (Throwable jjte000)
678 {
679 if (jjtc000)
680 {
681 jjtree.clearNodeScope(jjtn000);
682 jjtc000 = false;
683 }
684 else
685 {
686 jjtree.popNode();
687 }
688 if (jjte000 instanceof RuntimeException )
689 {
690 {
691 if (true) throw (RuntimeException ) jjte000;
692 }
693 }
694 if (jjte000 instanceof ParseException)
695 {
696 {
697 if (true) throw (ParseException) jjte000;
698 }
699 }
700 {
701 if (true) throw (Error ) jjte000;
702 }
703 }
704 finally
705 {
706 if (jjtc000)
707 {
708 jjtree.closeNodeScope(jjtn000, true);
709 }
710 }
711 throw new Error ("Missing return statement in function");
712 }
713
714 final public ParameterNode Parameter() throws ParseException
715 {
716
717 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTPARAMETER);
718 boolean jjtc000 = true;
719 jjtree.openNodeScope(jjtn000);
720 ParameterNode paramNode = (ParameterNode) jjtn000;
721 Token token;
722 try
723 {
724 jj_consume_token(COLON);
725 token = jj_consume_token(IDENTIFIER);
726 jjtree.closeNodeScope(jjtn000, true);
727 jjtc000 = false;
728 paramNode.setParamName(token.image);
729 {
730 if (true) return paramNode;
731 }
732 }
733 finally
734 {
735 if (jjtc000)
736 {
737 jjtree.closeNodeScope(jjtn000, true);
738 }
739 }
740 throw new Error ("Missing return statement in function");
741 }
742
743 final public PropertyOrFunctionNode FunctionCall() throws ParseException
744 {
745
746 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTFUNCTIONCALL);
747 boolean jjtc000 = true;
748 jjtree.openNodeScope(jjtn000);
749 PropertyOrFunctionNode pfnode = (PropertyOrFunctionNode) jjtn000;
750 PropertyNode path;
751 try
752 {
753 path = Objectpath();
754 pfnode.setLineInfo(path);
755 BracketOpen();
756 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
757 {
758 case INTEGER_LITERAL :
759 case FLOATING_POINT_LITERAL :
760 case CHARACTER_LITERAL :
761 case STRING_LITERAL :
762 case NULL :
763 case TRUE :
764 case FALSE :
765 case IDENTIFIER :
766 case LPAREN :
767 case BANG :
768 case COLON :
769 case MINUS :
770 Expression();
771 label_7 : while (true)
772 {
773 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
774 {
775 case COMMA :
776 ;
777 break;
778 default :
779 jj_la1[13] = jj_gen;
780 break label_7;
781 }
782 jj_consume_token(COMMA);
783 Expression();
784 }
785 break;
786 default :
787 jj_la1[14] = jj_gen;
788 ;
789 }
790 BracketClose();
791 jj_consume_token(52);
792 jjtree.closeNodeScope(jjtn000, true);
793 jjtc000 = false;
794 pfnode.setFunction(true);
795 {
796 if (true) return pfnode;
797 }
798 }
799 catch (Throwable jjte000)
800 {
801 if (jjtc000)
802 {
803 jjtree.clearNodeScope(jjtn000);
804 jjtc000 = false;
805 }
806 else
807 {
808 jjtree.popNode();
809 }
810 if (jjte000 instanceof RuntimeException )
811 {
812 {
813 if (true) throw (RuntimeException ) jjte000;
814 }
815 }
816 if (jjte000 instanceof ParseException)
817 {
818 {
819 if (true) throw (ParseException) jjte000;
820 }
821 }
822 {
823 if (true) throw (Error ) jjte000;
824 }
825 }
826 finally
827 {
828 if (jjtc000)
829 {
830 jjtree.closeNodeScope(jjtn000, true);
831 }
832 }
833 throw new Error ("Missing return statement in function");
834 }
835
836 final public IntegerNode integerLiteral() throws ParseException
837 {
838
839 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTINTEGERLITERAL);
840 boolean jjtc000 = true;
841 jjtree.openNodeScope(jjtn000);
842 Token token = null;
843 Token sign = null;
844 IntegerNode node = (IntegerNode) jjtn000;
845 try
846 {
847 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
848 {
849 case MINUS :
850 sign = jj_consume_token(MINUS);
851 break;
852 default :
853 jj_la1[15] = jj_gen;
854 ;
855 }
856 token = jj_consume_token(INTEGER_LITERAL);
857 node.setLineInfo(token);
858 try
859
|
Java API By Example, From Geeks To Geeks.