|
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 :
860 ElseStatement();
861 break;
862 case EDIT :
863 EditStatement();
864 break;
865 case CUSTOMPANEL :
866 CustomPanelStatement();
867 break;
868 case JAVA :
869 JavaStatement();
870 break;
871 case CHOOSE :
872 Choose();
873 break;
874 case ACTION :
875 Action();
876 break;
877 default :
878 jj_la1[18] = jj_gen;
879 jj_consume_token(-1);
880 throw new ParseException();
881 }
882 }
883 }
884 }
885 }
886
887 final public void SubScriptStatement() throws ParseException
888 {
889
890 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTSUBSCRIPTSTATEMENT);
891 boolean jjtc000 = true;
892 jjtree.openNodeScope(jjtn000);
893 Token token;
894 SubScriptStatementNode subScriptStatementNode = (SubScriptStatementNode) jjtn000;
895 try
896 {
897 token = jj_consume_token(SUBSCRIPT);
898 subScriptStatementNode.setLineInfo(token);
899 ActionList();
900 jj_consume_token(SEMICOLON);
901 }
902 catch (Throwable jjte000)
903 {
904 if (jjtc000)
905 {
906 jjtree.clearNodeScope(jjtn000);
907 jjtc000 = false;
908 }
909 else
910 {
911 jjtree.popNode();
912 }
913 if (jjte000 instanceof RuntimeException )
914 {
915 {
916 if (true) throw (RuntimeException ) jjte000;
917 }
918 }
919 if (jjte000 instanceof ParseException)
920 {
921 {
922 if (true) throw (ParseException) jjte000;
923 }
924 }
925 {
926 if (true) throw (Error ) jjte000;
927 }
928 }
929 finally
930 {
931 if (jjtc000)
932 {
933 jjtree.closeNodeScope(jjtn000, true);
934 }
935 }
936 }
937
938 final public void Choose() throws ParseException
939 {
940
941 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTCHOOSE);
942 boolean jjtc000 = true;
943 jjtree.openNodeScope(jjtn000);
944 Token token;
945 ChooseNode chooseNode = (ChooseNode) jjtn000;
946 try
947 {
948 token = jj_consume_token(CHOOSE);
949 chooseNode.setLineInfo(token);
950 token = jj_consume_token(IDENTIFIER);
951 chooseNode.setObjectType(token.image);
952 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
953 {
954 case LPAREN :
955 jj_consume_token(LPAREN);
956 OqlFilterNode();
957 jj_consume_token(RPAREN);
958 break;
959 default :
960 jj_la1[19] = jj_gen;
961 ;
962 }
963 jj_consume_token(INTO);
964 token = jj_consume_token(IDENTIFIER);
965 chooseNode.setResultVariable(token.image);
966 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
967 {
968 case JAVA :
969 jj_consume_token(JAVA);
970 token = jj_consume_token(STRING_LITERAL);
971 chooseNode.setCustomChooserClass(token.image);
972 break;
973 default :
974 jj_la1[20] = jj_gen;
975 ;
976 }
977 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
978 {
979 case EVENTS :
980 jj_consume_token(EVENTS);
981 jj_consume_token(LBRACE);
982 label_10 : while (true)
983 {
984 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
985 {
986 case IDENTIFIER :
987 ;
988 break;
989 default :
990 jj_la1[21] = jj_gen;
991 break label_10;
992 }
993 EventDefinition();
994 }
995 jj_consume_token(RBRACE);
996 break;
997 default :
998 jj_la1[22] = jj_gen;
999 ;
1000 }
1001 jj_consume_token(SEMICOLON);
1002 }
1003 catch (Throwable jjte000)
1004 {
1005 if (jjtc000)
1006 {
1007 jjtree.clearNodeScope(jjtn000);
1008 jjtc000 = false;
1009 }
1010 else
1011 {
1012 jjtree.popNode();
1013 }
1014 if (jjte000 instanceof RuntimeException )
1015 {
1016 {
1017 if (true) throw (RuntimeException ) jjte000;
1018 }
1019 }
1020 if (jjte000 instanceof ParseException)
1021 {
1022 {
1023 if (true) throw (ParseException) jjte000;
1024 }
1025 }
1026 {
1027 if (true) throw (Error ) jjte000;
1028 }
1029 }
1030 finally
1031 {
1032 if (jjtc000)
1033 {
1034 jjtree.closeNodeScope(jjtn000, true);
1035 }
1036 }
1037 }
1038
1039 final public void OqlFilterNode() throws ParseException
1040 {
1041
1042 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTOQLFILTERNODE);
1043 boolean jjtc000 = true;
1044 jjtree.openNodeScope(jjtn000);
1045 ExpressionNode expr;
1046 OqlFilterNode filterNode = (OqlFilterNode) jjtn000;
1047 try
1048 {
1049 expr = Expression();
1050 jjtree.closeNodeScope(jjtn000, true);
1051 jjtc000 = false;
1052 filterNode.setLineInfo(expr);
1053 }
1054 catch (Throwable jjte000)
1055 {
1056 if (jjtc000)
1057 {
1058 jjtree.clearNodeScope(jjtn000);
1059 jjtc000 = false;
1060 }
1061 else
1062 {
1063 jjtree.popNode();
1064 }
1065 if (jjte000 instanceof RuntimeException )
1066 {
1067 {
1068 if (true) throw (RuntimeException ) jjte000;
1069 }
1070 }
1071 if (jjte000 instanceof ParseException)
1072 {
1073 {
1074 if (true) throw (ParseException) jjte000;
1075 }
1076 }
1077 {
1078 if (true) throw (Error ) jjte000;
1079 }
1080 }
1081 finally
1082 {
1083 if (jjtc000)
1084 {
1085 jjtree.closeNodeScope(jjtn000, true);
1086 }
1087 }
1088 }
1089
1090 final public void TerminateStatement() throws ParseException
1091 {
1092
1093 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTTERMINATESTATEMENT);
1094 boolean jjtc000 = true;
1095 jjtree.openNodeScope(jjtn000);
1096 Token token;
1097 TerminateStatementNode terminateNode = (TerminateStatementNode) jjtn000;
1098 try
1099 {
1100 token = jj_consume_token(TERMINATE);
1101 terminateNode.setLineInfo(token);
1102 jj_consume_token(SCRIPT);
1103 jj_consume_token(SEMICOLON);
1104 }
1105 finally
1106 {
1107 if (jjtc000)
1108 {
1109 jjtree.closeNodeScope(jjtn000, true);
1110 }
1111 }
1112 }
1113
1114 final public void Dispatch() throws ParseException
1115 {
1116
1117 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTDISPATCH);
1118 boolean jjtc000 = true;
1119 jjtree.openNodeScope(jjtn000);
1120 Token token;
1121 DispatchNode dispatchNode = (DispatchNode) jjtn000;
1122 try
1123 {
1124 token = jj_consume_token(DISPATCH);
1125 dispatchNode.setLineInfo(token);
1126 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1127 {
1128 case JAVA :
1129 jj_consume_token(JAVA);
1130 token = jj_consume_token(STRING_LITERAL);
1131 dispatchNode.setCustomDispatcherClass(token.image);
1132 break;
1133 default :
1134 jj_la1[23] = jj_gen;
1135 ;
1136 }
1137 jj_consume_token(EVENTS);
1138 jj_consume_token(LBRACE);
1139 label_11 : while (true)
1140 {
1141 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1142 {
1143 case IDENTIFIER :
1144 ;
1145 break;
1146 default :
1147 jj_la1[24] = jj_gen;
1148 break label_11;
1149 }
1150 EventDefinition();
1151 }
1152 jj_consume_token(RBRACE);
1153 jj_consume_token(SEMICOLON);
1154 }
1155 catch (Throwable jjte000)
1156 {
1157 if (jjtc000)
1158 {
1159 jjtree.clearNodeScope(jjtn000);
1160 jjtc000 = false;
1161 }
1162 else
1163 {
1164 jjtree.popNode();
1165 }
1166 if (jjte000 instanceof RuntimeException )
1167 {
1168 {
1169 if (true) throw (RuntimeException ) jjte000;
1170 }
1171 }
1172 if (jjte000 instanceof ParseException)
1173 {
1174 {
1175 if (true) throw (ParseException) jjte000;
1176 }
1177 }
1178 {
1179 if (true) throw (Error ) jjte000;
1180 }
1181 }
1182 finally
1183 {
1184 if (jjtc000)
1185 {
1186 jjtree.closeNodeScope(jjtn000, true);
1187 }
1188 }
1189 }
1190
1191 final public void TransactionalStatement() throws ParseException
1192 {
1193
1194 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTTRANSACTIONALSTATEMENT);
1195 boolean jjtc000 = true;
1196 jjtree.openNodeScope(jjtn000);
1197 Token token;
1198 TransactionalStatementNode transactionalStatementNode = (TransactionalStatementNode) jjtn000;
1199 try
1200 {
1201 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1202 {
1203 case COMMIT :
1204 token = jj_consume_token(COMMIT);
1205 break;
1206 case ROLLBACK :
1207 token = jj_consume_token(ROLLBACK);
1208 break;
1209 default :
1210 jj_la1[25] = jj_gen;
1211 jj_consume_token(-1);
1212 throw new ParseException();
1213 }
1214 jj_consume_token(SEMICOLON);
1215 jjtree.closeNodeScope(jjtn000, true);
1216 jjtc000 = false;
1217 transactionalStatementNode.setLineInfo(token);
1218 transactionalStatementNode.setCommand(token.image);
1219 }
1220 finally
1221 {
1222 if (jjtc000)
1223 {
1224 jjtree.closeNodeScope(jjtn000, true);
1225 }
1226 }
1227 }
1228
1229 final public void TraceStatement() throws ParseException
1230 {
1231
1232 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTTRACESTATEMENT);
1233 boolean jjtc000 = true;
1234 jjtree.openNodeScope(jjtn000);
1235 Token token;
1236 TraceStatementNode traceStatementNode = (TraceStatementNode) jjtn000;
1237 try
1238 {
1239 token = jj_consume_token(TRACE);
1240 traceStatementNode.setLineInfo(token);
1241 jj_consume_token(LPAREN);
1242 CalculatedExpression();
1243 jj_consume_token(RPAREN);
1244 jj_consume_token(SEMICOLON);
1245 }
1246 catch (Throwable jjte000)
1247 {
1248 if (jjtc000)
1249 {
1250 jjtree.clearNodeScope(jjtn000);
1251 jjtc000 = false;
1252 }
1253 else
1254 {
1255 jjtree.popNode();
1256 }
1257 if (jjte000 instanceof RuntimeException )
1258 {
1259 {
1260 if (true) throw (RuntimeException ) jjte000;
1261 }
1262 }
1263 if (jjte000 instanceof ParseException)
1264 {
1265 {
1266 if (true) throw (ParseException) jjte000;
1267 }
1268 }
1269 {
1270 if (true) throw (Error ) jjte000;
1271 }
1272 }
1273 finally
1274 {
1275 if (jjtc000)
1276 {
1277 jjtree.closeNodeScope(jjtn000, true);
1278 }
1279 }
1280 }
1281
1282 final public void FailStatement() throws ParseException
1283 {
1284
1285 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTFAILSTATEMENT);
1286 boolean jjtc000 = true;
1287 jjtree.openNodeScope(jjtn000);
1288 Token token;
1289 FailStatementNode failStatementNode = (FailStatementNode) jjtn000;
1290 try
1291 {
1292 token = jj_consume_token(FAIL);
1293 failStatementNode.setLineInfo(token);
1294 jj_consume_token(LPAREN);
1295 CalculatedExpression();
1296 jj_consume_token(RPAREN);
1297 jj_consume_token(SEMICOLON);
1298 }
1299 catch (Throwable jjte000)
1300 {
1301 if (jjtc000)
1302 {
1303 jjtree.clearNodeScope(jjtn000);
1304 jjtc000 = false;
1305 }
1306 else
1307 {
1308 jjtree.popNode();
1309 }
1310 if (jjte000 instanceof RuntimeException )
1311 {
1312 {
1313 if (true) throw (RuntimeException ) jjte000;
1314 }
1315 }
1316 if (jjte000 instanceof ParseException)
1317 {
1318 {
1319 if (true) throw (ParseException) jjte000;
1320 }
1321 }
1322 {
1323 if (true) throw (Error ) jjte000;
1324 }
1325 }
1326 finally
1327 {
1328 if (jjtc000)
1329 {
1330 jjtree.closeNodeScope(jjtn000, true);
1331 }
1332 }
1333 }
1334
1335 final public void AssignmentStatement() throws ParseException
1336 {
1337
1338 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTASSIGNMENTSTATEMENT);
1339 boolean jjtc000 = true;
1340 jjtree.openNodeScope(jjtn000);
1341 AssignmentStatementNode assignmentStatementNode = (AssignmentStatementNode) jjtn000;
1342 PropertyPathNode pfnode;
1343 try
1344 {
1345 pfnode = Objectpath();
1346 assignmentStatementNode.setLineInfo(pfnode);
1347 jj_consume_token(ASSIGN);
1348 CalculatedExpression();
1349 jj_consume_token(SEMICOLON);
1350 }
1351 catch (Throwable jjte000)
1352 {
1353 if (jjtc000)
1354 {
1355 jjtree.clearNodeScope(jjtn000);
1356 jjtc000 = false;
1357 }
1358 else
1359 {
1360 jjtree.popNode();
1361 }
1362 if (jjte000 instanceof RuntimeException )
1363 {
1364 {
1365 if (true) throw (RuntimeException ) jjte000;
1366 }
1367 }
1368 if (jjte000 instanceof ParseException)
1369 {
1370 {
1371 if (true) throw (ParseException) jjte000;
1372 }
1373 }
1374 {
1375 if (true) throw (Error ) jjte000;
1376 }
1377 }
1378 finally
1379 {
1380 if (jjtc000)
1381 {
1382 jjtree.closeNodeScope(jjtn000, true);
1383 }
1384 }
1385 }
1386
1387 final public JavaStatementNode JavaStatement() throws ParseException
1388 {
1389
1390 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTJAVASTATEMENT);
1391 boolean jjtc000 = true;
1392 jjtree.openNodeScope(jjtn000);
1393 Token token;
1394 JavaStatementNode javaStatementNode = (JavaStatementNode) jjtn000;
1395 try
1396 {
1397 jj_consume_token(JAVA);
1398 token = jj_consume_token(STRING_LITERAL);
1399 javaStatementNode.setLineInfo(token);
1400 javaStatementNode.setTypeName(token.image);
1401 token = jj_consume_token(IDENTIFIER);
1402 javaStatementNode.setVariableName(token.image);
1403 jj_consume_token(SEMICOLON);
1404 jjtree.closeNodeScope(jjtn000, true);
1405 jjtc000 = false;
1406 {
1407 if (true) return javaStatementNode;
1408 }
1409 }
1410 finally
1411 {
1412 if (jjtc000)
1413 {
1414 jjtree.closeNodeScope(jjtn000, true);
1415 }
1416 }
1417 throw new Error ("Missing return statement in function");
1418 }
1419
1420 final public void DeleteStatement() throws ParseException
1421 {
1422
1423 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTDELETESTATEMENT);
1424 boolean jjtc000 = true;
1425 jjtree.openNodeScope(jjtn000);
1426 Token token;
1427 DeleteStatementNode deleteStatementNode = (DeleteStatementNode) jjtn000;
1428 try
1429 {
1430 token = jj_consume_token(DELETE);
1431 deleteStatementNode.setLineInfo(token);
1432 Objectpath();
1433 jj_consume_token(SEMICOLON);
1434 }
1435 catch (Throwable jjte000)
1436 {
1437 if (jjtc000)
1438 {
1439 jjtree.clearNodeScope(jjtn000);
1440 jjtc000 = false;
1441 }
1442 else
1443 {
1444 jjtree.popNode();
1445 }
1446 if (jjte000 instanceof RuntimeException )
1447 {
1448 {
1449 if (true) throw (RuntimeException ) jjte000;
1450 }
1451 }
1452 if (jjte000 instanceof ParseException)
1453 {
1454 {
1455 if (true) throw (ParseException) jjte000;
1456 }
1457 }
1458 {
1459 if (true) throw (Error ) jjte000;
1460 }
1461 }
1462 finally
1463 {
1464 if (jjtc000)
1465 {
1466 jjtree.closeNodeScope(jjtn000, true);
1467 }
1468 }
1469 }
1470
1471 final public DeclarationNode Declaration() throws ParseException
1472 {
1473
1474 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTDECLARATION);
1475 boolean jjtc000 = true;
1476 jjtree.openNodeScope(jjtn000);
1477 Token token;
1478 DeclarationNode declarationNode = (DeclarationNode) jjtn000;
1479 try
1480 {
1481 token = jj_consume_token(IDENTIFIER);
1482 declarationNode.setLineInfo(token);
1483 declarationNode.setTypeName(token.image);
1484 token = jj_consume_token(IDENTIFIER);
1485 declarationNode.setVariableName(token.image);
1486 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1487 {
1488 case ASSIGN :
1489 jj_consume_token(ASSIGN);
1490 CalculatedExpression();
1491 break;
1492 default :
1493 jj_la1[26] = jj_gen;
1494 ;
1495 }
1496 jj_consume_token(SEMICOLON);
1497 jjtree.closeNodeScope(jjtn000, true);
1498 jjtc000 = false;
1499 {
1500 if (true) return declarationNode;
1501 }
1502 }
1503 catch (Throwable jjte000)
1504 {
1505 if (jjtc000)
1506 {
1507 jjtree.clearNodeScope(jjtn000);
1508 jjtc000 = false;
1509 }
1510 else
1511 {
1512 jjtree.popNode();
1513 }
1514 if (jjte000 instanceof RuntimeException )
1515 {
1516 {
1517 if (true) throw (RuntimeException ) jjte000;
1518 }
1519 }
1520 if (jjte000 instanceof ParseException)
1521 {
1522 {
1523 if (true) throw (ParseException) jjte000;
1524 }
1525 }
1526 {
1527 if (true) throw (Error ) jjte000;
1528 }
1529 }
1530 finally
1531 {
1532 if (jjtc000)
1533 {
1534 jjtree.closeNodeScope(jjtn000, true);
1535 }
1536 }
1537 throw new Error ("Missing return statement in function");
1538 }
1539
1540 final public void EditStatement() throws ParseException
1541 {
1542
1543 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTEDITSTATEMENT);
1544 boolean jjtc000 = true;
1545 jjtree.openNodeScope(jjtn000);
1546 Token token;
1547 EditStatementNode stmtNode = (EditStatementNode) jjtn000;
1548 try
1549 {
1550 token = jj_consume_token(EDIT);
1551 stmtNode.setLineInfo(token);
1552 token = jj_consume_token(IDENTIFIER);
1553 stmtNode.setEditorName(token.image);
1554 jj_consume_token(LPAREN);
1555 Objectpath();
1556 jj_consume_token(RPAREN);
1557 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1558 {
1559 case EVENTS :
1560 jj_consume_token(EVENTS);
1561 jj_consume_token(LBRACE);
1562 label_12 : while (true)
1563 {
1564 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1565 {
1566 case IDENTIFIER :
1567 ;
1568 break;
1569 default :
1570 jj_la1[27] = jj_gen;
1571 break label_12;
1572 }
1573 EventDefinition();
1574 }
1575 jj_consume_token(RBRACE);
1576 break;
1577 default :
1578 jj_la1[28] = jj_gen;
1579 ;
1580 }
1581 jj_consume_token(SEMICOLON);
1582 }
1583 catch (Throwable jjte000)
1584 {
1585 if (jjtc000)
1586 {
1587 jjtree.clearNodeScope(jjtn000);
1588 jjtc000 = false;
1589 }
1590 else
1591 {
1592 jjtree.popNode();
1593 }
1594 if (jjte000 instanceof RuntimeException )
1595 {
1596 {
1597 if (true) throw (RuntimeException ) jjte000;
1598 }
1599 }
1600 if (jjte000 instanceof ParseException)
1601 {
1602 {
1603 if (true) throw (ParseException) jjte000;
1604 }
1605 }
1606 {
1607 if (true) throw (Error ) jjte000;
1608 }
1609 }
1610 finally
1611 {
1612 if (jjtc000)
1613 {
1614 jjtree.closeNodeScope(jjtn000, true);
1615 }
1616 }
1617 }
1618
1619 final public void CustomPanelStatement() throws ParseException
1620 {
1621
1622 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTCUSTOMPANELSTATEMENT);
1623 boolean jjtc000 = true;
1624 jjtree.openNodeScope(jjtn000);
1625 Token token;
1626 CustomPanelStatementNode stmtNode = (CustomPanelStatementNode) jjtn000;
1627 try
1628 {
1629 token = jj_consume_token(CUSTOMPANEL);
1630 stmtNode.setLineInfo(token);
1631 token = jj_consume_token(STRING_LITERAL);
1632 stmtNode.setPanelClass(token.image);
1633 jj_consume_token(SEMICOLON);
1634 }
1635 finally
1636 {
1637 if (jjtc000)
1638 {
1639 jjtree.closeNodeScope(jjtn000, true);
1640 }
1641 }
1642 }
1643
1644 final public void EventDefinition() throws ParseException
1645 {
1646
1647 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTEVENTDEFINITION);
1648 boolean jjtc000 = true;
1649 jjtree.openNodeScope(jjtn000);
1650 Token token;
1651 EventDefinitionNode eventDefinitionNode = (EventDefinitionNode) jjtn000;
1652 try
1653 {
1654 token = jj_consume_token(IDENTIFIER);
1655 eventDefinitionNode.setLineInfo(token);
1656 eventDefinitionNode.setEventName(token.image);
1657 token = jj_consume_token(STRING_LITERAL);
1658 eventDefinitionNode.setEventTitle(token.image);
1659 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1660 {
1661 case IDENTIFIER :
1662 token = jj_consume_token(IDENTIFIER);
1663 eventDefinitionNode.setOption(token.image);
1664 break;
1665 default :
1666 jj_la1[29] = jj_gen;
1667 ;
1668 }
1669 jj_consume_token(SEMICOLON);
1670 }
1671 finally
1672 {
1673 if (jjtc000)
1674 {
1675 jjtree.closeNodeScope(jjtn000, true);
1676 }
1677 }
1678 }
1679
1680 final public void SetStatement() throws ParseException
1681 {
1682
1683 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTSETSTATEMENT);
1684 boolean jjtc000 = true;
1685 jjtree.openNodeScope(jjtn000);
1686 Token token;
1687 SetNode setNode = (SetNode) jjtn000;
1688 try
1689 {
1690 token = jj_consume_token(SET);
1691 setNode.setLineInfo(token);
1692 token = jj_consume_token(IDENTIFIER);
1693 setNode.setSetName(token.image);
1694 jj_consume_token(ASSIGN);
1695 CalculatedExpression();
1696 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1697 {
1698 case FILTER :
1699 Filter();
1700 break;
1701 default :
1702 jj_la1[30] = jj_gen;
1703 ;
1704 }
1705 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1706 {
1707 case ORDER :
1708 OrderBy();
1709 break;
1710 default :
1711 jj_la1[31] = jj_gen;
1712 ;
1713 }
1714 jj_consume_token(SEMICOLON);
1715 }
1716 catch (Throwable jjte000)
1717 {
1718 if (jjtc000)
1719 {
1720 jjtree.clearNodeScope(jjtn000);
1721 jjtc000 = false;
1722 }
1723 else
1724 {
1725 jjtree.popNode();
1726 }
1727 if (jjte000 instanceof RuntimeException )
1728 {
1729 {
1730 if (true) throw (RuntimeException ) jjte000;
1731 }
1732 }
1733 if (jjte000 instanceof ParseException)
1734 {
1735 {
1736 if (true) throw (ParseException) jjte000;
1737 }
1738 }
1739 {
1740 if (true) throw (Error ) jjte000;
1741 }
1742 }
1743 finally
1744 {
1745 if (jjtc000)
1746 {
1747 jjtree.closeNodeScope(jjtn000, true);
1748 }
1749 }
1750 }
1751
1752 final public void ForStatement() throws ParseException
1753 {
1754 if (jj_2_7(10))
1755 {
1756 RangedBasedForStatement();
1757 }
1758 else
1759 {
1760 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1761 {
1762 case FOR :
1763 SetBasedForStatement();
1764 break;
1765 default :
1766 jj_la1[32] = jj_gen;
1767 jj_consume_token(-1);
1768 throw new ParseException();
1769 }
1770 }
1771 }
1772
1773 final public void SetBasedForStatement() throws ParseException
1774 {
1775
1776 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTSETBASEDFORSTATEMENT);
1777 boolean jjtc000 = true;
1778 jjtree.openNodeScope(jjtn000);
1779 Token token;
1780 ForNode forNode = (ForNode) jjtn000;
1781 try
1782 {
1783 token = jj_consume_token(FOR);
1784 forNode.setLineInfo(token);
1785 jj_consume_token(LPAREN);
1786 token = jj_consume_token(IDENTIFIER);
1787 forNode.setLoopVariable(token.image);
1788 jj_consume_token(IN);
1789 CalculatedExpression();
1790 jj_consume_token(RPAREN);
1791 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1792 {
1793 case FILTER :
1794 Filter();
1795 break;
1796 default :
1797 jj_la1[33] = jj_gen;
1798 ;
1799 }
1800 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1801 {
1802 case ORDER :
1803 OrderBy();
1804 break;
1805 default :
1806 jj_la1[34] = jj_gen;
1807 ;
1808 }
1809 Body();
1810 }
1811 catch (Throwable jjte000)
1812 {
1813 if (jjtc000)
1814 {
1815 jjtree.clearNodeScope(jjtn000);
1816 jjtc000 = false;
1817 }
1818 else
1819 {
1820 jjtree.popNode();
1821 }
1822 if (jjte000 instanceof RuntimeException )
1823 {
1824 {
1825 if (true) throw (RuntimeException ) jjte000;
1826 }
1827 }
1828 if (jjte000 instanceof ParseException)
1829 {
1830 {
1831 if (true) throw (ParseException) jjte000;
1832 }
1833 }
1834 {
1835 if (true) throw (Error ) jjte000;
1836 }
1837 }
1838 finally
1839 {
1840 if (jjtc000)
1841 {
1842 jjtree.closeNodeScope(jjtn000, true);
1843 }
1844 }
1845 }
1846
1847 final public void RangedBasedForStatement() throws ParseException
1848 {
1849
1850 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTRANGEDBASEDFORSTATEMENT);
1851 boolean jjtc000 = true;
1852 jjtree.openNodeScope(jjtn000);
1853 Token token;
1854 ForNode forNode = (ForNode) jjtn000;
1855 try
1856 {
1857 token = jj_consume_token(FOR);
1858 forNode.setLineInfo(token);
1859 jj_consume_token(LPAREN);
1860 token = jj_consume_token(IDENTIFIER);
1861 forNode.setLoopVariable(token.image);
1862 jj_consume_token(IN);
1863 forNode.setRanged(true);
1864 CalculatedExpression();
1865 jj_consume_token(TO);
1866 CalculatedExpression();
1867 jj_consume_token(RPAREN);
1868 Body();
1869 }
1870 catch (Throwable jjte000)
1871 {
1872 if (jjtc000)
1873 {
1874 jjtree.clearNodeScope(jjtn000);
1875 jjtc000 = false;
1876 }
1877 else
1878 {
1879 jjtree.popNode();
1880 }
1881 if (jjte000 instanceof RuntimeException )
1882 {
1883 {
1884 if (true) throw (RuntimeException ) jjte000;
1885 }
1886 }
1887 if (jjte000 instanceof ParseException)
1888 {
1889 {
1890 if (true) throw (ParseException) jjte000;
1891 }
1892 }
1893 {
1894 if (true) throw (Error ) jjte000;
1895 }
1896 }
1897 finally
1898 {
1899 if (jjtc000)
1900 {
1901 jjtree.closeNodeScope(jjtn000, true);
1902 }
1903 }
1904 }
1905
1906 final public void Filter() throws ParseException
1907 {
1908
1909 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTFILTER);
1910 boolean jjtc000 = true;
1911 jjtree.openNodeScope(jjtn000);
1912 try
1913 {
1914 jj_consume_token(FILTER);
1915 Expression();
1916 }
1917 catch (Throwable jjte000)
1918 {
1919 if (jjtc000)
1920 {
1921 jjtree.clearNodeScope(jjtn000);
1922 jjtc000 = false;
1923 }
1924 else
1925 {
1926 jjtree.popNode();
1927 }
1928 if (jjte000 instanceof RuntimeException )
1929 {
1930 {
1931 if (true) throw (RuntimeException ) jjte000;
1932 }
1933 }
1934 if (jjte000 instanceof ParseException)
1935 {
1936 {
1937 if (true) throw (ParseException) jjte000;
1938 }
1939 }
1940 {
1941 if (true) throw (Error ) jjte000;
1942 }
1943 }
1944 finally
1945 {
1946 if (jjtc000)
1947 {
1948 jjtree.closeNodeScope(jjtn000, true);
1949 }
1950 }
1951 }
1952
1953 final public void OrderBy() throws ParseException
1954 {
1955
1956 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTORDERBY);
1957 boolean jjtc000 = true;
1958 jjtree.openNodeScope(jjtn000);
1959 Token tok;
1960 ArrayList lst = new ArrayList ();
1961 OrderByNode orderNode = (OrderByNode) jjtn000;
1962 try
1963 {
1964 tok = jj_consume_token(ORDER);
1965 orderNode.setLineInfo(tok);
1966 jj_consume_token(BY);
1967 tok = jj_consume_token(IDENTIFIER);
1968 lst.add(tok.image.toString());
1969 label_13 : while (true)
1970 {
1971 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
1972 {
1973 case COMMA :
1974 ;
1975 break;
1976 default :
1977 jj_la1[35] = jj_gen;
1978 break label_13;
1979 }
1980 jj_consume_token(COMMA);
1981 tok = jj_consume_token(IDENTIFIER);
1982 lst.add(tok.image.toString());
1983 }
1984 jjtree.closeNodeScope(jjtn000, true);
1985 jjtc000 = false;
1986 orderNode.setProperties((String []) lst.toArray(new String [0]));
1987 }
1988 finally
1989 {
1990 if (jjtc000)
1991 {
1992 jjtree.closeNodeScope(jjtn000, true);
1993 }
1994 }
1995 }
1996
1997 final public void IfStatement() throws ParseException
1998 {
1999
2000 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTIFSTATEMENT);
2001 boolean jjtc000 = true;
2002 jjtree.openNodeScope(jjtn000);
2003 Token token;
2004 IfNode ifNode = (IfNode) jjtn000;
2005 try
2006 {
2007 token = jj_consume_token(IF);
2008 ifNode.setLineInfo(token);
2009 jj_consume_token(LPAREN);
2010 Expression();
2011 jj_consume_token(RPAREN);
2012 Body();
2013 }
2014 catch (Throwable jjte000)
2015 {
2016 if (jjtc000)
2017 {
2018 jjtree.clearNodeScope(jjtn000);
2019 jjtc000 = false;
2020 }
2021 else
2022 {
2023 jjtree.popNode();
2024 }
2025 if (jjte000 instanceof RuntimeException )
2026 {
2027 {
2028 if (true) throw (RuntimeException ) jjte000;
2029 }
2030 }
2031 if (jjte000 instanceof ParseException)
2032 {
2033 {
2034 if (true) throw (ParseException) jjte000;
2035 }
2036 }
2037 {
2038 if (true) throw (Error ) jjte000;
2039 }
2040 }
2041 finally
2042 {
2043 if (jjtc000)
2044 {
2045 jjtree.closeNodeScope(jjtn000, true);
2046 }
2047 }
2048 }
2049
2050 final public void ElseStatement() throws ParseException
2051 {
2052
2053 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTELSESTATEMENT);
2054 boolean jjtc000 = true;
2055 jjtree.openNodeScope(jjtn000);
2056 Token token;
2057 ElseNode elseNode = (ElseNode) jjtn000;
2058 try
2059 {
2060 token = jj_consume_token(ELSE);
2061 elseNode.setLineInfo(token);
2062 Body();
2063 }
2064 catch (Throwable jjte000)
2065 {
2066 if (jjtc000)
2067 {
2068 jjtree.clearNodeScope(jjtn000);
2069 jjtc000 = false;
2070 }
2071 else
2072 {
2073 jjtree.popNode();
2074 }
2075 if (jjte000 instanceof RuntimeException )
2076 {
2077 {
2078 if (true) throw (RuntimeException ) jjte000;
2079 }
2080 }
2081 if (jjte000 instanceof ParseException)
2082 {
2083 {
2084 if (true) throw (ParseException) jjte000;
2085 }
2086 }
2087 {
2088 if (true) throw (Error ) jjte000;
2089 }
2090 }
2091 finally
2092 {
2093 if (jjtc000)
2094 {
2095 jjtree.closeNodeScope(jjtn000, true);
2096 }
2097 }
2098 }
2099
2100 final public PropertyPathNode Objectpath() throws ParseException
2101 {
2102
2103 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTOBJECTPATH);
2104 boolean jjtc000 = true;
2105 jjtree.openNodeScope(jjtn000);
2106 Token token;
2107 PropertyPathNode pathNode = (PropertyPathNode) jjtn000;
2108 String rs;
2109 try
2110 {
2111 token = jj_consume_token(IDENTIFIER);
2112 pathNode.setLineInfo(token);
2113 rs = token.image;
2114 label_14 : while (true)
2115 {
2116 if (jj_2_8(2))
2117 {
2118 ;
2119 }
2120 else
2121 {
2122 break label_14;
2123 }
2124 jj_consume_token(DOT);
2125 token = jj_consume_token(IDENTIFIER);
2126 rs += "." + token.image;
2127 }
2128 jjtree.closeNodeScope(jjtn000, true);
2129 jjtc000 = false;
2130 pathNode.setPath(rs);
2131 {
2132 if (true) return pathNode;
2133 }
2134 }
2135 finally
2136 {
2137 if (jjtc000)
2138 {
2139 jjtree.closeNodeScope(jjtn000, true);
2140 }
2141 }
2142 throw new Error ("Missing return statement in function");
2143 }
2144
2145 final public ExpressionNode Expression() throws ParseException
2146 {
2147
2148 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTEXPRESSION);
2149 boolean jjtc000 = true;
2150 jjtree.openNodeScope(jjtn000);
2151 ExpressionNode expressionNode = (ExpressionNode) jjtn000;
2152 SubExpressionNode subExpressionNode;
2153 try
2154 {
2155 subExpressionNode = SubExpression();
2156 expressionNode.setLineInfo(subExpressionNode);
2157 label_15 : while (true)
2158 {
2159 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2160 {
2161 case SC_OR :
2162 case SC_AND :
2163 ;
2164 break;
2165 default :
2166 jj_la1[36] = jj_gen;
2167 break label_15;
2168 }
2169 AndOr();
2170 SubExpression();
2171 }
2172 jjtree.closeNodeScope(jjtn000, true);
2173 jjtc000 = false;
2174 {
2175 if (true) return expressionNode;
2176 }
2177 }
2178 catch (Throwable jjte000)
2179 {
2180 if (jjtc000)
2181 {
2182 jjtree.clearNodeScope(jjtn000);
2183 jjtc000 = false;
2184 }
2185 else
2186 {
2187 jjtree.popNode();
2188 }
2189 if (jjte000 instanceof RuntimeException )
2190 {
2191 {
2192 if (true) throw (RuntimeException ) jjte000;
2193 }
2194 }
2195 if (jjte000 instanceof ParseException)
2196 {
2197 {
2198 if (true) throw (ParseException) jjte000;
2199 }
2200 }
2201 {
2202 if (true) throw (Error ) jjte000;
2203 }
2204 }
2205 finally
2206 {
2207 if (jjtc000)
2208 {
2209 jjtree.closeNodeScope(jjtn000, true);
2210 }
2211 }
2212 throw new Error ("Missing return statement in function");
2213 }
2214
2215 final public AndOrNode AndOr() throws ParseException
2216 {
2217
2218 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTANDOR);
2219 boolean jjtc000 = true;
2220 jjtree.openNodeScope(jjtn000);
2221 Token token;
2222 AndOrNode node = (AndOrNode) jjtn000;
2223 try
2224 {
2225 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2226 {
2227 case SC_OR :
2228 token = jj_consume_token(SC_OR);
2229 break;
2230 case SC_AND :
2231 token = jj_consume_token(SC_AND);
2232 break;
2233 default :
2234 jj_la1[37] = jj_gen;
2235 jj_consume_token(-1);
2236 throw new ParseException();
2237 }
2238 jjtree.closeNodeScope(jjtn000, true);
2239 jjtc000 = false;
2240 node.setOperator(token.image.toString());
2241 {
2242 if (true) return node;
2243 }
2244 }
2245 finally
2246 {
2247 if (jjtc000)
2248 {
2249 jjtree.closeNodeScope(jjtn000, true);
2250 }
2251 }
2252 throw new Error ("Missing return statement in function");
2253 }
2254
2255 final public SubExpressionNode SubExpression() throws ParseException
2256 {
2257
2258 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTSUBEXPRESSION);
2259 boolean jjtc000 = true;
2260 jjtree.openNodeScope(jjtn000);
2261 Token token = null;
2262 SubExpressionNode subExpressionNode = (SubExpressionNode) jjtn000;
2263 CalculatedExpressionNode calcNode;
2264 try
2265 {
2266 calcNode = CalculatedExpression();
2267 subExpressionNode.setLineInfo(calcNode);
2268 label_16 : while (true)
2269 {
2270 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2271 {
2272 case INSTANCEOF :
2273 case GT :
2274 case LT :
2275 case EQ :
2276 case LE :
2277 case GE :
2278 case NE :
2279 ;
2280 break;
2281 default :
2282 jj_la1[38] = jj_gen;
2283 break label_16;
2284 }
2285 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2286 {
2287 case EQ :
2288 token = jj_consume_token(EQ);
2289 break;
2290 case NE :
2291 token = jj_consume_token(NE);
2292 break;
2293 case LT :
2294 token = jj_consume_token(LT);
2295 break;
2296 case INSTANCEOF :
2297 token = jj_consume_token(INSTANCEOF);
2298 break;
2299 case GT :
2300 token = jj_consume_token(GT);
2301 break;
2302 case LE :
2303 token = jj_consume_token(LE);
2304 break;
2305 case GE :
2306 token = jj_consume_token(GE);
2307 break;
2308 default :
2309 jj_la1[39] = jj_gen;
2310 jj_consume_token(-1);
2311 throw new ParseException();
2312 }
2313 CalculatedExpression();
2314 }
2315 jjtree.closeNodeScope(jjtn000, true);
2316 jjtc000 = false;
2317 if (token != null) subExpressionNode.setOperator(token.image);
2318 {
2319 if (true) return subExpressionNode;
2320 }
2321 }
2322 catch (Throwable jjte000)
2323 {
2324 if (jjtc000)
2325 {
2326 jjtree.clearNodeScope(jjtn000);
2327 jjtc000 = false;
2328 }
2329 else
2330 {
2331 jjtree.popNode();
2332 }
2333 if (jjte000 instanceof RuntimeException )
2334 {
2335 {
2336 if (true) throw (RuntimeException ) jjte000;
2337 }
2338 }
2339 if (jjte000 instanceof ParseException)
2340 {
2341 {
2342 if (true) throw (ParseException) jjte000;
2343 }
2344 }
2345 {
2346 if (true) throw (Error ) jjte000;
2347 }
2348 }
2349 finally
2350 {
2351 if (jjtc000)
2352 {
2353 jjtree.closeNodeScope(jjtn000, true);
2354 }
2355 }
2356 throw new Error ("Missing return statement in function");
2357 }
2358
2359 final public CalculatedExpressionNode CalculatedExpression() throws ParseException
2360 {
2361
2362 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTCALCULATEDEXPRESSION);
2363 boolean jjtc000 = true;
2364 jjtree.openNodeScope(jjtn000);
2365 CalculatedExpressionNode expressionNode = (CalculatedExpressionNode) jjtn000;
2366 SimpleNode primNode;
2367 try
2368 {
2369 primNode = PrimaryExpression();
2370 expressionNode.setLineInfo(primNode);
2371 label_17 : while (true)
2372 {
2373 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2374 {
2375 case DOT :
2376 case PLUS :
2377 case MINUS :
2378 case STAR :
2379 case SLASH :
2380 case REM :
2381 ;
2382 break;
2383 default :
2384 jj_la1[40] = jj_gen;
2385 break label_17;
2386 }
2387 Operator();
2388 PrimaryExpression();
2389 }
2390 jjtree.closeNodeScope(jjtn000, true);
2391 jjtc000 = false;
2392 {
2393 if (true) return expressionNode;
2394 }
2395 }
2396 catch (Throwable jjte000)
2397 {
2398 if (jjtc000)
2399 {
2400 jjtree.clearNodeScope(jjtn000);
2401 jjtc000 = false;
2402 }
2403 else
2404 {
2405 jjtree.popNode();
2406 }
2407 if (jjte000 instanceof RuntimeException )
2408 {
2409 {
2410 if (true) throw (RuntimeException ) jjte000;
2411 }
2412 }
2413 if (jjte000 instanceof ParseException)
2414 {
2415 {
2416 if (true) throw (ParseException) jjte000;
2417 }
2418 }
2419 {
2420 if (true) throw (Error ) jjte000;
2421 }
2422 }
2423 finally
2424 {
2425 if (jjtc000)
2426 {
2427 jjtree.closeNodeScope(jjtn000, true);
2428 }
2429 }
2430 throw new Error ("Missing return statement in function");
2431 }
2432
2433 final public void Operator() throws ParseException
2434 {
2435
2436 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTOPERATOR);
2437 boolean jjtc000 = true;
2438 jjtree.openNodeScope(jjtn000);
2439 OperatorNode opNode = (OperatorNode) jjtn000;
2440 try
2441 {
2442 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2443 {
2444 case PLUS :
2445 jj_consume_token(PLUS);
2446 opNode.setOperator("+");
2447 break;
2448 case MINUS :
2449 jj_consume_token(MINUS);
2450 opNode.setOperator("-");
2451 break;
2452 case STAR :
2453 jj_consume_token(STAR);
2454 opNode.setOperator("*");
2455 break;
2456 case SLASH :
2457 jj_consume_token(SLASH);
2458 opNode.setOperator("/");
2459 break;
2460 case REM :
2461 jj_consume_token(REM);
2462 opNode.setOperator("%");
2463 break;
2464 case DOT :
2465 jj_consume_token(DOT);
2466 opNode.setOperator(".");
2467 break;
2468 default :
2469 jj_la1[41] = jj_gen;
2470 jj_consume_token(-1);
2471 throw new ParseException();
2472 }
2473 jjtree.closeNodeScope(jjtn000, true);
2474 jjtc000 = false;
2475 opNode.setLineInfo(token);
2476 }
2477 finally
2478 {
2479 if (jjtc000)
2480 {
2481 jjtree.closeNodeScope(jjtn000, true);
2482 }
2483 }
2484 }
2485
2486 final public SimpleNode PrimaryExpression() throws ParseException
2487 {
2488 SimpleNode subNode;
2489 if (jj_2_10(3))
2490 {
2491 subNode = boolLiteral();
2492 }
2493 else
2494 {
2495 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2496 {
2497 case IDENTIFIER :
2498 case BANG :
2499 subNode = PropertyOrFunction();
2500 break;
2501 case NEW :
2502 subNode = New();
2503 break;
2504 default :
2505 jj_la1[42] = jj_gen;
2506 if (jj_2_11(2))
2507 {
2508 subNode = integerLiteral();
2509 }
2510 else
2511 {
2512 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2513 {
2514 case FLOATING_POINT_LITERAL :
2515 case MINUS :
2516 subNode = floatLiteral();
2517 break;
2518 case CHARACTER_LITERAL :
2519 subNode = charLiteral();
2520 break;
2521 case STRING_LITERAL :
2522 subNode = stringLiteral();
2523 break;
2524 case NULL :
2525 subNode = nullLiteral();
2526 break;
2527 case LPAREN :
2528 jj_consume_token(LPAREN);
2529 subNode = Expression();
2530 jj_consume_token(RPAREN);
2531 label_18 : while (true)
2532 {
2533 if (jj_2_9(2))
2534 {
2535 ;
2536 }
2537 else
2538 {
2539 break label_18;
2540 }
2541 Arguments();
2542 }
2543 break;
2544 default :
2545 jj_la1[43] = jj_gen;
2546 jj_consume_token(-1);
2547 throw new ParseException();
2548 }
2549 }
2550 }
2551 }
2552 {
2553 if (true) return subNode;
2554 }
2555 throw new Error ("Missing return statement in function");
2556 }
2557
2558 final public PropertyOrFunctionNode PropertyOrFunction() throws ParseException
2559 {
2560
2561 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTPROPERTYORFUNCTION);
2562 boolean jjtc000 = true;
2563 jjtree.openNodeScope(jjtn000);
2564 PropertyOrFunctionNode pfnode = (PropertyOrFunctionNode) jjtn000;
2565 PropertyPathNode path;
2566 Token not = null;
2567 try
2568 {
2569 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2570 {
2571 case BANG :
2572 not = jj_consume_token(BANG);
2573 break;
2574 default :
2575 jj_la1[44] = jj_gen;
2576 ;
2577 }
2578 path = Objectpath();
2579 pfnode.setLineInfo(path);
2580 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2581 {
2582 case LPAREN :
2583 jj_consume_token(LPAREN);
2584 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2585 {
2586 case INTEGER_LITERAL :
2587 case FLOATING_POINT_LITERAL :
2588 case CHARACTER_LITERAL :
2589 case STRING_LITERAL :
2590 case NEW :
2591 case TRUE :
2592 case FALSE :
2593 case NULL :
2594 case IDENTIFIER :
2595 case LPAREN :
2596 case BANG :
2597 case MINUS :
2598 Expression();
2599 label_19 : while (true)
2600 {
2601 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2602 {
2603 case COMMA :
2604 ;
2605 break;
2606 default :
2607 jj_la1[45] = jj_gen;
2608 break label_19;
2609 }
2610 jj_consume_token(COMMA);
2611 Expression();
2612 }
2613 break;
2614 default :
2615 jj_la1[46] = jj_gen;
2616 ;
2617 }
2618 jj_consume_token(RPAREN);
2619 pfnode.setFunction(true);
2620 break;
2621 default :
2622 jj_la1[47] = jj_gen;
2623 ;
2624 }
2625 jjtree.closeNodeScope(jjtn000, true);
2626 jjtc000 = false;
2627 if (not != null) path.setNegated(true);
2628 {
2629 if (true) return pfnode;
2630 }
2631 }
2632 catch (Throwable jjte000)
2633 {
2634 if (jjtc000)
2635 {
2636 jjtree.clearNodeScope(jjtn000);
2637 jjtc000 = false;
2638 }
2639 else
2640 {
2641 jjtree.popNode();
2642 }
2643 if (jjte000 instanceof RuntimeException )
2644 {
2645 {
2646 if (true) throw (RuntimeException ) jjte000;
2647 }
2648 }
2649 if (jjte000 instanceof ParseException)
2650 {
2651 {
2652 if (true) throw (ParseException) jjte000;
2653 }
2654 }
2655 {
2656 if (true) throw (Error ) jjte000;
2657 }
2658 }
2659 finally
2660 {
2661 if (jjtc000)
2662 {
2663 jjtree.closeNodeScope(jjtn000, true);
2664 }
2665 }
2666 throw new Error ("Missing return statement in function");
2667 }
2668
2669 final public PropertyOrFunctionNode FunctionCall() throws ParseException
2670 {
2671
2672 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTFUNCTIONCALL);
2673 boolean jjtc000 = true;
2674 jjtree.openNodeScope(jjtn000);
2675 PropertyOrFunctionNode pfnode = (PropertyOrFunctionNode) jjtn000;
2676 PropertyPathNode path;
2677 try
2678 {
2679 path = Objectpath();
2680 pfnode.setLineInfo(path);
2681 jj_consume_token(LPAREN);
2682 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2683 {
2684 case INTEGER_LITERAL :
2685 case FLOATING_POINT_LITERAL :
2686 case CHARACTER_LITERAL :
2687 case STRING_LITERAL :
2688 case NEW :
2689 case TRUE :
2690 case FALSE :
2691 case NULL :
2692 case IDENTIFIER :
2693 case LPAREN :
2694 case BANG :
2695 case MINUS :
2696 Expression();
2697 label_20 : while (true)
2698 {
2699 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2700 {
2701 case COMMA :
2702 ;
2703 break;
2704 default :
2705 jj_la1[48] = jj_gen;
2706 break label_20;
2707 }
2708 jj_consume_token(COMMA);
2709 Expression();
2710 }
2711 break;
2712 default :
2713 jj_la1[49] = jj_gen;
2714 ;
2715 }
2716 jj_consume_token(RPAREN);
2717 jj_consume_token(SEMICOLON);
2718 jjtree.closeNodeScope(jjtn000, true);
2719 jjtc000 = false;
2720 pfnode.setFunction(true);
2721 {
2722 if (true) return pfnode;
2723 }
2724 }
2725 catch (Throwable jjte000)
2726 {
2727 if (jjtc000)
2728 {
2729 jjtree.clearNodeScope(jjtn000);
2730 jjtc000 = false;
2731 }
2732 else
2733 {
2734 jjtree.popNode();
2735 }
2736 if (jjte000 instanceof RuntimeException )
2737 {
2738 {
2739 if (true) throw (RuntimeException ) jjte000;
2740 }
2741 }
2742 if (jjte000 instanceof ParseException)
2743 {
2744 {
2745 if (true) throw (ParseException) jjte000;
2746 }
2747 }
2748 {
2749 if (true) throw (Error ) jjte000;
2750 }
2751 }
2752 finally
2753 {
2754 if (jjtc000)
2755 {
2756 jjtree.closeNodeScope(jjtn000, true);
2757 }
2758 }
2759 throw new Error ("Missing return statement in function");
2760 }
2761
2762 final public NewNode New() throws ParseException
2763 {
2764
2765 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTNEW);
2766 boolean jjtc000 = true;
2767 jjtree.openNodeScope(jjtn000);
2768 NewNode newNode = (NewNode) jjtn000;
2769 Token token;
2770 try
2771 {
2772 jj_consume_token(NEW);
2773 token = jj_consume_token(IDENTIFIER);
2774 newNode.setClassName(token.image);
2775 Arguments();
2776 jjtree.closeNodeScope(jjtn000, true);
2777 jjtc000 = false;
2778 {
2779 if (true) return newNode;
2780 }
2781 }
2782 catch (Throwable jjte000)
2783 {
2784 if (jjtc000)
2785 {
2786 jjtree.clearNodeScope(jjtn000);
2787 jjtc000 = false;
2788 }
2789 else
2790 {
2791 jjtree.popNode();
2792 }
2793 if (jjte000 instanceof RuntimeException )
2794 {
2795 {
2796 if (true) throw (RuntimeException ) jjte000;
2797 }
2798 }
2799 if (jjte000 instanceof ParseException)
2800 {
2801 {
2802 if (true) throw (ParseException) jjte000;
2803 }
2804 }
2805 {
2806 if (true) throw (Error ) jjte000;
2807 }
2808 }
2809 finally
2810 {
2811 if (jjtc000)
2812 {
2813 jjtree.closeNodeScope(jjtn000, true);
2814 }
2815 }
2816 throw new Error ("Missing return statement in function");
2817 }
2818
2819 final public IntegerNode integerLiteral() throws ParseException
2820 {
2821
2822 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTINTEGERLITERAL);
2823 boolean jjtc000 = true;
2824 jjtree.openNodeScope(jjtn000);
2825 Token token = null;
2826 Token sign = null;
2827 IntegerNode node = (IntegerNode) jjtn000;
2828 try
2829 {
2830 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2831 {
2832 case MINUS :
2833 sign = jj_consume_token(MINUS);
2834 break;
2835 default :
2836 jj_la1[50] = jj_gen;
2837 ;
2838 }
2839 token = jj_consume_token(INTEGER_LITERAL);
2840 node.setLineInfo(token);
2841 try
2842 {
2843 int v = Integer.parseInt(token.image);
2844 if (sign != null) v = -v;
2845 node.setValue(v);
2846 }
2847 catch (Exception x)
2848 { x.printStackTrace();
2850 }
2851 jjtree.closeNodeScope(jjtn000, true);
2852 jjtc000 = false;
2853 {
2854 if (true) return node;
2855 }
2856 }
2857 finally
2858 {
2859 if (jjtc000)
2860 {
2861 jjtree.closeNodeScope(jjtn000, true);
2862 }
2863 }
2864 throw new Error ("Missing return statement in function");
2865 }
2866
2867 final public FloatNode floatLiteral() throws ParseException
2868 {
2869
2870 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTFLOATLITERAL);
2871 boolean jjtc000 = true;
2872 jjtree.openNodeScope(jjtn000);
2873 Token token = null;
2874 Token sign = null;
2875 FloatNode node = (FloatNode) jjtn000;
2876 try
2877 {
2878 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2879 {
2880 case MINUS :
2881 sign = jj_consume_token(MINUS);
2882 break;
2883 default :
2884 jj_la1[51] = jj_gen;
2885 ;
2886 }
2887 token = jj_consume_token(FLOATING_POINT_LITERAL);
2888 node.setLineInfo(token);
2889 try
2890 {
2891 float v = Float.parseFloat(token.image);
2892 if (sign != null) v = -v;
2893 node.setValue(v);
2894 }
2895 catch (Exception x)
2896 { x.printStackTrace();
2898 }
2899 jjtree.closeNodeScope(jjtn000, true);
2900 jjtc000 = false;
2901 {
2902 if (true) return node;
2903 }
2904 }
2905 finally
2906 {
2907 if (jjtc000)
2908 {
2909 jjtree.closeNodeScope(jjtn000, true);
2910 }
2911 }
2912 throw new Error ("Missing return statement in function");
2913 }
2914
2915 final public CharNode charLiteral() throws ParseException
2916 {
2917
2918 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTCHARLITERAL);
2919 boolean jjtc000 = true;
2920 jjtree.openNodeScope(jjtn000);
2921 Token token = null;
2922 CharNode node = (CharNode) jjtn000;
2923 try
2924 {
2925 token = jj_consume_token(CHARACTER_LITERAL);
2926 node.setLineInfo(token);
2927 node.setValue(token.image.toString());
2928 jjtree.closeNodeScope(jjtn000, true);
2929 jjtc000 = false;
2930 {
2931 if (true) return node;
2932 }
2933 }
2934 finally
2935 {
2936 if (jjtc000)
2937 {
2938 jjtree.closeNodeScope(jjtn000, true);
2939 }
2940 }
2941 throw new Error ("Missing return statement in function");
2942 }
2943
2944 final public StringNode stringLiteral() throws ParseException
2945 {
2946
2947 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTSTRINGLITERAL);
2948 boolean jjtc000 = true;
2949 jjtree.openNodeScope(jjtn000);
2950 Token token = null;
2951 StringNode node = (StringNode) jjtn000;
2952 try
2953 {
2954 token = jj_consume_token(STRING_LITERAL);
2955 node.setLineInfo(token);
2956 node.setValue(token.image.toString());
2957 jjtree.closeNodeScope(jjtn000, true);
2958 jjtc000 = false;
2959 {
2960 if (true) return node;
2961 }
2962 }
2963 finally
2964 {
2965 if (jjtc000)
2966 {
2967 jjtree.closeNodeScope(jjtn000, true);
2968 }
2969 }
2970 throw new Error ("Missing return statement in function");
2971 }
2972
2973 final public BoolNode boolLiteral() throws ParseException
2974 {
2975
2976 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTBOOLLITERAL);
2977 boolean jjtc000 = true;
2978 jjtree.openNodeScope(jjtn000);
2979 Token token = null;
2980 Token not = null;
2981 BoolNode node = (BoolNode) jjtn000;
2982 try
2983 {
2984 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2985 {
2986 case BANG :
2987 not = jj_consume_token(BANG);
2988 break;
2989 default :
2990 jj_la1[52] = jj_gen;
2991 ;
2992 }
2993 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
2994 {
2995 case TRUE :
2996 token = jj_consume_token(TRUE);
2997 break;
2998 case FALSE :
2999 token = jj_consume_token(FALSE);
3000 break;
3001 default :
3002 jj_la1[53] = jj_gen;
3003 jj_consume_token(-1);
3004 throw new ParseException();
3005 }
3006 jjtree.closeNodeScope(jjtn000, true);
3007 jjtc000 = false;
3008 node.setValue(token.image.equals("true"));
3009 if (not != null) node.setValue(!node.isTrue());
3010 node.setLineInfo(token);
3011 {
3012 if (true) return node;
3013 }
3014 }
3015 finally
3016 {
3017 if (jjtc000)
3018 {
3019 jjtree.closeNodeScope(jjtn000, true);
3020 }
3021 }
3022 throw new Error ("Missing return statement in function");
3023 }
3024
3025 final public NullNode nullLiteral() throws ParseException
3026 {
3027
3028 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTNULLLITERAL);
3029 boolean jjtc000 = true;
3030 jjtree.openNodeScope(jjtn000);
3031 Token token = null;
3032 NullNode node = (NullNode) jjtn000;
3033 try
3034 {
3035 token = jj_consume_token(NULL);
3036 jjtree.closeNodeScope(jjtn000, true);
3037 jjtc000 = false;
3038 node.setLineInfo(token);
3039 {
3040 if (true) return node;
3041 }
3042 }
3043 finally
3044 {
3045 if (jjtc000)
3046 {
3047 jjtree.closeNodeScope(jjtn000, true);
3048 }
3049 }
3050 throw new Error ("Missing return statement in function");
3051 }
3052
3053 final public ArgumentsNode Arguments() throws ParseException
3054 {
3055
3056 SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(JJTARGUMENTS);
3057 boolean jjtc000 = true;
3058 jjtree.openNodeScope(jjtn000);
3059 ArgumentsNode argumentsNode = (ArgumentsNode) jjtn000;
3060 try
3061 {
3062 jj_consume_token(LPAREN);
3063 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
3064 {
3065 case INTEGER_LITERAL :
3066 case FLOATING_POINT_LITERAL :
3067 case CHARACTER_LITERAL :
3068 case STRING_LITERAL :
3069 case NEW :
3070 case TRUE :
3071 case FALSE :
3072 case NULL :
3073 case IDENTIFIER :
3074 case LPAREN :
3075 case BANG :
3076 case MINUS :
3077 Expression();
3078 label_21 : while (true)
3079 {
3080 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk)
3081 {
3082 case COMMA :
3083 ;
3084 break;
3085 default :
3086 jj_la1[54] = jj_gen;
3087 break label_21;
3088 }
3089 jj_consume_token(COMMA);
3090 Expression();
3091 }
3092 break;
3093 default :
3094 jj_la1[55] = jj_gen;
3095 ;
3096 }
3097 jj_consume_token(RPAREN);
3098 jjtree.closeNodeScope(jjtn000, true);
3099 jjtc000 = false;
3100 {
3101 if (true) return argumentsNode;
3102 }
3103 }
3104 catch (Throwable jjte000)
3105 {
3106 if (jjtc000)
3107 {
3108 jjtree.clearNodeScope(jjtn000);
3109 jjtc000 = false;
3110 }
3111 else
3112 {
3113 jjtree.popNode();
3114 }
3115 if (jjte000 instanceof RuntimeException )
3116 {
3117 {
3118 if (true) throw (RuntimeException ) jjte000;
3119 }
3120 }
3121 if (jjte000 instanceof ParseException)
3122 {
3123 {
3124 if (true) throw (ParseException) jjte000;
3125 }
3126 }
3127 {
3128 if (true) throw (Error ) jjte000;
3129 }
3130 }
3131 finally
3132 {
3133 if (jjtc000)
3134 {
3135 jjtree.closeNodeScope(jjtn000, true);
3136 }
3137 }
3138 throw new Error ("Missing return statement in function");
3139 }
3140
3141 final private boolean jj_2_1(int xla)
3142 {
3143 jj_la = xla;
3144 jj_lastpos = jj_scanpos = token;
3145 boolean retval = !jj_3_1();
3146 jj_save(0, xla);
3147 return retval;
3148 }
3149
3150 final private boolean jj_2_2(int xla)
3151 {
3152 jj_la = xla;
3153 jj_lastpos = jj_scanpos = token;
3154 boolean retval = !jj_3_2();
3155 jj_save(1, xla);
3156 return retval;
3157 }
3158
3159 final private boolean jj_2_3(int xla)
3160 {
3161 jj_la = xla;
3162 jj_lastpos = jj_scanpos = token;
3163 boolean retval = !jj_3_3();
3164 jj_save(2, xla);
3165 return retval;
3166 }
3167
3168 final private boolean jj_2_4(int xla)
3169 {
3170 jj_la = xla;
3171 jj_lastpos = jj_scanpos = token;
3172 boolean retval = !jj_3_4();
3173 jj_save(3, xla);
3174 return retval;
3175 }
3176
3177 final private boolean jj_2_5(int xla)
3178 {
3179 jj_la = xla;
3180 jj_lastpos = jj_scanpos = token;
3181 boolean retval = !jj_3_5();
3182 jj_save(4, xla);
3183 return retval;
3184 }
3185
3186 final private boolean jj_2_6(int xla)
3187 {
3188 jj_la = xla;
3189 jj_lastpos = jj_scanpos = token;
3190 boolean retval = !jj_3_6();
3191 jj_save(5, xla);
3192 return retval;
3193 }
3194
3195 final private boolean jj_2_7(int xla)
3196 {
3197 jj_la = xla;
3198 jj_lastpos = jj_scanpos = token;
3199 boolean retval = !jj_3_7();
3200 jj_save(6, xla);
3201 return retval;
3202 }
3203
3204 final private boolean jj_2_8(int xla)
3205 {
3206 jj_la = xla;
3207 jj_lastpos = jj_scanpos = token;
3208 boolean retval = !jj_3_8();
3209 jj_save(7, xla);
3210 return retval;
3211 }
3212
3213 final private boolean jj_2_9(int xla)
3214 {
3215 jj_la = xla;
3216 jj_lastpos = jj_scanpos = token;
3217 boolean retval = !jj_3_9();
3218 jj_save(8, xla);
3219 return retval;
3220 }
3221
3222 final private boolean jj_2_10(int xla)
3223 {
3224 jj_la = xla;
3225 jj_lastpos = jj_scanpos = token;
3226 boolean retval = !jj_3_10();
3227 jj_save(9, xla);
3228 return retval;
3229 }
3230
3231 final private boolean jj_2_11(int xla)
3232 {
3233 jj_la = xla;
3234 jj_lastpos = jj_scanpos = token;
3235 boolean retval = !jj_3_11();
3236 jj_save(10, xla);
3237 return retval;
3238 }
3239
3240 final private boolean jj_3R_96()
3241 {
3242 if (jj_scan_token(CHARACTER_LITERAL)) return true;
3243 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3244 return false;
3245 }
3246
3247 final private boolean jj_3R_67()
3248 {
3249 if (jj_scan_token(ELSE)) return true;
3250 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3251 if (jj_3R_51()) return true;
3252 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3253 return false;
3254 }
3255
3256 final private boolean jj_3R_62()
3257 {
3258 if (jj_scan_token(TRACE)) return true;
3259 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3260 if (jj_scan_token(LPAREN)) return true;
3261 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3262 return false;
3263 }
3264
3265 final private boolean jj_3R_109()
3266 {
3267 if (jj_scan_token(MINUS)) return true;
3268 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3269 return false;
3270 }
3271
3272 final private boolean jj_3R_95()
3273 {
3274 Token xsp;
3275 xsp = jj_scanpos;
3276 if (jj_3R_109()) jj_scanpos = xsp;
3277 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3278 if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
3279 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3280 return false;
3281 }
3282
3283 final private boolean jj_3R_66()
3284 {
3285 if (jj_scan_token(IF)) return true;
3286 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3287 if (jj_scan_token(LPAREN)) return true;
3288 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3289 return false;
3290 }
3291
3292 final private boolean jj_3R_78()
3293 {
3294 if (jj_scan_token(ROLLBACK)) return true;
3295 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3296 return false;
3297 }
3298
3299 final private boolean jj_3R_77()
3300 {
3301 if (jj_scan_token(COMMIT)) return true;
3302 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3303 return false;
3304 }
3305
3306 final private boolean jj_3R_59()
3307 {
3308 Token xsp;
3309 xsp = jj_scanpos;
3310 if (jj_3R_77())
3311 {
3312 jj_scanpos = xsp;
3313 if (jj_3R_78()) return true;
3314 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3315 }
3316 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3317 if (jj_scan_token(SEMICOLON)) return true;
3318 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3319 return false;
3320 }
3321
3322 final private boolean jj_3R_79()
3323 {
3324 if (jj_scan_token(JAVA)) return true;
3325 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3326 return false;
3327 }
3328
3329 final private boolean jj_3R_63()
3330 {
3331 if (jj_scan_token(DISPATCH)) return true;
3332 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3333 Token xsp;
3334 xsp = jj_scanpos;
3335 if (jj_3R_79()) jj_scanpos = xsp;
3336 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3337 if (jj_scan_token(EVENTS)) return true;
3338 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3339 return false;
3340 }
3341
3342 final private boolean jj_3R_31()
3343 {
3344 Token xsp;
3345 xsp = jj_scanpos;
3346 if (jj_3R_56()) jj_scanpos = xsp;
3347 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3348 if (jj_scan_token(INTEGER_LITERAL)) return true;
3349 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3350 return false;
3351 }
3352
3353 final private boolean jj_3R_56()
3354 {
3355 if (jj_scan_token(MINUS)) return true;
3356 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3357 return false;
3358 }
3359
3360 final private boolean jj_3R_76()
3361 {
3362 if (jj_scan_token(COMMA)) return true;
3363 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3364 if (jj_3R_75()) return true;
3365 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3366 return false;
3367 }
3368
3369 final private boolean jj_3R_61()
3370 {
3371 if (jj_scan_token(TERMINATE)) return true;
3372 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3373 if (jj_scan_token(SCRIPT)) return true;
3374 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3375 return false;
3376 }
3377
3378 final private boolean jj_3R_28()
3379 {
3380 if (jj_scan_token(FOR)) return true;
3381 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3382 if (jj_scan_token(LPAREN)) return true;
3383 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3384 if (jj_scan_token(IDENTIFIER)) return true;
3385 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3386 if (jj_scan_token(IN)) return true;
3387 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3388 if (jj_3R_49()) return true;
3389 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3390 if (jj_scan_token(TO)) return true;
3391 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3392 if (jj_3R_49()) return true;
3393 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3394 if (jj_scan_token(RPAREN)) return true;
3395 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3396 if (jj_3R_51()) return true;
3397 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3398 return false;
3399 }
3400
3401 final private boolean jj_3R_94()
3402 {
3403 if (jj_scan_token(NEW)) return true;
3404 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3405 if (jj_scan_token(IDENTIFIER)) return true;
3406 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3407 if (jj_3R_29()) return true;
3408 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3409 return false;
3410 }
3411
3412 final private boolean jj_3R_120()
3413 {
3414 if (jj_scan_token(COMMA)) return true;
3415 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3416 if (jj_3R_75()) return true;
3417 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3418 return false;
3419 }
3420
3421 final private boolean jj_3R_50()
3422 {
3423 if (jj_3R_75()) return true;
3424 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3425 Token xsp;
3426 while (true)
3427 {
3428 xsp = jj_scanpos;
3429 if (jj_3R_76())
3430 {
3431 jj_scanpos = xsp;
3432 break;
3433 }
3434 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3435 }
3436 return false;
3437 }
3438
3439 final private boolean jj_3R_27()
3440 {
3441 if (jj_3R_48()) return true;
3442 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3443 if (jj_scan_token(LPAREN)) return true;
3444 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3445 Token xsp;
3446 xsp = jj_scanpos;
3447 if (jj_3R_50()) jj_scanpos = xsp;
3448 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3449 if (jj_scan_token(RPAREN)) return true;
3450 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3451 if (jj_scan_token(SEMICOLON)) return true;
3452 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3453 return false;
3454 }
3455
3456 final private boolean jj_3R_92()
3457 {
3458 if (jj_scan_token(FOR)) return true;
3459 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3460 if (jj_scan_token(LPAREN)) return true;
3461 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3462 return false;
3463 }
3464
3465 final private boolean jj_3R_71()
3466 {
3467 if (jj_scan_token(CHOOSE)) return true;
3468 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3469 if (jj_scan_token(IDENTIFIER)) return true;
3470 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3471 return false;
3472 }
3473
3474 final private boolean jj_3R_119()
3475 {
3476 if (jj_3R_75()) return true;
3477 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3478 Token xsp;
3479 while (true)
3480 {
3481 xsp = jj_scanpos;
3482 if (jj_3R_120())
3483 {
3484 jj_scanpos = xsp;
3485 break;
3486 }
3487 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3488 }
3489 return false;
3490 }
3491
3492 final private boolean jj_3R_81()
3493 {
3494 if (jj_3R_92()) return true;
3495 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3496 return false;
3497 }
3498
3499 final private boolean jj_3_7()
3500 {
3501 if (jj_3R_28()) return true;
3502 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3503 return false;
3504 }
3505
3506 final private boolean jj_3R_65()
3507 {
3508 Token xsp;
3509 xsp = jj_scanpos;
3510 if (jj_3_7())
3511 {
3512 jj_scanpos = xsp;
3513 if (jj_3R_81()) return true;
3514 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3515 }
3516 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3517 return false;
3518 }
3519
3520 final private boolean jj_3R_108()
3521 {
3522 if (jj_scan_token(LPAREN)) return true;
3523 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3524 Token xsp;
3525 xsp = jj_scanpos;
3526 if (jj_3R_119()) jj_scanpos = xsp;
3527 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3528 if (jj_scan_token(RPAREN)) return true;
3529 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3530 return false;
3531 }
3532
3533 final private boolean jj_3R_64()
3534 {
3535 if (jj_scan_token(SUBSCRIPT)) return true;
3536 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3537 if (jj_3R_80()) return true;
3538 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3539 return false;
3540 }
3541
3542 final private boolean jj_3R_107()
3543 {
3544 if (jj_scan_token(BANG)) return true;
3545 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3546 return false;
3547 }
3548
3549 final private boolean jj_3R_93()
3550 {
3551 Token xsp;
3552 xsp = jj_scanpos;
3553 if (jj_3R_107()) jj_scanpos = xsp;
3554 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3555 if (jj_3R_48()) return true;
3556 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3557 xsp = jj_scanpos;
3558 if (jj_3R_108()) jj_scanpos = xsp;
3559 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3560 return false;
3561 }
3562
3563 final private boolean jj_3R_57()
3564 {
3565 if (jj_scan_token(SET)) return true;
3566 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3567 if (jj_scan_token(IDENTIFIER)) return true;
3568 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3569 return false;
3570 }
3571
3572 final private boolean jj_3R_47()
3573 {
3574 if (jj_3R_72()) return true;
3575 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3576 return false;
3577 }
3578
3579 final private boolean jj_3R_46()
3580 {
3581 if (jj_3R_71()) return true;
3582 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3583 return false;
3584 }
3585
3586 final private boolean jj_3R_45()
3587 {
3588 if (jj_3R_70()) return true;
3589 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3590 return false;
3591 }
3592
3593 final private boolean jj_3R_44()
3594 {
3595 if (jj_3R_69()) return true;
3596 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3597 return false;
3598 }
3599
3600 final private boolean jj_3_9()
3601 {
3602 if (jj_3R_29()) return true;
3603 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3604 return false;
3605 }
3606
3607 final private boolean jj_3R_43()
3608 {
3609 if (jj_3R_68()) return true;
3610 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3611 return false;
3612 }
3613
3614 final private boolean jj_3R_42()
3615 {
3616 if (jj_3R_67()) return true;
3617 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3618 return false;
3619 }
3620
3621 final private boolean jj_3R_23()
3622 {
3623 if (jj_scan_token(STAR)) return true;
3624 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3625 return false;
3626 }
3627
3628 final private boolean jj_3R_88()
3629 {
3630 if (jj_scan_token(LPAREN)) return true;
3631 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3632 if (jj_3R_75()) return true;
3633 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3634 if (jj_scan_token(RPAREN)) return true;
3635 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3636 Token xsp;
3637 while (true)
3638 {
3639 xsp = jj_scanpos;
3640 if (jj_3_9())
3641 {
3642 jj_scanpos = xsp;
3643 break;
3644 }
3645 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3646 }
3647 return false;
3648 }
3649
3650 final private boolean jj_3R_41()
3651 {
3652 if (jj_3R_66()) return true;
3653 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3654 return false;
3655 }
3656
3657 final private boolean jj_3R_87()
3658 {
3659 if (jj_3R_98()) return true;
3660 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3661 return false;
3662 }
3663
3664 final private boolean jj_3R_40()
3665 {
3666 if (jj_3R_65()) return true;
3667 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3668 return false;
3669 }
3670
3671 final private boolean jj_3R_86()
3672 {
3673 if (jj_3R_97()) return true;
3674 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3675 return false;
3676 }
3677
3678 final private boolean jj_3_6()
3679 {
3680 if (jj_3R_27()) return true;
3681 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3682 return false;
3683 }
3684
3685 final private boolean jj_3R_85()
3686 {
3687 if (jj_3R_96()) return true;
3688 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3689 return false;
3690 }
3691
3692 final private boolean jj_3_5()
3693 {
3694 if (jj_3R_26()) return true;
3695 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3696 return false;
3697 }
3698
3699 final private boolean jj_3R_84()
3700 {
3701 if (jj_3R_95()) return true;
3702 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3703 return false;
3704 }
3705
3706 final private boolean jj_3R_39()
3707 {
3708 if (jj_3R_64()) return true;
3709 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3710 return false;
3711 }
3712
3713 final private boolean jj_3R_38()
3714 {
3715 if (jj_3R_63()) return true;
3716 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3717 return false;
3718 }
3719
3720 final private boolean jj_3_11()
3721 {
3722 if (jj_3R_31()) return true;
3723 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3724 return false;
3725 }
3726
3727 final private boolean jj_3R_37()
3728 {
3729 if (jj_3R_62()) return true;
3730 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3731 return false;
3732 }
3733
3734 final private boolean jj_3R_83()
3735 {
3736 if (jj_3R_94()) return true;
3737 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3738 return false;
3739 }
3740
3741 final private boolean jj_3R_36()
3742 {
3743 if (jj_3R_61()) return true;
3744 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3745 return false;
3746 }
3747
3748 final private boolean jj_3R_82()
3749 {
3750 if (jj_3R_93()) return true;
3751 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3752 return false;
3753 }
3754
3755 final private boolean jj_3R_35()
3756 {
3757 if (jj_3R_60()) return true;
3758 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3759 return false;
3760 }
3761
3762 final private boolean jj_3R_34()
3763 {
3764 if (jj_3R_59()) return true;
3765 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3766 return false;
3767 }
3768
3769 final private boolean jj_3R_33()
3770 {
3771 if (jj_3R_58()) return true;
3772 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3773 return false;
3774 }
3775
3776 final private boolean jj_3_10()
3777 {
3778 if (jj_3R_30()) return true;
3779 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3780 return false;
3781 }
3782
3783 final private boolean jj_3R_32()
3784 {
3785 if (jj_3R_57()) return true;
3786 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3787 return false;
3788 }
3789
3790 final private boolean jj_3_4()
3791 {
3792 if (jj_3R_25()) return true;
3793 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3794 return false;
3795 }
3796
3797 final private boolean jj_3R_73()
3798 {
3799 Token xsp;
3800 xsp = jj_scanpos;
3801 if (jj_3_10())
3802 {
3803 jj_scanpos = xsp;
3804 if (jj_3R_82())
3805 {
3806 jj_scanpos = xsp;
3807 if (jj_3R_83())
3808 {
3809 jj_scanpos = xsp;
3810 if (jj_3_11())
3811 {
3812 jj_scanpos = xsp;
3813 if (jj_3R_84())
3814 {
3815 jj_scanpos = xsp;
3816 if (jj_3R_85())
3817 {
3818 jj_scanpos = xsp;
3819 if (jj_3R_86())
3820 {
3821 jj_scanpos = xsp;
3822 if (jj_3R_87())
3823 {
3824 jj_scanpos = xsp;
3825 if (jj_3R_88()) return true;
3826 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3827 }
3828 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3829 }
3830 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3831 }
3832 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3833 }
3834 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3835 }
3836 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3837 }
3838 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3839 }
3840 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3841 }
3842 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3843 return false;
3844 }
3845
3846 final private boolean jj_3R_24()
3847 {
3848 Token xsp;
3849 xsp = jj_scanpos;
3850 if (jj_3_4())
3851 {
3852 jj_scanpos = xsp;
3853 if (jj_3R_32())
3854 {
3855 jj_scanpos = xsp;
3856 if (jj_3R_33())
3857 {
3858 jj_scanpos = xsp;
3859 if (jj_3R_34())
3860 {
3861 jj_scanpos = xsp;
3862 if (jj_3R_35())
3863 {
3864 jj_scanpos = xsp;
3865 if (jj_3R_36())
3866 {
3867 jj_scanpos = xsp;
3868 if (jj_3R_37())
3869 {
3870 jj_scanpos = xsp;
3871 if (jj_3R_38())
3872 {
3873 jj_scanpos = xsp;
3874 if (jj_3R_39())
3875 {
3876 jj_scanpos = xsp;
3877 if (jj_3_5())
3878 {
3879 jj_scanpos = xsp;
3880 if (jj_3_6())
3881 {
3882 jj_scanpos = xsp;
3883 if (jj_3R_40())
3884 {
3885 jj_scanpos = xsp;
3886 if (jj_3R_41())
3887 {
3888 jj_scanpos = xsp;
3889 if (jj_3R_42())
3890 {
3891 jj_scanpos = xsp;
3892 if (jj_3R_43())
3893 {
3894 jj_scanpos = xsp;
3895 if (jj_3R_44())
3896 {
3897 jj_scanpos = xsp;
3898 if (jj_3R_45())
3899 {
3900 jj_scanpos = xsp;
3901 if (jj_3R_46())
3902 {
3903 jj_scanpos = xsp;
3904 if (jj_3R_47()) return true;
3905 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3906 }
3907 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3908 }
3909 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3910 }
3911 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3912 }
3913 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3914 }
3915 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3916 }
3917 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3918 }
3919 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3920 }
3921 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3922 }
3923 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3924 }
3925 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3926 }
3927 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3928 }
3929 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3930 }
3931 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3932 }
3933 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3934 }
3935 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3936 }
3937 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3938 }
3939 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3940 }
3941 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3942 return false;
3943 }
3944
3945 final private boolean jj_3R_69()
3946 {
3947 if (jj_scan_token(CUSTOMPANEL)) return true;
3948 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3949 if (jj_scan_token(STRING_LITERAL)) return true;
3950 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3951 return false;
3952 }
3953
3954 final private boolean jj_3R_104()
3955 {
3956 if (jj_scan_token(DOT)) return true;
3957 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3958 return false;
3959 }
3960
3961 final private boolean jj_3R_103()
3962 {
3963 if (jj_scan_token(REM)) return true;
3964 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3965 return false;
3966 }
3967
3968 final private boolean jj_3R_102()
3969 {
3970 if (jj_scan_token(SLASH)) return true;
3971 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3972 return false;
3973 }
3974
3975 final private boolean jj_3R_101()
3976 {
3977 if (jj_scan_token(STAR)) return true;
3978 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3979 return false;
3980 }
3981
3982 final private boolean jj_3_3()
3983 {
3984 if (jj_3R_24()) return true;
3985 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3986 return false;
3987 }
3988
3989 final private boolean jj_3R_22()
3990 {
3991 if (jj_scan_token(IDENTIFIER)) return true;
3992 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
3993 return false;
3994 }
3995
3996 final private boolean jj_3R_100()
3997 {
3998 if (jj_scan_token(MINUS)) return true;
3999 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4000 return false;
4001 }
4002
4003 final private boolean jj_3R_99()
4004 {
4005 if (jj_scan_token(PLUS)) return true;
4006 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4007 return false;
4008 }
4009
4010 final private boolean jj_3R_51()
4011 {
4012 if (jj_scan_token(LBRACE)) return true;
4013 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4014 Token xsp;
4015 while (true)
4016 {
4017 xsp = jj_scanpos;
4018 if (jj_3_3())
4019 {
4020 jj_scanpos = xsp;
4021 break;
4022 }
4023 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4024 }
4025 if (jj_scan_token(RBRACE)) return true;
4026 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4027 return false;
4028 }
4029
4030 final private boolean jj_3R_89()
4031 {
4032 Token xsp;
4033 xsp = jj_scanpos;
4034 if (jj_3R_99())
4035 {
4036 jj_scanpos = xsp;
4037 if (jj_3R_100())
4038 {
4039 jj_scanpos = xsp;
4040 if (jj_3R_101())
4041 {
4042 jj_scanpos = xsp;
4043 if (jj_3R_102())
4044 {
4045 jj_scanpos = xsp;
4046 if (jj_3R_103())
4047 {
4048 jj_scanpos = xsp;
4049 if (jj_3R_104()) return true;
4050 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4051 }
4052 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4053 }
4054 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4055 }
4056 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4057 }
4058 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4059 }
4060 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4061 return false;
4062 }
4063
4064 final private boolean jj_3R_121()
4065 {
4066 if (jj_scan_token(COMMA)) return true;
4067 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4068 if (jj_3R_75()) return true;
4069 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4070 return false;
4071 }
4072
4073 final private boolean jj_3R_68()
4074 {
4075 if (jj_scan_token(EDIT)) return true;
4076 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4077 if (jj_scan_token(IDENTIFIER)) return true;
4078 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4079 return false;
4080 }
4081
4082 final private boolean jj_3R_74()
4083 {
4084 if (jj_3R_89()) return true;
4085 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4086 if (jj_3R_73()) return true;
4087 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4088 return false;
4089 }
4090
4091 final private boolean jj_3_2()
4092 {
4093 if (jj_scan_token(COMMA)) return true;
4094 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4095 if (jj_scan_token(IDENTIFIER)) return true;
4096 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4097 return false;
4098 }
4099
4100 final private boolean jj_3R_49()
4101 {
4102 if (jj_3R_73()) return true;
4103 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4104 Token xsp;
4105 while (true)
4106 {
4107 xsp = jj_scanpos;
4108 if (jj_3R_74())
4109 {
4110 jj_scanpos = xsp;
4111 break;
4112 }
4113 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4114 }
4115 return false;
4116 }
4117
4118 final private boolean jj_3_1()
4119 {
4120 if (jj_scan_token(DOT)) return true;
4121 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4122 Token xsp;
4123 xsp = jj_scanpos;
4124 if (jj_3R_22())
4125 {
4126 jj_scanpos = xsp;
4127 if (jj_3R_23()) return true;
4128 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4129 }
4130 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4131 return false;
4132 }
4133
4134 final private boolean jj_3R_116()
4135 {
4136 if (jj_scan_token(GE)) return true;
4137 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4138 return false;
4139 }
4140
4141 final private boolean jj_3R_115()
4142 {
4143 if (jj_scan_token(LE)) return true;
4144 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4145 return false;
4146 }
4147
4148 final private boolean jj_3R_114()
4149 {
4150 if (jj_scan_token(GT)) return true;
4151 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4152 return false;
4153 }
4154
4155 final private boolean jj_3R_113()
4156 {
4157 if (jj_scan_token(INSTANCEOF)) return true;
4158 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4159 return false;
4160 }
4161
4162 final private boolean jj_3R_52()
4163 {
4164 if (jj_3R_75()) return true;
4165 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4166 Token xsp;
4167 while (true)
4168 {
4169 xsp = jj_scanpos;
4170 if (jj_3R_121())
4171 {
4172 jj_scanpos = xsp;
4173 break;
4174 }
4175 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4176 }
4177 return false;
4178 }
4179
4180 final private boolean jj_3R_112()
4181 {
4182 if (jj_scan_token(LT)) return true;
4183 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4184 return false;
4185 }
4186
4187 final private boolean jj_3R_111()
4188 {
4189 if (jj_scan_token(NE)) return true;
4190 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4191 return false;
4192 }
4193
4194 final private boolean jj_3R_25()
4195 {
4196 if (jj_scan_token(IDENTIFIER)) return true;
4197 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4198 if (jj_scan_token(IDENTIFIER)) return true;
4199 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4200 return false;
4201 }
4202
4203 final private boolean jj_3R_110()
4204 {
4205 if (jj_scan_token(EQ)) return true;
4206 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4207 return false;
4208 }
4209
4210 final private boolean jj_3R_29()
4211 {
4212 if (jj_scan_token(LPAREN)) return true;
4213 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4214 Token xsp;
4215 xsp = jj_scanpos;
4216 if (jj_3R_52()) jj_scanpos = xsp;
4217 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4218 if (jj_scan_token(RPAREN)) return true;
4219 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4220 return false;
4221 }
4222
4223 final private boolean jj_3R_105()
4224 {
4225 Token xsp;
4226 xsp = jj_scanpos;
4227 if (jj_3R_110())
4228 {
4229 jj_scanpos = xsp;
4230 if (jj_3R_111())
4231 {
4232 jj_scanpos = xsp;
4233 if (jj_3R_112())
4234 {
4235 jj_scanpos = xsp;
4236 if (jj_3R_113())
4237 {
4238 jj_scanpos = xsp;
4239 if (jj_3R_114())
4240 {
4241 jj_scanpos = xsp;
4242 if (jj_3R_115())
4243 {
4244 jj_scanpos = xsp;
4245 if (jj_3R_116()) return true;
4246 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4247 }
4248 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4249 }
4250 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4251 }
4252 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4253 }
4254 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4255 }
4256 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4257 }
4258 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4259 if (jj_3R_49()) return true;
4260 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4261 return false;
4262 }
4263
4264 final private boolean jj_3R_90()
4265 {
4266 if (jj_3R_49()) return true;
4267 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4268 Token xsp;
4269 while (true)
4270 {
4271 xsp = jj_scanpos;
4272 if (jj_3R_105())
4273 {
4274 jj_scanpos = xsp;
4275 break;
4276 }
4277 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4278 }
4279 return false;
4280 }
4281
4282 final private boolean jj_3R_55()
4283 {
4284 if (jj_scan_token(FALSE)) return true;
4285 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4286 return false;
4287 }
4288
4289 final private boolean jj_3R_58()
4290 {
4291 if (jj_scan_token(DELETE)) return true;
4292 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4293 if (jj_3R_48()) return true;
4294 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4295 return false;
4296 }
4297
4298 final private boolean jj_3R_98()
4299 {
4300 if (jj_scan_token(NULL)) return true;
4301 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4302 return false;
4303 }
4304
4305 final private boolean jj_3R_118()
4306 {
4307 if (jj_scan_token(SC_AND)) return true;
4308 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4309 return false;
4310 }
4311
4312 final private boolean jj_3R_117()
4313 {
4314 if (jj_scan_token(SC_OR)) return true;
4315 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4316 return false;
4317 }
4318
4319 final private boolean jj_3R_106()
4320 {
4321 Token xsp;
4322 xsp = jj_scanpos;
4323 if (jj_3R_117())
4324 {
4325 jj_scanpos = xsp;
4326 if (jj_3R_118()) return true;
4327 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4328 }
4329 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4330 return false;
4331 }
4332
4333 final private boolean jj_3R_70()
4334 {
4335 if (jj_scan_token(JAVA)) return true;
4336 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4337 if (jj_scan_token(STRING_LITERAL)) return true;
4338 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4339 return false;
4340 }
4341
4342 final private boolean jj_3R_53()
4343 {
4344 if (jj_scan_token(BANG)) return true;
4345 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4346 return false;
4347 }
4348
4349 final private boolean jj_3R_54()
4350 {
4351 if (jj_scan_token(TRUE)) return true;
4352 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4353 return false;
4354 }
4355
4356 final private boolean jj_3R_30()
4357 {
4358 Token xsp;
4359 xsp = jj_scanpos;
4360 if (jj_3R_53()) jj_scanpos = xsp;
4361 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4362 xsp = jj_scanpos;
4363 if (jj_3R_54())
4364 {
4365 jj_scanpos = xsp;
4366 if (jj_3R_55()) return true;
4367 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4368 }
4369 else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4370 return false;
4371 }
4372
4373 final private boolean jj_3R_91()
4374 {
4375 if (jj_3R_106()) return true;
4376 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4377 if (jj_3R_90()) return true;
4378 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4379 return false;
4380 }
4381
4382 final private boolean jj_3R_72()
4383 {
4384 if (jj_scan_token(ACTION)) return true;
4385 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4386 if (jj_scan_token(IDENTIFIER)) return true;
4387 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4388 return false;
4389 }
4390
4391 final private boolean jj_3R_26()
4392 {
4393 if (jj_3R_48()) return true;
4394 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4395 if (jj_scan_token(ASSIGN)) return true;
4396 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4397 if (jj_3R_49()) return true;
4398 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4399 if (jj_scan_token(SEMICOLON)) return true;
4400 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4401 return false;
4402 }
4403
4404 final private boolean jj_3R_75()
4405 {
4406 if (jj_3R_90()) return true;
4407 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4408 Token xsp;
4409 while (true)
4410 {
4411 xsp = jj_scanpos;
4412 if (jj_3R_91())
4413 {
4414 jj_scanpos = xsp;
4415 break;
4416 }
4417 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4418 }
4419 return false;
4420 }
4421
4422 final private boolean jj_3R_97()
4423 {
4424 if (jj_scan_token(STRING_LITERAL)) return true;
4425 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4426 return false;
4427 }
4428
4429 final private boolean jj_3_8()
4430 {
4431 if (jj_scan_token(DOT)) return true;
4432 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4433 if (jj_scan_token(IDENTIFIER)) return true;
4434 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4435 return false;
4436 }
4437
4438 final private boolean jj_3R_80()
4439 {
4440 if (jj_scan_token(IDENTIFIER)) return true;
4441 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4442 return false;
4443 }
4444
4445 final private boolean jj_3R_60()
4446 {
4447 if (jj_scan_token(FAIL)) return true;
4448 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4449 if (jj_scan_token(LPAREN)) return true;
4450 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4451 return false;
4452 }
4453
4454 final private boolean jj_3R_48()
4455 {
4456 if (jj_scan_token(IDENTIFIER)) return true;
4457 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4458 Token xsp;
4459 while (true)
4460 {
4461 xsp = jj_scanpos;
4462 if (jj_3_8())
4463 {
4464 jj_scanpos = xsp;
4465 break;
4466 }
4467 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
4468 }
4469 return false;
4470 }
4471
4472 public DjScriptParserEngineTokenManager token_source;
4473 JavaCharStream jj_input_stream;
4474 public Token token, jj_nt;
4475 private int jj_ntk;
4476 private Token jj_scanpos, jj_lastpos;
4477 private int jj_la;
4478 public boolean lookingAhead = false;
4479 private boolean jj_semLA;
4480 private int jj_gen;
4481 final private int[] jj_la1 = new int[56];
4482 static private int[] jj_la1_0;
4483 static private int[] jj_la1_1;
4484 static private int[] jj_la1_2;
4485 static private int[] jj_la1_3;
4486 static
4487 {
4488 jj_la1_0();
4489 jj_la1_1();
4490 jj_la1_2();
4491 jj_la1_3();
4492 }
4493
4494 private static void jj_la1_0()
4495 {
4496 jj_la1_0 = new int[]{0x100000, 0x800000, 0x0, 0x0, 0x0, 0x800000, 0x0, 0x0, 0x0, 0x100000, 0x200000, 0x800000, 0x0,
4497 0x100000, 0x0, 0x0, 0x0, 0x86400000, 0x78000000, 0x0, 0x20000000, 0x0, 0x0, 0x20000000, 0x0, 0x0, 0x0, 0x0,
4498 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a0000, 0x0, 0x0, 0x1a2000, 0x0,
4499 0x0, 0x1a2000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a2000,};
4500 }
4501
4502 private static void jj_la1_1()
4503 {
4504 jj_la1_1 = new int[]{0x0, 0x0, 0x40, 0x1000000, 0x20, 0x0, 0x40, 0x1000000, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0,
4505 0x1000000, 0x1000000, 0x1000000, 0x11e, 0x50840, 0x8000000, 0x0, 0x1000000, 0x20, 0x0, 0x1000000, 0x6, 0x0,
4506 0x1000000, 0x20, 0x1000000, 0x200, 0x1000, 0x800, 0x200, 0x1000, 0x0, 0x0, 0x0, 0x20000, 0x20000, 0x0, 0x0,
4507 0x1000001, 0x8800000, 0x0, 0x0, 0x9c80001, 0x8000000, 0x0, 0x9c80001, 0x0, 0x0, 0x0, 0x480000, 0x0, 0x9c80001,};
4508 }
4509
4510 private static void jj_la1_2()
4511 {
4512 jj_la1_2 = new int[]{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x400000, 0x400000,
4513 0x400000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4,
4514 0x30000, 0x30000, 0xe860, 0xe860, 0x8f00008, 0x8f00008, 0x80, 0x200000, 0x80, 0x4, 0x200080, 0x0, 0x4,
4515 0x200080, 0x200000, 0x200000, 0x80, 0x0, 0x4, 0x200080,};
4516 }
4517
4518 private static void jj_la1_3()
4519 {
4520 jj_la1_3 = new int[]{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4521 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
4522 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,};
4523 }
4524
4525 final private JJCalls[] jj_2_rtns = new JJCalls[11];
4526 private boolean jj_rescan = false;
4527 private int jj_gc = 0;
4528
4529 public DjScriptParserEngine(java.io.InputStream stream)
4530 {
4531 jj_input_stream = new JavaCharStream(stream, 1, 1);
4532 token_source = new DjScriptParserEngineTokenManager(jj_input_stream);
4533 token = new Token();
4534 jj_ntk = -1;
4535 jj_gen = 0;
4536 for (int i = 0; i < 56; i++)
4537 jj_la1[i] = -1;
4538 for (int i = 0; i < jj_2_rtns.length; i++)
4539 jj_2_rtns[i] = new JJCalls();
4540 }
4541
4542 public void ReInit(java.io.InputStream stream)
4543 {
4544 jj_input_stream.ReInit(stream, 1, 1);
4545 token_source.ReInit(jj_input_stream);
4546 token = new Token();
4547 jj_ntk = -1;
4548 jjtree.reset();
4549 jj_gen = 0;
4550 for (int i = 0; i < 56; i++)
4551 jj_la1[i] = -1;
4552 for (int i = 0; i < jj_2_rtns.length; i++)
4553 jj_2_rtns[i] = new JJCalls();
4554 }
4555
4556 public DjScriptParserEngine(java.io.Reader stream)
4557 {
4558 jj_input_stream = new JavaCharStream(stream, 1, 1);
4559 token_source = new DjScriptParserEngineTokenManager(jj_input_stream);
4560 token = new Token();
4561 jj_ntk = -1;
4562 jj_gen = 0;
4563 for (int i = 0; i < 56; i++)
4564 jj_la1[i] = -1;
4565 for (int i = 0; i < jj_2_rtns.length; i++)
4566 jj_2_rtns[i] = new JJCalls();
4567 }
4568
4569 public void ReInit(java.io.Reader stream)
4570 {
4571 jj_input_stream.ReInit(stream, 1, 1);
4572 token_source.ReInit(jj_input_stream);
4573 token = new Token();
4574 jj_ntk = -1;
4575 jjtree.reset();
4576 jj_gen = 0;
4577 for (int i = 0; i < 56; i++)
4578 jj_la1[i] = -1;
4579 for (int i = 0; i < jj_2_rtns.length; i++)
4580 jj_2_rtns[i] = new JJCalls();
4581 }
4582
4583 public DjScriptParserEngine(DjScriptParserEngineTokenManager tm)
4584 {
4585 token_source = tm;
4586 token = new Token();
4587 jj_ntk = -1;
4588 jj_gen = 0;
4589 for (int i = 0; i < 56; i++)
4590 jj_la1[i] = -1;
4591 for (int i = 0; i < jj_2_rtns.length; i++)
4592 jj_2_rtns[i] = new JJCalls();
4593 }
4594
4595 public void ReInit(DjScriptParserEngineTokenManager tm)
4596 {
4597 token_source = tm;
4598 token = new Token();
4599 jj_ntk = -1;
4600 jjtree.reset();
4601 jj_gen = 0;
4602 for (int i = 0; i < 56; i++)
4603 jj_la1[i] = -1;
4604 for (int i = 0; i < jj_2_rtns.length; i++)
4605 jj_2_rtns[i] = new JJCalls();
4606 }
4607
4608 final private Token jj_consume_token(int kind) throws ParseException
4609 {
4610 Token oldToken;
4611 if ((oldToken = token).next != null) token = token.next;
4612 else token = token.next = token_source.getNextToken();
4613 jj_ntk = -1;
4614 if (token.kind == kind)
4615 {
4616 jj_gen++;
4617 if (++jj_gc > 100)
4618 {
4619 jj_gc = 0;
4620 for (int i = 0; i < jj_2_rtns.length; i++)
4621 {
4622 JJCalls c = jj_2_rtns[i];
4623 while (c != null)
4624 {
4625 if (c.gen < jj_gen) c.first = null;
4626 c = c.next;
4627 }
4628 }
4629 }
4630 return token;
4631 }
4632 token = oldToken;
4633 jj_kind = kind;
4634 throw generateParseException();
4635 }
4636
4637 final private boolean jj_scan_token(int kind)
4638 {
4639 if (jj_scanpos == jj_lastpos)
4640 {
4641 jj_la--;
4642 if (jj_scanpos.next == null)
4643 {
4644 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
4645 }
4646 else
4647 {
4648 jj_lastpos = jj_scanpos = jj_scanpos.next;
4649 }
4650 }
4651 else
4652 {
4653 jj_scanpos = jj_scanpos.next;
4654 }
4655 if (jj_rescan)
4656 {
4657 int i = 0;
4658 Token tok = token;
4659 while (tok != null && tok != jj_scanpos)
4660 {
4661 i++;
4662 tok = tok.next;
4663 }
4664 if (tok != null) jj_add_error_token(kind, i);
4665 }
4666 return (jj_scanpos.kind != kind);
4667 }
4668
4669 final public Token getNextToken()
4670 {
4671 if (token.next != null) token = token.next;
4672 else token = token.next = token_source.getNextToken();
4673 jj_ntk = -1;
4674 jj_gen++;
4675 return token;
4676 }
4677
4678 final public Token getToken(int index)
4679 {
4680 Token t = lookingAhead ? jj_scanpos : token;
4681 for (int i = 0; i < index; i++)
4682 {
4683 if (t.next != null) t = t.next;
4684 else t = t.next = token_source.getNextToken();
4685 }
4686 return t;
4687 }
4688
4689 final private int jj_ntk()
4690 {
4691 if ((jj_nt = token.next) == null) return (jj_ntk = (token.next = token_source.getNextToken()).kind);
4692 else return (jj_ntk = jj_nt.kind);
4693 }
4694
4695 private java.util.Vector jj_expentries = new java.util.Vector ();
4696 private int[] jj_expentry;
4697 private int jj_kind = -1;
4698 private int[] jj_lasttokens = new int[100];
4699 private int jj_endpos;
4700
4701 private void jj_add_error_token(int kind, int pos)
4702 {
4703 if (pos >= 100) return;
4704 if (pos == jj_endpos + 1)
4705 {
4706 jj_lasttokens[jj_endpos++] = kind;
4707 }
4708 else if (jj_endpos != 0)
4709 {
4710 jj_expentry = new int[jj_endpos];
4711 for (int i = 0; i < jj_endpos; i++)
4712 {
4713 jj_expentry[i] = jj_lasttokens[i];
4714 }
4715 boolean exists = false;
4716 for (java.util.Enumeration enum1 = jj_expentries.elements(); enum1.hasMoreElements();)
4717 {
4718 int[] oldentry = (int[]) (enum1.nextElement());
4719 if (oldentry.length == jj_expentry.length)
4720 {
4721 exists = true;
4722 for (int i = 0; i < jj_expentry.length; i++)
4723 {
4724 if (oldentry[i] != jj_expentry[i])
4725 {
4726 exists = false;
4727 break;
4728 }
4729 }
4730 if (exists) break;
4731 }
4732 }
4733 if (!exists) jj_expentries.addElement(jj_expentry);
4734 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
4735 }
4736 }
4737
4738 public ParseException generateParseException()
4739 {
4740 jj_expentries.removeAllElements();
4741 boolean[] la1tokens = new boolean[106];
4742 for (int i = 0; i < 106; i++)
4743 {
4744 la1tokens[i] = false;
4745 }
4746 if (jj_kind >= 0)
4747 {
4748 la1tokens[jj_kind] = true;
4749 jj_kind = -1;
4750 }
4751 for (int i = 0; i < 56; i++)
4752 {
4753 if (jj_la1[i] == jj_gen)
4754 {
4755 for (int j = 0; j < 32; j++)
4756 {
4757 if ((jj_la1_0[i] & (1 << j)) != 0)
4758 {
4759 la1tokens[j] = true;
4760 }
4761 if ((jj_la1_1[i] & (1 << j)) != 0)
4762 {
4763 la1tokens[32 + j] = true;
4764 }
4765 if ((jj_la1_2[i] & (1 << j)) != 0)
4766 {
4767 la1tokens[64 + j] = true;
4768 }
4769 if ((jj_la1_3[i] & (1 << j)) != 0)
4770 {
4771 la1tokens[96 + j] = true;
4772 }
4773 }
4774 }
4775 }
4776 for (int i = 0; i < 106; i++)
4777 {
4778 if (la1tokens[i])
4779 {
4780 jj_expentry = new int[1];
4781 jj_expentry[0] = i;
4782 jj_expentries.addElement(jj_expentry);
4783 }
4784 }
4785 jj_endpos = 0;
4786 jj_rescan_token();
4787 jj_add_error_token(0, 0);
4788 int[][] exptokseq = new int[jj_expentries.size()][];
4789 for (int i = 0; i < jj_expentries.size(); i++)
4790 {
4791 exptokseq[i] = (int[]) jj_expentries.elementAt(i);
4792 }
4793 return new ParseException(token, exptokseq, tokenImage);
4794 }
4795
4796 final public void enable_tracing()
4797 {
4798 }
4799
4800 final public void disable_tracing()
4801 {
4802 }
4803
4804 final private void jj_rescan_token()
4805 {
4806 jj_rescan = true;
4807 for (int i = 0; i < 11; i++)
4808 {
4809 JJCalls p = jj_2_rtns[i];
4810 do
4811 {
4812 if (p.gen > jj_gen)
4813 {
4814 jj_la = p.arg;
4815 jj_lastpos = jj_scanpos = p.first;
4816 switch (i)
4817 {
4818 case 0 :
4819 jj_3_1();
4820 break;
4821 case 1 :
4822 jj_3_2();
4823 break;
4824 case 2 :
4825 jj_3_3();
4826 break;
4827 case 3 :
4828 jj_3_4();
4829 break;
4830 case 4 :
4831 jj_3_5();
4832 break;
4833 case 5 :
4834 jj_3_6();
4835 break;
4836 case 6 :
4837 jj_3_7();
4838 break;
4839 case 7 :
4840 jj_3_8();
4841 break;
4842 case 8 :
4843 jj_3_9();
4844 break;
4845 case 9 :
4846 jj_3_10();
4847 break;
4848 case 10 :
4849 jj_3_11();
4850 break;
4851 }
4852 }
4853 p = p.next;
4854 }
4855 while (p != null);
4856 }
4857 jj_rescan = false;
4858 }
4859
4860 final private void jj_save(int index, int xla)
4861 {
4862 JJCalls p = jj_2_rtns[index];
4863 while (p.gen > jj_gen)
4864 {
4865 if (p.next == null)
4866 {
4867 p = p.next = new JJCalls();
4868 break;
4869 }
4870 p = p.next;
4871 }
4872 p.gen = jj_gen + xla - jj_la;
4873 p.first = token;
4874 p.arg = xla;
4875 }
4876
4877 static final class JJCalls
4878 {
4879 int gen;
4880 Token first;
4881 int arg;
4882 JJCalls next;
4883 }
4884
4885} |
Popular Tags |
Java API By Example, From Geeks To Geeks.