Source Code Cross Referenced for Parser.java in  » Code-Analyzer » beautyJ » de » gulden » util » javasource » jjt » 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 » Code Analyzer » beautyJ » de.gulden.util.javasource.jjt 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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