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