Source Code Cross Referenced for EJBQL.java in  » J2EE » JOnAS-4.8.6 » org » objectweb » jonas_ejb » deployment » ejbql » 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 » J2EE » JOnAS 4.8.6 » org.objectweb.jonas_ejb.deployment.ejbql 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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