Source Code Cross Referenced for ELParser.java in  » Sevlet-Container » apache-tomcat-6.0.14 » org » apache » el » 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 » Sevlet Container » apache tomcat 6.0.14 » org.apache.el.parser 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


0001:        /* Generated By:JJTree&JavaCC: Do not edit this line. ELParser.java */
0002:        package org.apache.el.parser;
0003:
0004:        import java.io.StringReader;
0005:        import javax.el.ELException;
0006:
0007:        public class ELParser/*@bgen(jjtree)*/implements 
0008:                ELParserTreeConstants, ELParserConstants {/*@bgen(jjtree)*/
0009:            protected JJTELParserState jjtree = new JJTELParserState();
0010:
0011:            public static Node parse(String ref) throws ELException {
0012:                try {
0013:                    return (new ELParser(new StringReader(ref)))
0014:                            .CompositeExpression();
0015:                } catch (ParseException pe) {
0016:                    throw new ELException(pe.getMessage());
0017:                }
0018:            }
0019:
0020:            public static void main(String[] argv) throws Exception {
0021:                String[] str = { "${foo()}", "${fn.fn:foo() ? a : b}",
0022:                        "${fn:foo() ? (fn_af.f:fd() ? a : b) : b}",
0023:                        "${a.b.c ? a : b}" };
0024:                for (int i = 0; i < str.length; i++) {
0025:                    SimpleNode sn = (SimpleNode) ELParser.parse(str[i]);
0026:                    System.out.println("====\n" + str[i]);
0027:                    sn.dump("\t");
0028:                }
0029:            }
0030:
0031:            /*
0032:             * CompositeExpression
0033:             * Allow most flexible parsing, restrict by examining
0034:             * type of returned node
0035:             */
0036:            final public AstCompositeExpression CompositeExpression()
0037:                    throws ParseException {
0038:                /*@bgen(jjtree) CompositeExpression */
0039:                AstCompositeExpression jjtn000 = new AstCompositeExpression(
0040:                        JJTCOMPOSITEEXPRESSION);
0041:                boolean jjtc000 = true;
0042:                jjtree.openNodeScope(jjtn000);
0043:                try {
0044:                    label_1: while (true) {
0045:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0046:                        case LITERAL_EXPRESSION:
0047:                        case START_DYNAMIC_EXPRESSION:
0048:                        case START_DEFERRED_EXPRESSION:
0049:                            ;
0050:                            break;
0051:                        default:
0052:                            jj_la1[0] = jj_gen;
0053:                            break label_1;
0054:                        }
0055:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0056:                        case START_DEFERRED_EXPRESSION:
0057:                            DeferredExpression();
0058:                            break;
0059:                        case START_DYNAMIC_EXPRESSION:
0060:                            DynamicExpression();
0061:                            break;
0062:                        case LITERAL_EXPRESSION:
0063:                            LiteralExpression();
0064:                            break;
0065:                        default:
0066:                            jj_la1[1] = jj_gen;
0067:                            jj_consume_token(-1);
0068:                            throw new ParseException();
0069:                        }
0070:                    }
0071:                    jj_consume_token(0);
0072:                    jjtree.closeNodeScope(jjtn000, true);
0073:                    jjtc000 = false;
0074:                    {
0075:                        if (true)
0076:                            return jjtn000;
0077:                    }
0078:                } catch (Throwable jjte000) {
0079:                    if (jjtc000) {
0080:                        jjtree.clearNodeScope(jjtn000);
0081:                        jjtc000 = false;
0082:                    } else {
0083:                        jjtree.popNode();
0084:                    }
0085:                    if (jjte000 instanceof  RuntimeException) {
0086:                        {
0087:                            if (true)
0088:                                throw (RuntimeException) jjte000;
0089:                        }
0090:                    }
0091:                    if (jjte000 instanceof  ParseException) {
0092:                        {
0093:                            if (true)
0094:                                throw (ParseException) jjte000;
0095:                        }
0096:                    }
0097:                    {
0098:                        if (true)
0099:                            throw (Error) jjte000;
0100:                    }
0101:                } finally {
0102:                    if (jjtc000) {
0103:                        jjtree.closeNodeScope(jjtn000, true);
0104:                    }
0105:                }
0106:                throw new Error("Missing return statement in function");
0107:            }
0108:
0109:            /*
0110:             * LiteralExpression
0111:             * Non-EL Expression blocks
0112:             */
0113:            final public void LiteralExpression() throws ParseException {
0114:                /*@bgen(jjtree) LiteralExpression */
0115:                AstLiteralExpression jjtn000 = new AstLiteralExpression(
0116:                        JJTLITERALEXPRESSION);
0117:                boolean jjtc000 = true;
0118:                jjtree.openNodeScope(jjtn000);
0119:                Token t = null;
0120:                try {
0121:                    t = jj_consume_token(LITERAL_EXPRESSION);
0122:                    jjtree.closeNodeScope(jjtn000, true);
0123:                    jjtc000 = false;
0124:                    jjtn000.setImage(t.image);
0125:                } finally {
0126:                    if (jjtc000) {
0127:                        jjtree.closeNodeScope(jjtn000, true);
0128:                    }
0129:                }
0130:            }
0131:
0132:            /*
0133:             * DeferredExpression
0134:             * #{..} Expressions
0135:             */
0136:            final public void DeferredExpression() throws ParseException {
0137:                /*@bgen(jjtree) DeferredExpression */
0138:                AstDeferredExpression jjtn000 = new AstDeferredExpression(
0139:                        JJTDEFERREDEXPRESSION);
0140:                boolean jjtc000 = true;
0141:                jjtree.openNodeScope(jjtn000);
0142:                try {
0143:                    jj_consume_token(START_DEFERRED_EXPRESSION);
0144:                    Expression();
0145:                    jj_consume_token(END_EXPRESSION);
0146:                } catch (Throwable jjte000) {
0147:                    if (jjtc000) {
0148:                        jjtree.clearNodeScope(jjtn000);
0149:                        jjtc000 = false;
0150:                    } else {
0151:                        jjtree.popNode();
0152:                    }
0153:                    if (jjte000 instanceof  RuntimeException) {
0154:                        {
0155:                            if (true)
0156:                                throw (RuntimeException) jjte000;
0157:                        }
0158:                    }
0159:                    if (jjte000 instanceof  ParseException) {
0160:                        {
0161:                            if (true)
0162:                                throw (ParseException) jjte000;
0163:                        }
0164:                    }
0165:                    {
0166:                        if (true)
0167:                            throw (Error) jjte000;
0168:                    }
0169:                } finally {
0170:                    if (jjtc000) {
0171:                        jjtree.closeNodeScope(jjtn000, true);
0172:                    }
0173:                }
0174:            }
0175:
0176:            /*
0177:             * DynamicExpression
0178:             * ${..} Expressions
0179:             */
0180:            final public void DynamicExpression() throws ParseException {
0181:                /*@bgen(jjtree) DynamicExpression */
0182:                AstDynamicExpression jjtn000 = new AstDynamicExpression(
0183:                        JJTDYNAMICEXPRESSION);
0184:                boolean jjtc000 = true;
0185:                jjtree.openNodeScope(jjtn000);
0186:                try {
0187:                    jj_consume_token(START_DYNAMIC_EXPRESSION);
0188:                    Expression();
0189:                    jj_consume_token(END_EXPRESSION);
0190:                } catch (Throwable jjte000) {
0191:                    if (jjtc000) {
0192:                        jjtree.clearNodeScope(jjtn000);
0193:                        jjtc000 = false;
0194:                    } else {
0195:                        jjtree.popNode();
0196:                    }
0197:                    if (jjte000 instanceof  RuntimeException) {
0198:                        {
0199:                            if (true)
0200:                                throw (RuntimeException) jjte000;
0201:                        }
0202:                    }
0203:                    if (jjte000 instanceof  ParseException) {
0204:                        {
0205:                            if (true)
0206:                                throw (ParseException) jjte000;
0207:                        }
0208:                    }
0209:                    {
0210:                        if (true)
0211:                            throw (Error) jjte000;
0212:                    }
0213:                } finally {
0214:                    if (jjtc000) {
0215:                        jjtree.closeNodeScope(jjtn000, true);
0216:                    }
0217:                }
0218:            }
0219:
0220:            /*
0221:             * Expression
0222:             * EL Expression Language Root, goes to Choice
0223:             */
0224:            final public void Expression() throws ParseException {
0225:                Choice();
0226:            }
0227:
0228:            /*
0229:             * Choice
0230:             * For Choice markup a ? b : c, then Or
0231:             */
0232:            final public void Choice() throws ParseException {
0233:                Or();
0234:                label_2: while (true) {
0235:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0236:                    case QUESTIONMARK:
0237:                        ;
0238:                        break;
0239:                    default:
0240:                        jj_la1[2] = jj_gen;
0241:                        break label_2;
0242:                    }
0243:                    jj_consume_token(QUESTIONMARK);
0244:                    Or();
0245:                    jj_consume_token(COLON);
0246:                    AstChoice jjtn001 = new AstChoice(JJTCHOICE);
0247:                    boolean jjtc001 = true;
0248:                    jjtree.openNodeScope(jjtn001);
0249:                    try {
0250:                        Choice();
0251:                    } catch (Throwable jjte001) {
0252:                        if (jjtc001) {
0253:                            jjtree.clearNodeScope(jjtn001);
0254:                            jjtc001 = false;
0255:                        } else {
0256:                            jjtree.popNode();
0257:                        }
0258:                        if (jjte001 instanceof  RuntimeException) {
0259:                            {
0260:                                if (true)
0261:                                    throw (RuntimeException) jjte001;
0262:                            }
0263:                        }
0264:                        if (jjte001 instanceof  ParseException) {
0265:                            {
0266:                                if (true)
0267:                                    throw (ParseException) jjte001;
0268:                            }
0269:                        }
0270:                        {
0271:                            if (true)
0272:                                throw (Error) jjte001;
0273:                        }
0274:                    } finally {
0275:                        if (jjtc001) {
0276:                            jjtree.closeNodeScope(jjtn001, 3);
0277:                        }
0278:                    }
0279:                }
0280:            }
0281:
0282:            /*
0283:             * Or
0284:             * For 'or' '||', then And
0285:             */
0286:            final public void Or() throws ParseException {
0287:                And();
0288:                label_3: while (true) {
0289:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0290:                    case OR0:
0291:                    case OR1:
0292:                        ;
0293:                        break;
0294:                    default:
0295:                        jj_la1[3] = jj_gen;
0296:                        break label_3;
0297:                    }
0298:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0299:                    case OR0:
0300:                        jj_consume_token(OR0);
0301:                        break;
0302:                    case OR1:
0303:                        jj_consume_token(OR1);
0304:                        break;
0305:                    default:
0306:                        jj_la1[4] = jj_gen;
0307:                        jj_consume_token(-1);
0308:                        throw new ParseException();
0309:                    }
0310:                    AstOr jjtn001 = new AstOr(JJTOR);
0311:                    boolean jjtc001 = true;
0312:                    jjtree.openNodeScope(jjtn001);
0313:                    try {
0314:                        And();
0315:                    } catch (Throwable jjte001) {
0316:                        if (jjtc001) {
0317:                            jjtree.clearNodeScope(jjtn001);
0318:                            jjtc001 = false;
0319:                        } else {
0320:                            jjtree.popNode();
0321:                        }
0322:                        if (jjte001 instanceof  RuntimeException) {
0323:                            {
0324:                                if (true)
0325:                                    throw (RuntimeException) jjte001;
0326:                            }
0327:                        }
0328:                        if (jjte001 instanceof  ParseException) {
0329:                            {
0330:                                if (true)
0331:                                    throw (ParseException) jjte001;
0332:                            }
0333:                        }
0334:                        {
0335:                            if (true)
0336:                                throw (Error) jjte001;
0337:                        }
0338:                    } finally {
0339:                        if (jjtc001) {
0340:                            jjtree.closeNodeScope(jjtn001, 2);
0341:                        }
0342:                    }
0343:                }
0344:            }
0345:
0346:            /*
0347:             * And
0348:             * For 'and' '&&', then Equality
0349:             */
0350:            final public void And() throws ParseException {
0351:                Equality();
0352:                label_4: while (true) {
0353:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0354:                    case AND0:
0355:                    case AND1:
0356:                        ;
0357:                        break;
0358:                    default:
0359:                        jj_la1[5] = jj_gen;
0360:                        break label_4;
0361:                    }
0362:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0363:                    case AND0:
0364:                        jj_consume_token(AND0);
0365:                        break;
0366:                    case AND1:
0367:                        jj_consume_token(AND1);
0368:                        break;
0369:                    default:
0370:                        jj_la1[6] = jj_gen;
0371:                        jj_consume_token(-1);
0372:                        throw new ParseException();
0373:                    }
0374:                    AstAnd jjtn001 = new AstAnd(JJTAND);
0375:                    boolean jjtc001 = true;
0376:                    jjtree.openNodeScope(jjtn001);
0377:                    try {
0378:                        Equality();
0379:                    } catch (Throwable jjte001) {
0380:                        if (jjtc001) {
0381:                            jjtree.clearNodeScope(jjtn001);
0382:                            jjtc001 = false;
0383:                        } else {
0384:                            jjtree.popNode();
0385:                        }
0386:                        if (jjte001 instanceof  RuntimeException) {
0387:                            {
0388:                                if (true)
0389:                                    throw (RuntimeException) jjte001;
0390:                            }
0391:                        }
0392:                        if (jjte001 instanceof  ParseException) {
0393:                            {
0394:                                if (true)
0395:                                    throw (ParseException) jjte001;
0396:                            }
0397:                        }
0398:                        {
0399:                            if (true)
0400:                                throw (Error) jjte001;
0401:                        }
0402:                    } finally {
0403:                        if (jjtc001) {
0404:                            jjtree.closeNodeScope(jjtn001, 2);
0405:                        }
0406:                    }
0407:                }
0408:            }
0409:
0410:            /*
0411:             * Equality
0412:             * For '==' 'eq' '!=' 'ne', then Compare
0413:             */
0414:            final public void Equality() throws ParseException {
0415:                Compare();
0416:                label_5: while (true) {
0417:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0418:                    case EQ0:
0419:                    case EQ1:
0420:                    case NE0:
0421:                    case NE1:
0422:                        ;
0423:                        break;
0424:                    default:
0425:                        jj_la1[7] = jj_gen;
0426:                        break label_5;
0427:                    }
0428:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0429:                    case EQ0:
0430:                    case EQ1:
0431:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0432:                        case EQ0:
0433:                            jj_consume_token(EQ0);
0434:                            break;
0435:                        case EQ1:
0436:                            jj_consume_token(EQ1);
0437:                            break;
0438:                        default:
0439:                            jj_la1[8] = jj_gen;
0440:                            jj_consume_token(-1);
0441:                            throw new ParseException();
0442:                        }
0443:                        AstEqual jjtn001 = new AstEqual(JJTEQUAL);
0444:                        boolean jjtc001 = true;
0445:                        jjtree.openNodeScope(jjtn001);
0446:                        try {
0447:                            Compare();
0448:                        } catch (Throwable jjte001) {
0449:                            if (jjtc001) {
0450:                                jjtree.clearNodeScope(jjtn001);
0451:                                jjtc001 = false;
0452:                            } else {
0453:                                jjtree.popNode();
0454:                            }
0455:                            if (jjte001 instanceof  RuntimeException) {
0456:                                {
0457:                                    if (true)
0458:                                        throw (RuntimeException) jjte001;
0459:                                }
0460:                            }
0461:                            if (jjte001 instanceof  ParseException) {
0462:                                {
0463:                                    if (true)
0464:                                        throw (ParseException) jjte001;
0465:                                }
0466:                            }
0467:                            {
0468:                                if (true)
0469:                                    throw (Error) jjte001;
0470:                            }
0471:                        } finally {
0472:                            if (jjtc001) {
0473:                                jjtree.closeNodeScope(jjtn001, 2);
0474:                            }
0475:                        }
0476:                        break;
0477:                    case NE0:
0478:                    case NE1:
0479:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0480:                        case NE0:
0481:                            jj_consume_token(NE0);
0482:                            break;
0483:                        case NE1:
0484:                            jj_consume_token(NE1);
0485:                            break;
0486:                        default:
0487:                            jj_la1[9] = jj_gen;
0488:                            jj_consume_token(-1);
0489:                            throw new ParseException();
0490:                        }
0491:                        AstNotEqual jjtn002 = new AstNotEqual(JJTNOTEQUAL);
0492:                        boolean jjtc002 = true;
0493:                        jjtree.openNodeScope(jjtn002);
0494:                        try {
0495:                            Compare();
0496:                        } catch (Throwable jjte002) {
0497:                            if (jjtc002) {
0498:                                jjtree.clearNodeScope(jjtn002);
0499:                                jjtc002 = false;
0500:                            } else {
0501:                                jjtree.popNode();
0502:                            }
0503:                            if (jjte002 instanceof  RuntimeException) {
0504:                                {
0505:                                    if (true)
0506:                                        throw (RuntimeException) jjte002;
0507:                                }
0508:                            }
0509:                            if (jjte002 instanceof  ParseException) {
0510:                                {
0511:                                    if (true)
0512:                                        throw (ParseException) jjte002;
0513:                                }
0514:                            }
0515:                            {
0516:                                if (true)
0517:                                    throw (Error) jjte002;
0518:                            }
0519:                        } finally {
0520:                            if (jjtc002) {
0521:                                jjtree.closeNodeScope(jjtn002, 2);
0522:                            }
0523:                        }
0524:                        break;
0525:                    default:
0526:                        jj_la1[10] = jj_gen;
0527:                        jj_consume_token(-1);
0528:                        throw new ParseException();
0529:                    }
0530:                }
0531:            }
0532:
0533:            /*
0534:             * Compare
0535:             * For a bunch of them, then Math
0536:             */
0537:            final public void Compare() throws ParseException {
0538:                Math();
0539:                label_6: while (true) {
0540:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0541:                    case GT0:
0542:                    case GT1:
0543:                    case LT0:
0544:                    case LT1:
0545:                    case GE0:
0546:                    case GE1:
0547:                    case LE0:
0548:                    case LE1:
0549:                        ;
0550:                        break;
0551:                    default:
0552:                        jj_la1[11] = jj_gen;
0553:                        break label_6;
0554:                    }
0555:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0556:                    case LT0:
0557:                    case LT1:
0558:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0559:                        case LT0:
0560:                            jj_consume_token(LT0);
0561:                            break;
0562:                        case LT1:
0563:                            jj_consume_token(LT1);
0564:                            break;
0565:                        default:
0566:                            jj_la1[12] = jj_gen;
0567:                            jj_consume_token(-1);
0568:                            throw new ParseException();
0569:                        }
0570:                        AstLessThan jjtn001 = new AstLessThan(JJTLESSTHAN);
0571:                        boolean jjtc001 = true;
0572:                        jjtree.openNodeScope(jjtn001);
0573:                        try {
0574:                            Math();
0575:                        } catch (Throwable jjte001) {
0576:                            if (jjtc001) {
0577:                                jjtree.clearNodeScope(jjtn001);
0578:                                jjtc001 = false;
0579:                            } else {
0580:                                jjtree.popNode();
0581:                            }
0582:                            if (jjte001 instanceof  RuntimeException) {
0583:                                {
0584:                                    if (true)
0585:                                        throw (RuntimeException) jjte001;
0586:                                }
0587:                            }
0588:                            if (jjte001 instanceof  ParseException) {
0589:                                {
0590:                                    if (true)
0591:                                        throw (ParseException) jjte001;
0592:                                }
0593:                            }
0594:                            {
0595:                                if (true)
0596:                                    throw (Error) jjte001;
0597:                            }
0598:                        } finally {
0599:                            if (jjtc001) {
0600:                                jjtree.closeNodeScope(jjtn001, 2);
0601:                            }
0602:                        }
0603:                        break;
0604:                    case GT0:
0605:                    case GT1:
0606:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0607:                        case GT0:
0608:                            jj_consume_token(GT0);
0609:                            break;
0610:                        case GT1:
0611:                            jj_consume_token(GT1);
0612:                            break;
0613:                        default:
0614:                            jj_la1[13] = jj_gen;
0615:                            jj_consume_token(-1);
0616:                            throw new ParseException();
0617:                        }
0618:                        AstGreaterThan jjtn002 = new AstGreaterThan(
0619:                                JJTGREATERTHAN);
0620:                        boolean jjtc002 = true;
0621:                        jjtree.openNodeScope(jjtn002);
0622:                        try {
0623:                            Math();
0624:                        } catch (Throwable jjte002) {
0625:                            if (jjtc002) {
0626:                                jjtree.clearNodeScope(jjtn002);
0627:                                jjtc002 = false;
0628:                            } else {
0629:                                jjtree.popNode();
0630:                            }
0631:                            if (jjte002 instanceof  RuntimeException) {
0632:                                {
0633:                                    if (true)
0634:                                        throw (RuntimeException) jjte002;
0635:                                }
0636:                            }
0637:                            if (jjte002 instanceof  ParseException) {
0638:                                {
0639:                                    if (true)
0640:                                        throw (ParseException) jjte002;
0641:                                }
0642:                            }
0643:                            {
0644:                                if (true)
0645:                                    throw (Error) jjte002;
0646:                            }
0647:                        } finally {
0648:                            if (jjtc002) {
0649:                                jjtree.closeNodeScope(jjtn002, 2);
0650:                            }
0651:                        }
0652:                        break;
0653:                    case LE0:
0654:                    case LE1:
0655:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0656:                        case LE0:
0657:                            jj_consume_token(LE0);
0658:                            break;
0659:                        case LE1:
0660:                            jj_consume_token(LE1);
0661:                            break;
0662:                        default:
0663:                            jj_la1[14] = jj_gen;
0664:                            jj_consume_token(-1);
0665:                            throw new ParseException();
0666:                        }
0667:                        AstLessThanEqual jjtn003 = new AstLessThanEqual(
0668:                                JJTLESSTHANEQUAL);
0669:                        boolean jjtc003 = true;
0670:                        jjtree.openNodeScope(jjtn003);
0671:                        try {
0672:                            Math();
0673:                        } catch (Throwable jjte003) {
0674:                            if (jjtc003) {
0675:                                jjtree.clearNodeScope(jjtn003);
0676:                                jjtc003 = false;
0677:                            } else {
0678:                                jjtree.popNode();
0679:                            }
0680:                            if (jjte003 instanceof  RuntimeException) {
0681:                                {
0682:                                    if (true)
0683:                                        throw (RuntimeException) jjte003;
0684:                                }
0685:                            }
0686:                            if (jjte003 instanceof  ParseException) {
0687:                                {
0688:                                    if (true)
0689:                                        throw (ParseException) jjte003;
0690:                                }
0691:                            }
0692:                            {
0693:                                if (true)
0694:                                    throw (Error) jjte003;
0695:                            }
0696:                        } finally {
0697:                            if (jjtc003) {
0698:                                jjtree.closeNodeScope(jjtn003, 2);
0699:                            }
0700:                        }
0701:                        break;
0702:                    case GE0:
0703:                    case GE1:
0704:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0705:                        case GE0:
0706:                            jj_consume_token(GE0);
0707:                            break;
0708:                        case GE1:
0709:                            jj_consume_token(GE1);
0710:                            break;
0711:                        default:
0712:                            jj_la1[15] = jj_gen;
0713:                            jj_consume_token(-1);
0714:                            throw new ParseException();
0715:                        }
0716:                        AstGreaterThanEqual jjtn004 = new AstGreaterThanEqual(
0717:                                JJTGREATERTHANEQUAL);
0718:                        boolean jjtc004 = true;
0719:                        jjtree.openNodeScope(jjtn004);
0720:                        try {
0721:                            Math();
0722:                        } catch (Throwable jjte004) {
0723:                            if (jjtc004) {
0724:                                jjtree.clearNodeScope(jjtn004);
0725:                                jjtc004 = false;
0726:                            } else {
0727:                                jjtree.popNode();
0728:                            }
0729:                            if (jjte004 instanceof  RuntimeException) {
0730:                                {
0731:                                    if (true)
0732:                                        throw (RuntimeException) jjte004;
0733:                                }
0734:                            }
0735:                            if (jjte004 instanceof  ParseException) {
0736:                                {
0737:                                    if (true)
0738:                                        throw (ParseException) jjte004;
0739:                                }
0740:                            }
0741:                            {
0742:                                if (true)
0743:                                    throw (Error) jjte004;
0744:                            }
0745:                        } finally {
0746:                            if (jjtc004) {
0747:                                jjtree.closeNodeScope(jjtn004, 2);
0748:                            }
0749:                        }
0750:                        break;
0751:                    default:
0752:                        jj_la1[16] = jj_gen;
0753:                        jj_consume_token(-1);
0754:                        throw new ParseException();
0755:                    }
0756:                }
0757:            }
0758:
0759:            /*
0760:             * Math
0761:             * For '+' '-', then Multiplication
0762:             */
0763:            final public void Math() throws ParseException {
0764:                Multiplication();
0765:                label_7: while (true) {
0766:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0767:                    case PLUS:
0768:                    case MINUS:
0769:                        ;
0770:                        break;
0771:                    default:
0772:                        jj_la1[17] = jj_gen;
0773:                        break label_7;
0774:                    }
0775:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0776:                    case PLUS:
0777:                        jj_consume_token(PLUS);
0778:                        AstPlus jjtn001 = new AstPlus(JJTPLUS);
0779:                        boolean jjtc001 = true;
0780:                        jjtree.openNodeScope(jjtn001);
0781:                        try {
0782:                            Multiplication();
0783:                        } catch (Throwable jjte001) {
0784:                            if (jjtc001) {
0785:                                jjtree.clearNodeScope(jjtn001);
0786:                                jjtc001 = false;
0787:                            } else {
0788:                                jjtree.popNode();
0789:                            }
0790:                            if (jjte001 instanceof  RuntimeException) {
0791:                                {
0792:                                    if (true)
0793:                                        throw (RuntimeException) jjte001;
0794:                                }
0795:                            }
0796:                            if (jjte001 instanceof  ParseException) {
0797:                                {
0798:                                    if (true)
0799:                                        throw (ParseException) jjte001;
0800:                                }
0801:                            }
0802:                            {
0803:                                if (true)
0804:                                    throw (Error) jjte001;
0805:                            }
0806:                        } finally {
0807:                            if (jjtc001) {
0808:                                jjtree.closeNodeScope(jjtn001, 2);
0809:                            }
0810:                        }
0811:                        break;
0812:                    case MINUS:
0813:                        jj_consume_token(MINUS);
0814:                        AstMinus jjtn002 = new AstMinus(JJTMINUS);
0815:                        boolean jjtc002 = true;
0816:                        jjtree.openNodeScope(jjtn002);
0817:                        try {
0818:                            Multiplication();
0819:                        } catch (Throwable jjte002) {
0820:                            if (jjtc002) {
0821:                                jjtree.clearNodeScope(jjtn002);
0822:                                jjtc002 = false;
0823:                            } else {
0824:                                jjtree.popNode();
0825:                            }
0826:                            if (jjte002 instanceof  RuntimeException) {
0827:                                {
0828:                                    if (true)
0829:                                        throw (RuntimeException) jjte002;
0830:                                }
0831:                            }
0832:                            if (jjte002 instanceof  ParseException) {
0833:                                {
0834:                                    if (true)
0835:                                        throw (ParseException) jjte002;
0836:                                }
0837:                            }
0838:                            {
0839:                                if (true)
0840:                                    throw (Error) jjte002;
0841:                            }
0842:                        } finally {
0843:                            if (jjtc002) {
0844:                                jjtree.closeNodeScope(jjtn002, 2);
0845:                            }
0846:                        }
0847:                        break;
0848:                    default:
0849:                        jj_la1[18] = jj_gen;
0850:                        jj_consume_token(-1);
0851:                        throw new ParseException();
0852:                    }
0853:                }
0854:            }
0855:
0856:            /*
0857:             * Multiplication
0858:             * For a bunch of them, then Unary
0859:             */
0860:            final public void Multiplication() throws ParseException {
0861:                Unary();
0862:                label_8: while (true) {
0863:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0864:                    case MULT:
0865:                    case DIV0:
0866:                    case DIV1:
0867:                    case MOD0:
0868:                    case MOD1:
0869:                        ;
0870:                        break;
0871:                    default:
0872:                        jj_la1[19] = jj_gen;
0873:                        break label_8;
0874:                    }
0875:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0876:                    case MULT:
0877:                        jj_consume_token(MULT);
0878:                        AstMult jjtn001 = new AstMult(JJTMULT);
0879:                        boolean jjtc001 = true;
0880:                        jjtree.openNodeScope(jjtn001);
0881:                        try {
0882:                            Unary();
0883:                        } catch (Throwable jjte001) {
0884:                            if (jjtc001) {
0885:                                jjtree.clearNodeScope(jjtn001);
0886:                                jjtc001 = false;
0887:                            } else {
0888:                                jjtree.popNode();
0889:                            }
0890:                            if (jjte001 instanceof  RuntimeException) {
0891:                                {
0892:                                    if (true)
0893:                                        throw (RuntimeException) jjte001;
0894:                                }
0895:                            }
0896:                            if (jjte001 instanceof  ParseException) {
0897:                                {
0898:                                    if (true)
0899:                                        throw (ParseException) jjte001;
0900:                                }
0901:                            }
0902:                            {
0903:                                if (true)
0904:                                    throw (Error) jjte001;
0905:                            }
0906:                        } finally {
0907:                            if (jjtc001) {
0908:                                jjtree.closeNodeScope(jjtn001, 2);
0909:                            }
0910:                        }
0911:                        break;
0912:                    case DIV0:
0913:                    case DIV1:
0914:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0915:                        case DIV0:
0916:                            jj_consume_token(DIV0);
0917:                            break;
0918:                        case DIV1:
0919:                            jj_consume_token(DIV1);
0920:                            break;
0921:                        default:
0922:                            jj_la1[20] = jj_gen;
0923:                            jj_consume_token(-1);
0924:                            throw new ParseException();
0925:                        }
0926:                        AstDiv jjtn002 = new AstDiv(JJTDIV);
0927:                        boolean jjtc002 = true;
0928:                        jjtree.openNodeScope(jjtn002);
0929:                        try {
0930:                            Unary();
0931:                        } catch (Throwable jjte002) {
0932:                            if (jjtc002) {
0933:                                jjtree.clearNodeScope(jjtn002);
0934:                                jjtc002 = false;
0935:                            } else {
0936:                                jjtree.popNode();
0937:                            }
0938:                            if (jjte002 instanceof  RuntimeException) {
0939:                                {
0940:                                    if (true)
0941:                                        throw (RuntimeException) jjte002;
0942:                                }
0943:                            }
0944:                            if (jjte002 instanceof  ParseException) {
0945:                                {
0946:                                    if (true)
0947:                                        throw (ParseException) jjte002;
0948:                                }
0949:                            }
0950:                            {
0951:                                if (true)
0952:                                    throw (Error) jjte002;
0953:                            }
0954:                        } finally {
0955:                            if (jjtc002) {
0956:                                jjtree.closeNodeScope(jjtn002, 2);
0957:                            }
0958:                        }
0959:                        break;
0960:                    case MOD0:
0961:                    case MOD1:
0962:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0963:                        case MOD0:
0964:                            jj_consume_token(MOD0);
0965:                            break;
0966:                        case MOD1:
0967:                            jj_consume_token(MOD1);
0968:                            break;
0969:                        default:
0970:                            jj_la1[21] = jj_gen;
0971:                            jj_consume_token(-1);
0972:                            throw new ParseException();
0973:                        }
0974:                        AstMod jjtn003 = new AstMod(JJTMOD);
0975:                        boolean jjtc003 = true;
0976:                        jjtree.openNodeScope(jjtn003);
0977:                        try {
0978:                            Unary();
0979:                        } catch (Throwable jjte003) {
0980:                            if (jjtc003) {
0981:                                jjtree.clearNodeScope(jjtn003);
0982:                                jjtc003 = false;
0983:                            } else {
0984:                                jjtree.popNode();
0985:                            }
0986:                            if (jjte003 instanceof  RuntimeException) {
0987:                                {
0988:                                    if (true)
0989:                                        throw (RuntimeException) jjte003;
0990:                                }
0991:                            }
0992:                            if (jjte003 instanceof  ParseException) {
0993:                                {
0994:                                    if (true)
0995:                                        throw (ParseException) jjte003;
0996:                                }
0997:                            }
0998:                            {
0999:                                if (true)
1000:                                    throw (Error) jjte003;
1001:                            }
1002:                        } finally {
1003:                            if (jjtc003) {
1004:                                jjtree.closeNodeScope(jjtn003, 2);
1005:                            }
1006:                        }
1007:                        break;
1008:                    default:
1009:                        jj_la1[22] = jj_gen;
1010:                        jj_consume_token(-1);
1011:                        throw new ParseException();
1012:                    }
1013:                }
1014:            }
1015:
1016:            /*
1017:             * Unary
1018:             * For '-' '!' 'not' 'empty', then Value
1019:             */
1020:            final public void Unary() throws ParseException {
1021:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1022:                case MINUS:
1023:                    jj_consume_token(MINUS);
1024:                    AstNegative jjtn001 = new AstNegative(JJTNEGATIVE);
1025:                    boolean jjtc001 = true;
1026:                    jjtree.openNodeScope(jjtn001);
1027:                    try {
1028:                        Unary();
1029:                    } catch (Throwable jjte001) {
1030:                        if (jjtc001) {
1031:                            jjtree.clearNodeScope(jjtn001);
1032:                            jjtc001 = false;
1033:                        } else {
1034:                            jjtree.popNode();
1035:                        }
1036:                        if (jjte001 instanceof  RuntimeException) {
1037:                            {
1038:                                if (true)
1039:                                    throw (RuntimeException) jjte001;
1040:                            }
1041:                        }
1042:                        if (jjte001 instanceof  ParseException) {
1043:                            {
1044:                                if (true)
1045:                                    throw (ParseException) jjte001;
1046:                            }
1047:                        }
1048:                        {
1049:                            if (true)
1050:                                throw (Error) jjte001;
1051:                        }
1052:                    } finally {
1053:                        if (jjtc001) {
1054:                            jjtree.closeNodeScope(jjtn001, true);
1055:                        }
1056:                    }
1057:                    break;
1058:                case NOT0:
1059:                case NOT1:
1060:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1061:                    case NOT0:
1062:                        jj_consume_token(NOT0);
1063:                        break;
1064:                    case NOT1:
1065:                        jj_consume_token(NOT1);
1066:                        break;
1067:                    default:
1068:                        jj_la1[23] = jj_gen;
1069:                        jj_consume_token(-1);
1070:                        throw new ParseException();
1071:                    }
1072:                    AstNot jjtn002 = new AstNot(JJTNOT);
1073:                    boolean jjtc002 = true;
1074:                    jjtree.openNodeScope(jjtn002);
1075:                    try {
1076:                        Unary();
1077:                    } catch (Throwable jjte002) {
1078:                        if (jjtc002) {
1079:                            jjtree.clearNodeScope(jjtn002);
1080:                            jjtc002 = false;
1081:                        } else {
1082:                            jjtree.popNode();
1083:                        }
1084:                        if (jjte002 instanceof  RuntimeException) {
1085:                            {
1086:                                if (true)
1087:                                    throw (RuntimeException) jjte002;
1088:                            }
1089:                        }
1090:                        if (jjte002 instanceof  ParseException) {
1091:                            {
1092:                                if (true)
1093:                                    throw (ParseException) jjte002;
1094:                            }
1095:                        }
1096:                        {
1097:                            if (true)
1098:                                throw (Error) jjte002;
1099:                        }
1100:                    } finally {
1101:                        if (jjtc002) {
1102:                            jjtree.closeNodeScope(jjtn002, true);
1103:                        }
1104:                    }
1105:                    break;
1106:                case EMPTY:
1107:                    jj_consume_token(EMPTY);
1108:                    AstEmpty jjtn003 = new AstEmpty(JJTEMPTY);
1109:                    boolean jjtc003 = true;
1110:                    jjtree.openNodeScope(jjtn003);
1111:                    try {
1112:                        Unary();
1113:                    } catch (Throwable jjte003) {
1114:                        if (jjtc003) {
1115:                            jjtree.clearNodeScope(jjtn003);
1116:                            jjtc003 = false;
1117:                        } else {
1118:                            jjtree.popNode();
1119:                        }
1120:                        if (jjte003 instanceof  RuntimeException) {
1121:                            {
1122:                                if (true)
1123:                                    throw (RuntimeException) jjte003;
1124:                            }
1125:                        }
1126:                        if (jjte003 instanceof  ParseException) {
1127:                            {
1128:                                if (true)
1129:                                    throw (ParseException) jjte003;
1130:                            }
1131:                        }
1132:                        {
1133:                            if (true)
1134:                                throw (Error) jjte003;
1135:                        }
1136:                    } finally {
1137:                        if (jjtc003) {
1138:                            jjtree.closeNodeScope(jjtn003, true);
1139:                        }
1140:                    }
1141:                    break;
1142:                case INTEGER_LITERAL:
1143:                case FLOATING_POINT_LITERAL:
1144:                case STRING_LITERAL:
1145:                case TRUE:
1146:                case FALSE:
1147:                case NULL:
1148:                case LPAREN:
1149:                case IDENTIFIER:
1150:                case NAMESPACE:
1151:                    Value();
1152:                    break;
1153:                default:
1154:                    jj_la1[24] = jj_gen;
1155:                    jj_consume_token(-1);
1156:                    throw new ParseException();
1157:                }
1158:            }
1159:
1160:            /*
1161:             * Value
1162:             * Defines Prefix plus zero or more Suffixes
1163:             */
1164:            final public void Value() throws ParseException {
1165:                AstValue jjtn001 = new AstValue(JJTVALUE);
1166:                boolean jjtc001 = true;
1167:                jjtree.openNodeScope(jjtn001);
1168:                try {
1169:                    ValuePrefix();
1170:                    label_9: while (true) {
1171:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1172:                        case DOT:
1173:                        case LBRACK:
1174:                            ;
1175:                            break;
1176:                        default:
1177:                            jj_la1[25] = jj_gen;
1178:                            break label_9;
1179:                        }
1180:                        ValueSuffix();
1181:                    }
1182:                } catch (Throwable jjte001) {
1183:                    if (jjtc001) {
1184:                        jjtree.clearNodeScope(jjtn001);
1185:                        jjtc001 = false;
1186:                    } else {
1187:                        jjtree.popNode();
1188:                    }
1189:                    if (jjte001 instanceof  RuntimeException) {
1190:                        {
1191:                            if (true)
1192:                                throw (RuntimeException) jjte001;
1193:                        }
1194:                    }
1195:                    if (jjte001 instanceof  ParseException) {
1196:                        {
1197:                            if (true)
1198:                                throw (ParseException) jjte001;
1199:                        }
1200:                    }
1201:                    {
1202:                        if (true)
1203:                            throw (Error) jjte001;
1204:                    }
1205:                } finally {
1206:                    if (jjtc001) {
1207:                        jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
1208:                    }
1209:                }
1210:            }
1211:
1212:            /*
1213:             * ValuePrefix
1214:             * For Literals, Variables, and Functions
1215:             */
1216:            final public void ValuePrefix() throws ParseException {
1217:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1218:                case INTEGER_LITERAL:
1219:                case FLOATING_POINT_LITERAL:
1220:                case STRING_LITERAL:
1221:                case TRUE:
1222:                case FALSE:
1223:                case NULL:
1224:                    Literal();
1225:                    break;
1226:                case LPAREN:
1227:                case IDENTIFIER:
1228:                case NAMESPACE:
1229:                    NonLiteral();
1230:                    break;
1231:                default:
1232:                    jj_la1[26] = jj_gen;
1233:                    jj_consume_token(-1);
1234:                    throw new ParseException();
1235:                }
1236:            }
1237:
1238:            /*
1239:             * ValueSuffix
1240:             * Either dot or bracket notation
1241:             */
1242:            final public void ValueSuffix() throws ParseException {
1243:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1244:                case DOT:
1245:                    DotSuffix();
1246:                    break;
1247:                case LBRACK:
1248:                    BracketSuffix();
1249:                    break;
1250:                default:
1251:                    jj_la1[27] = jj_gen;
1252:                    jj_consume_token(-1);
1253:                    throw new ParseException();
1254:                }
1255:            }
1256:
1257:            /*
1258:             * DotSuffix
1259:             * Dot Property
1260:             */
1261:            final public void DotSuffix() throws ParseException {
1262:                /*@bgen(jjtree) DotSuffix */
1263:                AstDotSuffix jjtn000 = new AstDotSuffix(JJTDOTSUFFIX);
1264:                boolean jjtc000 = true;
1265:                jjtree.openNodeScope(jjtn000);
1266:                Token t = null;
1267:                try {
1268:                    jj_consume_token(DOT);
1269:                    t = jj_consume_token(IDENTIFIER);
1270:                    jjtree.closeNodeScope(jjtn000, true);
1271:                    jjtc000 = false;
1272:                    jjtn000.setImage(t.image);
1273:                } finally {
1274:                    if (jjtc000) {
1275:                        jjtree.closeNodeScope(jjtn000, true);
1276:                    }
1277:                }
1278:            }
1279:
1280:            /*
1281:             * BracketSuffix
1282:             * Sub Expression Suffix
1283:             */
1284:            final public void BracketSuffix() throws ParseException {
1285:                /*@bgen(jjtree) BracketSuffix */
1286:                AstBracketSuffix jjtn000 = new AstBracketSuffix(
1287:                        JJTBRACKETSUFFIX);
1288:                boolean jjtc000 = true;
1289:                jjtree.openNodeScope(jjtn000);
1290:                try {
1291:                    jj_consume_token(LBRACK);
1292:                    Expression();
1293:                    jj_consume_token(RBRACK);
1294:                } catch (Throwable jjte000) {
1295:                    if (jjtc000) {
1296:                        jjtree.clearNodeScope(jjtn000);
1297:                        jjtc000 = false;
1298:                    } else {
1299:                        jjtree.popNode();
1300:                    }
1301:                    if (jjte000 instanceof  RuntimeException) {
1302:                        {
1303:                            if (true)
1304:                                throw (RuntimeException) jjte000;
1305:                        }
1306:                    }
1307:                    if (jjte000 instanceof  ParseException) {
1308:                        {
1309:                            if (true)
1310:                                throw (ParseException) jjte000;
1311:                        }
1312:                    }
1313:                    {
1314:                        if (true)
1315:                            throw (Error) jjte000;
1316:                    }
1317:                } finally {
1318:                    if (jjtc000) {
1319:                        jjtree.closeNodeScope(jjtn000, true);
1320:                    }
1321:                }
1322:            }
1323:
1324:            /*
1325:             * NonLiteral
1326:             * For Grouped Operations, Identifiers, and Functions
1327:             */
1328:            final public void NonLiteral() throws ParseException {
1329:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1330:                case LPAREN:
1331:                    jj_consume_token(LPAREN);
1332:                    Expression();
1333:                    jj_consume_token(RPAREN);
1334:                    break;
1335:                default:
1336:                    jj_la1[28] = jj_gen;
1337:                    if (jj_2_1(3)) {
1338:                        Function();
1339:                    } else {
1340:                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1341:                        case IDENTIFIER:
1342:                            Identifier();
1343:                            break;
1344:                        default:
1345:                            jj_la1[29] = jj_gen;
1346:                            jj_consume_token(-1);
1347:                            throw new ParseException();
1348:                        }
1349:                    }
1350:                }
1351:            }
1352:
1353:            /*
1354:             * Identifier
1355:             * Java Language Identifier
1356:             */
1357:            final public void Identifier() throws ParseException {
1358:                /*@bgen(jjtree) Identifier */
1359:                AstIdentifier jjtn000 = new AstIdentifier(JJTIDENTIFIER);
1360:                boolean jjtc000 = true;
1361:                jjtree.openNodeScope(jjtn000);
1362:                Token t = null;
1363:                try {
1364:                    t = jj_consume_token(IDENTIFIER);
1365:                    jjtree.closeNodeScope(jjtn000, true);
1366:                    jjtc000 = false;
1367:                    jjtn000.setImage(t.image);
1368:                } finally {
1369:                    if (jjtc000) {
1370:                        jjtree.closeNodeScope(jjtn000, true);
1371:                    }
1372:                }
1373:            }
1374:
1375:            /*
1376:             * Function
1377:             * Namespace:Name(a,b,c)
1378:             */
1379:            final public void Function() throws ParseException {
1380:                /*@bgen(jjtree) Function */
1381:                AstFunction jjtn000 = new AstFunction(JJTFUNCTION);
1382:                boolean jjtc000 = true;
1383:                jjtree.openNodeScope(jjtn000);
1384:                Token t0 = null;
1385:                Token t1 = null;
1386:                try {
1387:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1388:                    case NAMESPACE:
1389:                        t0 = jj_consume_token(NAMESPACE);
1390:                        break;
1391:                    default:
1392:                        jj_la1[30] = jj_gen;
1393:                        ;
1394:                    }
1395:                    t1 = jj_consume_token(IDENTIFIER);
1396:                    if (t0 != null) {
1397:                        jjtn000.setPrefix(t0.image.substring(0, t0.image
1398:                                .length() - 1));
1399:                        jjtn000.setLocalName(t1.image);
1400:                    } else {
1401:                        jjtn000.setLocalName(t1.image);
1402:                    }
1403:                    jj_consume_token(LPAREN);
1404:                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1405:                    case INTEGER_LITERAL:
1406:                    case FLOATING_POINT_LITERAL:
1407:                    case STRING_LITERAL:
1408:                    case TRUE:
1409:                    case FALSE:
1410:                    case NULL:
1411:                    case LPAREN:
1412:                    case NOT0:
1413:                    case NOT1:
1414:                    case EMPTY:
1415:                    case MINUS:
1416:                    case IDENTIFIER:
1417:                    case NAMESPACE:
1418:                        Expression();
1419:                        label_10: while (true) {
1420:                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1421:                            case COMMA:
1422:                                ;
1423:                                break;
1424:                            default:
1425:                                jj_la1[31] = jj_gen;
1426:                                break label_10;
1427:                            }
1428:                            jj_consume_token(COMMA);
1429:                            Expression();
1430:                        }
1431:                        break;
1432:                    default:
1433:                        jj_la1[32] = jj_gen;
1434:                        ;
1435:                    }
1436:                    jj_consume_token(RPAREN);
1437:                } catch (Throwable jjte000) {
1438:                    if (jjtc000) {
1439:                        jjtree.clearNodeScope(jjtn000);
1440:                        jjtc000 = false;
1441:                    } else {
1442:                        jjtree.popNode();
1443:                    }
1444:                    if (jjte000 instanceof  RuntimeException) {
1445:                        {
1446:                            if (true)
1447:                                throw (RuntimeException) jjte000;
1448:                        }
1449:                    }
1450:                    if (jjte000 instanceof  ParseException) {
1451:                        {
1452:                            if (true)
1453:                                throw (ParseException) jjte000;
1454:                        }
1455:                    }
1456:                    {
1457:                        if (true)
1458:                            throw (Error) jjte000;
1459:                    }
1460:                } finally {
1461:                    if (jjtc000) {
1462:                        jjtree.closeNodeScope(jjtn000, true);
1463:                    }
1464:                }
1465:            }
1466:
1467:            /*
1468:             * Literal
1469:             * Reserved Keywords
1470:             */
1471:            final public void Literal() throws ParseException {
1472:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1473:                case TRUE:
1474:                case FALSE:
1475:                    Boolean();
1476:                    break;
1477:                case FLOATING_POINT_LITERAL:
1478:                    FloatingPoint();
1479:                    break;
1480:                case INTEGER_LITERAL:
1481:                    Integer();
1482:                    break;
1483:                case STRING_LITERAL:
1484:                    String();
1485:                    break;
1486:                case NULL:
1487:                    Null();
1488:                    break;
1489:                default:
1490:                    jj_la1[33] = jj_gen;
1491:                    jj_consume_token(-1);
1492:                    throw new ParseException();
1493:                }
1494:            }
1495:
1496:            /*
1497:             * Boolean
1498:             * For 'true' 'false'
1499:             */
1500:            final public void Boolean() throws ParseException {
1501:                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1502:                case TRUE:
1503:                    AstTrue jjtn001 = new AstTrue(JJTTRUE);
1504:                    boolean jjtc001 = true;
1505:                    jjtree.openNodeScope(jjtn001);
1506:                    try {
1507:                        jj_consume_token(TRUE);
1508:                    } finally {
1509:                        if (jjtc001) {
1510:                            jjtree.closeNodeScope(jjtn001, true);
1511:                        }
1512:                    }
1513:                    break;
1514:                case FALSE:
1515:                    AstFalse jjtn002 = new AstFalse(JJTFALSE);
1516:                    boolean jjtc002 = true;
1517:                    jjtree.openNodeScope(jjtn002);
1518:                    try {
1519:                        jj_consume_token(FALSE);
1520:                    } finally {
1521:                        if (jjtc002) {
1522:                            jjtree.closeNodeScope(jjtn002, true);
1523:                        }
1524:                    }
1525:                    break;
1526:                default:
1527:                    jj_la1[34] = jj_gen;
1528:                    jj_consume_token(-1);
1529:                    throw new ParseException();
1530:                }
1531:            }
1532:
1533:            /*
1534:             * FloatinPoint
1535:             * For Decimal and Floating Point Literals
1536:             */
1537:            final public void FloatingPoint() throws ParseException {
1538:                /*@bgen(jjtree) FloatingPoint */
1539:                AstFloatingPoint jjtn000 = new AstFloatingPoint(
1540:                        JJTFLOATINGPOINT);
1541:                boolean jjtc000 = true;
1542:                jjtree.openNodeScope(jjtn000);
1543:                Token t = null;
1544:                try {
1545:                    t = jj_consume_token(FLOATING_POINT_LITERAL);
1546:                    jjtree.closeNodeScope(jjtn000, true);
1547:                    jjtc000 = false;
1548:                    jjtn000.setImage(t.image);
1549:                } finally {
1550:                    if (jjtc000) {
1551:                        jjtree.closeNodeScope(jjtn000, true);
1552:                    }
1553:                }
1554:            }
1555:
1556:            /*
1557:             * Integer
1558:             * For Simple Numeric Literals
1559:             */
1560:            final public void Integer() throws ParseException {
1561:                /*@bgen(jjtree) Integer */
1562:                AstInteger jjtn000 = new AstInteger(JJTINTEGER);
1563:                boolean jjtc000 = true;
1564:                jjtree.openNodeScope(jjtn000);
1565:                Token t = null;
1566:                try {
1567:                    t = jj_consume_token(INTEGER_LITERAL);
1568:                    jjtree.closeNodeScope(jjtn000, true);
1569:                    jjtc000 = false;
1570:                    jjtn000.setImage(t.image);
1571:                } finally {
1572:                    if (jjtc000) {
1573:                        jjtree.closeNodeScope(jjtn000, true);
1574:                    }
1575:                }
1576:            }
1577:
1578:            /*
1579:             * String
1580:             * For Quoted Literals
1581:             */
1582:            final public void String() throws ParseException {
1583:                /*@bgen(jjtree) String */
1584:                AstString jjtn000 = new AstString(JJTSTRING);
1585:                boolean jjtc000 = true;
1586:                jjtree.openNodeScope(jjtn000);
1587:                Token t = null;
1588:                try {
1589:                    t = jj_consume_token(STRING_LITERAL);
1590:                    jjtree.closeNodeScope(jjtn000, true);
1591:                    jjtc000 = false;
1592:                    jjtn000.setImage(t.image);
1593:                } finally {
1594:                    if (jjtc000) {
1595:                        jjtree.closeNodeScope(jjtn000, true);
1596:                    }
1597:                }
1598:            }
1599:
1600:            /*
1601:             * Null
1602:             * For 'null'
1603:             */
1604:            final public void Null() throws ParseException {
1605:                /*@bgen(jjtree) Null */
1606:                AstNull jjtn000 = new AstNull(JJTNULL);
1607:                boolean jjtc000 = true;
1608:                jjtree.openNodeScope(jjtn000);
1609:                try {
1610:                    jj_consume_token(NULL);
1611:                } finally {
1612:                    if (jjtc000) {
1613:                        jjtree.closeNodeScope(jjtn000, true);
1614:                    }
1615:                }
1616:            }
1617:
1618:            final private boolean jj_2_1(int xla) {
1619:                jj_la = xla;
1620:                jj_lastpos = jj_scanpos = token;
1621:                try {
1622:                    return !jj_3_1();
1623:                } catch (LookaheadSuccess ls) {
1624:                    return true;
1625:                } finally {
1626:                    jj_save(0, xla);
1627:                }
1628:            }
1629:
1630:            final private boolean jj_3R_11() {
1631:                Token xsp;
1632:                xsp = jj_scanpos;
1633:                if (jj_scan_token(54))
1634:                    jj_scanpos = xsp;
1635:                if (jj_scan_token(IDENTIFIER))
1636:                    return true;
1637:                if (jj_scan_token(LPAREN))
1638:                    return true;
1639:                xsp = jj_scanpos;
1640:                if (jj_3R_12())
1641:                    jj_scanpos = xsp;
1642:                if (jj_scan_token(RPAREN))
1643:                    return true;
1644:                return false;
1645:            }
1646:
1647:            final private boolean jj_3R_20() {
1648:                if (jj_3R_21())
1649:                    return true;
1650:                return false;
1651:            }
1652:
1653:            final private boolean jj_3R_44() {
1654:                if (jj_scan_token(IDENTIFIER))
1655:                    return true;
1656:                return false;
1657:            }
1658:
1659:            final private boolean jj_3R_19() {
1660:                if (jj_3R_20())
1661:                    return true;
1662:                return false;
1663:            }
1664:
1665:            final private boolean jj_3R_38() {
1666:                if (jj_3R_44())
1667:                    return true;
1668:                return false;
1669:            }
1670:
1671:            final private boolean jj_3_1() {
1672:                if (jj_3R_11())
1673:                    return true;
1674:                return false;
1675:            }
1676:
1677:            final private boolean jj_3R_31() {
1678:                Token xsp;
1679:                xsp = jj_scanpos;
1680:                if (jj_3R_37()) {
1681:                    jj_scanpos = xsp;
1682:                    if (jj_3_1()) {
1683:                        jj_scanpos = xsp;
1684:                        if (jj_3R_38())
1685:                            return true;
1686:                    }
1687:                }
1688:                return false;
1689:            }
1690:
1691:            final private boolean jj_3R_37() {
1692:                if (jj_scan_token(LPAREN))
1693:                    return true;
1694:                return false;
1695:            }
1696:
1697:            final private boolean jj_3R_43() {
1698:                if (jj_scan_token(NULL))
1699:                    return true;
1700:                return false;
1701:            }
1702:
1703:            final private boolean jj_3R_42() {
1704:                if (jj_scan_token(STRING_LITERAL))
1705:                    return true;
1706:                return false;
1707:            }
1708:
1709:            final private boolean jj_3R_18() {
1710:                if (jj_3R_19())
1711:                    return true;
1712:                return false;
1713:            }
1714:
1715:            final private boolean jj_3R_41() {
1716:                if (jj_scan_token(INTEGER_LITERAL))
1717:                    return true;
1718:                return false;
1719:            }
1720:
1721:            final private boolean jj_3R_17() {
1722:                if (jj_3R_18())
1723:                    return true;
1724:                return false;
1725:            }
1726:
1727:            final private boolean jj_3R_40() {
1728:                if (jj_scan_token(FLOATING_POINT_LITERAL))
1729:                    return true;
1730:                return false;
1731:            }
1732:
1733:            final private boolean jj_3R_29() {
1734:                if (jj_3R_31())
1735:                    return true;
1736:                return false;
1737:            }
1738:
1739:            final private boolean jj_3R_46() {
1740:                if (jj_scan_token(FALSE))
1741:                    return true;
1742:                return false;
1743:            }
1744:
1745:            final private boolean jj_3R_16() {
1746:                if (jj_3R_17())
1747:                    return true;
1748:                return false;
1749:            }
1750:
1751:            final private boolean jj_3R_27() {
1752:                Token xsp;
1753:                xsp = jj_scanpos;
1754:                if (jj_3R_28()) {
1755:                    jj_scanpos = xsp;
1756:                    if (jj_3R_29())
1757:                        return true;
1758:                }
1759:                return false;
1760:            }
1761:
1762:            final private boolean jj_3R_28() {
1763:                if (jj_3R_30())
1764:                    return true;
1765:                return false;
1766:            }
1767:
1768:            final private boolean jj_3R_45() {
1769:                if (jj_scan_token(TRUE))
1770:                    return true;
1771:                return false;
1772:            }
1773:
1774:            final private boolean jj_3R_39() {
1775:                Token xsp;
1776:                xsp = jj_scanpos;
1777:                if (jj_3R_45()) {
1778:                    jj_scanpos = xsp;
1779:                    if (jj_3R_46())
1780:                        return true;
1781:                }
1782:                return false;
1783:            }
1784:
1785:            final private boolean jj_3R_15() {
1786:                if (jj_3R_16())
1787:                    return true;
1788:                return false;
1789:            }
1790:
1791:            final private boolean jj_3R_26() {
1792:                if (jj_3R_27())
1793:                    return true;
1794:                return false;
1795:            }
1796:
1797:            final private boolean jj_3R_25() {
1798:                if (jj_3R_26())
1799:                    return true;
1800:                return false;
1801:            }
1802:
1803:            final private boolean jj_3R_36() {
1804:                if (jj_3R_43())
1805:                    return true;
1806:                return false;
1807:            }
1808:
1809:            final private boolean jj_3R_35() {
1810:                if (jj_3R_42())
1811:                    return true;
1812:                return false;
1813:            }
1814:
1815:            final private boolean jj_3R_24() {
1816:                if (jj_scan_token(EMPTY))
1817:                    return true;
1818:                return false;
1819:            }
1820:
1821:            final private boolean jj_3R_34() {
1822:                if (jj_3R_41())
1823:                    return true;
1824:                return false;
1825:            }
1826:
1827:            final private boolean jj_3R_33() {
1828:                if (jj_3R_40())
1829:                    return true;
1830:                return false;
1831:            }
1832:
1833:            final private boolean jj_3R_23() {
1834:                Token xsp;
1835:                xsp = jj_scanpos;
1836:                if (jj_scan_token(37)) {
1837:                    jj_scanpos = xsp;
1838:                    if (jj_scan_token(38))
1839:                        return true;
1840:                }
1841:                return false;
1842:            }
1843:
1844:            final private boolean jj_3R_12() {
1845:                if (jj_3R_13())
1846:                    return true;
1847:                return false;
1848:            }
1849:
1850:            final private boolean jj_3R_22() {
1851:                if (jj_scan_token(MINUS))
1852:                    return true;
1853:                return false;
1854:            }
1855:
1856:            final private boolean jj_3R_21() {
1857:                Token xsp;
1858:                xsp = jj_scanpos;
1859:                if (jj_3R_22()) {
1860:                    jj_scanpos = xsp;
1861:                    if (jj_3R_23()) {
1862:                        jj_scanpos = xsp;
1863:                        if (jj_3R_24()) {
1864:                            jj_scanpos = xsp;
1865:                            if (jj_3R_25())
1866:                                return true;
1867:                        }
1868:                    }
1869:                }
1870:                return false;
1871:            }
1872:
1873:            final private boolean jj_3R_30() {
1874:                Token xsp;
1875:                xsp = jj_scanpos;
1876:                if (jj_3R_32()) {
1877:                    jj_scanpos = xsp;
1878:                    if (jj_3R_33()) {
1879:                        jj_scanpos = xsp;
1880:                        if (jj_3R_34()) {
1881:                            jj_scanpos = xsp;
1882:                            if (jj_3R_35()) {
1883:                                jj_scanpos = xsp;
1884:                                if (jj_3R_36())
1885:                                    return true;
1886:                            }
1887:                        }
1888:                    }
1889:                }
1890:                return false;
1891:            }
1892:
1893:            final private boolean jj_3R_32() {
1894:                if (jj_3R_39())
1895:                    return true;
1896:                return false;
1897:            }
1898:
1899:            final private boolean jj_3R_14() {
1900:                if (jj_3R_15())
1901:                    return true;
1902:                return false;
1903:            }
1904:
1905:            final private boolean jj_3R_13() {
1906:                if (jj_3R_14())
1907:                    return true;
1908:                return false;
1909:            }
1910:
1911:            public ELParserTokenManager token_source;
1912:            SimpleCharStream jj_input_stream;
1913:            public Token token, jj_nt;
1914:            private int jj_ntk;
1915:            private Token jj_scanpos, jj_lastpos;
1916:            private int jj_la;
1917:            public boolean lookingAhead = false;
1918:            private boolean jj_semLA;
1919:            private int jj_gen;
1920:            final private int[] jj_la1 = new int[35];
1921:            static private int[] jj_la1_0;
1922:            static private int[] jj_la1_1;
1923:            static {
1924:                jj_la1_0();
1925:                jj_la1_1();
1926:            }
1927:
1928:            private static void jj_la1_0() {
1929:                jj_la1_0 = new int[] { 0xe, 0xe, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
1930:                        0x0, 0x0, 0x0, 0xfe000000, 0x18000000, 0x6000000,
1931:                        0x80000000, 0x60000000, 0xfe000000, 0x0, 0x0, 0x0, 0x0,
1932:                        0x0, 0x0, 0x0, 0x9d600, 0x240000, 0x9d600, 0x240000,
1933:                        0x80000, 0x0, 0x0, 0x1000000, 0x9d600, 0x1d600, 0xc000, };
1934:            }
1935:
1936:            private static void jj_la1_1() {
1937:                jj_la1_1 = new int[] { 0x0, 0x0, 0x10000, 0x600, 0x600, 0x180,
1938:                        0x180, 0x1e, 0x6, 0x18, 0x1e, 0x1, 0x0, 0x0, 0x1, 0x0,
1939:                        0x1, 0xc000, 0xc000, 0x1e2000, 0x60000, 0x180000,
1940:                        0x1e2000, 0x60, 0x608860, 0x0, 0x600000, 0x0, 0x0,
1941:                        0x200000, 0x400000, 0x0, 0x608860, 0x0, 0x0, };
1942:            }
1943:
1944:            final private JJCalls[] jj_2_rtns = new JJCalls[1];
1945:            private boolean jj_rescan = false;
1946:            private int jj_gc = 0;
1947:
1948:            public ELParser(java.io.InputStream stream) {
1949:                this (stream, null);
1950:            }
1951:
1952:            public ELParser(java.io.InputStream stream, String encoding) {
1953:                try {
1954:                    jj_input_stream = new SimpleCharStream(stream, encoding, 1,
1955:                            1);
1956:                } catch (java.io.UnsupportedEncodingException e) {
1957:                    throw new RuntimeException(e);
1958:                }
1959:                token_source = new ELParserTokenManager(jj_input_stream);
1960:                token = new Token();
1961:                jj_ntk = -1;
1962:                jj_gen = 0;
1963:                for (int i = 0; i < 35; i++)
1964:                    jj_la1[i] = -1;
1965:                for (int i = 0; i < jj_2_rtns.length; i++)
1966:                    jj_2_rtns[i] = new JJCalls();
1967:            }
1968:
1969:            public void ReInit(java.io.InputStream stream) {
1970:                ReInit(stream, null);
1971:            }
1972:
1973:            public void ReInit(java.io.InputStream stream, String encoding) {
1974:                try {
1975:                    jj_input_stream.ReInit(stream, encoding, 1, 1);
1976:                } catch (java.io.UnsupportedEncodingException e) {
1977:                    throw new RuntimeException(e);
1978:                }
1979:                token_source.ReInit(jj_input_stream);
1980:                token = new Token();
1981:                jj_ntk = -1;
1982:                jjtree.reset();
1983:                jj_gen = 0;
1984:                for (int i = 0; i < 35; i++)
1985:                    jj_la1[i] = -1;
1986:                for (int i = 0; i < jj_2_rtns.length; i++)
1987:                    jj_2_rtns[i] = new JJCalls();
1988:            }
1989:
1990:            public ELParser(java.io.Reader stream) {
1991:                jj_input_stream = new SimpleCharStream(stream, 1, 1);
1992:                token_source = new ELParserTokenManager(jj_input_stream);
1993:                token = new Token();
1994:                jj_ntk = -1;
1995:                jj_gen = 0;
1996:                for (int i = 0; i < 35; i++)
1997:                    jj_la1[i] = -1;
1998:                for (int i = 0; i < jj_2_rtns.length; i++)
1999:                    jj_2_rtns[i] = new JJCalls();
2000:            }
2001:
2002:            public void ReInit(java.io.Reader stream) {
2003:                jj_input_stream.ReInit(stream, 1, 1);
2004:                token_source.ReInit(jj_input_stream);
2005:                token = new Token();
2006:                jj_ntk = -1;
2007:                jjtree.reset();
2008:                jj_gen = 0;
2009:                for (int i = 0; i < 35; i++)
2010:                    jj_la1[i] = -1;
2011:                for (int i = 0; i < jj_2_rtns.length; i++)
2012:                    jj_2_rtns[i] = new JJCalls();
2013:            }
2014:
2015:            public ELParser(ELParserTokenManager tm) {
2016:                token_source = tm;
2017:                token = new Token();
2018:                jj_ntk = -1;
2019:                jj_gen = 0;
2020:                for (int i = 0; i < 35; i++)
2021:                    jj_la1[i] = -1;
2022:                for (int i = 0; i < jj_2_rtns.length; i++)
2023:                    jj_2_rtns[i] = new JJCalls();
2024:            }
2025:
2026:            public void ReInit(ELParserTokenManager tm) {
2027:                token_source = tm;
2028:                token = new Token();
2029:                jj_ntk = -1;
2030:                jjtree.reset();
2031:                jj_gen = 0;
2032:                for (int i = 0; i < 35; i++)
2033:                    jj_la1[i] = -1;
2034:                for (int i = 0; i < jj_2_rtns.length; i++)
2035:                    jj_2_rtns[i] = new JJCalls();
2036:            }
2037:
2038:            final private Token jj_consume_token(int kind)
2039:                    throws ParseException {
2040:                Token oldToken;
2041:                if ((oldToken = token).next != null)
2042:                    token = token.next;
2043:                else
2044:                    token = token.next = token_source.getNextToken();
2045:                jj_ntk = -1;
2046:                if (token.kind == kind) {
2047:                    jj_gen++;
2048:                    if (++jj_gc > 100) {
2049:                        jj_gc = 0;
2050:                        for (int i = 0; i < jj_2_rtns.length; i++) {
2051:                            JJCalls c = jj_2_rtns[i];
2052:                            while (c != null) {
2053:                                if (c.gen < jj_gen)
2054:                                    c.first = null;
2055:                                c = c.next;
2056:                            }
2057:                        }
2058:                    }
2059:                    return token;
2060:                }
2061:                token = oldToken;
2062:                jj_kind = kind;
2063:                throw generateParseException();
2064:            }
2065:
2066:            static private final class LookaheadSuccess extends java.lang.Error {
2067:            }
2068:
2069:            final private LookaheadSuccess jj_ls = new LookaheadSuccess();
2070:
2071:            final private boolean jj_scan_token(int kind) {
2072:                if (jj_scanpos == jj_lastpos) {
2073:                    jj_la--;
2074:                    if (jj_scanpos.next == null) {
2075:                        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
2076:                                .getNextToken();
2077:                    } else {
2078:                        jj_lastpos = jj_scanpos = jj_scanpos.next;
2079:                    }
2080:                } else {
2081:                    jj_scanpos = jj_scanpos.next;
2082:                }
2083:                if (jj_rescan) {
2084:                    int i = 0;
2085:                    Token tok = token;
2086:                    while (tok != null && tok != jj_scanpos) {
2087:                        i++;
2088:                        tok = tok.next;
2089:                    }
2090:                    if (tok != null)
2091:                        jj_add_error_token(kind, i);
2092:                }
2093:                if (jj_scanpos.kind != kind)
2094:                    return true;
2095:                if (jj_la == 0 && jj_scanpos == jj_lastpos)
2096:                    throw jj_ls;
2097:                return false;
2098:            }
2099:
2100:            final public Token getNextToken() {
2101:                if (token.next != null)
2102:                    token = token.next;
2103:                else
2104:                    token = token.next = token_source.getNextToken();
2105:                jj_ntk = -1;
2106:                jj_gen++;
2107:                return token;
2108:            }
2109:
2110:            final public Token getToken(int index) {
2111:                Token t = lookingAhead ? jj_scanpos : token;
2112:                for (int i = 0; i < index; i++) {
2113:                    if (t.next != null)
2114:                        t = t.next;
2115:                    else
2116:                        t = t.next = token_source.getNextToken();
2117:                }
2118:                return t;
2119:            }
2120:
2121:            final private int jj_ntk() {
2122:                if ((jj_nt = token.next) == null)
2123:                    return (jj_ntk = (token.next = token_source.getNextToken()).kind);
2124:                else
2125:                    return (jj_ntk = jj_nt.kind);
2126:            }
2127:
2128:            private java.util.Vector jj_expentries = new java.util.Vector();
2129:            private int[] jj_expentry;
2130:            private int jj_kind = -1;
2131:            private int[] jj_lasttokens = new int[100];
2132:            private int jj_endpos;
2133:
2134:            private void jj_add_error_token(int kind, int pos) {
2135:                if (pos >= 100)
2136:                    return;
2137:                if (pos == jj_endpos + 1) {
2138:                    jj_lasttokens[jj_endpos++] = kind;
2139:                } else if (jj_endpos != 0) {
2140:                    jj_expentry = new int[jj_endpos];
2141:                    for (int i = 0; i < jj_endpos; i++) {
2142:                        jj_expentry[i] = jj_lasttokens[i];
2143:                    }
2144:                    boolean exists = false;
2145:                    for (java.util.Enumeration e = jj_expentries.elements(); e
2146:                            .hasMoreElements();) {
2147:                        int[] oldentry = (int[]) (e.nextElement());
2148:                        if (oldentry.length == jj_expentry.length) {
2149:                            exists = true;
2150:                            for (int i = 0; i < jj_expentry.length; i++) {
2151:                                if (oldentry[i] != jj_expentry[i]) {
2152:                                    exists = false;
2153:                                    break;
2154:                                }
2155:                            }
2156:                            if (exists)
2157:                                break;
2158:                        }
2159:                    }
2160:                    if (!exists)
2161:                        jj_expentries.addElement(jj_expentry);
2162:                    if (pos != 0)
2163:                        jj_lasttokens[(jj_endpos = pos) - 1] = kind;
2164:                }
2165:            }
2166:
2167:            public ParseException generateParseException() {
2168:                jj_expentries.removeAllElements();
2169:                boolean[] la1tokens = new boolean[60];
2170:                for (int i = 0; i < 60; i++) {
2171:                    la1tokens[i] = false;
2172:                }
2173:                if (jj_kind >= 0) {
2174:                    la1tokens[jj_kind] = true;
2175:                    jj_kind = -1;
2176:                }
2177:                for (int i = 0; i < 35; i++) {
2178:                    if (jj_la1[i] == jj_gen) {
2179:                        for (int j = 0; j < 32; j++) {
2180:                            if ((jj_la1_0[i] & (1 << j)) != 0) {
2181:                                la1tokens[j] = true;
2182:                            }
2183:                            if ((jj_la1_1[i] & (1 << j)) != 0) {
2184:                                la1tokens[32 + j] = true;
2185:                            }
2186:                        }
2187:                    }
2188:                }
2189:                for (int i = 0; i < 60; i++) {
2190:                    if (la1tokens[i]) {
2191:                        jj_expentry = new int[1];
2192:                        jj_expentry[0] = i;
2193:                        jj_expentries.addElement(jj_expentry);
2194:                    }
2195:                }
2196:                jj_endpos = 0;
2197:                jj_rescan_token();
2198:                jj_add_error_token(0, 0);
2199:                int[][] exptokseq = new int[jj_expentries.size()][];
2200:                for (int i = 0; i < jj_expentries.size(); i++) {
2201:                    exptokseq[i] = (int[]) jj_expentries.elementAt(i);
2202:                }
2203:                return new ParseException(token, exptokseq, tokenImage);
2204:            }
2205:
2206:            final public void enable_tracing() {
2207:            }
2208:
2209:            final public void disable_tracing() {
2210:            }
2211:
2212:            final private void jj_rescan_token() {
2213:                jj_rescan = true;
2214:                for (int i = 0; i < 1; i++) {
2215:                    try {
2216:                        JJCalls p = jj_2_rtns[i];
2217:                        do {
2218:                            if (p.gen > jj_gen) {
2219:                                jj_la = p.arg;
2220:                                jj_lastpos = jj_scanpos = p.first;
2221:                                switch (i) {
2222:                                case 0:
2223:                                    jj_3_1();
2224:                                    break;
2225:                                }
2226:                            }
2227:                            p = p.next;
2228:                        } while (p != null);
2229:                    } catch (LookaheadSuccess ls) {
2230:                    }
2231:                }
2232:                jj_rescan = false;
2233:            }
2234:
2235:            final private void jj_save(int index, int xla) {
2236:                JJCalls p = jj_2_rtns[index];
2237:                while (p.gen > jj_gen) {
2238:                    if (p.next == null) {
2239:                        p = p.next = new JJCalls();
2240:                        break;
2241:                    }
2242:                    p = p.next;
2243:                }
2244:                p.gen = jj_gen + xla - jj_la;
2245:                p.first = token;
2246:                p.arg = xla;
2247:            }
2248:
2249:            static final class JJCalls {
2250:                int gen;
2251:                Token first;
2252:                int arg;
2253:                JJCalls next;
2254:            }
2255:
2256:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.