|
1
2 package org.python.parser;
3 import org.python.parser.ast.modType;
4
5 public class PythonGrammarimplements PythonGrammarTreeConstants, PythonGrammarConstants {
6 protected JJTPythonGrammarState jjtree = new JJTPythonGrammarState();public IParserHost hostLiteralMkr;
7
8 void jjtreeOpenNodeScope(Node n) {
9 Token t = getToken(1);
10 jjtree.pushNodePos(t.beginLine, t.beginColumn);
11 }
12
13 void jjtreeCloseNodeScope(Node n) {
14 jjtree.setNodePos();
15 }
16
17 Object  makeInt(String s, int radix) {
18 if (s.endsWith("L") || s.endsWith("l")) {
19 s = s.substring(0, s.length()-1);
20 return hostLiteralMkr.newLong(new java.math.BigInteger (s, radix));
21 }
22 int ndigits = s.length();
23 int i=0;
24 while (i < ndigits && s.charAt(i) == '0')
25 i++;
26 if ((ndigits - i) > 11) {
27 return hostLiteralMkr.newLong(new java.math.BigInteger (s, radix));
28 }
29
30 long l = Long.valueOf(s, radix).longValue();
31 if (l > 0xffffffffl || (radix == 10 && l > Integer.MAX_VALUE)) {
32 return hostLiteralMkr.newLong(new java.math.BigInteger (s, radix));
33 }
34 return hostLiteralMkr.newInteger((int) l);
35 }
36
37 Object makeFloat(String s) {
38 return hostLiteralMkr.newFloat(Double.valueOf(s).doubleValue());
39 }
40
41 Object makeLong(String s) {
42 return hostLiteralMkr.newLong(s);
43 }
44
45 Object makeComplex(String s) {
46 s = s.substring(0, s.length() - 1);
47 return hostLiteralMkr.newImaginary(Double.valueOf(s).doubleValue());
48 }
49
50 String makeString(String s, int quotes) {
51 char quoteChar = s.charAt(0);
53 int start=0;
54 boolean ustring = false;
55 if (quoteChar == 'u' || quoteChar == 'U') {
56 ustring = true;
57 start++;
58 }
59 quoteChar = s.charAt(start);
60 if (quoteChar == 'r' || quoteChar == 'R') {
61 return s.substring(quotes+start+1, s.length()-quotes);
62 } else {
63 StringBuffer sb = new StringBuffer (s.length());
64 char[] ca = s.toCharArray();
65 int n = ca.length-quotes;
66 int i=quotes+start;
67 int last_i=i;
68
69 return hostLiteralMkr.decode_UnicodeEscape(s, i, n, "strict", ustring);
70 }
71 }
72
73 private static final int MAX_LOOKAHEAD = 3;
75
76 public boolean partial_valid_sentence(Throwable t) {
77 if (t instanceof TokenMgrError) {
78 TokenMgrError e = (TokenMgrError)t;
81 switch(e.lexState) {
82 case IN_STRING1NLC:
83 case IN_STRING2NLC:
84 case IN_STRING13:
85 case IN_STRING23:
86 return e.EOFSeen;
87 default:
88 return false;
89 }
90 }
91 if (!(t instanceof ParseException))
92 return false;
93 try {
94 ParseException e = (ParseException)t;
95 int tok = getNextToken().kind;
96 if (tok == EOF) return true;
98
101 int[][] expected = e.expectedTokenSequences;
102
103 if (expected == null) return false;
104
105 int[] ahead = new int[MAX_LOOKAHEAD-1];
106
107 int i = 0;
108 for(;;) {
109 ahead[i] = tok;
110 i++;
111 tok = getNextToken().kind;
112 if (tok == EOF) break;
113 if (i >= MAX_LOOKAHEAD-1) return false;
114 }
115
116 int nahead = i;
117
118 next_expected:
119 for(int j = 0; j<expected.length; j++) {
120 int[] cand = expected[j];
121
122 if (cand.length <= nahead ) continue next_expected;
123
124 for(int k = 0; k < nahead; k++)
125 if (ahead[k] != cand[k])
126 continue next_expected;
127 return true;
128 }
129
130 return false;
131 } catch (TokenMgrError e1) {
132 return false;
133 }
134 }
135
136
138 public PythonGrammar(CharStream stream,IParserHost host) {
139 this(stream);
140 hostLiteralMkr = host;
141 }
142
143 public PythonGrammar(PythonGrammarTokenManager tm,
144 IParserHost host)
145 {
146 this(tm);
147 hostLiteralMkr = host;
148 }
149
150 final public modType single_input() throws ParseException {
153
154 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSINGLE_INPUT);
155 boolean jjtc000 = true;
156 jjtree.openNodeScope(jjtn000);
157 jjtreeOpenNodeScope(jjtn000);token_source.single_input=true;
158 try {
159 label_1:
160 while (true) {
161 if (jj_2_1(2)) {
162 ;
163 } else {
164 break label_1;
165 }
166 jj_consume_token(NEWLINE);
167 }
168 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
169 case LPAREN:
170 case LBRACE:
171 case LBRACKET:
172 case PLUS:
173 case MINUS:
174 case NOT:
175 case NOT_BOOL:
176 case LAMBDA:
177 case IF:
178 case WHILE:
179 case FOR:
180 case TRY:
181 case DEF:
182 case CLASS:
183 case PRINT:
184 case PASS:
185 case BREAK:
186 case CONTINUE:
187 case RETURN:
188 case YIELD:
189 case IMPORT:
190 case FROM:
191 case DEL:
192 case RAISE:
193 case GLOBAL:
194 case EXEC:
195 case ASSERT:
196 case AS:
197 case NAME:
198 case DECNUMBER:
199 case HEXNUMBER:
200 case OCTNUMBER:
201 case FLOAT:
202 case COMPLEX:
203 case SINGLE_STRING:
204 case SINGLE_STRING2:
205 case TRIPLE_STRING:
206 case TRIPLE_STRING2:
207 case 121:
208 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
209 case LPAREN:
210 case LBRACE:
211 case LBRACKET:
212 case PLUS:
213 case MINUS:
214 case NOT:
215 case NOT_BOOL:
216 case LAMBDA:
217 case PRINT:
218 case PASS:
219 case BREAK:
220 case CONTINUE:
221 case RETURN:
222 case YIELD:
223 case IMPORT:
224 case FROM:
225 case DEL:
226 case RAISE:
227 case GLOBAL:
228 case EXEC:
229 case ASSERT:
230 case AS:
231 case NAME:
232 case DECNUMBER:
233 case HEXNUMBER:
234 case OCTNUMBER:
235 case FLOAT:
236 case COMPLEX:
237 case SINGLE_STRING:
238 case SINGLE_STRING2:
239 case TRIPLE_STRING:
240 case TRIPLE_STRING2:
241 case 121:
242 simple_stmt();
243 break;
244 case IF:
245 case WHILE:
246 case FOR:
247 case TRY:
248 case DEF:
249 case CLASS:
250 compound_stmt();
251 jj_consume_token(NEWLINE);
252 break;
253 default:
254 jj_la1[0] = jj_gen;
255 jj_consume_token(-1);
256 throw new ParseException();
257 }
258 break;
259 default:
260 jj_la1[1] = jj_gen;
261 ;
262 }
263 label_2:
264 while (true) {
265 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
266 case NEWLINE:
267 ;
268 break;
269 default:
270 jj_la1[2] = jj_gen;
271 break label_2;
272 }
273 jj_consume_token(NEWLINE);
274 }
275 jj_consume_token(0);
276 jjtree.closeNodeScope(jjtn000, true);
277 jjtc000 = false;
278 jjtreeCloseNodeScope(jjtn000);
279 {if (true) return (modType) jjtree.popNode();}
280 } catch (Throwable jjte000) {
281 if (jjtc000) {
282 jjtree.clearNodeScope(jjtn000);
283 jjtc000 = false;
284 } else {
285 jjtree.popNode();
286 }
287 if (jjte000 instanceof RuntimeException ) {
288 {if (true) throw (RuntimeException )jjte000;}
289 }
290 if (jjte000 instanceof ParseException) {
291 {if (true) throw (ParseException)jjte000;}
292 }
293 {if (true) throw (Error )jjte000;}
294 } finally {
295 if (jjtc000) {
296 jjtree.closeNodeScope(jjtn000, true);
297 jjtreeCloseNodeScope(jjtn000);
298 }
299 }
300 throw new Error ("Missing return statement in function");
301 }
302
303 final public modType file_input() throws ParseException {
305
306 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTFILE_INPUT);
307 boolean jjtc000 = true;
308 jjtree.openNodeScope(jjtn000);
309 jjtreeOpenNodeScope(jjtn000);token_source.single_input=false;
310 try {
311 label_3:
312 while (true) {
313 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
314 case NEWLINE:
315 case LPAREN:
316 case LBRACE:
317 case LBRACKET:
318 case PLUS:
319 case MINUS:
320 case NOT:
321 case NOT_BOOL:
322 case LAMBDA:
323 case IF:
324 case WHILE:
325 case FOR:
326 case TRY:
327 case DEF:
328 case CLASS:
329 case PRINT:
330 case PASS:
331 case BREAK:
332 case CONTINUE:
333 case RETURN:
334 case YIELD:
335 case IMPORT:
336 case FROM:
337 case DEL:
338 case RAISE:
339 case GLOBAL:
340 case EXEC:
341 case ASSERT:
342 case AS:
343 case NAME:
344 case DECNUMBER:
345 case HEXNUMBER:
346 case OCTNUMBER:
347 case FLOAT:
348 case COMPLEX:
349 case SINGLE_STRING:
350 case SINGLE_STRING2:
351 case TRIPLE_STRING:
352 case TRIPLE_STRING2:
353 case 121:
354 ;
355 break;
356 default:
357 jj_la1[3] = jj_gen;
358 break label_3;
359 }
360 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
361 case NEWLINE:
362 jj_consume_token(NEWLINE);
363 break;
364 case LPAREN:
365 case LBRACE:
366 case LBRACKET:
367 case PLUS:
368 case MINUS:
369 case NOT:
370 case NOT_BOOL:
371 case LAMBDA:
372 case IF:
373 case WHILE:
374 case FOR:
375 case TRY:
376 case DEF:
377 case CLASS:
378 case PRINT:
379 case PASS:
380 case BREAK:
381 case CONTINUE:
382 case RETURN:
383 case YIELD:
384 case IMPORT:
385 case FROM:
386 case DEL:
387 case RAISE:
388 case GLOBAL:
389 case EXEC:
390 case ASSERT:
391 case AS:
392 case NAME:
393 case DECNUMBER:
394 case HEXNUMBER:
395 case OCTNUMBER:
396 case FLOAT:
397 case COMPLEX:
398 case SINGLE_STRING:
399 case SINGLE_STRING2:
400 case TRIPLE_STRING:
401 case TRIPLE_STRING2:
402 case 121:
403 stmt();
404 break;
405 default:
406 jj_la1[4] = jj_gen;
407 jj_consume_token(-1);
408 throw new ParseException();
409 }
410 }
411 jj_consume_token(0);
412 jjtree.closeNodeScope(jjtn000, true);
413 jjtc000 = false;
414 jjtreeCloseNodeScope(jjtn000);
415 {if (true) return (modType) jjtree.popNode();}
416 } catch (Throwable jjte000) {
417 if (jjtc000) {
418 jjtree.clearNodeScope(jjtn000);
419 jjtc000 = false;
420 } else {
421 jjtree.popNode();
422 }
423 if (jjte000 instanceof RuntimeException ) {
424 {if (true) throw (RuntimeException )jjte000;}
425 }
426 if (jjte000 instanceof ParseException) {
427 {if (true) throw (ParseException)jjte000;}
428 }
429 {if (true) throw (Error )jjte000;}
430 } finally {
431 if (jjtc000) {
432 jjtree.closeNodeScope(jjtn000, true);
433 jjtreeCloseNodeScope(jjtn000);
434 }
435 }
436 throw new Error ("Missing return statement in function");
437 }
438
439 final public modType eval_input() throws ParseException {
441
442 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEVAL_INPUT);
443 boolean jjtc000 = true;
444 jjtree.openNodeScope(jjtn000);
445 jjtreeOpenNodeScope(jjtn000);token_source.single_input=false;
446 try {
447 label_4:
448 while (true) {
449 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
450 case NEWLINE:
451 ;
452 break;
453 default:
454 jj_la1[5] = jj_gen;
455 break label_4;
456 }
457 jj_consume_token(NEWLINE);
458 }
459 SmartTestList();
460 label_5:
461 while (true) {
462 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
463 case NEWLINE:
464 ;
465 break;
466 default:
467 jj_la1[6] = jj_gen;
468 break label_5;
469 }
470 jj_consume_token(NEWLINE);
471 }
472 jj_consume_token(0);
473 jjtree.closeNodeScope(jjtn000, true);
474 jjtc000 = false;
475 jjtreeCloseNodeScope(jjtn000);
476 {if (true) return (modType) jjtree.popNode();}
477 } catch (Throwable jjte000) {
478 if (jjtc000) {
479 jjtree.clearNodeScope(jjtn000);
480 jjtc000 = false;
481 } else {
482 jjtree.popNode();
483 }
484 if (jjte000 instanceof RuntimeException ) {
485 {if (true) throw (RuntimeException )jjte000;}
486 }
487 if (jjte000 instanceof ParseException) {
488 {if (true) throw (ParseException)jjte000;}
489 }
490 {if (true) throw (Error )jjte000;}
491 } finally {
492 if (jjtc000) {
493 jjtree.closeNodeScope(jjtn000, true);
494 jjtreeCloseNodeScope(jjtn000);
495 }
496 }
497 throw new Error ("Missing return statement in function");
498 }
499
500 final public void funcdef() throws ParseException {
502
503 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTFUNCDEF);
504 boolean jjtc000 = true;
505 jjtree.openNodeScope(jjtn000);
506 jjtreeOpenNodeScope(jjtn000);
507 try {
508 jj_consume_token(DEF);
509 AnyName();
510 parameters();
511 jj_consume_token(COLON);
512 suite();
513 } catch (Throwable jjte000) {
514 if (jjtc000) {
515 jjtree.clearNodeScope(jjtn000);
516 jjtc000 = false;
517 } else {
518 jjtree.popNode();
519 }
520 if (jjte000 instanceof RuntimeException ) {
521 {if (true) throw (RuntimeException )jjte000;}
522 }
523 if (jjte000 instanceof ParseException) {
524 {if (true) throw (ParseException)jjte000;}
525 }
526 {if (true) throw (Error )jjte000;}
527 } finally {
528 if (jjtc000) {
529 jjtree.closeNodeScope(jjtn000, true);
530 jjtreeCloseNodeScope(jjtn000);
531 }
532 }
533 }
534
535 final public void parameters() throws ParseException {
537 jj_consume_token(LPAREN);
538 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
539 case LPAREN:
540 case MULTIPLY:
541 case POWER:
542 case AS:
543 case NAME:
544 varargslist();
545 break;
546 default:
547 jj_la1[7] = jj_gen;
548 ;
549 }
550 jj_consume_token(RPAREN);
551 }
552
553 final public void varargslist() throws ParseException {
555 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
556 case LPAREN:
557 case AS:
558 case NAME:
559 defaultarg();
560 label_6:
561 while (true) {
562 if (jj_2_2(2)) {
563 ;
564 } else {
565 break label_6;
566 }
567 jj_consume_token(COMMA);
568 defaultarg();
569 }
570 if (jj_2_3(3)) {
571 jj_consume_token(COMMA);
572 ExtraArgList();
573 } else {
574 ;
575 }
576 if (jj_2_4(2)) {
577 jj_consume_token(COMMA);
578 ExtraKeywordList();
579 } else {
580 ;
581 }
582 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
583 case COMMA:
584 jj_consume_token(COMMA);
585 break;
586 default:
587 jj_la1[8] = jj_gen;
588 ;
589 }
590 break;
591 case MULTIPLY:
592 case POWER:
593 if (jj_2_5(2)) {
594 ExtraArgList();
595 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
596 case COMMA:
597 jj_consume_token(COMMA);
598 ExtraKeywordList();
599 break;
600 default:
601 jj_la1[9] = jj_gen;
602 ;
603 }
604 } else {
605 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
606 case MULTIPLY:
607 case POWER:
608 ExtraKeywordList();
609 break;
610 default:
611 jj_la1[10] = jj_gen;
612 jj_consume_token(-1);
613 throw new ParseException();
614 }
615 }
616 break;
617 default:
618 jj_la1[11] = jj_gen;
619 jj_consume_token(-1);
620 throw new ParseException();
621 }
622 }
623
624 final public void ExtraArgList() throws ParseException {
625
626 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXTRAARGLIST);
627 boolean jjtc000 = true;
628 jjtree.openNodeScope(jjtn000);
629 jjtreeOpenNodeScope(jjtn000);
630 try {
631 jj_consume_token(MULTIPLY);
632 Name();
633 } catch (Throwable jjte000) {
634 if (jjtc000) {
635 jjtree.clearNodeScope(jjtn000);
636 jjtc000 = false;
637 } else {
638 jjtree.popNode();
639 }
640 if (jjte000 instanceof RuntimeException ) {
641 {if (true) throw (RuntimeException )jjte000;}
642 }
643 if (jjte000 instanceof ParseException) {
644 {if (true) throw (ParseException)jjte000;}
645 }
646 {if (true) throw (Error )jjte000;}
647 } finally {
648 if (jjtc000) {
649 jjtree.closeNodeScope(jjtn000, true);
650 jjtreeCloseNodeScope(jjtn000);
651 }
652 }
653 }
654
655 final public void ExtraKeywordList() throws ParseException {
656
657 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXTRAKEYWORDLIST);
658 boolean jjtc000 = true;
659 jjtree.openNodeScope(jjtn000);
660 jjtreeOpenNodeScope(jjtn000);
661 try {
662 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
663 case POWER:
664 jj_consume_token(POWER);
665 break;
666 case MULTIPLY:
667 jj_consume_token(MULTIPLY);
668 jj_consume_token(MULTIPLY);
669 break;
670 default:
671 jj_la1[12] = jj_gen;
672 jj_consume_token(-1);
673 throw new ParseException();
674 }
675 Name();
676 } catch (Throwable jjte000) {
677 if (jjtc000) {
678 jjtree.clearNodeScope(jjtn000);
679 jjtc000 = false;
680 } else {
681 jjtree.popNode();
682 }
683 if (jjte000 instanceof RuntimeException ) {
684 {if (true) throw (RuntimeException )jjte000;}
685 }
686 if (jjte000 instanceof ParseException) {
687 {if (true) throw (ParseException)jjte000;}
688 }
689 {if (true) throw (Error )jjte000;}
690 } finally {
691 if (jjtc000) {
692 jjtree.closeNodeScope(jjtn000, true);
693 jjtreeCloseNodeScope(jjtn000);
694 }
695 }
696 }
697
698 final public void defaultarg() throws ParseException {
699
700 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTDEFAULTARG);
701 boolean jjtc000 = true;
702 jjtree.openNodeScope(jjtn000);
703 jjtreeOpenNodeScope(jjtn000);
704 try {
705 fpdef();
706 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
707 case EQUAL:
708 jj_consume_token(EQUAL);
709 test();
710 break;
711 default:
712 jj_la1[13] = jj_gen;
713 ;
714 }
715 } catch (Throwable jjte000) {
716 if (jjtc000) {
717 jjtree.clearNodeScope(jjtn000);
718 jjtc000 = false;
719 } else {
720 jjtree.popNode();
721 }
722 if (jjte000 instanceof RuntimeException ) {
723 {if (true) throw (RuntimeException )jjte000;}
724 }
725 if (jjte000 instanceof ParseException) {
726 {if (true) throw (ParseException)jjte000;}
727 }
728 {if (true) throw (Error )jjte000;}
729 } finally {
730 if (jjtc000) {
731 jjtree.closeNodeScope(jjtn000, true);
732 jjtreeCloseNodeScope(jjtn000);
733 }
734 }
735 }
736
737 final public void fpdef() throws ParseException {
739 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
740 case AS:
741 case NAME:
742 Name();
743 break;
744 case LPAREN:
745 jj_consume_token(LPAREN);
746 fplist();
747 jj_consume_token(RPAREN);
748 break;
749 default:
750 jj_la1[14] = jj_gen;
751 jj_consume_token(-1);
752 throw new ParseException();
753 }
754 }
755
756 final public void fplist() throws ParseException {
758
759 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTUPLE);
760 boolean jjtc000 = true;
761 jjtree.openNodeScope(jjtn000);
762 jjtreeOpenNodeScope(jjtn000);
763 try {
764 fpdef();
765 label_7:
766 while (true) {
767 if (jj_2_6(2)) {
768 ;
769 } else {
770 break label_7;
771 }
772 jj_consume_token(COMMA);
773 fpdef();
774 }
775 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
776 case COMMA:
777 jj_consume_token(COMMA);
778 break;
779 default:
780 jj_la1[15] = jj_gen;
781 ;
782 }
783 } catch (Throwable jjte000) {
784 if (jjtc000) {
785 jjtree.clearNodeScope(jjtn000);
786 jjtc000 = false;
787 } else {
788 jjtree.popNode();
789 }
790 if (jjte000 instanceof RuntimeException ) {
791 {if (true) throw (RuntimeException )jjte000;}
792 }
793 if (jjte000 instanceof ParseException) {
794 {if (true) throw (ParseException)jjte000;}
795 }
796 {if (true) throw (Error )jjte000;}
797 } finally {
798 if (jjtc000) {
799 jjtree.closeNodeScope(jjtn000, true);
800 jjtreeCloseNodeScope(jjtn000);
801 }
802 }
803 }
804
805 final public void stmt() throws ParseException {
807 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
808 case LPAREN:
809 case LBRACE:
810 case LBRACKET:
811 case PLUS:
812 case MINUS:
813 case NOT:
814 case NOT_BOOL:
815 case LAMBDA:
816 case PRINT:
817 case PASS:
818 case BREAK:
819 case CONTINUE:
820 case RETURN:
821 case YIELD:
822 case IMPORT:
823 case FROM:
824 case DEL:
825 case RAISE:
826 case GLOBAL:
827 case EXEC:
828 case ASSERT:
829 case AS:
830 case NAME:
831 case DECNUMBER:
832 case HEXNUMBER:
833 case OCTNUMBER:
834 case FLOAT:
835 case COMPLEX:
836 case SINGLE_STRING:
837 case SINGLE_STRING2:
838 case TRIPLE_STRING:
839 case TRIPLE_STRING2:
840 case 121:
841 simple_stmt();
842 break;
843 case IF:
844 case WHILE:
845 case FOR:
846 case TRY:
847 case DEF:
848 case CLASS:
849 compound_stmt();
850 break;
851 default:
852 jj_la1[16] = jj_gen;
853 jj_consume_token(-1);
854 throw new ParseException();
855 }
856 }
857
858 final public void simple_stmt() throws ParseException {
860 small_stmt();
861 label_8:
862 while (true) {
863 if (jj_2_7(2)) {
864 ;
865 } else {
866 break label_8;
867 }
868 jj_consume_token(SEMICOLON);
869 small_stmt();
870 }
871 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
872 case SEMICOLON:
873 jj_consume_token(SEMICOLON);
874 break;
875 default:
876 jj_la1[17] = jj_gen;
877 ;
878 }
879 jj_consume_token(NEWLINE);
880 }
881
882 final public void small_stmt() throws ParseException {
884 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
885 case LPAREN:
886 case LBRACE:
887 case LBRACKET:
888 case PLUS:
889 case MINUS:
890 case NOT:
891 case NOT_BOOL:
892 case LAMBDA:
893 case AS:
894 case NAME:
895 case DECNUMBER:
896 case HEXNUMBER:
897 case OCTNUMBER:
898 case FLOAT:
899 case COMPLEX:
900 case SINGLE_STRING:
901 case SINGLE_STRING2:
902 case TRIPLE_STRING:
903 case TRIPLE_STRING2:
904 case 121:
905 expr_stmt();
906 break;
907 case PRINT:
908 print_stmt();
909 break;
910 case DEL:
911 del_stmt();
912 break;
913 case PASS:
914 pass_stmt();
915 break;
916 case BREAK:
917 case CONTINUE:
918 case RETURN:
919 case YIELD:
920 case RAISE:
921 flow_stmt();
922 break;
923 case IMPORT:
924 case FROM:
925 import_stmt();
926 break;
927 case GLOBAL:
928 global_stmt();
929 break;
930 case EXEC:
931 exec_stmt();
932 break;
933 case ASSERT:
934 assert_stmt();
935 break;
936 default:
937 jj_la1[18] = jj_gen;
938 jj_consume_token(-1);
939 throw new ParseException();
940 }
941 }
942
943 final public void expr_stmt() throws ParseException {
945 SmartTestList();
946 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
947 case PLUSEQ:
948 jj_consume_token(PLUSEQ);
949 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_PLUS);
950 boolean jjtc001 = true;
951 jjtree.openNodeScope(jjtn001);
952 jjtreeOpenNodeScope(jjtn001);
953 try {
954 SmartTestList();
955 } catch (Throwable jjte001) {
956 if (jjtc001) {
957 jjtree.clearNodeScope(jjtn001);
958 jjtc001 = false;
959 } else {
960 jjtree.popNode();
961 }
962 if (jjte001 instanceof RuntimeException ) {
963 {if (true) throw (RuntimeException )jjte001;}
964 }
965 if (jjte001 instanceof ParseException) {
966 {if (true) throw (ParseException)jjte001;}
967 }
968 {if (true) throw (Error )jjte001;}
969 } finally {
970 if (jjtc001) {
971 jjtree.closeNodeScope(jjtn001, 2);
972 jjtreeCloseNodeScope(jjtn001);
973 }
974 }
975 break;
976 case MINUSEQ:
977 jj_consume_token(MINUSEQ);
978 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_MINUS);
979 boolean jjtc002 = true;
980 jjtree.openNodeScope(jjtn002);
981 jjtreeOpenNodeScope(jjtn002);
982 try {
983 SmartTestList();
984 } catch (Throwable jjte002) {
985 if (jjtc002) {
986 jjtree.clearNodeScope(jjtn002);
987 jjtc002 = false;
988 } else {
989 jjtree.popNode();
990 }
991 if (jjte002 instanceof RuntimeException ) {
992 {if (true) throw (RuntimeException )jjte002;}
993 }
994 if (jjte002 instanceof ParseException) {
995 {if (true) throw (ParseException)jjte002;}
996 }
997 {if (true) throw (Error )jjte002;}
998 } finally {
999 if (jjtc002) {
1000 jjtree.closeNodeScope(jjtn002, 2);
1001 jjtreeCloseNodeScope(jjtn002);
1002 }
1003 }
1004 break;
1005 case MULTIPLYEQ:
1006 jj_consume_token(MULTIPLYEQ);
1007 SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_MULTIPLY);
1008 boolean jjtc003 = true;
1009 jjtree.openNodeScope(jjtn003);
1010 jjtreeOpenNodeScope(jjtn003);
1011 try {
1012 SmartTestList();
1013 } catch (Throwable jjte003) {
1014 if (jjtc003) {
1015 jjtree.clearNodeScope(jjtn003);
1016 jjtc003 = false;
1017 } else {
1018 jjtree.popNode();
1019 }
1020 if (jjte003 instanceof RuntimeException ) {
1021 {if (true) throw (RuntimeException )jjte003;}
1022 }
1023 if (jjte003 instanceof ParseException) {
1024 {if (true) throw (ParseException)jjte003;}
1025 }
1026 {if (true) throw (Error )jjte003;}
1027 } finally {
1028 if (jjtc003) {
1029 jjtree.closeNodeScope(jjtn003, 2);
1030 jjtreeCloseNodeScope(jjtn003);
1031 }
1032 }
1033 break;
1034 case DIVIDEEQ:
1035 jj_consume_token(DIVIDEEQ);
1036 SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_DIVIDE);
1037 boolean jjtc004 = true;
1038 jjtree.openNodeScope(jjtn004);
1039 jjtreeOpenNodeScope(jjtn004);
1040 try {
1041 SmartTestList();
1042 } catch (Throwable jjte004) {
1043 if (jjtc004) {
1044 jjtree.clearNodeScope(jjtn004);
1045 jjtc004 = false;
1046 } else {
1047 jjtree.popNode();
1048 }
1049 if (jjte004 instanceof RuntimeException ) {
1050 {if (true) throw (RuntimeException )jjte004;}
1051 }
1052 if (jjte004 instanceof ParseException) {
1053 {if (true) throw (ParseException)jjte004;}
1054 }
1055 {if (true) throw (Error )jjte004;}
1056 } finally {
1057 if (jjtc004) {
1058 jjtree.closeNodeScope(jjtn004, 2);
1059 jjtreeCloseNodeScope(jjtn004);
1060 }
1061 }
1062 break;
1063 case FLOORDIVIDEEQ:
1064 jj_consume_token(FLOORDIVIDEEQ);
1065 SimpleNode jjtn005 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_FLOORDIVIDE);
1066 boolean jjtc005 = true;
1067 jjtree.openNodeScope(jjtn005);
1068 jjtreeOpenNodeScope(jjtn005);
1069 try {
1070 SmartTestList();
1071 } catch (Throwable jjte005) {
1072 if (jjtc005) {
1073 jjtree.clearNodeScope(jjtn005);
1074 jjtc005 = false;
1075 } else {
1076 jjtree.popNode();
1077 }
1078 if (jjte005 instanceof RuntimeException ) {
1079 {if (true) throw (RuntimeException )jjte005;}
1080 }
1081 if (jjte005 instanceof ParseException) {
1082 {if (true) throw (ParseException)jjte005;}
1083 }
1084 {if (true) throw (Error )jjte005;}
1085 } finally {
1086 if (jjtc005) {
1087 jjtree.closeNodeScope(jjtn005, 2);
1088 jjtreeCloseNodeScope(jjtn005);
1089 }
1090 }
1091 break;
1092 case MODULOEQ:
1093 jj_consume_token(MODULOEQ);
1094 SimpleNode jjtn006 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_MODULO);
1095 boolean jjtc006 = true;
1096 jjtree.openNodeScope(jjtn006);
1097 jjtreeOpenNodeScope(jjtn006);
1098 try {
1099 SmartTestList();
1100 } catch (Throwable jjte006) {
1101 if (jjtc006) {
1102 jjtree.clearNodeScope(jjtn006);
1103 jjtc006 = false;
1104 } else {
1105 jjtree.popNode();
1106 }
1107 if (jjte006 instanceof RuntimeException ) {
1108 {if (true) throw (RuntimeException )jjte006;}
1109 }
1110 if (jjte006 instanceof ParseException) {
1111 {if (true) throw (ParseException)jjte006;}
1112 }
1113 {if (true) throw (Error )jjte006;}
1114 } finally {
1115 if (jjtc006) {
1116 jjtree.closeNodeScope(jjtn006, 2);
1117 jjtreeCloseNodeScope(jjtn006);
1118 }
1119 }
1120 break;
1121 case ANDEQ:
1122 jj_consume_token(ANDEQ);
1123 SimpleNode jjtn007 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_AND);
1124 boolean jjtc007 = true;
1125 jjtree.openNodeScope(jjtn007);
1126 jjtreeOpenNodeScope(jjtn007);
1127 try {
1128 SmartTestList();
1129 } catch (Throwable jjte007) {
1130 if (jjtc007) {
1131 jjtree.clearNodeScope(jjtn007);
1132 jjtc007 = false;
1133 } else {
1134 jjtree.popNode();
1135 }
1136 if (jjte007 instanceof RuntimeException ) {
1137 {if (true) throw (RuntimeException )jjte007;}
1138 }
1139 if (jjte007 instanceof ParseException) {
1140 {if (true) throw (ParseException)jjte007;}
1141 }
1142 {if (true) throw (Error )jjte007;}
1143 } finally {
1144 if (jjtc007) {
1145 jjtree.closeNodeScope(jjtn007, 2);
1146 jjtreeCloseNodeScope(jjtn007);
1147 }
1148 }
1149 break;
1150 case OREQ:
1151 jj_consume_token(OREQ);
1152 SimpleNode jjtn008 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_OR);
1153 boolean jjtc008 = true;
1154 jjtree.openNodeScope(jjtn008);
1155 jjtreeOpenNodeScope(jjtn008);
1156 try {
1157 SmartTestList();
1158 } catch (Throwable jjte008) {
1159 if (jjtc008) {
1160 jjtree.clearNodeScope(jjtn008);
1161 jjtc008 = false;
1162 } else {
1163 jjtree.popNode();
1164 }
1165 if (jjte008 instanceof RuntimeException ) {
1166 {if (true) throw (RuntimeException )jjte008;}
1167 }
1168 if (jjte008 instanceof ParseException) {
1169 {if (true) throw (ParseException)jjte008;}
1170 }
1171 {if (true) throw (Error )jjte008;}
1172 } finally {
1173 if (jjtc008) {
1174 jjtree.closeNodeScope(jjtn008, 2);
1175 jjtreeCloseNodeScope(jjtn008);
1176 }
1177 }
1178 break;
1179 case XOREQ:
1180 jj_consume_token(XOREQ);
1181 SimpleNode jjtn009 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_XOR);
1182 boolean jjtc009 = true;
1183 jjtree.openNodeScope(jjtn009);
1184 jjtreeOpenNodeScope(jjtn009);
1185 try {
1186 SmartTestList();
1187 } catch (Throwable jjte009) {
1188 if (jjtc009) {
1189 jjtree.clearNodeScope(jjtn009);
1190 jjtc009 = false;
1191 } else {
1192 jjtree.popNode();
1193 }
1194 if (jjte009 instanceof RuntimeException ) {
1195 {if (true) throw (RuntimeException )jjte009;}
1196 }
1197 if (jjte009 instanceof ParseException) {
1198 {if (true) throw (ParseException)jjte009;}
1199 }
1200 {if (true) throw (Error )jjte009;}
1201 } finally {
1202 if (jjtc009) {
1203 jjtree.closeNodeScope(jjtn009, 2);
1204 jjtreeCloseNodeScope(jjtn009);
1205 }
1206 }
1207 break;
1208 case LSHIFTEQ:
1209 jj_consume_token(LSHIFTEQ);
1210 SimpleNode jjtn010 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_LSHIFT);
1211 boolean jjtc010 = true;
1212 jjtree.openNodeScope(jjtn010);
1213 jjtreeOpenNodeScope(jjtn010);
1214 try {
1215 SmartTestList();
1216 } catch (Throwable jjte010) {
1217 if (jjtc010) {
1218 jjtree.clearNodeScope(jjtn010);
1219 jjtc010 = false;
1220 } else {
1221 jjtree.popNode();
1222 }
1223 if (jjte010 instanceof RuntimeException ) {
1224 {if (true) throw (RuntimeException )jjte010;}
1225 }
1226 if (jjte010 instanceof ParseException) {
1227 {if (true) throw (ParseException)jjte010;}
1228 }
1229 {if (true) throw (Error )jjte010;}
1230 } finally {
1231 if (jjtc010) {
1232 jjtree.closeNodeScope(jjtn010, 2);
1233 jjtreeCloseNodeScope(jjtn010);
1234 }
1235 }
1236 break;
1237 case RSHIFTEQ:
1238 jj_consume_token(RSHIFTEQ);
1239 SimpleNode jjtn011 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_RSHIFT);
1240 boolean jjtc011 = true;
1241 jjtree.openNodeScope(jjtn011);
1242 jjtreeOpenNodeScope(jjtn011);
1243 try {
1244 SmartTestList();
1245 } catch (Throwable jjte011) {
1246 if (jjtc011) {
1247 jjtree.clearNodeScope(jjtn011);
1248 jjtc011 = false;
1249 } else {
1250 jjtree.popNode();
1251 }
1252 if (jjte011 instanceof RuntimeException ) {
1253 {if (true) throw (RuntimeException )jjte011;}
1254 }
1255 if (jjte011 instanceof ParseException) {
1256 {if (true) throw (ParseException)jjte011;}
1257 }
1258 {if (true) throw (Error )jjte011;}
1259 } finally {
1260 if (jjtc011) {
1261 jjtree.closeNodeScope(jjtn011, 2);
1262 jjtreeCloseNodeScope(jjtn011);
1263 }
1264 }
1265 break;
1266 case POWEREQ:
1267 jj_consume_token(POWEREQ);
1268 SimpleNode jjtn012 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAUG_POWER);
1269 boolean jjtc012 = true;
1270 jjtree.openNodeScope(jjtn012);
1271 jjtreeOpenNodeScope(jjtn012);
1272 try {
1273 SmartTestList();
1274 } catch (Throwable jjte012) {
1275 if (jjtc012) {
1276 jjtree.clearNodeScope(jjtn012);
1277 jjtc012 = false;
1278 } else {
1279 jjtree.popNode();
1280 }
1281 if (jjte012 instanceof RuntimeException ) {
1282 {if (true) throw (RuntimeException )jjte012;}
1283 }
1284 if (jjte012 instanceof ParseException) {
1285 {if (true) throw (ParseException)jjte012;}
1286 }
1287 {if (true) throw (Error )jjte012;}
1288 } finally {
1289 if (jjtc012) {
1290 jjtree.closeNodeScope(jjtn012, 2);
1291 jjtreeCloseNodeScope(jjtn012);
1292 }
1293 }
1294 break;
1295 default:
1296 jj_la1[20] = jj_gen;
1297 SimpleNode jjtn013 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXPR_STMT);
1298 boolean jjtc013 = true;
1299 jjtree.openNodeScope(jjtn013);
1300 jjtreeOpenNodeScope(jjtn013);
1301 try {
1302 label_9:
1303 while (true) {
1304 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1305 case EQUAL:
1306 ;
1307 break;
1308 default:
1309 jj_la1[19] = jj_gen;
1310 break label_9;
1311 }
1312 jj_consume_token(EQUAL);
1313 SmartTestList();
1314 }
1315 } catch (Throwable jjte013) {
1316 if (jjtc013) {
1317 jjtree.clearNodeScope(jjtn013);
1318 jjtc013 = false;
1319 } else {
1320 jjtree.popNode();
1321 }
1322 if (jjte013 instanceof RuntimeException ) {
1323 {if (true) throw (RuntimeException )jjte013;}
1324 }
1325 if (jjte013 instanceof ParseException) {
1326 {if (true) throw (ParseException)jjte013;}
1327 }
1328 {if (true) throw (Error )jjte013;}
1329 } finally {
1330 if (jjtc013) {
1331 jjtree.closeNodeScope(jjtn013, jjtree . nodeArity ( ) + 1);
1332 jjtreeCloseNodeScope(jjtn013);
1333 }
1334 }
1335 }
1336 }
1337
1338 final public void print_stmt() throws ParseException {
1340 if (jj_2_10(2)) {
1341 jj_consume_token(PRINT);
1342 jj_consume_token(RSHIFT);
1343 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPRINTEXT_STMT);
1344 boolean jjtc001 = true;
1345 jjtree.openNodeScope(jjtn001);
1346 jjtreeOpenNodeScope(jjtn001);
1347 try {
1348 test();
1349 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1350 case COMMA:
1351 label_10:
1352 while (true) {
1353 jj_consume_token(COMMA);
1354 test();
1355 if (jj_2_8(2)) {
1356 ;
1357 } else {
1358 break label_10;
1359 }
1360 }
1361 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1362 case COMMA:
1363 Comma();
1364 break;
1365 default:
1366 jj_la1[21] = jj_gen;
1367 ;
1368 }
1369 break;
1370 default:
1371 jj_la1[22] = jj_gen;
1372 ;
1373 }
1374 } catch (Throwable jjte001) {
1375 if (jjtc001) {
1376 jjtree.clearNodeScope(jjtn001);
1377 jjtc001 = false;
1378 } else {
1379 jjtree.popNode();
1380 }
1381 if (jjte001 instanceof RuntimeException ) {
1382 {if (true) throw (RuntimeException )jjte001;}
1383 }
1384 if (jjte001 instanceof ParseException) {
1385 {if (true) throw (ParseException)jjte001;}
1386 }
1387 {if (true) throw (Error )jjte001;}
1388 } finally {
1389 if (jjtc001) {
1390 jjtree.closeNodeScope(jjtn001, true);
1391 jjtreeCloseNodeScope(jjtn001);
1392 }
1393 }
1394 } else if (jj_2_11(2)) {
1395 jj_consume_token(PRINT);
1396 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPRINT_STMT);
1397 boolean jjtc002 = true;
1398 jjtree.openNodeScope(jjtn002);
1399 jjtreeOpenNodeScope(jjtn002);
1400 try {
1401 test();
1402 label_11:
1403 while (true) {
1404 if (jj_2_9(2)) {
1405 ;
1406 } else {
1407 break label_11;
1408 }
1409 jj_consume_token(COMMA);
1410 test();
1411 }
1412 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1413 case COMMA:
1414 Comma();
1415 break;
1416 default:
1417 jj_la1[23] = jj_gen;
1418 ;
1419 }
1420 } catch (Throwable jjte002) {
1421 if (jjtc002) {
1422 jjtree.clearNodeScope(jjtn002);
1423 jjtc002 = false;
1424 } else {
1425 jjtree.popNode();
1426 }
1427 if (jjte002 instanceof RuntimeException ) {
1428 {if (true) throw (RuntimeException )jjte002;}
1429 }
1430 if (jjte002 instanceof ParseException) {
1431 {if (true) throw (ParseException)jjte002;}
1432 }
1433 {if (true) throw (Error )jjte002;}
1434 } finally {
1435 if (jjtc002) {
1436 jjtree.closeNodeScope(jjtn002, true);
1437 jjtreeCloseNodeScope(jjtn002);
1438 }
1439 }
1440 } else {
1441 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1442 case PRINT:
1443 SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPRINT_STMT);
1444 boolean jjtc003 = true;
1445 jjtree.openNodeScope(jjtn003);
1446 jjtreeOpenNodeScope(jjtn003);
1447 try {
1448 jj_consume_token(PRINT);
1449 } finally {
1450 if (jjtc003) {
1451 jjtree.closeNodeScope(jjtn003, true);
1452 jjtreeCloseNodeScope(jjtn003);
1453 }
1454 }
1455 break;
1456 default:
1457 jj_la1[24] = jj_gen;
1458 jj_consume_token(-1);
1459 throw new ParseException();
1460 }
1461 }
1462 }
1463
1464 final public void del_stmt() throws ParseException {
1466
1467 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTDEL_STMT);
1468 boolean jjtc000 = true;
1469 jjtree.openNodeScope(jjtn000);
1470 jjtreeOpenNodeScope(jjtn000);
1471 try {
1472 jj_consume_token(DEL);
1473 exprlist();
1474 } catch (Throwable jjte000) {
1475 if (jjtc000) {
1476 jjtree.clearNodeScope(jjtn000);
1477 jjtc000 = false;
1478 } else {
1479 jjtree.popNode();
1480 }
1481 if (jjte000 instanceof RuntimeException ) {
1482 {if (true) throw (RuntimeException )jjte000;}
1483 }
1484 if (jjte000 instanceof ParseException) {
1485 {if (true) throw (ParseException)jjte000;}
1486 }
1487 {if (true) throw (Error )jjte000;}
1488 } finally {
1489 if (jjtc000) {
1490 jjtree.closeNodeScope(jjtn000, true);
1491 jjtreeCloseNodeScope(jjtn000);
1492 }
1493 }
1494 }
1495
1496 final public void pass_stmt() throws ParseException {
1498
1499 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPASS_STMT);
1500 boolean jjtc000 = true;
1501 jjtree.openNodeScope(jjtn000);
1502 jjtreeOpenNodeScope(jjtn000);
1503 try {
1504 jj_consume_token(PASS);
1505 } finally {
1506 if (jjtc000) {
1507 jjtree.closeNodeScope(jjtn000, true);
1508 jjtreeCloseNodeScope(jjtn000);
1509 }
1510 }
1511 }
1512
1513 final public void flow_stmt() throws ParseException {
1515 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1516 case BREAK:
1517 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTBREAK_STMT);
1518 boolean jjtc001 = true;
1519 jjtree.openNodeScope(jjtn001);
1520 jjtreeOpenNodeScope(jjtn001);
1521 try {
1522 jj_consume_token(BREAK);
1523 } finally {
1524 if (jjtc001) {
1525 jjtree.closeNodeScope(jjtn001, 0);
1526 jjtreeCloseNodeScope(jjtn001);
1527 }
1528 }
1529 break;
1530 case CONTINUE:
1531 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCONTINUE_STMT);
1532 boolean jjtc002 = true;
1533 jjtree.openNodeScope(jjtn002);
1534 jjtreeOpenNodeScope(jjtn002);
1535 try {
1536 jj_consume_token(CONTINUE);
1537 } finally {
1538 if (jjtc002) {
1539 jjtree.closeNodeScope(jjtn002, 0);
1540 jjtreeCloseNodeScope(jjtn002);
1541 }
1542 }
1543 break;
1544 case RETURN:
1545 return_stmt();
1546 break;
1547 case YIELD:
1548 yield_stmt();
1549 break;
1550 case RAISE:
1551 raise_stmt();
1552 break;
1553 default:
1554 jj_la1[25] = jj_gen;
1555 jj_consume_token(-1);
1556 throw new ParseException();
1557 }
1558 }
1559
1560 final public void return_stmt() throws ParseException {
1562
1563 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTRETURN_STMT);
1564 boolean jjtc000 = true;
1565 jjtree.openNodeScope(jjtn000);
1566 jjtreeOpenNodeScope(jjtn000);
1567 try {
1568 jj_consume_token(RETURN);
1569 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1570 case LPAREN:
1571 case LBRACE:
1572 case LBRACKET:
1573 case PLUS:
1574 case MINUS:
1575 case NOT:
1576 case NOT_BOOL:
1577 case LAMBDA:
1578 case AS:
1579 case NAME:
1580 case DECNUMBER:
1581 case HEXNUMBER:
1582 case OCTNUMBER:
1583 case FLOAT:
1584 case COMPLEX:
1585 case SINGLE_STRING:
1586 case SINGLE_STRING2:
1587 case TRIPLE_STRING:
1588 case TRIPLE_STRING2:
1589 case 121:
1590 SmartTestList();
1591 break;
1592 default:
1593 jj_la1[26] = jj_gen;
1594 ;
1595 }
1596 } catch (Throwable jjte000) {
1597 if (jjtc000) {
1598 jjtree.clearNodeScope(jjtn000);
1599 jjtc000 = false;
1600 } else {
1601 jjtree.popNode();
1602 }
1603 if (jjte000 instanceof RuntimeException ) {
1604 {if (true) throw (RuntimeException )jjte000;}
1605 }
1606 if (jjte000 instanceof ParseException) {
1607 {if (true) throw (ParseException)jjte000;}
1608 }
1609 {if (true) throw (Error )jjte000;}
1610 } finally {
1611 if (jjtc000) {
1612 jjtree.closeNodeScope(jjtn000, true);
1613 jjtreeCloseNodeScope(jjtn000);
1614 }
1615 }
1616 }
1617
1618 final public void yield_stmt() throws ParseException {
1620
1621 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTYIELD_STMT);
1622 boolean jjtc000 = true;
1623 jjtree.openNodeScope(jjtn000);
1624 jjtreeOpenNodeScope(jjtn000);
1625 try {
1626 jj_consume_token(YIELD);
1627 SmartTestList();
1628 } catch (Throwable jjte000) {
1629 if (jjtc000) {
1630 jjtree.clearNodeScope(jjtn000);
1631 jjtc000 = false;
1632 } else {
1633 jjtree.popNode();
1634 }
1635 if (jjte000 instanceof RuntimeException ) {
1636 {if (true) throw (RuntimeException )jjte000;}
1637 }
1638 if (jjte000 instanceof ParseException) {
1639 {if (true) throw (ParseException)jjte000;}
1640 }
1641 {if (true) throw (Error )jjte000;}
1642 } finally {
1643 if (jjtc000) {
1644 jjtree.closeNodeScope(jjtn000, true);
1645 jjtreeCloseNodeScope(jjtn000);
1646 }
1647 }
1648 }
1649
1650 final public void raise_stmt() throws ParseException {
1652
1653 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTRAISE_STMT);
1654 boolean jjtc000 = true;
1655 jjtree.openNodeScope(jjtn000);
1656 jjtreeOpenNodeScope(jjtn000);
1657 try {
1658 jj_consume_token(RAISE);
1659 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1660 case LPAREN:
1661 case LBRACE:
1662 case LBRACKET:
1663 case PLUS:
1664 case MINUS:
1665 case NOT:
1666 case NOT_BOOL:
1667 case LAMBDA:
1668 case AS:
1669 case NAME:
1670 case DECNUMBER:
1671 case HEXNUMBER:
1672 case OCTNUMBER:
1673 case FLOAT:
1674 case COMPLEX:
1675 case SINGLE_STRING:
1676 case SINGLE_STRING2:
1677 case TRIPLE_STRING:
1678 case TRIPLE_STRING2:
1679 case 121:
1680 test();
1681 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1682 case COMMA:
1683 jj_consume_token(COMMA);
1684 test();
1685 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1686 case COMMA:
1687 jj_consume_token(COMMA);
1688 test();
1689 break;
1690 default:
1691 jj_la1[27] = jj_gen;
1692 ;
1693 }
1694 break;
1695 default:
1696 jj_la1[28] = jj_gen;
1697 ;
1698 }
1699 break;
1700 default:
1701 jj_la1[29] = jj_gen;
1702 ;
1703 }
1704 } catch (Throwable jjte000) {
1705 if (jjtc000) {
1706 jjtree.clearNodeScope(jjtn000);
1707 jjtc000 = false;
1708 } else {
1709 jjtree.popNode();
1710 }
1711 if (jjte000 instanceof RuntimeException ) {
1712 {if (true) throw (RuntimeException )jjte000;}
1713 }
1714 if (jjte000 instanceof ParseException) {
1715 {if (true) throw (ParseException)jjte000;}
1716 }
1717 {if (true) throw (Error )jjte000;}
1718 } finally {
1719 if (jjtc000) {
1720 jjtree.closeNodeScope(jjtn000, true);
1721 jjtreeCloseNodeScope(jjtn000);
1722 }
1723 }
1724 }
1725
1726 final public void import_stmt() throws ParseException {
1728 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1729 case IMPORT:
1730 jj_consume_token(IMPORT);
1731 Import();
1732 break;
1733 case FROM:
1734 jj_consume_token(FROM);
1735 ImportFrom();
1736 break;
1737 default:
1738 jj_la1[30] = jj_gen;
1739 jj_consume_token(-1);
1740 throw new ParseException();
1741 }
1742 }
1743
1744 final public void Import() throws ParseException {
1745
1746 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIMPORT);
1747 boolean jjtc000 = true;
1748 jjtree.openNodeScope(jjtn000);
1749 jjtreeOpenNodeScope(jjtn000);
1750 try {
1751 dotted_as_name();
1752 label_12:
1753 while (true) {
1754 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1755 case COMMA:
1756 ;
1757 break;
1758 default:
1759 jj_la1[31] = jj_gen;
1760 break label_12;
1761 }
1762 jj_consume_token(COMMA);
1763 dotted_as_name();
1764 }
1765 } catch (Throwable jjte000) {
1766 if (jjtc000) {
1767 jjtree.clearNodeScope(jjtn000);
1768 jjtc000 = false;
1769 } else {
1770 jjtree.popNode();
1771 }
1772 if (jjte000 instanceof RuntimeException ) {
1773 {if (true) throw (RuntimeException )jjte000;}
1774 }
1775 if (jjte000 instanceof ParseException) {
1776 {if (true) throw (ParseException)jjte000;}
1777 }
1778 {if (true) throw (Error )jjte000;}
1779 } finally {
1780 if (jjtc000) {
1781 jjtree.closeNodeScope(jjtn000, true);
1782 jjtreeCloseNodeScope(jjtn000);
1783 }
1784 }
1785 }
1786
1787 final public void ImportFrom() throws ParseException {
1788
1789 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIMPORTFROM);
1790 boolean jjtc000 = true;
1791 jjtree.openNodeScope(jjtn000);
1792 jjtreeOpenNodeScope(jjtn000);String mod; String name;
1793 try {
1794 mod = dotted_name();
1795 jj_consume_token(IMPORT);
1796 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1797 case MULTIPLY:
1798 jj_consume_token(MULTIPLY);
1799 break;
1800 case OR_BOOL:
1801 case AND_BOOL:
1802 case NOT_BOOL:
1803 case IS:
1804 case IN:
1805 case LAMBDA:
1806 case IF:
1807 case ELSE:
1808 case ELIF:
1809 case WHILE:
1810 case FOR:
1811 case TRY:
1812 case EXCEPT:
1813 case DEF:
1814 case CLASS:
1815 case FINALLY:
1816 case PRINT:
1817 case PASS:
1818 case BREAK:
1819 case CONTINUE:
1820 case RETURN:
1821 case YIELD:
1822 case IMPORT:
1823 case FROM:
1824 case DEL:
1825 case RAISE:
1826 case GLOBAL:
1827 case EXEC:
1828 case ASSERT:
1829 case AS:
1830 case NAME:
1831 name = import_as_name();
1832 label_13:
1833 while (true) {
1834 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1835 case COMMA:
1836 ;
1837 break;
1838 default:
1839 jj_la1[32] = jj_gen;
1840 break label_13;
1841 }
1842 jj_consume_token(COMMA);
1843 import_as_name();
1844 }
1845 jjtree.closeNodeScope(jjtn000, true);
1846 jjtc000 = false;
1847 jjtreeCloseNodeScope(jjtn000);
1848 if (mod.equals("__future__") && name.equals("generators"))
1849 token_source.generator_allowed = true;
1850 break;
1851 default:
1852 jj_la1[33] = jj_gen;
1853 jj_consume_token(-1);
1854 throw new ParseException();
1855 }
1856 } catch (Throwable jjte000) {
1857 if (jjtc000) {
1858 jjtree.clearNodeScope(jjtn000);
1859 jjtc000 = false;
1860 } else {
1861 jjtree.popNode();
1862 }
1863 if (jjte000 instanceof RuntimeException ) {
1864 {if (true) throw (RuntimeException )jjte000;}
1865 }
1866 if (jjte000 instanceof ParseException) {
1867 {if (true) throw (ParseException)jjte000;}
1868 }
1869 {if (true) throw (Error )jjte000;}
1870 } finally {
1871 if (jjtc000) {
1872 jjtree.closeNodeScope(jjtn000, true);
1873 jjtreeCloseNodeScope(jjtn000);
1874 }
1875 }
1876 }
1877
1878 final public void dotted_as_name() throws ParseException {
1880
1881 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTDOTTED_AS_NAME);
1882 boolean jjtc000 = true;
1883 jjtree.openNodeScope(jjtn000);
1884 jjtreeOpenNodeScope(jjtn000);
1885 try {
1886 dotted_name();
1887 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1888 case AS:
1889 jj_consume_token(AS);
1890 Name();
1891 break;
1892 default:
1893 jj_la1[34] = jj_gen;
1894 ;
1895 }
1896 } catch (Throwable jjte000) {
1897 if (jjtc000) {
1898 jjtree.clearNodeScope(jjtn000);
1899 jjtc000 = false;
1900 } else {
1901 jjtree.popNode();
1902 }
1903 if (jjte000 instanceof RuntimeException ) {
1904 {if (true) throw (RuntimeException )jjte000;}
1905 }
1906 if (jjte000 instanceof ParseException) {
1907 {if (true) throw (ParseException)jjte000;}
1908 }
1909 {if (true) throw (Error )jjte000;}
1910 } finally {
1911 if (jjtc000) {
1912 jjtree.closeNodeScope(jjtn000, true);
1913 jjtreeCloseNodeScope(jjtn000);
1914 }
1915 }
1916 }
1917
1918 final public String dotted_name() throws ParseException {
1920
1921 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTDOTTED_NAME);
1922 boolean jjtc000 = true;
1923 jjtree.openNodeScope(jjtn000);
1924 jjtreeOpenNodeScope(jjtn000);Token t; StringBuffer sb = new StringBuffer ();
1925 try {
1926 t = AnyName();
1927 sb.append(t.image);
1928 label_14:
1929 while (true) {
1930 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1931 case DOT:
1932 ;
1933 break;
1934 default:
1935 jj_la1[35] = jj_gen;
1936 break label_14;
1937 }
1938 jj_consume_token(DOT);
1939 t = AnyName();
1940 sb.append("." + t.image);
1941 }
1942 jjtree.closeNodeScope(jjtn000, true);
1943 jjtc000 = false;
1944 jjtreeCloseNodeScope(jjtn000);
1945 {if (true) return sb.toString();}
1946 } catch (Throwable jjte000) {
1947 if (jjtc000) {
1948 jjtree.clearNodeScope(jjtn000);
1949 jjtc000 = false;
1950 } else {
1951 jjtree.popNode();
1952 }
1953 if (jjte000 instanceof RuntimeException ) {
1954 {if (true) throw (RuntimeException )jjte000;}
1955 }
1956 if (jjte000 instanceof ParseException) {
1957 {if (true) throw (ParseException)jjte000;}
1958 }
1959 {if (true) throw (Error )jjte000;}
1960 } finally {
1961 if (jjtc000) {
1962 jjtree.closeNodeScope(jjtn000, true);
1963 jjtreeCloseNodeScope(jjtn000);
1964 }
1965 }
1966 throw new Error ("Missing return statement in function");
1967 }
1968
1969 final public String import_as_name() throws ParseException {
1971
1972 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIMPORT_AS_NAME);
1973 boolean jjtc000 = true;
1974 jjtree.openNodeScope(jjtn000);
1975 jjtreeOpenNodeScope(jjtn000);Token t;
1976 try {
1977 t = AnyName();
1978 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1979 case AS:
1980 jj_consume_token(AS);
1981 Name();
1982 break;
1983 default:
1984 jj_la1[36] = jj_gen;
1985 ;
1986 }
1987 jjtree.closeNodeScope(jjtn000, true);
1988 jjtc000 = false;
1989 jjtreeCloseNodeScope(jjtn000);
1990 {if (true) return t.image;}
1991 } catch (Throwable jjte000) {
1992 if (jjtc000) {
1993 jjtree.clearNodeScope(jjtn000);
1994 jjtc000 = false;
1995 } else {
1996 jjtree.popNode();
1997 }
1998 if (jjte000 instanceof RuntimeException ) {
1999 {if (true) throw (RuntimeException )jjte000;}
2000 }
2001 if (jjte000 instanceof ParseException) {
2002 {if (true) throw (ParseException)jjte000;}
2003 }
2004 {if (true) throw (Error )jjte000;}
2005 } finally {
2006 if (jjtc000) {
2007 jjtree.closeNodeScope(jjtn000, true);
2008 jjtreeCloseNodeScope(jjtn000);
2009 }
2010 }
2011 throw new Error ("Missing return statement in function");
2012 }
2013
2014 final public void global_stmt() throws ParseException {
2016
2017 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTGLOBAL_STMT);
2018 boolean jjtc000 = true;
2019 jjtree.openNodeScope(jjtn000);
2020 jjtreeOpenNodeScope(jjtn000);
2021 try {
2022 jj_consume_token(GLOBAL);
2023 Name();
2024 label_15:
2025 while (true) {
2026 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2027 case COMMA:
2028 ;
2029 break;
2030 default:
2031 jj_la1[37] = jj_gen;
2032 break label_15;
2033 }
2034 jj_consume_token(COMMA);
2035 Name();
2036 }
2037 } catch (Throwable jjte000) {
2038 if (jjtc000) {
2039 jjtree.clearNodeScope(jjtn000);
2040 jjtc000 = false;
2041 } else {
2042 jjtree.popNode();
2043 }
2044 if (jjte000 instanceof RuntimeException ) {
2045 {if (true) throw (RuntimeException )jjte000;}
2046 }
2047 if (jjte000 instanceof ParseException) {
2048 {if (true) throw (ParseException)jjte000;}
2049 }
2050 {if (true) throw (Error )jjte000;}
2051 } finally {
2052 if (jjtc000) {
2053 jjtree.closeNodeScope(jjtn000, true);
2054 jjtreeCloseNodeScope(jjtn000);
2055 }
2056 }
2057 }
2058
2059 final public void exec_stmt() throws ParseException {
2061
2062 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXEC_STMT);
2063 boolean jjtc000 = true;
2064 jjtree.openNodeScope(jjtn000);
2065 jjtreeOpenNodeScope(jjtn000);
2066 try {
2067 jj_consume_token(EXEC);
2068 expr();
2069 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2070 case IN:
2071 jj_consume_token(IN);
2072 test();
2073 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2074 case COMMA:
2075 jj_consume_token(COMMA);
2076 test();
2077 break;
2078 default:
2079 jj_la1[38] = jj_gen;
2080 ;
2081 }
2082 break;
2083 default:
2084 jj_la1[39] = jj_gen;
2085 ;
2086 }
2087 } catch (Throwable jjte000) {
2088 if (jjtc000) {
2089 jjtree.clearNodeScope(jjtn000);
2090 jjtc000 = false;
2091 } else {
2092 jjtree.popNode();
2093 }
2094 if (jjte000 instanceof RuntimeException ) {
2095 {if (true) throw (RuntimeException )jjte000;}
2096 }
2097 if (jjte000 instanceof ParseException) {
2098 {if (true) throw (ParseException)jjte000;}
2099 }
2100 {if (true) throw (Error )jjte000;}
2101 } finally {
2102 if (jjtc000) {
2103 jjtree.closeNodeScope(jjtn000, true);
2104 jjtreeCloseNodeScope(jjtn000);
2105 }
2106 }
2107 }
2108
2109 final public void assert_stmt() throws ParseException {
2111
2112 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTASSERT_STMT);
2113 boolean jjtc000 = true;
2114 jjtree.openNodeScope(jjtn000);
2115 jjtreeOpenNodeScope(jjtn000);
2116 try {
2117 jj_consume_token(ASSERT);
2118 test();
2119 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2120 case COMMA:
2121 jj_consume_token(COMMA);
2122 test();
2123 break;
2124 default:
2125 jj_la1[40] = jj_gen;
2126 ;
2127 }
2128 } catch (Throwable jjte000) {
2129 if (jjtc000) {
2130 jjtree.clearNodeScope(jjtn000);
2131 jjtc000 = false;
2132 } else {
2133 jjtree.popNode();
2134 }
2135 if (jjte000 instanceof RuntimeException ) {
2136 {if (true) throw (RuntimeException )jjte000;}
2137 }
2138 if (jjte000 instanceof ParseException) {
2139 {if (true) throw (ParseException)jjte000;}
2140 }
2141 {if (true) throw (Error )jjte000;}
2142 } finally {
2143 if (jjtc000) {
2144 jjtree.closeNodeScope(jjtn000, true);
2145 jjtreeCloseNodeScope(jjtn000);
2146 }
2147 }
2148 }
2149
2150 final public void compound_stmt() throws ParseException {
2152 token_source.compound = true;
2153 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2154 case IF:
2155 if_stmt();
2156 break;
2157 case WHILE:
2158 while_stmt();
2159 break;
2160 case FOR:
2161 for_stmt();
2162 break;
2163 case TRY:
2164 try_stmt();
2165 break;
2166 case DEF:
2167 funcdef();
2168 break;
2169 case CLASS:
2170 classdef();
2171 break;
2172 default:
2173 jj_la1[41] = jj_gen;
2174 jj_consume_token(-1);
2175 throw new ParseException();
2176 }
2177 }
2178
2179 final public void if_stmt() throws ParseException {
2181
2182 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIF_STMT);
2183 boolean jjtc000 = true;
2184 jjtree.openNodeScope(jjtn000);
2185 jjtreeOpenNodeScope(jjtn000);
2186 try {
2187 jj_consume_token(IF);
2188 test();
2189 jj_consume_token(COLON);
2190 suite();
2191 label_16:
2192 while (true) {
2193 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2194 case ELIF:
2195 ;
2196 break;
2197 default:
2198 jj_la1[42] = jj_gen;
2199 break label_16;
2200 }
2201 jj_consume_token(ELIF);
2202 test();
2203 jj_consume_token(COLON);
2204 suite();
2205 }
2206 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2207 case ELSE:
2208 jj_consume_token(ELSE);
2209 jj_consume_token(COLON);
2210 suite();
2211 break;
2212 default:
2213 jj_la1[43] = jj_gen;
2214 ;
2215 }
2216 } catch (Throwable jjte000) {
2217 if (jjtc000) {
2218 jjtree.clearNodeScope(jjtn000);
2219 jjtc000 = false;
2220 } else {
2221 jjtree.popNode();
2222 }
2223 if (jjte000 instanceof RuntimeException ) {
2224 {if (true) throw (RuntimeException )jjte000;}
2225 }
2226 if (jjte000 instanceof ParseException) {
2227 {if (true) throw (ParseException)jjte000;}
2228 }
2229 {if (true) throw (Error )jjte000;}
2230 } finally {
2231 if (jjtc000) {
2232 jjtree.closeNodeScope(jjtn000, true);
2233 jjtreeCloseNodeScope(jjtn000);
2234 }
2235 }
2236 }
2237
2238 final public void while_stmt() throws ParseException {
2240
2241 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTWHILE_STMT);
2242 boolean jjtc000 = true;
2243 jjtree.openNodeScope(jjtn000);
2244 jjtreeOpenNodeScope(jjtn000);
2245 try {
2246 jj_consume_token(WHILE);
2247 test();
2248 jj_consume_token(COLON);
2249 suite();
2250 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2251 case ELSE:
2252 jj_consume_token(ELSE);
2253 jj_consume_token(COLON);
2254 suite();
2255 break;
2256 default:
2257 jj_la1[44] = jj_gen;
2258 ;
2259 }
2260 } catch (Throwable jjte000) {
2261 if (jjtc000) {
2262 jjtree.clearNodeScope(jjtn000);
2263 jjtc000 = false;
2264 } else {
2265 jjtree.popNode();
2266 }
2267 if (jjte000 instanceof RuntimeException ) {
2268 {if (true) throw (RuntimeException )jjte000;}
2269 }
2270 if (jjte000 instanceof ParseException) {
2271 {if (true) throw (ParseException)jjte000;}
2272 }
2273 {if (true) throw (Error )jjte000;}
2274 } finally {
2275 if (jjtc000) {
2276 jjtree.closeNodeScope(jjtn000, true);
2277 jjtreeCloseNodeScope(jjtn000);
2278 }
2279 }
2280 }
2281
2282 final public void for_stmt() throws ParseException {
2284
2285 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTFOR_STMT);
2286 boolean jjtc000 = true;
2287 jjtree.openNodeScope(jjtn000);
2288 jjtreeOpenNodeScope(jjtn000);
2289 try {
2290 jj_consume_token(FOR);
2291 exprlist();
2292 jj_consume_token(IN);
2293 SmartTestList();
2294 jj_consume_token(COLON);
2295 suite();
2296 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2297 case ELSE:
2298 jj_consume_token(ELSE);
2299 jj_consume_token(COLON);
2300 suite();
2301 break;
2302 default:
2303 jj_la1[45] = jj_gen;
2304 ;
2305 }
2306 } catch (Throwable jjte000) {
2307 if (jjtc000) {
2308 jjtree.clearNodeScope(jjtn000);
2309 jjtc000 = false;
2310 } else {
2311 jjtree.popNode();
2312 }
2313 if (jjte000 instanceof RuntimeException ) {
2314 {if (true) throw (RuntimeException )jjte000;}
2315 }
2316 if (jjte000 instanceof ParseException) {
2317 {if (true) throw (ParseException)jjte000;}
2318 }
2319 {if (true) throw (Error )jjte000;}
2320 } finally {
2321 if (jjtc000) {
2322 jjtree.closeNodeScope(jjtn000, true);
2323 jjtreeCloseNodeScope(jjtn000);
2324 }
2325 }
2326 }
2327
2328 final public void try_stmt() throws ParseException {
2331 jj_consume_token(TRY);
2332 jj_consume_token(COLON);
2333 suite();
2334 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2335 case EXCEPT:
2336 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTRY_STMT);
2337 boolean jjtc001 = true;
2338 jjtree.openNodeScope(jjtn001);
2339 jjtreeOpenNodeScope(jjtn001);
2340 try {
2341 label_17:
2342 while (true) {
2343 except_clause();
2344 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2345 case EXCEPT:
2346 ;
2347 break;
2348 default:
2349 jj_la1[46] = jj_gen;
2350 break label_17;
2351 }
2352 }
2353 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2354 case ELSE:
2355 jj_consume_token(ELSE);
2356 jj_consume_token(COLON);
2357 suite();
2358 break;
2359 default:
2360 jj_la1[47] = jj_gen;
2361 ;
2362 }
2363 } catch (Throwable jjte001) {
2364 if (jjtc001) {
2365 jjtree.clearNodeScope(jjtn001);
2366 jjtc001 = false;
2367 } else {
2368 jjtree.popNode();
2369 }
2370 if (jjte001 instanceof RuntimeException ) {
2371 {if (true) throw (RuntimeException )jjte001;}
2372 }
2373 if (jjte001 instanceof ParseException) {
2374 {if (true) throw (ParseException)jjte001;}
2375 }
2376 {if (true) throw (Error )jjte001;}
2377 } finally {
2378 if (jjtc001) {
2379 jjtree.closeNodeScope(jjtn001, jjtree . nodeArity ( ) + 1);
2380 jjtreeCloseNodeScope(jjtn001);
2381 }
2382 }
2383 break;
2384 case FINALLY:
2385 jj_consume_token(FINALLY);
2386 jj_consume_token(COLON);
2387 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTRYFINALLY_STMT);
2388 boolean jjtc002 = true;
2389 jjtree.openNodeScope(jjtn002);
2390 jjtreeOpenNodeScope(jjtn002);
2391 try {
2392 suite();
2393 } catch (Throwable jjte002) {
2394 if (jjtc002) {
2395 jjtree.clearNodeScope(jjtn002);
2396 jjtc002 = false;
2397 } else {
2398 jjtree.popNode();
2399 }
2400 if (jjte002 instanceof RuntimeException ) {
2401 {if (true) throw (RuntimeException )jjte002;}
2402 }
2403 if (jjte002 instanceof ParseException) {
2404 {if (true) throw (ParseException)jjte002;}
2405 }
2406 {if (true) throw (Error )jjte002;}
2407 } finally {
2408 if (jjtc002) {
2409 jjtree.closeNodeScope(jjtn002, jjtree . nodeArity ( ) + 1);
2410 jjtreeCloseNodeScope(jjtn002);
2411 }
2412 }
2413 break;
2414 default:
2415 jj_la1[48] = jj_gen;
2416 jj_consume_token(-1);
2417 throw new ParseException();
2418 }
2419 }
2420
2421 final public void except_clause() throws ParseException {
2423
2424 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXCEPT_CLAUSE);
2425 boolean jjtc000 = true;
2426 jjtree.openNodeScope(jjtn000);
2427 jjtreeOpenNodeScope(jjtn000);
2428 try {
2429 jj_consume_token(EXCEPT);
2430 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2431 case LPAREN:
2432 case LBRACE:
2433 case LBRACKET:
2434 case PLUS:
2435 case MINUS:
2436 case NOT:
2437 case NOT_BOOL:
2438 case LAMBDA:
2439 case AS:
2440 case NAME:
2441 case DECNUMBER:
2442 case HEXNUMBER:
2443 case OCTNUMBER:
2444 case FLOAT:
2445 case COMPLEX:
2446 case SINGLE_STRING:
2447 case SINGLE_STRING2:
2448 case TRIPLE_STRING:
2449 case TRIPLE_STRING2:
2450 case 121:
2451 test();
2452 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2453 case COMMA:
2454 jj_consume_token(COMMA);
2455 test();
2456 break;
2457 default:
2458 jj_la1[49] = jj_gen;
2459 ;
2460 }
2461 break;
2462 default:
2463 jj_la1[50] = jj_gen;
2464 ;
2465 }
2466 jj_consume_token(COLON);
2467 suite();
2468 } catch (Throwable jjte000) {
2469 if (jjtc000) {
2470 jjtree.clearNodeScope(jjtn000);
2471 jjtc000 = false;
2472 } else {
2473 jjtree.popNode();
2474 }
2475 if (jjte000 instanceof RuntimeException ) {
2476 {if (true) throw (RuntimeException )jjte000;}
2477 }
2478 if (jjte000 instanceof ParseException) {
2479 {if (true) throw (ParseException)jjte000;}
2480 }
2481 {if (true) throw (Error )jjte000;}
2482 } finally {
2483 if (jjtc000) {
2484 jjtree.closeNodeScope(jjtn000, true);
2485 jjtreeCloseNodeScope(jjtn000);
2486 }
2487 }
2488 }
2489
2490 final public void suite() throws ParseException {
2492
2493 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSUITE);
2494 boolean jjtc000 = true;
2495 jjtree.openNodeScope(jjtn000);
2496 jjtreeOpenNodeScope(jjtn000);
2497 try {
2498 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2499 case LPAREN:
2500 case LBRACE:
2501 case LBRACKET:
2502 case PLUS:
2503 case MINUS:
2504 case NOT:
2505 case NOT_BOOL:
2506 case LAMBDA:
2507 case PRINT:
2508 case PASS:
2509 case BREAK:
2510 case CONTINUE:
2511 case RETURN:
2512 case YIELD:
2513 case IMPORT:
2514 case FROM:
2515 case DEL:
2516 case RAISE:
2517 case GLOBAL:
2518 case EXEC:
2519 case ASSERT:
2520 case AS:
2521 case NAME:
2522 case DECNUMBER:
2523 case HEXNUMBER:
2524 case OCTNUMBER:
2525 case FLOAT:
2526 case COMPLEX:
2527 case SINGLE_STRING:
2528 case SINGLE_STRING2:
2529 case TRIPLE_STRING:
2530 case TRIPLE_STRING2:
2531 case 121:
2532 simple_stmt();
2533 break;
2534 case NEWLINE:
2535 jj_consume_token(NEWLINE);
2536 token_source.expect_indent = true;
2537 jj_consume_token(INDENT);
2538 token_source.expect_indent = false;
2539 label_18:
2540 while (true) {
2541 stmt();
2542 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2543 case LPAREN:
2544 case LBRACE:
2545 case LBRACKET:
2546 case PLUS:
2547 case MINUS:
2548 case NOT:
2549 case NOT_BOOL:
2550 case LAMBDA:
2551 case IF:
2552 case WHILE:
2553 case FOR:
2554 case TRY:
2555 case DEF:
2556 case CLASS:
2557 case PRINT:
2558 case PASS:
2559 case BREAK:
2560 case CONTINUE:
2561 case RETURN:
2562 case YIELD:
2563 case IMPORT:
2564 case FROM:
2565 case DEL:
2566 case RAISE:
2567 case GLOBAL:
2568 case EXEC:
2569 case ASSERT:
2570 case AS:
2571 case NAME:
2572 case DECNUMBER:
2573 case HEXNUMBER:
2574 case OCTNUMBER:
2575 case FLOAT:
2576 case COMPLEX:
2577 case SINGLE_STRING:
2578 case SINGLE_STRING2:
2579 case TRIPLE_STRING:
2580 case TRIPLE_STRING2:
2581 case 121:
2582 ;
2583 break;
2584 default:
2585 jj_la1[51] = jj_gen;
2586 break label_18;
2587 }
2588 }
2589 jj_consume_token(DEDENT);
2590 break;
2591 default:
2592 jj_la1[52] = jj_gen;
2593 jj_consume_token(-1);
2594 throw new ParseException();
2595 }
2596 } catch (Throwable jjte000) {
2597 if (jjtc000) {
2598 jjtree.clearNodeScope(jjtn000);
2599 jjtc000 = false;
2600 } else {
2601 jjtree.popNode();
2602 }
2603 if (jjte000 instanceof RuntimeException ) {
2604 {if (true) throw (RuntimeException )jjte000;}
2605 }
2606 if (jjte000 instanceof ParseException) {
2607 {if (true) throw (ParseException)jjte000;}
2608 }
2609 {if (true) throw (Error )jjte000;}
2610 } finally {
2611 if (jjtc000) {
2612 jjtree.closeNodeScope(jjtn000, true);
2613 jjtreeCloseNodeScope(jjtn000);
2614 }
2615 }
2616 }
2617
2618 final public void test() throws ParseException {
2620
2621 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTOR_BOOLEAN);
2622 boolean jjtc000 = true;
2623 jjtree.openNodeScope(jjtn000);
2624 jjtreeOpenNodeScope(jjtn000);
2625 try {
2626 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2627 case LAMBDA:
2628 lambdef();
2629 break;
2630 case LPAREN:
2631 case LBRACE:
2632 case LBRACKET:
2633 case PLUS:
2634 case MINUS:
2635 case NOT:
2636 case NOT_BOOL:
2637 case AS:
2638 case NAME:
2639 case DECNUMBER:
2640 case HEXNUMBER:
2641 case OCTNUMBER:
2642 case FLOAT:
2643 case COMPLEX:
2644 case SINGLE_STRING:
2645 case SINGLE_STRING2:
2646 case TRIPLE_STRING:
2647 case TRIPLE_STRING2:
2648 case 121:
2649 and_test();
2650 label_19:
2651 while (true) {
2652 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2653 case OR_BOOL:
2654 ;
2655 break;
2656 default:
2657 jj_la1[53] = jj_gen;
2658 break label_19;
2659 }
2660 jj_consume_token(OR_BOOL);
2661 and_test();
2662 }
2663 break;
2664 default:
2665 jj_la1[54] = jj_gen;
2666 jj_consume_token(-1);
2667 throw new ParseException();
2668 }
2669 } catch (Throwable jjte000) {
2670 if (jjtc000) {
2671 jjtree.clearNodeScope(jjtn000);
2672 jjtc000 = false;
2673 } else {
2674 jjtree.popNode();
2675 }
2676 if (jjte000 instanceof RuntimeException ) {
2677 {if (true) throw (RuntimeException )jjte000;}
2678 }
2679 if (jjte000 instanceof ParseException) {
2680 {if (true) throw (ParseException)jjte000;}
2681 }
2682 {if (true) throw (Error )jjte000;}
2683 } finally {
2684 if (jjtc000) {
2685 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2686 jjtreeCloseNodeScope(jjtn000);
2687 }
2688 }
2689 }
2690
2691 final public void and_test() throws ParseException {
2693
2694 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAND_BOOLEAN);
2695 boolean jjtc000 = true;
2696 jjtree.openNodeScope(jjtn000);
2697 jjtreeOpenNodeScope(jjtn000);
2698 try {
2699 not_test();
2700 label_20:
2701 while (true) {
2702 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2703 case AND_BOOL:
2704 ;
2705 break;
2706 default:
2707 jj_la1[55] = jj_gen;
2708 break label_20;
2709 }
2710 jj_consume_token(AND_BOOL);
2711 not_test();
2712 }
2713 } catch (Throwable jjte000) {
2714 if (jjtc000) {
2715 jjtree.clearNodeScope(jjtn000);
2716 jjtc000 = false;
2717 } else {
2718 jjtree.popNode();
2719 }
2720 if (jjte000 instanceof RuntimeException ) {
2721 {if (true) throw (RuntimeException )jjte000;}
2722 }
2723 if (jjte000 instanceof ParseException) {
2724 {if (true) throw (ParseException)jjte000;}
2725 }
2726 {if (true) throw (Error )jjte000;}
2727 } finally {
2728 if (jjtc000) {
2729 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2730 jjtreeCloseNodeScope(jjtn000);
2731 }
2732 }
2733 }
2734
2735 final public void not_test() throws ParseException {
2737 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2738 case NOT_BOOL:
2739 jj_consume_token(NOT_BOOL);
2740 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNOT_1OP);
2741 boolean jjtc001 = true;
2742 jjtree.openNodeScope(jjtn001);
2743 jjtreeOpenNodeScope(jjtn001);
2744 try {
2745 not_test();
2746 } catch (Throwable jjte001) {
2747 if (jjtc001) {
2748 jjtree.clearNodeScope(jjtn001);
2749 jjtc001 = false;
2750 } else {
2751 jjtree.popNode();
2752 }
2753 if (jjte001 instanceof RuntimeException ) {
2754 {if (true) throw (RuntimeException )jjte001;}
2755 }
2756 if (jjte001 instanceof ParseException) {
2757 {if (true) throw (ParseException)jjte001;}
2758 }
2759 {if (true) throw (Error )jjte001;}
2760 } finally {
2761 if (jjtc001) {
2762 jjtree.closeNodeScope(jjtn001, 1);
2763 jjtreeCloseNodeScope(jjtn001);
2764 }
2765 }
2766 break;
2767 case LPAREN:
2768 case LBRACE:
2769 case LBRACKET:
2770 case PLUS:
2771 case MINUS:
2772 case NOT:
2773 case AS:
2774 case NAME:
2775 case DECNUMBER:
2776 case HEXNUMBER:
2777 case OCTNUMBER:
2778 case FLOAT:
2779 case COMPLEX:
2780 case SINGLE_STRING:
2781 case SINGLE_STRING2:
2782 case TRIPLE_STRING:
2783 case TRIPLE_STRING2:
2784 case 121:
2785 comparison();
2786 break;
2787 default:
2788 jj_la1[56] = jj_gen;
2789 jj_consume_token(-1);
2790 throw new ParseException();
2791 }
2792 }
2793
2794 final public void comparison() throws ParseException {
2796 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCOMPARISION);
2797 boolean jjtc001 = true;
2798 jjtree.openNodeScope(jjtn001);
2799 jjtreeOpenNodeScope(jjtn001);
2800 try {
2801 expr();
2802 label_21:
2803 while (true) {
2804 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2805 case GREATER:
2806 case LESS:
2807 case EQEQUAL:
2808 case EQLESS:
2809 case EQGREATER:
2810 case LESSGREATER:
2811 case NOTEQUAL:
2812 case NOT_BOOL:
2813 case IS:
2814 case IN:
2815 ;
2816 break;
2817 default:
2818 jj_la1[57] = jj_gen;
2819 break label_21;
2820 }
2821 comp_op();
2822 expr();
2823 }
2824 } catch (Throwable jjte001) {
2825 if (jjtc001) {
2826 jjtree.clearNodeScope(jjtn001);
2827 jjtc001 = false;
2828 } else {
2829 jjtree.popNode();
2830 }
2831 if (jjte001 instanceof RuntimeException ) {
2832 {if (true) throw (RuntimeException )jjte001;}
2833 }
2834 if (jjte001 instanceof ParseException) {
2835 {if (true) throw (ParseException)jjte001;}
2836 }
2837 {if (true) throw (Error )jjte001;}
2838 } finally {
2839 if (jjtc001) {
2840 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
2841 jjtreeCloseNodeScope(jjtn001);
2842 }
2843 }
2844 }
2845
2846 final public void comp_op() throws ParseException {
2848 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2849 case LESS:
2850 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTLESS_CMP);
2851 boolean jjtc001 = true;
2852 jjtree.openNodeScope(jjtn001);
2853 jjtreeOpenNodeScope(jjtn001);
2854 try {
2855 jj_consume_token(LESS);
2856 } finally {
2857 if (jjtc001) {
2858 jjtree.closeNodeScope(jjtn001, 0);
2859 jjtreeCloseNodeScope(jjtn001);
2860 }
2861 }
2862 break;
2863 case GREATER:
2864 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTGREATER_CMP);
2865 boolean jjtc002 = true;
2866 jjtree.openNodeScope(jjtn002);
2867 jjtreeOpenNodeScope(jjtn002);
2868 try {
2869 jj_consume_token(GREATER);
2870 } finally {
2871 if (jjtc002) {
2872 jjtree.closeNodeScope(jjtn002, 0);
2873 jjtreeCloseNodeScope(jjtn002);
2874 }
2875 }
2876 break;
2877 case EQEQUAL:
2878 SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEQUAL_CMP);
2879 boolean jjtc003 = true;
2880 jjtree.openNodeScope(jjtn003);
2881 jjtreeOpenNodeScope(jjtn003);
2882 try {
2883 jj_consume_token(EQEQUAL);
2884 } finally {
2885 if (jjtc003) {
2886 jjtree.closeNodeScope(jjtn003, 0);
2887 jjtreeCloseNodeScope(jjtn003);
2888 }
2889 }
2890 break;
2891 case EQGREATER:
2892 SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTGREATER_EQUAL_CMP);
2893 boolean jjtc004 = true;
2894 jjtree.openNodeScope(jjtn004);
2895 jjtreeOpenNodeScope(jjtn004);
2896 try {
2897 jj_consume_token(EQGREATER);
2898 } finally {
2899 if (jjtc004) {
2900 jjtree.closeNodeScope(jjtn004, 0);
2901 jjtreeCloseNodeScope(jjtn004);
2902 }
2903 }
2904 break;
2905 case EQLESS:
2906 SimpleNode jjtn005 = (SimpleNode)SimpleNode.jjtCreate(this, JJTLESS_EQUAL_CMP);
2907 boolean jjtc005 = true;
2908 jjtree.openNodeScope(jjtn005);
2909 jjtreeOpenNodeScope(jjtn005);
2910 try {
2911 jj_consume_token(EQLESS);
2912 } finally {
2913 if (jjtc005) {
2914 jjtree.closeNodeScope(jjtn005, 0);
2915 jjtreeCloseNodeScope(jjtn005);
2916 }
2917 }
2918 break;
2919 case LESSGREATER:
2920 SimpleNode jjtn006 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNOTEQUAL_CMP);
2921 boolean jjtc006 = true;
2922 jjtree.openNodeScope(jjtn006);
2923 jjtreeOpenNodeScope(jjtn006);
2924 try {
2925 jj_consume_token(LESSGREATER);
2926 } finally {
2927 if (jjtc006) {
2928 jjtree.closeNodeScope(jjtn006, 0);
2929 jjtreeCloseNodeScope(jjtn006);
2930 }
2931 }
2932 break;
2933 case NOTEQUAL:
2934 SimpleNode jjtn007 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNOTEQUAL_CMP);
2935 boolean jjtc007 = true;
2936 jjtree.openNodeScope(jjtn007);
2937 jjtreeOpenNodeScope(jjtn007);
2938 try {
2939 jj_consume_token(NOTEQUAL);
2940 } finally {
2941 if (jjtc007) {
2942 jjtree.closeNodeScope(jjtn007, 0);
2943 jjtreeCloseNodeScope(jjtn007);
2944 }
2945 }
2946 break;
2947 case IN:
2948 SimpleNode jjtn008 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIN_CMP);
2949 boolean jjtc008 = true;
2950 jjtree.openNodeScope(jjtn008);
2951 jjtreeOpenNodeScope(jjtn008);
2952 try {
2953 jj_consume_token(IN);
2954 } finally {
2955 if (jjtc008) {
2956 jjtree.closeNodeScope(jjtn008, 0);
2957 jjtreeCloseNodeScope(jjtn008);
2958 }
2959 }
2960 break;
2961 case NOT_BOOL:
2962 jj_consume_token(NOT_BOOL);
2963 SimpleNode jjtn009 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNOT_IN_CMP);
2964 boolean jjtc009 = true;
2965 jjtree.openNodeScope(jjtn009);
2966 jjtreeOpenNodeScope(jjtn009);
2967 try {
2968 jj_consume_token(IN);
2969 } finally {
2970 if (jjtc009) {
2971 jjtree.closeNodeScope(jjtn009, 0);
2972 jjtreeCloseNodeScope(jjtn009);
2973 }
2974 }
2975 break;
2976 default:
2977 jj_la1[58] = jj_gen;
2978 if (jj_2_12(2)) {
2979 jj_consume_token(IS);
2980 SimpleNode jjtn010 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIS_NOT_CMP);
2981 boolean jjtc010 = true;
2982 jjtree.openNodeScope(jjtn010);
2983 jjtreeOpenNodeScope(jjtn010);
2984 try {
2985 jj_consume_token(NOT_BOOL);
2986 } finally {
2987 if (jjtc010) {
2988 jjtree.closeNodeScope(jjtn010, 0);
2989 jjtreeCloseNodeScope(jjtn010);
2990 }
2991 }
2992 } else {
2993 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2994 case IS:
2995 SimpleNode jjtn011 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIS_CMP);
2996 boolean jjtc011 = true;
2997 jjtree.openNodeScope(jjtn011);
2998 jjtreeOpenNodeScope(jjtn011);
2999 try {
3000 jj_consume_token(IS);
3001 } finally {
3002 if (jjtc011) {
3003 jjtree.closeNodeScope(jjtn011, 0);
3004 jjtreeCloseNodeScope(jjtn011);
3005 }
3006 }
3007 break;
3008 default:
3009 jj_la1[59] = jj_gen;
3010 jj_consume_token(-1);
3011 throw new ParseException();
3012 }
3013 }
3014 }
3015 }
3016
3017 final public void expr() throws ParseException {
3019 xor_expr();
3020 label_22:
3021 while (true) {
3022 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3023 case OR:
3024 ;
3025 break;
3026 default:
3027 jj_la1[60] = jj_gen;
3028 break label_22;
3029 }
3030 jj_consume_token(OR);
3031 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTOR_2OP);
3032 boolean jjtc001 = true;
3033 jjtree.openNodeScope(jjtn001);
3034 jjtreeOpenNodeScope(jjtn001);
3035 try {
3036 xor_expr();
3037 } catch (Throwable jjte001) {
3038 if (jjtc001) {
3039 jjtree.clearNodeScope(jjtn001);
3040 jjtc001 = false;
3041 } else {
3042 jjtree.popNode();
3043 }
3044 if (jjte001 instanceof RuntimeException ) {
3045 {if (true) throw (RuntimeException )jjte001;}
3046 }
3047 if (jjte001 instanceof ParseException) {
3048 {if (true) throw (ParseException)jjte001;}
3049 }
3050 {if (true) throw (Error )jjte001;}
3051 } finally {
3052 if (jjtc001) {
3053 jjtree.closeNodeScope(jjtn001, 2);
3054 jjtreeCloseNodeScope(jjtn001);
3055 }
3056 }
3057 }
3058 }
3059
3060 final public void xor_expr() throws ParseException {
3062 and_expr();
3063 label_23:
3064 while (true) {
3065 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3066 case XOR:
3067 ;
3068 break;
3069 default:
3070 jj_la1[61] = jj_gen;
3071 break label_23;
3072 }
3073 jj_consume_token(XOR);
3074 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTXOR_2OP);
3075 boolean jjtc001 = true;
3076 jjtree.openNodeScope(jjtn001);
3077 jjtreeOpenNodeScope(jjtn001);
3078 try {
3079 and_expr();
3080 } catch (Throwable jjte001) {
3081 if (jjtc001) {
3082 jjtree.clearNodeScope(jjtn001);
3083 jjtc001 = false;
3084 } else {
3085 jjtree.popNode();
3086 }
3087 if (jjte001 instanceof RuntimeException ) {
3088 {if (true) throw (RuntimeException )jjte001;}
3089 }
3090 if (jjte001 instanceof ParseException) {
3091 {if (true) throw (ParseException)jjte001;}
3092 }
3093 {if (true) throw (Error )jjte001;}
3094 } finally {
3095 if (jjtc001) {
3096 jjtree.closeNodeScope(jjtn001, 2);
3097 jjtreeCloseNodeScope(jjtn001);
3098 }
3099 }
3100 }
3101 }
3102
3103 final public void and_expr() throws ParseException {
3105 shift_expr();
3106 label_24:
3107 while (true) {
3108 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3109 case AND:
3110 ;
3111 break;
3112 default:
3113 jj_la1[62] = jj_gen;
3114 break label_24;
3115 }
3116 jj_consume_token(AND);
3117 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAND_2OP);
3118 boolean jjtc001 = true;
3119 jjtree.openNodeScope(jjtn001);
3120 jjtreeOpenNodeScope(jjtn001);
3121 try {
3122 shift_expr();
3123 } catch (Throwable jjte001) {
3124 if (jjtc001) {
3125 jjtree.clearNodeScope(jjtn001);
3126 jjtc001 = false;
3127 } else {
3128 jjtree.popNode();
3129 }
3130 if (jjte001 instanceof RuntimeException ) {
3131 {if (true) throw (RuntimeException )jjte001;}
3132 }
3133 if (jjte001 instanceof ParseException) {
3134 {if (true) throw (ParseException)jjte001;}
3135 }
3136 {if (true) throw (Error )jjte001;}
3137 } finally {
3138 if (jjtc001) {
3139 jjtree.closeNodeScope(jjtn001, 2);
3140 jjtreeCloseNodeScope(jjtn001);
3141 }
3142 }
3143 }
3144 }
3145
3146 final public void shift_expr() throws ParseException {
3148 arith_expr();
3149 label_25:
3150 while (true) {
3151 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3152 case LSHIFT:
3153 case RSHIFT:
3154 ;
3155 break;
3156 default:
3157 jj_la1[63] = jj_gen;
3158 break label_25;
3159 }
3160 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3161 case LSHIFT:
3162 jj_consume_token(LSHIFT);
3163 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTLSHIFT_2OP);
3164 boolean jjtc001 = true;
3165 jjtree.openNodeScope(jjtn001);
3166 jjtreeOpenNodeScope(jjtn001);
3167 try {
3168 arith_expr();
3169 } catch (Throwable jjte001) {
3170 if (jjtc001) {
3171 jjtree.clearNodeScope(jjtn001);
3172 jjtc001 = false;
3173 } else {
3174 jjtree.popNode();
3175 }
3176 if (jjte001 instanceof RuntimeException ) {
3177 {if (true) throw (RuntimeException )jjte001;}
3178 }
3179 if (jjte001 instanceof ParseException) {
3180 {if (true) throw (ParseException)jjte001;}
3181 }
3182 {if (true) throw (Error )jjte001;}
3183 } finally {
3184 if (jjtc001) {
3185 jjtree.closeNodeScope(jjtn001, 2);
3186 jjtreeCloseNodeScope(jjtn001);
3187 }
3188 }
3189 break;
3190 case RSHIFT:
3191 jj_consume_token(RSHIFT);
3192 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTRSHIFT_2OP);
3193 boolean jjtc002 = true;
3194 jjtree.openNodeScope(jjtn002);
3195 jjtreeOpenNodeScope(jjtn002);
3196 try {
3197 arith_expr();
3198 } catch (Throwable jjte002) {
3199 if (jjtc002) {
3200 jjtree.clearNodeScope(jjtn002);
3201 jjtc002 = false;
3202 } else {
3203 jjtree.popNode();
3204 }
3205 if (jjte002 instanceof RuntimeException ) {
3206 {if (true) throw (RuntimeException )jjte002;}
3207 }
3208 if (jjte002 instanceof ParseException) {
3209 {if (true) throw (ParseException)jjte002;}
3210 }
3211 {if (true) throw (Error )jjte002;}
3212 } finally {
3213 if (jjtc002) {
3214 jjtree.closeNodeScope(jjtn002, 2);
3215 jjtreeCloseNodeScope(jjtn002);
3216 }
3217 }
3218 break;
3219 default:
3220 jj_la1[64] = jj_gen;
3221 jj_consume_token(-1);
3222 throw new ParseException();
3223 }
3224 }
3225 }
3226
3227 final public void arith_expr() throws ParseException {
3229 term();
3230 label_26:
3231 while (true) {
3232 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3233 case PLUS:
3234 case MINUS:
3235 ;
3236 break;
3237 default:
3238 jj_la1[65] = jj_gen;
3239 break label_26;
3240 }
3241 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3242 case PLUS:
3243 jj_consume_token(PLUS);
3244 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTADD_2OP);
3245 boolean jjtc001 = true;
3246 jjtree.openNodeScope(jjtn001);
3247 jjtreeOpenNodeScope(jjtn001);
3248 try {
3249 term();
3250 } catch (Throwable jjte001) {
3251 if (jjtc001) {
3252 jjtree.clearNodeScope(jjtn001);
3253 jjtc001 = false;
3254 } else {
3255 jjtree.popNode();
3256 }
3257 if (jjte001 instanceof RuntimeException ) {
3258 {if (true) throw (RuntimeException )jjte001;}
3259 }
3260 if (jjte001 instanceof ParseException) {
3261 {if (true) throw (ParseException)jjte001;}
3262 }
3263 {if (true) throw (Error )jjte001;}
3264 } finally {
3265 if (jjtc001) {
3266 jjtree.closeNodeScope(jjtn001, 2);
3267 jjtreeCloseNodeScope(jjtn001);
3268 }
3269 }
3270 break;
3271 case MINUS:
3272 jj_consume_token(MINUS);
3273 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSUB_2OP);
3274 boolean jjtc002 = true;
3275 jjtree.openNodeScope(jjtn002);
3276 jjtreeOpenNodeScope(jjtn002);
3277 try {
3278 term();
3279 } catch (Throwable jjte002) {
3280 if (jjtc002) {
3281 jjtree.clearNodeScope(jjtn002);
3282 jjtc002 = false;
3283 } else {
3284 jjtree.popNode();
3285 }
3286 if (jjte002 instanceof RuntimeException ) {
3287 {if (true) throw (RuntimeException )jjte002;}
3288 }
3289 if (jjte002 instanceof ParseException) {
3290 {if (true) throw (ParseException)jjte002;}
3291 }
3292 {if (true) throw (Error )jjte002;}
3293 } finally {
3294 if (jjtc002) {
3295 jjtree.closeNodeScope(jjtn002, 2);
3296 jjtreeCloseNodeScope(jjtn002);
3297 }
3298 }
3299 break;
3300 default:
3301 jj_la1[66] = jj_gen;
3302 jj_consume_token(-1);
3303 throw new ParseException();
3304 }
3305 }
3306 }
3307
3308 final public void term() throws ParseException {
3310 factor();
3311 label_27:
3312 while (true) {
3313 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3314 case MULTIPLY:
3315 case DIVIDE:
3316 case FLOORDIVIDE:
3317 case MODULO:
3318 ;
3319 break;
3320 default:
3321 jj_la1[67] = jj_gen;
3322 break label_27;
3323 }
3324 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3325 case MULTIPLY:
3326 jj_consume_token(MULTIPLY);
3327 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTMUL_2OP);
3328 boolean jjtc001 = true;
3329 jjtree.openNodeScope(jjtn001);
3330 jjtreeOpenNodeScope(jjtn001);
3331 try {
3332 factor();
3333 } catch (Throwable jjte001) {
3334 if (jjtc001) {
3335 jjtree.clearNodeScope(jjtn001);
3336 jjtc001 = false;
3337 } else {
3338 jjtree.popNode();
3339 }
3340 if (jjte001 instanceof RuntimeException ) {
3341 {if (true) throw (RuntimeException )jjte001;}
3342 }
3343 if (jjte001 instanceof ParseException) {
3344 {if (true) throw (ParseException)jjte001;}
3345 }
3346 {if (true) throw (Error )jjte001;}
3347 } finally {
3348 if (jjtc001) {
3349 jjtree.closeNodeScope(jjtn001, 2);
3350 jjtreeCloseNodeScope(jjtn001);
3351 }
3352 }
3353 break;
3354 case DIVIDE:
3355 jj_consume_token(DIVIDE);
3356 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTDIV_2OP);
3357 boolean jjtc002 = true;
3358 jjtree.openNodeScope(jjtn002);
3359 jjtreeOpenNodeScope(jjtn002);
3360 try {
3361 factor();
3362 } catch (Throwable jjte002) {
3363 if (jjtc002) {
3364 jjtree.clearNodeScope(jjtn002);
3365 jjtc002 = false;
3366 } else {
3367 jjtree.popNode();
3368 }
3369 if (jjte002 instanceof RuntimeException ) {
3370 {if (true) throw (RuntimeException )jjte002;}
3371 }
3372 if (jjte002 instanceof ParseException) {
3373 {if (true) throw (ParseException)jjte002;}
3374 }
3375 {if (true) throw (Error )jjte002;}
3376 } finally {
3377 if (jjtc002) {
3378 jjtree.closeNodeScope(jjtn002, 2);
3379 jjtreeCloseNodeScope(jjtn002);
3380 }
3381 }
3382 break;
3383 case FLOORDIVIDE:
3384 jj_consume_token(FLOORDIVIDE);
3385 SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTFLOORDIV_2OP);
3386 boolean jjtc003 = true;
3387 jjtree.openNodeScope(jjtn003);
3388 jjtreeOpenNodeScope(jjtn003);
3389 try {
3390 factor();
3391 } catch (Throwable jjte003) {
3392 if (jjtc003) {
3393 jjtree.clearNodeScope(jjtn003);
3394 jjtc003 = false;
3395 } else {
3396 jjtree.popNode();
3397 }
3398 if (jjte003 instanceof RuntimeException ) {
3399 {if (true) throw (RuntimeException )jjte003;}
3400 }
3401 if (jjte003 instanceof ParseException) {
3402 {if (true) throw (ParseException)jjte003;}
3403 }
3404 {if (true) throw (Error )jjte003;}
3405 } finally {
3406 if (jjtc003) {
3407 jjtree.closeNodeScope(jjtn003, 2);
3408 jjtreeCloseNodeScope(jjtn003);
3409 }
3410 }
3411 break;
3412 case MODULO:
3413 jj_consume_token(MODULO);
3414 SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTMOD_2OP);
3415 boolean jjtc004 = true;
3416 jjtree.openNodeScope(jjtn004);
3417 jjtreeOpenNodeScope(jjtn004);
3418 try {
3419 factor();
3420 } catch (Throwable jjte004) {
3421 if (jjtc004) {
3422 jjtree.clearNodeScope(jjtn004);
3423 jjtc004 = false;
3424 } else {
3425 jjtree.popNode();
3426 }
3427 if (jjte004 instanceof RuntimeException ) {
3428 {if (true) throw (RuntimeException )jjte004;}
3429 }
3430 if (jjte004 instanceof ParseException) {
3431 {if (true) throw (ParseException)jjte004;}
3432 }
3433 {if (true) throw (Error )jjte004;}
3434 } finally {
3435 if (jjtc004) {
3436 jjtree.closeNodeScope(jjtn004, 2);
3437 jjtreeCloseNodeScope(jjtn004);
3438 }
3439 }
3440 break;
3441 default:
3442 jj_la1[68] = jj_gen;
3443 jj_consume_token(-1);
3444 throw new ParseException();
3445 }
3446 }
3447 }
3448
3449 final public void factor() throws ParseException {
3451 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3452 case PLUS:
3453 jj_consume_token(PLUS);
3454 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPOS_1OP);
3455 boolean jjtc001 = true;
3456 jjtree.openNodeScope(jjtn001);
3457 jjtreeOpenNodeScope(jjtn001);
3458 try {
3459 factor();
3460 } catch (Throwable jjte001) {
3461 if (jjtc001) {
3462 jjtree.clearNodeScope(jjtn001);
3463 jjtc001 = false;
3464 } else {
3465 jjtree.popNode();
3466 }
3467 if (jjte001 instanceof RuntimeException ) {
3468 {if (true) throw (RuntimeException )jjte001;}
3469 }
3470 if (jjte001 instanceof ParseException) {
3471 {if (true) throw (ParseException)jjte001;}
3472 }
3473 {if (true) throw (Error )jjte001;}
3474 } finally {
3475 if (jjtc001) {
3476 jjtree.closeNodeScope(jjtn001, 1);
3477 jjtreeCloseNodeScope(jjtn001);
3478 }
3479 }
3480 break;
3481 case MINUS:
3482 jj_consume_token(MINUS);
3483 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNEG_1OP);
3484 boolean jjtc002 = true;
3485 jjtree.openNodeScope(jjtn002);
3486 jjtreeOpenNodeScope(jjtn002);
3487 try {
3488 factor();
3489 } catch (Throwable jjte002) {
3490 if (jjtc002) {
3491 jjtree.clearNodeScope(jjtn002);
3492 jjtc002 = false;
3493 } else {
3494 jjtree.popNode();
3495 }
3496 if (jjte002 instanceof RuntimeException ) {
3497 {if (true) throw (RuntimeException )jjte002;}
3498 }
3499 if (jjte002 instanceof ParseException) {
3500 {if (true) throw (ParseException)jjte002;}
3501 }
3502 {if (true) throw (Error )jjte002;}
3503 } finally {
3504 if (jjtc002) {
3505 jjtree.closeNodeScope(jjtn002, 1);
3506 jjtreeCloseNodeScope(jjtn002);
3507 }
3508 }
3509 break;
3510 case NOT:
3511 jj_consume_token(NOT);
3512 SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTINVERT_1OP);
3513 boolean jjtc003 = true;
3514 jjtree.openNodeScope(jjtn003);
3515 jjtreeOpenNodeScope(jjtn003);
3516 try {
3517 factor();
3518 } catch (Throwable jjte003) {
3519 if (jjtc003) {
3520 jjtree.clearNodeScope(jjtn003);
3521 jjtc003 = false;
3522 } else {
3523 jjtree.popNode();
3524 }
3525 if (jjte003 instanceof RuntimeException ) {
3526 {if (true) throw (RuntimeException )jjte003;}
3527 }
3528 if (jjte003 instanceof ParseException) {
3529 {if (true) throw (ParseException)jjte003;}
3530 }
3531 {if (true) throw (Error )jjte003;}
3532 } finally {
3533 if (jjtc003) {
3534 jjtree.closeNodeScope(jjtn003, 1);
3535 jjtreeCloseNodeScope(jjtn003);
3536 }
3537 }
3538 break;
3539 case LPAREN:
3540 case LBRACE:
3541 case LBRACKET:
3542 case AS:
3543 case NAME:
3544 case DECNUMBER:
3545 case HEXNUMBER:
3546 case OCTNUMBER:
3547 case FLOAT:
3548 case COMPLEX:
3549 case SINGLE_STRING:
3550 case SINGLE_STRING2:
3551 case TRIPLE_STRING:
3552 case TRIPLE_STRING2:
3553 case 121:
3554 power();
3555 break;
3556 default:
3557 jj_la1[69] = jj_gen;
3558 jj_consume_token(-1);
3559 throw new ParseException();
3560 }
3561 }
3562
3563
3564
3565 final public void power() throws ParseException {
3567 atomtrailer();
3568 label_28:
3569 while (true) {
3570 if (jj_2_13(2)) {
3571 ;
3572 } else {
3573 break label_28;
3574 }
3575 jj_consume_token(POWER);
3576 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPOW_2OP);
3577 boolean jjtc001 = true;
3578 jjtree.openNodeScope(jjtn001);
3579 jjtreeOpenNodeScope(jjtn001);
3580 try {
3581 factor();
3582 } catch (Throwable jjte001) {
3583 if (jjtc001) {
3584 jjtree.clearNodeScope(jjtn001);
3585 jjtc001 = false;
3586 } else {
3587 jjtree.popNode();
3588 }
3589 if (jjte001 instanceof RuntimeException ) {
3590 {if (true) throw (RuntimeException )jjte001;}
3591 }
3592 if (jjte001 instanceof ParseException) {
3593 {if (true) throw (ParseException)jjte001;}
3594 }
3595 {if (true) throw (Error )jjte001;}
3596 } finally {
3597 if (jjtc001) {
3598 jjtree.closeNodeScope(jjtn001, 2);
3599 jjtreeCloseNodeScope(jjtn001);
3600 }
3601 }
3602 }
3603 }
3604
3605 final public void atomtrailer() throws ParseException {
3607 atom();
3608 label_29:
3609 while (true) {
3610 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3611 case LPAREN:
3612 case LBRACKET:
3613 case DOT:
3614 ;
3615 break;
3616 default:
3617 jj_la1[70] = jj_gen;
3618 break label_29;
3619 }
3620 if (jj_2_14(2)) {
3621 jj_consume_token(LPAREN);
3622 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCALL_OP);
3623 boolean jjtc001 = true;
3624 jjtree.openNodeScope(jjtn001);
3625 jjtreeOpenNodeScope(jjtn001);
3626 try {
3627 jj_consume_token(RPAREN);
3628 } finally {
3629 if (jjtc001) {
3630 jjtree.closeNodeScope(jjtn001, 1);
3631 jjtreeCloseNodeScope(jjtn001);
3632 }
3633 }
3634 } else {
3635 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3636 case LPAREN:
3637 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCALL_OP);
3638 boolean jjtc002 = true;
3639 jjtree.openNodeScope(jjtn002);
3640 jjtreeOpenNodeScope(jjtn002);
3641 try {
3642 jj_consume_token(LPAREN);
3643 arglist();
3644 jj_consume_token(RPAREN);
3645 } catch (Throwable jjte002) {
3646 if (jjtc002) {
3647 jjtree.clearNodeScope(jjtn002);
3648 jjtc002 = false;
3649 } else {
3650 jjtree.popNode();
3651 }
3652 if (jjte002 instanceof RuntimeException ) {
3653 {if (true) throw (RuntimeException )jjte002;}
3654 }
3655 if (jjte002 instanceof ParseException) {
3656 {if (true) throw (ParseException)jjte002;}
3657 }
3658 {if (true) throw (Error )jjte002;}
3659 } finally {
3660 if (jjtc002) {
3661 jjtree.closeNodeScope(jjtn002, jjtree . nodeArity ( ) + 1);
3662 jjtreeCloseNodeScope(jjtn002);
3663 }
3664 }
3665 break;
3666 case LBRACKET:
3667 jj_consume_token(LBRACKET);
3668 subscriptlist();
3669 SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTINDEX_OP);
3670 boolean jjtc003 = true;
3671 jjtree.openNodeScope(jjtn003);
3672 jjtreeOpenNodeScope(jjtn003);
3673 try {
3674 jj_consume_token(RBRACKET);
3675 } finally {
3676 if (jjtc003) {
3677 jjtree.closeNodeScope(jjtn003, 2);
3678 jjtreeCloseNodeScope(jjtn003);
3679 }
3680 }
3681 break;
3682 case DOT:
3683 jj_consume_token(DOT);
3684 SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTDOT_OP);
3685 boolean jjtc004 = true;
3686 jjtree.openNodeScope(jjtn004);
3687 jjtreeOpenNodeScope(jjtn004);
3688 try {
3689 AnyName();
3690 } catch (Throwable jjte004) {
3691 if (jjtc004) {
3692 jjtree.clearNodeScope(jjtn004);
3693 jjtc004 = false;
3694 } else {
3695 jjtree.popNode();
3696 }
3697 if (jjte004 instanceof RuntimeException ) {
3698 {if (true) throw (RuntimeException )jjte004;}
3699 }
3700 if (jjte004 instanceof ParseException) {
3701 {if (true) throw (ParseException)jjte004;}
3702 }
3703 {if (true) throw (Error )jjte004;}
3704 } finally {
3705 if (jjtc004) {
3706 jjtree.closeNodeScope(jjtn004, 2);
3707 jjtreeCloseNodeScope(jjtn004);
3708 }
3709 }
3710 break;
3711 default:
3712 jj_la1[71] = jj_gen;
3713 jj_consume_token(-1);
3714 throw new ParseException();
3715 }
3716 }
3717 }
3718 }
3719
3720 final public void atom() throws ParseException {
3722 if (jj_2_15(2)) {
3723 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTUPLE);
3724 boolean jjtc001 = true;
3725 jjtree.openNodeScope(jjtn001);
3726 jjtreeOpenNodeScope(jjtn001);
3727 try {
3728 jj_consume_token(LPAREN);
3729 jj_consume_token(RPAREN);
3730 } finally {
3731 if (jjtc001) {
3732 jjtree.closeNodeScope(jjtn001, true);
3733 jjtreeCloseNodeScope(jjtn001);
3734 }
3735 }
3736 } else {
3737 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3738 case LPAREN:
3739 jj_consume_token(LPAREN);
3740 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3741 case LPAREN:
3742 case LBRACE:
3743 case LBRACKET:
3744 case PLUS:
3745 case MINUS:
3746 case NOT:
3747 case NOT_BOOL:
3748 case LAMBDA:
3749 case AS:
3750 case NAME:
3751 case DECNUMBER:
3752 case HEXNUMBER:
3753 case OCTNUMBER:
3754 case FLOAT:
3755 case COMPLEX:
3756 case SINGLE_STRING:
3757 case SINGLE_STRING2:
3758 case TRIPLE_STRING:
3759 case TRIPLE_STRING2:
3760 case 121:
3761 SmartTestList();
3762 break;
3763 default:
3764 jj_la1[72] = jj_gen;
3765 ;
3766 }
3767 jj_consume_token(RPAREN);
3768 break;
3769 case LBRACKET:
3770 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTLIST);
3771 boolean jjtc002 = true;
3772 jjtree.openNodeScope(jjtn002);
3773 jjtreeOpenNodeScope(jjtn002);
3774 try {
3775 jj_consume_token(LBRACKET);
3776 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3777 case LPAREN:
3778 case LBRACE:
3779 case LBRACKET:
3780 case PLUS:
3781 case MINUS:
3782 case NOT:
3783 case NOT_BOOL:
3784 case LAMBDA:
3785 case AS:
3786 case NAME:
3787 case DECNUMBER:
3788 case HEXNUMBER:
3789 case OCTNUMBER:
3790 case FLOAT:
3791 case COMPLEX:
3792 case SINGLE_STRING:
3793 case SINGLE_STRING2:
3794 case TRIPLE_STRING:
3795 case TRIPLE_STRING2:
3796 case 121:
3797 listmaker();
3798 break;
3799 default:
3800 jj_la1[73] = jj_gen;
3801 ;
3802 }
3803 jj_consume_token(RBRACKET);
3804 } catch (Throwable jjte002) {
3805 if (jjtc002) {
3806 jjtree.clearNodeScope(jjtn002);
3807 jjtc002 = false;
3808 } else {
3809 jjtree.popNode();
3810 }
3811 if (jjte002 instanceof RuntimeException ) {
3812 {if (true) throw (RuntimeException )jjte002;}
3813 }
3814 if (jjte002 instanceof ParseException) {
3815 {if (true) throw (ParseException)jjte002;}
3816 }
3817 {if (true) throw (Error )jjte002;}
3818 } finally {
3819 if (jjtc002) {
3820 jjtree.closeNodeScope(jjtn002, true);
3821 jjtreeCloseNodeScope(jjtn002);
3822 }
3823 }
3824 break;
3825 case LBRACE:
3826 SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTDICTIONARY);
3827 boolean jjtc003 = true;
3828 jjtree.openNodeScope(jjtn003);
3829 jjtreeOpenNodeScope(jjtn003);
3830 try {
3831 jj_consume_token(LBRACE);
3832 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3833 case LPAREN:
3834 case LBRACE:
3835 case LBRACKET:
3836 case PLUS:
3837 case MINUS:
3838 case NOT:
3839 case NOT_BOOL:
3840 case LAMBDA:
3841 case AS:
3842 case NAME:
3843 case DECNUMBER:
3844 case HEXNUMBER:
3845 case OCTNUMBER:
3846 case FLOAT:
3847 case COMPLEX:
3848 case SINGLE_STRING:
3849 case SINGLE_STRING2:
3850 case TRIPLE_STRING:
3851 case TRIPLE_STRING2:
3852 case 121:
3853 dictmaker();
3854 break;
3855 default:
3856 jj_la1[74] = jj_gen;
3857 ;
3858 }
3859 jj_consume_token(RBRACE);
3860 } catch (Throwable jjte003) {
3861 if (jjtc003) {
3862 jjtree.clearNodeScope(jjtn003);
3863 jjtc003 = false;
3864 } else {
3865 jjtree.popNode();
3866 }
3867 if (jjte003 instanceof RuntimeException ) {
3868 {if (true) throw (RuntimeException )jjte003;}
3869 }
3870 if (jjte003 instanceof ParseException) {
3871 {if (true) throw (ParseException)jjte003;}
3872 }
3873 {if (true) throw (Error )jjte003;}
3874 } finally {
3875 if (jjtc003) {
3876 jjtree.closeNodeScope(jjtn003, true);
3877 jjtreeCloseNodeScope(jjtn003);
3878 }
3879 }
3880 break;
3881 case 121:
3882 jj_consume_token(121);
3883 SmartTestList();
3884 SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSTR_1OP);
3885 boolean jjtc004 = true;
3886 jjtree.openNodeScope(jjtn004);
3887 jjtreeOpenNodeScope(jjtn004);
3888 try {
3889 jj_consume_token(121);
3890 } finally {
3891 if (jjtc004) {
3892 jjtree.closeNodeScope(jjtn004, 1);
3893 jjtreeCloseNodeScope(jjtn004);
3894 }
3895 }
3896 break;
3897 case AS:
3898 case NAME:
3899 Name();
3900 break;
3901 case DECNUMBER:
3902 case HEXNUMBER:
3903 case OCTNUMBER:
3904 case FLOAT:
3905 case COMPLEX:
3906 Number();
3907 break;
3908 case SINGLE_STRING:
3909 case SINGLE_STRING2:
3910 case TRIPLE_STRING:
3911 case TRIPLE_STRING2:
3912 String();
3913 label_30:
3914 while (true) {
3915 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3916 case SINGLE_STRING:
3917 case SINGLE_STRING2:
3918 case TRIPLE_STRING:
3919 case TRIPLE_STRING2:
3920 ;
3921 break;
3922 default:
3923 jj_la1[75] = jj_gen;
3924 break label_30;
3925 }
3926 SimpleNode jjtn005 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSTRJOIN);
3927 boolean jjtc005 = true;
3928 jjtree.openNodeScope(jjtn005);
3929 jjtreeOpenNodeScope(jjtn005);
3930 try {
3931 String();
3932 } catch (Throwable jjte005) {
3933 if (jjtc005) {
3934 jjtree.clearNodeScope(jjtn005);
3935 jjtc005 = false;
3936 } else {
3937 jjtree.popNode();
3938 }
3939 if (jjte005 instanceof RuntimeException ) {
3940 {if (true) throw (RuntimeException )jjte005;}
3941 }
3942 if (jjte005 instanceof ParseException) {
3943 {if (true) throw (ParseException)jjte005;}
3944 }
3945 {if (true) throw (Error )jjte005;}
3946 } finally {
3947 if (jjtc005) {
3948 jjtree.closeNodeScope(jjtn005, 2);
3949 jjtreeCloseNodeScope(jjtn005);
3950 }
3951 }
3952 }
3953 break;
3954 default:
3955 jj_la1[76] = jj_gen;
3956 jj_consume_token(-1);
3957 throw new ParseException();
3958 }
3959 }
3960 }
3961
3962 final public void lambdef() throws ParseException {
3964
3965 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTLAMBDEF);
3966 boolean jjtc000 = true;
3967 jjtree.openNodeScope(jjtn000);
3968 jjtreeOpenNodeScope(jjtn000);
3969 try {
3970 jj_consume_token(LAMBDA);
3971 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3972 case LPAREN:
3973 case MULTIPLY:
3974 case POWER:
3975 case AS:
3976 case NAME:
3977 varargslist();
3978 break;
3979 default:
3980 jj_la1[77] = jj_gen;
3981 ;
3982 }
3983 jj_consume_token(COLON);
3984 test();
3985 } catch (Throwable jjte000) {
3986 if (jjtc000) {
3987 jjtree.clearNodeScope(jjtn000);
3988 jjtc000 = false;
3989 } else {
3990 jjtree.popNode();
3991 }
3992 if (jjte000 instanceof RuntimeException ) {
3993 {if (true) throw (RuntimeException )jjte000;}
3994 }
3995 if (jjte000 instanceof ParseException) {
3996 {if (true) throw (ParseException)jjte000;}
3997 }
3998 {if (true) throw (Error )jjte000;}
3999 } finally {
4000 if (jjtc000) {
4001 jjtree.closeNodeScope(jjtn000, true);
4002 jjtreeCloseNodeScope(jjtn000);
4003 }
4004 }
4005 }
4006
4007 final public void subscriptlist() throws ParseException {
4009 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSUBSCRIPTLIST);
4010 boolean jjtc001 = true;
4011 jjtree.openNodeScope(jjtn001);
4012 jjtreeOpenNodeScope(jjtn001);
4013 try {
4014 subscript();
4015 label_31:
4016 while (true) {
4017 if (jj_2_16(2)) {
4018 ;
4019 } else {
4020 break label_31;
4021 }
4022 jj_consume_token(COMMA);
4023 subscript();
4024 }
4025 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4026 case COMMA:
4027 Comma();
4028 break;
4029 default:
4030 jj_la1[78] = jj_gen;
4031 ;
4032 }
4033 } catch (Throwable jjte001) {
4034 if (jjtc001) {
4035 jjtree.clearNodeScope(jjtn001);
4036 jjtc001 = false;
4037 } else {
4038 jjtree.popNode();
4039 }
4040 if (jjte001 instanceof RuntimeException ) {
4041 {if (true) throw (RuntimeException )jjte001;}
4042 }
4043 if (jjte001 instanceof ParseException) {
4044 {if (true) throw (ParseException)jjte001;}
4045 }
4046 {if (true) throw (Error )jjte001;}
4047 } finally {
4048 if (jjtc001) {
4049 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
4050 jjtreeCloseNodeScope(jjtn001);
4051 }
4052 }
4053 }
4054
4055 final public void subscript() throws ParseException {
4057 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4058 case DOT:
4059 jj_consume_token(DOT);
4060 jj_consume_token(DOT);
4061 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTELLIPSES);
4062 boolean jjtc001 = true;
4063 jjtree.openNodeScope(jjtn001);
4064 jjtreeOpenNodeScope(jjtn001);
4065 try {
4066 jj_consume_token(DOT);
4067 } finally {
4068 if (jjtc001) {
4069 jjtree.closeNodeScope(jjtn001, true);
4070 jjtreeCloseNodeScope(jjtn001);
4071 }
4072 }
4073 break;
4074 case LPAREN:
4075 case LBRACE:
4076 case LBRACKET:
4077 case PLUS:
4078 case MINUS:
4079 case NOT:
4080 case NOT_BOOL:
4081 case LAMBDA:
4082 case AS:
4083 case NAME:
4084 case DECNUMBER:
4085 case HEXNUMBER:
4086 case OCTNUMBER:
4087 case FLOAT:
4088 case COMPLEX:
4089 case SINGLE_STRING:
4090 case SINGLE_STRING2:
4091 case TRIPLE_STRING:
4092 case TRIPLE_STRING2:
4093 case 121:
4094 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSLICE);
4095 boolean jjtc002 = true;
4096 jjtree.openNodeScope(jjtn002);
4097 jjtreeOpenNodeScope(jjtn002);
4098 try {
4099 test();
4100 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4101 case COLON:
4102 slice();
4103 break;
4104 default:
4105 jj_la1[79] = jj_gen;
4106 ;
4107 }
4108 } catch (Throwable jjte002) {
4109 if (jjtc002) {
4110 jjtree.clearNodeScope(jjtn002);
4111 jjtc002 = false;
4112 } else {
4113 jjtree.popNode();
4114 }
4115 if (jjte002 instanceof RuntimeException ) {
4116 {if (true) throw (RuntimeException )jjte002;}
4117 }
4118 if (jjte002 instanceof ParseException) {
4119 {if (true) throw (ParseException)jjte002;}
4120 }
4121 {if (true) throw (Error )jjte002;}
4122 } finally {
4123 if (jjtc002) {
4124 jjtree.closeNodeScope(jjtn002, true);
4125 jjtreeCloseNodeScope(jjtn002);
4126 }
4127 }
4128 break;
4129 case COLON:
4130 SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSLICE);
4131 boolean jjtc003 = true;
4132 jjtree.openNodeScope(jjtn003);
4133 jjtreeOpenNodeScope(jjtn003);
4134 try {
4135 slice();
4136 } catch (Throwable jjte003) {
4137 if (jjtc003) {
4138 jjtree.clearNodeScope(jjtn003);
4139 jjtc003 = false;
4140 } else {
4141 jjtree.popNode();
4142 }
4143 if (jjte003 instanceof RuntimeException ) {
4144 {if (true) throw (RuntimeException )jjte003;}
4145 }
4146 if (jjte003 instanceof ParseException) {
4147 {if (true) throw (ParseException)jjte003;}
4148 }
4149 {if (true) throw (Error )jjte003;}
4150 } finally {
4151 if (jjtc003) {
4152 jjtree.closeNodeScope(jjtn003, jjtree.nodeArity() > 0);
4153 jjtreeCloseNodeScope(jjtn003);
4154 }
4155 }
4156 break;
4157 default:
4158 jj_la1[80] = jj_gen;
4159 jj_consume_token(-1);
4160 throw new ParseException();
4161 }
4162 }
4163
4164 final public void slice() throws ParseException {
4166 Colon();
4167 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4168 case LPAREN:
4169 case LBRACE:
4170 case LBRACKET:
4171 case PLUS:
4172 case MINUS:
4173 case NOT:
4174 case NOT_BOOL:
4175 case LAMBDA:
4176 case AS:
4177 case NAME:
4178 case DECNUMBER:
4179 case HEXNUMBER:
4180 case OCTNUMBER:
4181 case FLOAT:
4182 case COMPLEX:
4183 case SINGLE_STRING:
4184 case SINGLE_STRING2:
4185 case TRIPLE_STRING:
4186 case TRIPLE_STRING2:
4187 case 121:
4188 test();
4189 break;
4190 default:
4191 jj_la1[81] = jj_gen;
4192 ;
4193 }
4194 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4195 case COLON:
4196 Colon();
4197 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4198 case LPAREN:
4199 case LBRACE:
4200 case LBRACKET:
4201 case PLUS:
4202 case MINUS:
4203 case NOT:
4204 case NOT_BOOL:
4205 case LAMBDA:
4206 case AS:
4207 case NAME:
4208 case DECNUMBER:
4209 case HEXNUMBER:
4210 case OCTNUMBER:
4211 case FLOAT:
4212 case COMPLEX:
4213 case SINGLE_STRING:
4214 case SINGLE_STRING2:
4215 case TRIPLE_STRING:
4216 case TRIPLE_STRING2:
4217 case 121:
4218 test();
4219 break;
4220 default:
4221 jj_la1[82] = jj_gen;
4222 ;
4223 }
4224 break;
4225 default:
4226 jj_la1[83] = jj_gen;
4227 ;
4228 }
4229 }
4230
4231 final public void Colon() throws ParseException {
4232
4233 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCOLON);
4234 boolean jjtc000 = true;
4235 jjtree.openNodeScope(jjtn000);
4236 jjtreeOpenNodeScope(jjtn000);
4237 try {
4238 jj_consume_token(COLON);
4239 } finally {
4240 if (jjtc000) {
4241 jjtree.closeNodeScope(jjtn000, true);
4242 jjtreeCloseNodeScope(jjtn000);
4243 }
4244 }
4245 }
4246
4247 final public void Comma() throws ParseException {
4248
4249 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCOMMA);
4250 boolean jjtc000 = true;
4251 jjtree.openNodeScope(jjtn000);
4252 jjtreeOpenNodeScope(jjtn000);
4253 try {
4254 jj_consume_token(COMMA);
4255 } finally {
4256 if (jjtc000) {
4257 jjtree.closeNodeScope(jjtn000, true);
4258 jjtreeCloseNodeScope(jjtn000);
4259 }
4260 }
4261 }
4262
4263 final public void exprlist() throws ParseException {
4265 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTUPLE);
4266 boolean jjtc001 = true;
4267 jjtree.openNodeScope(jjtn001);
4268 jjtreeOpenNodeScope(jjtn001);
4269 try {
4270 expr();
4271 label_32:
4272 while (true) {
4273 if (jj_2_17(2)) {
4274 ;
4275 } else {
4276 break label_32;
4277 }
4278 jj_consume_token(COMMA);
4279 expr();
4280 }
4281 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4282 case COMMA:
4283 Comma();
4284 break;
4285 default:
4286 jj_la1[84] = jj_gen;
4287 ;
4288 }
4289 } catch (Throwable jjte001) {
4290 if (jjtc001) {
4291 jjtree.clearNodeScope(jjtn001);
4292 jjtc001 = false;
4293 } else {
4294 jjtree.popNode();
4295 }
4296 if (jjte001 instanceof RuntimeException ) {
4297 {if (true) throw (RuntimeException )jjte001;}
4298 }
4299 if (jjte001 instanceof ParseException) {
4300 {if (true) throw (ParseException)jjte001;}
4301 }
4302 {if (true) throw (Error )jjte001;}
4303 } finally {
4304 if (jjtc001) {
4305 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
4306 jjtreeCloseNodeScope(jjtn001);
4307 }
4308 }
4309 }
4310
4311 final public void SmartTestList() throws ParseException {
4313 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTUPLE);
4314 boolean jjtc001 = true;
4315 jjtree.openNodeScope(jjtn001);
4316 jjtreeOpenNodeScope(jjtn001);
4317 try {
4318 test();
4319 label_33:
4320 while (true) {
4321 if (jj_2_18(2)) {
4322 ;
4323 } else {
4324 break label_33;
4325 }
4326 jj_consume_token(COMMA);
4327 test();
4328 }
4329 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4330 case COMMA:
4331 Comma();
4332 break;
4333 default:
4334 jj_la1[85] = jj_gen;
4335 ;
4336 }
4337 } catch (Throwable jjte001) {
4338 if (jjtc001) {
4339 jjtree.clearNodeScope(jjtn001);
4340 jjtc001 = false;
4341 } else {
4342 jjtree.popNode();
4343 }
4344 if (jjte001 instanceof RuntimeException ) {
4345 {if (true) throw (RuntimeException )jjte001;}
4346 }
4347 if (jjte001 instanceof ParseException) {
4348 {if (true) throw (ParseException)jjte001;}
4349 }
4350 {if (true) throw (Error )jjte001;}
4351 } finally {
4352 if (jjtc001) {
4353 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
4354 jjtreeCloseNodeScope(jjtn001);
4355 }
4356 }
4357 }
4358
4359 final public void testlist() throws ParseException {
4361 test();
4362 label_34:
4363 while (true) {
4364 if (jj_2_19(2)) {
4365 ;
4366 } else {
4367 break label_34;
4368 }
4369 jj_consume_token(COMMA);
4370 test();
4371 }
4372 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4373 case COMMA:
4374 jj_consume_token(COMMA);
4375 break;
4376 default:
4377 jj_la1[86] = jj_gen;
4378 ;
4379 }
4380 }
4381
4382 final public void dictmaker() throws ParseException {
4384 test();
4385 jj_consume_token(COLON);
4386 test();
4387 label_35:
4388 while (true) {
4389 if (jj_2_20(2)) {
4390 ;
4391 } else {
4392 break label_35;
4393 }
4394 jj_consume_token(COMMA);
4395 test();
4396 jj_consume_token(COLON);
4397 test();
4398 }
4399 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4400 case COMMA:
4401 jj_consume_token(COMMA);
4402 break;
4403 default:
4404 jj_la1[87] = jj_gen;
4405 ;
4406 }
4407 }
4408
4409 final public void listmaker() throws ParseException {
4411 test();
4412 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4413 case FOR:
4414 label_36:
4415 while (true) {
4416 list_for();
4417 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4418 case FOR:
4419 ;
4420 break;
4421 default:
4422 jj_la1[88] = jj_gen;
4423 break label_36;
4424 }
4425 }
4426 break;
4427 default:
4428 jj_la1[90] = jj_gen;
4429 label_37:
4430 while (true) {
4431 if (jj_2_21(2)) {
4432 ;
4433 } else {
4434 break label_37;
4435 }
4436 jj_consume_token(COMMA);
4437 test();
4438 }
4439 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTUPLE);
4440 boolean jjtc001 = true;
4441 jjtree.openNodeScope(jjtn001);
4442 jjtreeOpenNodeScope(jjtn001);
4443 try {
4444 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4445 case COMMA:
4446 Comma();
4447 break;
4448 default:
4449 jj_la1[89] = jj_gen;
4450 ;
4451 }
4452 } catch (Throwable jjte001) {
4453 if (jjtc001) {
4454 jjtree.clearNodeScope(jjtn001);
4455 jjtc001 = false;
4456 } else {
4457 jjtree.popNode();
4458 }
4459 if (jjte001 instanceof RuntimeException ) {
4460 {if (true) throw (RuntimeException )jjte001;}
4461 }
4462 if (jjte001 instanceof ParseException) {
4463 {if (true) throw (ParseException)jjte001;}
4464 }
4465 {if (true) throw (Error )jjte001;}
4466 } finally {
4467 if (jjtc001) {
4468 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
4469 jjtreeCloseNodeScope(jjtn001);
4470 }
4471 }
4472 }
4473 }
4474
4475
4479 final public void list_for() throws ParseException {
4481
4482 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTLIST_FOR);
4483 boolean jjtc000 = true;
4484 jjtree.openNodeScope(jjtn000);
4485 jjtreeOpenNodeScope(jjtn000);
4486 try {
4487 jj_consume_token(FOR);
4488 exprlist();
4489 jj_consume_token(IN);
4490 SmartTestList();
4491 label_38:
4492 while (true) {
4493 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4494 case IF:
4495 ;
4496 break;
4497 default:
4498 jj_la1[91] = jj_gen;
4499 break label_38;
4500 }
4501 list_if();
4502 }
4503 } catch (Throwable jjte000) {
4504 if (jjtc000) {
4505 jjtree.clearNodeScope(jjtn000);
4506 jjtc000 = false;
4507 } else {
4508 jjtree.popNode();
4509 }
4510 if (jjte000 instanceof RuntimeException ) {
4511 {if (true) throw (RuntimeException )jjte000;}
4512 }
4513 if (jjte000 instanceof ParseException) {
4514 {if (true) throw (ParseException)jjte000;}
4515 }
4516 {if (true) throw (Error )jjte000;}
4517 } finally {
4518 if (jjtc000) {
4519 jjtree.closeNodeScope(jjtn000, true);
4520 jjtreeCloseNodeScope(jjtn000);
4521 }
4522 }
4523 }
4524
4525 final public void list_if() throws ParseException {
4527 jj_consume_token(IF);
4528 test();
4529 }
4530
4531 final public void classdef() throws ParseException {
4533
4534 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCLASSDEF);
4535 boolean jjtc000 = true;
4536 jjtree.openNodeScope(jjtn000);
4537 jjtreeOpenNodeScope(jjtn000);
4538 try {
4539 jj_consume_token(CLASS);
4540 Name();
4541 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4542 case LPAREN:
4543 jj_consume_token(LPAREN);
4544 testlist();
4545 jj_consume_token(RPAREN);
4546 break;
4547 default:
4548 jj_la1[92] = jj_gen;
4549 ;
4550 }
4551 jj_consume_token(COLON);
4552 suite();
4553 } catch (Throwable jjte000) {
4554 if (jjtc000) {
4555 jjtree.clearNodeScope(jjtn000);
4556 jjtc000 = false;
4557 } else {
4558 jjtree.popNode();
4559 }
4560 if (jjte000 instanceof RuntimeException ) {
4561 {if (true) throw (RuntimeException )jjte000;}
4562 }
4563 if (jjte000 instanceof ParseException) {
4564 {if (true) throw (ParseException)jjte000;}
4565 }
4566 {if (true) throw (Error )jjte000;}
4567 } finally {
4568 if (jjtc000) {
4569 jjtree.closeNodeScope(jjtn000, true);
4570 jjtreeCloseNodeScope(jjtn000);
4571 }
4572 }
4573 }
4574
4575 final public void arglist() throws ParseException {
4578 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4579 case LPAREN:
4580 case LBRACE:
4581 case LBRACKET:
4582 case PLUS:
4583 case MINUS:
4584 case NOT:
4585 case OR_BOOL:
4586 case AND_BOOL:
4587 case NOT_BOOL:
4588 case IS:
4589 case IN:
4590 case LAMBDA:
4591 case IF:
4592 case ELSE:
4593 case ELIF:
4594 case WHILE:
4595 case FOR:
4596 case TRY:
4597 case EXCEPT:
4598 case DEF:
4599 case CLASS:
4600 case FINALLY:
4601 case PRINT:
4602 case PASS:
4603 case BREAK:
4604 case CONTINUE:
4605 case RETURN:
4606 case YIELD:
4607 case IMPORT:
4608 case FROM:
4609 case DEL:
4610 case RAISE:
4611 case GLOBAL:
4612 case EXEC:
4613 case ASSERT:
4614 case AS:
4615 case NAME:
4616 case DECNUMBER:
4617 case HEXNUMBER:
4618 case OCTNUMBER:
4619 case FLOAT:
4620 case COMPLEX:
4621 case SINGLE_STRING:
4622 case SINGLE_STRING2:
4623 case TRIPLE_STRING:
4624 case TRIPLE_STRING2:
4625 case 121:
4626 normalargs();
4627 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4628 case COMMA:
4629 jj_consume_token(COMMA);
4630 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4631 case MULTIPLY:
4632 case POWER:
4633 if (jj_2_22(2)) {
4634 ExtraArgValueList();
4635 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4636 case COMMA:
4637 jj_consume_token(COMMA);
4638 ExtraKeywordValueList();
4639 break;
4640 default:
4641 jj_la1[93] = jj_gen;
4642 ;
4643 }
4644 } else {
4645 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4646 case MULTIPLY:
4647 case POWER:
4648 ExtraKeywordValueList();
4649 break;
4650 default:
4651 jj_la1[94] = jj_gen;
4652 jj_consume_token(-1);
4653 throw new ParseException();
4654 }
4655 }
4656 break;
4657 default:
4658 jj_la1[95] = jj_gen;
4659 ;
4660 }
4661 break;
4662 default:
4663 jj_la1[96] = jj_gen;
4664 ;
4665 }
4666 break;
4667 default:
4668 jj_la1[100] = jj_gen;
4669 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4670 case MULTIPLY:
4671 case POWER:
4672 if (jj_2_23(2)) {
4673 ExtraArgValueList();
4674 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4675 case COMMA:
4676 jj_consume_token(COMMA);
4677 ExtraKeywordValueList();
4678 break;
4679 default:
4680 jj_la1[97] = jj_gen;
4681 ;
4682 }
4683 } else {
4684 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4685 case MULTIPLY:
4686 case POWER:
4687 ExtraKeywordValueList();
4688 break;
4689 default:
4690 jj_la1[98] = jj_gen;
4691 jj_consume_token(-1);
4692 throw new ParseException();
4693 }
4694 }
4695 break;
4696 default:
4697 jj_la1[99] = jj_gen;
4698 ;
4699 }
4700 }
4701 }
4702
4703 final public void normalargs() throws ParseException {
4704 argument();
4705 label_39:
4706 while (true) {
4707 if (jj_2_24(2)) {
4708 ;
4709 } else {
4710 break label_39;
4711 }
4712 jj_consume_token(COMMA);
4713 argument();
4714 }
4715 }
4716
4717 final public void ExtraArgValueList() throws ParseException {
4718
4719 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXTRAARGVALUELIST);
4720 boolean jjtc000 = true;
4721 jjtree.openNodeScope(jjtn000);
4722 jjtreeOpenNodeScope(jjtn000);
4723 try {
4724 jj_consume_token(MULTIPLY);
4725 test();
4726 } catch (Throwable jjte000) {
4727 if (jjtc000) {
4728 jjtree.clearNodeScope(jjtn000);
4729 jjtc000 = false;
4730 } else {
4731 jjtree.popNode();
4732 }
4733 if (jjte000 instanceof RuntimeException ) {
4734 {if (true) throw (RuntimeException )jjte000;}
4735 }
4736 if (jjte000 instanceof ParseException) {
4737 {if (true) throw (ParseException)jjte000;}
4738 }
4739 {if (true) throw (Error )jjte000;}
4740 } finally {
4741 if (jjtc000) {
4742 jjtree.closeNodeScope(jjtn000, true);
4743 jjtreeCloseNodeScope(jjtn000);
4744 }
4745 }
4746 }
4747
4748 final public void ExtraKeywordValueList() throws ParseException {
4749
4750 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXTRAKEYWORDVALUELIST);
4751 boolean jjtc000 = true;
4752 jjtree.openNodeScope(jjtn000);
4753 jjtreeOpenNodeScope(jjtn000);
4754 try {
4755 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4756 case POWER:
4757 jj_consume_token(POWER);
4758 break;
4759 case MULTIPLY:
4760 jj_consume_token(MULTIPLY);
4761 jj_consume_token(MULTIPLY);
4762 break;
4763 default:
4764 jj_la1[101] = jj_gen;
4765 jj_consume_token(-1);
4766 throw new ParseException();
4767 }
4768 test();
4769 } catch (Throwable jjte000) {
4770 if (jjtc000) {
4771 jjtree.clearNodeScope(jjtn000);
4772 jjtc000 = false;
4773 } else {
4774 jjtree.popNode();
4775 }
4776 if (jjte000 instanceof RuntimeException ) {
4777 {if (true) throw (RuntimeException )jjte000;}
4778 }
4779 if (jjte000 instanceof ParseException) {
4780 {if (true) throw (ParseException)jjte000;}
4781 }
4782 {if (true) throw (Error )jjte000;}
4783 } finally {
4784 if (jjtc000) {
4785 jjtree.closeNodeScope(jjtn000, true);
4786 jjtreeCloseNodeScope(jjtn000);
4787 }
4788 }
4789 }
4790
4791 final public void argument() throws ParseException {
4793 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTKEYWORD);
4794 boolean jjtc001 = true;
4795 jjtree.openNodeScope(jjtn001);
4796 jjtreeOpenNodeScope(jjtn001);
4797 try {
4798 if (jj_2_25(2)) {
4799 AnyName();
4800 jj_consume_token(EQUAL);
4801 } else {
4802 ;
4803 }
4804 test();
4805 } catch (Throwable jjte001) {
4806 if (jjtc001) {
4807 jjtree.clearNodeScope(jjtn001);
4808 jjtc001 = false;
4809 } else {
4810 jjtree.popNode();
4811 }
4812 if (jjte001 instanceof RuntimeException ) {
4813 {if (true) throw (RuntimeException )jjte001;}
4814 }
4815 if (jjte001 instanceof ParseException) {
4816 {if (true) throw (ParseException)jjte001;}
4817 }
4818 {if (true) throw (Error )jjte001;}
4819 } finally {
4820 if (jjtc001) {
4821 jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
4822 jjtreeCloseNodeScope(jjtn001);
4823 }
4824 }
4825 }
4826
4827 final public void Number() throws ParseException {
4828
4829 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNUM);
4830 boolean jjtc000 = true;
4831 jjtree.openNodeScope(jjtn000);
4832 jjtreeOpenNodeScope(jjtn000);Token t;
4833 try {
4834 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4835 case HEXNUMBER:
4836 t = jj_consume_token(HEXNUMBER);
4837 String s = t.image.substring(2, t.image.length());
4838 jjtn000.setImage(makeInt(s, 16));
4839 jjtree.closeNodeScope(jjtn000, true);
4840 jjtc000 = false;
4841 jjtreeCloseNodeScope(jjtn000);
4842
4843 break;
4844 case OCTNUMBER:
4845 t = jj_consume_token(OCTNUMBER);
4846 jjtn000.setImage(makeInt(t.image, 8));
4847 jjtree.closeNodeScope(jjtn000, true);
4848 jjtc000 = false;
4849 jjtreeCloseNodeScope(jjtn000);
4850
4851 break;
4852 case DECNUMBER:
4853 t = jj_consume_token(DECNUMBER);
4854 jjtn000.setImage(makeInt(t.image, 10));
4855 jjtree.closeNodeScope(jjtn000, true);
4856 jjtc000 = false;
4857 jjtreeCloseNodeScope(jjtn000);
4858
4859 break;
4860 case FLOAT:
4861 t = jj_consume_token(FLOAT);
4862 jjtn000.setImage(makeFloat(t.image));
4863 jjtree.closeNodeScope(jjtn000, true);
4864 jjtc000 = false;
4865 jjtreeCloseNodeScope(jjtn000);
4866
4867 break;
4868 case COMPLEX:
4869 t = jj_consume_token(COMPLEX);
4870 jjtn000.setImage(makeComplex(t.image));
4871 jjtree.closeNodeScope(jjtn000, true);
4872 jjtc000 = false;
4873 jjtreeCloseNodeScope(jjtn000);
4874
4875 break;
4876 default:
4877 jj_la1[102] = jj_gen;
4878 jj_consume_token(-1);
4879 throw new ParseException();
4880 }
4881 } finally {
4882 if (jjtc000) {
4883 jjtree.closeNodeScope(jjtn000, true);
4884 jjtreeCloseNodeScope(jjtn000);
4885 }
4886 }
4887 }
4888
4889 final public void Complex() throws ParseException {
4890
4891 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCOMPLEX);
4892 boolean jjtc000 = true;
4893 jjtree.openNodeScope(jjtn000);
4894 jjtreeOpenNodeScope(jjtn000);
4895 try {
4896 jj_consume_token(FLOAT);
4897 } finally {
4898 if (jjtc000) {
4899 jjtree.closeNodeScope(jjtn000, true);
4900 jjtreeCloseNodeScope(jjtn000);
4901 }
4902 }
4903 }
4904
4905 final public void Name() throws ParseException {
4906
4907 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
4908 boolean jjtc000 = true;
4909 jjtree.openNodeScope(jjtn000);
4910 jjtreeOpenNodeScope(jjtn000);Token t;
4911 try {
4912 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4913 case NAME:
4914 t = jj_consume_token(NAME);
4915 jjtn000.setImage(t.image);
4916 jjtree.closeNodeScope(jjtn000, true);
4917 jjtc000 = false;
4918 jjtreeCloseNodeScope(jjtn000);
4919
4920 break;
4921 case AS:
4922 t = jj_consume_token(AS);
4923 jjtn000.setImage(t.image);
4924 jjtree.closeNodeScope(jjtn000, true);
4925 jjtc000 = false;
4926 jjtreeCloseNodeScope(jjtn000);
4927
4928 break;
4929 default:
4930 jj_la1[103] = jj_gen;
4931 jj_consume_token(-1);
4932 throw new ParseException();
4933 }
4934 } finally {
4935 if (jjtc000) {
4936 jjtree.closeNodeScope(jjtn000, true);
4937 jjtreeCloseNodeScope(jjtn000);
4938 }
4939 }
4940 }
4941
4942 final public void String() throws ParseException {
4943 Token t;
4944 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4945 case SINGLE_STRING:
4946 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSTRING);
4947 boolean jjtc001 = true;
4948 jjtree.openNodeScope(jjtn001);
4949 jjtreeOpenNodeScope(jjtn001);
4950 try {
4951 t = jj_consume_token(SINGLE_STRING);
4952 jjtn001.setImage(makeString(t.image, 1));
4953 jjtree.closeNodeScope(jjtn001, true);
4954 jjtc001 = false;
4955 jjtreeCloseNodeScope(jjtn001);
4956
4957 } finally {
4958 if (jjtc001) {
4959 jjtree.closeNodeScope(jjtn001, true);
4960 jjtreeCloseNodeScope(jjtn001);
4961 }
4962 }
4963 break;
4964 case SINGLE_STRING2:
4965 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSTRING);
4966 boolean jjtc002 = true;
4967 jjtree.openNodeScope(jjtn002);
4968 jjtreeOpenNodeScope(jjtn002);
4969 try {
4970 t = jj_consume_token(SINGLE_STRING2);
4971 jjtn002.setImage(makeString(t.image, 1));
4972 jjtree.closeNodeScope(jjtn002, true);
4973 jjtc002 = false;
4974 jjtreeCloseNodeScope(jjtn002);
4975
4976 } finally {
4977 if (jjtc002) {
4978 jjtree.closeNodeScope(jjtn002, true);
4979 jjtreeCloseNodeScope(jjtn002);
4980 }
4981 }
4982 break;
4983 case TRIPLE_STRING:
4984 SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSTRING);
4985 boolean jjtc003 = true;
4986 jjtree.openNodeScope(jjtn003);
4987 jjtreeOpenNodeScope(jjtn003);
4988 try {
4989 t = jj_consume_token(TRIPLE_STRING);
4990 jjtn003.setImage(makeString(t.image, 3));
4991 jjtree.closeNodeScope(jjtn003, true);
4992 jjtc003 = false;
4993 jjtreeCloseNodeScope(jjtn003);
4994
4995 } finally {
4996 if (jjtc003) {
4997 jjtree.closeNodeScope(jjtn003, true);
4998 jjtreeCloseNodeScope(jjtn003);
4999 }
5000 }
5001 break;
5002 case TRIPLE_STRING2:
5003 SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSTRING);
5004 boolean jjtc004 = true;
5005 jjtree.openNodeScope(jjtn004);
5006 jjtreeOpenNodeScope(jjtn004);
5007 try {
5008 t = jj_consume_token(TRIPLE_STRING2);
5009 jjtn004.setImage(makeString(t.image, 3));
5010 jjtree.closeNodeScope(jjtn004, true);
5011 jjtc004 = false;
5012 jjtreeCloseNodeScope(jjtn004);
5013
5014 } finally {
5015 if (jjtc004) {
5016 jjtree.closeNodeScope(jjtn004, true);
5017 jjtreeCloseNodeScope(jjtn004);
5018 }
5019 }
5020 break;
5021 default:
5022 jj_la1[104] = jj_gen;
5023 jj_consume_token(-1);
5024 throw new ParseException();
5025 }
5026 }
5027
5028 final public Token AnyName() throws ParseException {
5029 Token t;
5030 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5031 case NAME:
5032 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5033 boolean jjtc001 = true;
5034 jjtree.openNodeScope(jjtn001);
5035 jjtreeOpenNodeScope(jjtn001);
5036 try {
5037 t = jj_consume_token(NAME);
5038 jjtn001.setImage(t.image); {if (true) return t;}
5039 jjtree.closeNodeScope(jjtn001, true);
5040 jjtc001 = false;
5041 jjtreeCloseNodeScope(jjtn001);
5042
5043 } finally {
5044 if (jjtc001) {
5045 jjtree.closeNodeScope(jjtn001, true);
5046 jjtreeCloseNodeScope(jjtn001);
5047 }
5048 }
5049 break;
5050 case OR_BOOL:
5051 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5052 boolean jjtc002 = true;
5053 jjtree.openNodeScope(jjtn002);
5054 jjtreeOpenNodeScope(jjtn002);
5055 try {
5056 t = jj_consume_token(OR_BOOL);
5057 jjtn002.setImage(t.image); {if (true) return t;}
5058 jjtree.closeNodeScope(jjtn002, true);
5059 jjtc002 = false;
5060 jjtreeCloseNodeScope(jjtn002);
5061
5062 } finally {
5063 if (jjtc002) {
5064 jjtree.closeNodeScope(jjtn002, true);
5065 jjtreeCloseNodeScope(jjtn002);
5066 }
5067 }
5068 break;
5069 case AND_BOOL:
5070 SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5071 boolean jjtc003 = true;
5072 jjtree.openNodeScope(jjtn003);
5073 jjtreeOpenNodeScope(jjtn003);
5074 try {
5075 t = jj_consume_token(AND_BOOL);
5076 jjtn003.setImage(t.image); {if (true) return t;}
5077 jjtree.closeNodeScope(jjtn003, true);
5078 jjtc003 = false;
5079 jjtreeCloseNodeScope(jjtn003);
5080
5081 } finally {
5082 if (jjtc003) {
5083 jjtree.closeNodeScope(jjtn003, true);
5084 jjtreeCloseNodeScope(jjtn003);
5085 }
5086 }
5087 break;
5088 case NOT_BOOL:
5089 SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5090 boolean jjtc004 = true;
5091 jjtree.openNodeScope(jjtn004);
5092 jjtreeOpenNodeScope(jjtn004);
5093 try {
5094 t = jj_consume_token(NOT_BOOL);
5095 jjtn004.setImage(t.image); {if (true) return t;}
5096 jjtree.closeNodeScope(jjtn004, true);
5097 jjtc004 = false;
5098 jjtreeCloseNodeScope(jjtn004);
5099
5100 } finally {
5101 if (jjtc004) {
5102 jjtree.closeNodeScope(jjtn004, true);
5103 jjtreeCloseNodeScope(jjtn004);
5104 }
5105 }
5106 break;
5107 case IS:
5108 SimpleNode jjtn005 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5109 boolean jjtc005 = true;
5110 jjtree.openNodeScope(jjtn005);
5111 jjtreeOpenNodeScope(jjtn005);
5112 try {
5113 t = jj_consume_token(IS);
5114 jjtn005.setImage(t.image); {if (true) return t;}
5115 jjtree.closeNodeScope(jjtn005, true);
5116 jjtc005 = false;
5117 jjtreeCloseNodeScope(jjtn005);
5118
5119 } finally {
5120 if (jjtc005) {
5121 jjtree.closeNodeScope(jjtn005, true);
5122 jjtreeCloseNodeScope(jjtn005);
5123 }
5124 }
5125 break;
5126 case IN:
5127 SimpleNode jjtn006 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5128 boolean jjtc006 = true;
5129 jjtree.openNodeScope(jjtn006);
5130 jjtreeOpenNodeScope(jjtn006);
5131 try {
5132 t = jj_consume_token(IN);
5133 jjtn006.setImage(t.image); {if (true) return t;}
5134 jjtree.closeNodeScope(jjtn006, true);
5135 jjtc006 = false;
5136 jjtreeCloseNodeScope(jjtn006);
5137
5138 } finally {
5139 if (jjtc006) {
5140 jjtree.closeNodeScope(jjtn006, true);
5141 jjtreeCloseNodeScope(jjtn006);
5142 }
5143 }
5144 break;
5145 case LAMBDA:
5146 SimpleNode jjtn007 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5147 boolean jjtc007 = true;
5148 jjtree.openNodeScope(jjtn007);
5149 jjtreeOpenNodeScope(jjtn007);
5150 try {
5151 t = jj_consume_token(LAMBDA);
5152 jjtn007.setImage(t.image); {if (true) return t;}
5153 jjtree.closeNodeScope(jjtn007, true);
5154 jjtc007 = false;
5155 jjtreeCloseNodeScope(jjtn007);
5156
5157 } finally {
5158 if (jjtc007) {
5159 jjtree.closeNodeScope(jjtn007, true);
5160 jjtreeCloseNodeScope(jjtn007);
5161 }
5162 }
5163 break;
5164 case IF:
5165 SimpleNode jjtn008 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5166 boolean jjtc008 = true;
5167 jjtree.openNodeScope(jjtn008);
5168 jjtreeOpenNodeScope(jjtn008);
5169 try {
5170 t = jj_consume_token(IF);
5171 jjtn008.setImage(t.image); {if (true) return t;}
5172 jjtree.closeNodeScope(jjtn008, true);
5173 jjtc008 = false;
5174 jjtreeCloseNodeScope(jjtn008);
5175
5176 } finally {
5177 if (jjtc008) {
5178 jjtree.closeNodeScope(jjtn008, true);
5179 jjtreeCloseNodeScope(jjtn008);
5180 }
5181 }
5182 break;
5183 case ELSE:
5184 SimpleNode jjtn009 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5185 boolean jjtc009 = true;
5186 jjtree.openNodeScope(jjtn009);
5187 jjtreeOpenNodeScope(jjtn009);
5188 try {
5189 t = jj_consume_token(ELSE);
5190 jjtn009.setImage(t.image); {if (true) return t;}
5191 jjtree.closeNodeScope(jjtn009, true);
5192 jjtc009 = false;
5193 jjtreeCloseNodeScope(jjtn009);
5194
5195 } finally {
5196 if (jjtc009) {
5197 jjtree.closeNodeScope(jjtn009, true);
5198 jjtreeCloseNodeScope(jjtn009);
5199 }
5200 }
5201 break;
5202 case ELIF:
5203 SimpleNode jjtn010 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5204 boolean jjtc010 = true;
5205 jjtree.openNodeScope(jjtn010);
5206 jjtreeOpenNodeScope(jjtn010);
5207 try {
5208 t = jj_consume_token(ELIF);
5209 jjtn010.setImage(t.image); {if (true) return t;}
5210 jjtree.closeNodeScope(jjtn010, true);
5211 jjtc010 = false;
5212 jjtreeCloseNodeScope(jjtn010);
5213
5214 } finally {
5215 if (jjtc010) {
5216 jjtree.closeNodeScope(jjtn010, true);
5217 jjtreeCloseNodeScope(jjtn010);
5218 }
5219 }
5220 break;
5221 case WHILE:
5222 SimpleNode jjtn011 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5223 boolean jjtc011 = true;
5224 jjtree.openNodeScope(jjtn011);
5225 jjtreeOpenNodeScope(jjtn011);
5226 try {
5227 t = jj_consume_token(WHILE);
5228 jjtn011.setImage(t.image); {if (true) return t;}
5229 jjtree.closeNodeScope(jjtn011, true);
5230 jjtc011 = false;
5231 jjtreeCloseNodeScope(jjtn011);
5232
5233 } finally {
5234 if (jjtc011) {
5235 jjtree.closeNodeScope(jjtn011, true);
5236 jjtreeCloseNodeScope(jjtn011);
5237 }
5238 }
5239 break;
5240 case FOR:
5241 SimpleNode jjtn012 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5242 boolean jjtc012 = true;
5243 jjtree.openNodeScope(jjtn012);
5244 jjtreeOpenNodeScope(jjtn012);
5245 try {
5246 t = jj_consume_token(FOR);
5247 jjtn012.setImage(t.image); {if (true) return t;}
5248 jjtree.closeNodeScope(jjtn012, true);
5249 jjtc012 = false;
5250 jjtreeCloseNodeScope(jjtn012);
5251
5252 } finally {
5253 if (jjtc012) {
5254 jjtree.closeNodeScope(jjtn012, true);
5255 jjtreeCloseNodeScope(jjtn012);
5256 }
5257 }
5258 break;
5259 case TRY:
5260 SimpleNode jjtn013 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5261 boolean jjtc013 = true;
5262 jjtree.openNodeScope(jjtn013);
5263 jjtreeOpenNodeScope(jjtn013);
5264 try {
5265 t = jj_consume_token(TRY);
5266 jjtn013.setImage(t.image); {if (true) return t;}
5267 jjtree.closeNodeScope(jjtn013, true);
5268 jjtc013 = false;
5269 jjtreeCloseNodeScope(jjtn013);
5270
5271 } finally {
5272 if (jjtc013) {
5273 jjtree.closeNodeScope(jjtn013, true);
5274 jjtreeCloseNodeScope(jjtn013);
5275 }
5276 }
5277 break;
5278 case EXCEPT:
5279 SimpleNode jjtn014 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5280 boolean jjtc014 = true;
5281 jjtree.openNodeScope(jjtn014);
5282 jjtreeOpenNodeScope(jjtn014);
5283 try {
5284 t = jj_consume_token(EXCEPT);
5285 jjtn014.setImage(t.image); {if (true) return t;}
5286 jjtree.closeNodeScope(jjtn014, true);
5287 jjtc014 = false;
5288 jjtreeCloseNodeScope(jjtn014);
5289
5290 } finally {
5291 if (jjtc014) {
5292 jjtree.closeNodeScope(jjtn014, true);
5293 jjtreeCloseNodeScope(jjtn014);
5294 }
5295 }
5296 break;
5297 case DEF:
5298 SimpleNode jjtn015 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5299 boolean jjtc015 = true;
5300 jjtree.openNodeScope(jjtn015);
5301 jjtreeOpenNodeScope(jjtn015);
5302 try {
5303 t = jj_consume_token(DEF);
5304 jjtn015.setImage(t.image); {if (true) return t;}
5305 jjtree.closeNodeScope(jjtn015, true);
5306 jjtc015 = false;
5307 jjtreeCloseNodeScope(jjtn015);
5308
5309 } finally {
5310 if (jjtc015) {
5311 jjtree.closeNodeScope(jjtn015, true);
5312 jjtreeCloseNodeScope(jjtn015);
5313 }
5314 }
5315 break;
5316 case CLASS:
5317 SimpleNode jjtn016 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5318 boolean jjtc016 = true;
5319 jjtree.openNodeScope(jjtn016);
5320 jjtreeOpenNodeScope(jjtn016);
5321 try {
5322 t = jj_consume_token(CLASS);
5323 jjtn016.setImage(t.image); {if (true) return t;}
5324 jjtree.closeNodeScope(jjtn016, true);
5325 jjtc016 = false;
5326 jjtreeCloseNodeScope(jjtn016);
5327
5328 } finally {
5329 if (jjtc016) {
5330 jjtree.closeNodeScope(jjtn016, true);
5331 jjtreeCloseNodeScope(jjtn016);
5332 }
5333 }
5334 break;
5335 case FINALLY:
5336 SimpleNode jjtn017 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5337 boolean jjtc017 = true;
5338 jjtree.openNodeScope(jjtn017);
5339 jjtreeOpenNodeScope(jjtn017);
5340 try {
5341 t = jj_consume_token(FINALLY);
5342 jjtn017.setImage(t.image); {if (true) return t;}
5343 jjtree.closeNodeScope(jjtn017, true);
5344 jjtc017 = false;
5345 jjtreeCloseNodeScope(jjtn017);
5346
5347 } finally {
5348 if (jjtc017) {
5349 jjtree.closeNodeScope(jjtn017, true);
5350 jjtreeCloseNodeScope(jjtn017);
5351 }
5352 }
5353 break;
5354 case PRINT:
5355 SimpleNode jjtn018 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5356 boolean jjtc018 = true;
5357 jjtree.openNodeScope(jjtn018);
5358 jjtreeOpenNodeScope(jjtn018);
5359 try {
5360 t = jj_consume_token(PRINT);
5361 jjtn018.setImage(t.image); {if (true) return t;}
5362 jjtree.closeNodeScope(jjtn018, true);
5363 jjtc018 = false;
5364 jjtreeCloseNodeScope(jjtn018);
5365
5366 } finally {
5367 if (jjtc018) {
5368 jjtree.closeNodeScope(jjtn018, true);
5369 jjtreeCloseNodeScope(jjtn018);
5370 }
5371 }
5372 break;
5373 case PASS:
5374 SimpleNode jjtn019 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5375 boolean jjtc019 = true;
5376 jjtree.openNodeScope(jjtn019);
5377 jjtreeOpenNodeScope(jjtn019);
5378 try {
5379 t = jj_consume_token(PASS);
5380 jjtn019.setImage(t.image); {if (true) return t;}
5381 jjtree.closeNodeScope(jjtn019, true);
5382 jjtc019 = false;
5383 jjtreeCloseNodeScope(jjtn019);
5384
5385 } finally {
5386 if (jjtc019) {
5387 jjtree.closeNodeScope(jjtn019, true);
5388 jjtreeCloseNodeScope(jjtn019);
5389 }
5390 }
5391 break;
5392 case BREAK:
5393 SimpleNode jjtn020 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5394 boolean jjtc020 = true;
5395 jjtree.openNodeScope(jjtn020);
5396 jjtreeOpenNodeScope(jjtn020);
5397 try {
5398 t = jj_consume_token(BREAK);
5399 jjtn020.setImage(t.image); {if (true) return t;}
5400 jjtree.closeNodeScope(jjtn020, true);
5401 jjtc020 = false;
5402 jjtreeCloseNodeScope(jjtn020);
5403
5404 } finally {
5405 if (jjtc020) {
5406 jjtree.closeNodeScope(jjtn020, true);
5407 jjtreeCloseNodeScope(jjtn020);
5408 }
5409 }
5410 break;
5411 case CONTINUE:
5412 SimpleNode jjtn021 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5413 boolean jjtc021 = true;
5414 jjtree.openNodeScope(jjtn021);
5415 jjtreeOpenNodeScope(jjtn021);
5416 try {
5417 t = jj_consume_token(CONTINUE);
5418 jjtn021.setImage(t.image); {if (true) return t;}
5419 jjtree.closeNodeScope(jjtn021, true);
5420 jjtc021 = false;
5421 jjtreeCloseNodeScope(jjtn021);
5422
5423 } finally {
5424 if (jjtc021) {
5425 jjtree.closeNodeScope(jjtn021, true);
5426 jjtreeCloseNodeScope(jjtn021);
5427 }
5428 }
5429 break;
5430 case RETURN:
5431 SimpleNode jjtn022 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5432 boolean jjtc022 = true;
5433 jjtree.openNodeScope(jjtn022);
5434 jjtreeOpenNodeScope(jjtn022);
5435 try {
5436 t = jj_consume_token(RETURN);
5437 jjtn022.setImage(t.image); {if (true) return t;}
5438 jjtree.closeNodeScope(jjtn022, true);
5439 jjtc022 = false;
5440 jjtreeCloseNodeScope(jjtn022);
5441
5442 } finally {
5443 if (jjtc022) {
5444 jjtree.closeNodeScope(jjtn022, true);
5445 jjtreeCloseNodeScope(jjtn022);
5446 }
5447 }
5448 break;
5449 case YIELD:
5450 SimpleNode jjtn023 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5451 boolean jjtc023 = true;
5452 jjtree.openNodeScope(jjtn023);
5453 jjtreeOpenNodeScope(jjtn023);
5454 try {
5455 t = jj_consume_token(YIELD);
5456 jjtn023.setImage(t.image); {if (true) return t;}
5457 jjtree.closeNodeScope(jjtn023, true);
5458 jjtc023 = false;
5459 jjtreeCloseNodeScope(jjtn023);
5460
5461 } finally {
5462 if (jjtc023) {
5463 jjtree.closeNodeScope(jjtn023, true);
5464 jjtreeCloseNodeScope(jjtn023);
5465 }
5466 }
5467 break;
5468 case IMPORT:
5469 SimpleNode jjtn024 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5470 boolean jjtc024 = true;
5471 jjtree.openNodeScope(jjtn024);
5472 jjtreeOpenNodeScope(jjtn024);
5473 try {
5474 t = jj_consume_token(IMPORT);
5475 jjtn024.setImage(t.image); {if (true) return t;}
5476 jjtree.closeNodeScope(jjtn024, true);
5477 jjtc024 = false;
5478 jjtreeCloseNodeScope(jjtn024);
5479
5480 } finally {
5481 if (jjtc024) {
5482 jjtree.closeNodeScope(jjtn024, true);
5483 jjtreeCloseNodeScope(jjtn024);
5484 }
5485 }
5486 break;
5487 case FROM:
5488 SimpleNode jjtn025 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5489 boolean jjtc025 = true;
5490 jjtree.openNodeScope(jjtn025);
5491 jjtreeOpenNodeScope(jjtn025);
5492 try {
5493 t = jj_consume_token(FROM);
5494 jjtn025.setImage(t.image); {if (true) return t;}
5495 jjtree.closeNodeScope(jjtn025, true);
5496 jjtc025 = false;
5497 jjtreeCloseNodeScope(jjtn025);
5498
5499 } finally {
5500 if (jjtc025) {
5501 jjtree.closeNodeScope(jjtn025, true);
5502 jjtreeCloseNodeScope(jjtn025);
5503 }
5504 }
5505 break;
5506 case DEL:
5507 SimpleNode jjtn026 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5508 boolean jjtc026 = true;
5509 jjtree.openNodeScope(jjtn026);
5510 jjtreeOpenNodeScope(jjtn026);
5511 try {
5512 t = jj_consume_token(DEL);
5513 jjtn026.setImage(t.image); {if (true) return t;}
5514 jjtree.closeNodeScope(jjtn026, true);
5515 jjtc026 = false;
5516 jjtreeCloseNodeScope(jjtn026);
5517
5518 } finally {
5519 if (jjtc026) {
5520 jjtree.closeNodeScope(jjtn026, true);
5521 jjtreeCloseNodeScope(jjtn026);
5522 }
5523 }
5524 break;
5525 case RAISE:
5526 SimpleNode jjtn027 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5527 boolean jjtc027 = true;
5528 jjtree.openNodeScope(jjtn027);
5529 jjtreeOpenNodeScope(jjtn027);
5530 try {
5531 t = jj_consume_token(RAISE);
5532 jjtn027.setImage(t.image); {if (true) return t;}
5533 jjtree.closeNodeScope(jjtn027, true);
5534 jjtc027 = false;
5535 jjtreeCloseNodeScope(jjtn027);
5536
5537 } finally {
5538 if (jjtc027) {
5539 jjtree.closeNodeScope(jjtn027, true);
5540 jjtreeCloseNodeScope(jjtn027);
5541 }
5542 }
5543 break;
5544 case GLOBAL:
5545 SimpleNode jjtn028 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5546 boolean jjtc028 = true;
5547 jjtree.openNodeScope(jjtn028);
5548 jjtreeOpenNodeScope(jjtn028);
5549 try {
5550 t = jj_consume_token(GLOBAL);
5551 jjtn028.setImage(t.image); {if (true) return t;}
5552 jjtree.closeNodeScope(jjtn028, true);
5553 jjtc028 = false;
5554 jjtreeCloseNodeScope(jjtn028);
5555
5556 } finally {
5557 if (jjtc028) {
5558 jjtree.closeNodeScope(jjtn028, true);
5559 jjtreeCloseNodeScope(jjtn028);
5560 }
5561 }
5562 break;
5563 case EXEC:
5564 SimpleNode jjtn029 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5565 boolean jjtc029 = true;
5566 jjtree.openNodeScope(jjtn029);
5567 jjtreeOpenNodeScope(jjtn029);
5568 try {
5569 t = jj_consume_token(EXEC);
5570 jjtn029.setImage(t.image); {if (true) return t;}
5571 jjtree.closeNodeScope(jjtn029, true);
5572 jjtc029 = false;
5573 jjtreeCloseNodeScope(jjtn029);
5574
5575 } finally {
5576 if (jjtc029) {
5577 jjtree.closeNodeScope(jjtn029, true);
5578 jjtreeCloseNodeScope(jjtn029);
5579 }
5580 }
5581 break;
5582 case ASSERT:
5583 SimpleNode jjtn030 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5584 boolean jjtc030 = true;
5585 jjtree.openNodeScope(jjtn030);
5586 jjtreeOpenNodeScope(jjtn030);
5587 try {
5588 t = jj_consume_token(ASSERT);
5589 jjtn030.setImage(t.image); {if (true) return t;}
5590 jjtree.closeNodeScope(jjtn030, true);
5591 jjtc030 = false;
5592 jjtreeCloseNodeScope(jjtn030);
5593
5594 } finally {
5595 if (jjtc030) {
5596 jjtree.closeNodeScope(jjtn030, true);
5597 jjtreeCloseNodeScope(jjtn030);
5598 }
5599 }
5600 break;
5601 case AS:
5602 SimpleNode jjtn031 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNAME);
5603 boolean jjtc031 = true;
5604 jjtree.openNodeScope(jjtn031);
5605 jjtreeOpenNodeScope(jjtn031);
5606 try {
5607 t = jj_consume_token(AS);
5608 jjtn031.setImage(t.image); {if (true) return t;}
5609 jjtree.closeNodeScope(jjtn031, true);
5610 jjtc031 = false;
5611 jjtreeCloseNodeScope(jjtn031);
5612
5613 } finally {
5614 if (jjtc031) {
5615 jjtree.closeNodeScope(jjtn031, true);
5616 jjtreeCloseNodeScope(jjtn031);
5617 }
5618 }
5619 break;
5620 default:
5621 jj_la1[105] = jj_gen;
5622 jj_consume_token(-1);
5623 throw new ParseException();
5624 }
5625 throw new Error ("Missing return statement in function");
5626 }
5627
5628 final private boolean jj_2_1(int xla) {
5629 jj_la = xla; jj_lastpos = jj_scanpos = token;
5630 try { return !jj_3_1(); }
5631 catch(LookaheadSuccess ls) { return true; }
5632 finally { jj_save(0, xla); }
5633 }
5634
5635 final private boolean jj_2_2(int xla) {
5636 jj_la = xla; jj_lastpos = jj_scanpos = token;
5637 try { return !jj_3_2(); }
5638 catch(LookaheadSuccess ls) { return true; }
5639 finally { jj_save(1, xla); }
5640 }
5641
5642 final private boolean jj_2_3(int xla) {
5643 jj_la = xla; jj_lastpos = jj_scanpos = token;
5644 try { return !jj_3_3(); }
5645 catch(LookaheadSuccess ls) { return true; }
5646 finally { jj_save(2, xla); }
5647 }
5648
5649 final private boolean jj_2_4(int xla) {
5650 jj_la = xla; jj_lastpos = jj_scanpos = token;
5651 try { return !jj_3_4(); }
5652 catch(LookaheadSuccess ls) { return true; }
5653 finally { jj_save(3, xla); }
5654 }
5655
5656 final private boolean jj_2_5(int xla) {
5657 jj_la = xla; jj_lastpos = jj_scanpos = token;
5658 try { return !jj_3_5(); }
5659 catch(LookaheadSuccess ls) { return true; }
5660 finally { jj_save(4, xla); }
5661 }
5662
5663 final private boolean jj_2_6(int xla) {
5664 jj_la = xla; jj_lastpos = jj_scanpos = token;
5665 try { return !jj_3_6(); }
5666 catch(LookaheadSuccess ls) { return true; }
5667 finally { jj_save(5, xla); }
5668 }
5669
5670 final private boolean jj_2_7(int xla) {
5671 jj_la = xla; jj_lastpos = jj_scanpos = token;
5672 try { return !jj_3_7(); }
5673 catch(LookaheadSuccess ls) { return true; }
5674 finally { jj_save(6, xla); }
5675 }
5676
5677 final private boolean jj_2_8(int xla) {
5678 jj_la = xla; jj_lastpos = jj_scanpos = token;
5679 try { return !jj_3_8(); }
5680 catch(LookaheadSuccess ls) { return true; }
5681 finally { jj_save(7, xla); }
5682 }
5683
5684 final private boolean jj_2_9(int xla) {
5685 jj_la = xla; jj_lastpos = jj_scanpos = token;
5686 try { return !jj_3_9(); }
5687 catch(LookaheadSuccess ls) { return true; }
5688 finally { jj_save(8, xla); }
5689 }
5690
5691 final private boolean jj_2_10(int xla) {
5692 jj_la = xla; jj_lastpos = jj_scanpos = token;
5693 try { return !jj_3_10(); }
5694 catch(LookaheadSuccess ls) { return true; }
5695 finally { jj_save(9, xla); }
5696 }
5697
5698 final private boolean jj_2_11(int xla) {
5699 jj_la = xla; jj_lastpos = jj_scanpos = token;
5700 try { return !jj_3_11(); }
5701 catch(LookaheadSuccess ls) { return true; }
5702 finally { jj_save(10, xla); }
5703 }
5704
5705 final private boolean jj_2_12(int xla) {
5706 jj_la = xla; jj_lastpos = jj_scanpos = token;
5707 try { return !jj_3_12(); }
5708 catch(LookaheadSuccess ls) { return true; }
5709 finally { jj_save(11, xla); }
5710 }
5711
5712 final private boolean jj_2_13(int xla) {
5713 jj_la = xla; jj_lastpos = jj_scanpos = token;
5714 try { return !jj_3_13(); }
5715 catch(LookaheadSuccess ls) { return true; }
5716 finally { jj_save(12, xla); }
5717 }
5718
5719 final private boolean jj_2_14(int xla) {
5720 jj_la = xla; jj_lastpos = jj_scanpos = token;
5721 try { return !jj_3_14(); }
5722 catch(LookaheadSuccess ls) { return true; }
5723 finally { jj_save(13, xla); }
5724 }
5725
5726 final private boolean jj_2_15(int xla) {
5727 jj_la = xla; jj_lastpos = jj_scanpos = token;
5728 try { return !jj_3_15(); }
5729 catch(LookaheadSuccess ls) { return true; }
5730 finally { jj_save(14, xla); }
5731 }
5732
5733 final private boolean jj_2_16(int xla) {
5734 jj_la = xla; jj_lastpos = jj_scanpos = token;
5735 try { return !jj_3_16(); }
5736 catch(LookaheadSuccess ls) { return true; }
5737 finally { jj_save(15, xla); }
5738 }
5739
5740 final private boolean jj_2_17(int xla) {
5741 jj_la = xla; jj_lastpos = jj_scanpos = token;
5742 try { return !jj_3_17(); }
5743 catch(LookaheadSuccess ls) { return true; }
5744 finally { jj_save(16, xla); }
5745 }
5746
5747 final private boolean jj_2_18(int xla) {
5748 jj_la = xla; jj_lastpos = jj_scanpos = token;
5749 try { return !jj_3_18(); }
5750 catch(LookaheadSuccess ls) { return true; }
5751 finally { jj_save(17, xla); }
5752 }
5753
5754 final private boolean jj_2_19(int xla) {
5755 jj_la = xla; jj_lastpos = jj_scanpos = token;
5756 try { return !jj_3_19(); }
5757 catch(LookaheadSuccess ls) { return true; }
5758 finally { jj_save(18, xla); }
5759 }
5760
5761 final private boolean jj_2_20(int xla) {
5762 jj_la = xla; jj_lastpos = jj_scanpos = token;
5763 try { return !jj_3_20(); }
5764 catch(LookaheadSuccess ls) { return true; }
5765 finally { jj_save(19, xla); }
5766 }
5767
5768 final private boolean jj_2_21(int xla) {
5769 jj_la = xla; jj_lastpos = jj_scanpos = token;
5770 try { return !jj_3_21(); }
5771 catch(LookaheadSuccess ls) { return true; }
5772 finally { jj_save(20, xla); }
5773 }
5774
5775 final private boolean jj_2_22(int xla) {
5776 jj_la = xla; jj_lastpos = jj_scanpos = token;
5777 try { return !jj_3_22(); }
5778 catch(LookaheadSuccess ls) { return true; }
5779 finally { jj_save(21, xla); }
5780 }
5781
5782 final private boolean jj_2_23(int xla) {
5783 jj_la = xla; jj_lastpos = jj_scanpos = token;
5784 try { return !jj_3_23(); }
5785 catch(LookaheadSuccess ls) { return true; }
5786 finally { jj_save(22, xla); }
5787 }
5788
5789 final private boolean jj_2_24(int xla) {
5790 jj_la = xla; jj_lastpos = jj_scanpos = token;
5791 try { return !jj_3_24(); }
5792 catch(LookaheadSuccess ls) { return true; }
5793 finally { jj_save(23, xla); }
5794 }
5795
5796 final private boolean jj_2_25(int xla) {
5797 jj_la = xla; jj_lastpos = jj_scanpos = token;
5798 try { return !jj_3_25(); }
5799 catch(LookaheadSuccess ls) { return true; }
5800 finally { jj_save(24, xla); }
5801 }
5802
5803 final private boolean jj_3R_116() {
5804 if (jj_scan_token(ASSERT)) return true;
5805 return false;
5806 }
5807
5808 final private boolean jj_3R_115() {
5809 if (jj_scan_token(EXEC)) return true;
5810 return false;
5811 }
5812
5813 final private boolean jj_3R_114() {
5814 if (jj_scan_token(GLOBAL)) return true;
5815 return false;
5816 }
5817
5818 final private boolean jj_3R_130() {
5819 if (jj_scan_token(FROM)) return true;
5820 return false;
5821 }
5822
5823 final private boolean jj_3R_113() {
5824 Token xsp;
5825 xsp = jj_scanpos;
5826 if (jj_3R_129()) {
5827 jj_scanpos = xsp;
5828 if (jj_3R_130()) return true;
5829 }
5830 return false;
5831 }
5832
5833 final private boolean jj_3R_129() {
5834 if (jj_scan_token(IMPORT)) return true;
5835 return false;
5836 }
5837
5838 final private boolean jj_3R_137() {
5839 if (jj_scan_token(RAISE)) return true;
5840 return false;
5841 }
5842
5843 final private boolean jj_3_9() {
5844 if (jj_scan_token(COMMA)) return true;
5845 if (jj_3R_45()) return true;
5846 return false;
5847 }
5848
5849 final private boolean jj_3R_136() {
5850 if (jj_scan_token(YIELD)) return true;
5851 return false;
5852 }
5853
5854 final private boolean jj_3R_135() {
5855 if (jj_scan_token(RETURN)) return true;
5856 return false;
5857 }
5858
5859 final private boolean jj_3R_128() {
5860 if (jj_3R_137()) return true;
5861 return false;
5862 }
5863
5864 final private boolean jj_3R_127() {
5865 if (jj_3R_136()) return true;
5866 return false;
5867 }
5868
5869 final private boolean jj_3R_125() {
5870 if (jj_scan_token(CONTINUE)) return true;
5871 return false;
5872 }
5873
5874 final private boolean jj_3R_126() {
5875 if (jj_3R_135()) return true;
5876 return false;
5877 }
5878
5879 final private boolean jj_3R_112() {
5880 Token xsp;
5881 xsp = jj_scanpos;
5882 if (jj_3R_124()) {
5883 jj_scanpos = xsp;
5884 if (jj_3R_125()) {
5885 jj_scanpos = xsp;
5886 if (jj_3R_126()) {
5887 jj_scanpos = xsp;
5888 if (jj_3R_127()) {
5889 jj_scanpos = xsp;
5890 if (jj_3R_128()) return true;
5891 }
5892 }
5893 }
5894 }
5895 return false;
5896 }
5897
5898 final private boolean jj_3R_124() {
5899 if (jj_scan_token(BREAK)) return true;
5900 return false;
5901 }
5902
5903 final private boolean jj_3R_111() {
5904 if (jj_scan_token(PASS)) return true;
5905 return false;
5906 }
5907
5908 final private boolean jj_3R_105() {
5909 if (jj_scan_token(AS)) return true;
5910 return false;
5911 }
5912
5913 final private boolean jj_3R_104() {
5914 if (jj_scan_token(ASSERT)) return true;
5915 return false;
5916 }
5917
5918 final private boolean jj_3R_103() {
5919 if (jj_scan_token(EXEC)) return true;
5920 return false;
5921 }
5922
5923 final private boolean jj_3R_102() {
5924 if (jj_scan_token(GLOBAL)) return true;
5925 return false;
5926 }
5927
5928 final private boolean jj_3R_110() {
5929 if (jj_scan_token(DEL)) return true;
5930 return false;
5931 }
5932
5933 final private boolean jj_3R_101() {
5934 if (jj_scan_token(RAISE)) return true;
5935 return false;
5936 }
5937
5938 final private boolean jj_3R_100() {
5939 if (jj_scan_token(DEL)) return true;
5940 return false;
5941 }
5942
5943 final private boolean jj_3_8() {
5944 if (jj_scan_token(COMMA)) return true;
5945 if (jj_3R_45()) return true;
5946 return false;
5947 }
5948
5949 final private boolean jj_3R_99() {
5950 if (jj_scan_token(FROM)) return true;
5951 return false;
5952 }
5953
5954 final private boolean jj_3R_98() {
5955 if (jj_scan_token(IMPORT)) return true;
5956 return false;
5957 }
5958
5959 final private boolean jj_3R_123() {
5960 if (jj_scan_token(PRINT)) return true;
5961 return false;
5962 }
5963
5964 final private boolean jj_3R_97() {
5965 if (jj_scan_token(YIELD)) return true;
5966 return false;
5967 }
5968
5969 final private boolean jj_3R_96() {
5970 if (jj_scan_token(RETURN)) return true;
5971 return false;
5972 }
5973
5974 final private boolean jj_3R_95() {
5975 if (jj_scan_token(CONTINUE)) return true;
5976 return false;
5977 }
5978
5979 final private boolean jj_3_11() {
5980 if (jj_scan_token(PRINT)) return true;
5981 if (jj_3R_45()) return true;
5982 return false;
5983 }
5984
5985 final private boolean jj_3R_94() {
5986 if (jj_scan_token(BREAK)) return true;
5987 return false;
5988 }
5989
5990 final private boolean jj_3R_93() {
5991 if (jj_scan_token(PASS)) return true;
5992 return false;
5993 }
5994
5995 final private boolean jj_3R_92() {
5996 if (jj_scan_token(PRINT)) return true;
5997 return false;
5998 }
5999
6000 final private boolean jj_3_10() {
6001 if (jj_scan_token(PRINT)) return true;
6002 if (jj_scan_token(RSHIFT)) return true;
6003 return false;
6004 }
6005
6006 final private boolean jj_3R_109() {
6007 Token xsp;
6008 xsp = jj_scanpos;
6009 if (jj_3_10()) {
6010 jj_scanpos = xsp;
6011 if (jj_3_11()) {
6012 jj_scanpos = xsp;
6013 if (jj_3R_123()) return true;
6014 }
6015 }
6016 return false;
6017 }
6018
6019 final private boolean jj_3R_91() {
6020 if (jj_scan_token(FINALLY)) return true;
6021 return false;
6022 }
6023
6024 final private boolean jj_3R_90() {
6025 if (jj_scan_token(CLASS)) return true;
6026 return false;
6027 }
6028
6029 final private boolean jj_3R_89() {
6030 if (jj_scan_token(DEF)) return true;
6031 return false;
6032 }
6033
6034 final private boolean jj_3R_88() {
6035 if (jj_scan_token(EXCEPT)) return true;
6036 return false;
6037 }
6038
6039 final private boolean jj_3R_87() {
6040 if (jj_scan_token(TRY)) return true;
6041 return false;
6042 }
6043
6044 final private boolean jj_3R_86() {
6045 if (jj_scan_token(FOR)) return true;
6046 return false;
6047 }
6048
6049 final private boolean jj_3R_85() {
6050 if (jj_scan_token(WHILE)) return true;
6051 return false;
6052 }
6053
6054 final private boolean jj_3R_84() {
6055 if (jj_scan_token(ELIF)) return true;
6056 return false;
6057 }
6058
6059 final private boolean jj_3R_83() {
6060 if (jj_scan_token(ELSE)) return true;
6061 return false;
6062 }
6063
6064 final private boolean jj_3R_82() {
6065 if (jj_scan_token(IF)) return true;
6066 return false;
6067 }
6068
6069 final private boolean jj_3R_81() {
6070 if (jj_scan_token(LAMBDA)) return true;
6071 return false;
6072 }
6073
6074 final private boolean jj_3R_80() {
6075 if (jj_scan_token(IN)) return true;
6076 return false;
6077 }
6078
6079 final private boolean jj_3R_79() {
6080 if (jj_scan_token(IS)) return true;
6081 return false;
6082 }
6083
6084 final private boolean jj_3R_78() {
6085 if (jj_scan_token(NOT_BOOL)) return true;
6086 return false;
6087 }
6088
6089 final private boolean jj_3R_77() {
6090 if (jj_scan_token(AND_BOOL)) return true;
6091 return false;
6092 }
6093
6094 final private boolean jj_3R_76() {
6095 if (jj_scan_token(OR_BOOL)) return true;
6096 return false;
6097 }
6098
6099 final private boolean jj_3R_75() {
6100 if (jj_scan_token(NAME)) return true;
6101 return false;
6102 }
6103
6104 final private boolean jj_3R_51() {
6105 Token xsp;
6106 xsp = jj_scanpos;
6107 if (jj_3R_75()) {
6108 jj_scanpos = xsp;
6109 if (jj_3R_76()) {
6110 jj_scanpos = xsp;
6111 if (jj_3R_77()) {
6112 jj_scanpos = xsp;
6113 if (jj_3R_78()) {
6114 jj_scanpos = xsp;
6115 if (jj_3R_79()) {
6116 jj_scanpos = xsp;
6117 if (jj_3R_80()) {
6118 jj_scanpos = xsp;
6119 if (jj_3R_81()) {
6120 jj_scanpos = xsp;
6121 if (jj_3R_82()) {
6122 jj_scanpos = xsp;
6123 if (jj_3R_83()) {
6124 jj_scanpos = xsp;
6125 if (jj_3R_84()) {
6126 jj_scanpos = xsp;
6127 if (jj_3R_85()) {
6128 jj_scanpos = xsp;
6129 if (jj_3R_86()) {
6130 jj_scanpos = xsp;
6131 if (jj_3R_87()) {
6132 jj_scanpos = xsp;
6133 if (jj_3R_88()) {
6134 jj_scanpos = xsp;
6135 if (jj_3R_89()) {
6136 jj_scanpos = xsp;
6137 if (jj_3R_90()) {
6138 jj_scanpos = xsp;
6139 if (jj_3R_91()) {
6140 jj_scanpos = xsp;
6141 if (jj_3R_92()) {
6142 jj_scanpos = xsp;
6143 if (jj_3R_93()) {
6144 jj_scanpos = xsp;
6145 if (jj_3R_94()) {
6146 jj_scanpos = xsp;
6147 if (jj_3R_95()) {
6148 jj_scanpos = xsp;
6149 if (jj_3R_96()) {
6150 jj_scanpos = xsp;
6151 if (jj_3R_97()) {
6152 jj_scanpos = xsp;
6153 if (jj_3R_98()) {
6154 jj_scanpos = xsp;
6155 if (jj_3R_99()) {
6156 jj_scanpos = xsp;
6157 if (jj_3R_100()) {
6158 jj_scanpos = xsp;
6159 if (jj_3R_101()) {
6160 jj_scanpos = xsp;
6161 if (jj_3R_102()) {
6162 jj_scanpos = xsp;
6163 if (jj_3R_103()) {
6164 jj_scanpos = xsp;
6165 if (jj_3R_104()) {
6166 jj_scanpos = xsp;
6167 if (jj_3R_105()) return true;
6168 }
6169 }
6170 }
6171 }
6172 }
6173 }
6174 }
6175 }
6176 }
6177 }
6178 }
6179 }
6180 }
6181 }
6182 }
6183 }
6184 }
6185 }
6186 }
6187 }
6188 }
6189 }
6190 }
6191 }
6192 }
6193 }
6194 }
6195 }
6196 }
6197 }
6198 return false;
6199 }
6200
6201 final private boolean jj_3R_108() {
6202 if (jj_3R_122()) return true;
6203 return false;
6204 }
6205
6206 final private boolean jj_3R_161() {
6207 if (jj_scan_token(TRIPLE_STRING2)) return true;
6208 return false;
6209 }
6210
6211 final private boolean jj_3R_160() {
6212 if (jj_scan_token(TRIPLE_STRING)) return true;
6213 return false;
6214 }
6215
6216 final private boolean jj_3R_159() {
6217 if (jj_scan_token(SINGLE_STRING2)) return true;
6218 return false;
6219 }
6220
6221 final private boolean jj_3R_64() {
6222 if (jj_3R_116()) return true;
6223 return false;
6224 }
6225
6226 final private boolean jj_3R_63() {
6227 if (jj_3R_115()) return true;
6228 return false;
6229 }
6230
6231 final private boolean jj_3R_158() {
6232 if (jj_scan_token(SINGLE_STRING)) return true;
6233 return false;
6234 }
6235
6236 final private boolean jj_3R_62() {
6237 if (jj_3R_114()) return true;
6238 return false;
6239 }
6240
6241 final private boolean jj_3_7() {
6242 if (jj_scan_token(SEMICOLON)) return true;
6243 if (jj_3R_44()) return true;
6244 return false;
6245 }
6246
6247 final private boolean jj_3R_152() {
6248 Token xsp;
6249 xsp = jj_scanpos;
6250 if (jj_3R_158()) {
6251 jj_scanpos = xsp;
6252 if (jj_3R_159()) {
6253 jj_scanpos = xsp;
6254 if (jj_3R_160()) {
6255 jj_scanpos = xsp;
6256 if (jj_3R_161()) return true;
6257 }
6258 }
6259 }
6260 return false;
6261 }
6262
6263 final private boolean jj_3R_61() {
6264 if (jj_3R_113()) return true;
6265 return false;
6266 }
6267
6268 final private boolean jj_3R_60() {
6269 if (jj_3R_112()) return true;
6270 return false;
6271 }
6272
6273 final private boolean jj_3R_59() {
6274 if (jj_3R_111()) return true;
6275 return false;
6276 }
6277
6278 final private boolean jj_3R_58() {
6279 if (jj_3R_110()) return true;
6280 return false;
6281 }
6282
6283 final private boolean jj_3R_57() {
6284 if (jj_3R_109()) return true;
6285 return false;
6286 }
6287
6288 final private boolean jj_3R_56() {
6289 if (jj_3R_108()) return true;
6290 return false;
6291 }
6292
6293 final private boolean jj_3R_44() {
6294 Token xsp;
6295 xsp = jj_scanpos;
6296 if (jj_3R_56()) {
6297 jj_scanpos = xsp;
6298 if (jj_3R_57()) {
6299 jj_scanpos = xsp;
6300 if (jj_3R_58()) {
6301 jj_scanpos = xsp;
6302 if (jj_3R_59()) {
6303 jj_scanpos = xsp;
6304 if (jj_3R_60()) {
6305 jj_scanpos = xsp;
6306 if (jj_3R_61()) {
6307 jj_scanpos = xsp;
6308 if (jj_3R_62()) {
6309 jj_scanpos = xsp;
6310 if (jj_3R_63()) {
6311 jj_scanpos = xsp;
6312 if (jj_3R_64()) return true;
6313 }
6314 }
6315 }
6316 }
6317 }
6318 }
6319 }
6320 }
6321 return false;
6322 }
6323
6324 final private boolean jj_3R_107() {
6325 if (jj_scan_token(AS)) return true;
6326 return false;
6327 }
6328
6329 final private boolean jj_3R_52() {
6330 Token xsp;
6331 xsp = jj_scanpos;
6332 if (jj_3R_106()) {
6333 jj_scanpos = xsp;
6334 if (jj_3R_107()) return true;
6335 }
6336 return false;
6337 }
6338
6339 final private boolean jj_3R_106() {
6340 if (jj_scan_token(NAME)) return true;
6341 return false;
6342 }
6343
6344 final private boolean jj_3_6() {
6345 if (jj_scan_token(COMMA)) return true;
6346 if (jj_3R_43()) return true;
6347 return false;
6348 }
6349
6350 final private boolean jj_3R_55() {
6351 if (jj_scan_token(LPAREN)) return true;
6352 return false;
6353 }
6354
6355 final private boolean jj_3R_157() {
6356 if (jj_scan_token(COMPLEX)) return true;
6357 return false;
6358 }
6359
6360 final private boolean jj_3R_53() {
6361 if (jj_scan_token(MULTIPLY)) return true;
6362 return false;
6363 }
6364
6365 final private boolean jj_3R_156() {
6366 if (jj_scan_token(FLOAT)) return true;
6367 return false;
6368 }
6369
6370 final private boolean jj_3R_54() {
6371 if (jj_3R_52()) return true;
6372 return false;
6373 }
6374
6375 final private boolean jj_3R_43() {
6376 Token xsp;
6377 xsp = jj_scanpos;
6378 if (jj_3R_54()) {
6379 jj_scanpos = xsp;
6380 if (jj_3R_55()) return true;
6381 }
6382 return false;
6383 }
6384
6385 final private boolean jj_3R_155() {
6386 if (jj_scan_token(DECNUMBER)) return true;
6387 return false;
6388 }
6389
6390 final private boolean jj_3R_40() {
6391 if (jj_3R_43()) return true;
6392 return false;
6393 }
6394
6395 final private boolean jj_3_2() {
6396 if (jj_scan_token(COMMA)) return true;
6397 if (jj_3R_40()) return true;
6398 return false;
6399 }
6400
6401 final private boolean jj_3R_154() {
6402 if (jj_scan_token(OCTNUMBER)) return true;
6403 return false;
6404 }
6405
6406 final private boolean jj_3R_42() {
6407 Token xsp;
6408 xsp = jj_scanpos;
6409 if (jj_scan_token(33)) {
6410 jj_scanpos = xsp;
6411 if (jj_3R_53()) return true;
6412 }
6413 return false;
6414 }
6415
6416 final private boolean jj_3R_41() {
6417 if (jj_scan_token(MULTIPLY)) return true;
6418 if (jj_3R_52()) return true;
6419 return false;
6420 }
6421
6422 final private boolean jj_3R_151() {
6423 Token xsp;
6424 xsp = jj_scanpos;
6425 if (jj_3R_153()) {
6426 jj_scanpos = xsp;
6427 if (jj_3R_154()) {
6428 jj_scanpos = xsp;
6429 if (jj_3R_155()) {
6430 jj_scanpos = xsp;
6431 if (jj_3R_156()) {
6432 jj_scanpos = xsp;
6433 if (jj_3R_157()) return true;
6434 }
6435 }
6436 }
6437 }
6438 return false;
6439 }
6440
6441 final private boolean jj_3R_153() {
6442 if (jj_scan_token(HEXNUMBER)) return true;
6443 return false;
6444 }
6445
6446 final private boolean jj_3_4() {
6447 if (jj_scan_token(COMMA)) return true;
6448 if (jj_3R_42()) return true;
6449 return false;
6450 }
6451
6452 final private boolean jj_3_3() {
6453 if (jj_scan_token(COMMA)) return true;
6454 if (jj_3R_41()) return true;
6455 return false;
6456 }
6457
6458 final private boolean jj_3_5() {
6459 if (jj_3R_41()) return true;
6460 return false;
6461 }
6462
6463 final private boolean jj_3_25() {
6464 if (jj_3R_51()) return true;
6465 if (jj_scan_token(EQUAL)) return true;
6466 return false;
6467 }
6468
6469 final private boolean jj_3R_50() {
6470 Token xsp;
6471 xsp = jj_scanpos;
6472 if (jj_3_25()) jj_scanpos = xsp;
6473 if (jj_3R_45()) return true;
6474 return false;
6475 }
6476
6477 final private boolean jj_3_24() {
6478 if (jj_scan_token(COMMA)) return true;
6479 if (jj_3R_50()) return true;
6480 return false;
6481 }
6482
6483 final private boolean jj_3R_49() {
6484 if (jj_scan_token(MULTIPLY)) return true;
6485 if (jj_3R_45()) return true;
6486 return false;
6487 }
6488
6489 final private boolean jj_3_23() {
6490 if (jj_3R_49()) return true;
6491 return false;
6492 }
6493
6494 final private boolean jj_3_22() {
6495 if (jj_3R_49()) return true;
6496 return false;
6497 }
6498
6499 final private boolean jj_3_21() {
6500 if (jj_scan_token(COMMA)) return true;
6501 if (jj_3R_45()) return true;
6502 return false;
6503 }
6504
6505 final private boolean jj_3_20() {
6506 if (jj_scan_token(COMMA)) return true;
6507 if (jj_3R_45()) return true;
6508 return false;
6509 }
6510
6511 final private boolean jj_3_1() {
6512 if (jj_scan_token(NEWLINE)) return true;
6513 return false;
6514 }
6515
6516 final private boolean jj_3_19() {
6517 if (jj_scan_token(COMMA)) return true;
6518 if (jj_3R_45()) return true;
6519 return false;
6520 }
6521
6522 final private boolean jj_3_18() {
6523 if (jj_scan_token(COMMA)) return true;
6524 if (jj_3R_45()) return true;
6525 return false;
6526 }
6527
6528 final private boolean jj_3R_133() {
6529 if (jj_scan_token(COLON)) return true;
6530 return false;
6531 }
6532
6533 final private boolean jj_3_17() {
6534 if (jj_scan_token(COMMA)) return true;
6535 if (jj_3R_48()) return true;
6536 return false;
6537 }
6538
6539 final private boolean jj_3R_122() {
6540 if (jj_3R_45()) return true;
6541 return false;
6542 }
6543
6544 final private boolean jj_3_16() {
6545 if (jj_scan_token(COMMA)) return true;
6546 if (jj_3R_47()) return true;
6547 return false;
6548 }
6549
6550 final private boolean jj_3R_120() {
6551 if (jj_3R_133()) return true;
6552 return false;
6553 }
6554
6555 final private boolean jj_3R_73() {
6556 if (jj_3R_120()) return true;
6557 return false;
6558 }
6559
6560 final private boolean jj_3R_72() {
6561 if (jj_3R_45()) return true;
6562 return false;
6563 }
6564
6565 final private boolean jj_3R_71() {
6566 if (jj_scan_token(DOT)) return true;
6567 return false;
6568 }
6569
6570 final private boolean jj_3R_47() {
6571 Token xsp;
6572 xsp = jj_scanpos;
6573 if (jj_3R_71()) {
6574 jj_scanpos = xsp;
6575 if (jj_3R_72()) {
6576 jj_scanpos = xsp;
6577 if (jj_3R_73()) return true;
6578 }
6579 }
6580 return false;
6581 }
6582
6583 final private boolean jj_3R_117() {
6584 if (jj_scan_token(LAMBDA)) return true;
6585 return false;
6586 }
6587
6588 final private boolean jj_3R_149() {
6589 if (jj_3R_152()) return true;
6590 return false;
6591 }
6592
6593 final private boolean jj_3R_148() {
6594 if (jj_3R_151()) return true;
6595 return false;
6596 }
6597
6598 final private boolean jj_3R_147() {
6599 if (jj_3R_52()) return true;
6600 return false;
6601 }
6602
6603 final private boolean jj_3R_145() {
6604 if (jj_scan_token(LBRACE)) return true;
6605 return false;
6606 }
6607
6608 final private boolean jj_3R_146() {
6609 if (jj_scan_token(121)) return true;
6610 return false;
6611 }
6612
6613 final private boolean jj_3R_144() {
6614 if (jj_scan_token(LBRACKET)) return true;
6615 return false;
6616 }
6617
6618 final private boolean jj_3R_143() {
6619 if (jj_scan_token(LPAREN)) return true;
6620 return false;
6621 }
6622
6623 final private boolean jj_3_15() {
6624 if (jj_scan_token(LPAREN)) return true;
6625 if (jj_scan_token(RPAREN)) return true;
6626 return false;
6627 }
6628
6629 final private boolean jj_3R_140() {
6630 Token xsp;
6631 xsp = jj_scanpos;
6632 if (jj_3_15()) {
6633 jj_scanpos = xsp;
6634 if (jj_3R_143()) {
6635 jj_scanpos = xsp;
6636 if (jj_3R_144()) {
6637 jj_scanpos = xsp;
6638 if (jj_3R_145()) {
6639 jj_scanpos = xsp;
6640 if (jj_3R_146()) {
6641 jj_scanpos = xsp;
6642 if (jj_3R_147()) {
6643 jj_scanpos = xsp;
6644 if (jj_3R_148()) {
6645 jj_scanpos = xsp;
6646 if (jj_3R_149()) return true;
6647 }
6648 }
6649 }
6650 }
6651 }
6652 }
6653 }
6654 return false;
6655 }
6656
6657 final private boolean jj_3_14() {
6658 if (jj_scan_token(LPAREN)) return true;
6659 if (jj_scan_token(RPAREN)) return true;
6660 return false;
6661 }
6662
6663 final private boolean jj_3_13() {
6664 if (jj_scan_token(POWER)) return true;
6665 if (jj_3R_46()) return true;
6666 return false;
6667 }
6668
6669 final private boolean jj_3R_132() {
6670 if (jj_3R_140()) return true;
6671 return false;
6672 }
6673
6674 final private boolean jj_3R_119() {
6675 if (jj_3R_132()) return true;
6676 return false;
6677 }
6678
6679 final private boolean jj_3R_70() {
6680 if (jj_3R_119()) return true;
6681 return false;
6682 }
6683
6684 final private boolean jj_3R_69() {
6685 if (jj_scan_token(NOT)) return true;
6686 return false;
6687 }
6688
6689 final private boolean jj_3R_68() {
6690 if (jj_scan_token(MINUS)) return true;
6691 return false;
6692 }
6693
6694 final private boolean jj_3R_67() {
6695 if (jj_scan_token(PLUS)) return true;
6696 return false;
6697 }
6698
6699 final private boolean jj_3R_46() {
6700 Token xsp;
6701 xsp = jj_scanpos;
6702 if (jj_3R_67()) {
6703 jj_scanpos = xsp;
6704 if (jj_3R_68()) {
6705 jj_scanpos = xsp;
6706 if (jj_3R_69()) {
6707 jj_scanpos = xsp;
6708 if (jj_3R_70()) return true;
6709 }
6710 }
6711 }
6712 return false;
6713 }
6714
6715 final private boolean jj_3R_150() {
6716 if (jj_3R_46()) return true;
6717 return false;
6718 }
6719
6720 final private boolean jj_3R_141() {
6721 if (jj_3R_150()) return true;
6722 return false;
6723 }
6724
6725 final private boolean jj_3R_134() {
6726 if (jj_3R_141()) return true;
6727 return false;
6728 }
6729
6730 final private boolean jj_3R_121() {
6731 if (jj_3R_134()) return true;
6732 return false;
6733 }
6734
6735 final private boolean jj_3R_74() {
6736 if (jj_3R_121()) return true;
6737 return false;
6738 }
6739
6740 final private boolean jj_3R_48() {
6741 if (jj_3R_74()) return true;
6742 return false;
6743 }
6744
6745 final private boolean jj_3R_139() {
6746 if (jj_3R_142()) return true;
6747 return false;
6748 }
6749
6750 final private boolean jj_3_12() {
6751 if (jj_scan_token(IS)) return true;
6752 if (jj_scan_token(NOT_BOOL)) return true;
6753 return false;
6754 }
6755
6756 final private boolean jj_3R_142() {
6757 if (jj_3R_48()) return true;
6758 return false;
6759 }
6760
6761 final private boolean jj_3R_66() {
6762 if (jj_3R_118()) return true;
6763 return false;
6764 }
6765
6766 final private boolean jj_3R_131() {
6767 Token xsp;
6768 xsp = jj_scanpos;
6769 if (jj_3R_138()) {
6770 jj_scanpos = xsp;
6771 if (jj_3R_139()) return true;
6772 }
6773 return false;
6774 }
6775
6776 final private boolean jj_3R_138() {
6777 if (jj_scan_token(NOT_BOOL)) return true;
6778 return false;
6779 }
6780
6781 final private boolean jj_3R_118() {
6782 if (jj_3R_131()) return true;
6783 return false;
6784 }
6785
6786 final private boolean jj_3R_45() {
6787 Token xsp;
6788 xsp = jj_scanpos;
6789 if (jj_3R_65()) {
6790 jj_scanpos = xsp;
6791 if (jj_3R_66()) return true;
6792 }
6793 return false;
6794 }
6795
6796 final private boolean jj_3R_65() {
6797 if (jj_3R_117()) return true;
6798 return false;
6799 }
6800
6801 public PythonGrammarTokenManager token_source;
6802 public Token token, jj_nt;
6803 private int jj_ntk;
6804 private Token jj_scanpos, jj_lastpos;
6805 private int jj_la;
6806 public boolean lookingAhead = false;
6807 private boolean jj_semLA;
6808 private int jj_gen;
6809 final private int[] jj_la1 = new int[106];
6810 static private int[] jj_la1_0;
6811 static private int[] jj_la1_1;
6812 static private int[] jj_la1_2;
6813 static private int[] jj_la1_3;
6814 static {
6815 jj_la1_0();
6816 jj_la1_1();
6817 jj_la1_2();
6818 jj_la1_3();
6819 }
6820 private static void jj_la1_0() {
6821 jj_la1_0 = new int[] {0x30540000,0x30540000,0x40,0x30540040,0x30540040,0x40,0x40,0x40040000,0x2000000,0x2000000,0x40000000,0x40040000,0x40000000,0x0,0x40000,0x2000000,0x30540000,0x1000000,0x30540000,0x0,0x0,0x2000000,0x2000000,0x2000000,0x0,0x0,0x30540000,0x2000000,0x2000000,0x30540000,0x0,0x2000000,0x2000000,0x40000000,0x0,0x4000000,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x30540000,0x30540000,0x30540040,0x0,0x30540000,0x0,0x30540000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0x30000000,0xc0000000,0xc0000000,0x30540000,0x4440000,0x4440000,0x30540000,0x30540000,0x30540000,0x0,0x540000,0x40040000,0x2000000,0x8000000,0x3c540000,0x30540000,0x30540000,0x8000000,0x2000000,0x2000000,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x40000,0x2000000,0x40000000,0x40000000,0x2000000,0x2000000,0x40000000,0x40000000,0x30540000,0x40000000,0x0,0x0,0x0,0x0,};
6822 }
6823 private static void jj_la1_1() {
6824 jj_la1_1 = new int[] {0x80000020,0x80000020,0x0,0x80000020,0x80000020,0x0,0x0,0x2,0x0,0x0,0x2,0x2,0x2,0x200,0x0,0x0,0x80000020,0x0,0x80000020,0x200,0x1ffe0000,0x0,0x0,0x0,0x0,0x0,0x80000020,0x0,0x0,0x80000020,0x0,0x0,0x0,0xe0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000020,0x80000020,0x80000020,0x20000000,0x80000020,0x40000000,0x80000020,0x8001fc00,0x8001fc00,0x0,0x80,0x40,0x100,0xc,0xc,0x0,0x0,0x11,0x11,0x20,0x0,0x0,0x80000020,0x80000020,0x80000020,0x0,0x0,0x2,0x0,0x0,0x80000020,0x80000020,0x80000020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x2,0x0,0x0,0x2,0x2,0xe0000020,0x2,0x0,0x0,0x0,0xe0000000,};
6825 }
6826 private static void jj_la1_2() {
6827 jj_la1_2 = new int[] {0xefffedcc,0xefffedcc,0x0,0xefffedcc,0xefffedcc,0x0,0x0,0xc000000,0x0,0x0,0x0,0xc000000,0x0,0x0,0xc000000,0x0,0xefffedcc,0x0,0xefffe004,0x0,0x0,0x0,0x0,0x0,0x2000,0x478000,0xec000004,0x0,0x0,0xec000004,0x180000,0x0,0x0,0xfffffff,0x4000000,0x0,0x4000000,0x0,0x0,0x2,0x0,0xdc8,0x20,0x10,0x10,0x10,0x200,0x10,0x1200,0x0,0xec000004,0xefffedcc,0xefffe004,0x0,0xec000004,0x0,0xec000000,0x3,0x2,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xec000000,0x0,0x0,0xec000004,0xec000004,0xec000004,0x0,0xec000000,0xc000000,0x0,0x0,0xec000004,0xec000004,0xec000004,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x80,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xefffffff,0x0,0xe0000000,0xc000000,0x0,0xfffffff,};
6828 }
6829 private static void jj_la1_3() {
6830 jj_la1_3 = new int[] {0x2000f03,0x2000f03,0x0,0x2000f03,0x2000f03,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000f03,0x0,0x2000f03,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000f03,0x0,0x0,0x2000f03,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000f03,0x2000f03,0x2000f03,0x0,0x2000f03,0x0,0x2000f03,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000f03,0x0,0x0,0x2000f03,0x2000f03,0x2000f03,0xf00,0x2000f03,0x0,0x0,0x0,0x2000f03,0x2000f03,0x2000f03,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000f03,0x0,0x3,0x0,0xf00,0x0,};
6831 }
6832 final private JJCalls[] jj_2_rtns = new JJCalls[25];
6833 private boolean jj_rescan = false;
6834 private int jj_gc = 0;
6835
6836 public PythonGrammar(CharStream stream) {
6837 token_source = new PythonGrammarTokenManager(stream);
6838 token = new Token();
6839 jj_ntk = -1;
6840 jj_gen = 0;
6841 for (int i = 0; i < 106; i++) jj_la1[i] = -1;
6842 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6843 }
6844
6845 public void ReInit(CharStream stream) {
6846 token_source.ReInit(stream);
6847 token = new Token();
6848 jj_ntk = -1;
6849 jjtree.reset();
6850 jj_gen = 0;
6851 for (int i = 0; i < 106; i++) jj_la1[i] = -1;
6852 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6853 }
6854
6855 public PythonGrammar(PythonGrammarTokenManager tm) {
6856 token_source = tm;
6857 token = new Token();
6858 jj_ntk = -1;
6859 jj_gen = 0;
6860 for (int i = 0; i < 106; i++) jj_la1[i] = -1;
6861 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6862 }
6863
6864 public void ReInit(PythonGrammarTokenManager tm) {
6865 token_source = tm;
6866 token = new Token();
6867 jj_ntk = -1;
6868 jjtree.reset();
6869 jj_gen = 0;
6870 for (int i = 0; i < 106; i++) jj_la1[i] = -1;
6871 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
6872 }
6873
6874 final private Token jj_consume_token(int kind) throws ParseException {
6875 Token oldToken;
6876 if ((oldToken = token).next != null) token = token.next;
6877 else token = token.next = token_source.getNextToken();
6878 jj_ntk = -1;
6879 if (token.kind == kind) {
6880 jj_gen++;
6881 if (++jj_gc > 100) {
6882 jj_gc = 0;
6883 for (int i = 0; i < jj_2_rtns.length; i++) {
6884 JJCalls c = jj_2_rtns[i];
6885 while (c != null) {
6886 if (c.gen < jj_gen) c.first = null;
6887 c = c.next;
6888 }
6889 }
6890 }
6891 return token;
6892 }
6893 token = oldToken;
6894 jj_kind = kind;
6895 throw generateParseException();
6896 }
6897
6898 static private final class LookaheadSuccess extends java.lang.Error { }
6899 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
6900 final private boolean jj_scan_token(int kind) {
6901 if (jj_scanpos == jj_lastpos) {
6902 jj_la--;
6903 if (jj_scanpos.next == null) {
6904 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
6905 } else {
6906 jj_lastpos = jj_scanpos = jj_scanpos.next;
6907 }
6908 } else {
6909 jj_scanpos = jj_scanpos.next;
6910 }
6911 if (jj_rescan) {
6912 int i = 0; Token tok = token;
6913 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
6914 if (tok != null) jj_add_error_token(kind, i);
6915 }
6916 if (jj_scanpos.kind != kind) return true;
6917 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
6918 return false;
6919 }
6920
6921 final public Token getNextToken() {
6922 if (token.next != null) token = token.next;
6923 else token = token.next = token_source.getNextToken();
6924 jj_ntk = -1;
6925 jj_gen++;
6926 return token;
6927 }
6928
6929 final public Token getToken(int index) {
6930 Token t = lookingAhead ? jj_scanpos : token;
6931 for (int i = 0; i < index; i++) {
6932 if (t.next != null) t = t.next;
6933 else t = t.next = token_source.getNextToken();
6934 }
6935 return t;
6936 }
6937
6938 final private int jj_ntk() {
6939 if ((jj_nt=token.next) == null)
6940 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
6941 else
6942 return (jj_ntk = jj_nt.kind);
6943 }
6944
6945 private java.util.Vector jj_expentries = new java.util.Vector ();
6946 private int[] jj_expentry;
6947 private int jj_kind = -1;
6948 private int[] jj_lasttokens = new int[100];
6949 private int jj_endpos;
6950
6951 private void jj_add_error_token(int kind, int pos) {
6952 if (pos >= 100) return;
6953 if (pos == jj_endpos + 1) {
6954 jj_lasttokens[jj_endpos++] = kind;
6955 } else if (jj_endpos != 0) {
6956 jj_expentry = new int[jj_endpos];
6957 for (int i = 0; i < jj_endpos; i++) {
6958 jj_expentry[i] = jj_lasttokens[i];
6959 }
6960 boolean exists = false;
6961 for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
6962 int[] oldentry = (int[])(e.nextElement());
6963 if (oldentry.length == jj_expentry.length) {
6964 exists = true;
6965 for (int i = 0; i < jj_expentry.length; i++) {
6966 if (oldentry[i] != jj_expentry[i]) {
6967 exists = false;
6968 break;
6969 }
6970 }
6971 if (exists) break;
6972 }
6973 }
6974 if (!exists) jj_expentries.addElement(jj_expentry);
6975 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
6976 }
6977 }
6978
6979 public ParseException generateParseException() {
6980 jj_expentries.removeAllElements();
6981 boolean[] la1tokens = new boolean[122];
6982 for (int i = 0; i < 122; i++) {
6983 la1tokens[i] = false;
6984 }
6985 if (jj_kind >= 0) {
6986 la1tokens[jj_kind] = true;
6987 jj_kind = -1;
6988 }
6989 for (int i = 0; i < 106; i++) {
6990 if (jj_la1[i] == jj_gen) {
6991 for (int j = 0; j < 32; j++) {
6992 if ((jj_la1_0[i] & (1<<j)) != 0) {
6993 la1tokens[j] = true;
6994 }
6995 if ((jj_la1_1[i] & (1<<j)) != 0) {
6996 la1tokens[32+j] = true;
6997 }
6998 if ((jj_la1_2[i] & (1<<j)) != 0) {
6999 la1tokens[64+j] = true;
7000 }
7001 if ((jj_la1_3[i] & (1<<j)) != 0) {
7002 la1tokens[96+j] = true;
7003 }
7004 }
7005 }
7006 }
7007 for (int i = 0; i < 122; i++) {
7008 if (la1tokens[i]) {
7009 jj_expentry = new int[1];
7010 jj_expentry[0] = i;
7011 jj_expentries.addElement(jj_expentry);
7012 }
7013 }
7014 jj_endpos = 0;
7015 jj_rescan_token();
7016 jj_add_error_token(0, 0);
7017 int[][] exptokseq = new int[jj_expentries.size()][];
7018 for (int i = 0; i < jj_expentries.size(); i++) {
7019 exptokseq[i] = (int[])jj_expentries.elementAt(i);
7020 }
7021 return new ParseException(token, exptokseq, tokenImage);
7022 }
7023
7024 final public void enable_tracing() {
7025 }
7026
7027 final public void disable_tracing() {
7028 }
7029
7030 final private void jj_rescan_token() {
7031 jj_rescan = true;
7032 for (int i = 0; i < 25; i++) {
7033 JJCalls p = jj_2_rtns[i];
7034 do {
7035 if (p.gen > jj_gen) {
7036 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
7037 switch (i) {
7038 case 0: jj_3_1(); break;
7039 case 1: jj_3_2(); break;
7040 case 2: jj_3_3(); break;
7041 case 3: jj_3_4(); break;
7042 case 4: jj_3_5(); break;
7043 case 5: jj_3_6(); break;
7044 case 6: jj_3_7(); break;
7045 case 7: jj_3_8(); break;
7046 case 8: jj_3_9(); break;
7047 case 9: jj_3_10(); break;
7048 case 10: jj_3_11(); break;
7049 case 11: jj_3_12(); break;
7050 case 12: jj_3_13(); break;
7051 case 13: jj_3_14(); break;
7052 case 14: jj_3_15(); break;
7053 case 15: jj_3_16(); break;
7054 case 16: jj_3_17(); break;
7055 case 17: jj_3_18(); break;
7056 case 18: jj_3_19(); break;
7057 case 19: jj_3_20(); break;
7058 case 20: jj_3_21(); break;
7059 case 21: jj_3_22(); break;
7060 case 22: jj_3_23(); break;
7061 case 23: jj_3_24(); break;
7062 case 24: jj_3_25(); break;
7063 }
7064 }
7065 p = p.next;
7066 } while (p != null);
7067 }
7068 jj_rescan = false;
7069 }
7070
7071 final private void jj_save(int index, int xla) {
7072 JJCalls p = jj_2_rtns[index];
7073 while (p.gen > jj_gen) {
7074 if (p.next == null) { p = p.next = new JJCalls(); break; }
7075 p = p.next;
7076 }
7077 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
7078 }
7079
7080 static final class JJCalls {
7081 int gen;
7082 Token first;
7083 int arg;
7084 JJCalls next;
7085 }
7086
7087}
7088 |
Popular Tags |
Java API By Example, From Geeks To Geeks.