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: }
|