Source Code Cross Referenced for Parser.java in  » Library » Apache-commons-jexl-1.1-src » org » apache » commons » jexl » parser » Java Source Code / Java DocumentationJava Source Code and Java Documentation

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


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