Source Code Cross Referenced for OgnlParser.java in  » Scripting » OGNL » ognl » Java Source Code / Java DocumentationJava Source Code and Java Documentation

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


0001:        /* Generated By:JJTree&JavaCC: Do not edit this line. OgnlParser.java */
0002:        package ognl;
0003:
0004:        /**
0005:         * OgnlParser is a JavaCC parser class; it translates OGNL expressions into abstract
0006:         * syntax trees (ASTs) that can then be interpreted by the getValue and setValue methods.
0007:         */
0008:        public class OgnlParser/*@bgen(jjtree)*/implements 
0009:                OgnlParserTreeConstants, OgnlParserConstants {/*@bgen(jjtree)*/
0010:            protected JJTOgnlParserState jjtree = new JJTOgnlParserState();
0011:
0012:            /**
0013:             * This is the top-level construct of OGNL.
0014:             */
0015:            final public Node topLevelExpression() throws ParseException {
0016:                expression();
0017:                jj_consume_token(0);
0018:                {
0019:                    if (true)
0020:                        return jjtree.rootNode();
0021:                }
0022:                throw new Error("Missing return statement in function");
0023:            }
0024:
0025:            // sequence (level 14)
0026:            final public void expression() throws ParseException {
0027:                assignmentExpression();
0028:                label_1: while (true) {
0029:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0030:                    case 1:
0031:                        ;
0032:                        break;
0033:                    default:
0034:                        jj_la1[0] = jj_gen;
0035:                        break label_1;
0036:                    }
0037:                    jj_consume_token(1);
0038:                    ASTSequence jjtn001 = new ASTSequence(JJTSEQUENCE);
0039:                    boolean jjtc001 = true;
0040:                    jjtree.openNodeScope(jjtn001);
0041:                    try {
0042:                        assignmentExpression();
0043:                    } catch (Throwable jjte001) {
0044:                        if (jjtc001) {
0045:                            jjtree.clearNodeScope(jjtn001);
0046:                            jjtc001 = false;
0047:                        } else {
0048:                            jjtree.popNode();
0049:                        }
0050:                        if (jjte001 instanceof  RuntimeException) {
0051:                            {
0052:                                if (true)
0053:                                    throw (RuntimeException) jjte001;
0054:                            }
0055:                        }
0056:                        if (jjte001 instanceof  ParseException) {
0057:                            {
0058:                                if (true)
0059:                                    throw (ParseException) jjte001;
0060:                            }
0061:                        }
0062:                        {
0063:                            if (true)
0064:                                throw (Error) jjte001;
0065:                        }
0066:                    } finally {
0067:                        if (jjtc001) {
0068:                            jjtree.closeNodeScope(jjtn001, 2);
0069:                        }
0070:                    }
0071:                }
0072:            }
0073:
0074:            // assignment expression (level 13)
0075:            final public void assignmentExpression() throws ParseException {
0076:                conditionalTestExpression();
0077:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0078:                case 2:
0079:                    jj_consume_token(2);
0080:                    ASTAssign jjtn001 = new ASTAssign(JJTASSIGN);
0081:                    boolean jjtc001 = true;
0082:                    jjtree.openNodeScope(jjtn001);
0083:                    try {
0084:                        assignmentExpression();
0085:                    } catch (Throwable jjte001) {
0086:                        if (jjtc001) {
0087:                            jjtree.clearNodeScope(jjtn001);
0088:                            jjtc001 = false;
0089:                        } else {
0090:                            jjtree.popNode();
0091:                        }
0092:                        if (jjte001 instanceof  RuntimeException) {
0093:                            {
0094:                                if (true)
0095:                                    throw (RuntimeException) jjte001;
0096:                            }
0097:                        }
0098:                        if (jjte001 instanceof  ParseException) {
0099:                            {
0100:                                if (true)
0101:                                    throw (ParseException) jjte001;
0102:                            }
0103:                        }
0104:                        {
0105:                            if (true)
0106:                                throw (Error) jjte001;
0107:                        }
0108:                    } finally {
0109:                        if (jjtc001) {
0110:                            jjtree.closeNodeScope(jjtn001, 2);
0111:                        }
0112:                    }
0113:                    break;
0114:                default:
0115:                    jj_la1[1] = jj_gen;
0116:                    ;
0117:                }
0118:            }
0119:
0120:            // conditional test (level 12)
0121:            final public void conditionalTestExpression() throws ParseException {
0122:                logicalOrExpression();
0123:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0124:                case 3:
0125:                    jj_consume_token(3);
0126:                    conditionalTestExpression();
0127:                    jj_consume_token(4);
0128:                    ASTTest jjtn001 = new ASTTest(JJTTEST);
0129:                    boolean jjtc001 = true;
0130:                    jjtree.openNodeScope(jjtn001);
0131:                    try {
0132:                        conditionalTestExpression();
0133:                    } catch (Throwable jjte001) {
0134:                        if (jjtc001) {
0135:                            jjtree.clearNodeScope(jjtn001);
0136:                            jjtc001 = false;
0137:                        } else {
0138:                            jjtree.popNode();
0139:                        }
0140:                        if (jjte001 instanceof  RuntimeException) {
0141:                            {
0142:                                if (true)
0143:                                    throw (RuntimeException) jjte001;
0144:                            }
0145:                        }
0146:                        if (jjte001 instanceof  ParseException) {
0147:                            {
0148:                                if (true)
0149:                                    throw (ParseException) jjte001;
0150:                            }
0151:                        }
0152:                        {
0153:                            if (true)
0154:                                throw (Error) jjte001;
0155:                        }
0156:                    } finally {
0157:                        if (jjtc001) {
0158:                            jjtree.closeNodeScope(jjtn001, 3);
0159:                        }
0160:                    }
0161:                    break;
0162:                default:
0163:                    jj_la1[2] = jj_gen;
0164:                    ;
0165:                }
0166:            }
0167:
0168:            // logical or (||)  (level 11)
0169:            final public void logicalOrExpression() throws ParseException {
0170:                logicalAndExpression();
0171:                label_2: while (true) {
0172:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0173:                    case 5:
0174:                    case 6:
0175:                        ;
0176:                        break;
0177:                    default:
0178:                        jj_la1[3] = jj_gen;
0179:                        break label_2;
0180:                    }
0181:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0182:                    case 5:
0183:                        jj_consume_token(5);
0184:                        break;
0185:                    case 6:
0186:                        jj_consume_token(6);
0187:                        break;
0188:                    default:
0189:                        jj_la1[4] = jj_gen;
0190:                        jj_consume_token(-1);
0191:                        throw new ParseException();
0192:                    }
0193:                    ASTOr jjtn001 = new ASTOr(JJTOR);
0194:                    boolean jjtc001 = true;
0195:                    jjtree.openNodeScope(jjtn001);
0196:                    try {
0197:                        logicalAndExpression();
0198:                    } catch (Throwable jjte001) {
0199:                        if (jjtc001) {
0200:                            jjtree.clearNodeScope(jjtn001);
0201:                            jjtc001 = false;
0202:                        } else {
0203:                            jjtree.popNode();
0204:                        }
0205:                        if (jjte001 instanceof  RuntimeException) {
0206:                            {
0207:                                if (true)
0208:                                    throw (RuntimeException) jjte001;
0209:                            }
0210:                        }
0211:                        if (jjte001 instanceof  ParseException) {
0212:                            {
0213:                                if (true)
0214:                                    throw (ParseException) jjte001;
0215:                            }
0216:                        }
0217:                        {
0218:                            if (true)
0219:                                throw (Error) jjte001;
0220:                        }
0221:                    } finally {
0222:                        if (jjtc001) {
0223:                            jjtree.closeNodeScope(jjtn001, 2);
0224:                        }
0225:                    }
0226:                }
0227:            }
0228:
0229:            // logical and (&&)  (level 10)
0230:            final public void logicalAndExpression() throws ParseException {
0231:                inclusiveOrExpression();
0232:                label_3: while (true) {
0233:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0234:                    case 7:
0235:                    case 8:
0236:                        ;
0237:                        break;
0238:                    default:
0239:                        jj_la1[5] = jj_gen;
0240:                        break label_3;
0241:                    }
0242:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0243:                    case 7:
0244:                        jj_consume_token(7);
0245:                        break;
0246:                    case 8:
0247:                        jj_consume_token(8);
0248:                        break;
0249:                    default:
0250:                        jj_la1[6] = jj_gen;
0251:                        jj_consume_token(-1);
0252:                        throw new ParseException();
0253:                    }
0254:                    ASTAnd jjtn001 = new ASTAnd(JJTAND);
0255:                    boolean jjtc001 = true;
0256:                    jjtree.openNodeScope(jjtn001);
0257:                    try {
0258:                        inclusiveOrExpression();
0259:                    } catch (Throwable jjte001) {
0260:                        if (jjtc001) {
0261:                            jjtree.clearNodeScope(jjtn001);
0262:                            jjtc001 = false;
0263:                        } else {
0264:                            jjtree.popNode();
0265:                        }
0266:                        if (jjte001 instanceof  RuntimeException) {
0267:                            {
0268:                                if (true)
0269:                                    throw (RuntimeException) jjte001;
0270:                            }
0271:                        }
0272:                        if (jjte001 instanceof  ParseException) {
0273:                            {
0274:                                if (true)
0275:                                    throw (ParseException) jjte001;
0276:                            }
0277:                        }
0278:                        {
0279:                            if (true)
0280:                                throw (Error) jjte001;
0281:                        }
0282:                    } finally {
0283:                        if (jjtc001) {
0284:                            jjtree.closeNodeScope(jjtn001, 2);
0285:                        }
0286:                    }
0287:                }
0288:            }
0289:
0290:            // bitwise or non-short-circuiting or (|)  (level 9)
0291:            final public void inclusiveOrExpression() throws ParseException {
0292:                exclusiveOrExpression();
0293:                label_4: while (true) {
0294:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0295:                    case 9:
0296:                    case 10:
0297:                        ;
0298:                        break;
0299:                    default:
0300:                        jj_la1[7] = jj_gen;
0301:                        break label_4;
0302:                    }
0303:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0304:                    case 9:
0305:                        jj_consume_token(9);
0306:                        break;
0307:                    case 10:
0308:                        jj_consume_token(10);
0309:                        break;
0310:                    default:
0311:                        jj_la1[8] = jj_gen;
0312:                        jj_consume_token(-1);
0313:                        throw new ParseException();
0314:                    }
0315:                    ASTBitOr jjtn001 = new ASTBitOr(JJTBITOR);
0316:                    boolean jjtc001 = true;
0317:                    jjtree.openNodeScope(jjtn001);
0318:                    try {
0319:                        exclusiveOrExpression();
0320:                    } catch (Throwable jjte001) {
0321:                        if (jjtc001) {
0322:                            jjtree.clearNodeScope(jjtn001);
0323:                            jjtc001 = false;
0324:                        } else {
0325:                            jjtree.popNode();
0326:                        }
0327:                        if (jjte001 instanceof  RuntimeException) {
0328:                            {
0329:                                if (true)
0330:                                    throw (RuntimeException) jjte001;
0331:                            }
0332:                        }
0333:                        if (jjte001 instanceof  ParseException) {
0334:                            {
0335:                                if (true)
0336:                                    throw (ParseException) jjte001;
0337:                            }
0338:                        }
0339:                        {
0340:                            if (true)
0341:                                throw (Error) jjte001;
0342:                        }
0343:                    } finally {
0344:                        if (jjtc001) {
0345:                            jjtree.closeNodeScope(jjtn001, 2);
0346:                        }
0347:                    }
0348:                }
0349:            }
0350:
0351:            // exclusive or (^)  (level 8)
0352:            final public void exclusiveOrExpression() throws ParseException {
0353:                andExpression();
0354:                label_5: while (true) {
0355:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0356:                    case 11:
0357:                    case 12:
0358:                        ;
0359:                        break;
0360:                    default:
0361:                        jj_la1[9] = jj_gen;
0362:                        break label_5;
0363:                    }
0364:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0365:                    case 11:
0366:                        jj_consume_token(11);
0367:                        break;
0368:                    case 12:
0369:                        jj_consume_token(12);
0370:                        break;
0371:                    default:
0372:                        jj_la1[10] = jj_gen;
0373:                        jj_consume_token(-1);
0374:                        throw new ParseException();
0375:                    }
0376:                    ASTXor jjtn001 = new ASTXor(JJTXOR);
0377:                    boolean jjtc001 = true;
0378:                    jjtree.openNodeScope(jjtn001);
0379:                    try {
0380:                        andExpression();
0381:                    } catch (Throwable jjte001) {
0382:                        if (jjtc001) {
0383:                            jjtree.clearNodeScope(jjtn001);
0384:                            jjtc001 = false;
0385:                        } else {
0386:                            jjtree.popNode();
0387:                        }
0388:                        if (jjte001 instanceof  RuntimeException) {
0389:                            {
0390:                                if (true)
0391:                                    throw (RuntimeException) jjte001;
0392:                            }
0393:                        }
0394:                        if (jjte001 instanceof  ParseException) {
0395:                            {
0396:                                if (true)
0397:                                    throw (ParseException) jjte001;
0398:                            }
0399:                        }
0400:                        {
0401:                            if (true)
0402:                                throw (Error) jjte001;
0403:                        }
0404:                    } finally {
0405:                        if (jjtc001) {
0406:                            jjtree.closeNodeScope(jjtn001, 2);
0407:                        }
0408:                    }
0409:                }
0410:            }
0411:
0412:            // bitwise or non-short-circuiting and (&)  (level 7)
0413:            final public void andExpression() throws ParseException {
0414:                equalityExpression();
0415:                label_6: while (true) {
0416:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0417:                    case 13:
0418:                    case 14:
0419:                        ;
0420:                        break;
0421:                    default:
0422:                        jj_la1[11] = jj_gen;
0423:                        break label_6;
0424:                    }
0425:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0426:                    case 13:
0427:                        jj_consume_token(13);
0428:                        break;
0429:                    case 14:
0430:                        jj_consume_token(14);
0431:                        break;
0432:                    default:
0433:                        jj_la1[12] = jj_gen;
0434:                        jj_consume_token(-1);
0435:                        throw new ParseException();
0436:                    }
0437:                    ASTBitAnd jjtn001 = new ASTBitAnd(JJTBITAND);
0438:                    boolean jjtc001 = true;
0439:                    jjtree.openNodeScope(jjtn001);
0440:                    try {
0441:                        equalityExpression();
0442:                    } catch (Throwable jjte001) {
0443:                        if (jjtc001) {
0444:                            jjtree.clearNodeScope(jjtn001);
0445:                            jjtc001 = false;
0446:                        } else {
0447:                            jjtree.popNode();
0448:                        }
0449:                        if (jjte001 instanceof  RuntimeException) {
0450:                            {
0451:                                if (true)
0452:                                    throw (RuntimeException) jjte001;
0453:                            }
0454:                        }
0455:                        if (jjte001 instanceof  ParseException) {
0456:                            {
0457:                                if (true)
0458:                                    throw (ParseException) jjte001;
0459:                            }
0460:                        }
0461:                        {
0462:                            if (true)
0463:                                throw (Error) jjte001;
0464:                        }
0465:                    } finally {
0466:                        if (jjtc001) {
0467:                            jjtree.closeNodeScope(jjtn001, 2);
0468:                        }
0469:                    }
0470:                }
0471:            }
0472:
0473:            // equality/inequality (==/!=) (level 6)
0474:            final public void equalityExpression() throws ParseException {
0475:                relationalExpression();
0476:                label_7: while (true) {
0477:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0478:                    case 15:
0479:                    case 16:
0480:                    case 17:
0481:                    case 18:
0482:                        ;
0483:                        break;
0484:                    default:
0485:                        jj_la1[13] = jj_gen;
0486:                        break label_7;
0487:                    }
0488:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0489:                    case 15:
0490:                    case 16:
0491:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0492:                        case 15:
0493:                            jj_consume_token(15);
0494:                            break;
0495:                        case 16:
0496:                            jj_consume_token(16);
0497:                            break;
0498:                        default:
0499:                            jj_la1[14] = jj_gen;
0500:                            jj_consume_token(-1);
0501:                            throw new ParseException();
0502:                        }
0503:                        ASTEq jjtn001 = new ASTEq(JJTEQ);
0504:                        boolean jjtc001 = true;
0505:                        jjtree.openNodeScope(jjtn001);
0506:                        try {
0507:                            relationalExpression();
0508:                        } catch (Throwable jjte001) {
0509:                            if (jjtc001) {
0510:                                jjtree.clearNodeScope(jjtn001);
0511:                                jjtc001 = false;
0512:                            } else {
0513:                                jjtree.popNode();
0514:                            }
0515:                            if (jjte001 instanceof  RuntimeException) {
0516:                                {
0517:                                    if (true)
0518:                                        throw (RuntimeException) jjte001;
0519:                                }
0520:                            }
0521:                            if (jjte001 instanceof  ParseException) {
0522:                                {
0523:                                    if (true)
0524:                                        throw (ParseException) jjte001;
0525:                                }
0526:                            }
0527:                            {
0528:                                if (true)
0529:                                    throw (Error) jjte001;
0530:                            }
0531:                        } finally {
0532:                            if (jjtc001) {
0533:                                jjtree.closeNodeScope(jjtn001, 2);
0534:                            }
0535:                        }
0536:                        break;
0537:                    case 17:
0538:                    case 18:
0539:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0540:                        case 17:
0541:                            jj_consume_token(17);
0542:                            break;
0543:                        case 18:
0544:                            jj_consume_token(18);
0545:                            break;
0546:                        default:
0547:                            jj_la1[15] = jj_gen;
0548:                            jj_consume_token(-1);
0549:                            throw new ParseException();
0550:                        }
0551:                        ASTNotEq jjtn002 = new ASTNotEq(JJTNOTEQ);
0552:                        boolean jjtc002 = true;
0553:                        jjtree.openNodeScope(jjtn002);
0554:                        try {
0555:                            relationalExpression();
0556:                        } catch (Throwable jjte002) {
0557:                            if (jjtc002) {
0558:                                jjtree.clearNodeScope(jjtn002);
0559:                                jjtc002 = false;
0560:                            } else {
0561:                                jjtree.popNode();
0562:                            }
0563:                            if (jjte002 instanceof  RuntimeException) {
0564:                                {
0565:                                    if (true)
0566:                                        throw (RuntimeException) jjte002;
0567:                                }
0568:                            }
0569:                            if (jjte002 instanceof  ParseException) {
0570:                                {
0571:                                    if (true)
0572:                                        throw (ParseException) jjte002;
0573:                                }
0574:                            }
0575:                            {
0576:                                if (true)
0577:                                    throw (Error) jjte002;
0578:                            }
0579:                        } finally {
0580:                            if (jjtc002) {
0581:                                jjtree.closeNodeScope(jjtn002, 2);
0582:                            }
0583:                        }
0584:                        break;
0585:                    default:
0586:                        jj_la1[16] = jj_gen;
0587:                        jj_consume_token(-1);
0588:                        throw new ParseException();
0589:                    }
0590:                }
0591:            }
0592:
0593:            // boolean relational expressions (level 5)
0594:            final public void relationalExpression() throws ParseException {
0595:                shiftExpression();
0596:                label_8: while (true) {
0597:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0598:                    case 19:
0599:                    case 20:
0600:                    case 21:
0601:                    case 22:
0602:                    case 23:
0603:                    case 24:
0604:                    case 25:
0605:                    case 26:
0606:                    case 27:
0607:                    case 28:
0608:                        ;
0609:                        break;
0610:                    default:
0611:                        jj_la1[17] = jj_gen;
0612:                        break label_8;
0613:                    }
0614:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0615:                    case 19:
0616:                    case 20:
0617:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0618:                        case 19:
0619:                            jj_consume_token(19);
0620:                            break;
0621:                        case 20:
0622:                            jj_consume_token(20);
0623:                            break;
0624:                        default:
0625:                            jj_la1[18] = jj_gen;
0626:                            jj_consume_token(-1);
0627:                            throw new ParseException();
0628:                        }
0629:                        ASTLess jjtn001 = new ASTLess(JJTLESS);
0630:                        boolean jjtc001 = true;
0631:                        jjtree.openNodeScope(jjtn001);
0632:                        try {
0633:                            shiftExpression();
0634:                        } catch (Throwable jjte001) {
0635:                            if (jjtc001) {
0636:                                jjtree.clearNodeScope(jjtn001);
0637:                                jjtc001 = false;
0638:                            } else {
0639:                                jjtree.popNode();
0640:                            }
0641:                            if (jjte001 instanceof  RuntimeException) {
0642:                                {
0643:                                    if (true)
0644:                                        throw (RuntimeException) jjte001;
0645:                                }
0646:                            }
0647:                            if (jjte001 instanceof  ParseException) {
0648:                                {
0649:                                    if (true)
0650:                                        throw (ParseException) jjte001;
0651:                                }
0652:                            }
0653:                            {
0654:                                if (true)
0655:                                    throw (Error) jjte001;
0656:                            }
0657:                        } finally {
0658:                            if (jjtc001) {
0659:                                jjtree.closeNodeScope(jjtn001, 2);
0660:                            }
0661:                        }
0662:                        break;
0663:                    case 21:
0664:                    case 22:
0665:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0666:                        case 21:
0667:                            jj_consume_token(21);
0668:                            break;
0669:                        case 22:
0670:                            jj_consume_token(22);
0671:                            break;
0672:                        default:
0673:                            jj_la1[19] = jj_gen;
0674:                            jj_consume_token(-1);
0675:                            throw new ParseException();
0676:                        }
0677:                        ASTGreater jjtn002 = new ASTGreater(JJTGREATER);
0678:                        boolean jjtc002 = true;
0679:                        jjtree.openNodeScope(jjtn002);
0680:                        try {
0681:                            shiftExpression();
0682:                        } catch (Throwable jjte002) {
0683:                            if (jjtc002) {
0684:                                jjtree.clearNodeScope(jjtn002);
0685:                                jjtc002 = false;
0686:                            } else {
0687:                                jjtree.popNode();
0688:                            }
0689:                            if (jjte002 instanceof  RuntimeException) {
0690:                                {
0691:                                    if (true)
0692:                                        throw (RuntimeException) jjte002;
0693:                                }
0694:                            }
0695:                            if (jjte002 instanceof  ParseException) {
0696:                                {
0697:                                    if (true)
0698:                                        throw (ParseException) jjte002;
0699:                                }
0700:                            }
0701:                            {
0702:                                if (true)
0703:                                    throw (Error) jjte002;
0704:                            }
0705:                        } finally {
0706:                            if (jjtc002) {
0707:                                jjtree.closeNodeScope(jjtn002, 2);
0708:                            }
0709:                        }
0710:                        break;
0711:                    case 23:
0712:                    case 24:
0713:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0714:                        case 23:
0715:                            jj_consume_token(23);
0716:                            break;
0717:                        case 24:
0718:                            jj_consume_token(24);
0719:                            break;
0720:                        default:
0721:                            jj_la1[20] = jj_gen;
0722:                            jj_consume_token(-1);
0723:                            throw new ParseException();
0724:                        }
0725:                        ASTLessEq jjtn003 = new ASTLessEq(JJTLESSEQ);
0726:                        boolean jjtc003 = true;
0727:                        jjtree.openNodeScope(jjtn003);
0728:                        try {
0729:                            shiftExpression();
0730:                        } catch (Throwable jjte003) {
0731:                            if (jjtc003) {
0732:                                jjtree.clearNodeScope(jjtn003);
0733:                                jjtc003 = false;
0734:                            } else {
0735:                                jjtree.popNode();
0736:                            }
0737:                            if (jjte003 instanceof  RuntimeException) {
0738:                                {
0739:                                    if (true)
0740:                                        throw (RuntimeException) jjte003;
0741:                                }
0742:                            }
0743:                            if (jjte003 instanceof  ParseException) {
0744:                                {
0745:                                    if (true)
0746:                                        throw (ParseException) jjte003;
0747:                                }
0748:                            }
0749:                            {
0750:                                if (true)
0751:                                    throw (Error) jjte003;
0752:                            }
0753:                        } finally {
0754:                            if (jjtc003) {
0755:                                jjtree.closeNodeScope(jjtn003, 2);
0756:                            }
0757:                        }
0758:                        break;
0759:                    case 25:
0760:                    case 26:
0761:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0762:                        case 25:
0763:                            jj_consume_token(25);
0764:                            break;
0765:                        case 26:
0766:                            jj_consume_token(26);
0767:                            break;
0768:                        default:
0769:                            jj_la1[21] = jj_gen;
0770:                            jj_consume_token(-1);
0771:                            throw new ParseException();
0772:                        }
0773:                        ASTGreaterEq jjtn004 = new ASTGreaterEq(JJTGREATEREQ);
0774:                        boolean jjtc004 = true;
0775:                        jjtree.openNodeScope(jjtn004);
0776:                        try {
0777:                            shiftExpression();
0778:                        } catch (Throwable jjte004) {
0779:                            if (jjtc004) {
0780:                                jjtree.clearNodeScope(jjtn004);
0781:                                jjtc004 = false;
0782:                            } else {
0783:                                jjtree.popNode();
0784:                            }
0785:                            if (jjte004 instanceof  RuntimeException) {
0786:                                {
0787:                                    if (true)
0788:                                        throw (RuntimeException) jjte004;
0789:                                }
0790:                            }
0791:                            if (jjte004 instanceof  ParseException) {
0792:                                {
0793:                                    if (true)
0794:                                        throw (ParseException) jjte004;
0795:                                }
0796:                            }
0797:                            {
0798:                                if (true)
0799:                                    throw (Error) jjte004;
0800:                            }
0801:                        } finally {
0802:                            if (jjtc004) {
0803:                                jjtree.closeNodeScope(jjtn004, 2);
0804:                            }
0805:                        }
0806:                        break;
0807:                    case 27:
0808:                        jj_consume_token(27);
0809:                        ASTIn jjtn005 = new ASTIn(JJTIN);
0810:                        boolean jjtc005 = true;
0811:                        jjtree.openNodeScope(jjtn005);
0812:                        try {
0813:                            shiftExpression();
0814:                        } catch (Throwable jjte005) {
0815:                            if (jjtc005) {
0816:                                jjtree.clearNodeScope(jjtn005);
0817:                                jjtc005 = false;
0818:                            } else {
0819:                                jjtree.popNode();
0820:                            }
0821:                            if (jjte005 instanceof  RuntimeException) {
0822:                                {
0823:                                    if (true)
0824:                                        throw (RuntimeException) jjte005;
0825:                                }
0826:                            }
0827:                            if (jjte005 instanceof  ParseException) {
0828:                                {
0829:                                    if (true)
0830:                                        throw (ParseException) jjte005;
0831:                                }
0832:                            }
0833:                            {
0834:                                if (true)
0835:                                    throw (Error) jjte005;
0836:                            }
0837:                        } finally {
0838:                            if (jjtc005) {
0839:                                jjtree.closeNodeScope(jjtn005, 2);
0840:                            }
0841:                        }
0842:                        break;
0843:                    case 28:
0844:                        jj_consume_token(28);
0845:                        jj_consume_token(27);
0846:                        ASTNotIn jjtn006 = new ASTNotIn(JJTNOTIN);
0847:                        boolean jjtc006 = true;
0848:                        jjtree.openNodeScope(jjtn006);
0849:                        try {
0850:                            shiftExpression();
0851:                        } catch (Throwable jjte006) {
0852:                            if (jjtc006) {
0853:                                jjtree.clearNodeScope(jjtn006);
0854:                                jjtc006 = false;
0855:                            } else {
0856:                                jjtree.popNode();
0857:                            }
0858:                            if (jjte006 instanceof  RuntimeException) {
0859:                                {
0860:                                    if (true)
0861:                                        throw (RuntimeException) jjte006;
0862:                                }
0863:                            }
0864:                            if (jjte006 instanceof  ParseException) {
0865:                                {
0866:                                    if (true)
0867:                                        throw (ParseException) jjte006;
0868:                                }
0869:                            }
0870:                            {
0871:                                if (true)
0872:                                    throw (Error) jjte006;
0873:                            }
0874:                        } finally {
0875:                            if (jjtc006) {
0876:                                jjtree.closeNodeScope(jjtn006, 2);
0877:                            }
0878:                        }
0879:                        break;
0880:                    default:
0881:                        jj_la1[22] = jj_gen;
0882:                        jj_consume_token(-1);
0883:                        throw new ParseException();
0884:                    }
0885:                }
0886:            }
0887:
0888:            // bit shift expressions (level 4)
0889:            final public void shiftExpression() throws ParseException {
0890:                additiveExpression();
0891:                label_9: while (true) {
0892:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0893:                    case 29:
0894:                    case 30:
0895:                    case 31:
0896:                    case 32:
0897:                    case 33:
0898:                    case 34:
0899:                        ;
0900:                        break;
0901:                    default:
0902:                        jj_la1[23] = jj_gen;
0903:                        break label_9;
0904:                    }
0905:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0906:                    case 29:
0907:                    case 30:
0908:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0909:                        case 29:
0910:                            jj_consume_token(29);
0911:                            break;
0912:                        case 30:
0913:                            jj_consume_token(30);
0914:                            break;
0915:                        default:
0916:                            jj_la1[24] = jj_gen;
0917:                            jj_consume_token(-1);
0918:                            throw new ParseException();
0919:                        }
0920:                        ASTShiftLeft jjtn001 = new ASTShiftLeft(JJTSHIFTLEFT);
0921:                        boolean jjtc001 = true;
0922:                        jjtree.openNodeScope(jjtn001);
0923:                        try {
0924:                            additiveExpression();
0925:                        } catch (Throwable jjte001) {
0926:                            if (jjtc001) {
0927:                                jjtree.clearNodeScope(jjtn001);
0928:                                jjtc001 = false;
0929:                            } else {
0930:                                jjtree.popNode();
0931:                            }
0932:                            if (jjte001 instanceof  RuntimeException) {
0933:                                {
0934:                                    if (true)
0935:                                        throw (RuntimeException) jjte001;
0936:                                }
0937:                            }
0938:                            if (jjte001 instanceof  ParseException) {
0939:                                {
0940:                                    if (true)
0941:                                        throw (ParseException) jjte001;
0942:                                }
0943:                            }
0944:                            {
0945:                                if (true)
0946:                                    throw (Error) jjte001;
0947:                            }
0948:                        } finally {
0949:                            if (jjtc001) {
0950:                                jjtree.closeNodeScope(jjtn001, 2);
0951:                            }
0952:                        }
0953:                        break;
0954:                    case 31:
0955:                    case 32:
0956:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0957:                        case 31:
0958:                            jj_consume_token(31);
0959:                            break;
0960:                        case 32:
0961:                            jj_consume_token(32);
0962:                            break;
0963:                        default:
0964:                            jj_la1[25] = jj_gen;
0965:                            jj_consume_token(-1);
0966:                            throw new ParseException();
0967:                        }
0968:                        ASTShiftRight jjtn002 = new ASTShiftRight(JJTSHIFTRIGHT);
0969:                        boolean jjtc002 = true;
0970:                        jjtree.openNodeScope(jjtn002);
0971:                        try {
0972:                            additiveExpression();
0973:                        } catch (Throwable jjte002) {
0974:                            if (jjtc002) {
0975:                                jjtree.clearNodeScope(jjtn002);
0976:                                jjtc002 = false;
0977:                            } else {
0978:                                jjtree.popNode();
0979:                            }
0980:                            if (jjte002 instanceof  RuntimeException) {
0981:                                {
0982:                                    if (true)
0983:                                        throw (RuntimeException) jjte002;
0984:                                }
0985:                            }
0986:                            if (jjte002 instanceof  ParseException) {
0987:                                {
0988:                                    if (true)
0989:                                        throw (ParseException) jjte002;
0990:                                }
0991:                            }
0992:                            {
0993:                                if (true)
0994:                                    throw (Error) jjte002;
0995:                            }
0996:                        } finally {
0997:                            if (jjtc002) {
0998:                                jjtree.closeNodeScope(jjtn002, 2);
0999:                            }
1000:                        }
1001:                        break;
1002:                    case 33:
1003:                    case 34:
1004:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1005:                        case 33:
1006:                            jj_consume_token(33);
1007:                            break;
1008:                        case 34:
1009:                            jj_consume_token(34);
1010:                            break;
1011:                        default:
1012:                            jj_la1[26] = jj_gen;
1013:                            jj_consume_token(-1);
1014:                            throw new ParseException();
1015:                        }
1016:                        ASTUnsignedShiftRight jjtn003 = new ASTUnsignedShiftRight(
1017:                                JJTUNSIGNEDSHIFTRIGHT);
1018:                        boolean jjtc003 = true;
1019:                        jjtree.openNodeScope(jjtn003);
1020:                        try {
1021:                            additiveExpression();
1022:                        } catch (Throwable jjte003) {
1023:                            if (jjtc003) {
1024:                                jjtree.clearNodeScope(jjtn003);
1025:                                jjtc003 = false;
1026:                            } else {
1027:                                jjtree.popNode();
1028:                            }
1029:                            if (jjte003 instanceof  RuntimeException) {
1030:                                {
1031:                                    if (true)
1032:                                        throw (RuntimeException) jjte003;
1033:                                }
1034:                            }
1035:                            if (jjte003 instanceof  ParseException) {
1036:                                {
1037:                                    if (true)
1038:                                        throw (ParseException) jjte003;
1039:                                }
1040:                            }
1041:                            {
1042:                                if (true)
1043:                                    throw (Error) jjte003;
1044:                            }
1045:                        } finally {
1046:                            if (jjtc003) {
1047:                                jjtree.closeNodeScope(jjtn003, 2);
1048:                            }
1049:                        }
1050:                        break;
1051:                    default:
1052:                        jj_la1[27] = jj_gen;
1053:                        jj_consume_token(-1);
1054:                        throw new ParseException();
1055:                    }
1056:                }
1057:            }
1058:
1059:            // binary addition/subtraction (level 3)
1060:            final public void additiveExpression() throws ParseException {
1061:                multiplicativeExpression();
1062:                label_10: while (true) {
1063:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1064:                    case 35:
1065:                    case 36:
1066:                        ;
1067:                        break;
1068:                    default:
1069:                        jj_la1[28] = jj_gen;
1070:                        break label_10;
1071:                    }
1072:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1073:                    case 35:
1074:                        jj_consume_token(35);
1075:                        ASTAdd jjtn001 = new ASTAdd(JJTADD);
1076:                        boolean jjtc001 = true;
1077:                        jjtree.openNodeScope(jjtn001);
1078:                        try {
1079:                            multiplicativeExpression();
1080:                        } catch (Throwable jjte001) {
1081:                            if (jjtc001) {
1082:                                jjtree.clearNodeScope(jjtn001);
1083:                                jjtc001 = false;
1084:                            } else {
1085:                                jjtree.popNode();
1086:                            }
1087:                            if (jjte001 instanceof  RuntimeException) {
1088:                                {
1089:                                    if (true)
1090:                                        throw (RuntimeException) jjte001;
1091:                                }
1092:                            }
1093:                            if (jjte001 instanceof  ParseException) {
1094:                                {
1095:                                    if (true)
1096:                                        throw (ParseException) jjte001;
1097:                                }
1098:                            }
1099:                            {
1100:                                if (true)
1101:                                    throw (Error) jjte001;
1102:                            }
1103:                        } finally {
1104:                            if (jjtc001) {
1105:                                jjtree.closeNodeScope(jjtn001, 2);
1106:                            }
1107:                        }
1108:                        break;
1109:                    case 36:
1110:                        jj_consume_token(36);
1111:                        ASTSubtract jjtn002 = new ASTSubtract(JJTSUBTRACT);
1112:                        boolean jjtc002 = true;
1113:                        jjtree.openNodeScope(jjtn002);
1114:                        try {
1115:                            multiplicativeExpression();
1116:                        } catch (Throwable jjte002) {
1117:                            if (jjtc002) {
1118:                                jjtree.clearNodeScope(jjtn002);
1119:                                jjtc002 = false;
1120:                            } else {
1121:                                jjtree.popNode();
1122:                            }
1123:                            if (jjte002 instanceof  RuntimeException) {
1124:                                {
1125:                                    if (true)
1126:                                        throw (RuntimeException) jjte002;
1127:                                }
1128:                            }
1129:                            if (jjte002 instanceof  ParseException) {
1130:                                {
1131:                                    if (true)
1132:                                        throw (ParseException) jjte002;
1133:                                }
1134:                            }
1135:                            {
1136:                                if (true)
1137:                                    throw (Error) jjte002;
1138:                            }
1139:                        } finally {
1140:                            if (jjtc002) {
1141:                                jjtree.closeNodeScope(jjtn002, 2);
1142:                            }
1143:                        }
1144:                        break;
1145:                    default:
1146:                        jj_la1[29] = jj_gen;
1147:                        jj_consume_token(-1);
1148:                        throw new ParseException();
1149:                    }
1150:                }
1151:            }
1152:
1153:            // multiplication/division/remainder (level 2)
1154:            final public void multiplicativeExpression() throws ParseException {
1155:                unaryExpression();
1156:                label_11: while (true) {
1157:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1158:                    case 37:
1159:                    case 38:
1160:                    case 39:
1161:                        ;
1162:                        break;
1163:                    default:
1164:                        jj_la1[30] = jj_gen;
1165:                        break label_11;
1166:                    }
1167:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1168:                    case 37:
1169:                        jj_consume_token(37);
1170:                        ASTMultiply jjtn001 = new ASTMultiply(JJTMULTIPLY);
1171:                        boolean jjtc001 = true;
1172:                        jjtree.openNodeScope(jjtn001);
1173:                        try {
1174:                            unaryExpression();
1175:                        } catch (Throwable jjte001) {
1176:                            if (jjtc001) {
1177:                                jjtree.clearNodeScope(jjtn001);
1178:                                jjtc001 = false;
1179:                            } else {
1180:                                jjtree.popNode();
1181:                            }
1182:                            if (jjte001 instanceof  RuntimeException) {
1183:                                {
1184:                                    if (true)
1185:                                        throw (RuntimeException) jjte001;
1186:                                }
1187:                            }
1188:                            if (jjte001 instanceof  ParseException) {
1189:                                {
1190:                                    if (true)
1191:                                        throw (ParseException) jjte001;
1192:                                }
1193:                            }
1194:                            {
1195:                                if (true)
1196:                                    throw (Error) jjte001;
1197:                            }
1198:                        } finally {
1199:                            if (jjtc001) {
1200:                                jjtree.closeNodeScope(jjtn001, 2);
1201:                            }
1202:                        }
1203:                        break;
1204:                    case 38:
1205:                        jj_consume_token(38);
1206:                        ASTDivide jjtn002 = new ASTDivide(JJTDIVIDE);
1207:                        boolean jjtc002 = true;
1208:                        jjtree.openNodeScope(jjtn002);
1209:                        try {
1210:                            unaryExpression();
1211:                        } catch (Throwable jjte002) {
1212:                            if (jjtc002) {
1213:                                jjtree.clearNodeScope(jjtn002);
1214:                                jjtc002 = false;
1215:                            } else {
1216:                                jjtree.popNode();
1217:                            }
1218:                            if (jjte002 instanceof  RuntimeException) {
1219:                                {
1220:                                    if (true)
1221:                                        throw (RuntimeException) jjte002;
1222:                                }
1223:                            }
1224:                            if (jjte002 instanceof  ParseException) {
1225:                                {
1226:                                    if (true)
1227:                                        throw (ParseException) jjte002;
1228:                                }
1229:                            }
1230:                            {
1231:                                if (true)
1232:                                    throw (Error) jjte002;
1233:                            }
1234:                        } finally {
1235:                            if (jjtc002) {
1236:                                jjtree.closeNodeScope(jjtn002, 2);
1237:                            }
1238:                        }
1239:                        break;
1240:                    case 39:
1241:                        jj_consume_token(39);
1242:                        ASTRemainder jjtn003 = new ASTRemainder(JJTREMAINDER);
1243:                        boolean jjtc003 = true;
1244:                        jjtree.openNodeScope(jjtn003);
1245:                        try {
1246:                            unaryExpression();
1247:                        } catch (Throwable jjte003) {
1248:                            if (jjtc003) {
1249:                                jjtree.clearNodeScope(jjtn003);
1250:                                jjtc003 = false;
1251:                            } else {
1252:                                jjtree.popNode();
1253:                            }
1254:                            if (jjte003 instanceof  RuntimeException) {
1255:                                {
1256:                                    if (true)
1257:                                        throw (RuntimeException) jjte003;
1258:                                }
1259:                            }
1260:                            if (jjte003 instanceof  ParseException) {
1261:                                {
1262:                                    if (true)
1263:                                        throw (ParseException) jjte003;
1264:                                }
1265:                            }
1266:                            {
1267:                                if (true)
1268:                                    throw (Error) jjte003;
1269:                            }
1270:                        } finally {
1271:                            if (jjtc003) {
1272:                                jjtree.closeNodeScope(jjtn003, 2);
1273:                            }
1274:                        }
1275:                        break;
1276:                    default:
1277:                        jj_la1[31] = jj_gen;
1278:                        jj_consume_token(-1);
1279:                        throw new ParseException();
1280:                    }
1281:                }
1282:            }
1283:
1284:            // unary (level 1)
1285:            final public void unaryExpression() throws ParseException {
1286:                StringBuffer sb;
1287:                Token t;
1288:                ASTInstanceof ionode;
1289:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1290:                case 36:
1291:                    jj_consume_token(36);
1292:                    ASTNegate jjtn001 = new ASTNegate(JJTNEGATE);
1293:                    boolean jjtc001 = true;
1294:                    jjtree.openNodeScope(jjtn001);
1295:                    try {
1296:                        unaryExpression();
1297:                    } catch (Throwable jjte001) {
1298:                        if (jjtc001) {
1299:                            jjtree.clearNodeScope(jjtn001);
1300:                            jjtc001 = false;
1301:                        } else {
1302:                            jjtree.popNode();
1303:                        }
1304:                        if (jjte001 instanceof  RuntimeException) {
1305:                            {
1306:                                if (true)
1307:                                    throw (RuntimeException) jjte001;
1308:                            }
1309:                        }
1310:                        if (jjte001 instanceof  ParseException) {
1311:                            {
1312:                                if (true)
1313:                                    throw (ParseException) jjte001;
1314:                            }
1315:                        }
1316:                        {
1317:                            if (true)
1318:                                throw (Error) jjte001;
1319:                        }
1320:                    } finally {
1321:                        if (jjtc001) {
1322:                            jjtree.closeNodeScope(jjtn001, 1);
1323:                        }
1324:                    }
1325:                    break;
1326:                case 35:
1327:                    jj_consume_token(35);
1328:                    unaryExpression();
1329:                    break;
1330:                case 40:
1331:                    jj_consume_token(40);
1332:                    ASTBitNegate jjtn002 = new ASTBitNegate(JJTBITNEGATE);
1333:                    boolean jjtc002 = true;
1334:                    jjtree.openNodeScope(jjtn002);
1335:                    try {
1336:                        unaryExpression();
1337:                    } catch (Throwable jjte002) {
1338:                        if (jjtc002) {
1339:                            jjtree.clearNodeScope(jjtn002);
1340:                            jjtc002 = false;
1341:                        } else {
1342:                            jjtree.popNode();
1343:                        }
1344:                        if (jjte002 instanceof  RuntimeException) {
1345:                            {
1346:                                if (true)
1347:                                    throw (RuntimeException) jjte002;
1348:                            }
1349:                        }
1350:                        if (jjte002 instanceof  ParseException) {
1351:                            {
1352:                                if (true)
1353:                                    throw (ParseException) jjte002;
1354:                            }
1355:                        }
1356:                        {
1357:                            if (true)
1358:                                throw (Error) jjte002;
1359:                        }
1360:                    } finally {
1361:                        if (jjtc002) {
1362:                            jjtree.closeNodeScope(jjtn002, 1);
1363:                        }
1364:                    }
1365:                    break;
1366:                case 28:
1367:                case 41:
1368:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1369:                    case 41:
1370:                        jj_consume_token(41);
1371:                        break;
1372:                    case 28:
1373:                        jj_consume_token(28);
1374:                        break;
1375:                    default:
1376:                        jj_la1[32] = jj_gen;
1377:                        jj_consume_token(-1);
1378:                        throw new ParseException();
1379:                    }
1380:                    ASTNot jjtn003 = new ASTNot(JJTNOT);
1381:                    boolean jjtc003 = true;
1382:                    jjtree.openNodeScope(jjtn003);
1383:                    try {
1384:                        unaryExpression();
1385:                    } catch (Throwable jjte003) {
1386:                        if (jjtc003) {
1387:                            jjtree.clearNodeScope(jjtn003);
1388:                            jjtc003 = false;
1389:                        } else {
1390:                            jjtree.popNode();
1391:                        }
1392:                        if (jjte003 instanceof  RuntimeException) {
1393:                            {
1394:                                if (true)
1395:                                    throw (RuntimeException) jjte003;
1396:                            }
1397:                        }
1398:                        if (jjte003 instanceof  ParseException) {
1399:                            {
1400:                                if (true)
1401:                                    throw (ParseException) jjte003;
1402:                            }
1403:                        }
1404:                        {
1405:                            if (true)
1406:                                throw (Error) jjte003;
1407:                        }
1408:                    } finally {
1409:                        if (jjtc003) {
1410:                            jjtree.closeNodeScope(jjtn003, 1);
1411:                        }
1412:                    }
1413:                    break;
1414:                case 4:
1415:                case 44:
1416:                case 46:
1417:                case 47:
1418:                case 48:
1419:                case 49:
1420:                case 50:
1421:                case 51:
1422:                case 52:
1423:                case 54:
1424:                case 56:
1425:                case 57:
1426:                case IDENT:
1427:                case DYNAMIC_SUBSCRIPT:
1428:                case CHAR_LITERAL:
1429:                case BACK_CHAR_LITERAL:
1430:                case STRING_LITERAL:
1431:                case INT_LITERAL:
1432:                case FLT_LITERAL:
1433:                    navigationChain();
1434:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1435:                    case 42:
1436:                        jj_consume_token(42);
1437:                        t = jj_consume_token(IDENT);
1438:                        ASTInstanceof jjtn004 = new ASTInstanceof(JJTINSTANCEOF);
1439:                        boolean jjtc004 = true;
1440:                        jjtree.openNodeScope(jjtn004);
1441:                        try {
1442:                            jjtree.closeNodeScope(jjtn004, 1);
1443:                            jjtc004 = false;
1444:                            sb = new StringBuffer(t.image);
1445:                            ionode = jjtn004;
1446:                        } finally {
1447:                            if (jjtc004) {
1448:                                jjtree.closeNodeScope(jjtn004, 1);
1449:                            }
1450:                        }
1451:                        label_12: while (true) {
1452:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1453:                            case 43:
1454:                                ;
1455:                                break;
1456:                            default:
1457:                                jj_la1[33] = jj_gen;
1458:                                break label_12;
1459:                            }
1460:                            jj_consume_token(43);
1461:                            t = jj_consume_token(IDENT);
1462:                            sb.append('.').append(t.image);
1463:                        }
1464:                        ionode.setTargetType(new String(sb));
1465:                        break;
1466:                    default:
1467:                        jj_la1[34] = jj_gen;
1468:                        ;
1469:                    }
1470:                    break;
1471:                default:
1472:                    jj_la1[35] = jj_gen;
1473:                    jj_consume_token(-1);
1474:                    throw new ParseException();
1475:                }
1476:            }
1477:
1478:            // navigation chain: property references, method calls, projections, selections, etc.
1479:            final public void navigationChain() throws ParseException {
1480:                primaryExpression();
1481:                label_13: while (true) {
1482:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1483:                    case 43:
1484:                    case 44:
1485:                    case 52:
1486:                    case DYNAMIC_SUBSCRIPT:
1487:                        ;
1488:                        break;
1489:                    default:
1490:                        jj_la1[36] = jj_gen;
1491:                        break label_13;
1492:                    }
1493:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1494:                    case 43:
1495:                        jj_consume_token(43);
1496:                        ASTChain jjtn001 = new ASTChain(JJTCHAIN);
1497:                        boolean jjtc001 = true;
1498:                        jjtree.openNodeScope(jjtn001);
1499:                        try {
1500:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1501:                            case IDENT:
1502:                                if (jj_2_1(2)) {
1503:                                    methodCall();
1504:                                } else {
1505:                                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1506:                                    case IDENT:
1507:                                        propertyName();
1508:                                        break;
1509:                                    default:
1510:                                        jj_la1[37] = jj_gen;
1511:                                        jj_consume_token(-1);
1512:                                        throw new ParseException();
1513:                                    }
1514:                                }
1515:                                break;
1516:                            case 54:
1517:                                if (jj_2_2(2)) {
1518:                                    projection();
1519:                                } else {
1520:                                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1521:                                    case 54:
1522:                                        selection();
1523:                                        break;
1524:                                    default:
1525:                                        jj_la1[38] = jj_gen;
1526:                                        jj_consume_token(-1);
1527:                                        throw new ParseException();
1528:                                    }
1529:                                }
1530:                                break;
1531:                            case 44:
1532:                                jj_consume_token(44);
1533:                                expression();
1534:                                jj_consume_token(45);
1535:                                break;
1536:                            default:
1537:                                jj_la1[39] = jj_gen;
1538:                                jj_consume_token(-1);
1539:                                throw new ParseException();
1540:                            }
1541:                        } catch (Throwable jjte001) {
1542:                            if (jjtc001) {
1543:                                jjtree.clearNodeScope(jjtn001);
1544:                                jjtc001 = false;
1545:                            } else {
1546:                                jjtree.popNode();
1547:                            }
1548:                            if (jjte001 instanceof  RuntimeException) {
1549:                                {
1550:                                    if (true)
1551:                                        throw (RuntimeException) jjte001;
1552:                                }
1553:                            }
1554:                            if (jjte001 instanceof  ParseException) {
1555:                                {
1556:                                    if (true)
1557:                                        throw (ParseException) jjte001;
1558:                                }
1559:                            }
1560:                            {
1561:                                if (true)
1562:                                    throw (Error) jjte001;
1563:                            }
1564:                        } finally {
1565:                            if (jjtc001) {
1566:                                jjtree.closeNodeScope(jjtn001, 2);
1567:                            }
1568:                        }
1569:                        break;
1570:                    case 52:
1571:                    case DYNAMIC_SUBSCRIPT:
1572:                        ASTChain jjtn002 = new ASTChain(JJTCHAIN);
1573:                        boolean jjtc002 = true;
1574:                        jjtree.openNodeScope(jjtn002);
1575:                        try {
1576:                            index();
1577:                        } catch (Throwable jjte002) {
1578:                            if (jjtc002) {
1579:                                jjtree.clearNodeScope(jjtn002);
1580:                                jjtc002 = false;
1581:                            } else {
1582:                                jjtree.popNode();
1583:                            }
1584:                            if (jjte002 instanceof  RuntimeException) {
1585:                                {
1586:                                    if (true)
1587:                                        throw (RuntimeException) jjte002;
1588:                                }
1589:                            }
1590:                            if (jjte002 instanceof  ParseException) {
1591:                                {
1592:                                    if (true)
1593:                                        throw (ParseException) jjte002;
1594:                                }
1595:                            }
1596:                            {
1597:                                if (true)
1598:                                    throw (Error) jjte002;
1599:                            }
1600:                        } finally {
1601:                            if (jjtc002) {
1602:                                jjtree.closeNodeScope(jjtn002, 2);
1603:                            }
1604:                        }
1605:                        break;
1606:                    case 44:
1607:                        jj_consume_token(44);
1608:                        expression();
1609:                        ASTEval jjtn003 = new ASTEval(JJTEVAL);
1610:                        boolean jjtc003 = true;
1611:                        jjtree.openNodeScope(jjtn003);
1612:                        try {
1613:                            jj_consume_token(45);
1614:                        } finally {
1615:                            if (jjtc003) {
1616:                                jjtree.closeNodeScope(jjtn003, 2);
1617:                            }
1618:                        }
1619:                        break;
1620:                    default:
1621:                        jj_la1[40] = jj_gen;
1622:                        jj_consume_token(-1);
1623:                        throw new ParseException();
1624:                    }
1625:                }
1626:            }
1627:
1628:            final public void primaryExpression() throws ParseException {
1629:                Token t;
1630:                String className = null;
1631:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1632:                case CHAR_LITERAL:
1633:                case BACK_CHAR_LITERAL:
1634:                case STRING_LITERAL:
1635:                case INT_LITERAL:
1636:                case FLT_LITERAL:
1637:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1638:                    case CHAR_LITERAL:
1639:                        jj_consume_token(CHAR_LITERAL);
1640:                        break;
1641:                    case BACK_CHAR_LITERAL:
1642:                        jj_consume_token(BACK_CHAR_LITERAL);
1643:                        break;
1644:                    case STRING_LITERAL:
1645:                        jj_consume_token(STRING_LITERAL);
1646:                        break;
1647:                    case INT_LITERAL:
1648:                        jj_consume_token(INT_LITERAL);
1649:                        break;
1650:                    case FLT_LITERAL:
1651:                        jj_consume_token(FLT_LITERAL);
1652:                        break;
1653:                    default:
1654:                        jj_la1[41] = jj_gen;
1655:                        jj_consume_token(-1);
1656:                        throw new ParseException();
1657:                    }
1658:                    ASTConst jjtn001 = new ASTConst(JJTCONST);
1659:                    boolean jjtc001 = true;
1660:                    jjtree.openNodeScope(jjtn001);
1661:                    try {
1662:                        jjtree.closeNodeScope(jjtn001, 0);
1663:                        jjtc001 = false;
1664:                        jjtn001.setValue(token_source.literalValue);
1665:                    } finally {
1666:                        if (jjtc001) {
1667:                            jjtree.closeNodeScope(jjtn001, 0);
1668:                        }
1669:                    }
1670:                    break;
1671:                case 46:
1672:                    jj_consume_token(46);
1673:                    ASTConst jjtn002 = new ASTConst(JJTCONST);
1674:                    boolean jjtc002 = true;
1675:                    jjtree.openNodeScope(jjtn002);
1676:                    try {
1677:                        jjtree.closeNodeScope(jjtn002, 0);
1678:                        jjtc002 = false;
1679:                        jjtn002.setValue(Boolean.TRUE);
1680:                    } finally {
1681:                        if (jjtc002) {
1682:                            jjtree.closeNodeScope(jjtn002, 0);
1683:                        }
1684:                    }
1685:                    break;
1686:                case 47:
1687:                    jj_consume_token(47);
1688:                    ASTConst jjtn003 = new ASTConst(JJTCONST);
1689:                    boolean jjtc003 = true;
1690:                    jjtree.openNodeScope(jjtn003);
1691:                    try {
1692:                        jjtree.closeNodeScope(jjtn003, 0);
1693:                        jjtc003 = false;
1694:                        jjtn003.setValue(Boolean.FALSE);
1695:                    } finally {
1696:                        if (jjtc003) {
1697:                            jjtree.closeNodeScope(jjtn003, 0);
1698:                        }
1699:                    }
1700:                    break;
1701:                case 48:
1702:                    ASTConst jjtn004 = new ASTConst(JJTCONST);
1703:                    boolean jjtc004 = true;
1704:                    jjtree.openNodeScope(jjtn004);
1705:                    try {
1706:                        jj_consume_token(48);
1707:                    } finally {
1708:                        if (jjtc004) {
1709:                            jjtree.closeNodeScope(jjtn004, 0);
1710:                        }
1711:                    }
1712:                    break;
1713:                default:
1714:                    jj_la1[48] = jj_gen;
1715:                    if (jj_2_4(2)) {
1716:                        jj_consume_token(49);
1717:                        ASTThisVarRef jjtn005 = new ASTThisVarRef(JJTTHISVARREF);
1718:                        boolean jjtc005 = true;
1719:                        jjtree.openNodeScope(jjtn005);
1720:                        try {
1721:                            jjtree.closeNodeScope(jjtn005, 0);
1722:                            jjtc005 = false;
1723:                            jjtn005.setName("this");
1724:                        } finally {
1725:                            if (jjtc005) {
1726:                                jjtree.closeNodeScope(jjtn005, 0);
1727:                            }
1728:                        }
1729:                    } else if (jj_2_5(2)) {
1730:                        jj_consume_token(50);
1731:                        ASTRootVarRef jjtn006 = new ASTRootVarRef(JJTROOTVARREF);
1732:                        boolean jjtc006 = true;
1733:                        jjtree.openNodeScope(jjtn006);
1734:                        try {
1735:                            jjtree.closeNodeScope(jjtn006, 0);
1736:                            jjtc006 = false;
1737:                            jjtn006.setName("root");
1738:                        } finally {
1739:                            if (jjtc006) {
1740:                                jjtree.closeNodeScope(jjtn006, 0);
1741:                            }
1742:                        }
1743:                    } else if (jj_2_6(2)) {
1744:                        jj_consume_token(51);
1745:                        t = jj_consume_token(IDENT);
1746:                        ASTVarRef jjtn007 = new ASTVarRef(JJTVARREF);
1747:                        boolean jjtc007 = true;
1748:                        jjtree.openNodeScope(jjtn007);
1749:                        try {
1750:                            jjtree.closeNodeScope(jjtn007, 0);
1751:                            jjtc007 = false;
1752:                            jjtn007.setName(t.image);
1753:                        } finally {
1754:                            if (jjtc007) {
1755:                                jjtree.closeNodeScope(jjtn007, 0);
1756:                            }
1757:                        }
1758:                    } else if (jj_2_7(2)) {
1759:                        jj_consume_token(4);
1760:                        jj_consume_token(52);
1761:                        expression();
1762:                        jj_consume_token(53);
1763:                        ASTConst jjtn008 = new ASTConst(JJTCONST);
1764:                        boolean jjtc008 = true;
1765:                        jjtree.openNodeScope(jjtn008);
1766:                        try {
1767:                            jjtree.closeNodeScope(jjtn008, 1);
1768:                            jjtc008 = false;
1769:                            jjtn008.setValue(jjtn008.jjtGetChild(0));
1770:                        } finally {
1771:                            if (jjtc008) {
1772:                                jjtree.closeNodeScope(jjtn008, 1);
1773:                            }
1774:                        }
1775:                    } else {
1776:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1777:                        case 56:
1778:                            staticReference();
1779:                            break;
1780:                        default:
1781:                            jj_la1[49] = jj_gen;
1782:                            if (jj_2_8(2)) {
1783:                                constructorCall();
1784:                            } else {
1785:                                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1786:                                case IDENT:
1787:                                    if (jj_2_3(2)) {
1788:                                        methodCall();
1789:                                    } else {
1790:                                        switch ((jj_ntk == -1) ? jj_ntk()
1791:                                                : jj_ntk) {
1792:                                        case IDENT:
1793:                                            propertyName();
1794:                                            break;
1795:                                        default:
1796:                                            jj_la1[42] = jj_gen;
1797:                                            jj_consume_token(-1);
1798:                                            throw new ParseException();
1799:                                        }
1800:                                    }
1801:                                    break;
1802:                                case 52:
1803:                                case DYNAMIC_SUBSCRIPT:
1804:                                    index();
1805:                                    break;
1806:                                case 44:
1807:                                    jj_consume_token(44);
1808:                                    expression();
1809:                                    jj_consume_token(45);
1810:                                    break;
1811:                                case 54:
1812:                                    jj_consume_token(54);
1813:                                    ASTList jjtn009 = new ASTList(JJTLIST);
1814:                                    boolean jjtc009 = true;
1815:                                    jjtree.openNodeScope(jjtn009);
1816:                                    try {
1817:                                        switch ((jj_ntk == -1) ? jj_ntk()
1818:                                                : jj_ntk) {
1819:                                        case 4:
1820:                                        case 28:
1821:                                        case 35:
1822:                                        case 36:
1823:                                        case 40:
1824:                                        case 41:
1825:                                        case 44:
1826:                                        case 46:
1827:                                        case 47:
1828:                                        case 48:
1829:                                        case 49:
1830:                                        case 50:
1831:                                        case 51:
1832:                                        case 52:
1833:                                        case 54:
1834:                                        case 56:
1835:                                        case 57:
1836:                                        case IDENT:
1837:                                        case DYNAMIC_SUBSCRIPT:
1838:                                        case CHAR_LITERAL:
1839:                                        case BACK_CHAR_LITERAL:
1840:                                        case STRING_LITERAL:
1841:                                        case INT_LITERAL:
1842:                                        case FLT_LITERAL:
1843:                                            assignmentExpression();
1844:                                            label_14: while (true) {
1845:                                                switch ((jj_ntk == -1) ? jj_ntk()
1846:                                                        : jj_ntk) {
1847:                                                case 1:
1848:                                                    ;
1849:                                                    break;
1850:                                                default:
1851:                                                    jj_la1[43] = jj_gen;
1852:                                                    break label_14;
1853:                                                }
1854:                                                jj_consume_token(1);
1855:                                                assignmentExpression();
1856:                                            }
1857:                                            break;
1858:                                        default:
1859:                                            jj_la1[44] = jj_gen;
1860:                                            ;
1861:                                        }
1862:                                    } catch (Throwable jjte009) {
1863:                                        if (jjtc009) {
1864:                                            jjtree.clearNodeScope(jjtn009);
1865:                                            jjtc009 = false;
1866:                                        } else {
1867:                                            jjtree.popNode();
1868:                                        }
1869:                                        if (jjte009 instanceof  RuntimeException) {
1870:                                            {
1871:                                                if (true)
1872:                                                    throw (RuntimeException) jjte009;
1873:                                            }
1874:                                        }
1875:                                        if (jjte009 instanceof  ParseException) {
1876:                                            {
1877:                                                if (true)
1878:                                                    throw (ParseException) jjte009;
1879:                                            }
1880:                                        }
1881:                                        {
1882:                                            if (true)
1883:                                                throw (Error) jjte009;
1884:                                        }
1885:                                    } finally {
1886:                                        if (jjtc009) {
1887:                                            jjtree
1888:                                                    .closeNodeScope(jjtn009,
1889:                                                            true);
1890:                                        }
1891:                                    }
1892:                                    jj_consume_token(55);
1893:                                    break;
1894:                                default:
1895:                                    jj_la1[50] = jj_gen;
1896:                                    if (jj_2_9(2)) {
1897:                                        ASTMap jjtn010 = new ASTMap(JJTMAP);
1898:                                        boolean jjtc010 = true;
1899:                                        jjtree.openNodeScope(jjtn010);
1900:                                        try {
1901:                                            jj_consume_token(51);
1902:                                            switch ((jj_ntk == -1) ? jj_ntk()
1903:                                                    : jj_ntk) {
1904:                                            case 56:
1905:                                                className = classReference();
1906:                                                break;
1907:                                            default:
1908:                                                jj_la1[45] = jj_gen;
1909:                                                ;
1910:                                            }
1911:                                            jj_consume_token(54);
1912:                                            switch ((jj_ntk == -1) ? jj_ntk()
1913:                                                    : jj_ntk) {
1914:                                            case 4:
1915:                                            case 28:
1916:                                            case 35:
1917:                                            case 36:
1918:                                            case 40:
1919:                                            case 41:
1920:                                            case 44:
1921:                                            case 46:
1922:                                            case 47:
1923:                                            case 48:
1924:                                            case 49:
1925:                                            case 50:
1926:                                            case 51:
1927:                                            case 52:
1928:                                            case 54:
1929:                                            case 56:
1930:                                            case 57:
1931:                                            case IDENT:
1932:                                            case DYNAMIC_SUBSCRIPT:
1933:                                            case CHAR_LITERAL:
1934:                                            case BACK_CHAR_LITERAL:
1935:                                            case STRING_LITERAL:
1936:                                            case INT_LITERAL:
1937:                                            case FLT_LITERAL:
1938:                                                keyValueExpression();
1939:                                                label_15: while (true) {
1940:                                                    switch ((jj_ntk == -1) ? jj_ntk()
1941:                                                            : jj_ntk) {
1942:                                                    case 1:
1943:                                                        ;
1944:                                                        break;
1945:                                                    default:
1946:                                                        jj_la1[46] = jj_gen;
1947:                                                        break label_15;
1948:                                                    }
1949:                                                    jj_consume_token(1);
1950:                                                    keyValueExpression();
1951:                                                }
1952:                                                break;
1953:                                            default:
1954:                                                jj_la1[47] = jj_gen;
1955:                                                ;
1956:                                            }
1957:                                            jjtn010.setClassName(className);
1958:                                            jj_consume_token(55);
1959:                                        } catch (Throwable jjte010) {
1960:                                            if (jjtc010) {
1961:                                                jjtree.clearNodeScope(jjtn010);
1962:                                                jjtc010 = false;
1963:                                            } else {
1964:                                                jjtree.popNode();
1965:                                            }
1966:                                            if (jjte010 instanceof  RuntimeException) {
1967:                                                {
1968:                                                    if (true)
1969:                                                        throw (RuntimeException) jjte010;
1970:                                                }
1971:                                            }
1972:                                            if (jjte010 instanceof  ParseException) {
1973:                                                {
1974:                                                    if (true)
1975:                                                        throw (ParseException) jjte010;
1976:                                                }
1977:                                            }
1978:                                            {
1979:                                                if (true)
1980:                                                    throw (Error) jjte010;
1981:                                            }
1982:                                        } finally {
1983:                                            if (jjtc010) {
1984:                                                jjtree.closeNodeScope(jjtn010,
1985:                                                        true);
1986:                                            }
1987:                                        }
1988:                                    } else {
1989:                                        jj_consume_token(-1);
1990:                                        throw new ParseException();
1991:                                    }
1992:                                }
1993:                            }
1994:                        }
1995:                    }
1996:                }
1997:            }
1998:
1999:            final public void keyValueExpression() throws ParseException {
2000:                ASTKeyValue jjtn001 = new ASTKeyValue(JJTKEYVALUE);
2001:                boolean jjtc001 = true;
2002:                jjtree.openNodeScope(jjtn001);
2003:                try {
2004:                    assignmentExpression();
2005:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2006:                    case 4:
2007:                        jj_consume_token(4);
2008:                        assignmentExpression();
2009:                        break;
2010:                    default:
2011:                        jj_la1[51] = jj_gen;
2012:                        ;
2013:                    }
2014:                } catch (Throwable jjte001) {
2015:                    if (jjtc001) {
2016:                        jjtree.clearNodeScope(jjtn001);
2017:                        jjtc001 = false;
2018:                    } else {
2019:                        jjtree.popNode();
2020:                    }
2021:                    if (jjte001 instanceof  RuntimeException) {
2022:                        {
2023:                            if (true)
2024:                                throw (RuntimeException) jjte001;
2025:                        }
2026:                    }
2027:                    if (jjte001 instanceof  ParseException) {
2028:                        {
2029:                            if (true)
2030:                                throw (ParseException) jjte001;
2031:                        }
2032:                    }
2033:                    {
2034:                        if (true)
2035:                            throw (Error) jjte001;
2036:                    }
2037:                } finally {
2038:                    if (jjtc001) {
2039:                        jjtree.closeNodeScope(jjtn001, true);
2040:                    }
2041:                }
2042:            }
2043:
2044:            final public void staticReference() throws ParseException {
2045:                String className = "java.lang.Math";
2046:                Token t;
2047:                className = classReference();
2048:                if (jj_2_10(2)) {
2049:                    staticMethodCall(className);
2050:                } else {
2051:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2052:                    case IDENT:
2053:                        t = jj_consume_token(IDENT);
2054:                        ASTStaticField jjtn001 = new ASTStaticField(
2055:                                JJTSTATICFIELD);
2056:                        boolean jjtc001 = true;
2057:                        jjtree.openNodeScope(jjtn001);
2058:                        try {
2059:                            jjtree.closeNodeScope(jjtn001, 0);
2060:                            jjtc001 = false;
2061:                            jjtn001.init(className, t.image);
2062:                        } finally {
2063:                            if (jjtc001) {
2064:                                jjtree.closeNodeScope(jjtn001, 0);
2065:                            }
2066:                        }
2067:                        break;
2068:                    default:
2069:                        jj_la1[52] = jj_gen;
2070:                        jj_consume_token(-1);
2071:                        throw new ParseException();
2072:                    }
2073:                }
2074:            }
2075:
2076:            final public String classReference() throws ParseException {
2077:                String result = "java.lang.Math";
2078:                jj_consume_token(56);
2079:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2080:                case IDENT:
2081:                    result = className();
2082:                    break;
2083:                default:
2084:                    jj_la1[53] = jj_gen;
2085:                    ;
2086:                }
2087:                jj_consume_token(56);
2088:                {
2089:                    if (true)
2090:                        return result;
2091:                }
2092:                throw new Error("Missing return statement in function");
2093:            }
2094:
2095:            final public String className() throws ParseException {
2096:                Token t;
2097:                StringBuffer result;
2098:                t = jj_consume_token(IDENT);
2099:                result = new StringBuffer(t.image);
2100:                label_16: while (true) {
2101:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2102:                    case 43:
2103:                        ;
2104:                        break;
2105:                    default:
2106:                        jj_la1[54] = jj_gen;
2107:                        break label_16;
2108:                    }
2109:                    jj_consume_token(43);
2110:                    t = jj_consume_token(IDENT);
2111:                    result.append('.').append(t.image);
2112:                }
2113:                {
2114:                    if (true)
2115:                        return new String(result);
2116:                }
2117:                throw new Error("Missing return statement in function");
2118:            }
2119:
2120:            final public void constructorCall() throws ParseException {
2121:                /*@bgen(jjtree) Ctor */
2122:                ASTCtor jjtn000 = new ASTCtor(JJTCTOR);
2123:                boolean jjtc000 = true;
2124:                jjtree.openNodeScope(jjtn000);
2125:                String className;
2126:                Token t;
2127:                StringBuffer sb;
2128:                try {
2129:                    jj_consume_token(57);
2130:                    className = className();
2131:                    if (jj_2_11(2)) {
2132:                        jj_consume_token(44);
2133:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2134:                        case 4:
2135:                        case 28:
2136:                        case 35:
2137:                        case 36:
2138:                        case 40:
2139:                        case 41:
2140:                        case 44:
2141:                        case 46:
2142:                        case 47:
2143:                        case 48:
2144:                        case 49:
2145:                        case 50:
2146:                        case 51:
2147:                        case 52:
2148:                        case 54:
2149:                        case 56:
2150:                        case 57:
2151:                        case IDENT:
2152:                        case DYNAMIC_SUBSCRIPT:
2153:                        case CHAR_LITERAL:
2154:                        case BACK_CHAR_LITERAL:
2155:                        case STRING_LITERAL:
2156:                        case INT_LITERAL:
2157:                        case FLT_LITERAL:
2158:                            assignmentExpression();
2159:                            label_17: while (true) {
2160:                                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2161:                                case 1:
2162:                                    ;
2163:                                    break;
2164:                                default:
2165:                                    jj_la1[55] = jj_gen;
2166:                                    break label_17;
2167:                                }
2168:                                jj_consume_token(1);
2169:                                assignmentExpression();
2170:                            }
2171:                            break;
2172:                        default:
2173:                            jj_la1[56] = jj_gen;
2174:                            ;
2175:                        }
2176:                        jj_consume_token(45);
2177:                        jjtree.closeNodeScope(jjtn000, true);
2178:                        jjtc000 = false;
2179:                        jjtn000.setClassName(className);
2180:                    } else if (jj_2_12(2)) {
2181:                        jj_consume_token(52);
2182:                        jj_consume_token(53);
2183:                        jj_consume_token(54);
2184:                        ASTList jjtn001 = new ASTList(JJTLIST);
2185:                        boolean jjtc001 = true;
2186:                        jjtree.openNodeScope(jjtn001);
2187:                        try {
2188:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2189:                            case 4:
2190:                            case 28:
2191:                            case 35:
2192:                            case 36:
2193:                            case 40:
2194:                            case 41:
2195:                            case 44:
2196:                            case 46:
2197:                            case 47:
2198:                            case 48:
2199:                            case 49:
2200:                            case 50:
2201:                            case 51:
2202:                            case 52:
2203:                            case 54:
2204:                            case 56:
2205:                            case 57:
2206:                            case IDENT:
2207:                            case DYNAMIC_SUBSCRIPT:
2208:                            case CHAR_LITERAL:
2209:                            case BACK_CHAR_LITERAL:
2210:                            case STRING_LITERAL:
2211:                            case INT_LITERAL:
2212:                            case FLT_LITERAL:
2213:                                assignmentExpression();
2214:                                label_18: while (true) {
2215:                                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2216:                                    case 1:
2217:                                        ;
2218:                                        break;
2219:                                    default:
2220:                                        jj_la1[57] = jj_gen;
2221:                                        break label_18;
2222:                                    }
2223:                                    jj_consume_token(1);
2224:                                    assignmentExpression();
2225:                                }
2226:                                break;
2227:                            default:
2228:                                jj_la1[58] = jj_gen;
2229:                                ;
2230:                            }
2231:                        } catch (Throwable jjte001) {
2232:                            if (jjtc001) {
2233:                                jjtree.clearNodeScope(jjtn001);
2234:                                jjtc001 = false;
2235:                            } else {
2236:                                jjtree.popNode();
2237:                            }
2238:                            if (jjte001 instanceof  RuntimeException) {
2239:                                {
2240:                                    if (true)
2241:                                        throw (RuntimeException) jjte001;
2242:                                }
2243:                            }
2244:                            if (jjte001 instanceof  ParseException) {
2245:                                {
2246:                                    if (true)
2247:                                        throw (ParseException) jjte001;
2248:                                }
2249:                            }
2250:                            {
2251:                                if (true)
2252:                                    throw (Error) jjte001;
2253:                            }
2254:                        } finally {
2255:                            if (jjtc001) {
2256:                                jjtree.closeNodeScope(jjtn001, true);
2257:                            }
2258:                        }
2259:                        jj_consume_token(55);
2260:                        jjtree.closeNodeScope(jjtn000, true);
2261:                        jjtc000 = false;
2262:                        jjtn000.setClassName(className);
2263:                        jjtn000.setArray(true);
2264:                    } else if (jj_2_13(2)) {
2265:                        jj_consume_token(52);
2266:                        assignmentExpression();
2267:                        jj_consume_token(53);
2268:                        jjtree.closeNodeScope(jjtn000, true);
2269:                        jjtc000 = false;
2270:                        jjtn000.setClassName(className);
2271:                        jjtn000.setArray(true);
2272:                    } else {
2273:                        jj_consume_token(-1);
2274:                        throw new ParseException();
2275:                    }
2276:                } catch (Throwable jjte000) {
2277:                    if (jjtc000) {
2278:                        jjtree.clearNodeScope(jjtn000);
2279:                        jjtc000 = false;
2280:                    } else {
2281:                        jjtree.popNode();
2282:                    }
2283:                    if (jjte000 instanceof  RuntimeException) {
2284:                        {
2285:                            if (true)
2286:                                throw (RuntimeException) jjte000;
2287:                        }
2288:                    }
2289:                    if (jjte000 instanceof  ParseException) {
2290:                        {
2291:                            if (true)
2292:                                throw (ParseException) jjte000;
2293:                        }
2294:                    }
2295:                    {
2296:                        if (true)
2297:                            throw (Error) jjte000;
2298:                    }
2299:                } finally {
2300:                    if (jjtc000) {
2301:                        jjtree.closeNodeScope(jjtn000, true);
2302:                    }
2303:                }
2304:            }
2305:
2306:            final public void propertyName() throws ParseException {
2307:                /*@bgen(jjtree) Property */
2308:                ASTProperty jjtn000 = new ASTProperty(JJTPROPERTY);
2309:                boolean jjtc000 = true;
2310:                jjtree.openNodeScope(jjtn000);
2311:                Token t;
2312:                try {
2313:                    t = jj_consume_token(IDENT);
2314:                    ASTConst jjtn001 = new ASTConst(JJTCONST);
2315:                    boolean jjtc001 = true;
2316:                    jjtree.openNodeScope(jjtn001);
2317:                    try {
2318:                        jjtree.closeNodeScope(jjtn001, true);
2319:                        jjtc001 = false;
2320:                        jjtn001.setValue(t.image);
2321:                    } finally {
2322:                        if (jjtc001) {
2323:                            jjtree.closeNodeScope(jjtn001, true);
2324:                        }
2325:                    }
2326:                } finally {
2327:                    if (jjtc000) {
2328:                        jjtree.closeNodeScope(jjtn000, true);
2329:                    }
2330:                }
2331:            }
2332:
2333:            final public void staticMethodCall(String className)
2334:                    throws ParseException {
2335:                /*@bgen(jjtree) StaticMethod */
2336:                ASTStaticMethod jjtn000 = new ASTStaticMethod(JJTSTATICMETHOD);
2337:                boolean jjtc000 = true;
2338:                jjtree.openNodeScope(jjtn000);
2339:                Token t;
2340:                try {
2341:                    t = jj_consume_token(IDENT);
2342:                    jj_consume_token(44);
2343:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2344:                    case 4:
2345:                    case 28:
2346:                    case 35:
2347:                    case 36:
2348:                    case 40:
2349:                    case 41:
2350:                    case 44:
2351:                    case 46:
2352:                    case 47:
2353:                    case 48:
2354:                    case 49:
2355:                    case 50:
2356:                    case 51:
2357:                    case 52:
2358:                    case 54:
2359:                    case 56:
2360:                    case 57:
2361:                    case IDENT:
2362:                    case DYNAMIC_SUBSCRIPT:
2363:                    case CHAR_LITERAL:
2364:                    case BACK_CHAR_LITERAL:
2365:                    case STRING_LITERAL:
2366:                    case INT_LITERAL:
2367:                    case FLT_LITERAL:
2368:                        assignmentExpression();
2369:                        label_19: while (true) {
2370:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2371:                            case 1:
2372:                                ;
2373:                                break;
2374:                            default:
2375:                                jj_la1[59] = jj_gen;
2376:                                break label_19;
2377:                            }
2378:                            jj_consume_token(1);
2379:                            assignmentExpression();
2380:                        }
2381:                        break;
2382:                    default:
2383:                        jj_la1[60] = jj_gen;
2384:                        ;
2385:                    }
2386:                    jj_consume_token(45);
2387:                    jjtree.closeNodeScope(jjtn000, true);
2388:                    jjtc000 = false;
2389:                    jjtn000.init(className, t.image);
2390:                } catch (Throwable jjte000) {
2391:                    if (jjtc000) {
2392:                        jjtree.clearNodeScope(jjtn000);
2393:                        jjtc000 = false;
2394:                    } else {
2395:                        jjtree.popNode();
2396:                    }
2397:                    if (jjte000 instanceof  RuntimeException) {
2398:                        {
2399:                            if (true)
2400:                                throw (RuntimeException) jjte000;
2401:                        }
2402:                    }
2403:                    if (jjte000 instanceof  ParseException) {
2404:                        {
2405:                            if (true)
2406:                                throw (ParseException) jjte000;
2407:                        }
2408:                    }
2409:                    {
2410:                        if (true)
2411:                            throw (Error) jjte000;
2412:                    }
2413:                } finally {
2414:                    if (jjtc000) {
2415:                        jjtree.closeNodeScope(jjtn000, true);
2416:                    }
2417:                }
2418:            }
2419:
2420:            final public void methodCall() throws ParseException {
2421:                /*@bgen(jjtree) Method */
2422:                ASTMethod jjtn000 = new ASTMethod(JJTMETHOD);
2423:                boolean jjtc000 = true;
2424:                jjtree.openNodeScope(jjtn000);
2425:                Token t;
2426:                try {
2427:                    t = jj_consume_token(IDENT);
2428:                    jj_consume_token(44);
2429:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2430:                    case 4:
2431:                    case 28:
2432:                    case 35:
2433:                    case 36:
2434:                    case 40:
2435:                    case 41:
2436:                    case 44:
2437:                    case 46:
2438:                    case 47:
2439:                    case 48:
2440:                    case 49:
2441:                    case 50:
2442:                    case 51:
2443:                    case 52:
2444:                    case 54:
2445:                    case 56:
2446:                    case 57:
2447:                    case IDENT:
2448:                    case DYNAMIC_SUBSCRIPT:
2449:                    case CHAR_LITERAL:
2450:                    case BACK_CHAR_LITERAL:
2451:                    case STRING_LITERAL:
2452:                    case INT_LITERAL:
2453:                    case FLT_LITERAL:
2454:                        assignmentExpression();
2455:                        label_20: while (true) {
2456:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2457:                            case 1:
2458:                                ;
2459:                                break;
2460:                            default:
2461:                                jj_la1[61] = jj_gen;
2462:                                break label_20;
2463:                            }
2464:                            jj_consume_token(1);
2465:                            assignmentExpression();
2466:                        }
2467:                        break;
2468:                    default:
2469:                        jj_la1[62] = jj_gen;
2470:                        ;
2471:                    }
2472:                    jj_consume_token(45);
2473:                    jjtree.closeNodeScope(jjtn000, true);
2474:                    jjtc000 = false;
2475:                    jjtn000.setMethodName(t.image);
2476:                } catch (Throwable jjte000) {
2477:                    if (jjtc000) {
2478:                        jjtree.clearNodeScope(jjtn000);
2479:                        jjtc000 = false;
2480:                    } else {
2481:                        jjtree.popNode();
2482:                    }
2483:                    if (jjte000 instanceof  RuntimeException) {
2484:                        {
2485:                            if (true)
2486:                                throw (RuntimeException) jjte000;
2487:                        }
2488:                    }
2489:                    if (jjte000 instanceof  ParseException) {
2490:                        {
2491:                            if (true)
2492:                                throw (ParseException) jjte000;
2493:                        }
2494:                    }
2495:                    {
2496:                        if (true)
2497:                            throw (Error) jjte000;
2498:                    }
2499:                } finally {
2500:                    if (jjtc000) {
2501:                        jjtree.closeNodeScope(jjtn000, true);
2502:                    }
2503:                }
2504:            }
2505:
2506:            /**
2507:             * Apply an expression to all elements of a collection, creating a new collection
2508:             * as the result.
2509:             */
2510:            final public void projection() throws ParseException {
2511:                /*@bgen(jjtree) Project */
2512:                ASTProject jjtn000 = new ASTProject(JJTPROJECT);
2513:                boolean jjtc000 = true;
2514:                jjtree.openNodeScope(jjtn000);
2515:                try {
2516:                    jj_consume_token(54);
2517:                    expression();
2518:                    jj_consume_token(55);
2519:                } catch (Throwable jjte000) {
2520:                    if (jjtc000) {
2521:                        jjtree.clearNodeScope(jjtn000);
2522:                        jjtc000 = false;
2523:                    } else {
2524:                        jjtree.popNode();
2525:                    }
2526:                    if (jjte000 instanceof  RuntimeException) {
2527:                        {
2528:                            if (true)
2529:                                throw (RuntimeException) jjte000;
2530:                        }
2531:                    }
2532:                    if (jjte000 instanceof  ParseException) {
2533:                        {
2534:                            if (true)
2535:                                throw (ParseException) jjte000;
2536:                        }
2537:                    }
2538:                    {
2539:                        if (true)
2540:                            throw (Error) jjte000;
2541:                    }
2542:                } finally {
2543:                    if (jjtc000) {
2544:                        jjtree.closeNodeScope(jjtn000, true);
2545:                    }
2546:                }
2547:            }
2548:
2549:            final public void selection() throws ParseException {
2550:                if (jj_2_14(2)) {
2551:                    selectAll();
2552:                } else if (jj_2_15(2)) {
2553:                    selectFirst();
2554:                } else if (jj_2_16(2)) {
2555:                    selectLast();
2556:                } else {
2557:                    jj_consume_token(-1);
2558:                    throw new ParseException();
2559:                }
2560:            }
2561:
2562:            /**
2563:             * Apply a boolean expression to all elements of a collection, creating a new collection
2564:             * containing those elements for which the expression returned true.
2565:             */
2566:            final public void selectAll() throws ParseException {
2567:                /*@bgen(jjtree) Select */
2568:                ASTSelect jjtn000 = new ASTSelect(JJTSELECT);
2569:                boolean jjtc000 = true;
2570:                jjtree.openNodeScope(jjtn000);
2571:                try {
2572:                    jj_consume_token(54);
2573:                    jj_consume_token(3);
2574:                    expression();
2575:                    jj_consume_token(55);
2576:                } catch (Throwable jjte000) {
2577:                    if (jjtc000) {
2578:                        jjtree.clearNodeScope(jjtn000);
2579:                        jjtc000 = false;
2580:                    } else {
2581:                        jjtree.popNode();
2582:                    }
2583:                    if (jjte000 instanceof  RuntimeException) {
2584:                        {
2585:                            if (true)
2586:                                throw (RuntimeException) jjte000;
2587:                        }
2588:                    }
2589:                    if (jjte000 instanceof  ParseException) {
2590:                        {
2591:                            if (true)
2592:                                throw (ParseException) jjte000;
2593:                        }
2594:                    }
2595:                    {
2596:                        if (true)
2597:                            throw (Error) jjte000;
2598:                    }
2599:                } finally {
2600:                    if (jjtc000) {
2601:                        jjtree.closeNodeScope(jjtn000, true);
2602:                    }
2603:                }
2604:            }
2605:
2606:            /**
2607:             * Apply a boolean expression to all elements of a collection, creating a new collection
2608:             * containing those elements for the first element for which the expression returned true.
2609:             */
2610:            final public void selectFirst() throws ParseException {
2611:                /*@bgen(jjtree) SelectFirst */
2612:                ASTSelectFirst jjtn000 = new ASTSelectFirst(JJTSELECTFIRST);
2613:                boolean jjtc000 = true;
2614:                jjtree.openNodeScope(jjtn000);
2615:                try {
2616:                    jj_consume_token(54);
2617:                    jj_consume_token(11);
2618:                    expression();
2619:                    jj_consume_token(55);
2620:                } catch (Throwable jjte000) {
2621:                    if (jjtc000) {
2622:                        jjtree.clearNodeScope(jjtn000);
2623:                        jjtc000 = false;
2624:                    } else {
2625:                        jjtree.popNode();
2626:                    }
2627:                    if (jjte000 instanceof  RuntimeException) {
2628:                        {
2629:                            if (true)
2630:                                throw (RuntimeException) jjte000;
2631:                        }
2632:                    }
2633:                    if (jjte000 instanceof  ParseException) {
2634:                        {
2635:                            if (true)
2636:                                throw (ParseException) jjte000;
2637:                        }
2638:                    }
2639:                    {
2640:                        if (true)
2641:                            throw (Error) jjte000;
2642:                    }
2643:                } finally {
2644:                    if (jjtc000) {
2645:                        jjtree.closeNodeScope(jjtn000, true);
2646:                    }
2647:                }
2648:            }
2649:
2650:            /**
2651:             * Apply a boolean expression to all elements of a collection, creating a new collection
2652:             * containing those elements for the first element for which the expression returned true.
2653:             */
2654:            final public void selectLast() throws ParseException {
2655:                /*@bgen(jjtree) SelectLast */
2656:                ASTSelectLast jjtn000 = new ASTSelectLast(JJTSELECTLAST);
2657:                boolean jjtc000 = true;
2658:                jjtree.openNodeScope(jjtn000);
2659:                try {
2660:                    jj_consume_token(54);
2661:                    jj_consume_token(58);
2662:                    expression();
2663:                    jj_consume_token(55);
2664:                } catch (Throwable jjte000) {
2665:                    if (jjtc000) {
2666:                        jjtree.clearNodeScope(jjtn000);
2667:                        jjtc000 = false;
2668:                    } else {
2669:                        jjtree.popNode();
2670:                    }
2671:                    if (jjte000 instanceof  RuntimeException) {
2672:                        {
2673:                            if (true)
2674:                                throw (RuntimeException) jjte000;
2675:                        }
2676:                    }
2677:                    if (jjte000 instanceof  ParseException) {
2678:                        {
2679:                            if (true)
2680:                                throw (ParseException) jjte000;
2681:                        }
2682:                    }
2683:                    {
2684:                        if (true)
2685:                            throw (Error) jjte000;
2686:                    }
2687:                } finally {
2688:                    if (jjtc000) {
2689:                        jjtree.closeNodeScope(jjtn000, true);
2690:                    }
2691:                }
2692:            }
2693:
2694:            final public void index() throws ParseException {
2695:                /*@bgen(jjtree) Property */
2696:                ASTProperty jjtn000 = new ASTProperty(JJTPROPERTY);
2697:                boolean jjtc000 = true;
2698:                jjtree.openNodeScope(jjtn000);
2699:                try {
2700:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2701:                    case 52:
2702:                        jj_consume_token(52);
2703:                        expression();
2704:                        jj_consume_token(53);
2705:                        jjtree.closeNodeScope(jjtn000, true);
2706:                        jjtc000 = false;
2707:                        jjtn000.setIndexedAccess(true);
2708:                        break;
2709:                    case DYNAMIC_SUBSCRIPT:
2710:                        jj_consume_token(DYNAMIC_SUBSCRIPT);
2711:                        ASTConst jjtn001 = new ASTConst(JJTCONST);
2712:                        boolean jjtc001 = true;
2713:                        jjtree.openNodeScope(jjtn001);
2714:                        try {
2715:                            jjtree.closeNodeScope(jjtn001, true);
2716:                            jjtc001 = false;
2717:                            jjtn001.setValue(token_source.literalValue);
2718:                        } finally {
2719:                            if (jjtc001) {
2720:                                jjtree.closeNodeScope(jjtn001, true);
2721:                            }
2722:                        }
2723:                        jjtree.closeNodeScope(jjtn000, true);
2724:                        jjtc000 = false;
2725:                        jjtn000.setIndexedAccess(true);
2726:                        break;
2727:                    default:
2728:                        jj_la1[63] = jj_gen;
2729:                        jj_consume_token(-1);
2730:                        throw new ParseException();
2731:                    }
2732:                } catch (Throwable jjte000) {
2733:                    if (jjtc000) {
2734:                        jjtree.clearNodeScope(jjtn000);
2735:                        jjtc000 = false;
2736:                    } else {
2737:                        jjtree.popNode();
2738:                    }
2739:                    if (jjte000 instanceof  RuntimeException) {
2740:                        {
2741:                            if (true)
2742:                                throw (RuntimeException) jjte000;
2743:                        }
2744:                    }
2745:                    if (jjte000 instanceof  ParseException) {
2746:                        {
2747:                            if (true)
2748:                                throw (ParseException) jjte000;
2749:                        }
2750:                    }
2751:                    {
2752:                        if (true)
2753:                            throw (Error) jjte000;
2754:                    }
2755:                } finally {
2756:                    if (jjtc000) {
2757:                        jjtree.closeNodeScope(jjtn000, true);
2758:                    }
2759:                }
2760:            }
2761:
2762:            final private boolean jj_2_1(int xla) {
2763:                jj_la = xla;
2764:                jj_lastpos = jj_scanpos = token;
2765:                try {
2766:                    return !jj_3_1();
2767:                } catch (LookaheadSuccess ls) {
2768:                    return true;
2769:                } finally {
2770:                    jj_save(0, xla);
2771:                }
2772:            }
2773:
2774:            final private boolean jj_2_2(int xla) {
2775:                jj_la = xla;
2776:                jj_lastpos = jj_scanpos = token;
2777:                try {
2778:                    return !jj_3_2();
2779:                } catch (LookaheadSuccess ls) {
2780:                    return true;
2781:                } finally {
2782:                    jj_save(1, xla);
2783:                }
2784:            }
2785:
2786:            final private boolean jj_2_3(int xla) {
2787:                jj_la = xla;
2788:                jj_lastpos = jj_scanpos = token;
2789:                try {
2790:                    return !jj_3_3();
2791:                } catch (LookaheadSuccess ls) {
2792:                    return true;
2793:                } finally {
2794:                    jj_save(2, xla);
2795:                }
2796:            }
2797:
2798:            final private boolean jj_2_4(int xla) {
2799:                jj_la = xla;
2800:                jj_lastpos = jj_scanpos = token;
2801:                try {
2802:                    return !jj_3_4();
2803:                } catch (LookaheadSuccess ls) {
2804:                    return true;
2805:                } finally {
2806:                    jj_save(3, xla);
2807:                }
2808:            }
2809:
2810:            final private boolean jj_2_5(int xla) {
2811:                jj_la = xla;
2812:                jj_lastpos = jj_scanpos = token;
2813:                try {
2814:                    return !jj_3_5();
2815:                } catch (LookaheadSuccess ls) {
2816:                    return true;
2817:                } finally {
2818:                    jj_save(4, xla);
2819:                }
2820:            }
2821:
2822:            final private boolean jj_2_6(int xla) {
2823:                jj_la = xla;
2824:                jj_lastpos = jj_scanpos = token;
2825:                try {
2826:                    return !jj_3_6();
2827:                } catch (LookaheadSuccess ls) {
2828:                    return true;
2829:                } finally {
2830:                    jj_save(5, xla);
2831:                }
2832:            }
2833:
2834:            final private boolean jj_2_7(int xla) {
2835:                jj_la = xla;
2836:                jj_lastpos = jj_scanpos = token;
2837:                try {
2838:                    return !jj_3_7();
2839:                } catch (LookaheadSuccess ls) {
2840:                    return true;
2841:                } finally {
2842:                    jj_save(6, xla);
2843:                }
2844:            }
2845:
2846:            final private boolean jj_2_8(int xla) {
2847:                jj_la = xla;
2848:                jj_lastpos = jj_scanpos = token;
2849:                try {
2850:                    return !jj_3_8();
2851:                } catch (LookaheadSuccess ls) {
2852:                    return true;
2853:                } finally {
2854:                    jj_save(7, xla);
2855:                }
2856:            }
2857:
2858:            final private boolean jj_2_9(int xla) {
2859:                jj_la = xla;
2860:                jj_lastpos = jj_scanpos = token;
2861:                try {
2862:                    return !jj_3_9();
2863:                } catch (LookaheadSuccess ls) {
2864:                    return true;
2865:                } finally {
2866:                    jj_save(8, xla);
2867:                }
2868:            }
2869:
2870:            final private boolean jj_2_10(int xla) {
2871:                jj_la = xla;
2872:                jj_lastpos = jj_scanpos = token;
2873:                try {
2874:                    return !jj_3_10();
2875:                } catch (LookaheadSuccess ls) {
2876:                    return true;
2877:                } finally {
2878:                    jj_save(9, xla);
2879:                }
2880:            }
2881:
2882:            final private boolean jj_2_11(int xla) {
2883:                jj_la = xla;
2884:                jj_lastpos = jj_scanpos = token;
2885:                try {
2886:                    return !jj_3_11();
2887:                } catch (LookaheadSuccess ls) {
2888:                    return true;
2889:                } finally {
2890:                    jj_save(10, xla);
2891:                }
2892:            }
2893:
2894:            final private boolean jj_2_12(int xla) {
2895:                jj_la = xla;
2896:                jj_lastpos = jj_scanpos = token;
2897:                try {
2898:                    return !jj_3_12();
2899:                } catch (LookaheadSuccess ls) {
2900:                    return true;
2901:                } finally {
2902:                    jj_save(11, xla);
2903:                }
2904:            }
2905:
2906:            final private boolean jj_2_13(int xla) {
2907:                jj_la = xla;
2908:                jj_lastpos = jj_scanpos = token;
2909:                try {
2910:                    return !jj_3_13();
2911:                } catch (LookaheadSuccess ls) {
2912:                    return true;
2913:                } finally {
2914:                    jj_save(12, xla);
2915:                }
2916:            }
2917:
2918:            final private boolean jj_2_14(int xla) {
2919:                jj_la = xla;
2920:                jj_lastpos = jj_scanpos = token;
2921:                try {
2922:                    return !jj_3_14();
2923:                } catch (LookaheadSuccess ls) {
2924:                    return true;
2925:                } finally {
2926:                    jj_save(13, xla);
2927:                }
2928:            }
2929:
2930:            final private boolean jj_2_15(int xla) {
2931:                jj_la = xla;
2932:                jj_lastpos = jj_scanpos = token;
2933:                try {
2934:                    return !jj_3_15();
2935:                } catch (LookaheadSuccess ls) {
2936:                    return true;
2937:                } finally {
2938:                    jj_save(14, xla);
2939:                }
2940:            }
2941:
2942:            final private boolean jj_2_16(int xla) {
2943:                jj_la = xla;
2944:                jj_lastpos = jj_scanpos = token;
2945:                try {
2946:                    return !jj_3_16();
2947:                } catch (LookaheadSuccess ls) {
2948:                    return true;
2949:                } finally {
2950:                    jj_save(15, xla);
2951:                }
2952:            }
2953:
2954:            final private boolean jj_3_5() {
2955:                if (jj_scan_token(50))
2956:                    return true;
2957:                return false;
2958:            }
2959:
2960:            final private boolean jj_3_4() {
2961:                if (jj_scan_token(49))
2962:                    return true;
2963:                return false;
2964:            }
2965:
2966:            final private boolean jj_3R_27() {
2967:                if (jj_3R_34())
2968:                    return true;
2969:                return false;
2970:            }
2971:
2972:            final private boolean jj_3R_65() {
2973:                if (jj_scan_token(IDENT))
2974:                    return true;
2975:                return false;
2976:            }
2977:
2978:            final private boolean jj_3R_43() {
2979:                if (jj_3R_44())
2980:                    return true;
2981:                return false;
2982:            }
2983:
2984:            final private boolean jj_3R_56() {
2985:                if (jj_scan_token(48))
2986:                    return true;
2987:                return false;
2988:            }
2989:
2990:            final private boolean jj_3R_55() {
2991:                if (jj_scan_token(47))
2992:                    return true;
2993:                return false;
2994:            }
2995:
2996:            final private boolean jj_3R_54() {
2997:                if (jj_scan_token(46))
2998:                    return true;
2999:                return false;
3000:            }
3001:
3002:            final private boolean jj_3R_31() {
3003:                if (jj_3R_27())
3004:                    return true;
3005:                return false;
3006:            }
3007:
3008:            final private boolean jj_3_13() {
3009:                if (jj_scan_token(52))
3010:                    return true;
3011:                if (jj_3R_27())
3012:                    return true;
3013:                return false;
3014:            }
3015:
3016:            final private boolean jj_3R_53() {
3017:                Token xsp;
3018:                xsp = jj_scanpos;
3019:                if (jj_scan_token(73)) {
3020:                    jj_scanpos = xsp;
3021:                    if (jj_scan_token(76)) {
3022:                        jj_scanpos = xsp;
3023:                        if (jj_scan_token(79)) {
3024:                            jj_scanpos = xsp;
3025:                            if (jj_scan_token(80)) {
3026:                                jj_scanpos = xsp;
3027:                                if (jj_scan_token(81))
3028:                                    return true;
3029:                            }
3030:                        }
3031:                    }
3032:                }
3033:                return false;
3034:            }
3035:
3036:            final private boolean jj_3R_26() {
3037:                if (jj_3R_27())
3038:                    return true;
3039:                return false;
3040:            }
3041:
3042:            final private boolean jj_3R_52() {
3043:                Token xsp;
3044:                xsp = jj_scanpos;
3045:                if (jj_3R_53()) {
3046:                    jj_scanpos = xsp;
3047:                    if (jj_3R_54()) {
3048:                        jj_scanpos = xsp;
3049:                        if (jj_3R_55()) {
3050:                            jj_scanpos = xsp;
3051:                            if (jj_3R_56()) {
3052:                                jj_scanpos = xsp;
3053:                                if (jj_3_4()) {
3054:                                    jj_scanpos = xsp;
3055:                                    if (jj_3_5()) {
3056:                                        jj_scanpos = xsp;
3057:                                        if (jj_3_6()) {
3058:                                            jj_scanpos = xsp;
3059:                                            if (jj_3_7()) {
3060:                                                jj_scanpos = xsp;
3061:                                                if (jj_3R_57()) {
3062:                                                    jj_scanpos = xsp;
3063:                                                    if (jj_3_8()) {
3064:                                                        jj_scanpos = xsp;
3065:                                                        if (jj_3R_58()) {
3066:                                                            jj_scanpos = xsp;
3067:                                                            if (jj_3R_59()) {
3068:                                                                jj_scanpos = xsp;
3069:                                                                if (jj_3R_60()) {
3070:                                                                    jj_scanpos = xsp;
3071:                                                                    if (jj_3R_61()) {
3072:                                                                        jj_scanpos = xsp;
3073:                                                                        if (jj_3_9())
3074:                                                                            return true;
3075:                                                                    }
3076:                                                                }
3077:                                                            }
3078:                                                        }
3079:                                                    }
3080:                                                }
3081:                                            }
3082:                                        }
3083:                                    }
3084:                                }
3085:                            }
3086:                        }
3087:                    }
3088:                }
3089:                return false;
3090:            }
3091:
3092:            final private boolean jj_3R_42() {
3093:                if (jj_3R_43())
3094:                    return true;
3095:                return false;
3096:            }
3097:
3098:            final private boolean jj_3_12() {
3099:                if (jj_scan_token(52))
3100:                    return true;
3101:                if (jj_scan_token(53))
3102:                    return true;
3103:                return false;
3104:            }
3105:
3106:            final private boolean jj_3_11() {
3107:                if (jj_scan_token(44))
3108:                    return true;
3109:                Token xsp;
3110:                xsp = jj_scanpos;
3111:                if (jj_3R_26())
3112:                    jj_scanpos = xsp;
3113:                if (jj_scan_token(45))
3114:                    return true;
3115:                return false;
3116:            }
3117:
3118:            final private boolean jj_3R_67() {
3119:                if (jj_scan_token(DYNAMIC_SUBSCRIPT))
3120:                    return true;
3121:                return false;
3122:            }
3123:
3124:            final private boolean jj_3_2() {
3125:                if (jj_3R_22())
3126:                    return true;
3127:                return false;
3128:            }
3129:
3130:            final private boolean jj_3R_66() {
3131:                if (jj_scan_token(52))
3132:                    return true;
3133:                return false;
3134:            }
3135:
3136:            final private boolean jj_3R_64() {
3137:                Token xsp;
3138:                xsp = jj_scanpos;
3139:                if (jj_3R_66()) {
3140:                    jj_scanpos = xsp;
3141:                    if (jj_3R_67())
3142:                        return true;
3143:                }
3144:                return false;
3145:            }
3146:
3147:            final private boolean jj_3_1() {
3148:                if (jj_3R_21())
3149:                    return true;
3150:                return false;
3151:            }
3152:
3153:            final private boolean jj_3R_23() {
3154:                if (jj_scan_token(57))
3155:                    return true;
3156:                if (jj_3R_32())
3157:                    return true;
3158:                return false;
3159:            }
3160:
3161:            final private boolean jj_3R_41() {
3162:                if (jj_3R_42())
3163:                    return true;
3164:                return false;
3165:            }
3166:
3167:            final private boolean jj_3R_30() {
3168:                if (jj_scan_token(54))
3169:                    return true;
3170:                if (jj_scan_token(58))
3171:                    return true;
3172:                return false;
3173:            }
3174:
3175:            final private boolean jj_3R_32() {
3176:                if (jj_scan_token(IDENT))
3177:                    return true;
3178:                return false;
3179:            }
3180:
3181:            final private boolean jj_3R_51() {
3182:                if (jj_3R_52())
3183:                    return true;
3184:                return false;
3185:            }
3186:
3187:            final private boolean jj_3R_29() {
3188:                if (jj_scan_token(54))
3189:                    return true;
3190:                if (jj_scan_token(11))
3191:                    return true;
3192:                return false;
3193:            }
3194:
3195:            final private boolean jj_3R_40() {
3196:                if (jj_3R_41())
3197:                    return true;
3198:                return false;
3199:            }
3200:
3201:            final private boolean jj_3R_33() {
3202:                if (jj_scan_token(56))
3203:                    return true;
3204:                return false;
3205:            }
3206:
3207:            final private boolean jj_3R_63() {
3208:                if (jj_3R_65())
3209:                    return true;
3210:                return false;
3211:            }
3212:
3213:            final private boolean jj_3R_28() {
3214:                if (jj_scan_token(54))
3215:                    return true;
3216:                if (jj_scan_token(3))
3217:                    return true;
3218:                return false;
3219:            }
3220:
3221:            final private boolean jj_3R_50() {
3222:                if (jj_3R_51())
3223:                    return true;
3224:                return false;
3225:            }
3226:
3227:            final private boolean jj_3R_39() {
3228:                if (jj_3R_40())
3229:                    return true;
3230:                return false;
3231:            }
3232:
3233:            final private boolean jj_3_10() {
3234:                if (jj_3R_25())
3235:                    return true;
3236:                return false;
3237:            }
3238:
3239:            final private boolean jj_3R_24() {
3240:                if (jj_3R_33())
3241:                    return true;
3242:                return false;
3243:            }
3244:
3245:            final private boolean jj_3R_49() {
3246:                Token xsp;
3247:                xsp = jj_scanpos;
3248:                if (jj_scan_token(41)) {
3249:                    jj_scanpos = xsp;
3250:                    if (jj_scan_token(28))
3251:                        return true;
3252:                }
3253:                return false;
3254:            }
3255:
3256:            final private boolean jj_3R_48() {
3257:                if (jj_scan_token(40))
3258:                    return true;
3259:                return false;
3260:            }
3261:
3262:            final private boolean jj_3_16() {
3263:                if (jj_3R_30())
3264:                    return true;
3265:                return false;
3266:            }
3267:
3268:            final private boolean jj_3R_47() {
3269:                if (jj_scan_token(35))
3270:                    return true;
3271:                return false;
3272:            }
3273:
3274:            final private boolean jj_3_15() {
3275:                if (jj_3R_29())
3276:                    return true;
3277:                return false;
3278:            }
3279:
3280:            final private boolean jj_3R_38() {
3281:                if (jj_3R_39())
3282:                    return true;
3283:                return false;
3284:            }
3285:
3286:            final private boolean jj_3R_46() {
3287:                if (jj_scan_token(36))
3288:                    return true;
3289:                return false;
3290:            }
3291:
3292:            final private boolean jj_3_14() {
3293:                if (jj_3R_28())
3294:                    return true;
3295:                return false;
3296:            }
3297:
3298:            final private boolean jj_3R_62() {
3299:                if (jj_3R_33())
3300:                    return true;
3301:                return false;
3302:            }
3303:
3304:            final private boolean jj_3R_45() {
3305:                Token xsp;
3306:                xsp = jj_scanpos;
3307:                if (jj_3R_46()) {
3308:                    jj_scanpos = xsp;
3309:                    if (jj_3R_47()) {
3310:                        jj_scanpos = xsp;
3311:                        if (jj_3R_48()) {
3312:                            jj_scanpos = xsp;
3313:                            if (jj_3R_49()) {
3314:                                jj_scanpos = xsp;
3315:                                if (jj_3R_50())
3316:                                    return true;
3317:                            }
3318:                        }
3319:                    }
3320:                }
3321:                return false;
3322:            }
3323:
3324:            final private boolean jj_3R_37() {
3325:                if (jj_3R_38())
3326:                    return true;
3327:                return false;
3328:            }
3329:
3330:            final private boolean jj_3R_22() {
3331:                if (jj_scan_token(54))
3332:                    return true;
3333:                if (jj_3R_31())
3334:                    return true;
3335:                return false;
3336:            }
3337:
3338:            final private boolean jj_3_9() {
3339:                if (jj_scan_token(51))
3340:                    return true;
3341:                Token xsp;
3342:                xsp = jj_scanpos;
3343:                if (jj_3R_24())
3344:                    jj_scanpos = xsp;
3345:                if (jj_scan_token(54))
3346:                    return true;
3347:                return false;
3348:            }
3349:
3350:            final private boolean jj_3R_36() {
3351:                if (jj_3R_37())
3352:                    return true;
3353:                return false;
3354:            }
3355:
3356:            final private boolean jj_3R_61() {
3357:                if (jj_scan_token(54))
3358:                    return true;
3359:                return false;
3360:            }
3361:
3362:            final private boolean jj_3R_60() {
3363:                if (jj_scan_token(44))
3364:                    return true;
3365:                return false;
3366:            }
3367:
3368:            final private boolean jj_3R_59() {
3369:                if (jj_3R_64())
3370:                    return true;
3371:                return false;
3372:            }
3373:
3374:            final private boolean jj_3_3() {
3375:                if (jj_3R_21())
3376:                    return true;
3377:                return false;
3378:            }
3379:
3380:            final private boolean jj_3R_21() {
3381:                if (jj_scan_token(IDENT))
3382:                    return true;
3383:                if (jj_scan_token(44))
3384:                    return true;
3385:                return false;
3386:            }
3387:
3388:            final private boolean jj_3R_58() {
3389:                Token xsp;
3390:                xsp = jj_scanpos;
3391:                if (jj_3_3()) {
3392:                    jj_scanpos = xsp;
3393:                    if (jj_3R_63())
3394:                        return true;
3395:                }
3396:                return false;
3397:            }
3398:
3399:            final private boolean jj_3R_35() {
3400:                if (jj_3R_36())
3401:                    return true;
3402:                return false;
3403:            }
3404:
3405:            final private boolean jj_3R_44() {
3406:                if (jj_3R_45())
3407:                    return true;
3408:                return false;
3409:            }
3410:
3411:            final private boolean jj_3_8() {
3412:                if (jj_3R_23())
3413:                    return true;
3414:                return false;
3415:            }
3416:
3417:            final private boolean jj_3R_57() {
3418:                if (jj_3R_62())
3419:                    return true;
3420:                return false;
3421:            }
3422:
3423:            final private boolean jj_3R_34() {
3424:                if (jj_3R_35())
3425:                    return true;
3426:                return false;
3427:            }
3428:
3429:            final private boolean jj_3_7() {
3430:                if (jj_scan_token(4))
3431:                    return true;
3432:                if (jj_scan_token(52))
3433:                    return true;
3434:                return false;
3435:            }
3436:
3437:            final private boolean jj_3R_25() {
3438:                if (jj_scan_token(IDENT))
3439:                    return true;
3440:                if (jj_scan_token(44))
3441:                    return true;
3442:                return false;
3443:            }
3444:
3445:            final private boolean jj_3_6() {
3446:                if (jj_scan_token(51))
3447:                    return true;
3448:                if (jj_scan_token(IDENT))
3449:                    return true;
3450:                return false;
3451:            }
3452:
3453:            public OgnlParserTokenManager token_source;
3454:            JavaCharStream jj_input_stream;
3455:            public Token token, jj_nt;
3456:            private int jj_ntk;
3457:            private Token jj_scanpos, jj_lastpos;
3458:            private int jj_la;
3459:            public boolean lookingAhead = false;
3460:            private boolean jj_semLA;
3461:            private int jj_gen;
3462:            final private int[] jj_la1 = new int[64];
3463:            static private int[] jj_la1_0;
3464:            static private int[] jj_la1_1;
3465:            static private int[] jj_la1_2;
3466:            static {
3467:                jj_la1_0();
3468:                jj_la1_1();
3469:                jj_la1_2();
3470:            }
3471:
3472:            private static void jj_la1_0() {
3473:                jj_la1_0 = new int[] { 0x2, 0x4, 0x8, 0x60, 0x60, 0x180, 0x180,
3474:                        0x600, 0x600, 0x1800, 0x1800, 0x6000, 0x6000, 0x78000,
3475:                        0x18000, 0x60000, 0x78000, 0x1ff80000, 0x180000,
3476:                        0x600000, 0x1800000, 0x6000000, 0x1ff80000, 0xe0000000,
3477:                        0x60000000, 0x80000000, 0x0, 0xe0000000, 0x0, 0x0, 0x0,
3478:                        0x0, 0x10000000, 0x0, 0x0, 0x10000010, 0x0, 0x0, 0x0,
3479:                        0x0, 0x0, 0x0, 0x0, 0x2, 0x10000010, 0x0, 0x2,
3480:                        0x10000010, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x2,
3481:                        0x10000010, 0x2, 0x10000010, 0x2, 0x10000010, 0x2,
3482:                        0x10000010, 0x0, };
3483:            }
3484:
3485:            private static void jj_la1_1() {
3486:                jj_la1_1 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3487:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3488:                        0x0, 0x0, 0x0, 0x0, 0x7, 0x0, 0x1, 0x6, 0x7, 0x18,
3489:                        0x18, 0xe0, 0xe0, 0x200, 0x800, 0x400, 0x35fd318,
3490:                        0x101800, 0x0, 0x400000, 0x401000, 0x101800, 0x0, 0x0,
3491:                        0x0, 0x35fd318, 0x1000000, 0x0, 0x35fd318, 0x1c000,
3492:                        0x1000000, 0x501000, 0x0, 0x0, 0x0, 0x800, 0x0,
3493:                        0x35fd318, 0x0, 0x35fd318, 0x0, 0x35fd318, 0x0,
3494:                        0x35fd318, 0x100000, };
3495:            }
3496:
3497:            private static void jj_la1_2() {
3498:                jj_la1_2 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3499:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3500:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3501:                        0x0, 0x0, 0x0, 0x0, 0x0, 0x39209, 0x8, 0x1, 0x0, 0x1,
3502:                        0x8, 0x39200, 0x1, 0x0, 0x39209, 0x0, 0x0, 0x39209,
3503:                        0x39200, 0x0, 0x9, 0x0, 0x1, 0x1, 0x0, 0x0, 0x39209,
3504:                        0x0, 0x39209, 0x0, 0x39209, 0x0, 0x39209, 0x8, };
3505:            }
3506:
3507:            final private JJCalls[] jj_2_rtns = new JJCalls[16];
3508:            private boolean jj_rescan = false;
3509:            private int jj_gc = 0;
3510:
3511:            public OgnlParser(java.io.InputStream stream) {
3512:                jj_input_stream = new JavaCharStream(stream, 1, 1);
3513:                token_source = new OgnlParserTokenManager(jj_input_stream);
3514:                token = new Token();
3515:                jj_ntk = -1;
3516:                jj_gen = 0;
3517:                for (int i = 0; i < 64; i++)
3518:                    jj_la1[i] = -1;
3519:                for (int i = 0; i < jj_2_rtns.length; i++)
3520:                    jj_2_rtns[i] = new JJCalls();
3521:            }
3522:
3523:            public void ReInit(java.io.InputStream stream) {
3524:                jj_input_stream.ReInit(stream, 1, 1);
3525:                token_source.ReInit(jj_input_stream);
3526:                token = new Token();
3527:                jj_ntk = -1;
3528:                jjtree.reset();
3529:                jj_gen = 0;
3530:                for (int i = 0; i < 64; i++)
3531:                    jj_la1[i] = -1;
3532:                for (int i = 0; i < jj_2_rtns.length; i++)
3533:                    jj_2_rtns[i] = new JJCalls();
3534:            }
3535:
3536:            public OgnlParser(java.io.Reader stream) {
3537:                jj_input_stream = new JavaCharStream(stream, 1, 1);
3538:                token_source = new OgnlParserTokenManager(jj_input_stream);
3539:                token = new Token();
3540:                jj_ntk = -1;
3541:                jj_gen = 0;
3542:                for (int i = 0; i < 64; i++)
3543:                    jj_la1[i] = -1;
3544:                for (int i = 0; i < jj_2_rtns.length; i++)
3545:                    jj_2_rtns[i] = new JJCalls();
3546:            }
3547:
3548:            public void ReInit(java.io.Reader stream) {
3549:                jj_input_stream.ReInit(stream, 1, 1);
3550:                token_source.ReInit(jj_input_stream);
3551:                token = new Token();
3552:                jj_ntk = -1;
3553:                jjtree.reset();
3554:                jj_gen = 0;
3555:                for (int i = 0; i < 64; i++)
3556:                    jj_la1[i] = -1;
3557:                for (int i = 0; i < jj_2_rtns.length; i++)
3558:                    jj_2_rtns[i] = new JJCalls();
3559:            }
3560:
3561:            public OgnlParser(OgnlParserTokenManager tm) {
3562:                token_source = tm;
3563:                token = new Token();
3564:                jj_ntk = -1;
3565:                jj_gen = 0;
3566:                for (int i = 0; i < 64; i++)
3567:                    jj_la1[i] = -1;
3568:                for (int i = 0; i < jj_2_rtns.length; i++)
3569:                    jj_2_rtns[i] = new JJCalls();
3570:            }
3571:
3572:            public void ReInit(OgnlParserTokenManager tm) {
3573:                token_source = tm;
3574:                token = new Token();
3575:                jj_ntk = -1;
3576:                jjtree.reset();
3577:                jj_gen = 0;
3578:                for (int i = 0; i < 64; i++)
3579:                    jj_la1[i] = -1;
3580:                for (int i = 0; i < jj_2_rtns.length; i++)
3581:                    jj_2_rtns[i] = new JJCalls();
3582:            }
3583:
3584:            final private Token jj_consume_token(int kind)
3585:                    throws ParseException {
3586:                Token oldToken;
3587:                if ((oldToken = token).next != null)
3588:                    token = token.next;
3589:                else
3590:                    token = token.next = token_source.getNextToken();
3591:                jj_ntk = -1;
3592:                if (token.kind == kind) {
3593:                    jj_gen++;
3594:                    if (++jj_gc > 100) {
3595:                        jj_gc = 0;
3596:                        for (int i = 0; i < jj_2_rtns.length; i++) {
3597:                            JJCalls c = jj_2_rtns[i];
3598:                            while (c != null) {
3599:                                if (c.gen < jj_gen)
3600:                                    c.first = null;
3601:                                c = c.next;
3602:                            }
3603:                        }
3604:                    }
3605:                    return token;
3606:                }
3607:                token = oldToken;
3608:                jj_kind = kind;
3609:                throw generateParseException();
3610:            }
3611:
3612:            static private final class LookaheadSuccess extends java.lang.Error {
3613:            }
3614:
3615:            final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3616:
3617:            final private boolean jj_scan_token(int kind) {
3618:                if (jj_scanpos == jj_lastpos) {
3619:                    jj_la--;
3620:                    if (jj_scanpos.next == null) {
3621:                        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
3622:                                .getNextToken();
3623:                    } else {
3624:                        jj_lastpos = jj_scanpos = jj_scanpos.next;
3625:                    }
3626:                } else {
3627:                    jj_scanpos = jj_scanpos.next;
3628:                }
3629:                if (jj_rescan) {
3630:                    int i = 0;
3631:                    Token tok = token;
3632:                    while (tok != null && tok != jj_scanpos) {
3633:                        i++;
3634:                        tok = tok.next;
3635:                    }
3636:                    if (tok != null)
3637:                        jj_add_error_token(kind, i);
3638:                }
3639:                if (jj_scanpos.kind != kind)
3640:                    return true;
3641:                if (jj_la == 0 && jj_scanpos == jj_lastpos)
3642:                    throw jj_ls;
3643:                return false;
3644:            }
3645:
3646:            final public Token getNextToken() {
3647:                if (token.next != null)
3648:                    token = token.next;
3649:                else
3650:                    token = token.next = token_source.getNextToken();
3651:                jj_ntk = -1;
3652:                jj_gen++;
3653:                return token;
3654:            }
3655:
3656:            final public Token getToken(int index) {
3657:                Token t = lookingAhead ? jj_scanpos : token;
3658:                for (int i = 0; i < index; i++) {
3659:                    if (t.next != null)
3660:                        t = t.next;
3661:                    else
3662:                        t = t.next = token_source.getNextToken();
3663:                }
3664:                return t;
3665:            }
3666:
3667:            final private int jj_ntk() {
3668:                if ((jj_nt = token.next) == null)
3669:                    return (jj_ntk = (token.next = token_source.getNextToken()).kind);
3670:                else
3671:                    return (jj_ntk = jj_nt.kind);
3672:            }
3673:
3674:            private java.util.Vector jj_expentries = new java.util.Vector();
3675:            private int[] jj_expentry;
3676:            private int jj_kind = -1;
3677:            private int[] jj_lasttokens = new int[100];
3678:            private int jj_endpos;
3679:
3680:            private void jj_add_error_token(int kind, int pos) {
3681:                if (pos >= 100)
3682:                    return;
3683:                if (pos == jj_endpos + 1) {
3684:                    jj_lasttokens[jj_endpos++] = kind;
3685:                } else if (jj_endpos != 0) {
3686:                    jj_expentry = new int[jj_endpos];
3687:                    for (int i = 0; i < jj_endpos; i++) {
3688:                        jj_expentry[i] = jj_lasttokens[i];
3689:                    }
3690:                    boolean exists = false;
3691:                    for (java.util.Enumeration e = jj_expentries.elements(); e
3692:                            .hasMoreElements();) {
3693:                        int[] oldentry = (int[]) (e.nextElement());
3694:                        if (oldentry.length == jj_expentry.length) {
3695:                            exists = true;
3696:                            for (int i = 0; i < jj_expentry.length; i++) {
3697:                                if (oldentry[i] != jj_expentry[i]) {
3698:                                    exists = false;
3699:                                    break;
3700:                                }
3701:                            }
3702:                            if (exists)
3703:                                break;
3704:                        }
3705:                    }
3706:                    if (!exists)
3707:                        jj_expentries.addElement(jj_expentry);
3708:                    if (pos != 0)
3709:                        jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3710:                }
3711:            }
3712:
3713:            public ParseException generateParseException() {
3714:                jj_expentries.removeAllElements();
3715:                boolean[] la1tokens = new boolean[86];
3716:                for (int i = 0; i < 86; i++) {
3717:                    la1tokens[i] = false;
3718:                }
3719:                if (jj_kind >= 0) {
3720:                    la1tokens[jj_kind] = true;
3721:                    jj_kind = -1;
3722:                }
3723:                for (int i = 0; i < 64; i++) {
3724:                    if (jj_la1[i] == jj_gen) {
3725:                        for (int j = 0; j < 32; j++) {
3726:                            if ((jj_la1_0[i] & (1 << j)) != 0) {
3727:                                la1tokens[j] = true;
3728:                            }
3729:                            if ((jj_la1_1[i] & (1 << j)) != 0) {
3730:                                la1tokens[32 + j] = true;
3731:                            }
3732:                            if ((jj_la1_2[i] & (1 << j)) != 0) {
3733:                                la1tokens[64 + j] = true;
3734:                            }
3735:                        }
3736:                    }
3737:                }
3738:                for (int i = 0; i < 86; i++) {
3739:                    if (la1tokens[i]) {
3740:                        jj_expentry = new int[1];
3741:                        jj_expentry[0] = i;
3742:                        jj_expentries.addElement(jj_expentry);
3743:                    }
3744:                }
3745:                jj_endpos = 0;
3746:                jj_rescan_token();
3747:                jj_add_error_token(0, 0);
3748:                int[][] exptokseq = new int[jj_expentries.size()][];
3749:                for (int i = 0; i < jj_expentries.size(); i++) {
3750:                    exptokseq[i] = (int[]) jj_expentries.elementAt(i);
3751:                }
3752:                return new ParseException(token, exptokseq, tokenImage);
3753:            }
3754:
3755:            final public void enable_tracing() {
3756:            }
3757:
3758:            final public void disable_tracing() {
3759:            }
3760:
3761:            final private void jj_rescan_token() {
3762:                jj_rescan = true;
3763:                for (int i = 0; i < 16; i++) {
3764:                    JJCalls p = jj_2_rtns[i];
3765:                    do {
3766:                        if (p.gen > jj_gen) {
3767:                            jj_la = p.arg;
3768:                            jj_lastpos = jj_scanpos = p.first;
3769:                            switch (i) {
3770:                            case 0:
3771:                                jj_3_1();
3772:                                break;
3773:                            case 1:
3774:                                jj_3_2();
3775:                                break;
3776:                            case 2:
3777:                                jj_3_3();
3778:                                break;
3779:                            case 3:
3780:                                jj_3_4();
3781:                                break;
3782:                            case 4:
3783:                                jj_3_5();
3784:                                break;
3785:                            case 5:
3786:                                jj_3_6();
3787:                                break;
3788:                            case 6:
3789:                                jj_3_7();
3790:                                break;
3791:                            case 7:
3792:                                jj_3_8();
3793:                                break;
3794:                            case 8:
3795:                                jj_3_9();
3796:                                break;
3797:                            case 9:
3798:                                jj_3_10();
3799:                                break;
3800:                            case 10:
3801:                                jj_3_11();
3802:                                break;
3803:                            case 11:
3804:                                jj_3_12();
3805:                                break;
3806:                            case 12:
3807:                                jj_3_13();
3808:                                break;
3809:                            case 13:
3810:                                jj_3_14();
3811:                                break;
3812:                            case 14:
3813:                                jj_3_15();
3814:                                break;
3815:                            case 15:
3816:                                jj_3_16();
3817:                                break;
3818:                            }
3819:                        }
3820:                        p = p.next;
3821:                    } while (p != null);
3822:                }
3823:                jj_rescan = false;
3824:            }
3825:
3826:            final private void jj_save(int index, int xla) {
3827:                JJCalls p = jj_2_rtns[index];
3828:                while (p.gen > jj_gen) {
3829:                    if (p.next == null) {
3830:                        p = p.next = new JJCalls();
3831:                        break;
3832:                    }
3833:                    p = p.next;
3834:                }
3835:                p.gen = jj_gen + xla - jj_la;
3836:                p.first = token;
3837:                p.arg = xla;
3838:            }
3839:
3840:            static final class JJCalls {
3841:                int gen;
3842:                Token first;
3843:                int arg;
3844:                JJCalls next;
3845:            }
3846:
3847:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.