Source Code Cross Referenced for ExpressionParser.java in  » Aspect-oriented » aspectwerkz-2.0 » org » codehaus » aspectwerkz » expression » ast » 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 » Aspect oriented » aspectwerkz 2.0 » org.codehaus.aspectwerkz.expression.ast 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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