KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > python > parser > PythonGrammar


1 /* Generated By:JJTree&JavaCC: Do not edit this line. PythonGrammar.java */
2 package org.python.parser;
3 import org.python.parser.ast.modType;
4
5 public class PythonGrammar/*@bgen(jjtree)*/implements PythonGrammarTreeConstants, PythonGrammarConstants {/*@bgen(jjtree)*/
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 JavaDoc makeInt(String JavaDoc 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 JavaDoc(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 JavaDoc(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 JavaDoc(s, radix));
33         }
34         return hostLiteralMkr.newInteger((int) l);
35     }
36
37     Object JavaDoc makeFloat(String JavaDoc s) {
38         return hostLiteralMkr.newFloat(Double.valueOf(s).doubleValue());
39     }
40
41     Object JavaDoc makeLong(String JavaDoc s) {
42         return hostLiteralMkr.newLong(s);
43     }
44
45     Object JavaDoc makeComplex(String JavaDoc s) {
46         s = s.substring(0, s.length() - 1);
47         return hostLiteralMkr.newImaginary(Double.valueOf(s).doubleValue());
48     }
49
50     String JavaDoc makeString(String JavaDoc s, int quotes) {
51         //System.out.println("string: "+s);
52
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 JavaDoc sb = new StringBuffer JavaDoc(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     // ! maximal currently used LOOKAHEAD is 3
74
private static final int MAX_LOOKAHEAD = 3;
75
76     public boolean partial_valid_sentence(Throwable JavaDoc t) {
77         if (t instanceof TokenMgrError) {
78            // check whether EOF condition inside multi-line string,
79
// or just after newline continuation inside a string (*NLC states)
80
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; // all tokens eaten
97

98             // or check whether remaing tokens partially fullfill lookahead
99
// expectations
100

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    // constructors taking a IParserHost impl
137

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 //single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE
151
// apparently CPython coalesces newlines, we don't
152
final public modType single_input() throws ParseException {
153                          /*@bgen(jjtree) single_input */
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 JavaDoc jjte000) {
281       if (jjtc000) {
282         jjtree.clearNodeScope(jjtn000);
283         jjtc000 = false;
284       } else {
285         jjtree.popNode();
286       }
287       if (jjte000 instanceof RuntimeException JavaDoc) {
288         {if (true) throw (RuntimeException JavaDoc)jjte000;}
289       }
290       if (jjte000 instanceof ParseException) {
291         {if (true) throw (ParseException)jjte000;}
292       }
293       {if (true) throw (Error JavaDoc)jjte000;}
294     } finally {
295       if (jjtc000) {
296         jjtree.closeNodeScope(jjtn000, true);
297         jjtreeCloseNodeScope(jjtn000);
298       }
299     }
300     throw new Error JavaDoc("Missing return statement in function");
301   }
302
303 //file_input: (NEWLINE | stmt)* ENDMARKER
304
final public modType file_input() throws ParseException {
305                        /*@bgen(jjtree) file_input */
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 JavaDoc jjte000) {
417       if (jjtc000) {
418         jjtree.clearNodeScope(jjtn000);
419         jjtc000 = false;
420       } else {
421         jjtree.popNode();
422       }
423       if (jjte000 instanceof RuntimeException JavaDoc) {
424         {if (true) throw (RuntimeException JavaDoc)jjte000;}
425       }
426       if (jjte000 instanceof ParseException) {
427         {if (true) throw (ParseException)jjte000;}
428       }
429       {if (true) throw (Error JavaDoc)jjte000;}
430     } finally {
431       if (jjtc000) {
432         jjtree.closeNodeScope(jjtn000, true);
433         jjtreeCloseNodeScope(jjtn000);
434       }
435     }
436     throw new Error JavaDoc("Missing return statement in function");
437   }
438
439 //eval_input: NEWLINE* testlist NEWLINE* ENDMARKER
440
final public modType eval_input() throws ParseException {
441                        /*@bgen(jjtree) eval_input */
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 JavaDoc jjte000) {
478       if (jjtc000) {
479         jjtree.clearNodeScope(jjtn000);
480         jjtc000 = false;
481       } else {
482         jjtree.popNode();
483       }
484       if (jjte000 instanceof RuntimeException JavaDoc) {
485         {if (true) throw (RuntimeException JavaDoc)jjte000;}
486       }
487       if (jjte000 instanceof ParseException) {
488         {if (true) throw (ParseException)jjte000;}
489       }
490       {if (true) throw (Error JavaDoc)jjte000;}
491     } finally {
492       if (jjtc000) {
493         jjtree.closeNodeScope(jjtn000, true);
494         jjtreeCloseNodeScope(jjtn000);
495       }
496     }
497     throw new Error JavaDoc("Missing return statement in function");
498   }
499
500 //funcdef: 'def' NAME parameters ':' suite
501
final public void funcdef() throws ParseException {
502                  /*@bgen(jjtree) funcdef */
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 JavaDoc jjte000) {
514     if (jjtc000) {
515       jjtree.clearNodeScope(jjtn000);
516       jjtc000 = false;
517     } else {
518       jjtree.popNode();
519     }
520     if (jjte000 instanceof RuntimeException JavaDoc) {
521       {if (true) throw (RuntimeException JavaDoc)jjte000;}
522     }
523     if (jjte000 instanceof ParseException) {
524       {if (true) throw (ParseException)jjte000;}
525     }
526     {if (true) throw (Error JavaDoc)jjte000;}
527     } finally {
528     if (jjtc000) {
529       jjtree.closeNodeScope(jjtn000, true);
530       jjtreeCloseNodeScope(jjtn000);
531     }
532     }
533   }
534
535 //parameters: '(' [varargslist] ')'
536
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 //varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' ('**'|'*' '*') NAME] | ('**'|'*' '*') NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [',']
554
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                       /*@bgen(jjtree) ExtraArgList */
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 JavaDoc jjte000) {
634     if (jjtc000) {
635       jjtree.clearNodeScope(jjtn000);
636       jjtc000 = false;
637     } else {
638       jjtree.popNode();
639     }
640     if (jjte000 instanceof RuntimeException JavaDoc) {
641       {if (true) throw (RuntimeException JavaDoc)jjte000;}
642     }
643     if (jjte000 instanceof ParseException) {
644       {if (true) throw (ParseException)jjte000;}
645     }
646     {if (true) throw (Error JavaDoc)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                           /*@bgen(jjtree) ExtraKeywordList */
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 JavaDoc jjte000) {
677     if (jjtc000) {
678       jjtree.clearNodeScope(jjtn000);
679       jjtc000 = false;
680     } else {
681       jjtree.popNode();
682     }
683     if (jjte000 instanceof RuntimeException JavaDoc) {
684       {if (true) throw (RuntimeException JavaDoc)jjte000;}
685     }
686     if (jjte000 instanceof ParseException) {
687       {if (true) throw (ParseException)jjte000;}
688     }
689     {if (true) throw (Error JavaDoc)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                     /*@bgen(jjtree) defaultarg */
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 JavaDoc jjte000) {
716     if (jjtc000) {
717       jjtree.clearNodeScope(jjtn000);
718       jjtc000 = false;
719     } else {
720       jjtree.popNode();
721     }
722     if (jjte000 instanceof RuntimeException JavaDoc) {
723       {if (true) throw (RuntimeException JavaDoc)jjte000;}
724     }
725     if (jjte000 instanceof ParseException) {
726       {if (true) throw (ParseException)jjte000;}
727     }
728     {if (true) throw (Error JavaDoc)jjte000;}
729     } finally {
730     if (jjtc000) {
731       jjtree.closeNodeScope(jjtn000, true);
732       jjtreeCloseNodeScope(jjtn000);
733     }
734     }
735   }
736
737 //fpdef: NAME | '(' fplist ')'
738
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 //fplist: fpdef (',' fpdef)* [',']
757
final public void fplist() throws ParseException {
758                        /*@bgen(jjtree) tuple */
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 JavaDoc jjte000) {
784     if (jjtc000) {
785       jjtree.clearNodeScope(jjtn000);
786       jjtc000 = false;
787     } else {
788       jjtree.popNode();
789     }
790     if (jjte000 instanceof RuntimeException JavaDoc) {
791       {if (true) throw (RuntimeException JavaDoc)jjte000;}
792     }
793     if (jjte000 instanceof ParseException) {
794       {if (true) throw (ParseException)jjte000;}
795     }
796     {if (true) throw (Error JavaDoc)jjte000;}
797     } finally {
798     if (jjtc000) {
799       jjtree.closeNodeScope(jjtn000, true);
800       jjtreeCloseNodeScope(jjtn000);
801     }
802     }
803   }
804
805 //stmt: simple_stmt | compound_stmt
806
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 //simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
859
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 //small_stmt: expr_stmt | print_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt
883
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 //expr_stmt: testlist (augassign testlist | ('=' testlist)*)
944
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 JavaDoc jjte001) {
956                if (jjtc001) {
957                  jjtree.clearNodeScope(jjtn001);
958                  jjtc001 = false;
959                } else {
960                  jjtree.popNode();
961                }
962                if (jjte001 instanceof RuntimeException JavaDoc) {
963                  {if (true) throw (RuntimeException JavaDoc)jjte001;}
964                }
965                if (jjte001 instanceof ParseException) {
966                  {if (true) throw (ParseException)jjte001;}
967                }
968                {if (true) throw (Error JavaDoc)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 JavaDoc jjte002) {
985                 if (jjtc002) {
986                   jjtree.clearNodeScope(jjtn002);
987                   jjtc002 = false;
988                 } else {
989                   jjtree.popNode();
990                 }
991                 if (jjte002 instanceof RuntimeException JavaDoc) {
992                   {if (true) throw (RuntimeException JavaDoc)jjte002;}
993                 }
994                 if (jjte002 instanceof ParseException) {
995                   {if (true) throw (ParseException)jjte002;}
996                 }
997                 {if (true) throw (Error JavaDoc)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 JavaDoc jjte003) {
1014                   if (jjtc003) {
1015                     jjtree.clearNodeScope(jjtn003);
1016                     jjtc003 = false;
1017                   } else {
1018                     jjtree.popNode();
1019                   }
1020                   if (jjte003 instanceof RuntimeException JavaDoc) {
1021                     {if (true) throw (RuntimeException JavaDoc)jjte003;}
1022                   }
1023                   if (jjte003 instanceof ParseException) {
1024                     {if (true) throw (ParseException)jjte003;}
1025                   }
1026                   {if (true) throw (Error JavaDoc)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 JavaDoc jjte004) {
1043                 if (jjtc004) {
1044                   jjtree.clearNodeScope(jjtn004);
1045                   jjtc004 = false;
1046                 } else {
1047                   jjtree.popNode();
1048                 }
1049                 if (jjte004 instanceof RuntimeException JavaDoc) {
1050                   {if (true) throw (RuntimeException JavaDoc)jjte004;}
1051                 }
1052                 if (jjte004 instanceof ParseException) {
1053                   {if (true) throw (ParseException)jjte004;}
1054                 }
1055                 {if (true) throw (Error JavaDoc)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 JavaDoc jjte005) {
1072                      if (jjtc005) {
1073                        jjtree.clearNodeScope(jjtn005);
1074                        jjtc005 = false;
1075                      } else {
1076                        jjtree.popNode();
1077                      }
1078                      if (jjte005 instanceof RuntimeException JavaDoc) {
1079                        {if (true) throw (RuntimeException JavaDoc)jjte005;}
1080                      }
1081                      if (jjte005 instanceof ParseException) {
1082                        {if (true) throw (ParseException)jjte005;}
1083                      }
1084                      {if (true) throw (Error JavaDoc)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 JavaDoc jjte006) {
1101                 if (jjtc006) {
1102                   jjtree.clearNodeScope(jjtn006);
1103                   jjtc006 = false;
1104                 } else {
1105                   jjtree.popNode();
1106                 }
1107                 if (jjte006 instanceof RuntimeException JavaDoc) {
1108                   {if (true) throw (RuntimeException JavaDoc)jjte006;}
1109                 }
1110                 if (jjte006 instanceof ParseException) {
1111                   {if (true) throw (ParseException)jjte006;}
1112                 }
1113                 {if (true) throw (Error JavaDoc)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 JavaDoc jjte007) {
1130              if (jjtc007) {
1131                jjtree.clearNodeScope(jjtn007);
1132                jjtc007 = false;
1133              } else {
1134                jjtree.popNode();
1135              }
1136              if (jjte007 instanceof RuntimeException JavaDoc) {
1137                {if (true) throw (RuntimeException JavaDoc)jjte007;}
1138              }
1139              if (jjte007 instanceof ParseException) {
1140                {if (true) throw (ParseException)jjte007;}
1141              }
1142              {if (true) throw (Error JavaDoc)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 JavaDoc jjte008) {
1159             if (jjtc008) {
1160               jjtree.clearNodeScope(jjtn008);
1161               jjtc008 = false;
1162             } else {
1163               jjtree.popNode();
1164             }
1165             if (jjte008 instanceof RuntimeException JavaDoc) {
1166               {if (true) throw (RuntimeException JavaDoc)jjte008;}
1167             }
1168             if (jjte008 instanceof ParseException) {
1169               {if (true) throw (ParseException)jjte008;}
1170             }
1171             {if (true) throw (Error JavaDoc)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 JavaDoc jjte009) {
1188              if (jjtc009) {
1189                jjtree.clearNodeScope(jjtn009);
1190                jjtc009 = false;
1191              } else {
1192                jjtree.popNode();
1193              }
1194              if (jjte009 instanceof RuntimeException JavaDoc) {
1195                {if (true) throw (RuntimeException JavaDoc)jjte009;}
1196              }
1197              if (jjte009 instanceof ParseException) {
1198                {if (true) throw (ParseException)jjte009;}
1199              }
1200              {if (true) throw (Error JavaDoc)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 JavaDoc jjte010) {
1217                 if (jjtc010) {
1218                   jjtree.clearNodeScope(jjtn010);
1219                   jjtc010 = false;
1220                 } else {
1221                   jjtree.popNode();
1222                 }
1223                 if (jjte010 instanceof RuntimeException JavaDoc) {
1224                   {if (true) throw (RuntimeException JavaDoc)jjte010;}
1225                 }
1226                 if (jjte010 instanceof ParseException) {
1227                   {if (true) throw (ParseException)jjte010;}
1228                 }
1229                 {if (true) throw (Error JavaDoc)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 JavaDoc jjte011) {
1246                 if (jjtc011) {
1247                   jjtree.clearNodeScope(jjtn011);
1248                   jjtc011 = false;
1249                 } else {
1250                   jjtree.popNode();
1251                 }
1252                 if (jjte011 instanceof RuntimeException JavaDoc) {
1253                   {if (true) throw (RuntimeException JavaDoc)jjte011;}
1254                 }
1255                 if (jjte011 instanceof ParseException) {
1256                   {if (true) throw (ParseException)jjte011;}
1257                 }
1258                 {if (true) throw (Error JavaDoc)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 JavaDoc jjte012) {
1275                if (jjtc012) {
1276                  jjtree.clearNodeScope(jjtn012);
1277                  jjtc012 = false;
1278                } else {
1279                  jjtree.popNode();
1280                }
1281                if (jjte012 instanceof RuntimeException JavaDoc) {
1282                  {if (true) throw (RuntimeException JavaDoc)jjte012;}
1283                }
1284                if (jjte012 instanceof ParseException) {
1285                  {if (true) throw (ParseException)jjte012;}
1286                }
1287                {if (true) throw (Error JavaDoc)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 JavaDoc jjte013) {
1316      if (jjtc013) {
1317        jjtree.clearNodeScope(jjtn013);
1318        jjtc013 = false;
1319      } else {
1320        jjtree.popNode();
1321      }
1322      if (jjte013 instanceof RuntimeException JavaDoc) {
1323        {if (true) throw (RuntimeException JavaDoc)jjte013;}
1324      }
1325      if (jjte013 instanceof ParseException) {
1326        {if (true) throw (ParseException)jjte013;}
1327      }
1328      {if (true) throw (Error JavaDoc)jjte013;}
1329      } finally {
1330      if (jjtc013) {
1331        jjtree.closeNodeScope(jjtn013, jjtree . nodeArity ( ) + 1);
1332        jjtreeCloseNodeScope(jjtn013);
1333      }
1334      }
1335    }
1336  }
1337
1338//print_stmt: 'print' (test ',')* [test] | 'print' '>>' test (, test)+ [,]
1339
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 JavaDoc jjte001) {
1375                                    if (jjtc001) {
1376                                      jjtree.clearNodeScope(jjtn001);
1377                                      jjtc001 = false;
1378                                    } else {
1379                                      jjtree.popNode();
1380                                    }
1381                                    if (jjte001 instanceof RuntimeException JavaDoc) {
1382                                      {if (true) throw (RuntimeException JavaDoc)jjte001;}
1383                                    }
1384                                    if (jjte001 instanceof ParseException) {
1385                                      {if (true) throw (ParseException)jjte001;}
1386                                    }
1387                                    {if (true) throw (Error JavaDoc)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 JavaDoc jjte002) {
1421                           if (jjtc002) {
1422                             jjtree.clearNodeScope(jjtn002);
1423                             jjtc002 = false;
1424                           } else {
1425                             jjtree.popNode();
1426                           }
1427                           if (jjte002 instanceof RuntimeException JavaDoc) {
1428                             {if (true) throw (RuntimeException JavaDoc)jjte002;}
1429                           }
1430                           if (jjte002 instanceof ParseException) {
1431                             {if (true) throw (ParseException)jjte002;}
1432                           }
1433                           {if (true) throw (Error JavaDoc)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//del_stmt: 'del' exprlist
1465
final public void del_stmt() throws ParseException {
1466                  /*@bgen(jjtree) del_stmt */
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 JavaDoc jjte000) {
1475    if (jjtc000) {
1476      jjtree.clearNodeScope(jjtn000);
1477      jjtc000 = false;
1478    } else {
1479      jjtree.popNode();
1480    }
1481    if (jjte000 instanceof RuntimeException JavaDoc) {
1482      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1483    }
1484    if (jjte000 instanceof ParseException) {
1485      {if (true) throw (ParseException)jjte000;}
1486    }
1487    {if (true) throw (Error JavaDoc)jjte000;}
1488    } finally {
1489    if (jjtc000) {
1490      jjtree.closeNodeScope(jjtn000, true);
1491      jjtreeCloseNodeScope(jjtn000);
1492    }
1493    }
1494  }
1495
1496//pass_stmt: 'pass'
1497
final public void pass_stmt() throws ParseException {
1498                   /*@bgen(jjtree) pass_stmt */
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//flow_stmt: break_stmt | continue_stmt | return_stmt | yield_stmt | raise_stmt
1514
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//return_stmt: 'return' [testlist]
1561
final public void return_stmt() throws ParseException {
1562                     /*@bgen(jjtree) return_stmt */
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 JavaDoc jjte000) {
1597    if (jjtc000) {
1598      jjtree.clearNodeScope(jjtn000);
1599      jjtc000 = false;
1600    } else {
1601      jjtree.popNode();
1602    }
1603    if (jjte000 instanceof RuntimeException JavaDoc) {
1604      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1605    }
1606    if (jjte000 instanceof ParseException) {
1607      {if (true) throw (ParseException)jjte000;}
1608    }
1609    {if (true) throw (Error JavaDoc)jjte000;}
1610    } finally {
1611    if (jjtc000) {
1612      jjtree.closeNodeScope(jjtn000, true);
1613      jjtreeCloseNodeScope(jjtn000);
1614    }
1615    }
1616  }
1617
1618//yield_stmt: 'yield' [testlist]
1619
final public void yield_stmt() throws ParseException {
1620                    /*@bgen(jjtree) yield_stmt */
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 JavaDoc jjte000) {
1629    if (jjtc000) {
1630      jjtree.clearNodeScope(jjtn000);
1631      jjtc000 = false;
1632    } else {
1633      jjtree.popNode();
1634    }
1635    if (jjte000 instanceof RuntimeException JavaDoc) {
1636      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1637    }
1638    if (jjte000 instanceof ParseException) {
1639      {if (true) throw (ParseException)jjte000;}
1640    }
1641    {if (true) throw (Error JavaDoc)jjte000;}
1642    } finally {
1643    if (jjtc000) {
1644      jjtree.closeNodeScope(jjtn000, true);
1645      jjtreeCloseNodeScope(jjtn000);
1646    }
1647    }
1648  }
1649
1650//raise_stmt: 'raise' [test [',' test [',' test]]]
1651
final public void raise_stmt() throws ParseException {
1652                    /*@bgen(jjtree) raise_stmt */
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 JavaDoc jjte000) {
1705    if (jjtc000) {
1706      jjtree.clearNodeScope(jjtn000);
1707      jjtc000 = false;
1708    } else {
1709      jjtree.popNode();
1710    }
1711    if (jjte000 instanceof RuntimeException JavaDoc) {
1712      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1713    }
1714    if (jjte000 instanceof ParseException) {
1715      {if (true) throw (ParseException)jjte000;}
1716    }
1717    {if (true) throw (Error JavaDoc)jjte000;}
1718    } finally {
1719    if (jjtc000) {
1720      jjtree.closeNodeScope(jjtn000, true);
1721      jjtreeCloseNodeScope(jjtn000);
1722    }
1723    }
1724  }
1725
1726//import_stmt: 'import' dotted_name (',' dotted_name)* | 'from' dotted_name 'import' ('*' | NAME (',' NAME)*)
1727
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                /*@bgen(jjtree) Import */
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 JavaDoc jjte000) {
1766    if (jjtc000) {
1767      jjtree.clearNodeScope(jjtn000);
1768      jjtc000 = false;
1769    } else {
1770      jjtree.popNode();
1771    }
1772    if (jjte000 instanceof RuntimeException JavaDoc) {
1773      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1774    }
1775    if (jjte000 instanceof ParseException) {
1776      {if (true) throw (ParseException)jjte000;}
1777    }
1778    {if (true) throw (Error JavaDoc)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                    /*@bgen(jjtree) ImportFrom */
1789                     SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIMPORTFROM);
1790                     boolean jjtc000 = true;
1791                     jjtree.openNodeScope(jjtn000);
1792                     jjtreeOpenNodeScope(jjtn000);String JavaDoc mod; String JavaDoc 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 JavaDoc jjte000) {
1857      if (jjtc000) {
1858        jjtree.clearNodeScope(jjtn000);
1859        jjtc000 = false;
1860      } else {
1861        jjtree.popNode();
1862      }
1863      if (jjte000 instanceof RuntimeException JavaDoc) {
1864        {if (true) throw (RuntimeException JavaDoc)jjte000;}
1865      }
1866      if (jjte000 instanceof ParseException) {
1867        {if (true) throw (ParseException)jjte000;}
1868      }
1869      {if (true) throw (Error JavaDoc)jjte000;}
1870    } finally {
1871      if (jjtc000) {
1872        jjtree.closeNodeScope(jjtn000, true);
1873        jjtreeCloseNodeScope(jjtn000);
1874      }
1875    }
1876  }
1877
1878//dotted_as_name: dotted_name [NAME NAME]
1879
final public void dotted_as_name() throws ParseException {
1880                        /*@bgen(jjtree) dotted_as_name */
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 JavaDoc jjte000) {
1897    if (jjtc000) {
1898      jjtree.clearNodeScope(jjtn000);
1899      jjtc000 = false;
1900    } else {
1901      jjtree.popNode();
1902    }
1903    if (jjte000 instanceof RuntimeException JavaDoc) {
1904      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1905    }
1906    if (jjte000 instanceof ParseException) {
1907      {if (true) throw (ParseException)jjte000;}
1908    }
1909    {if (true) throw (Error JavaDoc)jjte000;}
1910    } finally {
1911    if (jjtc000) {
1912      jjtree.closeNodeScope(jjtn000, true);
1913      jjtreeCloseNodeScope(jjtn000);
1914    }
1915    }
1916  }
1917
1918//dotted_name: NAME ('.' NAME)*
1919
final public String JavaDoc dotted_name() throws ParseException {
1920                       /*@bgen(jjtree) dotted_name */
1921                        SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTDOTTED_NAME);
1922                        boolean jjtc000 = true;
1923                        jjtree.openNodeScope(jjtn000);
1924                        jjtreeOpenNodeScope(jjtn000);Token t; StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
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 JavaDoc jjte000) {
1947    if (jjtc000) {
1948      jjtree.clearNodeScope(jjtn000);
1949      jjtc000 = false;
1950    } else {
1951      jjtree.popNode();
1952    }
1953    if (jjte000 instanceof RuntimeException JavaDoc) {
1954      {if (true) throw (RuntimeException JavaDoc)jjte000;}
1955    }
1956    if (jjte000 instanceof ParseException) {
1957      {if (true) throw (ParseException)jjte000;}
1958    }
1959    {if (true) throw (Error JavaDoc)jjte000;}
1960    } finally {
1961    if (jjtc000) {
1962      jjtree.closeNodeScope(jjtn000, true);
1963      jjtreeCloseNodeScope(jjtn000);
1964    }
1965    }
1966    throw new Error JavaDoc("Missing return statement in function");
1967  }
1968
1969//import_as_name: NAME [NAME NAME]
1970
final public String JavaDoc import_as_name() throws ParseException {
1971                          /*@bgen(jjtree) import_as_name */
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 JavaDoc jjte000) {
1992    if (jjtc000) {
1993      jjtree.clearNodeScope(jjtn000);
1994      jjtc000 = false;
1995    } else {
1996      jjtree.popNode();
1997    }
1998    if (jjte000 instanceof RuntimeException JavaDoc) {
1999      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2000    }
2001    if (jjte000 instanceof ParseException) {
2002      {if (true) throw (ParseException)jjte000;}
2003    }
2004    {if (true) throw (Error JavaDoc)jjte000;}
2005    } finally {
2006    if (jjtc000) {
2007      jjtree.closeNodeScope(jjtn000, true);
2008      jjtreeCloseNodeScope(jjtn000);
2009    }
2010    }
2011    throw new Error JavaDoc("Missing return statement in function");
2012  }
2013
2014//global_stmt: 'global' NAME (',' NAME)*
2015
final public void global_stmt() throws ParseException {
2016                     /*@bgen(jjtree) global_stmt */
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 JavaDoc jjte000) {
2038    if (jjtc000) {
2039      jjtree.clearNodeScope(jjtn000);
2040      jjtc000 = false;
2041    } else {
2042      jjtree.popNode();
2043    }
2044    if (jjte000 instanceof RuntimeException JavaDoc) {
2045      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2046    }
2047    if (jjte000 instanceof ParseException) {
2048      {if (true) throw (ParseException)jjte000;}
2049    }
2050    {if (true) throw (Error JavaDoc)jjte000;}
2051    } finally {
2052    if (jjtc000) {
2053      jjtree.closeNodeScope(jjtn000, true);
2054      jjtreeCloseNodeScope(jjtn000);
2055    }
2056    }
2057  }
2058
2059//exec_stmt: 'exec' expr ['in' test [',' test]]
2060
final public void exec_stmt() throws ParseException {
2061                   /*@bgen(jjtree) exec_stmt */
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 JavaDoc jjte000) {
2088    if (jjtc000) {
2089      jjtree.clearNodeScope(jjtn000);
2090      jjtc000 = false;
2091    } else {
2092      jjtree.popNode();
2093    }
2094    if (jjte000 instanceof RuntimeException JavaDoc) {
2095      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2096    }
2097    if (jjte000 instanceof ParseException) {
2098      {if (true) throw (ParseException)jjte000;}
2099    }
2100    {if (true) throw (Error JavaDoc)jjte000;}
2101    } finally {
2102    if (jjtc000) {
2103      jjtree.closeNodeScope(jjtn000, true);
2104      jjtreeCloseNodeScope(jjtn000);
2105    }
2106    }
2107  }
2108
2109//assert_stmt: 'assert' test [',' test]
2110
final public void assert_stmt() throws ParseException {
2111                     /*@bgen(jjtree) assert_stmt */
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 JavaDoc jjte000) {
2129    if (jjtc000) {
2130      jjtree.clearNodeScope(jjtn000);
2131      jjtc000 = false;
2132    } else {
2133      jjtree.popNode();
2134    }
2135    if (jjte000 instanceof RuntimeException JavaDoc) {
2136      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2137    }
2138    if (jjte000 instanceof ParseException) {
2139      {if (true) throw (ParseException)jjte000;}
2140    }
2141    {if (true) throw (Error JavaDoc)jjte000;}
2142    } finally {
2143    if (jjtc000) {
2144      jjtree.closeNodeScope(jjtn000, true);
2145      jjtreeCloseNodeScope(jjtn000);
2146    }
2147    }
2148  }
2149
2150//compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef
2151
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//if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
2180
final public void if_stmt() throws ParseException {
2181                 /*@bgen(jjtree) if_stmt */
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 JavaDoc jjte000) {
2217      if (jjtc000) {
2218        jjtree.clearNodeScope(jjtn000);
2219        jjtc000 = false;
2220      } else {
2221        jjtree.popNode();
2222      }
2223      if (jjte000 instanceof RuntimeException JavaDoc) {
2224        {if (true) throw (RuntimeException JavaDoc)jjte000;}
2225      }
2226      if (jjte000 instanceof ParseException) {
2227        {if (true) throw (ParseException)jjte000;}
2228      }
2229      {if (true) throw (Error JavaDoc)jjte000;}
2230    } finally {
2231      if (jjtc000) {
2232        jjtree.closeNodeScope(jjtn000, true);
2233        jjtreeCloseNodeScope(jjtn000);
2234      }
2235    }
2236  }
2237
2238//while_stmt: 'while' test ':' suite ['else' ':' suite]
2239
final public void while_stmt() throws ParseException {
2240                    /*@bgen(jjtree) while_stmt */
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 JavaDoc jjte000) {
2261    if (jjtc000) {
2262      jjtree.clearNodeScope(jjtn000);
2263      jjtc000 = false;
2264    } else {
2265      jjtree.popNode();
2266    }
2267    if (jjte000 instanceof RuntimeException JavaDoc) {
2268      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2269    }
2270    if (jjte000 instanceof ParseException) {
2271      {if (true) throw (ParseException)jjte000;}
2272    }
2273    {if (true) throw (Error JavaDoc)jjte000;}
2274    } finally {
2275    if (jjtc000) {
2276      jjtree.closeNodeScope(jjtn000, true);
2277      jjtreeCloseNodeScope(jjtn000);
2278    }
2279    }
2280  }
2281
2282//for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
2283
final public void for_stmt() throws ParseException {
2284                  /*@bgen(jjtree) for_stmt */
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 JavaDoc jjte000) {
2307    if (jjtc000) {
2308      jjtree.clearNodeScope(jjtn000);
2309      jjtc000 = false;
2310    } else {
2311      jjtree.popNode();
2312    }
2313    if (jjte000 instanceof RuntimeException JavaDoc) {
2314      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2315    }
2316    if (jjte000 instanceof ParseException) {
2317      {if (true) throw (ParseException)jjte000;}
2318    }
2319    {if (true) throw (Error JavaDoc)jjte000;}
2320    } finally {
2321    if (jjtc000) {
2322      jjtree.closeNodeScope(jjtn000, true);
2323      jjtreeCloseNodeScope(jjtn000);
2324    }
2325    }
2326  }
2327
2328//try_stmt: ('try' ':' suite (except_clause ':' suite)+ #diagram:break
2329
// ['else' ':' suite] | 'try' ':' suite 'finally' ':' suite)
2330
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 JavaDoc jjte001) {
2364      if (jjtc001) {
2365        jjtree.clearNodeScope(jjtn001);
2366        jjtc001 = false;
2367      } else {
2368        jjtree.popNode();
2369      }
2370      if (jjte001 instanceof RuntimeException JavaDoc) {
2371        {if (true) throw (RuntimeException JavaDoc)jjte001;}
2372      }
2373      if (jjte001 instanceof ParseException) {
2374        {if (true) throw (ParseException)jjte001;}
2375      }
2376      {if (true) throw (Error JavaDoc)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 JavaDoc jjte002) {
2394                          if (jjtc002) {
2395                            jjtree.clearNodeScope(jjtn002);
2396                            jjtc002 = false;
2397                          } else {
2398                            jjtree.popNode();
2399                          }
2400                          if (jjte002 instanceof RuntimeException JavaDoc) {
2401                            {if (true) throw (RuntimeException JavaDoc)jjte002;}
2402                          }
2403                          if (jjte002 instanceof ParseException) {
2404                            {if (true) throw (ParseException)jjte002;}
2405                          }
2406                          {if (true) throw (Error JavaDoc)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//except_clause: 'except' [test [',' test]]
2422
final public void except_clause() throws ParseException {
2423                       /*@bgen(jjtree) except_clause */
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 JavaDoc jjte000) {
2469    if (jjtc000) {
2470      jjtree.clearNodeScope(jjtn000);
2471      jjtc000 = false;
2472    } else {
2473      jjtree.popNode();
2474    }
2475    if (jjte000 instanceof RuntimeException JavaDoc) {
2476      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2477    }
2478    if (jjte000 instanceof ParseException) {
2479      {if (true) throw (ParseException)jjte000;}
2480    }
2481    {if (true) throw (Error JavaDoc)jjte000;}
2482    } finally {
2483    if (jjtc000) {
2484      jjtree.closeNodeScope(jjtn000, true);
2485      jjtreeCloseNodeScope(jjtn000);
2486    }
2487    }
2488  }
2489
2490//suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
2491
final public void suite() throws ParseException {
2492               /*@bgen(jjtree) suite */
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 JavaDoc jjte000) {
2597    if (jjtc000) {
2598      jjtree.clearNodeScope(jjtn000);
2599      jjtc000 = false;
2600    } else {
2601      jjtree.popNode();
2602    }
2603    if (jjte000 instanceof RuntimeException JavaDoc) {
2604      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2605    }
2606    if (jjte000 instanceof ParseException) {
2607      {if (true) throw (ParseException)jjte000;}
2608    }
2609    {if (true) throw (Error JavaDoc)jjte000;}
2610    } finally {
2611    if (jjtc000) {
2612      jjtree.closeNodeScope(jjtn000, true);
2613      jjtreeCloseNodeScope(jjtn000);
2614    }
2615    }
2616  }
2617
2618//test: and_test ('or' and_test)* | lambdef
2619
final public void test() throws ParseException {
2620                              /*@bgen(jjtree) #or_boolean(> 1) */
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 JavaDoc jjte000) {
2670    if (jjtc000) {
2671      jjtree.clearNodeScope(jjtn000);
2672      jjtc000 = false;
2673    } else {
2674      jjtree.popNode();
2675    }
2676    if (jjte000 instanceof RuntimeException JavaDoc) {
2677      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2678    }
2679    if (jjte000 instanceof ParseException) {
2680      {if (true) throw (ParseException)jjte000;}
2681    }
2682    {if (true) throw (Error JavaDoc)jjte000;}
2683    } finally {
2684    if (jjtc000) {
2685      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2686      jjtreeCloseNodeScope(jjtn000);
2687    }
2688    }
2689  }
2690
2691//and_test: not_test ('and' not_test)*
2692
final public void and_test() throws ParseException {
2693                                   /*@bgen(jjtree) #and_boolean(> 1) */
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 JavaDoc jjte000) {
2714    if (jjtc000) {
2715      jjtree.clearNodeScope(jjtn000);
2716      jjtc000 = false;
2717    } else {
2718      jjtree.popNode();
2719    }
2720    if (jjte000 instanceof RuntimeException JavaDoc) {
2721      {if (true) throw (RuntimeException JavaDoc)jjte000;}
2722    }
2723    if (jjte000 instanceof ParseException) {
2724      {if (true) throw (ParseException)jjte000;}
2725    }
2726    {if (true) throw (Error JavaDoc)jjte000;}
2727    } finally {
2728    if (jjtc000) {
2729      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2730      jjtreeCloseNodeScope(jjtn000);
2731    }
2732    }
2733  }
2734
2735//not_test: 'not' not_test | comparison
2736
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 JavaDoc jjte001) {
2747               if (jjtc001) {
2748                 jjtree.clearNodeScope(jjtn001);
2749                 jjtc001 = false;
2750               } else {
2751                 jjtree.popNode();
2752               }
2753               if (jjte001 instanceof RuntimeException JavaDoc) {
2754                 {if (true) throw (RuntimeException JavaDoc)jjte001;}
2755               }
2756               if (jjte001 instanceof ParseException) {
2757                 {if (true) throw (ParseException)jjte001;}
2758               }
2759               {if (true) throw (Error JavaDoc)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//comparison: expr (comp_op expr)*
2795
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 JavaDoc jjte001) {
2825    if (jjtc001) {
2826      jjtree.clearNodeScope(jjtn001);
2827      jjtc001 = false;
2828    } else {
2829      jjtree.popNode();
2830    }
2831    if (jjte001 instanceof RuntimeException JavaDoc) {
2832      {if (true) throw (RuntimeException JavaDoc)jjte001;}
2833    }
2834    if (jjte001 instanceof ParseException) {
2835      {if (true) throw (ParseException)jjte001;}
2836    }
2837    {if (true) throw (Error JavaDoc)jjte001;}
2838    } finally {
2839    if (jjtc001) {
2840      jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
2841      jjtreeCloseNodeScope(jjtn001);
2842    }
2843    }
2844  }
2845
2846//comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
2847
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//expr: xor_expr ('|' xor_expr)*
3018
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 JavaDoc jjte001) {
3038                     if (jjtc001) {
3039                       jjtree.clearNodeScope(jjtn001);
3040                       jjtc001 = false;
3041                     } else {
3042                       jjtree.popNode();
3043                     }
3044                     if (jjte001 instanceof RuntimeException JavaDoc) {
3045                       {if (true) throw (RuntimeException JavaDoc)jjte001;}
3046                     }
3047                     if (jjte001 instanceof ParseException) {
3048                       {if (true) throw (ParseException)jjte001;}
3049                     }
3050                     {if (true) throw (Error JavaDoc)jjte001;}
3051      } finally {
3052                     if (jjtc001) {
3053                       jjtree.closeNodeScope(jjtn001, 2);
3054                       jjtreeCloseNodeScope(jjtn001);
3055                     }
3056      }
3057    }
3058  }
3059
3060//xor_expr: and_expr ('^' and_expr)*
3061
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 JavaDoc jjte001) {
3081                      if (jjtc001) {
3082                        jjtree.clearNodeScope(jjtn001);
3083                        jjtc001 = false;
3084                      } else {
3085                        jjtree.popNode();
3086                      }
3087                      if (jjte001 instanceof RuntimeException JavaDoc) {
3088                        {if (true) throw (RuntimeException JavaDoc)jjte001;}
3089                      }
3090                      if (jjte001 instanceof ParseException) {
3091                        {if (true) throw (ParseException)jjte001;}
3092                      }
3093                      {if (true) throw (Error JavaDoc)jjte001;}
3094      } finally {
3095                      if (jjtc001) {
3096                        jjtree.closeNodeScope(jjtn001, 2);
3097                        jjtreeCloseNodeScope(jjtn001);
3098                      }
3099      }
3100    }
3101  }
3102
3103//and_expr: shift_expr ('&' shift_expr)*
3104
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 JavaDoc jjte001) {
3124                        if (jjtc001) {
3125                          jjtree.clearNodeScope(jjtn001);
3126                          jjtc001 = false;
3127                        } else {
3128                          jjtree.popNode();
3129                        }
3130                        if (jjte001 instanceof RuntimeException JavaDoc) {
3131                          {if (true) throw (RuntimeException JavaDoc)jjte001;}
3132                        }
3133                        if (jjte001 instanceof ParseException) {
3134                          {if (true) throw (ParseException)jjte001;}
3135                        }
3136                        {if (true) throw (Error JavaDoc)jjte001;}
3137      } finally {
3138                        if (jjtc001) {
3139                          jjtree.closeNodeScope(jjtn001, 2);
3140                          jjtreeCloseNodeScope(jjtn001);
3141                        }
3142      }
3143    }
3144  }
3145
3146//shift_expr: arith_expr (('<<'|'>>') arith_expr)*
3147
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 JavaDoc jjte001) {
3170                             if (jjtc001) {
3171                               jjtree.clearNodeScope(jjtn001);
3172                               jjtc001 = false;
3173                             } else {
3174                               jjtree.popNode();
3175                             }
3176                             if (jjte001 instanceof RuntimeException JavaDoc) {
3177                               {if (true) throw (RuntimeException JavaDoc)jjte001;}
3178                             }
3179                             if (jjte001 instanceof ParseException) {
3180                               {if (true) throw (ParseException)jjte001;}
3181                             }
3182                             {if (true) throw (Error JavaDoc)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 JavaDoc jjte002) {
3199               if (jjtc002) {
3200                 jjtree.clearNodeScope(jjtn002);
3201                 jjtc002 = false;
3202               } else {
3203                 jjtree.popNode();
3204               }
3205               if (jjte002 instanceof RuntimeException JavaDoc) {
3206                 {if (true) throw (RuntimeException JavaDoc)jjte002;}
3207               }
3208               if (jjte002 instanceof ParseException) {
3209                 {if (true) throw (ParseException)jjte002;}
3210               }
3211               {if (true) throw (Error JavaDoc)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//arith_expr: term (('+'|'-') term)*
3228
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 JavaDoc jjte001) {
3251                     if (jjtc001) {
3252                       jjtree.clearNodeScope(jjtn001);
3253                       jjtc001 = false;
3254                     } else {
3255                       jjtree.popNode();
3256                     }
3257                     if (jjte001 instanceof RuntimeException JavaDoc) {
3258                       {if (true) throw (RuntimeException JavaDoc)jjte001;}
3259                     }
3260                     if (jjte001 instanceof ParseException) {
3261                       {if (true) throw (ParseException)jjte001;}
3262                     }
3263                     {if (true) throw (Error JavaDoc)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 JavaDoc jjte002) {
3280              if (jjtc002) {
3281                jjtree.clearNodeScope(jjtn002);
3282                jjtc002 = false;
3283              } else {
3284                jjtree.popNode();
3285              }
3286              if (jjte002 instanceof RuntimeException JavaDoc) {
3287                {if (true) throw (RuntimeException JavaDoc)jjte002;}
3288              }
3289              if (jjte002 instanceof ParseException) {
3290                {if (true) throw (ParseException)jjte002;}
3291              }
3292              {if (true) throw (Error JavaDoc)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//term: factor (('*'|'/'|'%') factor)*
3309
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 JavaDoc jjte001) {
3334                             if (jjtc001) {
3335                               jjtree.clearNodeScope(jjtn001);
3336                               jjtc001 = false;
3337                             } else {
3338                               jjtree.popNode();
3339                             }
3340                             if (jjte001 instanceof RuntimeException JavaDoc) {
3341                               {if (true) throw (RuntimeException JavaDoc)jjte001;}
3342                             }
3343                             if (jjte001 instanceof ParseException) {
3344                               {if (true) throw (ParseException)jjte001;}
3345                             }
3346                             {if (true) throw (Error JavaDoc)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 JavaDoc jjte002) {
3363               if (jjtc002) {
3364                 jjtree.clearNodeScope(jjtn002);
3365                 jjtc002 = false;
3366               } else {
3367                 jjtree.popNode();
3368               }
3369               if (jjte002 instanceof RuntimeException JavaDoc) {
3370                 {if (true) throw (RuntimeException JavaDoc)jjte002;}
3371               }
3372               if (jjte002 instanceof ParseException) {
3373                 {if (true) throw (ParseException)jjte002;}
3374               }
3375               {if (true) throw (Error JavaDoc)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 JavaDoc jjte003) {
3392                    if (jjtc003) {
3393                      jjtree.clearNodeScope(jjtn003);
3394                      jjtc003 = false;
3395                    } else {
3396                      jjtree.popNode();
3397                    }
3398                    if (jjte003 instanceof RuntimeException JavaDoc) {
3399                      {if (true) throw (RuntimeException JavaDoc)jjte003;}
3400                    }
3401                    if (jjte003 instanceof ParseException) {
3402                      {if (true) throw (ParseException)jjte003;}
3403                    }
3404                    {if (true) throw (Error JavaDoc)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 JavaDoc jjte004) {
3421               if (jjtc004) {
3422                 jjtree.clearNodeScope(jjtn004);
3423                 jjtc004 = false;
3424               } else {
3425                 jjtree.popNode();
3426               }
3427               if (jjte004 instanceof RuntimeException JavaDoc) {
3428                 {if (true) throw (RuntimeException JavaDoc)jjte004;}
3429               }
3430               if (jjte004 instanceof ParseException) {
3431                 {if (true) throw (ParseException)jjte004;}
3432               }
3433               {if (true) throw (Error JavaDoc)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//factor: ('+'|'-'|'~') factor | power
3450
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 JavaDoc jjte001) {
3461             if (jjtc001) {
3462               jjtree.clearNodeScope(jjtn001);
3463               jjtc001 = false;
3464             } else {
3465               jjtree.popNode();
3466             }
3467             if (jjte001 instanceof RuntimeException JavaDoc) {
3468               {if (true) throw (RuntimeException JavaDoc)jjte001;}
3469             }
3470             if (jjte001 instanceof ParseException) {
3471               {if (true) throw (ParseException)jjte001;}
3472             }
3473             {if (true) throw (Error JavaDoc)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 JavaDoc jjte002) {
3490              if (jjtc002) {
3491                jjtree.clearNodeScope(jjtn002);
3492                jjtc002 = false;
3493              } else {
3494                jjtree.popNode();
3495              }
3496              if (jjte002 instanceof RuntimeException JavaDoc) {
3497                {if (true) throw (RuntimeException JavaDoc)jjte002;}
3498              }
3499              if (jjte002 instanceof ParseException) {
3500                {if (true) throw (ParseException)jjte002;}
3501              }
3502              {if (true) throw (Error JavaDoc)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 JavaDoc jjte003) {
3519            if (jjtc003) {
3520              jjtree.clearNodeScope(jjtn003);
3521              jjtc003 = false;
3522            } else {
3523              jjtree.popNode();
3524            }
3525            if (jjte003 instanceof RuntimeException JavaDoc) {
3526              {if (true) throw (RuntimeException JavaDoc)jjte003;}
3527            }
3528            if (jjte003 instanceof ParseException) {
3529              {if (true) throw (ParseException)jjte003;}
3530            }
3531            {if (true) throw (Error JavaDoc)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  /*Modified, no recursion*/
3564
3565//power: atom trailer* ('**' factor)*
3566
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 JavaDoc jjte001) {
3583                                        if (jjtc001) {
3584                                          jjtree.clearNodeScope(jjtn001);
3585                                          jjtc001 = false;
3586                                        } else {
3587                                          jjtree.popNode();
3588                                        }
3589                                        if (jjte001 instanceof RuntimeException JavaDoc) {
3590                                          {if (true) throw (RuntimeException JavaDoc)jjte001;}
3591                                        }
3592                                        if (jjte001 instanceof ParseException) {
3593                                          {if (true) throw (ParseException)jjte001;}
3594                                        }
3595                                        {if (true) throw (Error JavaDoc)jjte001;}
3596      } finally {
3597                                        if (jjtc001) {
3598                                          jjtree.closeNodeScope(jjtn001, 2);
3599                                          jjtreeCloseNodeScope(jjtn001);
3600                                        }
3601      }
3602    }
3603  }
3604
3605//trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
3606
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 JavaDoc jjte002) {
3646      if (jjtc002) {
3647        jjtree.clearNodeScope(jjtn002);
3648        jjtc002 = false;
3649      } else {
3650        jjtree.popNode();
3651      }
3652      if (jjte002 instanceof RuntimeException JavaDoc) {
3653        {if (true) throw (RuntimeException JavaDoc)jjte002;}
3654      }
3655      if (jjte002 instanceof ParseException) {
3656        {if (true) throw (ParseException)jjte002;}
3657      }
3658      {if (true) throw (Error JavaDoc)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 JavaDoc jjte004) {
3691            if (jjtc004) {
3692              jjtree.clearNodeScope(jjtn004);
3693              jjtc004 = false;
3694            } else {
3695              jjtree.popNode();
3696            }
3697            if (jjte004 instanceof RuntimeException JavaDoc) {
3698              {if (true) throw (RuntimeException JavaDoc)jjte004;}
3699            }
3700            if (jjte004 instanceof ParseException) {
3701              {if (true) throw (ParseException)jjte004;}
3702            }
3703            {if (true) throw (Error JavaDoc)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//atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+
3721
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 JavaDoc jjte002) {
3805      if (jjtc002) {
3806        jjtree.clearNodeScope(jjtn002);
3807        jjtc002 = false;
3808      } else {
3809        jjtree.popNode();
3810      }
3811      if (jjte002 instanceof RuntimeException JavaDoc) {
3812        {if (true) throw (RuntimeException JavaDoc)jjte002;}
3813      }
3814      if (jjte002 instanceof ParseException) {
3815        {if (true) throw (ParseException)jjte002;}
3816      }
3817      {if (true) throw (Error JavaDoc)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 JavaDoc jjte003) {
3861      if (jjtc003) {
3862        jjtree.clearNodeScope(jjtn003);
3863        jjtc003 = false;
3864      } else {
3865        jjtree.popNode();
3866      }
3867      if (jjte003 instanceof RuntimeException JavaDoc) {
3868        {if (true) throw (RuntimeException JavaDoc)jjte003;}
3869      }
3870      if (jjte003 instanceof ParseException) {
3871        {if (true) throw (ParseException)jjte003;}
3872      }
3873      {if (true) throw (Error JavaDoc)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 JavaDoc jjte005) {
3933                if (jjtc005) {
3934                  jjtree.clearNodeScope(jjtn005);
3935                  jjtc005 = false;
3936                } else {
3937                  jjtree.popNode();
3938                }
3939                if (jjte005 instanceof RuntimeException JavaDoc) {
3940                  {if (true) throw (RuntimeException JavaDoc)jjte005;}
3941                }
3942                if (jjte005 instanceof ParseException) {
3943                  {if (true) throw (ParseException)jjte005;}
3944                }
3945                {if (true) throw (Error JavaDoc)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//lambdef: 'lambda' [varargslist] ':' test
3963
final public void lambdef() throws ParseException {
3964                /*@bgen(jjtree) lambdef */
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 JavaDoc jjte000) {
3986    if (jjtc000) {
3987      jjtree.clearNodeScope(jjtn000);
3988      jjtc000 = false;
3989    } else {
3990      jjtree.popNode();
3991    }
3992    if (jjte000 instanceof RuntimeException JavaDoc) {
3993      {if (true) throw (RuntimeException JavaDoc)jjte000;}
3994    }
3995    if (jjte000 instanceof ParseException) {
3996      {if (true) throw (ParseException)jjte000;}
3997    }
3998    {if (true) throw (Error JavaDoc)jjte000;}
3999    } finally {
4000    if (jjtc000) {
4001      jjtree.closeNodeScope(jjtn000, true);
4002      jjtreeCloseNodeScope(jjtn000);
4003    }
4004    }
4005  }
4006
4007//subscriptlist: subscript (',' subscript)* [',']
4008
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 JavaDoc jjte001) {
4034    if (jjtc001) {
4035      jjtree.clearNodeScope(jjtn001);
4036      jjtc001 = false;
4037    } else {
4038      jjtree.popNode();
4039    }
4040    if (jjte001 instanceof RuntimeException JavaDoc) {
4041      {if (true) throw (RuntimeException JavaDoc)jjte001;}
4042    }
4043    if (jjte001 instanceof ParseException) {
4044      {if (true) throw (ParseException)jjte001;}
4045    }
4046    {if (true) throw (Error JavaDoc)jjte001;}
4047    } finally {
4048    if (jjtc001) {
4049      jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
4050      jjtreeCloseNodeScope(jjtn001);
4051    }
4052    }
4053  }
4054
4055//subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
4056
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 JavaDoc jjte002) {
4109      if (jjtc002) {
4110        jjtree.clearNodeScope(jjtn002);
4111        jjtc002 = false;
4112      } else {
4113        jjtree.popNode();
4114      }
4115      if (jjte002 instanceof RuntimeException JavaDoc) {
4116        {if (true) throw (RuntimeException JavaDoc)jjte002;}
4117      }
4118      if (jjte002 instanceof ParseException) {
4119        {if (true) throw (ParseException)jjte002;}
4120      }
4121      {if (true) throw (Error JavaDoc)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 JavaDoc jjte003) {
4137      if (jjtc003) {
4138        jjtree.clearNodeScope(jjtn003);
4139        jjtc003 = false;
4140      } else {
4141        jjtree.popNode();
4142      }
4143      if (jjte003 instanceof RuntimeException JavaDoc) {
4144        {if (true) throw (RuntimeException JavaDoc)jjte003;}
4145      }
4146      if (jjte003 instanceof ParseException) {
4147        {if (true) throw (ParseException)jjte003;}
4148      }
4149      {if (true) throw (Error JavaDoc)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//sliceop: ':' [test]
4165
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               /*@bgen(jjtree) Colon */
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               /*@bgen(jjtree) Comma */
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//exprlist: expr (',' expr)* [',']
4264
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 JavaDoc jjte001) {
4290    if (jjtc001) {
4291      jjtree.clearNodeScope(jjtn001);
4292      jjtc001 = false;
4293    } else {
4294      jjtree.popNode();
4295    }
4296    if (jjte001 instanceof RuntimeException JavaDoc) {
4297      {if (true) throw (RuntimeException JavaDoc)jjte001;}
4298    }
4299    if (jjte001 instanceof ParseException) {
4300      {if (true) throw (ParseException)jjte001;}
4301    }
4302    {if (true) throw (Error JavaDoc)jjte001;}
4303    } finally {
4304    if (jjtc001) {
4305      jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
4306      jjtreeCloseNodeScope(jjtn001);
4307    }
4308    }
4309  }
4310
4311//testlist: test (',' test)* [',']
4312
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 JavaDoc jjte001) {
4338    if (jjtc001) {
4339      jjtree.clearNodeScope(jjtn001);
4340      jjtc001 = false;
4341    } else {
4342      jjtree.popNode();
4343    }
4344    if (jjte001 instanceof RuntimeException JavaDoc) {
4345      {if (true) throw (RuntimeException JavaDoc)jjte001;}
4346    }
4347    if (jjte001 instanceof ParseException) {
4348      {if (true) throw (ParseException)jjte001;}
4349    }
4350    {if (true) throw (Error JavaDoc)jjte001;}
4351    } finally {
4352    if (jjtc001) {
4353      jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
4354      jjtreeCloseNodeScope(jjtn001);
4355    }
4356    }
4357  }
4358
4359//testlist: test (',' test)* [',']
4360
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//dictmaker: test ':' test (',' test ':' test)* [',']
4383
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//listmaker: test ( list_for | (',' test)* [','] )
4410
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 JavaDoc jjte001) {
4453                                                            if (jjtc001) {
4454                                                              jjtree.clearNodeScope(jjtn001);
4455                                                              jjtc001 = false;
4456                                                            } else {
4457                                                              jjtree.popNode();
4458                                                            }
4459                                                            if (jjte001 instanceof RuntimeException JavaDoc) {
4460                                                              {if (true) throw (RuntimeException JavaDoc)jjte001;}
4461                                                            }
4462                                                            if (jjte001 instanceof ParseException) {
4463                                                              {if (true) throw (ParseException)jjte001;}
4464                                                            }
4465                                                            {if (true) throw (Error JavaDoc)jjte001;}
4466      } finally {
4467                                                            if (jjtc001) {
4468                                                              jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
4469                                                              jjtreeCloseNodeScope(jjtn001);
4470                                                            }
4471      }
4472    }
4473  }
4474
4475//list_iter: [list_for | list_if]
4476
//void list_iter() #void: {}
4477
//{ [ (list_for() | list_if()) ] }
4478

4479//list_for: 'for' exprlist 'in' testlist list_iter
4480
final public void list_for() throws ParseException {
4481                  /*@bgen(jjtree) list_for */
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 JavaDoc jjte000) {
4504    if (jjtc000) {
4505      jjtree.clearNodeScope(jjtn000);
4506      jjtc000 = false;
4507    } else {
4508      jjtree.popNode();
4509    }
4510    if (jjte000 instanceof RuntimeException JavaDoc) {
4511      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4512    }
4513    if (jjte000 instanceof ParseException) {
4514      {if (true) throw (ParseException)jjte000;}
4515    }
4516    {if (true) throw (Error JavaDoc)jjte000;}
4517    } finally {
4518    if (jjtc000) {
4519      jjtree.closeNodeScope(jjtn000, true);
4520      jjtreeCloseNodeScope(jjtn000);
4521    }
4522    }
4523  }
4524
4525//list_if: 'if' test list_iter
4526
final public void list_if() throws ParseException {
4527    jj_consume_token(IF);
4528    test();
4529  }
4530
4531//classdef: 'class' NAME ['(' testlist ')'] ':' suite
4532
final public void classdef() throws ParseException {
4533                  /*@bgen(jjtree) classdef */
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 JavaDoc jjte000) {
4554   if (jjtc000) {
4555     jjtree.clearNodeScope(jjtn000);
4556     jjtc000 = false;
4557   } else {
4558     jjtree.popNode();
4559   }
4560   if (jjte000 instanceof RuntimeException JavaDoc) {
4561     {if (true) throw (RuntimeException JavaDoc)jjte000;}
4562   }
4563   if (jjte000 instanceof ParseException) {
4564     {if (true) throw (ParseException)jjte000;}
4565   }
4566   {if (true) throw (Error JavaDoc)jjte000;}
4567    } finally {
4568   if (jjtc000) {
4569     jjtree.closeNodeScope(jjtn000, true);
4570     jjtreeCloseNodeScope(jjtn000);
4571   }
4572    }
4573  }
4574
4575//arglist: (argument ',')*
4576
// (argument [',']| '*' test [',' '**' test] | '**' test)
4577
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                           /*@bgen(jjtree) ExtraArgValueList */
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 JavaDoc jjte000) {
4727    if (jjtc000) {
4728      jjtree.clearNodeScope(jjtn000);
4729      jjtc000 = false;
4730    } else {
4731      jjtree.popNode();
4732    }
4733    if (jjte000 instanceof RuntimeException JavaDoc) {
4734      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4735    }
4736    if (jjte000 instanceof ParseException) {
4737      {if (true) throw (ParseException)jjte000;}
4738    }
4739    {if (true) throw (Error JavaDoc)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                               /*@bgen(jjtree) ExtraKeywordValueList */
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 JavaDoc jjte000) {
4770    if (jjtc000) {
4771      jjtree.clearNodeScope(jjtn000);
4772      jjtc000 = false;
4773    } else {
4774      jjtree.popNode();
4775    }
4776    if (jjte000 instanceof RuntimeException JavaDoc) {
4777      {if (true) throw (RuntimeException JavaDoc)jjte000;}
4778    }
4779    if (jjte000 instanceof ParseException) {
4780      {if (true) throw (ParseException)jjte000;}
4781    }
4782    {if (true) throw (Error JavaDoc)jjte000;}
4783    } finally {
4784    if (jjtc000) {
4785      jjtree.closeNodeScope(jjtn000, true);
4786      jjtreeCloseNodeScope(jjtn000);
4787    }
4788    }
4789  }
4790
4791//argument: [test '='] test # Really [keyword '='] test
4792
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 JavaDoc jjte001) {
4806    if (jjtc001) {
4807      jjtree.clearNodeScope(jjtn001);
4808      jjtc001 = false;
4809    } else {
4810      jjtree.popNode();
4811    }
4812    if (jjte001 instanceof RuntimeException JavaDoc) {
4813      {if (true) throw (RuntimeException JavaDoc)jjte001;}
4814    }
4815    if (jjte001 instanceof ParseException) {
4816      {if (true) throw (ParseException)jjte001;}
4817    }
4818    {if (true) throw (Error JavaDoc)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 /*@bgen(jjtree) Num */
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 JavaDoc 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                 /*@bgen(jjtree) Complex */
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 /*@bgen(jjtree) Name */
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 JavaDoc("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