Source Code Cross Referenced for PythonGrammar.java in  » Scripting » jython » org » python » parser » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Scripting » jython » org.python.parser 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


0001:        /* Generated By:JJTree&JavaCC: Do not edit this line. PythonGrammar.java */
0002:        package org.python.parser;
0003:
0004:        import org.python.parser.ast.modType;
0005:
0006:        public class PythonGrammar/*@bgen(jjtree)*/implements 
0007:                PythonGrammarTreeConstants, PythonGrammarConstants {/*@bgen(jjtree)*/
0008:            protected JJTPythonGrammarState jjtree = new JJTPythonGrammarState();
0009:            public IParserHost hostLiteralMkr;
0010:
0011:            void jjtreeOpenNodeScope(Node n) {
0012:                Token t = getToken(1);
0013:                jjtree.pushNodePos(t.beginLine, t.beginColumn);
0014:            }
0015:
0016:            void jjtreeCloseNodeScope(Node n) {
0017:                jjtree.setNodePos();
0018:            }
0019:
0020:            Object makeInt(String s, int radix) {
0021:                if (s.endsWith("L") || s.endsWith("l")) {
0022:                    s = s.substring(0, s.length() - 1);
0023:                    return hostLiteralMkr.newLong(new java.math.BigInteger(s,
0024:                            radix));
0025:                }
0026:                int ndigits = s.length();
0027:                int i = 0;
0028:                while (i < ndigits && s.charAt(i) == '0')
0029:                    i++;
0030:                if ((ndigits - i) > 11) {
0031:                    return hostLiteralMkr.newLong(new java.math.BigInteger(s,
0032:                            radix));
0033:                }
0034:
0035:                long l = Long.valueOf(s, radix).longValue();
0036:                if (l > 0xffffffffl || (radix == 10 && l > Integer.MAX_VALUE)) {
0037:                    return hostLiteralMkr.newLong(new java.math.BigInteger(s,
0038:                            radix));
0039:                }
0040:                return hostLiteralMkr.newInteger((int) l);
0041:            }
0042:
0043:            Object makeFloat(String s) {
0044:                return hostLiteralMkr.newFloat(Double.valueOf(s).doubleValue());
0045:            }
0046:
0047:            Object makeLong(String s) {
0048:                return hostLiteralMkr.newLong(s);
0049:            }
0050:
0051:            Object makeComplex(String s) {
0052:                s = s.substring(0, s.length() - 1);
0053:                return hostLiteralMkr.newImaginary(Double.valueOf(s)
0054:                        .doubleValue());
0055:            }
0056:
0057:            String makeString(String s, int quotes) {
0058:                //System.out.println("string: "+s);
0059:                char quoteChar = s.charAt(0);
0060:                int start = 0;
0061:                boolean ustring = false;
0062:                if (quoteChar == 'u' || quoteChar == 'U') {
0063:                    ustring = true;
0064:                    start++;
0065:                }
0066:                quoteChar = s.charAt(start);
0067:                if (quoteChar == 'r' || quoteChar == 'R') {
0068:                    return s.substring(quotes + start + 1, s.length() - quotes);
0069:                } else {
0070:                    StringBuffer sb = new StringBuffer(s.length());
0071:                    char[] ca = s.toCharArray();
0072:                    int n = ca.length - quotes;
0073:                    int i = quotes + start;
0074:                    int last_i = i;
0075:
0076:                    return hostLiteralMkr.decode_UnicodeEscape(s, i, n,
0077:                            "strict", ustring);
0078:                }
0079:            }
0080:
0081:            // ! maximal currently used LOOKAHEAD is 3
0082:            private static final int MAX_LOOKAHEAD = 3;
0083:
0084:            public boolean partial_valid_sentence(Throwable t) {
0085:                if (t instanceof  TokenMgrError) {
0086:                    // check whether EOF condition inside multi-line string,
0087:                    // or just after newline continuation inside a string (*NLC states)
0088:                    TokenMgrError e = (TokenMgrError) t;
0089:                    switch (e.lexState) {
0090:                    case IN_STRING1NLC:
0091:                    case IN_STRING2NLC:
0092:                    case IN_STRING13:
0093:                    case IN_STRING23:
0094:                    case IN_USTRING1NLC:
0095:                    case IN_USTRING2NLC:
0096:                    case IN_USTRING13:
0097:                    case IN_USTRING23:
0098:                        return e.EOFSeen;
0099:                    default:
0100:                        return false;
0101:                    }
0102:                }
0103:                if (!(t instanceof  ParseException))
0104:                    return false;
0105:                try {
0106:                    ParseException e = (ParseException) t;
0107:                    int tok = getNextToken().kind;
0108:                    if (tok == EOF)
0109:                        return true; // all tokens eaten
0110:
0111:                    // or check whether remaing tokens partially fullfill lookahead
0112:                    // expectations
0113:
0114:                    int[][] expected = e.expectedTokenSequences;
0115:
0116:                    if (expected == null)
0117:                        return false;
0118:
0119:                    int[] ahead = new int[MAX_LOOKAHEAD - 1];
0120:
0121:                    int i = 0;
0122:                    for (;;) {
0123:                        ahead[i] = tok;
0124:                        i++;
0125:                        tok = getNextToken().kind;
0126:                        if (tok == EOF)
0127:                            break;
0128:                        if (i >= MAX_LOOKAHEAD - 1)
0129:                            return false;
0130:                    }
0131:
0132:                    int nahead = i;
0133:
0134:                    next_expected: for (int j = 0; j < expected.length; j++) {
0135:                        int[] cand = expected[j];
0136:
0137:                        if (cand.length <= nahead)
0138:                            continue next_expected;
0139:
0140:                        for (int k = 0; k < nahead; k++)
0141:                            if (ahead[k] != cand[k])
0142:                                continue next_expected;
0143:                        return true;
0144:                    }
0145:
0146:                    return false;
0147:                } catch (TokenMgrError e1) {
0148:                    return false;
0149:                }
0150:            }
0151:
0152:            // constructors taking a IParserHost impl
0153:
0154:            public PythonGrammar(CharStream stream, IParserHost host) {
0155:                this (stream);
0156:                hostLiteralMkr = host;
0157:            }
0158:
0159:            public PythonGrammar(PythonGrammarTokenManager tm, IParserHost host) {
0160:                this (tm);
0161:                hostLiteralMkr = host;
0162:            }
0163:
0164:            //single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE
0165:            // apparently CPython coalesces newlines, we don't
0166:            final public modType single_input() throws ParseException {
0167:                /*@bgen(jjtree) single_input */
0168:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
0169:                        JJTSINGLE_INPUT);
0170:                boolean jjtc000 = true;
0171:                jjtree.openNodeScope(jjtn000);
0172:                jjtreeOpenNodeScope(jjtn000);
0173:                token_source.single_input = true;
0174:                try {
0175:                    label_1: while (true) {
0176:                        if (jj_2_1(2)) {
0177:                            ;
0178:                        } else {
0179:                            break label_1;
0180:                        }
0181:                        jj_consume_token(NEWLINE);
0182:                    }
0183:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0184:                    case LPAREN:
0185:                    case LBRACE:
0186:                    case LBRACKET:
0187:                    case PLUS:
0188:                    case MINUS:
0189:                    case NOT:
0190:                    case NOT_BOOL:
0191:                    case LAMBDA:
0192:                    case IF:
0193:                    case WHILE:
0194:                    case FOR:
0195:                    case TRY:
0196:                    case DEF:
0197:                    case CLASS:
0198:                    case PRINT:
0199:                    case PASS:
0200:                    case BREAK:
0201:                    case CONTINUE:
0202:                    case RETURN:
0203:                    case YIELD:
0204:                    case IMPORT:
0205:                    case FROM:
0206:                    case DEL:
0207:                    case RAISE:
0208:                    case GLOBAL:
0209:                    case EXEC:
0210:                    case ASSERT:
0211:                    case AS:
0212:                    case NAME:
0213:                    case DECNUMBER:
0214:                    case HEXNUMBER:
0215:                    case OCTNUMBER:
0216:                    case FLOAT:
0217:                    case COMPLEX:
0218:                    case SINGLE_STRING:
0219:                    case SINGLE_STRING2:
0220:                    case TRIPLE_STRING:
0221:                    case TRIPLE_STRING2:
0222:                    case SINGLE_USTRING:
0223:                    case SINGLE_USTRING2:
0224:                    case TRIPLE_USTRING:
0225:                    case TRIPLE_USTRING2:
0226:                    case 135:
0227:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0228:                        case LPAREN:
0229:                        case LBRACE:
0230:                        case LBRACKET:
0231:                        case PLUS:
0232:                        case MINUS:
0233:                        case NOT:
0234:                        case NOT_BOOL:
0235:                        case LAMBDA:
0236:                        case PRINT:
0237:                        case PASS:
0238:                        case BREAK:
0239:                        case CONTINUE:
0240:                        case RETURN:
0241:                        case YIELD:
0242:                        case IMPORT:
0243:                        case FROM:
0244:                        case DEL:
0245:                        case RAISE:
0246:                        case GLOBAL:
0247:                        case EXEC:
0248:                        case ASSERT:
0249:                        case AS:
0250:                        case NAME:
0251:                        case DECNUMBER:
0252:                        case HEXNUMBER:
0253:                        case OCTNUMBER:
0254:                        case FLOAT:
0255:                        case COMPLEX:
0256:                        case SINGLE_STRING:
0257:                        case SINGLE_STRING2:
0258:                        case TRIPLE_STRING:
0259:                        case TRIPLE_STRING2:
0260:                        case SINGLE_USTRING:
0261:                        case SINGLE_USTRING2:
0262:                        case TRIPLE_USTRING:
0263:                        case TRIPLE_USTRING2:
0264:                        case 135:
0265:                            simple_stmt();
0266:                            break;
0267:                        case IF:
0268:                        case WHILE:
0269:                        case FOR:
0270:                        case TRY:
0271:                        case DEF:
0272:                        case CLASS:
0273:                            compound_stmt();
0274:                            jj_consume_token(NEWLINE);
0275:                            break;
0276:                        default:
0277:                            jj_la1[0] = jj_gen;
0278:                            jj_consume_token(-1);
0279:                            throw new ParseException();
0280:                        }
0281:                        break;
0282:                    default:
0283:                        jj_la1[1] = jj_gen;
0284:                        ;
0285:                    }
0286:                    label_2: while (true) {
0287:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0288:                        case NEWLINE:
0289:                            ;
0290:                            break;
0291:                        default:
0292:                            jj_la1[2] = jj_gen;
0293:                            break label_2;
0294:                        }
0295:                        jj_consume_token(NEWLINE);
0296:                    }
0297:                    jj_consume_token(0);
0298:                    jjtree.closeNodeScope(jjtn000, true);
0299:                    jjtc000 = false;
0300:                    jjtreeCloseNodeScope(jjtn000);
0301:                    {
0302:                        if (true)
0303:                            return (modType) jjtree.popNode();
0304:                    }
0305:                } catch (Throwable jjte000) {
0306:                    if (jjtc000) {
0307:                        jjtree.clearNodeScope(jjtn000);
0308:                        jjtc000 = false;
0309:                    } else {
0310:                        jjtree.popNode();
0311:                    }
0312:                    if (jjte000 instanceof  RuntimeException) {
0313:                        {
0314:                            if (true)
0315:                                throw (RuntimeException) jjte000;
0316:                        }
0317:                    }
0318:                    if (jjte000 instanceof  ParseException) {
0319:                        {
0320:                            if (true)
0321:                                throw (ParseException) jjte000;
0322:                        }
0323:                    }
0324:                    {
0325:                        if (true)
0326:                            throw (Error) jjte000;
0327:                    }
0328:                } finally {
0329:                    if (jjtc000) {
0330:                        jjtree.closeNodeScope(jjtn000, true);
0331:                        jjtreeCloseNodeScope(jjtn000);
0332:                    }
0333:                }
0334:                throw new Error("Missing return statement in function");
0335:            }
0336:
0337:            //file_input: (NEWLINE | stmt)* ENDMARKER
0338:            final public modType file_input() throws ParseException {
0339:                /*@bgen(jjtree) file_input */
0340:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
0341:                        JJTFILE_INPUT);
0342:                boolean jjtc000 = true;
0343:                jjtree.openNodeScope(jjtn000);
0344:                jjtreeOpenNodeScope(jjtn000);
0345:                token_source.single_input = false;
0346:                try {
0347:                    label_3: while (true) {
0348:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0349:                        case NEWLINE:
0350:                        case LPAREN:
0351:                        case LBRACE:
0352:                        case LBRACKET:
0353:                        case PLUS:
0354:                        case MINUS:
0355:                        case NOT:
0356:                        case NOT_BOOL:
0357:                        case LAMBDA:
0358:                        case IF:
0359:                        case WHILE:
0360:                        case FOR:
0361:                        case TRY:
0362:                        case DEF:
0363:                        case CLASS:
0364:                        case PRINT:
0365:                        case PASS:
0366:                        case BREAK:
0367:                        case CONTINUE:
0368:                        case RETURN:
0369:                        case YIELD:
0370:                        case IMPORT:
0371:                        case FROM:
0372:                        case DEL:
0373:                        case RAISE:
0374:                        case GLOBAL:
0375:                        case EXEC:
0376:                        case ASSERT:
0377:                        case AS:
0378:                        case NAME:
0379:                        case DECNUMBER:
0380:                        case HEXNUMBER:
0381:                        case OCTNUMBER:
0382:                        case FLOAT:
0383:                        case COMPLEX:
0384:                        case SINGLE_STRING:
0385:                        case SINGLE_STRING2:
0386:                        case TRIPLE_STRING:
0387:                        case TRIPLE_STRING2:
0388:                        case SINGLE_USTRING:
0389:                        case SINGLE_USTRING2:
0390:                        case TRIPLE_USTRING:
0391:                        case TRIPLE_USTRING2:
0392:                        case 135:
0393:                            ;
0394:                            break;
0395:                        default:
0396:                            jj_la1[3] = jj_gen;
0397:                            break label_3;
0398:                        }
0399:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0400:                        case NEWLINE:
0401:                            jj_consume_token(NEWLINE);
0402:                            break;
0403:                        case LPAREN:
0404:                        case LBRACE:
0405:                        case LBRACKET:
0406:                        case PLUS:
0407:                        case MINUS:
0408:                        case NOT:
0409:                        case NOT_BOOL:
0410:                        case LAMBDA:
0411:                        case IF:
0412:                        case WHILE:
0413:                        case FOR:
0414:                        case TRY:
0415:                        case DEF:
0416:                        case CLASS:
0417:                        case PRINT:
0418:                        case PASS:
0419:                        case BREAK:
0420:                        case CONTINUE:
0421:                        case RETURN:
0422:                        case YIELD:
0423:                        case IMPORT:
0424:                        case FROM:
0425:                        case DEL:
0426:                        case RAISE:
0427:                        case GLOBAL:
0428:                        case EXEC:
0429:                        case ASSERT:
0430:                        case AS:
0431:                        case NAME:
0432:                        case DECNUMBER:
0433:                        case HEXNUMBER:
0434:                        case OCTNUMBER:
0435:                        case FLOAT:
0436:                        case COMPLEX:
0437:                        case SINGLE_STRING:
0438:                        case SINGLE_STRING2:
0439:                        case TRIPLE_STRING:
0440:                        case TRIPLE_STRING2:
0441:                        case SINGLE_USTRING:
0442:                        case SINGLE_USTRING2:
0443:                        case TRIPLE_USTRING:
0444:                        case TRIPLE_USTRING2:
0445:                        case 135:
0446:                            stmt();
0447:                            break;
0448:                        default:
0449:                            jj_la1[4] = jj_gen;
0450:                            jj_consume_token(-1);
0451:                            throw new ParseException();
0452:                        }
0453:                    }
0454:                    jj_consume_token(0);
0455:                    jjtree.closeNodeScope(jjtn000, true);
0456:                    jjtc000 = false;
0457:                    jjtreeCloseNodeScope(jjtn000);
0458:                    {
0459:                        if (true)
0460:                            return (modType) jjtree.popNode();
0461:                    }
0462:                } catch (Throwable jjte000) {
0463:                    if (jjtc000) {
0464:                        jjtree.clearNodeScope(jjtn000);
0465:                        jjtc000 = false;
0466:                    } else {
0467:                        jjtree.popNode();
0468:                    }
0469:                    if (jjte000 instanceof  RuntimeException) {
0470:                        {
0471:                            if (true)
0472:                                throw (RuntimeException) jjte000;
0473:                        }
0474:                    }
0475:                    if (jjte000 instanceof  ParseException) {
0476:                        {
0477:                            if (true)
0478:                                throw (ParseException) jjte000;
0479:                        }
0480:                    }
0481:                    {
0482:                        if (true)
0483:                            throw (Error) jjte000;
0484:                    }
0485:                } finally {
0486:                    if (jjtc000) {
0487:                        jjtree.closeNodeScope(jjtn000, true);
0488:                        jjtreeCloseNodeScope(jjtn000);
0489:                    }
0490:                }
0491:                throw new Error("Missing return statement in function");
0492:            }
0493:
0494:            //eval_input: NEWLINE* testlist NEWLINE* ENDMARKER
0495:            final public modType eval_input() throws ParseException {
0496:                /*@bgen(jjtree) eval_input */
0497:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
0498:                        JJTEVAL_INPUT);
0499:                boolean jjtc000 = true;
0500:                jjtree.openNodeScope(jjtn000);
0501:                jjtreeOpenNodeScope(jjtn000);
0502:                token_source.single_input = false;
0503:                try {
0504:                    label_4: while (true) {
0505:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0506:                        case NEWLINE:
0507:                            ;
0508:                            break;
0509:                        default:
0510:                            jj_la1[5] = jj_gen;
0511:                            break label_4;
0512:                        }
0513:                        jj_consume_token(NEWLINE);
0514:                    }
0515:                    SmartTestList();
0516:                    label_5: while (true) {
0517:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0518:                        case NEWLINE:
0519:                            ;
0520:                            break;
0521:                        default:
0522:                            jj_la1[6] = jj_gen;
0523:                            break label_5;
0524:                        }
0525:                        jj_consume_token(NEWLINE);
0526:                    }
0527:                    jj_consume_token(0);
0528:                    jjtree.closeNodeScope(jjtn000, true);
0529:                    jjtc000 = false;
0530:                    jjtreeCloseNodeScope(jjtn000);
0531:                    {
0532:                        if (true)
0533:                            return (modType) jjtree.popNode();
0534:                    }
0535:                } catch (Throwable jjte000) {
0536:                    if (jjtc000) {
0537:                        jjtree.clearNodeScope(jjtn000);
0538:                        jjtc000 = false;
0539:                    } else {
0540:                        jjtree.popNode();
0541:                    }
0542:                    if (jjte000 instanceof  RuntimeException) {
0543:                        {
0544:                            if (true)
0545:                                throw (RuntimeException) jjte000;
0546:                        }
0547:                    }
0548:                    if (jjte000 instanceof  ParseException) {
0549:                        {
0550:                            if (true)
0551:                                throw (ParseException) jjte000;
0552:                        }
0553:                    }
0554:                    {
0555:                        if (true)
0556:                            throw (Error) jjte000;
0557:                    }
0558:                } finally {
0559:                    if (jjtc000) {
0560:                        jjtree.closeNodeScope(jjtn000, true);
0561:                        jjtreeCloseNodeScope(jjtn000);
0562:                    }
0563:                }
0564:                throw new Error("Missing return statement in function");
0565:            }
0566:
0567:            //funcdef: 'def' NAME parameters ':' suite
0568:            final public void funcdef() throws ParseException {
0569:                /*@bgen(jjtree) funcdef */
0570:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
0571:                        JJTFUNCDEF);
0572:                boolean jjtc000 = true;
0573:                jjtree.openNodeScope(jjtn000);
0574:                jjtreeOpenNodeScope(jjtn000);
0575:                try {
0576:                    jj_consume_token(DEF);
0577:                    AnyName();
0578:                    parameters();
0579:                    jj_consume_token(COLON);
0580:                    suite();
0581:                } catch (Throwable jjte000) {
0582:                    if (jjtc000) {
0583:                        jjtree.clearNodeScope(jjtn000);
0584:                        jjtc000 = false;
0585:                    } else {
0586:                        jjtree.popNode();
0587:                    }
0588:                    if (jjte000 instanceof  RuntimeException) {
0589:                        {
0590:                            if (true)
0591:                                throw (RuntimeException) jjte000;
0592:                        }
0593:                    }
0594:                    if (jjte000 instanceof  ParseException) {
0595:                        {
0596:                            if (true)
0597:                                throw (ParseException) jjte000;
0598:                        }
0599:                    }
0600:                    {
0601:                        if (true)
0602:                            throw (Error) jjte000;
0603:                    }
0604:                } finally {
0605:                    if (jjtc000) {
0606:                        jjtree.closeNodeScope(jjtn000, true);
0607:                        jjtreeCloseNodeScope(jjtn000);
0608:                    }
0609:                }
0610:            }
0611:
0612:            //parameters: '(' [varargslist] ')'
0613:            final public void parameters() throws ParseException {
0614:                jj_consume_token(LPAREN);
0615:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0616:                case LPAREN:
0617:                case MULTIPLY:
0618:                case POWER:
0619:                case AS:
0620:                case NAME:
0621:                    varargslist();
0622:                    break;
0623:                default:
0624:                    jj_la1[7] = jj_gen;
0625:                    ;
0626:                }
0627:                jj_consume_token(RPAREN);
0628:            }
0629:
0630:            //varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' ('**'|'*' '*') NAME] | ('**'|'*' '*') NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [',']
0631:            final public void varargslist() throws ParseException {
0632:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0633:                case LPAREN:
0634:                case AS:
0635:                case NAME:
0636:                    defaultarg();
0637:                    label_6: while (true) {
0638:                        if (jj_2_2(2)) {
0639:                            ;
0640:                        } else {
0641:                            break label_6;
0642:                        }
0643:                        jj_consume_token(COMMA);
0644:                        defaultarg();
0645:                    }
0646:                    if (jj_2_3(3)) {
0647:                        jj_consume_token(COMMA);
0648:                        ExtraArgList();
0649:                    } else {
0650:                        ;
0651:                    }
0652:                    if (jj_2_4(2)) {
0653:                        jj_consume_token(COMMA);
0654:                        ExtraKeywordList();
0655:                    } else {
0656:                        ;
0657:                    }
0658:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0659:                    case COMMA:
0660:                        jj_consume_token(COMMA);
0661:                        break;
0662:                    default:
0663:                        jj_la1[8] = jj_gen;
0664:                        ;
0665:                    }
0666:                    break;
0667:                case MULTIPLY:
0668:                case POWER:
0669:                    if (jj_2_5(2)) {
0670:                        ExtraArgList();
0671:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0672:                        case COMMA:
0673:                            jj_consume_token(COMMA);
0674:                            ExtraKeywordList();
0675:                            break;
0676:                        default:
0677:                            jj_la1[9] = jj_gen;
0678:                            ;
0679:                        }
0680:                    } else {
0681:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0682:                        case MULTIPLY:
0683:                        case POWER:
0684:                            ExtraKeywordList();
0685:                            break;
0686:                        default:
0687:                            jj_la1[10] = jj_gen;
0688:                            jj_consume_token(-1);
0689:                            throw new ParseException();
0690:                        }
0691:                    }
0692:                    break;
0693:                default:
0694:                    jj_la1[11] = jj_gen;
0695:                    jj_consume_token(-1);
0696:                    throw new ParseException();
0697:                }
0698:            }
0699:
0700:            final public void ExtraArgList() throws ParseException {
0701:                /*@bgen(jjtree) ExtraArgList */
0702:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
0703:                        JJTEXTRAARGLIST);
0704:                boolean jjtc000 = true;
0705:                jjtree.openNodeScope(jjtn000);
0706:                jjtreeOpenNodeScope(jjtn000);
0707:                try {
0708:                    jj_consume_token(MULTIPLY);
0709:                    Name();
0710:                } catch (Throwable jjte000) {
0711:                    if (jjtc000) {
0712:                        jjtree.clearNodeScope(jjtn000);
0713:                        jjtc000 = false;
0714:                    } else {
0715:                        jjtree.popNode();
0716:                    }
0717:                    if (jjte000 instanceof  RuntimeException) {
0718:                        {
0719:                            if (true)
0720:                                throw (RuntimeException) jjte000;
0721:                        }
0722:                    }
0723:                    if (jjte000 instanceof  ParseException) {
0724:                        {
0725:                            if (true)
0726:                                throw (ParseException) jjte000;
0727:                        }
0728:                    }
0729:                    {
0730:                        if (true)
0731:                            throw (Error) jjte000;
0732:                    }
0733:                } finally {
0734:                    if (jjtc000) {
0735:                        jjtree.closeNodeScope(jjtn000, true);
0736:                        jjtreeCloseNodeScope(jjtn000);
0737:                    }
0738:                }
0739:            }
0740:
0741:            final public void ExtraKeywordList() throws ParseException {
0742:                /*@bgen(jjtree) ExtraKeywordList */
0743:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
0744:                        JJTEXTRAKEYWORDLIST);
0745:                boolean jjtc000 = true;
0746:                jjtree.openNodeScope(jjtn000);
0747:                jjtreeOpenNodeScope(jjtn000);
0748:                try {
0749:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0750:                    case POWER:
0751:                        jj_consume_token(POWER);
0752:                        break;
0753:                    case MULTIPLY:
0754:                        jj_consume_token(MULTIPLY);
0755:                        jj_consume_token(MULTIPLY);
0756:                        break;
0757:                    default:
0758:                        jj_la1[12] = jj_gen;
0759:                        jj_consume_token(-1);
0760:                        throw new ParseException();
0761:                    }
0762:                    Name();
0763:                } catch (Throwable jjte000) {
0764:                    if (jjtc000) {
0765:                        jjtree.clearNodeScope(jjtn000);
0766:                        jjtc000 = false;
0767:                    } else {
0768:                        jjtree.popNode();
0769:                    }
0770:                    if (jjte000 instanceof  RuntimeException) {
0771:                        {
0772:                            if (true)
0773:                                throw (RuntimeException) jjte000;
0774:                        }
0775:                    }
0776:                    if (jjte000 instanceof  ParseException) {
0777:                        {
0778:                            if (true)
0779:                                throw (ParseException) jjte000;
0780:                        }
0781:                    }
0782:                    {
0783:                        if (true)
0784:                            throw (Error) jjte000;
0785:                    }
0786:                } finally {
0787:                    if (jjtc000) {
0788:                        jjtree.closeNodeScope(jjtn000, true);
0789:                        jjtreeCloseNodeScope(jjtn000);
0790:                    }
0791:                }
0792:            }
0793:
0794:            final public void defaultarg() throws ParseException {
0795:                /*@bgen(jjtree) defaultarg */
0796:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
0797:                        JJTDEFAULTARG);
0798:                boolean jjtc000 = true;
0799:                jjtree.openNodeScope(jjtn000);
0800:                jjtreeOpenNodeScope(jjtn000);
0801:                try {
0802:                    fpdef();
0803:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0804:                    case EQUAL:
0805:                        jj_consume_token(EQUAL);
0806:                        test();
0807:                        break;
0808:                    default:
0809:                        jj_la1[13] = jj_gen;
0810:                        ;
0811:                    }
0812:                } catch (Throwable jjte000) {
0813:                    if (jjtc000) {
0814:                        jjtree.clearNodeScope(jjtn000);
0815:                        jjtc000 = false;
0816:                    } else {
0817:                        jjtree.popNode();
0818:                    }
0819:                    if (jjte000 instanceof  RuntimeException) {
0820:                        {
0821:                            if (true)
0822:                                throw (RuntimeException) jjte000;
0823:                        }
0824:                    }
0825:                    if (jjte000 instanceof  ParseException) {
0826:                        {
0827:                            if (true)
0828:                                throw (ParseException) jjte000;
0829:                        }
0830:                    }
0831:                    {
0832:                        if (true)
0833:                            throw (Error) jjte000;
0834:                    }
0835:                } finally {
0836:                    if (jjtc000) {
0837:                        jjtree.closeNodeScope(jjtn000, true);
0838:                        jjtreeCloseNodeScope(jjtn000);
0839:                    }
0840:                }
0841:            }
0842:
0843:            //fpdef: NAME | '(' fplist ')'
0844:            final public void fpdef() throws ParseException {
0845:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0846:                case AS:
0847:                case NAME:
0848:                    Name();
0849:                    break;
0850:                case LPAREN:
0851:                    jj_consume_token(LPAREN);
0852:                    fplist();
0853:                    jj_consume_token(RPAREN);
0854:                    break;
0855:                default:
0856:                    jj_la1[14] = jj_gen;
0857:                    jj_consume_token(-1);
0858:                    throw new ParseException();
0859:                }
0860:            }
0861:
0862:            //fplist: fpdef (',' fpdef)* [',']
0863:            final public void fplist() throws ParseException {
0864:                /*@bgen(jjtree) tuple */
0865:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
0866:                        JJTTUPLE);
0867:                boolean jjtc000 = true;
0868:                jjtree.openNodeScope(jjtn000);
0869:                jjtreeOpenNodeScope(jjtn000);
0870:                try {
0871:                    fpdef();
0872:                    label_7: while (true) {
0873:                        if (jj_2_6(2)) {
0874:                            ;
0875:                        } else {
0876:                            break label_7;
0877:                        }
0878:                        jj_consume_token(COMMA);
0879:                        fpdef();
0880:                    }
0881:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0882:                    case COMMA:
0883:                        jj_consume_token(COMMA);
0884:                        break;
0885:                    default:
0886:                        jj_la1[15] = jj_gen;
0887:                        ;
0888:                    }
0889:                } catch (Throwable jjte000) {
0890:                    if (jjtc000) {
0891:                        jjtree.clearNodeScope(jjtn000);
0892:                        jjtc000 = false;
0893:                    } else {
0894:                        jjtree.popNode();
0895:                    }
0896:                    if (jjte000 instanceof  RuntimeException) {
0897:                        {
0898:                            if (true)
0899:                                throw (RuntimeException) jjte000;
0900:                        }
0901:                    }
0902:                    if (jjte000 instanceof  ParseException) {
0903:                        {
0904:                            if (true)
0905:                                throw (ParseException) jjte000;
0906:                        }
0907:                    }
0908:                    {
0909:                        if (true)
0910:                            throw (Error) jjte000;
0911:                    }
0912:                } finally {
0913:                    if (jjtc000) {
0914:                        jjtree.closeNodeScope(jjtn000, true);
0915:                        jjtreeCloseNodeScope(jjtn000);
0916:                    }
0917:                }
0918:            }
0919:
0920:            //stmt: simple_stmt | compound_stmt
0921:            final public void stmt() throws ParseException {
0922:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0923:                case LPAREN:
0924:                case LBRACE:
0925:                case LBRACKET:
0926:                case PLUS:
0927:                case MINUS:
0928:                case NOT:
0929:                case NOT_BOOL:
0930:                case LAMBDA:
0931:                case PRINT:
0932:                case PASS:
0933:                case BREAK:
0934:                case CONTINUE:
0935:                case RETURN:
0936:                case YIELD:
0937:                case IMPORT:
0938:                case FROM:
0939:                case DEL:
0940:                case RAISE:
0941:                case GLOBAL:
0942:                case EXEC:
0943:                case ASSERT:
0944:                case AS:
0945:                case NAME:
0946:                case DECNUMBER:
0947:                case HEXNUMBER:
0948:                case OCTNUMBER:
0949:                case FLOAT:
0950:                case COMPLEX:
0951:                case SINGLE_STRING:
0952:                case SINGLE_STRING2:
0953:                case TRIPLE_STRING:
0954:                case TRIPLE_STRING2:
0955:                case SINGLE_USTRING:
0956:                case SINGLE_USTRING2:
0957:                case TRIPLE_USTRING:
0958:                case TRIPLE_USTRING2:
0959:                case 135:
0960:                    simple_stmt();
0961:                    break;
0962:                case IF:
0963:                case WHILE:
0964:                case FOR:
0965:                case TRY:
0966:                case DEF:
0967:                case CLASS:
0968:                    compound_stmt();
0969:                    break;
0970:                default:
0971:                    jj_la1[16] = jj_gen;
0972:                    jj_consume_token(-1);
0973:                    throw new ParseException();
0974:                }
0975:            }
0976:
0977:            //simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
0978:            final public void simple_stmt() throws ParseException {
0979:                small_stmt();
0980:                label_8: while (true) {
0981:                    if (jj_2_7(2)) {
0982:                        ;
0983:                    } else {
0984:                        break label_8;
0985:                    }
0986:                    jj_consume_token(SEMICOLON);
0987:                    small_stmt();
0988:                }
0989:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0990:                case SEMICOLON:
0991:                    jj_consume_token(SEMICOLON);
0992:                    break;
0993:                default:
0994:                    jj_la1[17] = jj_gen;
0995:                    ;
0996:                }
0997:                jj_consume_token(NEWLINE);
0998:            }
0999:
1000:            //small_stmt: expr_stmt | print_stmt  | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt
1001:            final public void small_stmt() throws ParseException {
1002:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1003:                case LPAREN:
1004:                case LBRACE:
1005:                case LBRACKET:
1006:                case PLUS:
1007:                case MINUS:
1008:                case NOT:
1009:                case NOT_BOOL:
1010:                case LAMBDA:
1011:                case AS:
1012:                case NAME:
1013:                case DECNUMBER:
1014:                case HEXNUMBER:
1015:                case OCTNUMBER:
1016:                case FLOAT:
1017:                case COMPLEX:
1018:                case SINGLE_STRING:
1019:                case SINGLE_STRING2:
1020:                case TRIPLE_STRING:
1021:                case TRIPLE_STRING2:
1022:                case SINGLE_USTRING:
1023:                case SINGLE_USTRING2:
1024:                case TRIPLE_USTRING:
1025:                case TRIPLE_USTRING2:
1026:                case 135:
1027:                    expr_stmt();
1028:                    break;
1029:                case PRINT:
1030:                    print_stmt();
1031:                    break;
1032:                case DEL:
1033:                    del_stmt();
1034:                    break;
1035:                case PASS:
1036:                    pass_stmt();
1037:                    break;
1038:                case BREAK:
1039:                case CONTINUE:
1040:                case RETURN:
1041:                case YIELD:
1042:                case RAISE:
1043:                    flow_stmt();
1044:                    break;
1045:                case IMPORT:
1046:                case FROM:
1047:                    import_stmt();
1048:                    break;
1049:                case GLOBAL:
1050:                    global_stmt();
1051:                    break;
1052:                case EXEC:
1053:                    exec_stmt();
1054:                    break;
1055:                case ASSERT:
1056:                    assert_stmt();
1057:                    break;
1058:                default:
1059:                    jj_la1[18] = jj_gen;
1060:                    jj_consume_token(-1);
1061:                    throw new ParseException();
1062:                }
1063:            }
1064:
1065:            //expr_stmt: testlist (augassign testlist | ('=' testlist)*)
1066:            final public void expr_stmt() throws ParseException {
1067:                SmartTestList();
1068:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1069:                case PLUSEQ:
1070:                    jj_consume_token(PLUSEQ);
1071:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
1072:                            this , JJTAUG_PLUS);
1073:                    boolean jjtc001 = true;
1074:                    jjtree.openNodeScope(jjtn001);
1075:                    jjtreeOpenNodeScope(jjtn001);
1076:                    try {
1077:                        SmartTestList();
1078:                    } catch (Throwable jjte001) {
1079:                        if (jjtc001) {
1080:                            jjtree.clearNodeScope(jjtn001);
1081:                            jjtc001 = false;
1082:                        } else {
1083:                            jjtree.popNode();
1084:                        }
1085:                        if (jjte001 instanceof  RuntimeException) {
1086:                            {
1087:                                if (true)
1088:                                    throw (RuntimeException) jjte001;
1089:                            }
1090:                        }
1091:                        if (jjte001 instanceof  ParseException) {
1092:                            {
1093:                                if (true)
1094:                                    throw (ParseException) jjte001;
1095:                            }
1096:                        }
1097:                        {
1098:                            if (true)
1099:                                throw (Error) jjte001;
1100:                        }
1101:                    } finally {
1102:                        if (jjtc001) {
1103:                            jjtree.closeNodeScope(jjtn001, 2);
1104:                            jjtreeCloseNodeScope(jjtn001);
1105:                        }
1106:                    }
1107:                    break;
1108:                case MINUSEQ:
1109:                    jj_consume_token(MINUSEQ);
1110:                    SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
1111:                            this , JJTAUG_MINUS);
1112:                    boolean jjtc002 = true;
1113:                    jjtree.openNodeScope(jjtn002);
1114:                    jjtreeOpenNodeScope(jjtn002);
1115:                    try {
1116:                        SmartTestList();
1117:                    } catch (Throwable jjte002) {
1118:                        if (jjtc002) {
1119:                            jjtree.clearNodeScope(jjtn002);
1120:                            jjtc002 = false;
1121:                        } else {
1122:                            jjtree.popNode();
1123:                        }
1124:                        if (jjte002 instanceof  RuntimeException) {
1125:                            {
1126:                                if (true)
1127:                                    throw (RuntimeException) jjte002;
1128:                            }
1129:                        }
1130:                        if (jjte002 instanceof  ParseException) {
1131:                            {
1132:                                if (true)
1133:                                    throw (ParseException) jjte002;
1134:                            }
1135:                        }
1136:                        {
1137:                            if (true)
1138:                                throw (Error) jjte002;
1139:                        }
1140:                    } finally {
1141:                        if (jjtc002) {
1142:                            jjtree.closeNodeScope(jjtn002, 2);
1143:                            jjtreeCloseNodeScope(jjtn002);
1144:                        }
1145:                    }
1146:                    break;
1147:                case MULTIPLYEQ:
1148:                    jj_consume_token(MULTIPLYEQ);
1149:                    SimpleNode jjtn003 = (SimpleNode) SimpleNode.jjtCreate(
1150:                            this , JJTAUG_MULTIPLY);
1151:                    boolean jjtc003 = true;
1152:                    jjtree.openNodeScope(jjtn003);
1153:                    jjtreeOpenNodeScope(jjtn003);
1154:                    try {
1155:                        SmartTestList();
1156:                    } catch (Throwable jjte003) {
1157:                        if (jjtc003) {
1158:                            jjtree.clearNodeScope(jjtn003);
1159:                            jjtc003 = false;
1160:                        } else {
1161:                            jjtree.popNode();
1162:                        }
1163:                        if (jjte003 instanceof  RuntimeException) {
1164:                            {
1165:                                if (true)
1166:                                    throw (RuntimeException) jjte003;
1167:                            }
1168:                        }
1169:                        if (jjte003 instanceof  ParseException) {
1170:                            {
1171:                                if (true)
1172:                                    throw (ParseException) jjte003;
1173:                            }
1174:                        }
1175:                        {
1176:                            if (true)
1177:                                throw (Error) jjte003;
1178:                        }
1179:                    } finally {
1180:                        if (jjtc003) {
1181:                            jjtree.closeNodeScope(jjtn003, 2);
1182:                            jjtreeCloseNodeScope(jjtn003);
1183:                        }
1184:                    }
1185:                    break;
1186:                case DIVIDEEQ:
1187:                    jj_consume_token(DIVIDEEQ);
1188:                    SimpleNode jjtn004 = (SimpleNode) SimpleNode.jjtCreate(
1189:                            this , JJTAUG_DIVIDE);
1190:                    boolean jjtc004 = true;
1191:                    jjtree.openNodeScope(jjtn004);
1192:                    jjtreeOpenNodeScope(jjtn004);
1193:                    try {
1194:                        SmartTestList();
1195:                    } catch (Throwable jjte004) {
1196:                        if (jjtc004) {
1197:                            jjtree.clearNodeScope(jjtn004);
1198:                            jjtc004 = false;
1199:                        } else {
1200:                            jjtree.popNode();
1201:                        }
1202:                        if (jjte004 instanceof  RuntimeException) {
1203:                            {
1204:                                if (true)
1205:                                    throw (RuntimeException) jjte004;
1206:                            }
1207:                        }
1208:                        if (jjte004 instanceof  ParseException) {
1209:                            {
1210:                                if (true)
1211:                                    throw (ParseException) jjte004;
1212:                            }
1213:                        }
1214:                        {
1215:                            if (true)
1216:                                throw (Error) jjte004;
1217:                        }
1218:                    } finally {
1219:                        if (jjtc004) {
1220:                            jjtree.closeNodeScope(jjtn004, 2);
1221:                            jjtreeCloseNodeScope(jjtn004);
1222:                        }
1223:                    }
1224:                    break;
1225:                case FLOORDIVIDEEQ:
1226:                    jj_consume_token(FLOORDIVIDEEQ);
1227:                    SimpleNode jjtn005 = (SimpleNode) SimpleNode.jjtCreate(
1228:                            this , JJTAUG_FLOORDIVIDE);
1229:                    boolean jjtc005 = true;
1230:                    jjtree.openNodeScope(jjtn005);
1231:                    jjtreeOpenNodeScope(jjtn005);
1232:                    try {
1233:                        SmartTestList();
1234:                    } catch (Throwable jjte005) {
1235:                        if (jjtc005) {
1236:                            jjtree.clearNodeScope(jjtn005);
1237:                            jjtc005 = false;
1238:                        } else {
1239:                            jjtree.popNode();
1240:                        }
1241:                        if (jjte005 instanceof  RuntimeException) {
1242:                            {
1243:                                if (true)
1244:                                    throw (RuntimeException) jjte005;
1245:                            }
1246:                        }
1247:                        if (jjte005 instanceof  ParseException) {
1248:                            {
1249:                                if (true)
1250:                                    throw (ParseException) jjte005;
1251:                            }
1252:                        }
1253:                        {
1254:                            if (true)
1255:                                throw (Error) jjte005;
1256:                        }
1257:                    } finally {
1258:                        if (jjtc005) {
1259:                            jjtree.closeNodeScope(jjtn005, 2);
1260:                            jjtreeCloseNodeScope(jjtn005);
1261:                        }
1262:                    }
1263:                    break;
1264:                case MODULOEQ:
1265:                    jj_consume_token(MODULOEQ);
1266:                    SimpleNode jjtn006 = (SimpleNode) SimpleNode.jjtCreate(
1267:                            this , JJTAUG_MODULO);
1268:                    boolean jjtc006 = true;
1269:                    jjtree.openNodeScope(jjtn006);
1270:                    jjtreeOpenNodeScope(jjtn006);
1271:                    try {
1272:                        SmartTestList();
1273:                    } catch (Throwable jjte006) {
1274:                        if (jjtc006) {
1275:                            jjtree.clearNodeScope(jjtn006);
1276:                            jjtc006 = false;
1277:                        } else {
1278:                            jjtree.popNode();
1279:                        }
1280:                        if (jjte006 instanceof  RuntimeException) {
1281:                            {
1282:                                if (true)
1283:                                    throw (RuntimeException) jjte006;
1284:                            }
1285:                        }
1286:                        if (jjte006 instanceof  ParseException) {
1287:                            {
1288:                                if (true)
1289:                                    throw (ParseException) jjte006;
1290:                            }
1291:                        }
1292:                        {
1293:                            if (true)
1294:                                throw (Error) jjte006;
1295:                        }
1296:                    } finally {
1297:                        if (jjtc006) {
1298:                            jjtree.closeNodeScope(jjtn006, 2);
1299:                            jjtreeCloseNodeScope(jjtn006);
1300:                        }
1301:                    }
1302:                    break;
1303:                case ANDEQ:
1304:                    jj_consume_token(ANDEQ);
1305:                    SimpleNode jjtn007 = (SimpleNode) SimpleNode.jjtCreate(
1306:                            this , JJTAUG_AND);
1307:                    boolean jjtc007 = true;
1308:                    jjtree.openNodeScope(jjtn007);
1309:                    jjtreeOpenNodeScope(jjtn007);
1310:                    try {
1311:                        SmartTestList();
1312:                    } catch (Throwable jjte007) {
1313:                        if (jjtc007) {
1314:                            jjtree.clearNodeScope(jjtn007);
1315:                            jjtc007 = false;
1316:                        } else {
1317:                            jjtree.popNode();
1318:                        }
1319:                        if (jjte007 instanceof  RuntimeException) {
1320:                            {
1321:                                if (true)
1322:                                    throw (RuntimeException) jjte007;
1323:                            }
1324:                        }
1325:                        if (jjte007 instanceof  ParseException) {
1326:                            {
1327:                                if (true)
1328:                                    throw (ParseException) jjte007;
1329:                            }
1330:                        }
1331:                        {
1332:                            if (true)
1333:                                throw (Error) jjte007;
1334:                        }
1335:                    } finally {
1336:                        if (jjtc007) {
1337:                            jjtree.closeNodeScope(jjtn007, 2);
1338:                            jjtreeCloseNodeScope(jjtn007);
1339:                        }
1340:                    }
1341:                    break;
1342:                case OREQ:
1343:                    jj_consume_token(OREQ);
1344:                    SimpleNode jjtn008 = (SimpleNode) SimpleNode.jjtCreate(
1345:                            this , JJTAUG_OR);
1346:                    boolean jjtc008 = true;
1347:                    jjtree.openNodeScope(jjtn008);
1348:                    jjtreeOpenNodeScope(jjtn008);
1349:                    try {
1350:                        SmartTestList();
1351:                    } catch (Throwable jjte008) {
1352:                        if (jjtc008) {
1353:                            jjtree.clearNodeScope(jjtn008);
1354:                            jjtc008 = false;
1355:                        } else {
1356:                            jjtree.popNode();
1357:                        }
1358:                        if (jjte008 instanceof  RuntimeException) {
1359:                            {
1360:                                if (true)
1361:                                    throw (RuntimeException) jjte008;
1362:                            }
1363:                        }
1364:                        if (jjte008 instanceof  ParseException) {
1365:                            {
1366:                                if (true)
1367:                                    throw (ParseException) jjte008;
1368:                            }
1369:                        }
1370:                        {
1371:                            if (true)
1372:                                throw (Error) jjte008;
1373:                        }
1374:                    } finally {
1375:                        if (jjtc008) {
1376:                            jjtree.closeNodeScope(jjtn008, 2);
1377:                            jjtreeCloseNodeScope(jjtn008);
1378:                        }
1379:                    }
1380:                    break;
1381:                case XOREQ:
1382:                    jj_consume_token(XOREQ);
1383:                    SimpleNode jjtn009 = (SimpleNode) SimpleNode.jjtCreate(
1384:                            this , JJTAUG_XOR);
1385:                    boolean jjtc009 = true;
1386:                    jjtree.openNodeScope(jjtn009);
1387:                    jjtreeOpenNodeScope(jjtn009);
1388:                    try {
1389:                        SmartTestList();
1390:                    } catch (Throwable jjte009) {
1391:                        if (jjtc009) {
1392:                            jjtree.clearNodeScope(jjtn009);
1393:                            jjtc009 = false;
1394:                        } else {
1395:                            jjtree.popNode();
1396:                        }
1397:                        if (jjte009 instanceof  RuntimeException) {
1398:                            {
1399:                                if (true)
1400:                                    throw (RuntimeException) jjte009;
1401:                            }
1402:                        }
1403:                        if (jjte009 instanceof  ParseException) {
1404:                            {
1405:                                if (true)
1406:                                    throw (ParseException) jjte009;
1407:                            }
1408:                        }
1409:                        {
1410:                            if (true)
1411:                                throw (Error) jjte009;
1412:                        }
1413:                    } finally {
1414:                        if (jjtc009) {
1415:                            jjtree.closeNodeScope(jjtn009, 2);
1416:                            jjtreeCloseNodeScope(jjtn009);
1417:                        }
1418:                    }
1419:                    break;
1420:                case LSHIFTEQ:
1421:                    jj_consume_token(LSHIFTEQ);
1422:                    SimpleNode jjtn010 = (SimpleNode) SimpleNode.jjtCreate(
1423:                            this , JJTAUG_LSHIFT);
1424:                    boolean jjtc010 = true;
1425:                    jjtree.openNodeScope(jjtn010);
1426:                    jjtreeOpenNodeScope(jjtn010);
1427:                    try {
1428:                        SmartTestList();
1429:                    } catch (Throwable jjte010) {
1430:                        if (jjtc010) {
1431:                            jjtree.clearNodeScope(jjtn010);
1432:                            jjtc010 = false;
1433:                        } else {
1434:                            jjtree.popNode();
1435:                        }
1436:                        if (jjte010 instanceof  RuntimeException) {
1437:                            {
1438:                                if (true)
1439:                                    throw (RuntimeException) jjte010;
1440:                            }
1441:                        }
1442:                        if (jjte010 instanceof  ParseException) {
1443:                            {
1444:                                if (true)
1445:                                    throw (ParseException) jjte010;
1446:                            }
1447:                        }
1448:                        {
1449:                            if (true)
1450:                                throw (Error) jjte010;
1451:                        }
1452:                    } finally {
1453:                        if (jjtc010) {
1454:                            jjtree.closeNodeScope(jjtn010, 2);
1455:                            jjtreeCloseNodeScope(jjtn010);
1456:                        }
1457:                    }
1458:                    break;
1459:                case RSHIFTEQ:
1460:                    jj_consume_token(RSHIFTEQ);
1461:                    SimpleNode jjtn011 = (SimpleNode) SimpleNode.jjtCreate(
1462:                            this , JJTAUG_RSHIFT);
1463:                    boolean jjtc011 = true;
1464:                    jjtree.openNodeScope(jjtn011);
1465:                    jjtreeOpenNodeScope(jjtn011);
1466:                    try {
1467:                        SmartTestList();
1468:                    } catch (Throwable jjte011) {
1469:                        if (jjtc011) {
1470:                            jjtree.clearNodeScope(jjtn011);
1471:                            jjtc011 = false;
1472:                        } else {
1473:                            jjtree.popNode();
1474:                        }
1475:                        if (jjte011 instanceof  RuntimeException) {
1476:                            {
1477:                                if (true)
1478:                                    throw (RuntimeException) jjte011;
1479:                            }
1480:                        }
1481:                        if (jjte011 instanceof  ParseException) {
1482:                            {
1483:                                if (true)
1484:                                    throw (ParseException) jjte011;
1485:                            }
1486:                        }
1487:                        {
1488:                            if (true)
1489:                                throw (Error) jjte011;
1490:                        }
1491:                    } finally {
1492:                        if (jjtc011) {
1493:                            jjtree.closeNodeScope(jjtn011, 2);
1494:                            jjtreeCloseNodeScope(jjtn011);
1495:                        }
1496:                    }
1497:                    break;
1498:                case POWEREQ:
1499:                    jj_consume_token(POWEREQ);
1500:                    SimpleNode jjtn012 = (SimpleNode) SimpleNode.jjtCreate(
1501:                            this , JJTAUG_POWER);
1502:                    boolean jjtc012 = true;
1503:                    jjtree.openNodeScope(jjtn012);
1504:                    jjtreeOpenNodeScope(jjtn012);
1505:                    try {
1506:                        SmartTestList();
1507:                    } catch (Throwable jjte012) {
1508:                        if (jjtc012) {
1509:                            jjtree.clearNodeScope(jjtn012);
1510:                            jjtc012 = false;
1511:                        } else {
1512:                            jjtree.popNode();
1513:                        }
1514:                        if (jjte012 instanceof  RuntimeException) {
1515:                            {
1516:                                if (true)
1517:                                    throw (RuntimeException) jjte012;
1518:                            }
1519:                        }
1520:                        if (jjte012 instanceof  ParseException) {
1521:                            {
1522:                                if (true)
1523:                                    throw (ParseException) jjte012;
1524:                            }
1525:                        }
1526:                        {
1527:                            if (true)
1528:                                throw (Error) jjte012;
1529:                        }
1530:                    } finally {
1531:                        if (jjtc012) {
1532:                            jjtree.closeNodeScope(jjtn012, 2);
1533:                            jjtreeCloseNodeScope(jjtn012);
1534:                        }
1535:                    }
1536:                    break;
1537:                default:
1538:                    jj_la1[20] = jj_gen;
1539:                    SimpleNode jjtn013 = (SimpleNode) SimpleNode.jjtCreate(
1540:                            this , JJTEXPR_STMT);
1541:                    boolean jjtc013 = true;
1542:                    jjtree.openNodeScope(jjtn013);
1543:                    jjtreeOpenNodeScope(jjtn013);
1544:                    try {
1545:                        label_9: while (true) {
1546:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1547:                            case EQUAL:
1548:                                ;
1549:                                break;
1550:                            default:
1551:                                jj_la1[19] = jj_gen;
1552:                                break label_9;
1553:                            }
1554:                            jj_consume_token(EQUAL);
1555:                            SmartTestList();
1556:                        }
1557:                    } catch (Throwable jjte013) {
1558:                        if (jjtc013) {
1559:                            jjtree.clearNodeScope(jjtn013);
1560:                            jjtc013 = false;
1561:                        } else {
1562:                            jjtree.popNode();
1563:                        }
1564:                        if (jjte013 instanceof  RuntimeException) {
1565:                            {
1566:                                if (true)
1567:                                    throw (RuntimeException) jjte013;
1568:                            }
1569:                        }
1570:                        if (jjte013 instanceof  ParseException) {
1571:                            {
1572:                                if (true)
1573:                                    throw (ParseException) jjte013;
1574:                            }
1575:                        }
1576:                        {
1577:                            if (true)
1578:                                throw (Error) jjte013;
1579:                        }
1580:                    } finally {
1581:                        if (jjtc013) {
1582:                            jjtree.closeNodeScope(jjtn013,
1583:                                    jjtree.nodeArity() + 1);
1584:                            jjtreeCloseNodeScope(jjtn013);
1585:                        }
1586:                    }
1587:                }
1588:            }
1589:
1590:            //print_stmt: 'print' (test ',')* [test] | 'print' '>>' test (, test)+ [,]
1591:            final public void print_stmt() throws ParseException {
1592:                if (jj_2_10(2)) {
1593:                    jj_consume_token(PRINT);
1594:                    jj_consume_token(RSHIFT);
1595:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
1596:                            this , JJTPRINTEXT_STMT);
1597:                    boolean jjtc001 = true;
1598:                    jjtree.openNodeScope(jjtn001);
1599:                    jjtreeOpenNodeScope(jjtn001);
1600:                    try {
1601:                        test();
1602:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1603:                        case COMMA:
1604:                            label_10: while (true) {
1605:                                jj_consume_token(COMMA);
1606:                                test();
1607:                                if (jj_2_8(2)) {
1608:                                    ;
1609:                                } else {
1610:                                    break label_10;
1611:                                }
1612:                            }
1613:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1614:                            case COMMA:
1615:                                Comma();
1616:                                break;
1617:                            default:
1618:                                jj_la1[21] = jj_gen;
1619:                                ;
1620:                            }
1621:                            break;
1622:                        default:
1623:                            jj_la1[22] = jj_gen;
1624:                            ;
1625:                        }
1626:                    } catch (Throwable jjte001) {
1627:                        if (jjtc001) {
1628:                            jjtree.clearNodeScope(jjtn001);
1629:                            jjtc001 = false;
1630:                        } else {
1631:                            jjtree.popNode();
1632:                        }
1633:                        if (jjte001 instanceof  RuntimeException) {
1634:                            {
1635:                                if (true)
1636:                                    throw (RuntimeException) jjte001;
1637:                            }
1638:                        }
1639:                        if (jjte001 instanceof  ParseException) {
1640:                            {
1641:                                if (true)
1642:                                    throw (ParseException) jjte001;
1643:                            }
1644:                        }
1645:                        {
1646:                            if (true)
1647:                                throw (Error) jjte001;
1648:                        }
1649:                    } finally {
1650:                        if (jjtc001) {
1651:                            jjtree.closeNodeScope(jjtn001, true);
1652:                            jjtreeCloseNodeScope(jjtn001);
1653:                        }
1654:                    }
1655:                } else if (jj_2_11(2)) {
1656:                    jj_consume_token(PRINT);
1657:                    SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
1658:                            this , JJTPRINT_STMT);
1659:                    boolean jjtc002 = true;
1660:                    jjtree.openNodeScope(jjtn002);
1661:                    jjtreeOpenNodeScope(jjtn002);
1662:                    try {
1663:                        test();
1664:                        label_11: while (true) {
1665:                            if (jj_2_9(2)) {
1666:                                ;
1667:                            } else {
1668:                                break label_11;
1669:                            }
1670:                            jj_consume_token(COMMA);
1671:                            test();
1672:                        }
1673:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1674:                        case COMMA:
1675:                            Comma();
1676:                            break;
1677:                        default:
1678:                            jj_la1[23] = jj_gen;
1679:                            ;
1680:                        }
1681:                    } catch (Throwable jjte002) {
1682:                        if (jjtc002) {
1683:                            jjtree.clearNodeScope(jjtn002);
1684:                            jjtc002 = false;
1685:                        } else {
1686:                            jjtree.popNode();
1687:                        }
1688:                        if (jjte002 instanceof  RuntimeException) {
1689:                            {
1690:                                if (true)
1691:                                    throw (RuntimeException) jjte002;
1692:                            }
1693:                        }
1694:                        if (jjte002 instanceof  ParseException) {
1695:                            {
1696:                                if (true)
1697:                                    throw (ParseException) jjte002;
1698:                            }
1699:                        }
1700:                        {
1701:                            if (true)
1702:                                throw (Error) jjte002;
1703:                        }
1704:                    } finally {
1705:                        if (jjtc002) {
1706:                            jjtree.closeNodeScope(jjtn002, true);
1707:                            jjtreeCloseNodeScope(jjtn002);
1708:                        }
1709:                    }
1710:                } else {
1711:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1712:                    case PRINT:
1713:                        SimpleNode jjtn003 = (SimpleNode) SimpleNode.jjtCreate(
1714:                                this , JJTPRINT_STMT);
1715:                        boolean jjtc003 = true;
1716:                        jjtree.openNodeScope(jjtn003);
1717:                        jjtreeOpenNodeScope(jjtn003);
1718:                        try {
1719:                            jj_consume_token(PRINT);
1720:                        } finally {
1721:                            if (jjtc003) {
1722:                                jjtree.closeNodeScope(jjtn003, true);
1723:                                jjtreeCloseNodeScope(jjtn003);
1724:                            }
1725:                        }
1726:                        break;
1727:                    default:
1728:                        jj_la1[24] = jj_gen;
1729:                        jj_consume_token(-1);
1730:                        throw new ParseException();
1731:                    }
1732:                }
1733:            }
1734:
1735:            //del_stmt: 'del' exprlist
1736:            final public void del_stmt() throws ParseException {
1737:                /*@bgen(jjtree) del_stmt */
1738:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
1739:                        JJTDEL_STMT);
1740:                boolean jjtc000 = true;
1741:                jjtree.openNodeScope(jjtn000);
1742:                jjtreeOpenNodeScope(jjtn000);
1743:                try {
1744:                    jj_consume_token(DEL);
1745:                    exprlist();
1746:                } catch (Throwable jjte000) {
1747:                    if (jjtc000) {
1748:                        jjtree.clearNodeScope(jjtn000);
1749:                        jjtc000 = false;
1750:                    } else {
1751:                        jjtree.popNode();
1752:                    }
1753:                    if (jjte000 instanceof  RuntimeException) {
1754:                        {
1755:                            if (true)
1756:                                throw (RuntimeException) jjte000;
1757:                        }
1758:                    }
1759:                    if (jjte000 instanceof  ParseException) {
1760:                        {
1761:                            if (true)
1762:                                throw (ParseException) jjte000;
1763:                        }
1764:                    }
1765:                    {
1766:                        if (true)
1767:                            throw (Error) jjte000;
1768:                    }
1769:                } finally {
1770:                    if (jjtc000) {
1771:                        jjtree.closeNodeScope(jjtn000, true);
1772:                        jjtreeCloseNodeScope(jjtn000);
1773:                    }
1774:                }
1775:            }
1776:
1777:            //pass_stmt: 'pass'
1778:            final public void pass_stmt() throws ParseException {
1779:                /*@bgen(jjtree) pass_stmt */
1780:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
1781:                        JJTPASS_STMT);
1782:                boolean jjtc000 = true;
1783:                jjtree.openNodeScope(jjtn000);
1784:                jjtreeOpenNodeScope(jjtn000);
1785:                try {
1786:                    jj_consume_token(PASS);
1787:                } finally {
1788:                    if (jjtc000) {
1789:                        jjtree.closeNodeScope(jjtn000, true);
1790:                        jjtreeCloseNodeScope(jjtn000);
1791:                    }
1792:                }
1793:            }
1794:
1795:            //flow_stmt: break_stmt | continue_stmt | return_stmt | yield_stmt | raise_stmt
1796:            final public void flow_stmt() throws ParseException {
1797:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1798:                case BREAK:
1799:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
1800:                            this , JJTBREAK_STMT);
1801:                    boolean jjtc001 = true;
1802:                    jjtree.openNodeScope(jjtn001);
1803:                    jjtreeOpenNodeScope(jjtn001);
1804:                    try {
1805:                        jj_consume_token(BREAK);
1806:                    } finally {
1807:                        if (jjtc001) {
1808:                            jjtree.closeNodeScope(jjtn001, 0);
1809:                            jjtreeCloseNodeScope(jjtn001);
1810:                        }
1811:                    }
1812:                    break;
1813:                case CONTINUE:
1814:                    SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
1815:                            this , JJTCONTINUE_STMT);
1816:                    boolean jjtc002 = true;
1817:                    jjtree.openNodeScope(jjtn002);
1818:                    jjtreeOpenNodeScope(jjtn002);
1819:                    try {
1820:                        jj_consume_token(CONTINUE);
1821:                    } finally {
1822:                        if (jjtc002) {
1823:                            jjtree.closeNodeScope(jjtn002, 0);
1824:                            jjtreeCloseNodeScope(jjtn002);
1825:                        }
1826:                    }
1827:                    break;
1828:                case RETURN:
1829:                    return_stmt();
1830:                    break;
1831:                case YIELD:
1832:                    yield_stmt();
1833:                    break;
1834:                case RAISE:
1835:                    raise_stmt();
1836:                    break;
1837:                default:
1838:                    jj_la1[25] = jj_gen;
1839:                    jj_consume_token(-1);
1840:                    throw new ParseException();
1841:                }
1842:            }
1843:
1844:            //return_stmt: 'return' [testlist]
1845:            final public void return_stmt() throws ParseException {
1846:                /*@bgen(jjtree) return_stmt */
1847:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
1848:                        JJTRETURN_STMT);
1849:                boolean jjtc000 = true;
1850:                jjtree.openNodeScope(jjtn000);
1851:                jjtreeOpenNodeScope(jjtn000);
1852:                try {
1853:                    jj_consume_token(RETURN);
1854:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1855:                    case LPAREN:
1856:                    case LBRACE:
1857:                    case LBRACKET:
1858:                    case PLUS:
1859:                    case MINUS:
1860:                    case NOT:
1861:                    case NOT_BOOL:
1862:                    case LAMBDA:
1863:                    case AS:
1864:                    case NAME:
1865:                    case DECNUMBER:
1866:                    case HEXNUMBER:
1867:                    case OCTNUMBER:
1868:                    case FLOAT:
1869:                    case COMPLEX:
1870:                    case SINGLE_STRING:
1871:                    case SINGLE_STRING2:
1872:                    case TRIPLE_STRING:
1873:                    case TRIPLE_STRING2:
1874:                    case SINGLE_USTRING:
1875:                    case SINGLE_USTRING2:
1876:                    case TRIPLE_USTRING:
1877:                    case TRIPLE_USTRING2:
1878:                    case 135:
1879:                        SmartTestList();
1880:                        break;
1881:                    default:
1882:                        jj_la1[26] = jj_gen;
1883:                        ;
1884:                    }
1885:                } catch (Throwable jjte000) {
1886:                    if (jjtc000) {
1887:                        jjtree.clearNodeScope(jjtn000);
1888:                        jjtc000 = false;
1889:                    } else {
1890:                        jjtree.popNode();
1891:                    }
1892:                    if (jjte000 instanceof  RuntimeException) {
1893:                        {
1894:                            if (true)
1895:                                throw (RuntimeException) jjte000;
1896:                        }
1897:                    }
1898:                    if (jjte000 instanceof  ParseException) {
1899:                        {
1900:                            if (true)
1901:                                throw (ParseException) jjte000;
1902:                        }
1903:                    }
1904:                    {
1905:                        if (true)
1906:                            throw (Error) jjte000;
1907:                    }
1908:                } finally {
1909:                    if (jjtc000) {
1910:                        jjtree.closeNodeScope(jjtn000, true);
1911:                        jjtreeCloseNodeScope(jjtn000);
1912:                    }
1913:                }
1914:            }
1915:
1916:            //yield_stmt: 'yield' [testlist]
1917:            final public void yield_stmt() throws ParseException {
1918:                /*@bgen(jjtree) yield_stmt */
1919:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
1920:                        JJTYIELD_STMT);
1921:                boolean jjtc000 = true;
1922:                jjtree.openNodeScope(jjtn000);
1923:                jjtreeOpenNodeScope(jjtn000);
1924:                try {
1925:                    jj_consume_token(YIELD);
1926:                    SmartTestList();
1927:                } catch (Throwable jjte000) {
1928:                    if (jjtc000) {
1929:                        jjtree.clearNodeScope(jjtn000);
1930:                        jjtc000 = false;
1931:                    } else {
1932:                        jjtree.popNode();
1933:                    }
1934:                    if (jjte000 instanceof  RuntimeException) {
1935:                        {
1936:                            if (true)
1937:                                throw (RuntimeException) jjte000;
1938:                        }
1939:                    }
1940:                    if (jjte000 instanceof  ParseException) {
1941:                        {
1942:                            if (true)
1943:                                throw (ParseException) jjte000;
1944:                        }
1945:                    }
1946:                    {
1947:                        if (true)
1948:                            throw (Error) jjte000;
1949:                    }
1950:                } finally {
1951:                    if (jjtc000) {
1952:                        jjtree.closeNodeScope(jjtn000, true);
1953:                        jjtreeCloseNodeScope(jjtn000);
1954:                    }
1955:                }
1956:            }
1957:
1958:            //raise_stmt: 'raise' [test [',' test [',' test]]]
1959:            final public void raise_stmt() throws ParseException {
1960:                /*@bgen(jjtree) raise_stmt */
1961:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
1962:                        JJTRAISE_STMT);
1963:                boolean jjtc000 = true;
1964:                jjtree.openNodeScope(jjtn000);
1965:                jjtreeOpenNodeScope(jjtn000);
1966:                try {
1967:                    jj_consume_token(RAISE);
1968:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1969:                    case LPAREN:
1970:                    case LBRACE:
1971:                    case LBRACKET:
1972:                    case PLUS:
1973:                    case MINUS:
1974:                    case NOT:
1975:                    case NOT_BOOL:
1976:                    case LAMBDA:
1977:                    case AS:
1978:                    case NAME:
1979:                    case DECNUMBER:
1980:                    case HEXNUMBER:
1981:                    case OCTNUMBER:
1982:                    case FLOAT:
1983:                    case COMPLEX:
1984:                    case SINGLE_STRING:
1985:                    case SINGLE_STRING2:
1986:                    case TRIPLE_STRING:
1987:                    case TRIPLE_STRING2:
1988:                    case SINGLE_USTRING:
1989:                    case SINGLE_USTRING2:
1990:                    case TRIPLE_USTRING:
1991:                    case TRIPLE_USTRING2:
1992:                    case 135:
1993:                        test();
1994:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1995:                        case COMMA:
1996:                            jj_consume_token(COMMA);
1997:                            test();
1998:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1999:                            case COMMA:
2000:                                jj_consume_token(COMMA);
2001:                                test();
2002:                                break;
2003:                            default:
2004:                                jj_la1[27] = jj_gen;
2005:                                ;
2006:                            }
2007:                            break;
2008:                        default:
2009:                            jj_la1[28] = jj_gen;
2010:                            ;
2011:                        }
2012:                        break;
2013:                    default:
2014:                        jj_la1[29] = jj_gen;
2015:                        ;
2016:                    }
2017:                } catch (Throwable jjte000) {
2018:                    if (jjtc000) {
2019:                        jjtree.clearNodeScope(jjtn000);
2020:                        jjtc000 = false;
2021:                    } else {
2022:                        jjtree.popNode();
2023:                    }
2024:                    if (jjte000 instanceof  RuntimeException) {
2025:                        {
2026:                            if (true)
2027:                                throw (RuntimeException) jjte000;
2028:                        }
2029:                    }
2030:                    if (jjte000 instanceof  ParseException) {
2031:                        {
2032:                            if (true)
2033:                                throw (ParseException) jjte000;
2034:                        }
2035:                    }
2036:                    {
2037:                        if (true)
2038:                            throw (Error) jjte000;
2039:                    }
2040:                } finally {
2041:                    if (jjtc000) {
2042:                        jjtree.closeNodeScope(jjtn000, true);
2043:                        jjtreeCloseNodeScope(jjtn000);
2044:                    }
2045:                }
2046:            }
2047:
2048:            //import_stmt: 'import' dotted_name (',' dotted_name)* | 'from' dotted_name 'import' ('*' | NAME (',' NAME)*)
2049:            final public void import_stmt() throws ParseException {
2050:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2051:                case IMPORT:
2052:                    jj_consume_token(IMPORT);
2053:                    Import();
2054:                    break;
2055:                case FROM:
2056:                    jj_consume_token(FROM);
2057:                    ImportFrom();
2058:                    break;
2059:                default:
2060:                    jj_la1[30] = jj_gen;
2061:                    jj_consume_token(-1);
2062:                    throw new ParseException();
2063:                }
2064:            }
2065:
2066:            final public void Import() throws ParseException {
2067:                /*@bgen(jjtree) Import */
2068:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2069:                        JJTIMPORT);
2070:                boolean jjtc000 = true;
2071:                jjtree.openNodeScope(jjtn000);
2072:                jjtreeOpenNodeScope(jjtn000);
2073:                try {
2074:                    dotted_as_name();
2075:                    label_12: while (true) {
2076:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2077:                        case COMMA:
2078:                            ;
2079:                            break;
2080:                        default:
2081:                            jj_la1[31] = jj_gen;
2082:                            break label_12;
2083:                        }
2084:                        jj_consume_token(COMMA);
2085:                        dotted_as_name();
2086:                    }
2087:                } catch (Throwable jjte000) {
2088:                    if (jjtc000) {
2089:                        jjtree.clearNodeScope(jjtn000);
2090:                        jjtc000 = false;
2091:                    } else {
2092:                        jjtree.popNode();
2093:                    }
2094:                    if (jjte000 instanceof  RuntimeException) {
2095:                        {
2096:                            if (true)
2097:                                throw (RuntimeException) jjte000;
2098:                        }
2099:                    }
2100:                    if (jjte000 instanceof  ParseException) {
2101:                        {
2102:                            if (true)
2103:                                throw (ParseException) jjte000;
2104:                        }
2105:                    }
2106:                    {
2107:                        if (true)
2108:                            throw (Error) jjte000;
2109:                    }
2110:                } finally {
2111:                    if (jjtc000) {
2112:                        jjtree.closeNodeScope(jjtn000, true);
2113:                        jjtreeCloseNodeScope(jjtn000);
2114:                    }
2115:                }
2116:            }
2117:
2118:            final public void ImportFrom() throws ParseException {
2119:                /*@bgen(jjtree) ImportFrom */
2120:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2121:                        JJTIMPORTFROM);
2122:                boolean jjtc000 = true;
2123:                jjtree.openNodeScope(jjtn000);
2124:                jjtreeOpenNodeScope(jjtn000);
2125:                String mod;
2126:                String name;
2127:                try {
2128:                    mod = dotted_name();
2129:                    jj_consume_token(IMPORT);
2130:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2131:                    case MULTIPLY:
2132:                        jj_consume_token(MULTIPLY);
2133:                        break;
2134:                    case OR_BOOL:
2135:                    case AND_BOOL:
2136:                    case NOT_BOOL:
2137:                    case IS:
2138:                    case IN:
2139:                    case LAMBDA:
2140:                    case IF:
2141:                    case ELSE:
2142:                    case ELIF:
2143:                    case WHILE:
2144:                    case FOR:
2145:                    case TRY:
2146:                    case EXCEPT:
2147:                    case DEF:
2148:                    case CLASS:
2149:                    case FINALLY:
2150:                    case PRINT:
2151:                    case PASS:
2152:                    case BREAK:
2153:                    case CONTINUE:
2154:                    case RETURN:
2155:                    case YIELD:
2156:                    case IMPORT:
2157:                    case FROM:
2158:                    case DEL:
2159:                    case RAISE:
2160:                    case GLOBAL:
2161:                    case EXEC:
2162:                    case ASSERT:
2163:                    case AS:
2164:                    case NAME:
2165:                        name = import_as_name();
2166:                        label_13: while (true) {
2167:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2168:                            case COMMA:
2169:                                ;
2170:                                break;
2171:                            default:
2172:                                jj_la1[32] = jj_gen;
2173:                                break label_13;
2174:                            }
2175:                            jj_consume_token(COMMA);
2176:                            import_as_name();
2177:                        }
2178:                        jjtree.closeNodeScope(jjtn000, true);
2179:                        jjtc000 = false;
2180:                        jjtreeCloseNodeScope(jjtn000);
2181:                        if (mod.equals("__future__")
2182:                                && name.equals("generators"))
2183:                            token_source.generator_allowed = true;
2184:                        break;
2185:                    default:
2186:                        jj_la1[33] = jj_gen;
2187:                        jj_consume_token(-1);
2188:                        throw new ParseException();
2189:                    }
2190:                } catch (Throwable jjte000) {
2191:                    if (jjtc000) {
2192:                        jjtree.clearNodeScope(jjtn000);
2193:                        jjtc000 = false;
2194:                    } else {
2195:                        jjtree.popNode();
2196:                    }
2197:                    if (jjte000 instanceof  RuntimeException) {
2198:                        {
2199:                            if (true)
2200:                                throw (RuntimeException) jjte000;
2201:                        }
2202:                    }
2203:                    if (jjte000 instanceof  ParseException) {
2204:                        {
2205:                            if (true)
2206:                                throw (ParseException) jjte000;
2207:                        }
2208:                    }
2209:                    {
2210:                        if (true)
2211:                            throw (Error) jjte000;
2212:                    }
2213:                } finally {
2214:                    if (jjtc000) {
2215:                        jjtree.closeNodeScope(jjtn000, true);
2216:                        jjtreeCloseNodeScope(jjtn000);
2217:                    }
2218:                }
2219:            }
2220:
2221:            //dotted_as_name: dotted_name [NAME NAME]
2222:            final public void dotted_as_name() throws ParseException {
2223:                /*@bgen(jjtree) dotted_as_name */
2224:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2225:                        JJTDOTTED_AS_NAME);
2226:                boolean jjtc000 = true;
2227:                jjtree.openNodeScope(jjtn000);
2228:                jjtreeOpenNodeScope(jjtn000);
2229:                try {
2230:                    dotted_name();
2231:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2232:                    case AS:
2233:                        jj_consume_token(AS);
2234:                        Name();
2235:                        break;
2236:                    default:
2237:                        jj_la1[34] = jj_gen;
2238:                        ;
2239:                    }
2240:                } catch (Throwable jjte000) {
2241:                    if (jjtc000) {
2242:                        jjtree.clearNodeScope(jjtn000);
2243:                        jjtc000 = false;
2244:                    } else {
2245:                        jjtree.popNode();
2246:                    }
2247:                    if (jjte000 instanceof  RuntimeException) {
2248:                        {
2249:                            if (true)
2250:                                throw (RuntimeException) jjte000;
2251:                        }
2252:                    }
2253:                    if (jjte000 instanceof  ParseException) {
2254:                        {
2255:                            if (true)
2256:                                throw (ParseException) jjte000;
2257:                        }
2258:                    }
2259:                    {
2260:                        if (true)
2261:                            throw (Error) jjte000;
2262:                    }
2263:                } finally {
2264:                    if (jjtc000) {
2265:                        jjtree.closeNodeScope(jjtn000, true);
2266:                        jjtreeCloseNodeScope(jjtn000);
2267:                    }
2268:                }
2269:            }
2270:
2271:            //dotted_name: NAME ('.' NAME)*
2272:            final public String dotted_name() throws ParseException {
2273:                /*@bgen(jjtree) dotted_name */
2274:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2275:                        JJTDOTTED_NAME);
2276:                boolean jjtc000 = true;
2277:                jjtree.openNodeScope(jjtn000);
2278:                jjtreeOpenNodeScope(jjtn000);
2279:                Token t;
2280:                StringBuffer sb = new StringBuffer();
2281:                try {
2282:                    t = AnyName();
2283:                    sb.append(t.image);
2284:                    label_14: while (true) {
2285:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2286:                        case DOT:
2287:                            ;
2288:                            break;
2289:                        default:
2290:                            jj_la1[35] = jj_gen;
2291:                            break label_14;
2292:                        }
2293:                        jj_consume_token(DOT);
2294:                        t = AnyName();
2295:                        sb.append("." + t.image);
2296:                    }
2297:                    jjtree.closeNodeScope(jjtn000, true);
2298:                    jjtc000 = false;
2299:                    jjtreeCloseNodeScope(jjtn000);
2300:                    {
2301:                        if (true)
2302:                            return sb.toString();
2303:                    }
2304:                } catch (Throwable jjte000) {
2305:                    if (jjtc000) {
2306:                        jjtree.clearNodeScope(jjtn000);
2307:                        jjtc000 = false;
2308:                    } else {
2309:                        jjtree.popNode();
2310:                    }
2311:                    if (jjte000 instanceof  RuntimeException) {
2312:                        {
2313:                            if (true)
2314:                                throw (RuntimeException) jjte000;
2315:                        }
2316:                    }
2317:                    if (jjte000 instanceof  ParseException) {
2318:                        {
2319:                            if (true)
2320:                                throw (ParseException) jjte000;
2321:                        }
2322:                    }
2323:                    {
2324:                        if (true)
2325:                            throw (Error) jjte000;
2326:                    }
2327:                } finally {
2328:                    if (jjtc000) {
2329:                        jjtree.closeNodeScope(jjtn000, true);
2330:                        jjtreeCloseNodeScope(jjtn000);
2331:                    }
2332:                }
2333:                throw new Error("Missing return statement in function");
2334:            }
2335:
2336:            //import_as_name: NAME [NAME NAME]
2337:            final public String import_as_name() throws ParseException {
2338:                /*@bgen(jjtree) import_as_name */
2339:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2340:                        JJTIMPORT_AS_NAME);
2341:                boolean jjtc000 = true;
2342:                jjtree.openNodeScope(jjtn000);
2343:                jjtreeOpenNodeScope(jjtn000);
2344:                Token t;
2345:                try {
2346:                    t = AnyName();
2347:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2348:                    case AS:
2349:                        jj_consume_token(AS);
2350:                        Name();
2351:                        break;
2352:                    default:
2353:                        jj_la1[36] = jj_gen;
2354:                        ;
2355:                    }
2356:                    jjtree.closeNodeScope(jjtn000, true);
2357:                    jjtc000 = false;
2358:                    jjtreeCloseNodeScope(jjtn000);
2359:                    {
2360:                        if (true)
2361:                            return t.image;
2362:                    }
2363:                } catch (Throwable jjte000) {
2364:                    if (jjtc000) {
2365:                        jjtree.clearNodeScope(jjtn000);
2366:                        jjtc000 = false;
2367:                    } else {
2368:                        jjtree.popNode();
2369:                    }
2370:                    if (jjte000 instanceof  RuntimeException) {
2371:                        {
2372:                            if (true)
2373:                                throw (RuntimeException) jjte000;
2374:                        }
2375:                    }
2376:                    if (jjte000 instanceof  ParseException) {
2377:                        {
2378:                            if (true)
2379:                                throw (ParseException) jjte000;
2380:                        }
2381:                    }
2382:                    {
2383:                        if (true)
2384:                            throw (Error) jjte000;
2385:                    }
2386:                } finally {
2387:                    if (jjtc000) {
2388:                        jjtree.closeNodeScope(jjtn000, true);
2389:                        jjtreeCloseNodeScope(jjtn000);
2390:                    }
2391:                }
2392:                throw new Error("Missing return statement in function");
2393:            }
2394:
2395:            //global_stmt: 'global' NAME (',' NAME)*
2396:            final public void global_stmt() throws ParseException {
2397:                /*@bgen(jjtree) global_stmt */
2398:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2399:                        JJTGLOBAL_STMT);
2400:                boolean jjtc000 = true;
2401:                jjtree.openNodeScope(jjtn000);
2402:                jjtreeOpenNodeScope(jjtn000);
2403:                try {
2404:                    jj_consume_token(GLOBAL);
2405:                    Name();
2406:                    label_15: while (true) {
2407:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2408:                        case COMMA:
2409:                            ;
2410:                            break;
2411:                        default:
2412:                            jj_la1[37] = jj_gen;
2413:                            break label_15;
2414:                        }
2415:                        jj_consume_token(COMMA);
2416:                        Name();
2417:                    }
2418:                } catch (Throwable jjte000) {
2419:                    if (jjtc000) {
2420:                        jjtree.clearNodeScope(jjtn000);
2421:                        jjtc000 = false;
2422:                    } else {
2423:                        jjtree.popNode();
2424:                    }
2425:                    if (jjte000 instanceof  RuntimeException) {
2426:                        {
2427:                            if (true)
2428:                                throw (RuntimeException) jjte000;
2429:                        }
2430:                    }
2431:                    if (jjte000 instanceof  ParseException) {
2432:                        {
2433:                            if (true)
2434:                                throw (ParseException) jjte000;
2435:                        }
2436:                    }
2437:                    {
2438:                        if (true)
2439:                            throw (Error) jjte000;
2440:                    }
2441:                } finally {
2442:                    if (jjtc000) {
2443:                        jjtree.closeNodeScope(jjtn000, true);
2444:                        jjtreeCloseNodeScope(jjtn000);
2445:                    }
2446:                }
2447:            }
2448:
2449:            //exec_stmt: 'exec' expr ['in' test [',' test]]
2450:            final public void exec_stmt() throws ParseException {
2451:                /*@bgen(jjtree) exec_stmt */
2452:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2453:                        JJTEXEC_STMT);
2454:                boolean jjtc000 = true;
2455:                jjtree.openNodeScope(jjtn000);
2456:                jjtreeOpenNodeScope(jjtn000);
2457:                try {
2458:                    jj_consume_token(EXEC);
2459:                    expr();
2460:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2461:                    case IN:
2462:                        jj_consume_token(IN);
2463:                        test();
2464:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2465:                        case COMMA:
2466:                            jj_consume_token(COMMA);
2467:                            test();
2468:                            break;
2469:                        default:
2470:                            jj_la1[38] = jj_gen;
2471:                            ;
2472:                        }
2473:                        break;
2474:                    default:
2475:                        jj_la1[39] = jj_gen;
2476:                        ;
2477:                    }
2478:                } catch (Throwable jjte000) {
2479:                    if (jjtc000) {
2480:                        jjtree.clearNodeScope(jjtn000);
2481:                        jjtc000 = false;
2482:                    } else {
2483:                        jjtree.popNode();
2484:                    }
2485:                    if (jjte000 instanceof  RuntimeException) {
2486:                        {
2487:                            if (true)
2488:                                throw (RuntimeException) jjte000;
2489:                        }
2490:                    }
2491:                    if (jjte000 instanceof  ParseException) {
2492:                        {
2493:                            if (true)
2494:                                throw (ParseException) jjte000;
2495:                        }
2496:                    }
2497:                    {
2498:                        if (true)
2499:                            throw (Error) jjte000;
2500:                    }
2501:                } finally {
2502:                    if (jjtc000) {
2503:                        jjtree.closeNodeScope(jjtn000, true);
2504:                        jjtreeCloseNodeScope(jjtn000);
2505:                    }
2506:                }
2507:            }
2508:
2509:            //assert_stmt: 'assert' test [',' test]
2510:            final public void assert_stmt() throws ParseException {
2511:                /*@bgen(jjtree) assert_stmt */
2512:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2513:                        JJTASSERT_STMT);
2514:                boolean jjtc000 = true;
2515:                jjtree.openNodeScope(jjtn000);
2516:                jjtreeOpenNodeScope(jjtn000);
2517:                try {
2518:                    jj_consume_token(ASSERT);
2519:                    test();
2520:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2521:                    case COMMA:
2522:                        jj_consume_token(COMMA);
2523:                        test();
2524:                        break;
2525:                    default:
2526:                        jj_la1[40] = jj_gen;
2527:                        ;
2528:                    }
2529:                } catch (Throwable jjte000) {
2530:                    if (jjtc000) {
2531:                        jjtree.clearNodeScope(jjtn000);
2532:                        jjtc000 = false;
2533:                    } else {
2534:                        jjtree.popNode();
2535:                    }
2536:                    if (jjte000 instanceof  RuntimeException) {
2537:                        {
2538:                            if (true)
2539:                                throw (RuntimeException) jjte000;
2540:                        }
2541:                    }
2542:                    if (jjte000 instanceof  ParseException) {
2543:                        {
2544:                            if (true)
2545:                                throw (ParseException) jjte000;
2546:                        }
2547:                    }
2548:                    {
2549:                        if (true)
2550:                            throw (Error) jjte000;
2551:                    }
2552:                } finally {
2553:                    if (jjtc000) {
2554:                        jjtree.closeNodeScope(jjtn000, true);
2555:                        jjtreeCloseNodeScope(jjtn000);
2556:                    }
2557:                }
2558:            }
2559:
2560:            //compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef
2561:            final public void compound_stmt() throws ParseException {
2562:                token_source.compound = true;
2563:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2564:                case IF:
2565:                    if_stmt();
2566:                    break;
2567:                case WHILE:
2568:                    while_stmt();
2569:                    break;
2570:                case FOR:
2571:                    for_stmt();
2572:                    break;
2573:                case TRY:
2574:                    try_stmt();
2575:                    break;
2576:                case DEF:
2577:                    funcdef();
2578:                    break;
2579:                case CLASS:
2580:                    classdef();
2581:                    break;
2582:                default:
2583:                    jj_la1[41] = jj_gen;
2584:                    jj_consume_token(-1);
2585:                    throw new ParseException();
2586:                }
2587:            }
2588:
2589:            //if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
2590:            final public void if_stmt() throws ParseException {
2591:                /*@bgen(jjtree) if_stmt */
2592:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2593:                        JJTIF_STMT);
2594:                boolean jjtc000 = true;
2595:                jjtree.openNodeScope(jjtn000);
2596:                jjtreeOpenNodeScope(jjtn000);
2597:                try {
2598:                    jj_consume_token(IF);
2599:                    test();
2600:                    jj_consume_token(COLON);
2601:                    suite();
2602:                    label_16: while (true) {
2603:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2604:                        case ELIF:
2605:                            ;
2606:                            break;
2607:                        default:
2608:                            jj_la1[42] = jj_gen;
2609:                            break label_16;
2610:                        }
2611:                        jj_consume_token(ELIF);
2612:                        test();
2613:                        jj_consume_token(COLON);
2614:                        suite();
2615:                    }
2616:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2617:                    case ELSE:
2618:                        jj_consume_token(ELSE);
2619:                        jj_consume_token(COLON);
2620:                        suite();
2621:                        break;
2622:                    default:
2623:                        jj_la1[43] = jj_gen;
2624:                        ;
2625:                    }
2626:                } catch (Throwable jjte000) {
2627:                    if (jjtc000) {
2628:                        jjtree.clearNodeScope(jjtn000);
2629:                        jjtc000 = false;
2630:                    } else {
2631:                        jjtree.popNode();
2632:                    }
2633:                    if (jjte000 instanceof  RuntimeException) {
2634:                        {
2635:                            if (true)
2636:                                throw (RuntimeException) jjte000;
2637:                        }
2638:                    }
2639:                    if (jjte000 instanceof  ParseException) {
2640:                        {
2641:                            if (true)
2642:                                throw (ParseException) jjte000;
2643:                        }
2644:                    }
2645:                    {
2646:                        if (true)
2647:                            throw (Error) jjte000;
2648:                    }
2649:                } finally {
2650:                    if (jjtc000) {
2651:                        jjtree.closeNodeScope(jjtn000, true);
2652:                        jjtreeCloseNodeScope(jjtn000);
2653:                    }
2654:                }
2655:            }
2656:
2657:            //while_stmt: 'while' test ':' suite ['else' ':' suite]
2658:            final public void while_stmt() throws ParseException {
2659:                /*@bgen(jjtree) while_stmt */
2660:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2661:                        JJTWHILE_STMT);
2662:                boolean jjtc000 = true;
2663:                jjtree.openNodeScope(jjtn000);
2664:                jjtreeOpenNodeScope(jjtn000);
2665:                try {
2666:                    jj_consume_token(WHILE);
2667:                    test();
2668:                    jj_consume_token(COLON);
2669:                    suite();
2670:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2671:                    case ELSE:
2672:                        jj_consume_token(ELSE);
2673:                        jj_consume_token(COLON);
2674:                        suite();
2675:                        break;
2676:                    default:
2677:                        jj_la1[44] = jj_gen;
2678:                        ;
2679:                    }
2680:                } catch (Throwable jjte000) {
2681:                    if (jjtc000) {
2682:                        jjtree.clearNodeScope(jjtn000);
2683:                        jjtc000 = false;
2684:                    } else {
2685:                        jjtree.popNode();
2686:                    }
2687:                    if (jjte000 instanceof  RuntimeException) {
2688:                        {
2689:                            if (true)
2690:                                throw (RuntimeException) jjte000;
2691:                        }
2692:                    }
2693:                    if (jjte000 instanceof  ParseException) {
2694:                        {
2695:                            if (true)
2696:                                throw (ParseException) jjte000;
2697:                        }
2698:                    }
2699:                    {
2700:                        if (true)
2701:                            throw (Error) jjte000;
2702:                    }
2703:                } finally {
2704:                    if (jjtc000) {
2705:                        jjtree.closeNodeScope(jjtn000, true);
2706:                        jjtreeCloseNodeScope(jjtn000);
2707:                    }
2708:                }
2709:            }
2710:
2711:            //for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
2712:            final public void for_stmt() throws ParseException {
2713:                /*@bgen(jjtree) for_stmt */
2714:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2715:                        JJTFOR_STMT);
2716:                boolean jjtc000 = true;
2717:                jjtree.openNodeScope(jjtn000);
2718:                jjtreeOpenNodeScope(jjtn000);
2719:                try {
2720:                    jj_consume_token(FOR);
2721:                    exprlist();
2722:                    jj_consume_token(IN);
2723:                    SmartTestList();
2724:                    jj_consume_token(COLON);
2725:                    suite();
2726:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2727:                    case ELSE:
2728:                        jj_consume_token(ELSE);
2729:                        jj_consume_token(COLON);
2730:                        suite();
2731:                        break;
2732:                    default:
2733:                        jj_la1[45] = jj_gen;
2734:                        ;
2735:                    }
2736:                } catch (Throwable jjte000) {
2737:                    if (jjtc000) {
2738:                        jjtree.clearNodeScope(jjtn000);
2739:                        jjtc000 = false;
2740:                    } else {
2741:                        jjtree.popNode();
2742:                    }
2743:                    if (jjte000 instanceof  RuntimeException) {
2744:                        {
2745:                            if (true)
2746:                                throw (RuntimeException) jjte000;
2747:                        }
2748:                    }
2749:                    if (jjte000 instanceof  ParseException) {
2750:                        {
2751:                            if (true)
2752:                                throw (ParseException) jjte000;
2753:                        }
2754:                    }
2755:                    {
2756:                        if (true)
2757:                            throw (Error) jjte000;
2758:                    }
2759:                } finally {
2760:                    if (jjtc000) {
2761:                        jjtree.closeNodeScope(jjtn000, true);
2762:                        jjtreeCloseNodeScope(jjtn000);
2763:                    }
2764:                }
2765:            }
2766:
2767:            //try_stmt: ('try' ':' suite (except_clause ':' suite)+ #diagram:break
2768:            //           ['else' ':' suite] | 'try' ':' suite 'finally' ':' suite)
2769:            final public void try_stmt() throws ParseException {
2770:                jj_consume_token(TRY);
2771:                jj_consume_token(COLON);
2772:                suite();
2773:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2774:                case EXCEPT:
2775:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
2776:                            this , JJTTRY_STMT);
2777:                    boolean jjtc001 = true;
2778:                    jjtree.openNodeScope(jjtn001);
2779:                    jjtreeOpenNodeScope(jjtn001);
2780:                    try {
2781:                        label_17: while (true) {
2782:                            except_clause();
2783:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2784:                            case EXCEPT:
2785:                                ;
2786:                                break;
2787:                            default:
2788:                                jj_la1[46] = jj_gen;
2789:                                break label_17;
2790:                            }
2791:                        }
2792:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2793:                        case ELSE:
2794:                            jj_consume_token(ELSE);
2795:                            jj_consume_token(COLON);
2796:                            suite();
2797:                            break;
2798:                        default:
2799:                            jj_la1[47] = jj_gen;
2800:                            ;
2801:                        }
2802:                    } catch (Throwable jjte001) {
2803:                        if (jjtc001) {
2804:                            jjtree.clearNodeScope(jjtn001);
2805:                            jjtc001 = false;
2806:                        } else {
2807:                            jjtree.popNode();
2808:                        }
2809:                        if (jjte001 instanceof  RuntimeException) {
2810:                            {
2811:                                if (true)
2812:                                    throw (RuntimeException) jjte001;
2813:                            }
2814:                        }
2815:                        if (jjte001 instanceof  ParseException) {
2816:                            {
2817:                                if (true)
2818:                                    throw (ParseException) jjte001;
2819:                            }
2820:                        }
2821:                        {
2822:                            if (true)
2823:                                throw (Error) jjte001;
2824:                        }
2825:                    } finally {
2826:                        if (jjtc001) {
2827:                            jjtree.closeNodeScope(jjtn001,
2828:                                    jjtree.nodeArity() + 1);
2829:                            jjtreeCloseNodeScope(jjtn001);
2830:                        }
2831:                    }
2832:                    break;
2833:                case FINALLY:
2834:                    jj_consume_token(FINALLY);
2835:                    jj_consume_token(COLON);
2836:                    SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
2837:                            this , JJTTRYFINALLY_STMT);
2838:                    boolean jjtc002 = true;
2839:                    jjtree.openNodeScope(jjtn002);
2840:                    jjtreeOpenNodeScope(jjtn002);
2841:                    try {
2842:                        suite();
2843:                    } catch (Throwable jjte002) {
2844:                        if (jjtc002) {
2845:                            jjtree.clearNodeScope(jjtn002);
2846:                            jjtc002 = false;
2847:                        } else {
2848:                            jjtree.popNode();
2849:                        }
2850:                        if (jjte002 instanceof  RuntimeException) {
2851:                            {
2852:                                if (true)
2853:                                    throw (RuntimeException) jjte002;
2854:                            }
2855:                        }
2856:                        if (jjte002 instanceof  ParseException) {
2857:                            {
2858:                                if (true)
2859:                                    throw (ParseException) jjte002;
2860:                            }
2861:                        }
2862:                        {
2863:                            if (true)
2864:                                throw (Error) jjte002;
2865:                        }
2866:                    } finally {
2867:                        if (jjtc002) {
2868:                            jjtree.closeNodeScope(jjtn002,
2869:                                    jjtree.nodeArity() + 1);
2870:                            jjtreeCloseNodeScope(jjtn002);
2871:                        }
2872:                    }
2873:                    break;
2874:                default:
2875:                    jj_la1[48] = jj_gen;
2876:                    jj_consume_token(-1);
2877:                    throw new ParseException();
2878:                }
2879:            }
2880:
2881:            //except_clause: 'except' [test [',' test]]
2882:            final public void except_clause() throws ParseException {
2883:                /*@bgen(jjtree) except_clause */
2884:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2885:                        JJTEXCEPT_CLAUSE);
2886:                boolean jjtc000 = true;
2887:                jjtree.openNodeScope(jjtn000);
2888:                jjtreeOpenNodeScope(jjtn000);
2889:                try {
2890:                    jj_consume_token(EXCEPT);
2891:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2892:                    case LPAREN:
2893:                    case LBRACE:
2894:                    case LBRACKET:
2895:                    case PLUS:
2896:                    case MINUS:
2897:                    case NOT:
2898:                    case NOT_BOOL:
2899:                    case LAMBDA:
2900:                    case AS:
2901:                    case NAME:
2902:                    case DECNUMBER:
2903:                    case HEXNUMBER:
2904:                    case OCTNUMBER:
2905:                    case FLOAT:
2906:                    case COMPLEX:
2907:                    case SINGLE_STRING:
2908:                    case SINGLE_STRING2:
2909:                    case TRIPLE_STRING:
2910:                    case TRIPLE_STRING2:
2911:                    case SINGLE_USTRING:
2912:                    case SINGLE_USTRING2:
2913:                    case TRIPLE_USTRING:
2914:                    case TRIPLE_USTRING2:
2915:                    case 135:
2916:                        test();
2917:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2918:                        case COMMA:
2919:                            jj_consume_token(COMMA);
2920:                            test();
2921:                            break;
2922:                        default:
2923:                            jj_la1[49] = jj_gen;
2924:                            ;
2925:                        }
2926:                        break;
2927:                    default:
2928:                        jj_la1[50] = jj_gen;
2929:                        ;
2930:                    }
2931:                    jj_consume_token(COLON);
2932:                    suite();
2933:                } catch (Throwable jjte000) {
2934:                    if (jjtc000) {
2935:                        jjtree.clearNodeScope(jjtn000);
2936:                        jjtc000 = false;
2937:                    } else {
2938:                        jjtree.popNode();
2939:                    }
2940:                    if (jjte000 instanceof  RuntimeException) {
2941:                        {
2942:                            if (true)
2943:                                throw (RuntimeException) jjte000;
2944:                        }
2945:                    }
2946:                    if (jjte000 instanceof  ParseException) {
2947:                        {
2948:                            if (true)
2949:                                throw (ParseException) jjte000;
2950:                        }
2951:                    }
2952:                    {
2953:                        if (true)
2954:                            throw (Error) jjte000;
2955:                    }
2956:                } finally {
2957:                    if (jjtc000) {
2958:                        jjtree.closeNodeScope(jjtn000, true);
2959:                        jjtreeCloseNodeScope(jjtn000);
2960:                    }
2961:                }
2962:            }
2963:
2964:            //suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
2965:            final public void suite() throws ParseException {
2966:                /*@bgen(jjtree) suite */
2967:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
2968:                        JJTSUITE);
2969:                boolean jjtc000 = true;
2970:                jjtree.openNodeScope(jjtn000);
2971:                jjtreeOpenNodeScope(jjtn000);
2972:                try {
2973:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2974:                    case LPAREN:
2975:                    case LBRACE:
2976:                    case LBRACKET:
2977:                    case PLUS:
2978:                    case MINUS:
2979:                    case NOT:
2980:                    case NOT_BOOL:
2981:                    case LAMBDA:
2982:                    case PRINT:
2983:                    case PASS:
2984:                    case BREAK:
2985:                    case CONTINUE:
2986:                    case RETURN:
2987:                    case YIELD:
2988:                    case IMPORT:
2989:                    case FROM:
2990:                    case DEL:
2991:                    case RAISE:
2992:                    case GLOBAL:
2993:                    case EXEC:
2994:                    case ASSERT:
2995:                    case AS:
2996:                    case NAME:
2997:                    case DECNUMBER:
2998:                    case HEXNUMBER:
2999:                    case OCTNUMBER:
3000:                    case FLOAT:
3001:                    case COMPLEX:
3002:                    case SINGLE_STRING:
3003:                    case SINGLE_STRING2:
3004:                    case TRIPLE_STRING:
3005:                    case TRIPLE_STRING2:
3006:                    case SINGLE_USTRING:
3007:                    case SINGLE_USTRING2:
3008:                    case TRIPLE_USTRING:
3009:                    case TRIPLE_USTRING2:
3010:                    case 135:
3011:                        simple_stmt();
3012:                        break;
3013:                    case NEWLINE:
3014:                        jj_consume_token(NEWLINE);
3015:                        token_source.expect_indent = true;
3016:                        jj_consume_token(INDENT);
3017:                        token_source.expect_indent = false;
3018:                        label_18: while (true) {
3019:                            stmt();
3020:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3021:                            case LPAREN:
3022:                            case LBRACE:
3023:                            case LBRACKET:
3024:                            case PLUS:
3025:                            case MINUS:
3026:                            case NOT:
3027:                            case NOT_BOOL:
3028:                            case LAMBDA:
3029:                            case IF:
3030:                            case WHILE:
3031:                            case FOR:
3032:                            case TRY:
3033:                            case DEF:
3034:                            case CLASS:
3035:                            case PRINT:
3036:                            case PASS:
3037:                            case BREAK:
3038:                            case CONTINUE:
3039:                            case RETURN:
3040:                            case YIELD:
3041:                            case IMPORT:
3042:                            case FROM:
3043:                            case DEL:
3044:                            case RAISE:
3045:                            case GLOBAL:
3046:                            case EXEC:
3047:                            case ASSERT:
3048:                            case AS:
3049:                            case NAME:
3050:                            case DECNUMBER:
3051:                            case HEXNUMBER:
3052:                            case OCTNUMBER:
3053:                            case FLOAT:
3054:                            case COMPLEX:
3055:                            case SINGLE_STRING:
3056:                            case SINGLE_STRING2:
3057:                            case TRIPLE_STRING:
3058:                            case TRIPLE_STRING2:
3059:                            case SINGLE_USTRING:
3060:                            case SINGLE_USTRING2:
3061:                            case TRIPLE_USTRING:
3062:                            case TRIPLE_USTRING2:
3063:                            case 135:
3064:                                ;
3065:                                break;
3066:                            default:
3067:                                jj_la1[51] = jj_gen;
3068:                                break label_18;
3069:                            }
3070:                        }
3071:                        jj_consume_token(DEDENT);
3072:                        break;
3073:                    default:
3074:                        jj_la1[52] = jj_gen;
3075:                        jj_consume_token(-1);
3076:                        throw new ParseException();
3077:                    }
3078:                } catch (Throwable jjte000) {
3079:                    if (jjtc000) {
3080:                        jjtree.clearNodeScope(jjtn000);
3081:                        jjtc000 = false;
3082:                    } else {
3083:                        jjtree.popNode();
3084:                    }
3085:                    if (jjte000 instanceof  RuntimeException) {
3086:                        {
3087:                            if (true)
3088:                                throw (RuntimeException) jjte000;
3089:                        }
3090:                    }
3091:                    if (jjte000 instanceof  ParseException) {
3092:                        {
3093:                            if (true)
3094:                                throw (ParseException) jjte000;
3095:                        }
3096:                    }
3097:                    {
3098:                        if (true)
3099:                            throw (Error) jjte000;
3100:                    }
3101:                } finally {
3102:                    if (jjtc000) {
3103:                        jjtree.closeNodeScope(jjtn000, true);
3104:                        jjtreeCloseNodeScope(jjtn000);
3105:                    }
3106:                }
3107:            }
3108:
3109:            //test: and_test ('or' and_test)* | lambdef
3110:            final public void test() throws ParseException {
3111:                /*@bgen(jjtree) #or_boolean(> 1) */
3112:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
3113:                        JJTOR_BOOLEAN);
3114:                boolean jjtc000 = true;
3115:                jjtree.openNodeScope(jjtn000);
3116:                jjtreeOpenNodeScope(jjtn000);
3117:                try {
3118:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3119:                    case LAMBDA:
3120:                        lambdef();
3121:                        break;
3122:                    case LPAREN:
3123:                    case LBRACE:
3124:                    case LBRACKET:
3125:                    case PLUS:
3126:                    case MINUS:
3127:                    case NOT:
3128:                    case NOT_BOOL:
3129:                    case AS:
3130:                    case NAME:
3131:                    case DECNUMBER:
3132:                    case HEXNUMBER:
3133:                    case OCTNUMBER:
3134:                    case FLOAT:
3135:                    case COMPLEX:
3136:                    case SINGLE_STRING:
3137:                    case SINGLE_STRING2:
3138:                    case TRIPLE_STRING:
3139:                    case TRIPLE_STRING2:
3140:                    case SINGLE_USTRING:
3141:                    case SINGLE_USTRING2:
3142:                    case TRIPLE_USTRING:
3143:                    case TRIPLE_USTRING2:
3144:                    case 135:
3145:                        and_test();
3146:                        label_19: while (true) {
3147:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3148:                            case OR_BOOL:
3149:                                ;
3150:                                break;
3151:                            default:
3152:                                jj_la1[53] = jj_gen;
3153:                                break label_19;
3154:                            }
3155:                            jj_consume_token(OR_BOOL);
3156:                            and_test();
3157:                        }
3158:                        break;
3159:                    default:
3160:                        jj_la1[54] = jj_gen;
3161:                        jj_consume_token(-1);
3162:                        throw new ParseException();
3163:                    }
3164:                } catch (Throwable jjte000) {
3165:                    if (jjtc000) {
3166:                        jjtree.clearNodeScope(jjtn000);
3167:                        jjtc000 = false;
3168:                    } else {
3169:                        jjtree.popNode();
3170:                    }
3171:                    if (jjte000 instanceof  RuntimeException) {
3172:                        {
3173:                            if (true)
3174:                                throw (RuntimeException) jjte000;
3175:                        }
3176:                    }
3177:                    if (jjte000 instanceof  ParseException) {
3178:                        {
3179:                            if (true)
3180:                                throw (ParseException) jjte000;
3181:                        }
3182:                    }
3183:                    {
3184:                        if (true)
3185:                            throw (Error) jjte000;
3186:                    }
3187:                } finally {
3188:                    if (jjtc000) {
3189:                        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
3190:                        jjtreeCloseNodeScope(jjtn000);
3191:                    }
3192:                }
3193:            }
3194:
3195:            //and_test: not_test ('and' not_test)*
3196:            final public void and_test() throws ParseException {
3197:                /*@bgen(jjtree) #and_boolean(> 1) */
3198:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
3199:                        JJTAND_BOOLEAN);
3200:                boolean jjtc000 = true;
3201:                jjtree.openNodeScope(jjtn000);
3202:                jjtreeOpenNodeScope(jjtn000);
3203:                try {
3204:                    not_test();
3205:                    label_20: while (true) {
3206:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3207:                        case AND_BOOL:
3208:                            ;
3209:                            break;
3210:                        default:
3211:                            jj_la1[55] = jj_gen;
3212:                            break label_20;
3213:                        }
3214:                        jj_consume_token(AND_BOOL);
3215:                        not_test();
3216:                    }
3217:                } catch (Throwable jjte000) {
3218:                    if (jjtc000) {
3219:                        jjtree.clearNodeScope(jjtn000);
3220:                        jjtc000 = false;
3221:                    } else {
3222:                        jjtree.popNode();
3223:                    }
3224:                    if (jjte000 instanceof  RuntimeException) {
3225:                        {
3226:                            if (true)
3227:                                throw (RuntimeException) jjte000;
3228:                        }
3229:                    }
3230:                    if (jjte000 instanceof  ParseException) {
3231:                        {
3232:                            if (true)
3233:                                throw (ParseException) jjte000;
3234:                        }
3235:                    }
3236:                    {
3237:                        if (true)
3238:                            throw (Error) jjte000;
3239:                    }
3240:                } finally {
3241:                    if (jjtc000) {
3242:                        jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
3243:                        jjtreeCloseNodeScope(jjtn000);
3244:                    }
3245:                }
3246:            }
3247:
3248:            //not_test: 'not' not_test | comparison
3249:            final public void not_test() throws ParseException {
3250:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3251:                case NOT_BOOL:
3252:                    jj_consume_token(NOT_BOOL);
3253:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
3254:                            this , JJTNOT_1OP);
3255:                    boolean jjtc001 = true;
3256:                    jjtree.openNodeScope(jjtn001);
3257:                    jjtreeOpenNodeScope(jjtn001);
3258:                    try {
3259:                        not_test();
3260:                    } catch (Throwable jjte001) {
3261:                        if (jjtc001) {
3262:                            jjtree.clearNodeScope(jjtn001);
3263:                            jjtc001 = false;
3264:                        } else {
3265:                            jjtree.popNode();
3266:                        }
3267:                        if (jjte001 instanceof  RuntimeException) {
3268:                            {
3269:                                if (true)
3270:                                    throw (RuntimeException) jjte001;
3271:                            }
3272:                        }
3273:                        if (jjte001 instanceof  ParseException) {
3274:                            {
3275:                                if (true)
3276:                                    throw (ParseException) jjte001;
3277:                            }
3278:                        }
3279:                        {
3280:                            if (true)
3281:                                throw (Error) jjte001;
3282:                        }
3283:                    } finally {
3284:                        if (jjtc001) {
3285:                            jjtree.closeNodeScope(jjtn001, 1);
3286:                            jjtreeCloseNodeScope(jjtn001);
3287:                        }
3288:                    }
3289:                    break;
3290:                case LPAREN:
3291:                case LBRACE:
3292:                case LBRACKET:
3293:                case PLUS:
3294:                case MINUS:
3295:                case NOT:
3296:                case AS:
3297:                case NAME:
3298:                case DECNUMBER:
3299:                case HEXNUMBER:
3300:                case OCTNUMBER:
3301:                case FLOAT:
3302:                case COMPLEX:
3303:                case SINGLE_STRING:
3304:                case SINGLE_STRING2:
3305:                case TRIPLE_STRING:
3306:                case TRIPLE_STRING2:
3307:                case SINGLE_USTRING:
3308:                case SINGLE_USTRING2:
3309:                case TRIPLE_USTRING:
3310:                case TRIPLE_USTRING2:
3311:                case 135:
3312:                    comparison();
3313:                    break;
3314:                default:
3315:                    jj_la1[56] = jj_gen;
3316:                    jj_consume_token(-1);
3317:                    throw new ParseException();
3318:                }
3319:            }
3320:
3321:            //comparison: expr (comp_op expr)*
3322:            final public void comparison() throws ParseException {
3323:                SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(this ,
3324:                        JJTCOMPARISION);
3325:                boolean jjtc001 = true;
3326:                jjtree.openNodeScope(jjtn001);
3327:                jjtreeOpenNodeScope(jjtn001);
3328:                try {
3329:                    expr();
3330:                    label_21: while (true) {
3331:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3332:                        case GREATER:
3333:                        case LESS:
3334:                        case EQEQUAL:
3335:                        case EQLESS:
3336:                        case EQGREATER:
3337:                        case LESSGREATER:
3338:                        case NOTEQUAL:
3339:                        case NOT_BOOL:
3340:                        case IS:
3341:                        case IN:
3342:                            ;
3343:                            break;
3344:                        default:
3345:                            jj_la1[57] = jj_gen;
3346:                            break label_21;
3347:                        }
3348:                        comp_op();
3349:                        expr();
3350:                    }
3351:                } catch (Throwable jjte001) {
3352:                    if (jjtc001) {
3353:                        jjtree.clearNodeScope(jjtn001);
3354:                        jjtc001 = false;
3355:                    } else {
3356:                        jjtree.popNode();
3357:                    }
3358:                    if (jjte001 instanceof  RuntimeException) {
3359:                        {
3360:                            if (true)
3361:                                throw (RuntimeException) jjte001;
3362:                        }
3363:                    }
3364:                    if (jjte001 instanceof  ParseException) {
3365:                        {
3366:                            if (true)
3367:                                throw (ParseException) jjte001;
3368:                        }
3369:                    }
3370:                    {
3371:                        if (true)
3372:                            throw (Error) jjte001;
3373:                    }
3374:                } finally {
3375:                    if (jjtc001) {
3376:                        jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
3377:                        jjtreeCloseNodeScope(jjtn001);
3378:                    }
3379:                }
3380:            }
3381:
3382:            //comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
3383:            final public void comp_op() throws ParseException {
3384:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3385:                case LESS:
3386:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
3387:                            this , JJTLESS_CMP);
3388:                    boolean jjtc001 = true;
3389:                    jjtree.openNodeScope(jjtn001);
3390:                    jjtreeOpenNodeScope(jjtn001);
3391:                    try {
3392:                        jj_consume_token(LESS);
3393:                    } finally {
3394:                        if (jjtc001) {
3395:                            jjtree.closeNodeScope(jjtn001, 0);
3396:                            jjtreeCloseNodeScope(jjtn001);
3397:                        }
3398:                    }
3399:                    break;
3400:                case GREATER:
3401:                    SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
3402:                            this , JJTGREATER_CMP);
3403:                    boolean jjtc002 = true;
3404:                    jjtree.openNodeScope(jjtn002);
3405:                    jjtreeOpenNodeScope(jjtn002);
3406:                    try {
3407:                        jj_consume_token(GREATER);
3408:                    } finally {
3409:                        if (jjtc002) {
3410:                            jjtree.closeNodeScope(jjtn002, 0);
3411:                            jjtreeCloseNodeScope(jjtn002);
3412:                        }
3413:                    }
3414:                    break;
3415:                case EQEQUAL:
3416:                    SimpleNode jjtn003 = (SimpleNode) SimpleNode.jjtCreate(
3417:                            this , JJTEQUAL_CMP);
3418:                    boolean jjtc003 = true;
3419:                    jjtree.openNodeScope(jjtn003);
3420:                    jjtreeOpenNodeScope(jjtn003);
3421:                    try {
3422:                        jj_consume_token(EQEQUAL);
3423:                    } finally {
3424:                        if (jjtc003) {
3425:                            jjtree.closeNodeScope(jjtn003, 0);
3426:                            jjtreeCloseNodeScope(jjtn003);
3427:                        }
3428:                    }
3429:                    break;
3430:                case EQGREATER:
3431:                    SimpleNode jjtn004 = (SimpleNode) SimpleNode.jjtCreate(
3432:                            this , JJTGREATER_EQUAL_CMP);
3433:                    boolean jjtc004 = true;
3434:                    jjtree.openNodeScope(jjtn004);
3435:                    jjtreeOpenNodeScope(jjtn004);
3436:                    try {
3437:                        jj_consume_token(EQGREATER);
3438:                    } finally {
3439:                        if (jjtc004) {
3440:                            jjtree.closeNodeScope(jjtn004, 0);
3441:                            jjtreeCloseNodeScope(jjtn004);
3442:                        }
3443:                    }
3444:                    break;
3445:                case EQLESS:
3446:                    SimpleNode jjtn005 = (SimpleNode) SimpleNode.jjtCreate(
3447:                            this , JJTLESS_EQUAL_CMP);
3448:                    boolean jjtc005 = true;
3449:                    jjtree.openNodeScope(jjtn005);
3450:                    jjtreeOpenNodeScope(jjtn005);
3451:                    try {
3452:                        jj_consume_token(EQLESS);
3453:                    } finally {
3454:                        if (jjtc005) {
3455:                            jjtree.closeNodeScope(jjtn005, 0);
3456:                            jjtreeCloseNodeScope(jjtn005);
3457:                        }
3458:                    }
3459:                    break;
3460:                case LESSGREATER:
3461:                    SimpleNode jjtn006 = (SimpleNode) SimpleNode.jjtCreate(
3462:                            this , JJTNOTEQUAL_CMP);
3463:                    boolean jjtc006 = true;
3464:                    jjtree.openNodeScope(jjtn006);
3465:                    jjtreeOpenNodeScope(jjtn006);
3466:                    try {
3467:                        jj_consume_token(LESSGREATER);
3468:                    } finally {
3469:                        if (jjtc006) {
3470:                            jjtree.closeNodeScope(jjtn006, 0);
3471:                            jjtreeCloseNodeScope(jjtn006);
3472:                        }
3473:                    }
3474:                    break;
3475:                case NOTEQUAL:
3476:                    SimpleNode jjtn007 = (SimpleNode) SimpleNode.jjtCreate(
3477:                            this , JJTNOTEQUAL_CMP);
3478:                    boolean jjtc007 = true;
3479:                    jjtree.openNodeScope(jjtn007);
3480:                    jjtreeOpenNodeScope(jjtn007);
3481:                    try {
3482:                        jj_consume_token(NOTEQUAL);
3483:                    } finally {
3484:                        if (jjtc007) {
3485:                            jjtree.closeNodeScope(jjtn007, 0);
3486:                            jjtreeCloseNodeScope(jjtn007);
3487:                        }
3488:                    }
3489:                    break;
3490:                case IN:
3491:                    SimpleNode jjtn008 = (SimpleNode) SimpleNode.jjtCreate(
3492:                            this , JJTIN_CMP);
3493:                    boolean jjtc008 = true;
3494:                    jjtree.openNodeScope(jjtn008);
3495:                    jjtreeOpenNodeScope(jjtn008);
3496:                    try {
3497:                        jj_consume_token(IN);
3498:                    } finally {
3499:                        if (jjtc008) {
3500:                            jjtree.closeNodeScope(jjtn008, 0);
3501:                            jjtreeCloseNodeScope(jjtn008);
3502:                        }
3503:                    }
3504:                    break;
3505:                case NOT_BOOL:
3506:                    jj_consume_token(NOT_BOOL);
3507:                    SimpleNode jjtn009 = (SimpleNode) SimpleNode.jjtCreate(
3508:                            this , JJTNOT_IN_CMP);
3509:                    boolean jjtc009 = true;
3510:                    jjtree.openNodeScope(jjtn009);
3511:                    jjtreeOpenNodeScope(jjtn009);
3512:                    try {
3513:                        jj_consume_token(IN);
3514:                    } finally {
3515:                        if (jjtc009) {
3516:                            jjtree.closeNodeScope(jjtn009, 0);
3517:                            jjtreeCloseNodeScope(jjtn009);
3518:                        }
3519:                    }
3520:                    break;
3521:                default:
3522:                    jj_la1[58] = jj_gen;
3523:                    if (jj_2_12(2)) {
3524:                        jj_consume_token(IS);
3525:                        SimpleNode jjtn010 = (SimpleNode) SimpleNode.jjtCreate(
3526:                                this , JJTIS_NOT_CMP);
3527:                        boolean jjtc010 = true;
3528:                        jjtree.openNodeScope(jjtn010);
3529:                        jjtreeOpenNodeScope(jjtn010);
3530:                        try {
3531:                            jj_consume_token(NOT_BOOL);
3532:                        } finally {
3533:                            if (jjtc010) {
3534:                                jjtree.closeNodeScope(jjtn010, 0);
3535:                                jjtreeCloseNodeScope(jjtn010);
3536:                            }
3537:                        }
3538:                    } else {
3539:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3540:                        case IS:
3541:                            SimpleNode jjtn011 = (SimpleNode) SimpleNode
3542:                                    .jjtCreate(this , JJTIS_CMP);
3543:                            boolean jjtc011 = true;
3544:                            jjtree.openNodeScope(jjtn011);
3545:                            jjtreeOpenNodeScope(jjtn011);
3546:                            try {
3547:                                jj_consume_token(IS);
3548:                            } finally {
3549:                                if (jjtc011) {
3550:                                    jjtree.closeNodeScope(jjtn011, 0);
3551:                                    jjtreeCloseNodeScope(jjtn011);
3552:                                }
3553:                            }
3554:                            break;
3555:                        default:
3556:                            jj_la1[59] = jj_gen;
3557:                            jj_consume_token(-1);
3558:                            throw new ParseException();
3559:                        }
3560:                    }
3561:                }
3562:            }
3563:
3564:            //expr: xor_expr ('|' xor_expr)*
3565:            final public void expr() throws ParseException {
3566:                xor_expr();
3567:                label_22: while (true) {
3568:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3569:                    case OR:
3570:                        ;
3571:                        break;
3572:                    default:
3573:                        jj_la1[60] = jj_gen;
3574:                        break label_22;
3575:                    }
3576:                    jj_consume_token(OR);
3577:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
3578:                            this , JJTOR_2OP);
3579:                    boolean jjtc001 = true;
3580:                    jjtree.openNodeScope(jjtn001);
3581:                    jjtreeOpenNodeScope(jjtn001);
3582:                    try {
3583:                        xor_expr();
3584:                    } catch (Throwable jjte001) {
3585:                        if (jjtc001) {
3586:                            jjtree.clearNodeScope(jjtn001);
3587:                            jjtc001 = false;
3588:                        } else {
3589:                            jjtree.popNode();
3590:                        }
3591:                        if (jjte001 instanceof  RuntimeException) {
3592:                            {
3593:                                if (true)
3594:                                    throw (RuntimeException) jjte001;
3595:                            }
3596:                        }
3597:                        if (jjte001 instanceof  ParseException) {
3598:                            {
3599:                                if (true)
3600:                                    throw (ParseException) jjte001;
3601:                            }
3602:                        }
3603:                        {
3604:                            if (true)
3605:                                throw (Error) jjte001;
3606:                        }
3607:                    } finally {
3608:                        if (jjtc001) {
3609:                            jjtree.closeNodeScope(jjtn001, 2);
3610:                            jjtreeCloseNodeScope(jjtn001);
3611:                        }
3612:                    }
3613:                }
3614:            }
3615:
3616:            //xor_expr: and_expr ('^' and_expr)*
3617:            final public void xor_expr() throws ParseException {
3618:                and_expr();
3619:                label_23: while (true) {
3620:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3621:                    case XOR:
3622:                        ;
3623:                        break;
3624:                    default:
3625:                        jj_la1[61] = jj_gen;
3626:                        break label_23;
3627:                    }
3628:                    jj_consume_token(XOR);
3629:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
3630:                            this , JJTXOR_2OP);
3631:                    boolean jjtc001 = true;
3632:                    jjtree.openNodeScope(jjtn001);
3633:                    jjtreeOpenNodeScope(jjtn001);
3634:                    try {
3635:                        and_expr();
3636:                    } catch (Throwable jjte001) {
3637:                        if (jjtc001) {
3638:                            jjtree.clearNodeScope(jjtn001);
3639:                            jjtc001 = false;
3640:                        } else {
3641:                            jjtree.popNode();
3642:                        }
3643:                        if (jjte001 instanceof  RuntimeException) {
3644:                            {
3645:                                if (true)
3646:                                    throw (RuntimeException) jjte001;
3647:                            }
3648:                        }
3649:                        if (jjte001 instanceof  ParseException) {
3650:                            {
3651:                                if (true)
3652:                                    throw (ParseException) jjte001;
3653:                            }
3654:                        }
3655:                        {
3656:                            if (true)
3657:                                throw (Error) jjte001;
3658:                        }
3659:                    } finally {
3660:                        if (jjtc001) {
3661:                            jjtree.closeNodeScope(jjtn001, 2);
3662:                            jjtreeCloseNodeScope(jjtn001);
3663:                        }
3664:                    }
3665:                }
3666:            }
3667:
3668:            //and_expr: shift_expr ('&' shift_expr)*
3669:            final public void and_expr() throws ParseException {
3670:                shift_expr();
3671:                label_24: while (true) {
3672:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3673:                    case AND:
3674:                        ;
3675:                        break;
3676:                    default:
3677:                        jj_la1[62] = jj_gen;
3678:                        break label_24;
3679:                    }
3680:                    jj_consume_token(AND);
3681:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
3682:                            this , JJTAND_2OP);
3683:                    boolean jjtc001 = true;
3684:                    jjtree.openNodeScope(jjtn001);
3685:                    jjtreeOpenNodeScope(jjtn001);
3686:                    try {
3687:                        shift_expr();
3688:                    } catch (Throwable jjte001) {
3689:                        if (jjtc001) {
3690:                            jjtree.clearNodeScope(jjtn001);
3691:                            jjtc001 = false;
3692:                        } else {
3693:                            jjtree.popNode();
3694:                        }
3695:                        if (jjte001 instanceof  RuntimeException) {
3696:                            {
3697:                                if (true)
3698:                                    throw (RuntimeException) jjte001;
3699:                            }
3700:                        }
3701:                        if (jjte001 instanceof  ParseException) {
3702:                            {
3703:                                if (true)
3704:                                    throw (ParseException) jjte001;
3705:                            }
3706:                        }
3707:                        {
3708:                            if (true)
3709:                                throw (Error) jjte001;
3710:                        }
3711:                    } finally {
3712:                        if (jjtc001) {
3713:                            jjtree.closeNodeScope(jjtn001, 2);
3714:                            jjtreeCloseNodeScope(jjtn001);
3715:                        }
3716:                    }
3717:                }
3718:            }
3719:
3720:            //shift_expr: arith_expr (('<<'|'>>') arith_expr)*
3721:            final public void shift_expr() throws ParseException {
3722:                arith_expr();
3723:                label_25: while (true) {
3724:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3725:                    case LSHIFT:
3726:                    case RSHIFT:
3727:                        ;
3728:                        break;
3729:                    default:
3730:                        jj_la1[63] = jj_gen;
3731:                        break label_25;
3732:                    }
3733:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3734:                    case LSHIFT:
3735:                        jj_consume_token(LSHIFT);
3736:                        SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
3737:                                this , JJTLSHIFT_2OP);
3738:                        boolean jjtc001 = true;
3739:                        jjtree.openNodeScope(jjtn001);
3740:                        jjtreeOpenNodeScope(jjtn001);
3741:                        try {
3742:                            arith_expr();
3743:                        } catch (Throwable jjte001) {
3744:                            if (jjtc001) {
3745:                                jjtree.clearNodeScope(jjtn001);
3746:                                jjtc001 = false;
3747:                            } else {
3748:                                jjtree.popNode();
3749:                            }
3750:                            if (jjte001 instanceof  RuntimeException) {
3751:                                {
3752:                                    if (true)
3753:                                        throw (RuntimeException) jjte001;
3754:                                }
3755:                            }
3756:                            if (jjte001 instanceof  ParseException) {
3757:                                {
3758:                                    if (true)
3759:                                        throw (ParseException) jjte001;
3760:                                }
3761:                            }
3762:                            {
3763:                                if (true)
3764:                                    throw (Error) jjte001;
3765:                            }
3766:                        } finally {
3767:                            if (jjtc001) {
3768:                                jjtree.closeNodeScope(jjtn001, 2);
3769:                                jjtreeCloseNodeScope(jjtn001);
3770:                            }
3771:                        }
3772:                        break;
3773:                    case RSHIFT:
3774:                        jj_consume_token(RSHIFT);
3775:                        SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
3776:                                this , JJTRSHIFT_2OP);
3777:                        boolean jjtc002 = true;
3778:                        jjtree.openNodeScope(jjtn002);
3779:                        jjtreeOpenNodeScope(jjtn002);
3780:                        try {
3781:                            arith_expr();
3782:                        } catch (Throwable jjte002) {
3783:                            if (jjtc002) {
3784:                                jjtree.clearNodeScope(jjtn002);
3785:                                jjtc002 = false;
3786:                            } else {
3787:                                jjtree.popNode();
3788:                            }
3789:                            if (jjte002 instanceof  RuntimeException) {
3790:                                {
3791:                                    if (true)
3792:                                        throw (RuntimeException) jjte002;
3793:                                }
3794:                            }
3795:                            if (jjte002 instanceof  ParseException) {
3796:                                {
3797:                                    if (true)
3798:                                        throw (ParseException) jjte002;
3799:                                }
3800:                            }
3801:                            {
3802:                                if (true)
3803:                                    throw (Error) jjte002;
3804:                            }
3805:                        } finally {
3806:                            if (jjtc002) {
3807:                                jjtree.closeNodeScope(jjtn002, 2);
3808:                                jjtreeCloseNodeScope(jjtn002);
3809:                            }
3810:                        }
3811:                        break;
3812:                    default:
3813:                        jj_la1[64] = jj_gen;
3814:                        jj_consume_token(-1);
3815:                        throw new ParseException();
3816:                    }
3817:                }
3818:            }
3819:
3820:            //arith_expr: term (('+'|'-') term)*
3821:            final public void arith_expr() throws ParseException {
3822:                term();
3823:                label_26: while (true) {
3824:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3825:                    case PLUS:
3826:                    case MINUS:
3827:                        ;
3828:                        break;
3829:                    default:
3830:                        jj_la1[65] = jj_gen;
3831:                        break label_26;
3832:                    }
3833:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3834:                    case PLUS:
3835:                        jj_consume_token(PLUS);
3836:                        SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
3837:                                this , JJTADD_2OP);
3838:                        boolean jjtc001 = true;
3839:                        jjtree.openNodeScope(jjtn001);
3840:                        jjtreeOpenNodeScope(jjtn001);
3841:                        try {
3842:                            term();
3843:                        } catch (Throwable jjte001) {
3844:                            if (jjtc001) {
3845:                                jjtree.clearNodeScope(jjtn001);
3846:                                jjtc001 = false;
3847:                            } else {
3848:                                jjtree.popNode();
3849:                            }
3850:                            if (jjte001 instanceof  RuntimeException) {
3851:                                {
3852:                                    if (true)
3853:                                        throw (RuntimeException) jjte001;
3854:                                }
3855:                            }
3856:                            if (jjte001 instanceof  ParseException) {
3857:                                {
3858:                                    if (true)
3859:                                        throw (ParseException) jjte001;
3860:                                }
3861:                            }
3862:                            {
3863:                                if (true)
3864:                                    throw (Error) jjte001;
3865:                            }
3866:                        } finally {
3867:                            if (jjtc001) {
3868:                                jjtree.closeNodeScope(jjtn001, 2);
3869:                                jjtreeCloseNodeScope(jjtn001);
3870:                            }
3871:                        }
3872:                        break;
3873:                    case MINUS:
3874:                        jj_consume_token(MINUS);
3875:                        SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
3876:                                this , JJTSUB_2OP);
3877:                        boolean jjtc002 = true;
3878:                        jjtree.openNodeScope(jjtn002);
3879:                        jjtreeOpenNodeScope(jjtn002);
3880:                        try {
3881:                            term();
3882:                        } catch (Throwable jjte002) {
3883:                            if (jjtc002) {
3884:                                jjtree.clearNodeScope(jjtn002);
3885:                                jjtc002 = false;
3886:                            } else {
3887:                                jjtree.popNode();
3888:                            }
3889:                            if (jjte002 instanceof  RuntimeException) {
3890:                                {
3891:                                    if (true)
3892:                                        throw (RuntimeException) jjte002;
3893:                                }
3894:                            }
3895:                            if (jjte002 instanceof  ParseException) {
3896:                                {
3897:                                    if (true)
3898:                                        throw (ParseException) jjte002;
3899:                                }
3900:                            }
3901:                            {
3902:                                if (true)
3903:                                    throw (Error) jjte002;
3904:                            }
3905:                        } finally {
3906:                            if (jjtc002) {
3907:                                jjtree.closeNodeScope(jjtn002, 2);
3908:                                jjtreeCloseNodeScope(jjtn002);
3909:                            }
3910:                        }
3911:                        break;
3912:                    default:
3913:                        jj_la1[66] = jj_gen;
3914:                        jj_consume_token(-1);
3915:                        throw new ParseException();
3916:                    }
3917:                }
3918:            }
3919:
3920:            //term: factor (('*'|'/'|'%') factor)*
3921:            final public void term() throws ParseException {
3922:                factor();
3923:                label_27: while (true) {
3924:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3925:                    case MULTIPLY:
3926:                    case DIVIDE:
3927:                    case FLOORDIVIDE:
3928:                    case MODULO:
3929:                        ;
3930:                        break;
3931:                    default:
3932:                        jj_la1[67] = jj_gen;
3933:                        break label_27;
3934:                    }
3935:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3936:                    case MULTIPLY:
3937:                        jj_consume_token(MULTIPLY);
3938:                        SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
3939:                                this , JJTMUL_2OP);
3940:                        boolean jjtc001 = true;
3941:                        jjtree.openNodeScope(jjtn001);
3942:                        jjtreeOpenNodeScope(jjtn001);
3943:                        try {
3944:                            factor();
3945:                        } catch (Throwable jjte001) {
3946:                            if (jjtc001) {
3947:                                jjtree.clearNodeScope(jjtn001);
3948:                                jjtc001 = false;
3949:                            } else {
3950:                                jjtree.popNode();
3951:                            }
3952:                            if (jjte001 instanceof  RuntimeException) {
3953:                                {
3954:                                    if (true)
3955:                                        throw (RuntimeException) jjte001;
3956:                                }
3957:                            }
3958:                            if (jjte001 instanceof  ParseException) {
3959:                                {
3960:                                    if (true)
3961:                                        throw (ParseException) jjte001;
3962:                                }
3963:                            }
3964:                            {
3965:                                if (true)
3966:                                    throw (Error) jjte001;
3967:                            }
3968:                        } finally {
3969:                            if (jjtc001) {
3970:                                jjtree.closeNodeScope(jjtn001, 2);
3971:                                jjtreeCloseNodeScope(jjtn001);
3972:                            }
3973:                        }
3974:                        break;
3975:                    case DIVIDE:
3976:                        jj_consume_token(DIVIDE);
3977:                        SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
3978:                                this , JJTDIV_2OP);
3979:                        boolean jjtc002 = true;
3980:                        jjtree.openNodeScope(jjtn002);
3981:                        jjtreeOpenNodeScope(jjtn002);
3982:                        try {
3983:                            factor();
3984:                        } catch (Throwable jjte002) {
3985:                            if (jjtc002) {
3986:                                jjtree.clearNodeScope(jjtn002);
3987:                                jjtc002 = false;
3988:                            } else {
3989:                                jjtree.popNode();
3990:                            }
3991:                            if (jjte002 instanceof  RuntimeException) {
3992:                                {
3993:                                    if (true)
3994:                                        throw (RuntimeException) jjte002;
3995:                                }
3996:                            }
3997:                            if (jjte002 instanceof  ParseException) {
3998:                                {
3999:                                    if (true)
4000:                                        throw (ParseException) jjte002;
4001:                                }
4002:                            }
4003:                            {
4004:                                if (true)
4005:                                    throw (Error) jjte002;
4006:                            }
4007:                        } finally {
4008:                            if (jjtc002) {
4009:                                jjtree.closeNodeScope(jjtn002, 2);
4010:                                jjtreeCloseNodeScope(jjtn002);
4011:                            }
4012:                        }
4013:                        break;
4014:                    case FLOORDIVIDE:
4015:                        jj_consume_token(FLOORDIVIDE);
4016:                        SimpleNode jjtn003 = (SimpleNode) SimpleNode.jjtCreate(
4017:                                this , JJTFLOORDIV_2OP);
4018:                        boolean jjtc003 = true;
4019:                        jjtree.openNodeScope(jjtn003);
4020:                        jjtreeOpenNodeScope(jjtn003);
4021:                        try {
4022:                            factor();
4023:                        } catch (Throwable jjte003) {
4024:                            if (jjtc003) {
4025:                                jjtree.clearNodeScope(jjtn003);
4026:                                jjtc003 = false;
4027:                            } else {
4028:                                jjtree.popNode();
4029:                            }
4030:                            if (jjte003 instanceof  RuntimeException) {
4031:                                {
4032:                                    if (true)
4033:                                        throw (RuntimeException) jjte003;
4034:                                }
4035:                            }
4036:                            if (jjte003 instanceof  ParseException) {
4037:                                {
4038:                                    if (true)
4039:                                        throw (ParseException) jjte003;
4040:                                }
4041:                            }
4042:                            {
4043:                                if (true)
4044:                                    throw (Error) jjte003;
4045:                            }
4046:                        } finally {
4047:                            if (jjtc003) {
4048:                                jjtree.closeNodeScope(jjtn003, 2);
4049:                                jjtreeCloseNodeScope(jjtn003);
4050:                            }
4051:                        }
4052:                        break;
4053:                    case MODULO:
4054:                        jj_consume_token(MODULO);
4055:                        SimpleNode jjtn004 = (SimpleNode) SimpleNode.jjtCreate(
4056:                                this , JJTMOD_2OP);
4057:                        boolean jjtc004 = true;
4058:                        jjtree.openNodeScope(jjtn004);
4059:                        jjtreeOpenNodeScope(jjtn004);
4060:                        try {
4061:                            factor();
4062:                        } catch (Throwable jjte004) {
4063:                            if (jjtc004) {
4064:                                jjtree.clearNodeScope(jjtn004);
4065:                                jjtc004 = false;
4066:                            } else {
4067:                                jjtree.popNode();
4068:                            }
4069:                            if (jjte004 instanceof  RuntimeException) {
4070:                                {
4071:                                    if (true)
4072:                                        throw (RuntimeException) jjte004;
4073:                                }
4074:                            }
4075:                            if (jjte004 instanceof  ParseException) {
4076:                                {
4077:                                    if (true)
4078:                                        throw (ParseException) jjte004;
4079:                                }
4080:                            }
4081:                            {
4082:                                if (true)
4083:                                    throw (Error) jjte004;
4084:                            }
4085:                        } finally {
4086:                            if (jjtc004) {
4087:                                jjtree.closeNodeScope(jjtn004, 2);
4088:                                jjtreeCloseNodeScope(jjtn004);
4089:                            }
4090:                        }
4091:                        break;
4092:                    default:
4093:                        jj_la1[68] = jj_gen;
4094:                        jj_consume_token(-1);
4095:                        throw new ParseException();
4096:                    }
4097:                }
4098:            }
4099:
4100:            //factor: ('+'|'-'|'~') factor | power
4101:            final public void factor() throws ParseException {
4102:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4103:                case PLUS:
4104:                    jj_consume_token(PLUS);
4105:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
4106:                            this , JJTPOS_1OP);
4107:                    boolean jjtc001 = true;
4108:                    jjtree.openNodeScope(jjtn001);
4109:                    jjtreeOpenNodeScope(jjtn001);
4110:                    try {
4111:                        factor();
4112:                    } catch (Throwable jjte001) {
4113:                        if (jjtc001) {
4114:                            jjtree.clearNodeScope(jjtn001);
4115:                            jjtc001 = false;
4116:                        } else {
4117:                            jjtree.popNode();
4118:                        }
4119:                        if (jjte001 instanceof  RuntimeException) {
4120:                            {
4121:                                if (true)
4122:                                    throw (RuntimeException) jjte001;
4123:                            }
4124:                        }
4125:                        if (jjte001 instanceof  ParseException) {
4126:                            {
4127:                                if (true)
4128:                                    throw (ParseException) jjte001;
4129:                            }
4130:                        }
4131:                        {
4132:                            if (true)
4133:                                throw (Error) jjte001;
4134:                        }
4135:                    } finally {
4136:                        if (jjtc001) {
4137:                            jjtree.closeNodeScope(jjtn001, 1);
4138:                            jjtreeCloseNodeScope(jjtn001);
4139:                        }
4140:                    }
4141:                    break;
4142:                case MINUS:
4143:                    jj_consume_token(MINUS);
4144:                    SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
4145:                            this , JJTNEG_1OP);
4146:                    boolean jjtc002 = true;
4147:                    jjtree.openNodeScope(jjtn002);
4148:                    jjtreeOpenNodeScope(jjtn002);
4149:                    try {
4150:                        factor();
4151:                    } catch (Throwable jjte002) {
4152:                        if (jjtc002) {
4153:                            jjtree.clearNodeScope(jjtn002);
4154:                            jjtc002 = false;
4155:                        } else {
4156:                            jjtree.popNode();
4157:                        }
4158:                        if (jjte002 instanceof  RuntimeException) {
4159:                            {
4160:                                if (true)
4161:                                    throw (RuntimeException) jjte002;
4162:                            }
4163:                        }
4164:                        if (jjte002 instanceof  ParseException) {
4165:                            {
4166:                                if (true)
4167:                                    throw (ParseException) jjte002;
4168:                            }
4169:                        }
4170:                        {
4171:                            if (true)
4172:                                throw (Error) jjte002;
4173:                        }
4174:                    } finally {
4175:                        if (jjtc002) {
4176:                            jjtree.closeNodeScope(jjtn002, 1);
4177:                            jjtreeCloseNodeScope(jjtn002);
4178:                        }
4179:                    }
4180:                    break;
4181:                case NOT:
4182:                    jj_consume_token(NOT);
4183:                    SimpleNode jjtn003 = (SimpleNode) SimpleNode.jjtCreate(
4184:                            this , JJTINVERT_1OP);
4185:                    boolean jjtc003 = true;
4186:                    jjtree.openNodeScope(jjtn003);
4187:                    jjtreeOpenNodeScope(jjtn003);
4188:                    try {
4189:                        factor();
4190:                    } catch (Throwable jjte003) {
4191:                        if (jjtc003) {
4192:                            jjtree.clearNodeScope(jjtn003);
4193:                            jjtc003 = false;
4194:                        } else {
4195:                            jjtree.popNode();
4196:                        }
4197:                        if (jjte003 instanceof  RuntimeException) {
4198:                            {
4199:                                if (true)
4200:                                    throw (RuntimeException) jjte003;
4201:                            }
4202:                        }
4203:                        if (jjte003 instanceof  ParseException) {
4204:                            {
4205:                                if (true)
4206:                                    throw (ParseException) jjte003;
4207:                            }
4208:                        }
4209:                        {
4210:                            if (true)
4211:                                throw (Error) jjte003;
4212:                        }
4213:                    } finally {
4214:                        if (jjtc003) {
4215:                            jjtree.closeNodeScope(jjtn003, 1);
4216:                            jjtreeCloseNodeScope(jjtn003);
4217:                        }
4218:                    }
4219:                    break;
4220:                case LPAREN:
4221:                case LBRACE:
4222:                case LBRACKET:
4223:                case AS:
4224:                case NAME:
4225:                case DECNUMBER:
4226:                case HEXNUMBER:
4227:                case OCTNUMBER:
4228:                case FLOAT:
4229:                case COMPLEX:
4230:                case SINGLE_STRING:
4231:                case SINGLE_STRING2:
4232:                case TRIPLE_STRING:
4233:                case TRIPLE_STRING2:
4234:                case SINGLE_USTRING:
4235:                case SINGLE_USTRING2:
4236:                case TRIPLE_USTRING:
4237:                case TRIPLE_USTRING2:
4238:                case 135:
4239:                    power();
4240:                    break;
4241:                default:
4242:                    jj_la1[69] = jj_gen;
4243:                    jj_consume_token(-1);
4244:                    throw new ParseException();
4245:                }
4246:            }
4247:
4248:            /*Modified, no recursion*/
4249:
4250:            //power: atom trailer* ('**' factor)*
4251:            final public void power() throws ParseException {
4252:                atomtrailer();
4253:                label_28: while (true) {
4254:                    if (jj_2_13(2)) {
4255:                        ;
4256:                    } else {
4257:                        break label_28;
4258:                    }
4259:                    jj_consume_token(POWER);
4260:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
4261:                            this , JJTPOW_2OP);
4262:                    boolean jjtc001 = true;
4263:                    jjtree.openNodeScope(jjtn001);
4264:                    jjtreeOpenNodeScope(jjtn001);
4265:                    try {
4266:                        factor();
4267:                    } catch (Throwable jjte001) {
4268:                        if (jjtc001) {
4269:                            jjtree.clearNodeScope(jjtn001);
4270:                            jjtc001 = false;
4271:                        } else {
4272:                            jjtree.popNode();
4273:                        }
4274:                        if (jjte001 instanceof  RuntimeException) {
4275:                            {
4276:                                if (true)
4277:                                    throw (RuntimeException) jjte001;
4278:                            }
4279:                        }
4280:                        if (jjte001 instanceof  ParseException) {
4281:                            {
4282:                                if (true)
4283:                                    throw (ParseException) jjte001;
4284:                            }
4285:                        }
4286:                        {
4287:                            if (true)
4288:                                throw (Error) jjte001;
4289:                        }
4290:                    } finally {
4291:                        if (jjtc001) {
4292:                            jjtree.closeNodeScope(jjtn001, 2);
4293:                            jjtreeCloseNodeScope(jjtn001);
4294:                        }
4295:                    }
4296:                }
4297:            }
4298:
4299:            //trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
4300:            final public void atomtrailer() throws ParseException {
4301:                atom();
4302:                label_29: while (true) {
4303:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4304:                    case LPAREN:
4305:                    case LBRACKET:
4306:                    case DOT:
4307:                        ;
4308:                        break;
4309:                    default:
4310:                        jj_la1[70] = jj_gen;
4311:                        break label_29;
4312:                    }
4313:                    if (jj_2_14(2)) {
4314:                        jj_consume_token(LPAREN);
4315:                        SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
4316:                                this , JJTCALL_OP);
4317:                        boolean jjtc001 = true;
4318:                        jjtree.openNodeScope(jjtn001);
4319:                        jjtreeOpenNodeScope(jjtn001);
4320:                        try {
4321:                            jj_consume_token(RPAREN);
4322:                        } finally {
4323:                            if (jjtc001) {
4324:                                jjtree.closeNodeScope(jjtn001, 1);
4325:                                jjtreeCloseNodeScope(jjtn001);
4326:                            }
4327:                        }
4328:                    } else {
4329:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4330:                        case LPAREN:
4331:                            SimpleNode jjtn002 = (SimpleNode) SimpleNode
4332:                                    .jjtCreate(this , JJTCALL_OP);
4333:                            boolean jjtc002 = true;
4334:                            jjtree.openNodeScope(jjtn002);
4335:                            jjtreeOpenNodeScope(jjtn002);
4336:                            try {
4337:                                jj_consume_token(LPAREN);
4338:                                arglist();
4339:                                jj_consume_token(RPAREN);
4340:                            } catch (Throwable jjte002) {
4341:                                if (jjtc002) {
4342:                                    jjtree.clearNodeScope(jjtn002);
4343:                                    jjtc002 = false;
4344:                                } else {
4345:                                    jjtree.popNode();
4346:                                }
4347:                                if (jjte002 instanceof  RuntimeException) {
4348:                                    {
4349:                                        if (true)
4350:                                            throw (RuntimeException) jjte002;
4351:                                    }
4352:                                }
4353:                                if (jjte002 instanceof  ParseException) {
4354:                                    {
4355:                                        if (true)
4356:                                            throw (ParseException) jjte002;
4357:                                    }
4358:                                }
4359:                                {
4360:                                    if (true)
4361:                                        throw (Error) jjte002;
4362:                                }
4363:                            } finally {
4364:                                if (jjtc002) {
4365:                                    jjtree.closeNodeScope(jjtn002, jjtree
4366:                                            .nodeArity() + 1);
4367:                                    jjtreeCloseNodeScope(jjtn002);
4368:                                }
4369:                            }
4370:                            break;
4371:                        case LBRACKET:
4372:                            jj_consume_token(LBRACKET);
4373:                            subscriptlist();
4374:                            SimpleNode jjtn003 = (SimpleNode) SimpleNode
4375:                                    .jjtCreate(this , JJTINDEX_OP);
4376:                            boolean jjtc003 = true;
4377:                            jjtree.openNodeScope(jjtn003);
4378:                            jjtreeOpenNodeScope(jjtn003);
4379:                            try {
4380:                                jj_consume_token(RBRACKET);
4381:                            } finally {
4382:                                if (jjtc003) {
4383:                                    jjtree.closeNodeScope(jjtn003, 2);
4384:                                    jjtreeCloseNodeScope(jjtn003);
4385:                                }
4386:                            }
4387:                            break;
4388:                        case DOT:
4389:                            jj_consume_token(DOT);
4390:                            SimpleNode jjtn004 = (SimpleNode) SimpleNode
4391:                                    .jjtCreate(this , JJTDOT_OP);
4392:                            boolean jjtc004 = true;
4393:                            jjtree.openNodeScope(jjtn004);
4394:                            jjtreeOpenNodeScope(jjtn004);
4395:                            try {
4396:                                AnyName();
4397:                            } catch (Throwable jjte004) {
4398:                                if (jjtc004) {
4399:                                    jjtree.clearNodeScope(jjtn004);
4400:                                    jjtc004 = false;
4401:                                } else {
4402:                                    jjtree.popNode();
4403:                                }
4404:                                if (jjte004 instanceof  RuntimeException) {
4405:                                    {
4406:                                        if (true)
4407:                                            throw (RuntimeException) jjte004;
4408:                                    }
4409:                                }
4410:                                if (jjte004 instanceof  ParseException) {
4411:                                    {
4412:                                        if (true)
4413:                                            throw (ParseException) jjte004;
4414:                                    }
4415:                                }
4416:                                {
4417:                                    if (true)
4418:                                        throw (Error) jjte004;
4419:                                }
4420:                            } finally {
4421:                                if (jjtc004) {
4422:                                    jjtree.closeNodeScope(jjtn004, 2);
4423:                                    jjtreeCloseNodeScope(jjtn004);
4424:                                }
4425:                            }
4426:                            break;
4427:                        default:
4428:                            jj_la1[71] = jj_gen;
4429:                            jj_consume_token(-1);
4430:                            throw new ParseException();
4431:                        }
4432:                    }
4433:                }
4434:            }
4435:
4436:            //atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+
4437:            final public void atom() throws ParseException {
4438:                if (jj_2_15(2)) {
4439:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
4440:                            this , JJTTUPLE);
4441:                    boolean jjtc001 = true;
4442:                    jjtree.openNodeScope(jjtn001);
4443:                    jjtreeOpenNodeScope(jjtn001);
4444:                    try {
4445:                        jj_consume_token(LPAREN);
4446:                        jj_consume_token(RPAREN);
4447:                    } finally {
4448:                        if (jjtc001) {
4449:                            jjtree.closeNodeScope(jjtn001, true);
4450:                            jjtreeCloseNodeScope(jjtn001);
4451:                        }
4452:                    }
4453:                } else {
4454:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4455:                    case LPAREN:
4456:                        jj_consume_token(LPAREN);
4457:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4458:                        case LPAREN:
4459:                        case LBRACE:
4460:                        case LBRACKET:
4461:                        case PLUS:
4462:                        case MINUS:
4463:                        case NOT:
4464:                        case NOT_BOOL:
4465:                        case LAMBDA:
4466:                        case AS:
4467:                        case NAME:
4468:                        case DECNUMBER:
4469:                        case HEXNUMBER:
4470:                        case OCTNUMBER:
4471:                        case FLOAT:
4472:                        case COMPLEX:
4473:                        case SINGLE_STRING:
4474:                        case SINGLE_STRING2:
4475:                        case TRIPLE_STRING:
4476:                        case TRIPLE_STRING2:
4477:                        case SINGLE_USTRING:
4478:                        case SINGLE_USTRING2:
4479:                        case TRIPLE_USTRING:
4480:                        case TRIPLE_USTRING2:
4481:                        case 135:
4482:                            SmartTestList();
4483:                            break;
4484:                        default:
4485:                            jj_la1[72] = jj_gen;
4486:                            ;
4487:                        }
4488:                        jj_consume_token(RPAREN);
4489:                        break;
4490:                    case LBRACKET:
4491:                        SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
4492:                                this , JJTLIST);
4493:                        boolean jjtc002 = true;
4494:                        jjtree.openNodeScope(jjtn002);
4495:                        jjtreeOpenNodeScope(jjtn002);
4496:                        try {
4497:                            jj_consume_token(LBRACKET);
4498:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4499:                            case LPAREN:
4500:                            case LBRACE:
4501:                            case LBRACKET:
4502:                            case PLUS:
4503:                            case MINUS:
4504:                            case NOT:
4505:                            case NOT_BOOL:
4506:                            case LAMBDA:
4507:                            case AS:
4508:                            case NAME:
4509:                            case DECNUMBER:
4510:                            case HEXNUMBER:
4511:                            case OCTNUMBER:
4512:                            case FLOAT:
4513:                            case COMPLEX:
4514:                            case SINGLE_STRING:
4515:                            case SINGLE_STRING2:
4516:                            case TRIPLE_STRING:
4517:                            case TRIPLE_STRING2:
4518:                            case SINGLE_USTRING:
4519:                            case SINGLE_USTRING2:
4520:                            case TRIPLE_USTRING:
4521:                            case TRIPLE_USTRING2:
4522:                            case 135:
4523:                                listmaker();
4524:                                break;
4525:                            default:
4526:                                jj_la1[73] = jj_gen;
4527:                                ;
4528:                            }
4529:                            jj_consume_token(RBRACKET);
4530:                        } catch (Throwable jjte002) {
4531:                            if (jjtc002) {
4532:                                jjtree.clearNodeScope(jjtn002);
4533:                                jjtc002 = false;
4534:                            } else {
4535:                                jjtree.popNode();
4536:                            }
4537:                            if (jjte002 instanceof  RuntimeException) {
4538:                                {
4539:                                    if (true)
4540:                                        throw (RuntimeException) jjte002;
4541:                                }
4542:                            }
4543:                            if (jjte002 instanceof  ParseException) {
4544:                                {
4545:                                    if (true)
4546:                                        throw (ParseException) jjte002;
4547:                                }
4548:                            }
4549:                            {
4550:                                if (true)
4551:                                    throw (Error) jjte002;
4552:                            }
4553:                        } finally {
4554:                            if (jjtc002) {
4555:                                jjtree.closeNodeScope(jjtn002, true);
4556:                                jjtreeCloseNodeScope(jjtn002);
4557:                            }
4558:                        }
4559:                        break;
4560:                    case LBRACE:
4561:                        SimpleNode jjtn003 = (SimpleNode) SimpleNode.jjtCreate(
4562:                                this , JJTDICTIONARY);
4563:                        boolean jjtc003 = true;
4564:                        jjtree.openNodeScope(jjtn003);
4565:                        jjtreeOpenNodeScope(jjtn003);
4566:                        try {
4567:                            jj_consume_token(LBRACE);
4568:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4569:                            case LPAREN:
4570:                            case LBRACE:
4571:                            case LBRACKET:
4572:                            case PLUS:
4573:                            case MINUS:
4574:                            case NOT:
4575:                            case NOT_BOOL:
4576:                            case LAMBDA:
4577:                            case AS:
4578:                            case NAME:
4579:                            case DECNUMBER:
4580:                            case HEXNUMBER:
4581:                            case OCTNUMBER:
4582:                            case FLOAT:
4583:                            case COMPLEX:
4584:                            case SINGLE_STRING:
4585:                            case SINGLE_STRING2:
4586:                            case TRIPLE_STRING:
4587:                            case TRIPLE_STRING2:
4588:                            case SINGLE_USTRING:
4589:                            case SINGLE_USTRING2:
4590:                            case TRIPLE_USTRING:
4591:                            case TRIPLE_USTRING2:
4592:                            case 135:
4593:                                dictmaker();
4594:                                break;
4595:                            default:
4596:                                jj_la1[74] = jj_gen;
4597:                                ;
4598:                            }
4599:                            jj_consume_token(RBRACE);
4600:                        } catch (Throwable jjte003) {
4601:                            if (jjtc003) {
4602:                                jjtree.clearNodeScope(jjtn003);
4603:                                jjtc003 = false;
4604:                            } else {
4605:                                jjtree.popNode();
4606:                            }
4607:                            if (jjte003 instanceof  RuntimeException) {
4608:                                {
4609:                                    if (true)
4610:                                        throw (RuntimeException) jjte003;
4611:                                }
4612:                            }
4613:                            if (jjte003 instanceof  ParseException) {
4614:                                {
4615:                                    if (true)
4616:                                        throw (ParseException) jjte003;
4617:                                }
4618:                            }
4619:                            {
4620:                                if (true)
4621:                                    throw (Error) jjte003;
4622:                            }
4623:                        } finally {
4624:                            if (jjtc003) {
4625:                                jjtree.closeNodeScope(jjtn003, true);
4626:                                jjtreeCloseNodeScope(jjtn003);
4627:                            }
4628:                        }
4629:                        break;
4630:                    case 135:
4631:                        jj_consume_token(135);
4632:                        SmartTestList();
4633:                        SimpleNode jjtn004 = (SimpleNode) SimpleNode.jjtCreate(
4634:                                this , JJTSTR_1OP);
4635:                        boolean jjtc004 = true;
4636:                        jjtree.openNodeScope(jjtn004);
4637:                        jjtreeOpenNodeScope(jjtn004);
4638:                        try {
4639:                            jj_consume_token(135);
4640:                        } finally {
4641:                            if (jjtc004) {
4642:                                jjtree.closeNodeScope(jjtn004, 1);
4643:                                jjtreeCloseNodeScope(jjtn004);
4644:                            }
4645:                        }
4646:                        break;
4647:                    case AS:
4648:                    case NAME:
4649:                        Name();
4650:                        break;
4651:                    case DECNUMBER:
4652:                    case HEXNUMBER:
4653:                    case OCTNUMBER:
4654:                    case FLOAT:
4655:                    case COMPLEX:
4656:                        Number();
4657:                        break;
4658:                    case SINGLE_STRING:
4659:                    case SINGLE_STRING2:
4660:                    case TRIPLE_STRING:
4661:                    case TRIPLE_STRING2:
4662:                    case SINGLE_USTRING:
4663:                    case SINGLE_USTRING2:
4664:                    case TRIPLE_USTRING:
4665:                    case TRIPLE_USTRING2:
4666:                        String();
4667:                        label_30: while (true) {
4668:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4669:                            case SINGLE_STRING:
4670:                            case SINGLE_STRING2:
4671:                            case TRIPLE_STRING:
4672:                            case TRIPLE_STRING2:
4673:                            case SINGLE_USTRING:
4674:                            case SINGLE_USTRING2:
4675:                            case TRIPLE_USTRING:
4676:                            case TRIPLE_USTRING2:
4677:                                ;
4678:                                break;
4679:                            default:
4680:                                jj_la1[75] = jj_gen;
4681:                                break label_30;
4682:                            }
4683:                            SimpleNode jjtn005 = (SimpleNode) SimpleNode
4684:                                    .jjtCreate(this , JJTSTRJOIN);
4685:                            boolean jjtc005 = true;
4686:                            jjtree.openNodeScope(jjtn005);
4687:                            jjtreeOpenNodeScope(jjtn005);
4688:                            try {
4689:                                String();
4690:                            } catch (Throwable jjte005) {
4691:                                if (jjtc005) {
4692:                                    jjtree.clearNodeScope(jjtn005);
4693:                                    jjtc005 = false;
4694:                                } else {
4695:                                    jjtree.popNode();
4696:                                }
4697:                                if (jjte005 instanceof  RuntimeException) {
4698:                                    {
4699:                                        if (true)
4700:                                            throw (RuntimeException) jjte005;
4701:                                    }
4702:                                }
4703:                                if (jjte005 instanceof  ParseException) {
4704:                                    {
4705:                                        if (true)
4706:                                            throw (ParseException) jjte005;
4707:                                    }
4708:                                }
4709:                                {
4710:                                    if (true)
4711:                                        throw (Error) jjte005;
4712:                                }
4713:                            } finally {
4714:                                if (jjtc005) {
4715:                                    jjtree.closeNodeScope(jjtn005, 2);
4716:                                    jjtreeCloseNodeScope(jjtn005);
4717:                                }
4718:                            }
4719:                        }
4720:                        break;
4721:                    default:
4722:                        jj_la1[76] = jj_gen;
4723:                        jj_consume_token(-1);
4724:                        throw new ParseException();
4725:                    }
4726:                }
4727:            }
4728:
4729:            //lambdef: 'lambda' [varargslist] ':' test
4730:            final public void lambdef() throws ParseException {
4731:                /*@bgen(jjtree) lambdef */
4732:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
4733:                        JJTLAMBDEF);
4734:                boolean jjtc000 = true;
4735:                jjtree.openNodeScope(jjtn000);
4736:                jjtreeOpenNodeScope(jjtn000);
4737:                try {
4738:                    jj_consume_token(LAMBDA);
4739:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4740:                    case LPAREN:
4741:                    case MULTIPLY:
4742:                    case POWER:
4743:                    case AS:
4744:                    case NAME:
4745:                        varargslist();
4746:                        break;
4747:                    default:
4748:                        jj_la1[77] = jj_gen;
4749:                        ;
4750:                    }
4751:                    jj_consume_token(COLON);
4752:                    test();
4753:                } catch (Throwable jjte000) {
4754:                    if (jjtc000) {
4755:                        jjtree.clearNodeScope(jjtn000);
4756:                        jjtc000 = false;
4757:                    } else {
4758:                        jjtree.popNode();
4759:                    }
4760:                    if (jjte000 instanceof  RuntimeException) {
4761:                        {
4762:                            if (true)
4763:                                throw (RuntimeException) jjte000;
4764:                        }
4765:                    }
4766:                    if (jjte000 instanceof  ParseException) {
4767:                        {
4768:                            if (true)
4769:                                throw (ParseException) jjte000;
4770:                        }
4771:                    }
4772:                    {
4773:                        if (true)
4774:                            throw (Error) jjte000;
4775:                    }
4776:                } finally {
4777:                    if (jjtc000) {
4778:                        jjtree.closeNodeScope(jjtn000, true);
4779:                        jjtreeCloseNodeScope(jjtn000);
4780:                    }
4781:                }
4782:            }
4783:
4784:            //subscriptlist: subscript (',' subscript)* [',']
4785:            final public void subscriptlist() throws ParseException {
4786:                SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(this ,
4787:                        JJTSUBSCRIPTLIST);
4788:                boolean jjtc001 = true;
4789:                jjtree.openNodeScope(jjtn001);
4790:                jjtreeOpenNodeScope(jjtn001);
4791:                try {
4792:                    subscript();
4793:                    label_31: while (true) {
4794:                        if (jj_2_16(2)) {
4795:                            ;
4796:                        } else {
4797:                            break label_31;
4798:                        }
4799:                        jj_consume_token(COMMA);
4800:                        subscript();
4801:                    }
4802:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4803:                    case COMMA:
4804:                        Comma();
4805:                        break;
4806:                    default:
4807:                        jj_la1[78] = jj_gen;
4808:                        ;
4809:                    }
4810:                } catch (Throwable jjte001) {
4811:                    if (jjtc001) {
4812:                        jjtree.clearNodeScope(jjtn001);
4813:                        jjtc001 = false;
4814:                    } else {
4815:                        jjtree.popNode();
4816:                    }
4817:                    if (jjte001 instanceof  RuntimeException) {
4818:                        {
4819:                            if (true)
4820:                                throw (RuntimeException) jjte001;
4821:                        }
4822:                    }
4823:                    if (jjte001 instanceof  ParseException) {
4824:                        {
4825:                            if (true)
4826:                                throw (ParseException) jjte001;
4827:                        }
4828:                    }
4829:                    {
4830:                        if (true)
4831:                            throw (Error) jjte001;
4832:                    }
4833:                } finally {
4834:                    if (jjtc001) {
4835:                        jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
4836:                        jjtreeCloseNodeScope(jjtn001);
4837:                    }
4838:                }
4839:            }
4840:
4841:            //subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
4842:            final public void subscript() throws ParseException {
4843:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4844:                case DOT:
4845:                    jj_consume_token(DOT);
4846:                    jj_consume_token(DOT);
4847:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
4848:                            this , JJTELLIPSES);
4849:                    boolean jjtc001 = true;
4850:                    jjtree.openNodeScope(jjtn001);
4851:                    jjtreeOpenNodeScope(jjtn001);
4852:                    try {
4853:                        jj_consume_token(DOT);
4854:                    } finally {
4855:                        if (jjtc001) {
4856:                            jjtree.closeNodeScope(jjtn001, true);
4857:                            jjtreeCloseNodeScope(jjtn001);
4858:                        }
4859:                    }
4860:                    break;
4861:                case LPAREN:
4862:                case LBRACE:
4863:                case LBRACKET:
4864:                case PLUS:
4865:                case MINUS:
4866:                case NOT:
4867:                case NOT_BOOL:
4868:                case LAMBDA:
4869:                case AS:
4870:                case NAME:
4871:                case DECNUMBER:
4872:                case HEXNUMBER:
4873:                case OCTNUMBER:
4874:                case FLOAT:
4875:                case COMPLEX:
4876:                case SINGLE_STRING:
4877:                case SINGLE_STRING2:
4878:                case TRIPLE_STRING:
4879:                case TRIPLE_STRING2:
4880:                case SINGLE_USTRING:
4881:                case SINGLE_USTRING2:
4882:                case TRIPLE_USTRING:
4883:                case TRIPLE_USTRING2:
4884:                case 135:
4885:                    SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
4886:                            this , JJTSLICE);
4887:                    boolean jjtc002 = true;
4888:                    jjtree.openNodeScope(jjtn002);
4889:                    jjtreeOpenNodeScope(jjtn002);
4890:                    try {
4891:                        test();
4892:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4893:                        case COLON:
4894:                            slice();
4895:                            break;
4896:                        default:
4897:                            jj_la1[79] = jj_gen;
4898:                            ;
4899:                        }
4900:                    } catch (Throwable jjte002) {
4901:                        if (jjtc002) {
4902:                            jjtree.clearNodeScope(jjtn002);
4903:                            jjtc002 = false;
4904:                        } else {
4905:                            jjtree.popNode();
4906:                        }
4907:                        if (jjte002 instanceof  RuntimeException) {
4908:                            {
4909:                                if (true)
4910:                                    throw (RuntimeException) jjte002;
4911:                            }
4912:                        }
4913:                        if (jjte002 instanceof  ParseException) {
4914:                            {
4915:                                if (true)
4916:                                    throw (ParseException) jjte002;
4917:                            }
4918:                        }
4919:                        {
4920:                            if (true)
4921:                                throw (Error) jjte002;
4922:                        }
4923:                    } finally {
4924:                        if (jjtc002) {
4925:                            jjtree.closeNodeScope(jjtn002, true);
4926:                            jjtreeCloseNodeScope(jjtn002);
4927:                        }
4928:                    }
4929:                    break;
4930:                case COLON:
4931:                    SimpleNode jjtn003 = (SimpleNode) SimpleNode.jjtCreate(
4932:                            this , JJTSLICE);
4933:                    boolean jjtc003 = true;
4934:                    jjtree.openNodeScope(jjtn003);
4935:                    jjtreeOpenNodeScope(jjtn003);
4936:                    try {
4937:                        slice();
4938:                    } catch (Throwable jjte003) {
4939:                        if (jjtc003) {
4940:                            jjtree.clearNodeScope(jjtn003);
4941:                            jjtc003 = false;
4942:                        } else {
4943:                            jjtree.popNode();
4944:                        }
4945:                        if (jjte003 instanceof  RuntimeException) {
4946:                            {
4947:                                if (true)
4948:                                    throw (RuntimeException) jjte003;
4949:                            }
4950:                        }
4951:                        if (jjte003 instanceof  ParseException) {
4952:                            {
4953:                                if (true)
4954:                                    throw (ParseException) jjte003;
4955:                            }
4956:                        }
4957:                        {
4958:                            if (true)
4959:                                throw (Error) jjte003;
4960:                        }
4961:                    } finally {
4962:                        if (jjtc003) {
4963:                            jjtree.closeNodeScope(jjtn003,
4964:                                    jjtree.nodeArity() > 0);
4965:                            jjtreeCloseNodeScope(jjtn003);
4966:                        }
4967:                    }
4968:                    break;
4969:                default:
4970:                    jj_la1[80] = jj_gen;
4971:                    jj_consume_token(-1);
4972:                    throw new ParseException();
4973:                }
4974:            }
4975:
4976:            //sliceop: ':' [test]
4977:            final public void slice() throws ParseException {
4978:                Colon();
4979:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4980:                case LPAREN:
4981:                case LBRACE:
4982:                case LBRACKET:
4983:                case PLUS:
4984:                case MINUS:
4985:                case NOT:
4986:                case NOT_BOOL:
4987:                case LAMBDA:
4988:                case AS:
4989:                case NAME:
4990:                case DECNUMBER:
4991:                case HEXNUMBER:
4992:                case OCTNUMBER:
4993:                case FLOAT:
4994:                case COMPLEX:
4995:                case SINGLE_STRING:
4996:                case SINGLE_STRING2:
4997:                case TRIPLE_STRING:
4998:                case TRIPLE_STRING2:
4999:                case SINGLE_USTRING:
5000:                case SINGLE_USTRING2:
5001:                case TRIPLE_USTRING:
5002:                case TRIPLE_USTRING2:
5003:                case 135:
5004:                    test();
5005:                    break;
5006:                default:
5007:                    jj_la1[81] = jj_gen;
5008:                    ;
5009:                }
5010:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5011:                case COLON:
5012:                    Colon();
5013:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5014:                    case LPAREN:
5015:                    case LBRACE:
5016:                    case LBRACKET:
5017:                    case PLUS:
5018:                    case MINUS:
5019:                    case NOT:
5020:                    case NOT_BOOL:
5021:                    case LAMBDA:
5022:                    case AS:
5023:                    case NAME:
5024:                    case DECNUMBER:
5025:                    case HEXNUMBER:
5026:                    case OCTNUMBER:
5027:                    case FLOAT:
5028:                    case COMPLEX:
5029:                    case SINGLE_STRING:
5030:                    case SINGLE_STRING2:
5031:                    case TRIPLE_STRING:
5032:                    case TRIPLE_STRING2:
5033:                    case SINGLE_USTRING:
5034:                    case SINGLE_USTRING2:
5035:                    case TRIPLE_USTRING:
5036:                    case TRIPLE_USTRING2:
5037:                    case 135:
5038:                        test();
5039:                        break;
5040:                    default:
5041:                        jj_la1[82] = jj_gen;
5042:                        ;
5043:                    }
5044:                    break;
5045:                default:
5046:                    jj_la1[83] = jj_gen;
5047:                    ;
5048:                }
5049:            }
5050:
5051:            final public void Colon() throws ParseException {
5052:                /*@bgen(jjtree) Colon */
5053:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
5054:                        JJTCOLON);
5055:                boolean jjtc000 = true;
5056:                jjtree.openNodeScope(jjtn000);
5057:                jjtreeOpenNodeScope(jjtn000);
5058:                try {
5059:                    jj_consume_token(COLON);
5060:                } finally {
5061:                    if (jjtc000) {
5062:                        jjtree.closeNodeScope(jjtn000, true);
5063:                        jjtreeCloseNodeScope(jjtn000);
5064:                    }
5065:                }
5066:            }
5067:
5068:            final public void Comma() throws ParseException {
5069:                /*@bgen(jjtree) Comma */
5070:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
5071:                        JJTCOMMA);
5072:                boolean jjtc000 = true;
5073:                jjtree.openNodeScope(jjtn000);
5074:                jjtreeOpenNodeScope(jjtn000);
5075:                try {
5076:                    jj_consume_token(COMMA);
5077:                } finally {
5078:                    if (jjtc000) {
5079:                        jjtree.closeNodeScope(jjtn000, true);
5080:                        jjtreeCloseNodeScope(jjtn000);
5081:                    }
5082:                }
5083:            }
5084:
5085:            //exprlist: expr (',' expr)* [',']
5086:            final public void exprlist() throws ParseException {
5087:                SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(this ,
5088:                        JJTTUPLE);
5089:                boolean jjtc001 = true;
5090:                jjtree.openNodeScope(jjtn001);
5091:                jjtreeOpenNodeScope(jjtn001);
5092:                try {
5093:                    expr();
5094:                    label_32: while (true) {
5095:                        if (jj_2_17(2)) {
5096:                            ;
5097:                        } else {
5098:                            break label_32;
5099:                        }
5100:                        jj_consume_token(COMMA);
5101:                        expr();
5102:                    }
5103:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5104:                    case COMMA:
5105:                        Comma();
5106:                        break;
5107:                    default:
5108:                        jj_la1[84] = jj_gen;
5109:                        ;
5110:                    }
5111:                } catch (Throwable jjte001) {
5112:                    if (jjtc001) {
5113:                        jjtree.clearNodeScope(jjtn001);
5114:                        jjtc001 = false;
5115:                    } else {
5116:                        jjtree.popNode();
5117:                    }
5118:                    if (jjte001 instanceof  RuntimeException) {
5119:                        {
5120:                            if (true)
5121:                                throw (RuntimeException) jjte001;
5122:                        }
5123:                    }
5124:                    if (jjte001 instanceof  ParseException) {
5125:                        {
5126:                            if (true)
5127:                                throw (ParseException) jjte001;
5128:                        }
5129:                    }
5130:                    {
5131:                        if (true)
5132:                            throw (Error) jjte001;
5133:                    }
5134:                } finally {
5135:                    if (jjtc001) {
5136:                        jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
5137:                        jjtreeCloseNodeScope(jjtn001);
5138:                    }
5139:                }
5140:            }
5141:
5142:            //testlist: test (',' test)* [',']
5143:            final public void SmartTestList() throws ParseException {
5144:                SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(this ,
5145:                        JJTTUPLE);
5146:                boolean jjtc001 = true;
5147:                jjtree.openNodeScope(jjtn001);
5148:                jjtreeOpenNodeScope(jjtn001);
5149:                try {
5150:                    test();
5151:                    label_33: while (true) {
5152:                        if (jj_2_18(2)) {
5153:                            ;
5154:                        } else {
5155:                            break label_33;
5156:                        }
5157:                        jj_consume_token(COMMA);
5158:                        test();
5159:                    }
5160:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5161:                    case COMMA:
5162:                        Comma();
5163:                        break;
5164:                    default:
5165:                        jj_la1[85] = jj_gen;
5166:                        ;
5167:                    }
5168:                } catch (Throwable jjte001) {
5169:                    if (jjtc001) {
5170:                        jjtree.clearNodeScope(jjtn001);
5171:                        jjtc001 = false;
5172:                    } else {
5173:                        jjtree.popNode();
5174:                    }
5175:                    if (jjte001 instanceof  RuntimeException) {
5176:                        {
5177:                            if (true)
5178:                                throw (RuntimeException) jjte001;
5179:                        }
5180:                    }
5181:                    if (jjte001 instanceof  ParseException) {
5182:                        {
5183:                            if (true)
5184:                                throw (ParseException) jjte001;
5185:                        }
5186:                    }
5187:                    {
5188:                        if (true)
5189:                            throw (Error) jjte001;
5190:                    }
5191:                } finally {
5192:                    if (jjtc001) {
5193:                        jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
5194:                        jjtreeCloseNodeScope(jjtn001);
5195:                    }
5196:                }
5197:            }
5198:
5199:            //testlist: test (',' test)* [',']
5200:            final public void testlist() throws ParseException {
5201:                test();
5202:                label_34: while (true) {
5203:                    if (jj_2_19(2)) {
5204:                        ;
5205:                    } else {
5206:                        break label_34;
5207:                    }
5208:                    jj_consume_token(COMMA);
5209:                    test();
5210:                }
5211:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5212:                case COMMA:
5213:                    jj_consume_token(COMMA);
5214:                    break;
5215:                default:
5216:                    jj_la1[86] = jj_gen;
5217:                    ;
5218:                }
5219:            }
5220:
5221:            //dictmaker: test ':' test (',' test ':' test)* [',']
5222:            final public void dictmaker() throws ParseException {
5223:                test();
5224:                jj_consume_token(COLON);
5225:                test();
5226:                label_35: while (true) {
5227:                    if (jj_2_20(2)) {
5228:                        ;
5229:                    } else {
5230:                        break label_35;
5231:                    }
5232:                    jj_consume_token(COMMA);
5233:                    test();
5234:                    jj_consume_token(COLON);
5235:                    test();
5236:                }
5237:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5238:                case COMMA:
5239:                    jj_consume_token(COMMA);
5240:                    break;
5241:                default:
5242:                    jj_la1[87] = jj_gen;
5243:                    ;
5244:                }
5245:            }
5246:
5247:            //listmaker: test ( list_for | (',' test)* [','] )
5248:            final public void listmaker() throws ParseException {
5249:                test();
5250:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5251:                case FOR:
5252:                    label_36: while (true) {
5253:                        list_for();
5254:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5255:                        case FOR:
5256:                            ;
5257:                            break;
5258:                        default:
5259:                            jj_la1[88] = jj_gen;
5260:                            break label_36;
5261:                        }
5262:                    }
5263:                    break;
5264:                default:
5265:                    jj_la1[90] = jj_gen;
5266:                    label_37: while (true) {
5267:                        if (jj_2_21(2)) {
5268:                            ;
5269:                        } else {
5270:                            break label_37;
5271:                        }
5272:                        jj_consume_token(COMMA);
5273:                        test();
5274:                    }
5275:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
5276:                            this , JJTTUPLE);
5277:                    boolean jjtc001 = true;
5278:                    jjtree.openNodeScope(jjtn001);
5279:                    jjtreeOpenNodeScope(jjtn001);
5280:                    try {
5281:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5282:                        case COMMA:
5283:                            Comma();
5284:                            break;
5285:                        default:
5286:                            jj_la1[89] = jj_gen;
5287:                            ;
5288:                        }
5289:                    } catch (Throwable jjte001) {
5290:                        if (jjtc001) {
5291:                            jjtree.clearNodeScope(jjtn001);
5292:                            jjtc001 = false;
5293:                        } else {
5294:                            jjtree.popNode();
5295:                        }
5296:                        if (jjte001 instanceof  RuntimeException) {
5297:                            {
5298:                                if (true)
5299:                                    throw (RuntimeException) jjte001;
5300:                            }
5301:                        }
5302:                        if (jjte001 instanceof  ParseException) {
5303:                            {
5304:                                if (true)
5305:                                    throw (ParseException) jjte001;
5306:                            }
5307:                        }
5308:                        {
5309:                            if (true)
5310:                                throw (Error) jjte001;
5311:                        }
5312:                    } finally {
5313:                        if (jjtc001) {
5314:                            jjtree.closeNodeScope(jjtn001,
5315:                                    jjtree.nodeArity() > 1);
5316:                            jjtreeCloseNodeScope(jjtn001);
5317:                        }
5318:                    }
5319:                }
5320:            }
5321:
5322:            //list_iter: [list_for | list_if]
5323:            //void list_iter() #void: {}
5324:            //{ [ (list_for() | list_if()) ] }
5325:
5326:            //list_for: 'for' exprlist 'in' testlist list_iter
5327:            final public void list_for() throws ParseException {
5328:                /*@bgen(jjtree) list_for */
5329:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
5330:                        JJTLIST_FOR);
5331:                boolean jjtc000 = true;
5332:                jjtree.openNodeScope(jjtn000);
5333:                jjtreeOpenNodeScope(jjtn000);
5334:                try {
5335:                    jj_consume_token(FOR);
5336:                    exprlist();
5337:                    jj_consume_token(IN);
5338:                    SmartTestList();
5339:                    label_38: while (true) {
5340:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5341:                        case IF:
5342:                            ;
5343:                            break;
5344:                        default:
5345:                            jj_la1[91] = jj_gen;
5346:                            break label_38;
5347:                        }
5348:                        list_if();
5349:                    }
5350:                } catch (Throwable jjte000) {
5351:                    if (jjtc000) {
5352:                        jjtree.clearNodeScope(jjtn000);
5353:                        jjtc000 = false;
5354:                    } else {
5355:                        jjtree.popNode();
5356:                    }
5357:                    if (jjte000 instanceof  RuntimeException) {
5358:                        {
5359:                            if (true)
5360:                                throw (RuntimeException) jjte000;
5361:                        }
5362:                    }
5363:                    if (jjte000 instanceof  ParseException) {
5364:                        {
5365:                            if (true)
5366:                                throw (ParseException) jjte000;
5367:                        }
5368:                    }
5369:                    {
5370:                        if (true)
5371:                            throw (Error) jjte000;
5372:                    }
5373:                } finally {
5374:                    if (jjtc000) {
5375:                        jjtree.closeNodeScope(jjtn000, true);
5376:                        jjtreeCloseNodeScope(jjtn000);
5377:                    }
5378:                }
5379:            }
5380:
5381:            //list_if: 'if' test list_iter
5382:            final public void list_if() throws ParseException {
5383:                jj_consume_token(IF);
5384:                test();
5385:            }
5386:
5387:            //classdef: 'class' NAME ['(' testlist ')'] ':' suite
5388:            final public void classdef() throws ParseException {
5389:                /*@bgen(jjtree) classdef */
5390:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
5391:                        JJTCLASSDEF);
5392:                boolean jjtc000 = true;
5393:                jjtree.openNodeScope(jjtn000);
5394:                jjtreeOpenNodeScope(jjtn000);
5395:                try {
5396:                    jj_consume_token(CLASS);
5397:                    Name();
5398:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5399:                    case LPAREN:
5400:                        jj_consume_token(LPAREN);
5401:                        testlist();
5402:                        jj_consume_token(RPAREN);
5403:                        break;
5404:                    default:
5405:                        jj_la1[92] = jj_gen;
5406:                        ;
5407:                    }
5408:                    jj_consume_token(COLON);
5409:                    suite();
5410:                } catch (Throwable jjte000) {
5411:                    if (jjtc000) {
5412:                        jjtree.clearNodeScope(jjtn000);
5413:                        jjtc000 = false;
5414:                    } else {
5415:                        jjtree.popNode();
5416:                    }
5417:                    if (jjte000 instanceof  RuntimeException) {
5418:                        {
5419:                            if (true)
5420:                                throw (RuntimeException) jjte000;
5421:                        }
5422:                    }
5423:                    if (jjte000 instanceof  ParseException) {
5424:                        {
5425:                            if (true)
5426:                                throw (ParseException) jjte000;
5427:                        }
5428:                    }
5429:                    {
5430:                        if (true)
5431:                            throw (Error) jjte000;
5432:                    }
5433:                } finally {
5434:                    if (jjtc000) {
5435:                        jjtree.closeNodeScope(jjtn000, true);
5436:                        jjtreeCloseNodeScope(jjtn000);
5437:                    }
5438:                }
5439:            }
5440:
5441:            //arglist: (argument ',')*
5442:            //              (argument [',']| '*' test [',' '**' test] | '**' test)
5443:            final public void arglist() throws ParseException {
5444:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5445:                case LPAREN:
5446:                case LBRACE:
5447:                case LBRACKET:
5448:                case PLUS:
5449:                case MINUS:
5450:                case NOT:
5451:                case OR_BOOL:
5452:                case AND_BOOL:
5453:                case NOT_BOOL:
5454:                case IS:
5455:                case IN:
5456:                case LAMBDA:
5457:                case IF:
5458:                case ELSE:
5459:                case ELIF:
5460:                case WHILE:
5461:                case FOR:
5462:                case TRY:
5463:                case EXCEPT:
5464:                case DEF:
5465:                case CLASS:
5466:                case FINALLY:
5467:                case PRINT:
5468:                case PASS:
5469:                case BREAK:
5470:                case CONTINUE:
5471:                case RETURN:
5472:                case YIELD:
5473:                case IMPORT:
5474:                case FROM:
5475:                case DEL:
5476:                case RAISE:
5477:                case GLOBAL:
5478:                case EXEC:
5479:                case ASSERT:
5480:                case AS:
5481:                case NAME:
5482:                case DECNUMBER:
5483:                case HEXNUMBER:
5484:                case OCTNUMBER:
5485:                case FLOAT:
5486:                case COMPLEX:
5487:                case SINGLE_STRING:
5488:                case SINGLE_STRING2:
5489:                case TRIPLE_STRING:
5490:                case TRIPLE_STRING2:
5491:                case SINGLE_USTRING:
5492:                case SINGLE_USTRING2:
5493:                case TRIPLE_USTRING:
5494:                case TRIPLE_USTRING2:
5495:                case 135:
5496:                    normalargs();
5497:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5498:                    case COMMA:
5499:                        jj_consume_token(COMMA);
5500:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5501:                        case MULTIPLY:
5502:                        case POWER:
5503:                            if (jj_2_22(2)) {
5504:                                ExtraArgValueList();
5505:                                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5506:                                case COMMA:
5507:                                    jj_consume_token(COMMA);
5508:                                    ExtraKeywordValueList();
5509:                                    break;
5510:                                default:
5511:                                    jj_la1[93] = jj_gen;
5512:                                    ;
5513:                                }
5514:                            } else {
5515:                                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5516:                                case MULTIPLY:
5517:                                case POWER:
5518:                                    ExtraKeywordValueList();
5519:                                    break;
5520:                                default:
5521:                                    jj_la1[94] = jj_gen;
5522:                                    jj_consume_token(-1);
5523:                                    throw new ParseException();
5524:                                }
5525:                            }
5526:                            break;
5527:                        default:
5528:                            jj_la1[95] = jj_gen;
5529:                            ;
5530:                        }
5531:                        break;
5532:                    default:
5533:                        jj_la1[96] = jj_gen;
5534:                        ;
5535:                    }
5536:                    break;
5537:                default:
5538:                    jj_la1[100] = jj_gen;
5539:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5540:                    case MULTIPLY:
5541:                    case POWER:
5542:                        if (jj_2_23(2)) {
5543:                            ExtraArgValueList();
5544:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5545:                            case COMMA:
5546:                                jj_consume_token(COMMA);
5547:                                ExtraKeywordValueList();
5548:                                break;
5549:                            default:
5550:                                jj_la1[97] = jj_gen;
5551:                                ;
5552:                            }
5553:                        } else {
5554:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5555:                            case MULTIPLY:
5556:                            case POWER:
5557:                                ExtraKeywordValueList();
5558:                                break;
5559:                            default:
5560:                                jj_la1[98] = jj_gen;
5561:                                jj_consume_token(-1);
5562:                                throw new ParseException();
5563:                            }
5564:                        }
5565:                        break;
5566:                    default:
5567:                        jj_la1[99] = jj_gen;
5568:                        ;
5569:                    }
5570:                }
5571:            }
5572:
5573:            final public void normalargs() throws ParseException {
5574:                argument();
5575:                label_39: while (true) {
5576:                    if (jj_2_24(2)) {
5577:                        ;
5578:                    } else {
5579:                        break label_39;
5580:                    }
5581:                    jj_consume_token(COMMA);
5582:                    argument();
5583:                }
5584:            }
5585:
5586:            final public void ExtraArgValueList() throws ParseException {
5587:                /*@bgen(jjtree) ExtraArgValueList */
5588:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
5589:                        JJTEXTRAARGVALUELIST);
5590:                boolean jjtc000 = true;
5591:                jjtree.openNodeScope(jjtn000);
5592:                jjtreeOpenNodeScope(jjtn000);
5593:                try {
5594:                    jj_consume_token(MULTIPLY);
5595:                    test();
5596:                } catch (Throwable jjte000) {
5597:                    if (jjtc000) {
5598:                        jjtree.clearNodeScope(jjtn000);
5599:                        jjtc000 = false;
5600:                    } else {
5601:                        jjtree.popNode();
5602:                    }
5603:                    if (jjte000 instanceof  RuntimeException) {
5604:                        {
5605:                            if (true)
5606:                                throw (RuntimeException) jjte000;
5607:                        }
5608:                    }
5609:                    if (jjte000 instanceof  ParseException) {
5610:                        {
5611:                            if (true)
5612:                                throw (ParseException) jjte000;
5613:                        }
5614:                    }
5615:                    {
5616:                        if (true)
5617:                            throw (Error) jjte000;
5618:                    }
5619:                } finally {
5620:                    if (jjtc000) {
5621:                        jjtree.closeNodeScope(jjtn000, true);
5622:                        jjtreeCloseNodeScope(jjtn000);
5623:                    }
5624:                }
5625:            }
5626:
5627:            final public void ExtraKeywordValueList() throws ParseException {
5628:                /*@bgen(jjtree) ExtraKeywordValueList */
5629:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
5630:                        JJTEXTRAKEYWORDVALUELIST);
5631:                boolean jjtc000 = true;
5632:                jjtree.openNodeScope(jjtn000);
5633:                jjtreeOpenNodeScope(jjtn000);
5634:                try {
5635:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5636:                    case POWER:
5637:                        jj_consume_token(POWER);
5638:                        break;
5639:                    case MULTIPLY:
5640:                        jj_consume_token(MULTIPLY);
5641:                        jj_consume_token(MULTIPLY);
5642:                        break;
5643:                    default:
5644:                        jj_la1[101] = jj_gen;
5645:                        jj_consume_token(-1);
5646:                        throw new ParseException();
5647:                    }
5648:                    test();
5649:                } catch (Throwable jjte000) {
5650:                    if (jjtc000) {
5651:                        jjtree.clearNodeScope(jjtn000);
5652:                        jjtc000 = false;
5653:                    } else {
5654:                        jjtree.popNode();
5655:                    }
5656:                    if (jjte000 instanceof  RuntimeException) {
5657:                        {
5658:                            if (true)
5659:                                throw (RuntimeException) jjte000;
5660:                        }
5661:                    }
5662:                    if (jjte000 instanceof  ParseException) {
5663:                        {
5664:                            if (true)
5665:                                throw (ParseException) jjte000;
5666:                        }
5667:                    }
5668:                    {
5669:                        if (true)
5670:                            throw (Error) jjte000;
5671:                    }
5672:                } finally {
5673:                    if (jjtc000) {
5674:                        jjtree.closeNodeScope(jjtn000, true);
5675:                        jjtreeCloseNodeScope(jjtn000);
5676:                    }
5677:                }
5678:            }
5679:
5680:            //argument: [test '='] test     # Really [keyword '='] test
5681:            final public void argument() throws ParseException {
5682:                SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(this ,
5683:                        JJTKEYWORD);
5684:                boolean jjtc001 = true;
5685:                jjtree.openNodeScope(jjtn001);
5686:                jjtreeOpenNodeScope(jjtn001);
5687:                try {
5688:                    if (jj_2_25(2)) {
5689:                        AnyName();
5690:                        jj_consume_token(EQUAL);
5691:                    } else {
5692:                        ;
5693:                    }
5694:                    test();
5695:                } catch (Throwable jjte001) {
5696:                    if (jjtc001) {
5697:                        jjtree.clearNodeScope(jjtn001);
5698:                        jjtc001 = false;
5699:                    } else {
5700:                        jjtree.popNode();
5701:                    }
5702:                    if (jjte001 instanceof  RuntimeException) {
5703:                        {
5704:                            if (true)
5705:                                throw (RuntimeException) jjte001;
5706:                        }
5707:                    }
5708:                    if (jjte001 instanceof  ParseException) {
5709:                        {
5710:                            if (true)
5711:                                throw (ParseException) jjte001;
5712:                        }
5713:                    }
5714:                    {
5715:                        if (true)
5716:                            throw (Error) jjte001;
5717:                    }
5718:                } finally {
5719:                    if (jjtc001) {
5720:                        jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
5721:                        jjtreeCloseNodeScope(jjtn001);
5722:                    }
5723:                }
5724:            }
5725:
5726:            final public void Number() throws ParseException {
5727:                /*@bgen(jjtree) Num */
5728:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
5729:                        JJTNUM);
5730:                boolean jjtc000 = true;
5731:                jjtree.openNodeScope(jjtn000);
5732:                jjtreeOpenNodeScope(jjtn000);
5733:                Token t;
5734:                try {
5735:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5736:                    case HEXNUMBER:
5737:                        t = jj_consume_token(HEXNUMBER);
5738:                        String s = t.image.substring(2, t.image.length());
5739:                        jjtn000.setImage(makeInt(s, 16));
5740:                        jjtree.closeNodeScope(jjtn000, true);
5741:                        jjtc000 = false;
5742:                        jjtreeCloseNodeScope(jjtn000);
5743:
5744:                        break;
5745:                    case OCTNUMBER:
5746:                        t = jj_consume_token(OCTNUMBER);
5747:                        jjtn000.setImage(makeInt(t.image, 8));
5748:                        jjtree.closeNodeScope(jjtn000, true);
5749:                        jjtc000 = false;
5750:                        jjtreeCloseNodeScope(jjtn000);
5751:
5752:                        break;
5753:                    case DECNUMBER:
5754:                        t = jj_consume_token(DECNUMBER);
5755:                        jjtn000.setImage(makeInt(t.image, 10));
5756:                        jjtree.closeNodeScope(jjtn000, true);
5757:                        jjtc000 = false;
5758:                        jjtreeCloseNodeScope(jjtn000);
5759:
5760:                        break;
5761:                    case FLOAT:
5762:                        t = jj_consume_token(FLOAT);
5763:                        jjtn000.setImage(makeFloat(t.image));
5764:                        jjtree.closeNodeScope(jjtn000, true);
5765:                        jjtc000 = false;
5766:                        jjtreeCloseNodeScope(jjtn000);
5767:
5768:                        break;
5769:                    case COMPLEX:
5770:                        t = jj_consume_token(COMPLEX);
5771:                        jjtn000.setImage(makeComplex(t.image));
5772:                        jjtree.closeNodeScope(jjtn000, true);
5773:                        jjtc000 = false;
5774:                        jjtreeCloseNodeScope(jjtn000);
5775:
5776:                        break;
5777:                    default:
5778:                        jj_la1[102] = jj_gen;
5779:                        jj_consume_token(-1);
5780:                        throw new ParseException();
5781:                    }
5782:                } finally {
5783:                    if (jjtc000) {
5784:                        jjtree.closeNodeScope(jjtn000, true);
5785:                        jjtreeCloseNodeScope(jjtn000);
5786:                    }
5787:                }
5788:            }
5789:
5790:            final public void Complex() throws ParseException {
5791:                /*@bgen(jjtree) Complex */
5792:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
5793:                        JJTCOMPLEX);
5794:                boolean jjtc000 = true;
5795:                jjtree.openNodeScope(jjtn000);
5796:                jjtreeOpenNodeScope(jjtn000);
5797:                try {
5798:                    jj_consume_token(FLOAT);
5799:                } finally {
5800:                    if (jjtc000) {
5801:                        jjtree.closeNodeScope(jjtn000, true);
5802:                        jjtreeCloseNodeScope(jjtn000);
5803:                    }
5804:                }
5805:            }
5806:
5807:            final public void Name() throws ParseException {
5808:                /*@bgen(jjtree) Name */
5809:                SimpleNode jjtn000 = (SimpleNode) SimpleNode.jjtCreate(this ,
5810:                        JJTNAME);
5811:                boolean jjtc000 = true;
5812:                jjtree.openNodeScope(jjtn000);
5813:                jjtreeOpenNodeScope(jjtn000);
5814:                Token t;
5815:                try {
5816:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5817:                    case NAME:
5818:                        t = jj_consume_token(NAME);
5819:                        jjtn000.setImage(t.image);
5820:                        jjtree.closeNodeScope(jjtn000, true);
5821:                        jjtc000 = false;
5822:                        jjtreeCloseNodeScope(jjtn000);
5823:
5824:                        break;
5825:                    case AS:
5826:                        t = jj_consume_token(AS);
5827:                        jjtn000.setImage(t.image);
5828:                        jjtree.closeNodeScope(jjtn000, true);
5829:                        jjtc000 = false;
5830:                        jjtreeCloseNodeScope(jjtn000);
5831:
5832:                        break;
5833:                    default:
5834:                        jj_la1[103] = jj_gen;
5835:                        jj_consume_token(-1);
5836:                        throw new ParseException();
5837:                    }
5838:                } finally {
5839:                    if (jjtc000) {
5840:                        jjtree.closeNodeScope(jjtn000, true);
5841:                        jjtreeCloseNodeScope(jjtn000);
5842:                    }
5843:                }
5844:            }
5845:
5846:            final public void String() throws ParseException {
5847:                Token t;
5848:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5849:                case SINGLE_STRING:
5850:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
5851:                            this , JJTSTRING);
5852:                    boolean jjtc001 = true;
5853:                    jjtree.openNodeScope(jjtn001);
5854:                    jjtreeOpenNodeScope(jjtn001);
5855:                    try {
5856:                        t = jj_consume_token(SINGLE_STRING);
5857:                        jjtn001.setImage(makeString(t.image, 1));
5858:                        jjtree.closeNodeScope(jjtn001, true);
5859:                        jjtc001 = false;
5860:                        jjtreeCloseNodeScope(jjtn001);
5861:
5862:                    } finally {
5863:                        if (jjtc001) {
5864:                            jjtree.closeNodeScope(jjtn001, true);
5865:                            jjtreeCloseNodeScope(jjtn001);
5866:                        }
5867:                    }
5868:                    break;
5869:                case SINGLE_STRING2:
5870:                    SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
5871:                            this , JJTSTRING);
5872:                    boolean jjtc002 = true;
5873:                    jjtree.openNodeScope(jjtn002);
5874:                    jjtreeOpenNodeScope(jjtn002);
5875:                    try {
5876:                        t = jj_consume_token(SINGLE_STRING2);
5877:                        jjtn002.setImage(makeString(t.image, 1));
5878:                        jjtree.closeNodeScope(jjtn002, true);
5879:                        jjtc002 = false;
5880:                        jjtreeCloseNodeScope(jjtn002);
5881:
5882:                    } finally {
5883:                        if (jjtc002) {
5884:                            jjtree.closeNodeScope(jjtn002, true);
5885:                            jjtreeCloseNodeScope(jjtn002);
5886:                        }
5887:                    }
5888:                    break;
5889:                case TRIPLE_STRING:
5890:                    SimpleNode jjtn003 = (SimpleNode) SimpleNode.jjtCreate(
5891:                            this , JJTSTRING);
5892:                    boolean jjtc003 = true;
5893:                    jjtree.openNodeScope(jjtn003);
5894:                    jjtreeOpenNodeScope(jjtn003);
5895:                    try {
5896:                        t = jj_consume_token(TRIPLE_STRING);
5897:                        jjtn003.setImage(makeString(t.image, 3));
5898:                        jjtree.closeNodeScope(jjtn003, true);
5899:                        jjtc003 = false;
5900:                        jjtreeCloseNodeScope(jjtn003);
5901:
5902:                    } finally {
5903:                        if (jjtc003) {
5904:                            jjtree.closeNodeScope(jjtn003, true);
5905:                            jjtreeCloseNodeScope(jjtn003);
5906:                        }
5907:                    }
5908:                    break;
5909:                case TRIPLE_STRING2:
5910:                    SimpleNode jjtn004 = (SimpleNode) SimpleNode.jjtCreate(
5911:                            this , JJTSTRING);
5912:                    boolean jjtc004 = true;
5913:                    jjtree.openNodeScope(jjtn004);
5914:                    jjtreeOpenNodeScope(jjtn004);
5915:                    try {
5916:                        t = jj_consume_token(TRIPLE_STRING2);
5917:                        jjtn004.setImage(makeString(t.image, 3));
5918:                        jjtree.closeNodeScope(jjtn004, true);
5919:                        jjtc004 = false;
5920:                        jjtreeCloseNodeScope(jjtn004);
5921:
5922:                    } finally {
5923:                        if (jjtc004) {
5924:                            jjtree.closeNodeScope(jjtn004, true);
5925:                            jjtreeCloseNodeScope(jjtn004);
5926:                        }
5927:                    }
5928:                    break;
5929:                case SINGLE_USTRING:
5930:                    SimpleNode jjtn005 = (SimpleNode) SimpleNode.jjtCreate(
5931:                            this , JJTUNICODE);
5932:                    boolean jjtc005 = true;
5933:                    jjtree.openNodeScope(jjtn005);
5934:                    jjtreeOpenNodeScope(jjtn005);
5935:                    try {
5936:                        t = jj_consume_token(SINGLE_USTRING);
5937:                        jjtn005.setImage(makeString(t.image, 1));
5938:                        jjtree.closeNodeScope(jjtn005, true);
5939:                        jjtc005 = false;
5940:                        jjtreeCloseNodeScope(jjtn005);
5941:
5942:                    } finally {
5943:                        if (jjtc005) {
5944:                            jjtree.closeNodeScope(jjtn005, true);
5945:                            jjtreeCloseNodeScope(jjtn005);
5946:                        }
5947:                    }
5948:                    break;
5949:                case SINGLE_USTRING2:
5950:                    SimpleNode jjtn006 = (SimpleNode) SimpleNode.jjtCreate(
5951:                            this , JJTUNICODE);
5952:                    boolean jjtc006 = true;
5953:                    jjtree.openNodeScope(jjtn006);
5954:                    jjtreeOpenNodeScope(jjtn006);
5955:                    try {
5956:                        t = jj_consume_token(SINGLE_USTRING2);
5957:                        jjtn006.setImage(makeString(t.image, 1));
5958:                        jjtree.closeNodeScope(jjtn006, true);
5959:                        jjtc006 = false;
5960:                        jjtreeCloseNodeScope(jjtn006);
5961:
5962:                    } finally {
5963:                        if (jjtc006) {
5964:                            jjtree.closeNodeScope(jjtn006, true);
5965:                            jjtreeCloseNodeScope(jjtn006);
5966:                        }
5967:                    }
5968:                    break;
5969:                case TRIPLE_USTRING:
5970:                    SimpleNode jjtn007 = (SimpleNode) SimpleNode.jjtCreate(
5971:                            this , JJTUNICODE);
5972:                    boolean jjtc007 = true;
5973:                    jjtree.openNodeScope(jjtn007);
5974:                    jjtreeOpenNodeScope(jjtn007);
5975:                    try {
5976:                        t = jj_consume_token(TRIPLE_USTRING);
5977:                        jjtn007.setImage(makeString(t.image, 3));
5978:                        jjtree.closeNodeScope(jjtn007, true);
5979:                        jjtc007 = false;
5980:                        jjtreeCloseNodeScope(jjtn007);
5981:
5982:                    } finally {
5983:                        if (jjtc007) {
5984:                            jjtree.closeNodeScope(jjtn007, true);
5985:                            jjtreeCloseNodeScope(jjtn007);
5986:                        }
5987:                    }
5988:                    break;
5989:                case TRIPLE_USTRING2:
5990:                    SimpleNode jjtn008 = (SimpleNode) SimpleNode.jjtCreate(
5991:                            this , JJTUNICODE);
5992:                    boolean jjtc008 = true;
5993:                    jjtree.openNodeScope(jjtn008);
5994:                    jjtreeOpenNodeScope(jjtn008);
5995:                    try {
5996:                        t = jj_consume_token(TRIPLE_USTRING2);
5997:                        jjtn008.setImage(makeString(t.image, 3));
5998:                        jjtree.closeNodeScope(jjtn008, true);
5999:                        jjtc008 = false;
6000:                        jjtreeCloseNodeScope(jjtn008);
6001:
6002:                    } finally {
6003:                        if (jjtc008) {
6004:                            jjtree.closeNodeScope(jjtn008, true);
6005:                            jjtreeCloseNodeScope(jjtn008);
6006:                        }
6007:                    }
6008:                    break;
6009:                default:
6010:                    jj_la1[104] = jj_gen;
6011:                    jj_consume_token(-1);
6012:                    throw new ParseException();
6013:                }
6014:            }
6015:
6016:            final public Token AnyName() throws ParseException {
6017:                Token t;
6018:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
6019:                case NAME:
6020:                    SimpleNode jjtn001 = (SimpleNode) SimpleNode.jjtCreate(
6021:                            this , JJTNAME);
6022:                    boolean jjtc001 = true;
6023:                    jjtree.openNodeScope(jjtn001);
6024:                    jjtreeOpenNodeScope(jjtn001);
6025:                    try {
6026:                        t = jj_consume_token(NAME);
6027:                        jjtn001.setImage(t.image);
6028:                        {
6029:                            if (true)
6030:                                return t;
6031:                        }
6032:                        jjtree.closeNodeScope(jjtn001, true);
6033:                        jjtc001 = false;
6034:                        jjtreeCloseNodeScope(jjtn001);
6035:
6036:                    } finally {
6037:                        if (jjtc001) {
6038:                            jjtree.closeNodeScope(jjtn001, true);
6039:                            jjtreeCloseNodeScope(jjtn001);
6040:                        }
6041:                    }
6042:                    break;
6043:                case OR_BOOL:
6044:                    SimpleNode jjtn002 = (SimpleNode) SimpleNode.jjtCreate(
6045:                            this , JJTNAME);
6046:                    boolean jjtc002 = true;
6047:                    jjtree.openNodeScope(jjtn002);
6048:                    jjtreeOpenNodeScope(jjtn002);
6049:                    try {
6050:                        t = jj_consume_token(OR_BOOL);
6051:                        jjtn002.setImage(t.image);
6052:                        {
6053:                            if (true)
6054:                                return t;
6055:                        }
6056:                        jjtree.closeNodeScope(jjtn002, true);
6057:                        jjtc002 = false;
6058:                        jjtreeCloseNodeScope(jjtn002);
6059:
6060:                    } finally {
6061:                        if (jjtc002) {
6062:                            jjtree.closeNodeScope(jjtn002, true);
6063:                            jjtreeCloseNodeScope(jjtn002);
6064:                        }
6065:                    }
6066:                    break;
6067:                case AND_BOOL:
6068:                    SimpleNode jjtn003 = (SimpleNode) SimpleNode.jjtCreate(
6069:                            this , JJTNAME);
6070:                    boolean jjtc003 = true;
6071:                    jjtree.openNodeScope(jjtn003);
6072:                    jjtreeOpenNodeScope(jjtn003);
6073:                    try {
6074:                        t = jj_consume_token(AND_BOOL);
6075:                        jjtn003.setImage(t.image);
6076:                        {
6077:                            if (true)
6078:                                return t;
6079:                        }
6080:                        jjtree.closeNodeScope(jjtn003, true);
6081:                        jjtc003 = false;
6082:                        jjtreeCloseNodeScope(jjtn003);
6083:
6084:                    } finally {
6085:                        if (jjtc003) {
6086:                            jjtree.closeNodeScope(jjtn003, true);
6087:                            jjtreeCloseNodeScope(jjtn003);
6088:                        }
6089:                    }
6090:                    break;
6091:                case NOT_BOOL:
6092:                    SimpleNode jjtn004 = (SimpleNode) SimpleNode.jjtCreate(
6093:                            this , JJTNAME);
6094:                    boolean jjtc004 = true;
6095:                    jjtree.openNodeScope(jjtn004);
6096:                    jjtreeOpenNodeScope(jjtn004);
6097:                    try {
6098:                        t = jj_consume_token(NOT_BOOL);
6099:                        jjtn004.setImage(t.image);
6100:                        {
6101:                            if (true)
6102:                                return t;
6103:                        }
6104:                        jjtree.closeNodeScope(jjtn004, true);
6105:                        jjtc004 = false;
6106:                        jjtreeCloseNodeScope(jjtn004);
6107:
6108:                    } finally {
6109:                        if (jjtc004) {
6110:                            jjtree.closeNodeScope(jjtn004, true);
6111:                            jjtreeCloseNodeScope(jjtn004);
6112:                        }
6113:                    }
6114:                    break;
6115:                case IS:
6116:                    SimpleNode jjtn005 = (SimpleNode) SimpleNode.jjtCreate(
6117:                            this , JJTNAME);
6118:                    boolean jjtc005 = true;
6119:                    jjtree.openNodeScope(jjtn005);
6120:                    jjtreeOpenNodeScope(jjtn005);
6121:                    try {
6122:                        t = jj_consume_token(IS);
6123:                        jjtn005.setImage(t.image);
6124:                        {
6125:                            if (true)
6126:                                return t;
6127:                        }
6128:                        jjtree.closeNodeScope(jjtn005, true);
6129:                        jjtc005 = false;
6130:                        jjtreeCloseNodeScope(jjtn005);
6131:
6132:                    } finally {
6133:                        if (jjtc005) {
6134:                            jjtree.closeNodeScope(jjtn005, true);
6135:                            jjtreeCloseNodeScope(jjtn005);
6136:                        }
6137:                    }
6138:                    break;
6139:                case IN:
6140:                    SimpleNode jjtn006 = (SimpleNode) SimpleNode.jjtCreate(
6141:                            this , JJTNAME);
6142:                    boolean jjtc006 = true;
6143:                    jjtree.openNodeScope(jjtn006);
6144:                    jjtreeOpenNodeScope(jjtn006);
6145:                    try {
6146:                        t = jj_consume_token(IN);
6147:                        jjtn006.setImage(t.image);
6148:                        {
6149:                            if (true)
6150:                                return t;
6151:                        }
6152:                        jjtree.closeNodeScope(jjtn006, true);
6153:                        jjtc006 = false;
6154:                        jjtreeCloseNodeScope(jjtn006);
6155:
6156:                    } finally {
6157:                        if (jjtc006) {
6158:                            jjtree.closeNodeScope(jjtn006, true);
6159:                            jjtreeCloseNodeScope(jjtn006);
6160:                        }
6161:                    }
6162:                    break;
6163:                case LAMBDA:
6164:                    SimpleNode jjtn007 = (SimpleNode) SimpleNode.jjtCreate(
6165:                            this , JJTNAME);
6166:                    boolean jjtc007 = true;
6167:                    jjtree.openNodeScope(jjtn007);
6168:                    jjtreeOpenNodeScope(jjtn007);
6169:                    try {
6170:                        t = jj_consume_token(LAMBDA);
6171:                        jjtn007.setImage(t.image);
6172:                        {
6173:                            if (true)
6174:                                return t;
6175:                        }
6176:                        jjtree.closeNodeScope(jjtn007, true);
6177:                        jjtc007 = false;
6178:                        jjtreeCloseNodeScope(jjtn007);
6179:
6180:                    } finally {
6181:                        if (jjtc007) {
6182:                            jjtree.closeNodeScope(jjtn007, true);
6183:                            jjtreeCloseNodeScope(jjtn007);
6184:                        }
6185:                    }
6186:                    break;
6187:                case IF:
6188:                    SimpleNode jjtn008 = (SimpleNode) SimpleNode.jjtCreate(
6189:                            this , JJTNAME);
6190:                    boolean jjtc008 = true;
6191:                    jjtree.openNodeScope(jjtn008);
6192:                    jjtreeOpenNodeScope(jjtn008);
6193:                    try {
6194:                        t = jj_consume_token(IF);
6195:                        jjtn008.setImage(t.image);
6196:                        {
6197:                            if (true)
6198:                                return t;
6199:                        }
6200:                        jjtree.closeNodeScope(jjtn008, true);
6201:                        jjtc008 = false;
6202:                        jjtreeCloseNodeScope(jjtn008);
6203:
6204:                    } finally {
6205:                        if (jjtc008) {
6206:                            jjtree.closeNodeScope(jjtn008, true);
6207:                            jjtreeCloseNodeScope(jjtn008);
6208:                        }
6209:                    }
6210:                    break;
6211:                case ELSE:
6212:                    SimpleNode jjtn009 = (SimpleNode) SimpleNode.jjtCreate(
6213:                            this , JJTNAME);
6214:                    boolean jjtc009 = true;
6215:                    jjtree.openNodeScope(jjtn009);
6216:                    jjtreeOpenNodeScope(jjtn009);
6217:                    try {
6218:                        t = jj_consume_token(ELSE);
6219:                        jjtn009.setImage(t.image);
6220:                        {
6221:                            if (true)
6222:                                return t;
6223:                        }
6224:                        jjtree.closeNodeScope(jjtn009, true);
6225:                        jjtc009 = false;
6226:                        jjtreeCloseNodeScope(jjtn009);
6227:
6228:                    } finally {
6229:                        if (jjtc009) {
6230:                            jjtree.closeNodeScope(jjtn009, true);
6231:                            jjtreeCloseNodeScope(jjtn009);
6232:                        }
6233:                    }
6234:                    break;
6235:                case ELIF:
6236:                    SimpleNode jjtn010 = (SimpleNode) SimpleNode.jjtCreate(
6237:                            this , JJTNAME);
6238:                    boolean jjtc010 = true;
6239:                    jjtree.openNodeScope(jjtn010);
6240:                    jjtreeOpenNodeScope(jjtn010);
6241:                    try {
6242:                        t = jj_consume_token(ELIF);
6243:                        jjtn010.setImage(t.image);
6244:                        {
6245:                            if (true)
6246:                                return t;
6247:                        }
6248:                        jjtree.closeNodeScope(jjtn010, true);
6249:                        jjtc010 = false;
6250:                        jjtreeCloseNodeScope(jjtn010);
6251:
6252:                    } finally {
6253:                        if (jjtc010) {
6254:                            jjtree.closeNodeScope(jjtn010, true);
6255:                            jjtreeCloseNodeScope(jjtn010);
6256:                        }
6257:                    }
6258:                    break;
6259:                case WHILE:
6260:                    SimpleNode jjtn011 = (SimpleNode) SimpleNode.jjtCreate(
6261:                            this , JJTNAME);
6262:                    boolean jjtc011 = true;
6263:                    jjtree.openNodeScope(jjtn011);
6264:                    jjtreeOpenNodeScope(jjtn011);
6265:                    try {
6266:                        t = jj_consume_token(WHILE);
6267:                        jjtn011.setImage(t.image);
6268:                        {
6269:                            if (true)
6270:                                return t;
6271:                        }
6272:                        jjtree.closeNodeScope(jjtn011, true);
6273:                        jjtc011 = false;
6274:                        jjtreeCloseNodeScope(jjtn011);
6275:
6276:                    } finally {
6277:                        if (jjtc011) {
6278:                            jjtree.closeNodeScope(jjtn011, true);
6279:                            jjtreeCloseNodeScope(jjtn011);
6280:                        }
6281:                    }
6282:                    break;
6283:                case FOR:
6284:                    SimpleNode jjtn012 = (SimpleNode) SimpleNode.jjtCreate(
6285:                            this , JJTNAME);
6286:                    boolean jjtc012 = true;
6287:                    jjtree.openNodeScope(jjtn012);
6288:                    jjtreeOpenNodeScope(jjtn012);
6289:                    try {
6290:                        t = jj_consume_token(FOR);
6291:                        jjtn012.setImage(t.image);
6292:                        {
6293:                            if (true)
6294:                                return t;
6295:                        }
6296:                        jjtree.closeNodeScope(jjtn012, true);
6297:                        jjtc012 = false;
6298:                        jjtreeCloseNodeScope(jjtn012);
6299:
6300:                    } finally {
6301:                        if (jjtc012) {
6302:                            jjtree.closeNodeScope(jjtn012, true);
6303:                            jjtreeCloseNodeScope(jjtn012);
6304:                        }
6305:                    }
6306:                    break;
6307:                case TRY:
6308:                    SimpleNode jjtn013 = (SimpleNode) SimpleNode.jjtCreate(
6309:                            this , JJTNAME);
6310:                    boolean jjtc013 = true;
6311:                    jjtree.openNodeScope(jjtn013);
6312:                    jjtreeOpenNodeScope(jjtn013);
6313:                    try {
6314:                        t = jj_consume_token(TRY);
6315:                        jjtn013.setImage(t.image);
6316:                        {
6317:                            if (true)
6318:                                return t;
6319:                        }
6320:                        jjtree.closeNodeScope(jjtn013, true);
6321:                        jjtc013 = false;
6322:                        jjtreeCloseNodeScope(jjtn013);
6323:
6324:                    } finally {
6325:                        if (jjtc013) {
6326:                            jjtree.closeNodeScope(jjtn013, true);
6327:                            jjtreeCloseNodeScope(jjtn013);
6328:                        }
6329:                    }
6330:                    break;
6331:                case EXCEPT:
6332:                    SimpleNode jjtn014 = (SimpleNode) SimpleNode.jjtCreate(
6333:                            this , JJTNAME);
6334:                    boolean jjtc014 = true;
6335:                    jjtree.openNodeScope(jjtn014);
6336:                    jjtreeOpenNodeScope(jjtn014);
6337:                    try {
6338:                        t = jj_consume_token(EXCEPT);
6339:                        jjtn014.setImage(t.image);
6340:                        {
6341:                            if (true)
6342:                                return t;
6343:                        }
6344:                        jjtree.closeNodeScope(jjtn014, true);
6345:                        jjtc014 = false;
6346:                        jjtreeCloseNodeScope(jjtn014);
6347:
6348:                    } finally {
6349:                        if (jjtc014) {
6350:                            jjtree.closeNodeScope(jjtn014, true);
6351:                            jjtreeCloseNodeScope(jjtn014);
6352:                        }
6353:                    }
6354:                    break;
6355:                case DEF:
6356:                    SimpleNode jjtn015 = (SimpleNode) SimpleNode.jjtCreate(
6357:                            this , JJTNAME);
6358:                    boolean jjtc015 = true;
6359:                    jjtree.openNodeScope(jjtn015);
6360:                    jjtreeOpenNodeScope(jjtn015);
6361:                    try {
6362:                        t = jj_consume_token(DEF);
6363:                        jjtn015.setImage(t.image);
6364:                        {
6365:                            if (true)
6366:                                return t;
6367:                        }
6368:                        jjtree.closeNodeScope(jjtn015, true);
6369:                        jjtc015 = false;
6370:                        jjtreeCloseNodeScope(jjtn015);
6371:
6372:                    } finally {
6373:                        if (jjtc015) {
6374:                            jjtree.closeNodeScope(jjtn015, true);
6375:                            jjtreeCloseNodeScope(jjtn015);
6376:                        }
6377:                    }
6378:                    break;
6379:                case CLASS:
6380:                    SimpleNode jjtn016 = (SimpleNode) SimpleNode.jjtCreate(
6381:                            this , JJTNAME);
6382:                    boolean jjtc016 = true;
6383:                    jjtree.openNodeScope(jjtn016);
6384:                    jjtreeOpenNodeScope(jjtn016);
6385:                    try {
6386:                        t = jj_consume_token(CLASS);
6387:                        jjtn016.setImage(t.image);
6388:                        {
6389:                            if (true)
6390:                                return t;
6391:                        }
6392:                        jjtree.closeNodeScope(jjtn016, true);
6393:                        jjtc016 = false;
6394:                        jjtreeCloseNodeScope(jjtn016);
6395:
6396:                    } finally {
6397:                        if (jjtc016) {
6398:                            jjtree.closeNodeScope(jjtn016, true);
6399:                            jjtreeCloseNodeScope(jjtn016);
6400:                        }
6401:                    }
6402:                    break;
6403:                case FINALLY:
6404:                    SimpleNode jjtn017 = (SimpleNode) SimpleNode.jjtCreate(
6405:                            this , JJTNAME);
6406:                    boolean jjtc017 = true;
6407:                    jjtree.openNodeScope(jjtn017);
6408:                    jjtreeOpenNodeScope(jjtn017);
6409:                    try {
6410:                        t = jj_consume_token(FINALLY);
6411:                        jjtn017.setImage(t.image);
6412:                        {
6413:                            if (true)
6414:                                return t;
6415:                        }
6416:                        jjtree.closeNodeScope(jjtn017, true);
6417:                        jjtc017 = false;
6418:                        jjtreeCloseNodeScope(jjtn017);
6419:
6420:                    } finally {
6421:                        if (jjtc017) {
6422:                            jjtree.closeNodeScope(jjtn017, true);
6423:                            jjtreeCloseNodeScope(jjtn017);
6424:                        }
6425:                    }
6426:                    break;
6427:                case PRINT:
6428:                    SimpleNode jjtn018 = (SimpleNode) SimpleNode.jjtCreate(
6429:                            this , JJTNAME);
6430:                    boolean jjtc018 = true;
6431:                    jjtree.openNodeScope(jjtn018);
6432:                    jjtreeOpenNodeScope(jjtn018);
6433:                    try {
6434:                        t = jj_consume_token(PRINT);
6435:                        jjtn018.setImage(t.image);
6436:                        {
6437:                            if (true)
6438:                                return t;
6439:                        }
6440:                        jjtree.closeNodeScope(jjtn018, true);
6441:                        jjtc018 = false;
6442:                        jjtreeCloseNodeScope(jjtn018);
6443:
6444:                    } finally {
6445:                        if (jjtc018) {
6446:                            jjtree.closeNodeScope(jjtn018, true);
6447:                            jjtreeCloseNodeScope(jjtn018);
6448:                        }
6449:                    }
6450:                    break;
6451:                case PASS:
6452:                    SimpleNode jjtn019 = (SimpleNode) SimpleNode.jjtCreate(
6453:                            this , JJTNAME);
6454:                    boolean jjtc019 = true;
6455:                    jjtree.openNodeScope(jjtn019);
6456:                    jjtreeOpenNodeScope(jjtn019);
6457:                    try {
6458:                        t = jj_consume_token(PASS);
6459:                        jjtn019.setImage(t.image);
6460:                        {
6461:                            if (true)
6462:                                return t;
6463:                        }
6464:                        jjtree.closeNodeScope(jjtn019, true);
6465:                        jjtc019 = false;
6466:                        jjtreeCloseNodeScope(jjtn019);
6467:
6468:                    } finally {
6469:                        if (jjtc019) {
6470:                            jjtree.closeNodeScope(jjtn019, true);
6471:                            jjtreeCloseNodeScope(jjtn019);
6472:                        }
6473:                    }
6474:                    break;
6475:                case BREAK:
6476:                    SimpleNode jjtn020 = (SimpleNode) SimpleNode.jjtCreate(
6477:                            this , JJTNAME);
6478:                    boolean jjtc020 = true;
6479:                    jjtree.openNodeScope(jjtn020);
6480:                    jjtreeOpenNodeScope(jjtn020);
6481:                    try {
6482:                        t = jj_consume_token(BREAK);
6483:                        jjtn020.setImage(t.image);
6484:                        {
6485:                            if (true)
6486:                                return t;
6487:                        }
6488:                        jjtree.closeNodeScope(jjtn020, true);
6489:                        jjtc020 = false;
6490:                        jjtreeCloseNodeScope(jjtn020);
6491:
6492:                    } finally {
6493:                        if (jjtc020) {
6494:                            jjtree.closeNodeScope(jjtn020, true);
6495:                            jjtreeCloseNodeScope(jjtn020);
6496:                        }
6497:                    }
6498:                    break;
6499:                case CONTINUE:
6500:                    SimpleNode jjtn021 = (SimpleNode) SimpleNode.jjtCreate(
6501:                            this , JJTNAME);
6502:                    boolean jjtc021 = true;
6503:                    jjtree.openNodeScope(jjtn021);
6504:                    jjtreeOpenNodeScope(jjtn021);
6505:                    try {
6506:                        t = jj_consume_token(CONTINUE);
6507:                        jjtn021.setImage(t.image);
6508:                        {
6509:                            if (true)
6510:                                return t;
6511:                        }
6512:                        jjtree.closeNodeScope(jjtn021, true);
6513:                        jjtc021 = false;
6514:                        jjtreeCloseNodeScope(jjtn021);
6515:
6516:                    } finally {
6517:                        if (jjtc021) {
6518:                            jjtree.closeNodeScope(jjtn021, true);
6519:                            jjtreeCloseNodeScope(jjtn021);
6520:                        }
6521:                    }
6522:                    break;
6523:                case RETURN:
6524:                    SimpleNode jjtn022 = (SimpleNode) SimpleNode.jjtCreate(
6525:                            this , JJTNAME);
6526:                    boolean jjtc022 = true;
6527:                    jjtree.openNodeScope(jjtn022);
6528:                    jjtreeOpenNodeScope(jjtn022);
6529:                    try {
6530:                        t = jj_consume_token(RETURN);
6531:                        jjtn022.setImage(t.image);
6532:                        {
6533:                            if (true)
6534:                                return t;
6535:                        }
6536:                        jjtree.closeNodeScope(jjtn022, true);
6537:                        jjtc022 = false;
6538:                        jjtreeCloseNodeScope(jjtn022);
6539:
6540:                    } finally {
6541:                        if (jjtc022) {
6542:                            jjtree.closeNodeScope(jjtn022, true);
6543:                            jjtreeCloseNodeScope(jjtn022);
6544:                        }
6545:                    }
6546:                    break;
6547:                case YIELD:
6548:                    SimpleNode jjtn023 = (SimpleNode) SimpleNode.jjtCreate(
6549:                            this , JJTNAME);
6550:                    boolean jjtc023 = true;
6551:                    jjtree.openNodeScope(jjtn023);
6552:                    jjtreeOpenNodeScope(jjtn023);
6553:                    try {
6554:                        t = jj_consume_token(YIELD);
6555:                        jjtn023.setImage(t.image);
6556:                        {
6557:                            if (true)
6558:                                return t;
6559:                        }
6560:                        jjtree.closeNodeScope(jjtn023, true);
6561:                        jjtc023 = false;
6562:                        jjtreeCloseNodeScope(jjtn023);
6563:
6564:                    } finally {
6565:                        if (jjtc023) {
6566:                            jjtree.closeNodeScope(jjtn023, true);
6567:                            jjtreeCloseNodeScope(jjtn023);
6568:                        }
6569:                    }
6570:                    break;
6571:                case IMPORT:
6572:                    SimpleNode jjtn024 = (SimpleNode) SimpleNode.jjtCreate(
6573:                            this , JJTNAME);
6574:                    boolean jjtc024 = true;
6575:                    jjtree.openNodeScope(jjtn024);
6576:                    jjtreeOpenNodeScope(jjtn024);
6577:                    try {
6578:                        t = jj_consume_token(IMPORT);
6579:                        jjtn024.setImage(t.image);
6580:                        {
6581:                            if (true)
6582:                                return t;
6583:                        }
6584:                        jjtree.closeNodeScope(jjtn024, true);
6585:                        jjtc024 = false;
6586:                        jjtreeCloseNodeScope(jjtn024);
6587:
6588:                    } finally {
6589:                        if (jjtc024) {
6590:                            jjtree.closeNodeScope(jjtn024, true);
6591:                            jjtreeCloseNodeScope(jjtn024);
6592:                        }
6593:                    }
6594:                    break;
6595:                case FROM:
6596:                    SimpleNode jjtn025 = (SimpleNode) SimpleNode.jjtCreate(
6597:                            this , JJTNAME);
6598:                    boolean jjtc025 = true;
6599:                    jjtree.openNodeScope(jjtn025);
6600:                    jjtreeOpenNodeScope(jjtn025);
6601:                    try {
6602:                        t = jj_consume_token(FROM);
6603:                        jjtn025.setImage(t.image);
6604:                        {
6605:                            if (true)
6606:                                return t;
6607:                        }
6608:                        jjtree.closeNodeScope(jjtn025, true);
6609:                        jjtc025 = false;
6610:                        jjtreeCloseNodeScope(jjtn025);
6611:
6612:                    } finally {
6613:                        if (jjtc025) {
6614:                            jjtree.closeNodeScope(jjtn025, true);
6615:                            jjtreeCloseNodeScope(jjtn025);
6616:                        }
6617:                    }
6618:                    break;
6619:                case DEL:
6620:                    SimpleNode jjtn026 = (SimpleNode) SimpleNode.jjtCreate(
6621:                            this , JJTNAME);
6622:                    boolean jjtc026 = true;
6623:                    jjtree.openNodeScope(jjtn026);
6624:                    jjtreeOpenNodeScope(jjtn026);
6625:                    try {
6626:                        t = jj_consume_token(DEL);
6627:                        jjtn026.setImage(t.image);
6628:                        {
6629:                            if (true)
6630:                                return t;
6631:                        }
6632:                        jjtree.closeNodeScope(jjtn026, true);
6633:                        jjtc026 = false;
6634:                        jjtreeCloseNodeScope(jjtn026);
6635:
6636:                    } finally {
6637:                        if (jjtc026) {
6638:                            jjtree.closeNodeScope(jjtn026, true);
6639:                            jjtreeCloseNodeScope(jjtn026);
6640:                        }
6641:                    }
6642:                    break;
6643:                case RAISE:
6644:                    SimpleNode jjtn027 = (SimpleNode) SimpleNode.jjtCreate(
6645:                            this , JJTNAME);
6646:                    boolean jjtc027 = true;
6647:                    jjtree.openNodeScope(jjtn027);
6648:                    jjtreeOpenNodeScope(jjtn027);
6649:                    try {
6650:                        t = jj_consume_token(RAISE);
6651:                        jjtn027.setImage(t.image);
6652:                        {
6653:                            if (true)
6654:                                return t;
6655:                        }
6656:                        jjtree.closeNodeScope(jjtn027, true);
6657:                        jjtc027 = false;
6658:                        jjtreeCloseNodeScope(jjtn027);
6659:
6660:                    } finally {
6661:                        if (jjtc027) {
6662:                            jjtree.closeNodeScope(jjtn027, true);
6663:                            jjtreeCloseNodeScope(jjtn027);
6664:                        }
6665:                    }
6666:                    break;
6667:                case GLOBAL:
6668:                    SimpleNode jjtn028 = (SimpleNode) SimpleNode.jjtCreate(
6669:                            this , JJTNAME);
6670:                    boolean jjtc028 = true;
6671:                    jjtree.openNodeScope(jjtn028);
6672:                    jjtreeOpenNodeScope(jjtn028);
6673:                    try {
6674:                        t = jj_consume_token(GLOBAL);
6675:                        jjtn028.setImage(t.image);
6676:                        {
6677:                            if (true)
6678:                                return t;
6679:                        }
6680:                        jjtree.closeNodeScope(jjtn028, true);
6681:                        jjtc028 = false;
6682:                        jjtreeCloseNodeScope(jjtn028);
6683:
6684:                    } finally {
6685:                        if (jjtc028) {
6686:                            jjtree.closeNodeScope(jjtn028, true);
6687:                            jjtreeCloseNodeScope(jjtn028);
6688:                        }
6689:                    }
6690:                    break;
6691:                case EXEC:
6692:                    SimpleNode jjtn029 = (SimpleNode) SimpleNode.jjtCreate(
6693:                            this , JJTNAME);
6694:                    boolean jjtc029 = true;
6695:                    jjtree.openNodeScope(jjtn029);
6696:                    jjtreeOpenNodeScope(jjtn029);
6697:                    try {
6698:                        t = jj_consume_token(EXEC);
6699:                        jjtn029.setImage(t.image);
6700:                        {
6701:                            if (true)
6702:                                return t;
6703:                        }
6704:                        jjtree.closeNodeScope(jjtn029, true);
6705:                        jjtc029 = false;
6706:                        jjtreeCloseNodeScope(jjtn029);
6707:
6708:                    } finally {
6709:                        if (jjtc029) {
6710:                            jjtree.closeNodeScope(jjtn029, true);
6711:                            jjtreeCloseNodeScope(jjtn029);
6712:                        }
6713:                    }
6714:                    break;
6715:                case ASSERT:
6716:                    SimpleNode jjtn030 = (SimpleNode) SimpleNode.jjtCreate(
6717:                            this , JJTNAME);
6718:                    boolean jjtc030 = true;
6719:                    jjtree.openNodeScope(jjtn030);
6720:                    jjtreeOpenNodeScope(jjtn030);
6721:                    try {
6722:                        t = jj_consume_token(ASSERT);
6723:                        jjtn030.setImage(t.image);
6724:                        {
6725:                            if (true)
6726:                                return t;
6727:                        }
6728:                        jjtree.closeNodeScope(jjtn030, true);
6729:                        jjtc030 = false;
6730:                        jjtreeCloseNodeScope(jjtn030);
6731:
6732:                    } finally {
6733:                        if (jjtc030) {
6734:                            jjtree.closeNodeScope(jjtn030, true);
6735:                            jjtreeCloseNodeScope(jjtn030);
6736:                        }
6737:                    }
6738:                    break;
6739:                case AS:
6740:                    SimpleNode jjtn031 = (SimpleNode) SimpleNode.jjtCreate(
6741:                            this , JJTNAME);
6742:                    boolean jjtc031 = true;
6743:                    jjtree.openNodeScope(jjtn031);
6744:                    jjtreeOpenNodeScope(jjtn031);
6745:                    try {
6746:                        t = jj_consume_token(AS);
6747:                        jjtn031.setImage(t.image);
6748:                        {
6749:                            if (true)
6750:                                return t;
6751:                        }
6752:                        jjtree.closeNodeScope(jjtn031, true);
6753:                        jjtc031 = false;
6754:                        jjtreeCloseNodeScope(jjtn031);
6755:
6756:                    } finally {
6757:                        if (jjtc031) {
6758:                            jjtree.closeNodeScope(jjtn031, true);
6759:                            jjtreeCloseNodeScope(jjtn031);
6760:                        }
6761:                    }
6762:                    break;
6763:                default:
6764:                    jj_la1[105] = jj_gen;
6765:                    jj_consume_token(-1);
6766:                    throw new ParseException();
6767:                }
6768:                throw new Error("Missing return statement in function");
6769:            }
6770:
6771:            final private boolean jj_2_1(int xla) {
6772:                jj_la = xla;
6773:                jj_lastpos = jj_scanpos = token;
6774:                try {
6775:                    return !jj_3_1();
6776:                } catch (LookaheadSuccess ls) {
6777:                    return true;
6778:                } finally {
6779:                    jj_save(0, xla);
6780:                }
6781:            }
6782:
6783:            final private boolean jj_2_2(int xla) {
6784:                jj_la = xla;
6785:                jj_lastpos = jj_scanpos = token;
6786:                try {
6787:                    return !jj_3_2();
6788:                } catch (LookaheadSuccess ls) {
6789:                    return true;
6790:                } finally {
6791:                    jj_save(1, xla);
6792:                }
6793:            }
6794:
6795:            final private boolean jj_2_3(int xla) {
6796:                jj_la = xla;
6797:                jj_lastpos = jj_scanpos = token;
6798:                try {
6799:                    return !jj_3_3();
6800:                } catch (LookaheadSuccess ls) {
6801:                    return true;
6802:                } finally {
6803:                    jj_save(2, xla);
6804:                }
6805:            }
6806:
6807:            final private boolean jj_2_4(int xla) {
6808:                jj_la = xla;
6809:                jj_lastpos = jj_scanpos = token;
6810:                try {
6811:                    return !jj_3_4();
6812:                } catch (LookaheadSuccess ls) {
6813:                    return true;
6814:                } finally {
6815:                    jj_save(3, xla);
6816:                }
6817:            }
6818:
6819:            final private boolean jj_2_5(int xla) {
6820:                jj_la = xla;
6821:                jj_lastpos = jj_scanpos = token;
6822:                try {
6823:                    return !jj_3_5();
6824:                } catch (LookaheadSuccess ls) {
6825:                    return true;
6826:                } finally {
6827:                    jj_save(4, xla);
6828:                }
6829:            }
6830:
6831:            final private boolean jj_2_6(int xla) {
6832:                jj_la = xla;
6833:                jj_lastpos = jj_scanpos = token;
6834:                try {
6835:                    return !jj_3_6();
6836:                } catch (LookaheadSuccess ls) {
6837:                    return true;
6838:                } finally {
6839:                    jj_save(5, xla);
6840:                }
6841:            }
6842:
6843:            final private boolean jj_2_7(int xla) {
6844:                jj_la = xla;
6845:                jj_lastpos = jj_scanpos = token;
6846:                try {
6847:                    return !jj_3_7();
6848:                } catch (LookaheadSuccess ls) {
6849:                    return true;
6850:                } finally {
6851:                    jj_save(6, xla);
6852:                }
6853:            }
6854:
6855:            final private boolean jj_2_8(int xla) {
6856:                jj_la = xla;
6857:                jj_lastpos = jj_scanpos = token;
6858:                try {
6859:                    return !jj_3_8();
6860:                } catch (LookaheadSuccess ls) {
6861:                    return true;
6862:                } finally {
6863:                    jj_save(7, xla);
6864:                }
6865:            }
6866:
6867:            final private boolean jj_2_9(int xla) {
6868:                jj_la = xla;
6869:                jj_lastpos = jj_scanpos = token;
6870:                try {
6871:                    return !jj_3_9();
6872:                } catch (LookaheadSuccess ls) {
6873:                    return true;
6874:                } finally {
6875:                    jj_save(8, xla);
6876:                }
6877:            }
6878:
6879:            final private boolean jj_2_10(int xla) {
6880:                jj_la = xla;
6881:                jj_lastpos = jj_scanpos = token;
6882:                try {
6883:                    return !jj_3_10();
6884:                } catch (LookaheadSuccess ls) {
6885:                    return true;
6886:                } finally {
6887:                    jj_save(9, xla);
6888:                }
6889:            }
6890:
6891:            final private boolean jj_2_11(int xla) {
6892:                jj_la = xla;
6893:                jj_lastpos = jj_scanpos = token;
6894:                try {
6895:                    return !jj_3_11();
6896:                } catch (LookaheadSuccess ls) {
6897:                    return true;
6898:                } finally {
6899:                    jj_save(10, xla);
6900:                }
6901:            }
6902:
6903:            final private boolean jj_2_12(int xla) {
6904:                jj_la = xla;
6905:                jj_lastpos = jj_scanpos = token;
6906:                try {
6907:                    return !jj_3_12();
6908:                } catch (LookaheadSuccess ls) {
6909:                    return true;
6910:                } finally {
6911:                    jj_save(11, xla);
6912:                }
6913:            }
6914:
6915:            final private boolean jj_2_13(int xla) {
6916:                jj_la = xla;
6917:                jj_lastpos = jj_scanpos = token;
6918:                try {
6919:                    return !jj_3_13();
6920:                } catch (LookaheadSuccess ls) {
6921:                    return true;
6922:                } finally {
6923:                    jj_save(12, xla);
6924:                }
6925:            }
6926:
6927:            final private boolean jj_2_14(int xla) {
6928:                jj_la = xla;
6929:                jj_lastpos = jj_scanpos = token;
6930:                try {
6931:                    return !jj_3_14();
6932:                } catch (LookaheadSuccess ls) {
6933:                    return true;
6934:                } finally {
6935:                    jj_save(13, xla);
6936:                }
6937:            }
6938:
6939:            final private boolean jj_2_15(int xla) {
6940:                jj_la = xla;
6941:                jj_lastpos = jj_scanpos = token;
6942:                try {
6943:                    return !jj_3_15();
6944:                } catch (LookaheadSuccess ls) {
6945:                    return true;
6946:                } finally {
6947:                    jj_save(14, xla);
6948:                }
6949:            }
6950:
6951:            final private boolean jj_2_16(int xla) {
6952:                jj_la = xla;
6953:                jj_lastpos = jj_scanpos = token;
6954:                try {
6955:                    return !jj_3_16();
6956:                } catch (LookaheadSuccess ls) {
6957:                    return true;
6958:                } finally {
6959:                    jj_save(15, xla);
6960:                }
6961:            }
6962:
6963:            final private boolean jj_2_17(int xla) {
6964:                jj_la = xla;
6965:                jj_lastpos = jj_scanpos = token;
6966:                try {
6967:                    return !jj_3_17();
6968:                } catch (LookaheadSuccess ls) {
6969:                    return true;
6970:                } finally {
6971:                    jj_save(16, xla);
6972:                }
6973:            }
6974:
6975:            final private boolean jj_2_18(int xla) {
6976:                jj_la = xla;
6977:                jj_lastpos = jj_scanpos = token;
6978:                try {
6979:                    return !jj_3_18();
6980:                } catch (LookaheadSuccess ls) {
6981:                    return true;
6982:                } finally {
6983:                    jj_save(17, xla);
6984:                }
6985:            }
6986:
6987:            final private boolean jj_2_19(int xla) {
6988:                jj_la = xla;
6989:                jj_lastpos = jj_scanpos = token;
6990:                try {
6991:                    return !jj_3_19();
6992:                } catch (LookaheadSuccess ls) {
6993:                    return true;
6994:                } finally {
6995:                    jj_save(18, xla);
6996:                }
6997:            }
6998:
6999:            final private boolean jj_2_20(int xla) {
7000:                jj_la = xla;
7001:                jj_lastpos = jj_scanpos = token;
7002:                try {
7003:                    return !jj_3_20();
7004:                } catch (LookaheadSuccess ls) {
7005:                    return true;
7006:                } finally {
7007:                    jj_save(19, xla);
7008:                }
7009:            }
7010:
7011:            final private boolean jj_2_21(int xla) {
7012:                jj_la = xla;
7013:                jj_lastpos = jj_scanpos = token;
7014:                try {
7015:                    return !jj_3_21();
7016:                } catch (LookaheadSuccess ls) {
7017:                    return true;
7018:                } finally {
7019:                    jj_save(20, xla);
7020:                }
7021:            }
7022:
7023:            final private boolean jj_2_22(int xla) {
7024:                jj_la = xla;
7025:                jj_lastpos = jj_scanpos = token;
7026:                try {
7027:                    return !jj_3_22();
7028:                } catch (LookaheadSuccess ls) {
7029:                    return true;
7030:                } finally {
7031:                    jj_save(21, xla);
7032:                }
7033:            }
7034:
7035:            final private boolean jj_2_23(int xla) {
7036:                jj_la = xla;
7037:                jj_lastpos = jj_scanpos = token;
7038:                try {
7039:                    return !jj_3_23();
7040:                } catch (LookaheadSuccess ls) {
7041:                    return true;
7042:                } finally {
7043:                    jj_save(22, xla);
7044:                }
7045:            }
7046:
7047:            final private boolean jj_2_24(int xla) {
7048:                jj_la = xla;
7049:                jj_lastpos = jj_scanpos = token;
7050:                try {
7051:                    return !jj_3_24();
7052:                } catch (LookaheadSuccess ls) {
7053:                    return true;
7054:                } finally {
7055:                    jj_save(23, xla);
7056:                }
7057:            }
7058:
7059:            final private boolean jj_2_25(int xla) {
7060:                jj_la = xla;
7061:                jj_lastpos = jj_scanpos = token;
7062:                try {
7063:                    return !jj_3_25();
7064:                } catch (LookaheadSuccess ls) {
7065:                    return true;
7066:                } finally {
7067:                    jj_save(24, xla);
7068:                }
7069:            }
7070:
7071:            final private boolean jj_3R_130() {
7072:                if (jj_scan_token(FROM))
7073:                    return true;
7074:                return false;
7075:            }
7076:
7077:            final private boolean jj_3R_113() {
7078:                Token xsp;
7079:                xsp = jj_scanpos;
7080:                if (jj_3R_129()) {
7081:                    jj_scanpos = xsp;
7082:                    if (jj_3R_130())
7083:                        return true;
7084:                }
7085:                return false;
7086:            }
7087:
7088:            final private boolean jj_3R_129() {
7089:                if (jj_scan_token(IMPORT))
7090:                    return true;
7091:                return false;
7092:            }
7093:
7094:            final private boolean jj_3R_137() {
7095:                if (jj_scan_token(RAISE))
7096:                    return true;
7097:                return false;
7098:            }
7099:
7100:            final private boolean jj_3_9() {
7101:                if (jj_scan_token(COMMA))
7102:                    return true;
7103:                if (jj_3R_45())
7104:                    return true;
7105:                return false;
7106:            }
7107:
7108:            final private boolean jj_3R_136() {
7109:                if (jj_scan_token(YIELD))
7110:                    return true;
7111:                return false;
7112:            }
7113:
7114:            final private boolean jj_3R_135() {
7115:                if (jj_scan_token(RETURN))
7116:                    return true;
7117:                return false;
7118:            }
7119:
7120:            final private boolean jj_3R_128() {
7121:                if (jj_3R_137())
7122:                    return true;
7123:                return false;
7124:            }
7125:
7126:            final private boolean jj_3R_127() {
7127:                if (jj_3R_136())
7128:                    return true;
7129:                return false;
7130:            }
7131:
7132:            final private boolean jj_3R_125() {
7133:                if (jj_scan_token(CONTINUE))
7134:                    return true;
7135:                return false;
7136:            }
7137:
7138:            final private boolean jj_3R_126() {
7139:                if (jj_3R_135())
7140:                    return true;
7141:                return false;
7142:            }
7143:
7144:            final private boolean jj_3R_112() {
7145:                Token xsp;
7146:                xsp = jj_scanpos;
7147:                if (jj_3R_124()) {
7148:                    jj_scanpos = xsp;
7149:                    if (jj_3R_125()) {
7150:                        jj_scanpos = xsp;
7151:                        if (jj_3R_126()) {
7152:                            jj_scanpos = xsp;
7153:                            if (jj_3R_127()) {
7154:                                jj_scanpos = xsp;
7155:                                if (jj_3R_128())
7156:                                    return true;
7157:                            }
7158:                        }
7159:                    }
7160:                }
7161:                return false;
7162:            }
7163:
7164:            final private boolean jj_3R_124() {
7165:                if (jj_scan_token(BREAK))
7166:                    return true;
7167:                return false;
7168:            }
7169:
7170:            final private boolean jj_3R_105() {
7171:                if (jj_scan_token(AS))
7172:                    return true;
7173:                return false;
7174:            }
7175:
7176:            final private boolean jj_3R_104() {
7177:                if (jj_scan_token(ASSERT))
7178:                    return true;
7179:                return false;
7180:            }
7181:
7182:            final private boolean jj_3R_103() {
7183:                if (jj_scan_token(EXEC))
7184:                    return true;
7185:                return false;
7186:            }
7187:
7188:            final private boolean jj_3R_102() {
7189:                if (jj_scan_token(GLOBAL))
7190:                    return true;
7191:                return false;
7192:            }
7193:
7194:            final private boolean jj_3R_111() {
7195:                if (jj_scan_token(PASS))
7196:                    return true;
7197:                return false;
7198:            }
7199:
7200:            final private boolean jj_3R_101() {
7201:                if (jj_scan_token(RAISE))
7202:                    return true;
7203:                return false;
7204:            }
7205:
7206:            final private boolean jj_3R_100() {
7207:                if (jj_scan_token(DEL))
7208:                    return true;
7209:                return false;
7210:            }
7211:
7212:            final private boolean jj_3R_99() {
7213:                if (jj_scan_token(FROM))
7214:                    return true;
7215:                return false;
7216:            }
7217:
7218:            final private boolean jj_3R_98() {
7219:                if (jj_scan_token(IMPORT))
7220:                    return true;
7221:                return false;
7222:            }
7223:
7224:            final private boolean jj_3R_110() {
7225:                if (jj_scan_token(DEL))
7226:                    return true;
7227:                return false;
7228:            }
7229:
7230:            final private boolean jj_3R_97() {
7231:                if (jj_scan_token(YIELD))
7232:                    return true;
7233:                return false;
7234:            }
7235:
7236:            final private boolean jj_3R_96() {
7237:                if (jj_scan_token(RETURN))
7238:                    return true;
7239:                return false;
7240:            }
7241:
7242:            final private boolean jj_3_8() {
7243:                if (jj_scan_token(COMMA))
7244:                    return true;
7245:                if (jj_3R_45())
7246:                    return true;
7247:                return false;
7248:            }
7249:
7250:            final private boolean jj_3R_95() {
7251:                if (jj_scan_token(CONTINUE))
7252:                    return true;
7253:                return false;
7254:            }
7255:
7256:            final private boolean jj_3R_94() {
7257:                if (jj_scan_token(BREAK))
7258:                    return true;
7259:                return false;
7260:            }
7261:
7262:            final private boolean jj_3R_123() {
7263:                if (jj_scan_token(PRINT))
7264:                    return true;
7265:                return false;
7266:            }
7267:
7268:            final private boolean jj_3R_93() {
7269:                if (jj_scan_token(PASS))
7270:                    return true;
7271:                return false;
7272:            }
7273:
7274:            final private boolean jj_3R_92() {
7275:                if (jj_scan_token(PRINT))
7276:                    return true;
7277:                return false;
7278:            }
7279:
7280:            final private boolean jj_3R_91() {
7281:                if (jj_scan_token(FINALLY))
7282:                    return true;
7283:                return false;
7284:            }
7285:
7286:            final private boolean jj_3_11() {
7287:                if (jj_scan_token(PRINT))
7288:                    return true;
7289:                if (jj_3R_45())
7290:                    return true;
7291:                return false;
7292:            }
7293:
7294:            final private boolean jj_3R_90() {
7295:                if (jj_scan_token(CLASS))
7296:                    return true;
7297:                return false;
7298:            }
7299:
7300:            final private boolean jj_3R_89() {
7301:                if (jj_scan_token(DEF))
7302:                    return true;
7303:                return false;
7304:            }
7305:
7306:            final private boolean jj_3R_88() {
7307:                if (jj_scan_token(EXCEPT))
7308:                    return true;
7309:                return false;
7310:            }
7311:
7312:            final private boolean jj_3_10() {
7313:                if (jj_scan_token(PRINT))
7314:                    return true;
7315:                if (jj_scan_token(RSHIFT))
7316:                    return true;
7317:                return false;
7318:            }
7319:
7320:            final private boolean jj_3R_109() {
7321:                Token xsp;
7322:                xsp = jj_scanpos;
7323:                if (jj_3_10()) {
7324:                    jj_scanpos = xsp;
7325:                    if (jj_3_11()) {
7326:                        jj_scanpos = xsp;
7327:                        if (jj_3R_123())
7328:                            return true;
7329:                    }
7330:                }
7331:                return false;
7332:            }
7333:
7334:            final private boolean jj_3R_87() {
7335:                if (jj_scan_token(TRY))
7336:                    return true;
7337:                return false;
7338:            }
7339:
7340:            final private boolean jj_3R_86() {
7341:                if (jj_scan_token(FOR))
7342:                    return true;
7343:                return false;
7344:            }
7345:
7346:            final private boolean jj_3R_85() {
7347:                if (jj_scan_token(WHILE))
7348:                    return true;
7349:                return false;
7350:            }
7351:
7352:            final private boolean jj_3R_84() {
7353:                if (jj_scan_token(ELIF))
7354:                    return true;
7355:                return false;
7356:            }
7357:
7358:            final private boolean jj_3R_83() {
7359:                if (jj_scan_token(ELSE))
7360:                    return true;
7361:                return false;
7362:            }
7363:
7364:            final private boolean jj_3R_82() {
7365:                if (jj_scan_token(IF))
7366:                    return true;
7367:                return false;
7368:            }
7369:
7370:            final private boolean jj_3R_81() {
7371:                if (jj_scan_token(LAMBDA))
7372:                    return true;
7373:                return false;
7374:            }
7375:
7376:            final private boolean jj_3R_80() {
7377:                if (jj_scan_token(IN))
7378:                    return true;
7379:                return false;
7380:            }
7381:
7382:            final private boolean jj_3R_79() {
7383:                if (jj_scan_token(IS))
7384:                    return true;
7385:                return false;
7386:            }
7387:
7388:            final private boolean jj_3R_78() {
7389:                if (jj_scan_token(NOT_BOOL))
7390:                    return true;
7391:                return false;
7392:            }
7393:
7394:            final private boolean jj_3R_77() {
7395:                if (jj_scan_token(AND_BOOL))
7396:                    return true;
7397:                return false;
7398:            }
7399:
7400:            final private boolean jj_3R_76() {
7401:                if (jj_scan_token(OR_BOOL))
7402:                    return true;
7403:                return false;
7404:            }
7405:
7406:            final private boolean jj_3R_75() {
7407:                if (jj_scan_token(NAME))
7408:                    return true;
7409:                return false;
7410:            }
7411:
7412:            final private boolean jj_3R_51() {
7413:                Token xsp;
7414:                xsp = jj_scanpos;
7415:                if (jj_3R_75()) {
7416:                    jj_scanpos = xsp;
7417:                    if (jj_3R_76()) {
7418:                        jj_scanpos = xsp;
7419:                        if (jj_3R_77()) {
7420:                            jj_scanpos = xsp;
7421:                            if (jj_3R_78()) {
7422:                                jj_scanpos = xsp;
7423:                                if (jj_3R_79()) {
7424:                                    jj_scanpos = xsp;
7425:                                    if (jj_3R_80()) {
7426:                                        jj_scanpos = xsp;
7427:                                        if (jj_3R_81()) {
7428:                                            jj_scanpos = xsp;
7429:                                            if (jj_3R_82()) {
7430:                                                jj_scanpos = xsp;
7431:                                                if (jj_3R_83()) {
7432:                                                    jj_scanpos = xsp;
7433:                                                    if (jj_3R_84()) {
7434:                                                        jj_scanpos = xsp;
7435:                                                        if (jj_3R_85()) {
7436:                                                            jj_scanpos = xsp;
7437:                                                            if (jj_3R_86()) {
7438:                                                                jj_scanpos = xsp;
7439:                                                                if (jj_3R_87()) {
7440:                                                                    jj_scanpos = xsp;
7441:                                                                    if (jj_3R_88()) {
7442:                                                                        jj_scanpos = xsp;
7443:                                                                        if (jj_3R_89()) {
7444:                                                                            jj_scanpos = xsp;
7445:                                                                            if (jj_3R_90()) {
7446:                                                                                jj_scanpos = xsp;
7447:                                                                                if (jj_3R_91()) {
7448:                                                                                    jj_scanpos = xsp;
7449:                                                                                    if (jj_3R_92()) {
7450:                                                                                        jj_scanpos = xsp;
7451:                                                                                        if (jj_3R_93()) {
7452:                                                                                            jj_scanpos = xsp;
7453:                                                                                            if (jj_3R_94()) {
7454:                                                                                                jj_scanpos = xsp;
7455:                                                                                                if (jj_3R_95()) {
7456:                                                                                                    jj_scanpos = xsp;
7457:                                                                                                    if (jj_3R_96()) {
7458:                                                                                                        jj_scanpos = xsp;
7459:                                                                                                        if (jj_3R_97()) {
7460:                                                                                                            jj_scanpos = xsp;
7461:                                                                                                            if (jj_3R_98()) {
7462:                                                                                                                jj_scanpos = xsp;
7463:                                                                                                                if (jj_3R_99()) {
7464:                                                                                                                    jj_scanpos = xsp;
7465:                                                                                                                    if (jj_3R_100()) {
7466:                                                                                                                        jj_scanpos = xsp;
7467:                                                                                                                        if (jj_3R_101()) {
7468:                                                                                                                            jj_scanpos = xsp;
7469:                                                                                                                            if (jj_3R_102()) {
7470:                                                                                                                                jj_scanpos = xsp;
7471:                                                                                                                                if (jj_3R_103()) {
7472:                                                                                                                                    jj_scanpos = xsp;
7473:                                                                                                                                    if (jj_3R_104()) {
7474:                                                                                                                                        jj_scanpos = xsp;
7475:                                                                                                                                        if (jj_3R_105())
7476:                                                                                                                                            return true;
7477:                                                                                                                                    }
7478:                                                                                                                                }
7479:                                                                                                                            }
7480:                                                                                                                        }
7481:                                                                                                                    }
7482:                                                                                                                }
7483:                                                                                                            }
7484:                                                                                                        }
7485:                                                                                                    }
7486:                                                                                                }
7487:                                                                                            }
7488:                                                                                        }
7489:                                                                                    }
7490:                                                                                }
7491:                                                                            }
7492:                                                                        }
7493:                                                                    }
7494:                                                                }
7495:                                                            }
7496:                                                        }
7497:                                                    }
7498:                                                }
7499:                                            }
7500:                                        }
7501:                                    }
7502:                                }
7503:                            }
7504:                        }
7505:                    }
7506:                }
7507:                return false;
7508:            }
7509:
7510:            final private boolean jj_3R_165() {
7511:                if (jj_scan_token(TRIPLE_USTRING2))
7512:                    return true;
7513:                return false;
7514:            }
7515:
7516:            final private boolean jj_3R_108() {
7517:                if (jj_3R_122())
7518:                    return true;
7519:                return false;
7520:            }
7521:
7522:            final private boolean jj_3R_164() {
7523:                if (jj_scan_token(TRIPLE_USTRING))
7524:                    return true;
7525:                return false;
7526:            }
7527:
7528:            final private boolean jj_3R_163() {
7529:                if (jj_scan_token(SINGLE_USTRING2))
7530:                    return true;
7531:                return false;
7532:            }
7533:
7534:            final private boolean jj_3R_162() {
7535:                if (jj_scan_token(SINGLE_USTRING))
7536:                    return true;
7537:                return false;
7538:            }
7539:
7540:            final private boolean jj_3R_161() {
7541:                if (jj_scan_token(TRIPLE_STRING2))
7542:                    return true;
7543:                return false;
7544:            }
7545:
7546:            final private boolean jj_3R_160() {
7547:                if (jj_scan_token(TRIPLE_STRING))
7548:                    return true;
7549:                return false;
7550:            }
7551:
7552:            final private boolean jj_3R_159() {
7553:                if (jj_scan_token(SINGLE_STRING2))
7554:                    return true;
7555:                return false;
7556:            }
7557:
7558:            final private boolean jj_3R_64() {
7559:                if (jj_3R_116())
7560:                    return true;
7561:                return false;
7562:            }
7563:
7564:            final private boolean jj_3R_63() {
7565:                if (jj_3R_115())
7566:                    return true;
7567:                return false;
7568:            }
7569:
7570:            final private boolean jj_3R_158() {
7571:                if (jj_scan_token(SINGLE_STRING))
7572:                    return true;
7573:                return false;
7574:            }
7575:
7576:            final private boolean jj_3R_62() {
7577:                if (jj_3R_114())
7578:                    return true;
7579:                return false;
7580:            }
7581:
7582:            final private boolean jj_3_7() {
7583:                if (jj_scan_token(SEMICOLON))
7584:                    return true;
7585:                if (jj_3R_44())
7586:                    return true;
7587:                return false;
7588:            }
7589:
7590:            final private boolean jj_3R_152() {
7591:                Token xsp;
7592:                xsp = jj_scanpos;
7593:                if (jj_3R_158()) {
7594:                    jj_scanpos = xsp;
7595:                    if (jj_3R_159()) {
7596:                        jj_scanpos = xsp;
7597:                        if (jj_3R_160()) {
7598:                            jj_scanpos = xsp;
7599:                            if (jj_3R_161()) {
7600:                                jj_scanpos = xsp;
7601:                                if (jj_3R_162()) {
7602:                                    jj_scanpos = xsp;
7603:                                    if (jj_3R_163()) {
7604:                                        jj_scanpos = xsp;
7605:                                        if (jj_3R_164()) {
7606:                                            jj_scanpos = xsp;
7607:                                            if (jj_3R_165())
7608:                                                return true;
7609:                                        }
7610:                                    }
7611:                                }
7612:                            }
7613:                        }
7614:                    }
7615:                }
7616:                return false;
7617:            }
7618:
7619:            final private boolean jj_3R_61() {
7620:                if (jj_3R_113())
7621:                    return true;
7622:                return false;
7623:            }
7624:
7625:            final private boolean jj_3R_60() {
7626:                if (jj_3R_112())
7627:                    return true;
7628:                return false;
7629:            }
7630:
7631:            final private boolean jj_3R_59() {
7632:                if (jj_3R_111())
7633:                    return true;
7634:                return false;
7635:            }
7636:
7637:            final private boolean jj_3R_58() {
7638:                if (jj_3R_110())
7639:                    return true;
7640:                return false;
7641:            }
7642:
7643:            final private boolean jj_3R_57() {
7644:                if (jj_3R_109())
7645:                    return true;
7646:                return false;
7647:            }
7648:
7649:            final private boolean jj_3R_56() {
7650:                if (jj_3R_108())
7651:                    return true;
7652:                return false;
7653:            }
7654:
7655:            final private boolean jj_3R_44() {
7656:                Token xsp;
7657:                xsp = jj_scanpos;
7658:                if (jj_3R_56()) {
7659:                    jj_scanpos = xsp;
7660:                    if (jj_3R_57()) {
7661:                        jj_scanpos = xsp;
7662:                        if (jj_3R_58()) {
7663:                            jj_scanpos = xsp;
7664:                            if (jj_3R_59()) {
7665:                                jj_scanpos = xsp;
7666:                                if (jj_3R_60()) {
7667:                                    jj_scanpos = xsp;
7668:                                    if (jj_3R_61()) {
7669:                                        jj_scanpos = xsp;
7670:                                        if (jj_3R_62()) {
7671:                                            jj_scanpos = xsp;
7672:                                            if (jj_3R_63()) {
7673:                                                jj_scanpos = xsp;
7674:                                                if (jj_3R_64())
7675:                                                    return true;
7676:                                            }
7677:                                        }
7678:                                    }
7679:                                }
7680:                            }
7681:                        }
7682:                    }
7683:                }
7684:                return false;
7685:            }
7686:
7687:            final private boolean jj_3R_107() {
7688:                if (jj_scan_token(AS))
7689:                    return true;
7690:                return false;
7691:            }
7692:
7693:            final private boolean jj_3R_52() {
7694:                Token xsp;
7695:                xsp = jj_scanpos;
7696:                if (jj_3R_106()) {
7697:                    jj_scanpos = xsp;
7698:                    if (jj_3R_107())
7699:                        return true;
7700:                }
7701:                return false;
7702:            }
7703:
7704:            final private boolean jj_3R_106() {
7705:                if (jj_scan_token(NAME))
7706:                    return true;
7707:                return false;
7708:            }
7709:
7710:            final private boolean jj_3_6() {
7711:                if (jj_scan_token(COMMA))
7712:                    return true;
7713:                if (jj_3R_43())
7714:                    return true;
7715:                return false;
7716:            }
7717:
7718:            final private boolean jj_3R_55() {
7719:                if (jj_scan_token(LPAREN))
7720:                    return true;
7721:                return false;
7722:            }
7723:
7724:            final private boolean jj_3R_157() {
7725:                if (jj_scan_token(COMPLEX))
7726:                    return true;
7727:                return false;
7728:            }
7729:
7730:            final private boolean jj_3R_53() {
7731:                if (jj_scan_token(MULTIPLY))
7732:                    return true;
7733:                return false;
7734:            }
7735:
7736:            final private boolean jj_3R_156() {
7737:                if (jj_scan_token(FLOAT))
7738:                    return true;
7739:                return false;
7740:            }
7741:
7742:            final private boolean jj_3R_54() {
7743:                if (jj_3R_52())
7744:                    return true;
7745:                return false;
7746:            }
7747:
7748:            final private boolean jj_3R_43() {
7749:                Token xsp;
7750:                xsp = jj_scanpos;
7751:                if (jj_3R_54()) {
7752:                    jj_scanpos = xsp;
7753:                    if (jj_3R_55())
7754:                        return true;
7755:                }
7756:                return false;
7757:            }
7758:
7759:            final private boolean jj_3R_155() {
7760:                if (jj_scan_token(DECNUMBER))
7761:                    return true;
7762:                return false;
7763:            }
7764:
7765:            final private boolean jj_3R_40() {
7766:                if (jj_3R_43())
7767:                    return true;
7768:                return false;
7769:            }
7770:
7771:            final private boolean jj_3_2() {
7772:                if (jj_scan_token(COMMA))
7773:                    return true;
7774:                if (jj_3R_40())
7775:                    return true;
7776:                return false;
7777:            }
7778:
7779:            final private boolean jj_3R_154() {
7780:                if (jj_scan_token(OCTNUMBER))
7781:                    return true;
7782:                return false;
7783:            }
7784:
7785:            final private boolean jj_3R_42() {
7786:                Token xsp;
7787:                xsp = jj_scanpos;
7788:                if (jj_scan_token(33)) {
7789:                    jj_scanpos = xsp;
7790:                    if (jj_3R_53())
7791:                        return true;
7792:                }
7793:                return false;
7794:            }
7795:
7796:            final private boolean jj_3R_41() {
7797:                if (jj_scan_token(MULTIPLY))
7798:                    return true;
7799:                if (jj_3R_52())
7800:                    return true;
7801:                return false;
7802:            }
7803:
7804:            final private boolean jj_3R_151() {
7805:                Token xsp;
7806:                xsp = jj_scanpos;
7807:                if (jj_3R_153()) {
7808:                    jj_scanpos = xsp;
7809:                    if (jj_3R_154()) {
7810:                        jj_scanpos = xsp;
7811:                        if (jj_3R_155()) {
7812:                            jj_scanpos = xsp;
7813:                            if (jj_3R_156()) {
7814:                                jj_scanpos = xsp;
7815:                                if (jj_3R_157())
7816:                                    return true;
7817:                            }
7818:                        }
7819:                    }
7820:                }
7821:                return false;
7822:            }
7823:
7824:            final private boolean jj_3R_153() {
7825:                if (jj_scan_token(HEXNUMBER))
7826:                    return true;
7827:                return false;
7828:            }
7829:
7830:            final private boolean jj_3_4() {
7831:                if (jj_scan_token(COMMA))
7832:                    return true;
7833:                if (jj_3R_42())
7834:                    return true;
7835:                return false;
7836:            }
7837:
7838:            final private boolean jj_3_3() {
7839:                if (jj_scan_token(COMMA))
7840:                    return true;
7841:                if (jj_3R_41())
7842:                    return true;
7843:                return false;
7844:            }
7845:
7846:            final private boolean jj_3_5() {
7847:                if (jj_3R_41())
7848:                    return true;
7849:                return false;
7850:            }
7851:
7852:            final private boolean jj_3_25() {
7853:                if (jj_3R_51())
7854:                    return true;
7855:                if (jj_scan_token(EQUAL))
7856:                    return true;
7857:                return false;
7858:            }
7859:
7860:            final private boolean jj_3R_50() {
7861:                Token xsp;
7862:                xsp = jj_scanpos;
7863:                if (jj_3_25())
7864:                    jj_scanpos = xsp;
7865:                if (jj_3R_45())
7866:                    return true;
7867:                return false;
7868:            }
7869:
7870:            final private boolean jj_3_24() {
7871:                if (jj_scan_token(COMMA))
7872:                    return true;
7873:                if (jj_3R_50())
7874:                    return true;
7875:                return false;
7876:            }
7877:
7878:            final private boolean jj_3R_49() {
7879:                if (jj_scan_token(MULTIPLY))
7880:                    return true;
7881:                if (jj_3R_45())
7882:                    return true;
7883:                return false;
7884:            }
7885:
7886:            final private boolean jj_3_23() {
7887:                if (jj_3R_49())
7888:                    return true;
7889:                return false;
7890:            }
7891:
7892:            final private boolean jj_3_22() {
7893:                if (jj_3R_49())
7894:                    return true;
7895:                return false;
7896:            }
7897:
7898:            final private boolean jj_3_21() {
7899:                if (jj_scan_token(COMMA))
7900:                    return true;
7901:                if (jj_3R_45())
7902:                    return true;
7903:                return false;
7904:            }
7905:
7906:            final private boolean jj_3_20() {
7907:                if (jj_scan_token(COMMA))
7908:                    return true;
7909:                if (jj_3R_45())
7910:                    return true;
7911:                return false;
7912:            }
7913:
7914:            final private boolean jj_3_1() {
7915:                if (jj_scan_token(NEWLINE))
7916:                    return true;
7917:                return false;
7918:            }
7919:
7920:            final private boolean jj_3_19() {
7921:                if (jj_scan_token(COMMA))
7922:                    return true;
7923:                if (jj_3R_45())
7924:                    return true;
7925:                return false;
7926:            }
7927:
7928:            final private boolean jj_3_18() {
7929:                if (jj_scan_token(COMMA))
7930:                    return true;
7931:                if (jj_3R_45())
7932:                    return true;
7933:                return false;
7934:            }
7935:
7936:            final private boolean jj_3R_133() {
7937:                if (jj_scan_token(COLON))
7938:                    return true;
7939:                return false;
7940:            }
7941:
7942:            final private boolean jj_3_17() {
7943:                if (jj_scan_token(COMMA))
7944:                    return true;
7945:                if (jj_3R_48())
7946:                    return true;
7947:                return false;
7948:            }
7949:
7950:            final private boolean jj_3R_122() {
7951:                if (jj_3R_45())
7952:                    return true;
7953:                return false;
7954:            }
7955:
7956:            final private boolean jj_3_16() {
7957:                if (jj_scan_token(COMMA))
7958:                    return true;
7959:                if (jj_3R_47())
7960:                    return true;
7961:                return false;
7962:            }
7963:
7964:            final private boolean jj_3R_120() {
7965:                if (jj_3R_133())
7966:                    return true;
7967:                return false;
7968:            }
7969:
7970:            final private boolean jj_3R_73() {
7971:                if (jj_3R_120())
7972:                    return true;
7973:                return false;
7974:            }
7975:
7976:            final private boolean jj_3R_72() {
7977:                if (jj_3R_45())
7978:                    return true;
7979:                return false;
7980:            }
7981:
7982:            final private boolean jj_3R_71() {
7983:                if (jj_scan_token(DOT))
7984:                    return true;
7985:                return false;
7986:            }
7987:
7988:            final private boolean jj_3R_47() {
7989:                Token xsp;
7990:                xsp = jj_scanpos;
7991:                if (jj_3R_71()) {
7992:                    jj_scanpos = xsp;
7993:                    if (jj_3R_72()) {
7994:                        jj_scanpos = xsp;
7995:                        if (jj_3R_73())
7996:                            return true;
7997:                    }
7998:                }
7999:                return false;
8000:            }
8001:
8002:            final private boolean jj_3R_117() {
8003:                if (jj_scan_token(LAMBDA))
8004:                    return true;
8005:                return false;
8006:            }
8007:
8008:            final private boolean jj_3R_149() {
8009:                if (jj_3R_152())
8010:                    return true;
8011:                return false;
8012:            }
8013:
8014:            final private boolean jj_3R_148() {
8015:                if (jj_3R_151())
8016:                    return true;
8017:                return false;
8018:            }
8019:
8020:            final private boolean jj_3R_147() {
8021:                if (jj_3R_52())
8022:                    return true;
8023:                return false;
8024:            }
8025:
8026:            final private boolean jj_3R_145() {
8027:                if (jj_scan_token(LBRACE))
8028:                    return true;
8029:                return false;
8030:            }
8031:
8032:            final private boolean jj_3R_146() {
8033:                if (jj_scan_token(135))
8034:                    return true;
8035:                return false;
8036:            }
8037:
8038:            final private boolean jj_3R_144() {
8039:                if (jj_scan_token(LBRACKET))
8040:                    return true;
8041:                return false;
8042:            }
8043:
8044:            final private boolean jj_3R_143() {
8045:                if (jj_scan_token(LPAREN))
8046:                    return true;
8047:                return false;
8048:            }
8049:
8050:            final private boolean jj_3_15() {
8051:                if (jj_scan_token(LPAREN))
8052:                    return true;
8053:                if (jj_scan_token(RPAREN))
8054:                    return true;
8055:                return false;
8056:            }
8057:
8058:            final private boolean jj_3R_140() {
8059:                Token xsp;
8060:                xsp = jj_scanpos;
8061:                if (jj_3_15()) {
8062:                    jj_scanpos = xsp;
8063:                    if (jj_3R_143()) {
8064:                        jj_scanpos = xsp;
8065:                        if (jj_3R_144()) {
8066:                            jj_scanpos = xsp;
8067:                            if (jj_3R_145()) {
8068:                                jj_scanpos = xsp;
8069:                                if (jj_3R_146()) {
8070:                                    jj_scanpos = xsp;
8071:                                    if (jj_3R_147()) {
8072:                                        jj_scanpos = xsp;
8073:                                        if (jj_3R_148()) {
8074:                                            jj_scanpos = xsp;
8075:                                            if (jj_3R_149())
8076:                                                return true;
8077:                                        }
8078:                                    }
8079:                                }
8080:                            }
8081:                        }
8082:                    }
8083:                }
8084:                return false;
8085:            }
8086:
8087:            final private boolean jj_3_14() {
8088:                if (jj_scan_token(LPAREN))
8089:                    return true;
8090:                if (jj_scan_token(RPAREN))
8091:                    return true;
8092:                return false;
8093:            }
8094:
8095:            final private boolean jj_3_13() {
8096:                if (jj_scan_token(POWER))
8097:                    return true;
8098:                if (jj_3R_46())
8099:                    return true;
8100:                return false;
8101:            }
8102:
8103:            final private boolean jj_3R_132() {
8104:                if (jj_3R_140())
8105:                    return true;
8106:                return false;
8107:            }
8108:
8109:            final private boolean jj_3R_119() {
8110:                if (jj_3R_132())
8111:                    return true;
8112:                return false;
8113:            }
8114:
8115:            final private boolean jj_3R_70() {
8116:                if (jj_3R_119())
8117:                    return true;
8118:                return false;
8119:            }
8120:
8121:            final private boolean jj_3R_69() {
8122:                if (jj_scan_token(NOT))
8123:                    return true;
8124:                return false;
8125:            }
8126:
8127:            final private boolean jj_3R_68() {
8128:                if (jj_scan_token(MINUS))
8129:                    return true;
8130:                return false;
8131:            }
8132:
8133:            final private boolean jj_3R_67() {
8134:                if (jj_scan_token(PLUS))
8135:                    return true;
8136:                return false;
8137:            }
8138:
8139:            final private boolean jj_3R_46() {
8140:                Token xsp;
8141:                xsp = jj_scanpos;
8142:                if (jj_3R_67()) {
8143:                    jj_scanpos = xsp;
8144:                    if (jj_3R_68()) {
8145:                        jj_scanpos = xsp;
8146:                        if (jj_3R_69()) {
8147:                            jj_scanpos = xsp;
8148:                            if (jj_3R_70())
8149:                                return true;
8150:                        }
8151:                    }
8152:                }
8153:                return false;
8154:            }
8155:
8156:            final private boolean jj_3R_150() {
8157:                if (jj_3R_46())
8158:                    return true;
8159:                return false;
8160:            }
8161:
8162:            final private boolean jj_3R_141() {
8163:                if (jj_3R_150())
8164:                    return true;
8165:                return false;
8166:            }
8167:
8168:            final private boolean jj_3R_134() {
8169:                if (jj_3R_141())
8170:                    return true;
8171:                return false;
8172:            }
8173:
8174:            final private boolean jj_3R_121() {
8175:                if (jj_3R_134())
8176:                    return true;
8177:                return false;
8178:            }
8179:
8180:            final private boolean jj_3R_74() {
8181:                if (jj_3R_121())
8182:                    return true;
8183:                return false;
8184:            }
8185:
8186:            final private boolean jj_3R_48() {
8187:                if (jj_3R_74())
8188:                    return true;
8189:                return false;
8190:            }
8191:
8192:            final private boolean jj_3R_139() {
8193:                if (jj_3R_142())
8194:                    return true;
8195:                return false;
8196:            }
8197:
8198:            final private boolean jj_3_12() {
8199:                if (jj_scan_token(IS))
8200:                    return true;
8201:                if (jj_scan_token(NOT_BOOL))
8202:                    return true;
8203:                return false;
8204:            }
8205:
8206:            final private boolean jj_3R_142() {
8207:                if (jj_3R_48())
8208:                    return true;
8209:                return false;
8210:            }
8211:
8212:            final private boolean jj_3R_66() {
8213:                if (jj_3R_118())
8214:                    return true;
8215:                return false;
8216:            }
8217:
8218:            final private boolean jj_3R_131() {
8219:                Token xsp;
8220:                xsp = jj_scanpos;
8221:                if (jj_3R_138()) {
8222:                    jj_scanpos = xsp;
8223:                    if (jj_3R_139())
8224:                        return true;
8225:                }
8226:                return false;
8227:            }
8228:
8229:            final private boolean jj_3R_138() {
8230:                if (jj_scan_token(NOT_BOOL))
8231:                    return true;
8232:                return false;
8233:            }
8234:
8235:            final private boolean jj_3R_118() {
8236:                if (jj_3R_131())
8237:                    return true;
8238:                return false;
8239:            }
8240:
8241:            final private boolean jj_3R_45() {
8242:                Token xsp;
8243:                xsp = jj_scanpos;
8244:                if (jj_3R_65()) {
8245:                    jj_scanpos = xsp;
8246:                    if (jj_3R_66())
8247:                        return true;
8248:                }
8249:                return false;
8250:            }
8251:
8252:            final private boolean jj_3R_65() {
8253:                if (jj_3R_117())
8254:                    return true;
8255:                return false;
8256:            }
8257:
8258:            final private boolean jj_3R_116() {
8259:                if (jj_scan_token(ASSERT))
8260:                    return true;
8261:                return false;
8262:            }
8263:
8264:            final private boolean jj_3R_115() {
8265:                if (jj_scan_token(EXEC))
8266:                    return true;
8267:                return false;
8268:            }
8269:
8270:            final private boolean jj_3R_114() {
8271:                if (jj_scan_token(GLOBAL))
8272:                    return true;
8273:                return false;
8274:            }
8275:
8276:            public PythonGrammarTokenManager token_source;
8277:            public Token token, jj_nt;
8278:            private int jj_ntk;
8279:            private Token jj_scanpos, jj_lastpos;
8280:            private int jj_la;
8281:            public boolean lookingAhead = false;
8282:            private boolean jj_semLA;
8283:            private int jj_gen;
8284:            final private int[] jj_la1 = new int[106];
8285:            static private int[] jj_la1_0;
8286:            static private int[] jj_la1_1;
8287:            static private int[] jj_la1_2;
8288:            static private int[] jj_la1_3;
8289:            static private int[] jj_la1_4;
8290:            static {
8291:                jj_la1_0();
8292:                jj_la1_1();
8293:                jj_la1_2();
8294:                jj_la1_3();
8295:                jj_la1_4();
8296:            }
8297:
8298:            private static void jj_la1_0() {
8299:                jj_la1_0 = new int[] { 0x30540000, 0x30540000, 0x40,
8300:                        0x30540040, 0x30540040, 0x40, 0x40, 0x40040000,
8301:                        0x2000000, 0x2000000, 0x40000000, 0x40040000,
8302:                        0x40000000, 0x0, 0x40000, 0x2000000, 0x30540000,
8303:                        0x1000000, 0x30540000, 0x0, 0x0, 0x2000000, 0x2000000,
8304:                        0x2000000, 0x0, 0x0, 0x30540000, 0x2000000, 0x2000000,
8305:                        0x30540000, 0x0, 0x2000000, 0x2000000, 0x40000000, 0x0,
8306:                        0x4000000, 0x0, 0x2000000, 0x2000000, 0x0, 0x2000000,
8307:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2000000,
8308:                        0x30540000, 0x30540000, 0x30540040, 0x0, 0x30540000,
8309:                        0x0, 0x30540000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8310:                        0x0, 0x30000000, 0x30000000, 0xc0000000, 0xc0000000,
8311:                        0x30540000, 0x4440000, 0x4440000, 0x30540000,
8312:                        0x30540000, 0x30540000, 0x0, 0x540000, 0x40040000,
8313:                        0x2000000, 0x8000000, 0x3c540000, 0x30540000,
8314:                        0x30540000, 0x8000000, 0x2000000, 0x2000000, 0x2000000,
8315:                        0x2000000, 0x0, 0x2000000, 0x0, 0x0, 0x40000,
8316:                        0x2000000, 0x40000000, 0x40000000, 0x2000000,
8317:                        0x2000000, 0x40000000, 0x40000000, 0x30540000,
8318:                        0x40000000, 0x0, 0x0, 0x0, 0x0, };
8319:            }
8320:
8321:            private static void jj_la1_1() {
8322:                jj_la1_1 = new int[] { 0x80000020, 0x80000020, 0x0, 0x80000020,
8323:                        0x80000020, 0x0, 0x0, 0x2, 0x0, 0x0, 0x2, 0x2, 0x2,
8324:                        0x200, 0x0, 0x0, 0x80000020, 0x0, 0x80000020, 0x200,
8325:                        0x1ffe0000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80000020, 0x0,
8326:                        0x0, 0x80000020, 0x0, 0x0, 0x0, 0xe0000000, 0x0, 0x0,
8327:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8328:                        0x0, 0x0, 0x0, 0x80000020, 0x80000020, 0x80000020,
8329:                        0x20000000, 0x80000020, 0x40000000, 0x80000020,
8330:                        0x8001fc00, 0x8001fc00, 0x0, 0x80, 0x40, 0x100, 0xc,
8331:                        0xc, 0x0, 0x0, 0x11, 0x11, 0x20, 0x0, 0x0, 0x80000020,
8332:                        0x80000020, 0x80000020, 0x0, 0x0, 0x2, 0x0, 0x0,
8333:                        0x80000020, 0x80000020, 0x80000020, 0x0, 0x0, 0x0, 0x0,
8334:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x0, 0x0,
8335:                        0x2, 0x2, 0xe0000020, 0x2, 0x0, 0x0, 0x0, 0xe0000000, };
8336:            }
8337:
8338:            private static void jj_la1_2() {
8339:                jj_la1_2 = new int[] { 0xefffedcc, 0xefffedcc, 0x0, 0xefffedcc,
8340:                        0xefffedcc, 0x0, 0x0, 0xc000000, 0x0, 0x0, 0x0,
8341:                        0xc000000, 0x0, 0x0, 0xc000000, 0x0, 0xefffedcc, 0x0,
8342:                        0xefffe004, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2000, 0x478000,
8343:                        0xec000004, 0x0, 0x0, 0xec000004, 0x180000, 0x0, 0x0,
8344:                        0xfffffff, 0x4000000, 0x0, 0x4000000, 0x0, 0x0, 0x2,
8345:                        0x0, 0xdc8, 0x20, 0x10, 0x10, 0x10, 0x200, 0x10,
8346:                        0x1200, 0x0, 0xec000004, 0xefffedcc, 0xefffe004, 0x0,
8347:                        0xec000004, 0x0, 0xec000000, 0x3, 0x2, 0x1, 0x0, 0x0,
8348:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xec000000, 0x0,
8349:                        0x0, 0xec000004, 0xec000004, 0xec000004, 0x0,
8350:                        0xec000000, 0xc000000, 0x0, 0x0, 0xec000004,
8351:                        0xec000004, 0xec000004, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80,
8352:                        0x0, 0x80, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8353:                        0xefffffff, 0x0, 0xe0000000, 0xc000000, 0x0, 0xfffffff, };
8354:            }
8355:
8356:            private static void jj_la1_3() {
8357:                jj_la1_3 = new int[] { 0xff003, 0xff003, 0x0, 0xff003, 0xff003,
8358:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8359:                        0xff003, 0x0, 0xff003, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8360:                        0x0, 0xff003, 0x0, 0x0, 0xff003, 0x0, 0x0, 0x0, 0x0,
8361:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8362:                        0x0, 0x0, 0x0, 0x0, 0x0, 0xff003, 0xff003, 0xff003,
8363:                        0x0, 0xff003, 0x0, 0xff003, 0x0, 0x0, 0x0, 0x0, 0x0,
8364:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff003, 0x0, 0x0,
8365:                        0xff003, 0xff003, 0xff003, 0xff000, 0xff003, 0x0, 0x0,
8366:                        0x0, 0xff003, 0xff003, 0xff003, 0x0, 0x0, 0x0, 0x0,
8367:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8368:                        0x0, 0x0, 0xff003, 0x0, 0x3, 0x0, 0xff000, 0x0, };
8369:            }
8370:
8371:            private static void jj_la1_4() {
8372:                jj_la1_4 = new int[] { 0x80, 0x80, 0x0, 0x80, 0x80, 0x0, 0x0,
8373:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0,
8374:                        0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0,
8375:                        0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8376:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8377:                        0x80, 0x80, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x0, 0x0,
8378:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0,
8379:                        0x0, 0x80, 0x80, 0x80, 0x0, 0x80, 0x0, 0x0, 0x0, 0x80,
8380:                        0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8381:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0,
8382:                        0x0, 0x0, 0x0, 0x0, };
8383:            }
8384:
8385:            final private JJCalls[] jj_2_rtns = new JJCalls[25];
8386:            private boolean jj_rescan = false;
8387:            private int jj_gc = 0;
8388:
8389:            public PythonGrammar(CharStream stream) {
8390:                token_source = new PythonGrammarTokenManager(stream);
8391:                token = new Token();
8392:                jj_ntk = -1;
8393:                jj_gen = 0;
8394:                for (int i = 0; i < 106; i++)
8395:                    jj_la1[i] = -1;
8396:                for (int i = 0; i < jj_2_rtns.length; i++)
8397:                    jj_2_rtns[i] = new JJCalls();
8398:            }
8399:
8400:            public void ReInit(CharStream stream) {
8401:                token_source.ReInit(stream);
8402:                token = new Token();
8403:                jj_ntk = -1;
8404:                jjtree.reset();
8405:                jj_gen = 0;
8406:                for (int i = 0; i < 106; i++)
8407:                    jj_la1[i] = -1;
8408:                for (int i = 0; i < jj_2_rtns.length; i++)
8409:                    jj_2_rtns[i] = new JJCalls();
8410:            }
8411:
8412:            public PythonGrammar(PythonGrammarTokenManager tm) {
8413:                token_source = tm;
8414:                token = new Token();
8415:                jj_ntk = -1;
8416:                jj_gen = 0;
8417:                for (int i = 0; i < 106; i++)
8418:                    jj_la1[i] = -1;
8419:                for (int i = 0; i < jj_2_rtns.length; i++)
8420:                    jj_2_rtns[i] = new JJCalls();
8421:            }
8422:
8423:            public void ReInit(PythonGrammarTokenManager tm) {
8424:                token_source = tm;
8425:                token = new Token();
8426:                jj_ntk = -1;
8427:                jjtree.reset();
8428:                jj_gen = 0;
8429:                for (int i = 0; i < 106; i++)
8430:                    jj_la1[i] = -1;
8431:                for (int i = 0; i < jj_2_rtns.length; i++)
8432:                    jj_2_rtns[i] = new JJCalls();
8433:            }
8434:
8435:            final private Token jj_consume_token(int kind)
8436:                    throws ParseException {
8437:                Token oldToken;
8438:                if ((oldToken = token).next != null)
8439:                    token = token.next;
8440:                else
8441:                    token = token.next = token_source.getNextToken();
8442:                jj_ntk = -1;
8443:                if (token.kind == kind) {
8444:                    jj_gen++;
8445:                    if (++jj_gc > 100) {
8446:                        jj_gc = 0;
8447:                        for (int i = 0; i < jj_2_rtns.length; i++) {
8448:                            JJCalls c = jj_2_rtns[i];
8449:                            while (c != null) {
8450:                                if (c.gen < jj_gen)
8451:                                    c.first = null;
8452:                                c = c.next;
8453:                            }
8454:                        }
8455:                    }
8456:                    return token;
8457:                }
8458:                token = oldToken;
8459:                jj_kind = kind;
8460:                throw generateParseException();
8461:            }
8462:
8463:            static private final class LookaheadSuccess extends java.lang.Error {
8464:            }
8465:
8466:            final private LookaheadSuccess jj_ls = new LookaheadSuccess();
8467:
8468:            final private boolean jj_scan_token(int kind) {
8469:                if (jj_scanpos == jj_lastpos) {
8470:                    jj_la--;
8471:                    if (jj_scanpos.next == null) {
8472:                        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
8473:                                .getNextToken();
8474:                    } else {
8475:                        jj_lastpos = jj_scanpos = jj_scanpos.next;
8476:                    }
8477:                } else {
8478:                    jj_scanpos = jj_scanpos.next;
8479:                }
8480:                if (jj_rescan) {
8481:                    int i = 0;
8482:                    Token tok = token;
8483:                    while (tok != null && tok != jj_scanpos) {
8484:                        i++;
8485:                        tok = tok.next;
8486:                    }
8487:                    if (tok != null)
8488:                        jj_add_error_token(kind, i);
8489:                }
8490:                if (jj_scanpos.kind != kind)
8491:                    return true;
8492:                if (jj_la == 0 && jj_scanpos == jj_lastpos)
8493:                    throw jj_ls;
8494:                return false;
8495:            }
8496:
8497:            final public Token getNextToken() {
8498:                if (token.next != null)
8499:                    token = token.next;
8500:                else
8501:                    token = token.next = token_source.getNextToken();
8502:                jj_ntk = -1;
8503:                jj_gen++;
8504:                return token;
8505:            }
8506:
8507:            final public Token getToken(int index) {
8508:                Token t = lookingAhead ? jj_scanpos : token;
8509:                for (int i = 0; i < index; i++) {
8510:                    if (t.next != null)
8511:                        t = t.next;
8512:                    else
8513:                        t = t.next = token_source.getNextToken();
8514:                }
8515:                return t;
8516:            }
8517:
8518:            final private int jj_ntk() {
8519:                if ((jj_nt = token.next) == null)
8520:                    return (jj_ntk = (token.next = token_source.getNextToken()).kind);
8521:                else
8522:                    return (jj_ntk = jj_nt.kind);
8523:            }
8524:
8525:            private java.util.Vector jj_expentries = new java.util.Vector();
8526:            private int[] jj_expentry;
8527:            private int jj_kind = -1;
8528:            private int[] jj_lasttokens = new int[100];
8529:            private int jj_endpos;
8530:
8531:            private void jj_add_error_token(int kind, int pos) {
8532:                if (pos >= 100)
8533:                    return;
8534:                if (pos == jj_endpos + 1) {
8535:                    jj_lasttokens[jj_endpos++] = kind;
8536:                } else if (jj_endpos != 0) {
8537:                    jj_expentry = new int[jj_endpos];
8538:                    for (int i = 0; i < jj_endpos; i++) {
8539:                        jj_expentry[i] = jj_lasttokens[i];
8540:                    }
8541:                    boolean exists = false;
8542:                    for (java.util.Enumeration e = jj_expentries.elements(); e
8543:                            .hasMoreElements();) {
8544:                        int[] oldentry = (int[]) (e.nextElement());
8545:                        if (oldentry.length == jj_expentry.length) {
8546:                            exists = true;
8547:                            for (int i = 0; i < jj_expentry.length; i++) {
8548:                                if (oldentry[i] != jj_expentry[i]) {
8549:                                    exists = false;
8550:                                    break;
8551:                                }
8552:                            }
8553:                            if (exists)
8554:                                break;
8555:                        }
8556:                    }
8557:                    if (!exists)
8558:                        jj_expentries.addElement(jj_expentry);
8559:                    if (pos != 0)
8560:                        jj_lasttokens[(jj_endpos = pos) - 1] = kind;
8561:                }
8562:            }
8563:
8564:            public ParseException generateParseException() {
8565:                jj_expentries.removeAllElements();
8566:                boolean[] la1tokens = new boolean[136];
8567:                for (int i = 0; i < 136; i++) {
8568:                    la1tokens[i] = false;
8569:                }
8570:                if (jj_kind >= 0) {
8571:                    la1tokens[jj_kind] = true;
8572:                    jj_kind = -1;
8573:                }
8574:                for (int i = 0; i < 106; i++) {
8575:                    if (jj_la1[i] == jj_gen) {
8576:                        for (int j = 0; j < 32; j++) {
8577:                            if ((jj_la1_0[i] & (1 << j)) != 0) {
8578:                                la1tokens[j] = true;
8579:                            }
8580:                            if ((jj_la1_1[i] & (1 << j)) != 0) {
8581:                                la1tokens[32 + j] = true;
8582:                            }
8583:                            if ((jj_la1_2[i] & (1 << j)) != 0) {
8584:                                la1tokens[64 + j] = true;
8585:                            }
8586:                            if ((jj_la1_3[i] & (1 << j)) != 0) {
8587:                                la1tokens[96 + j] = true;
8588:                            }
8589:                            if ((jj_la1_4[i] & (1 << j)) != 0) {
8590:                                la1tokens[128 + j] = true;
8591:                            }
8592:                        }
8593:                    }
8594:                }
8595:                for (int i = 0; i < 136; i++) {
8596:                    if (la1tokens[i]) {
8597:                        jj_expentry = new int[1];
8598:                        jj_expentry[0] = i;
8599:                        jj_expentries.addElement(jj_expentry);
8600:                    }
8601:                }
8602:                jj_endpos = 0;
8603:                jj_rescan_token();
8604:                jj_add_error_token(0, 0);
8605:                int[][] exptokseq = new int[jj_expentries.size()][];
8606:                for (int i = 0; i < jj_expentries.size(); i++) {
8607:                    exptokseq[i] = (int[]) jj_expentries.elementAt(i);
8608:                }
8609:                return new ParseException(token, exptokseq, tokenImage);
8610:            }
8611:
8612:            final public void enable_tracing() {
8613:            }
8614:
8615:            final public void disable_tracing() {
8616:            }
8617:
8618:            final private void jj_rescan_token() {
8619:                jj_rescan = true;
8620:                for (int i = 0; i < 25; i++) {
8621:                    JJCalls p = jj_2_rtns[i];
8622:                    do {
8623:                        if (p.gen > jj_gen) {
8624:                            jj_la = p.arg;
8625:                            jj_lastpos = jj_scanpos = p.first;
8626:                            switch (i) {
8627:                            case 0:
8628:                                jj_3_1();
8629:                                break;
8630:                            case 1:
8631:                                jj_3_2();
8632:                                break;
8633:                            case 2:
8634:                                jj_3_3();
8635:                                break;
8636:                            case 3:
8637:                                jj_3_4();
8638:                                break;
8639:                            case 4:
8640:                                jj_3_5();
8641:                                break;
8642:                            case 5:
8643:                                jj_3_6();
8644:                                break;
8645:                            case 6:
8646:                                jj_3_7();
8647:                                break;
8648:                            case 7:
8649:                                jj_3_8();
8650:                                break;
8651:                            case 8:
8652:                                jj_3_9();
8653:                                break;
8654:                            case 9:
8655:                                jj_3_10();
8656:                                break;
8657:                            case 10:
8658:                                jj_3_11();
8659:                                break;
8660:                            case 11:
8661:                                jj_3_12();
8662:                                break;
8663:                            case 12:
8664:                                jj_3_13();
8665:                                break;
8666:                            case 13:
8667:                                jj_3_14();
8668:                                break;
8669:                            case 14:
8670:                                jj_3_15();
8671:                                break;
8672:                            case 15:
8673:                                jj_3_16();
8674:                                break;
8675:                            case 16:
8676:                                jj_3_17();
8677:                                break;
8678:                            case 17:
8679:                                jj_3_18();
8680:                                break;
8681:                            case 18:
8682:                                jj_3_19();
8683:                                break;
8684:                            case 19:
8685:                                jj_3_20();
8686:                                break;
8687:                            case 20:
8688:                                jj_3_21();
8689:                                break;
8690:                            case 21:
8691:                                jj_3_22();
8692:                                break;
8693:                            case 22:
8694:                                jj_3_23();
8695:                                break;
8696:                            case 23:
8697:                                jj_3_24();
8698:                                break;
8699:                            case 24:
8700:                                jj_3_25();
8701:                                break;
8702:                            }
8703:                        }
8704:                        p = p.next;
8705:                    } while (p != null);
8706:                }
8707:                jj_rescan = false;
8708:            }
8709:
8710:            final private void jj_save(int index, int xla) {
8711:                JJCalls p = jj_2_rtns[index];
8712:                while (p.gen > jj_gen) {
8713:                    if (p.next == null) {
8714:                        p = p.next = new JJCalls();
8715:                        break;
8716:                    }
8717:                    p = p.next;
8718:                }
8719:                p.gen = jj_gen + xla - jj_la;
8720:                p.first = token;
8721:                p.arg = xla;
8722:            }
8723:
8724:            static final class JJCalls {
8725:                int gen;
8726:                Token first;
8727:                int arg;
8728:                JJCalls next;
8729:            }
8730:
8731:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.