0001: /*
0002: * All content copyright (c) 2003-2006 Terracotta, Inc., except as may otherwise be noted in a separate copyright notice. All rights reserved.
0003: */
0004: package com.tc.aspectwerkz.expression.ast;
0005:
0006: import java.lang.reflect.Modifier;
0007: import java.io.Reader;
0008: import java.io.StringReader;
0009:
0010: /**
0011: * Usage:
0012: * <pre>
0013: * ExpressionParser parser = new ExpressionParser(System.in); // can be only one
0014: * ASTRoot root = parser.parse("call(@RequiresNew public * foo.Bar.*(String, ..) AND withincode(* foo.Baz.within(..)");
0015: * Expression expression = new Expression(root);
0016: * ...
0017: * </pre>
0018: * <p/>
0019: * <p/>
0020: * TODO: the grammar is still fragile
0021: *
0022: * @author <a href="mailto:jboner@codehaus.org">Jonas BonŽr</a>
0023: * @author <a href="mailto:alex@gnilux.com">Alexandre Vasseur</a>
0024: * @author <a href="mailto:the_mindstorm@evolva.ro">Alex Popescu</a>
0025: */
0026: public class ExpressionParser/*@bgen(jjtree)*/implements
0027: ExpressionParserTreeConstants, ExpressionParserConstants {/*@bgen(jjtree)*/
0028: protected static JJTExpressionParserState jjtree = new JJTExpressionParserState();
0029:
0030: public ASTRoot parse(String expression) throws ParseException {
0031: return parse(new StringReader(expression));
0032: }
0033:
0034: public ASTRoot parse(Reader reader) throws ParseException {
0035: ReInit(reader);
0036: return Root();
0037: }
0038:
0039: //------------------ Bootstrap ------------------
0040:
0041: /**
0042: * Entry point.
0043: */
0044: static final public ASTRoot Root() throws ParseException {
0045: /*@bgen(jjtree) Root */
0046: ASTRoot jjtn000 = new ASTRoot(JJTROOT);
0047: boolean jjtc000 = true;
0048: jjtree.openNodeScope(jjtn000);
0049: try {
0050: Expression();
0051: jj_consume_token(0);
0052: jjtree.closeNodeScope(jjtn000, true);
0053: jjtc000 = false;
0054: {
0055: if (true)
0056: return jjtn000;
0057: }
0058: } catch (Throwable jjte000) {
0059: if (jjtc000) {
0060: jjtree.clearNodeScope(jjtn000);
0061: jjtc000 = false;
0062: } else {
0063: jjtree.popNode();
0064: }
0065: if (jjte000 instanceof RuntimeException) {
0066: {
0067: if (true)
0068: throw (RuntimeException) jjte000;
0069: }
0070: }
0071: if (jjte000 instanceof ParseException) {
0072: {
0073: if (true)
0074: throw (ParseException) jjte000;
0075: }
0076: }
0077: {
0078: if (true)
0079: throw (Error) jjte000;
0080: }
0081: } finally {
0082: if (jjtc000) {
0083: jjtree.closeNodeScope(jjtn000, true);
0084: }
0085: }
0086: throw new Error("Missing return statement in function");
0087: }
0088:
0089: /**
0090: * Expression.
0091: */
0092: static final public void Expression() throws ParseException {
0093: /*@bgen(jjtree) Expression */
0094: ASTExpression jjtn000 = new ASTExpression(JJTEXPRESSION);
0095: boolean jjtc000 = true;
0096: jjtree.openNodeScope(jjtn000);
0097: try {
0098: AndExpression();
0099: } catch (Throwable jjte000) {
0100: if (jjtc000) {
0101: jjtree.clearNodeScope(jjtn000);
0102: jjtc000 = false;
0103: } else {
0104: jjtree.popNode();
0105: }
0106: if (jjte000 instanceof RuntimeException) {
0107: {
0108: if (true)
0109: throw (RuntimeException) jjte000;
0110: }
0111: }
0112: if (jjte000 instanceof ParseException) {
0113: {
0114: if (true)
0115: throw (ParseException) jjte000;
0116: }
0117: }
0118: {
0119: if (true)
0120: throw (Error) jjte000;
0121: }
0122: } finally {
0123: if (jjtc000) {
0124: jjtree.closeNodeScope(jjtn000, true);
0125: }
0126: }
0127: }
0128:
0129: //------------------ Logical operators ------------------
0130:
0131: /**
0132: * AndExpression.
0133: */
0134: static final public void AndExpression() throws ParseException {
0135: ASTAnd jjtn001 = new ASTAnd(JJTAND);
0136: boolean jjtc001 = true;
0137: jjtree.openNodeScope(jjtn001);
0138: try {
0139: OrExpression();
0140: label_1: while (true) {
0141: if (jj_2_1(2)) {
0142: ;
0143: } else {
0144: break label_1;
0145: }
0146: jj_consume_token(AND);
0147: OrExpression();
0148: }
0149: } catch (Throwable jjte001) {
0150: if (jjtc001) {
0151: jjtree.clearNodeScope(jjtn001);
0152: jjtc001 = false;
0153: } else {
0154: jjtree.popNode();
0155: }
0156: if (jjte001 instanceof RuntimeException) {
0157: {
0158: if (true)
0159: throw (RuntimeException) jjte001;
0160: }
0161: }
0162: if (jjte001 instanceof ParseException) {
0163: {
0164: if (true)
0165: throw (ParseException) jjte001;
0166: }
0167: }
0168: {
0169: if (true)
0170: throw (Error) jjte001;
0171: }
0172: } finally {
0173: if (jjtc001) {
0174: jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
0175: }
0176: }
0177: }
0178:
0179: /**
0180: * OrExpression.
0181: */
0182: static final public void OrExpression() throws ParseException {
0183: ASTOr jjtn001 = new ASTOr(JJTOR);
0184: boolean jjtc001 = true;
0185: jjtree.openNodeScope(jjtn001);
0186: try {
0187: UnaryExpression();
0188: label_2: while (true) {
0189: if (jj_2_2(2)) {
0190: ;
0191: } else {
0192: break label_2;
0193: }
0194: jj_consume_token(OR);
0195: AndExpression();
0196: }
0197: } catch (Throwable jjte001) {
0198: if (jjtc001) {
0199: jjtree.clearNodeScope(jjtn001);
0200: jjtc001 = false;
0201: } else {
0202: jjtree.popNode();
0203: }
0204: if (jjte001 instanceof RuntimeException) {
0205: {
0206: if (true)
0207: throw (RuntimeException) jjte001;
0208: }
0209: }
0210: if (jjte001 instanceof ParseException) {
0211: {
0212: if (true)
0213: throw (ParseException) jjte001;
0214: }
0215: }
0216: {
0217: if (true)
0218: throw (Error) jjte001;
0219: }
0220: } finally {
0221: if (jjtc001) {
0222: jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
0223: }
0224: }
0225: }
0226:
0227: /**
0228: * UnaryExpression.
0229: */
0230: static final public void UnaryExpression() throws ParseException {
0231: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0232: case NOT:
0233: NotExpression();
0234: break;
0235: case 86:
0236: jj_consume_token(86);
0237: Expression();
0238: jj_consume_token(87);
0239: break;
0240: case EXECUTION:
0241: case CALL:
0242: case SET:
0243: case GET:
0244: case HANDLER:
0245: case WITHIN:
0246: case WITHIN_CODE:
0247: case STATIC_INITIALIZATION:
0248: case CFLOW:
0249: case CFLOW_BELOW:
0250: case ARGS:
0251: case TARGET:
0252: case THIS:
0253: case IF:
0254: case HAS_METHOD:
0255: case HAS_FIELD:
0256: case POINTCUT_REFERENCE_WITH_ARGS:
0257: case POINTCUT_REFERENCE:
0258: Pointcut();
0259: break;
0260: default:
0261: jj_la1[0] = jj_gen;
0262: jj_consume_token(-1);
0263: throw new ParseException();
0264: }
0265: }
0266:
0267: /**
0268: * NotExpression.
0269: */
0270: static final public void NotExpression() throws ParseException {
0271: jj_consume_token(NOT);
0272: ASTNot jjtn001 = new ASTNot(JJTNOT);
0273: boolean jjtc001 = true;
0274: jjtree.openNodeScope(jjtn001);
0275: try {
0276: UnaryExpression();
0277: } catch (Throwable jjte001) {
0278: if (jjtc001) {
0279: jjtree.clearNodeScope(jjtn001);
0280: jjtc001 = false;
0281: } else {
0282: jjtree.popNode();
0283: }
0284: if (jjte001 instanceof RuntimeException) {
0285: {
0286: if (true)
0287: throw (RuntimeException) jjte001;
0288: }
0289: }
0290: if (jjte001 instanceof ParseException) {
0291: {
0292: if (true)
0293: throw (ParseException) jjte001;
0294: }
0295: }
0296: {
0297: if (true)
0298: throw (Error) jjte001;
0299: }
0300: } finally {
0301: if (jjtc001) {
0302: jjtree.closeNodeScope(jjtn001, true);
0303: }
0304: }
0305: }
0306:
0307: //------------------ Pointcuts ------------------
0308:
0309: /**
0310: * Pointcut.
0311: */
0312: static final public void Pointcut() throws ParseException {
0313: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0314: case CALL:
0315: Call();
0316: break;
0317: case EXECUTION:
0318: Execution();
0319: break;
0320: case WITHIN_CODE:
0321: WithinCode();
0322: break;
0323: case HAS_METHOD:
0324: HasMethod();
0325: break;
0326: case SET:
0327: Set();
0328: break;
0329: case GET:
0330: Get();
0331: break;
0332: case HAS_FIELD:
0333: HasField();
0334: break;
0335: case WITHIN:
0336: Within();
0337: break;
0338: case HANDLER:
0339: Handler();
0340: break;
0341: case ARGS:
0342: Args();
0343: break;
0344: case TARGET:
0345: Target();
0346: break;
0347: case THIS:
0348: This();
0349: break;
0350: case CFLOW:
0351: Cflow();
0352: break;
0353: case CFLOW_BELOW:
0354: CflowBelow();
0355: break;
0356: case STATIC_INITIALIZATION:
0357: StaticInitialization();
0358: break;
0359: case IF:
0360: If();
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: /**
1590: * If() marker
1591: */
1592: static final public void If() throws ParseException {
1593: /*@bgen(jjtree) If */
1594: ASTIf jjtn000 = new ASTIf(JJTIF);
1595: boolean jjtc000 = true;
1596: jjtree.openNodeScope(jjtn000);
1597: try {
1598: jj_consume_token(IF);
1599: } finally {
1600: if (jjtc000) {
1601: jjtree.closeNodeScope(jjtn000, true);
1602: }
1603: }
1604: }
1605:
1606: //------------------ Patterns ------------------
1607:
1608: /**
1609: * Class pattern.
1610: */
1611: static final public void ClassPattern() throws ParseException {
1612: /*@bgen(jjtree) ClassPattern */
1613: ASTClassPattern jjtn000 = new ASTClassPattern(JJTCLASSPATTERN);
1614: boolean jjtc000 = true;
1615: jjtree.openNodeScope(jjtn000);
1616: Token pattern;
1617: try {
1618: label_14: while (true) {
1619: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1620: case CLASS_PRIVATE:
1621: case CLASS_PROTECTED:
1622: case CLASS_PUBLIC:
1623: case CLASS_STATIC:
1624: case CLASS_ABSTRACT:
1625: case CLASS_FINAL:
1626: case CLASS_NOT:
1627: ;
1628: break;
1629: default:
1630: jj_la1[25] = jj_gen;
1631: break label_14;
1632: }
1633: ClassModifier();
1634: }
1635: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1636: case CLASS_PATTERN:
1637: pattern = jj_consume_token(CLASS_PATTERN);
1638: break;
1639: case EAGER_WILDCARD:
1640: pattern = jj_consume_token(EAGER_WILDCARD);
1641: break;
1642: default:
1643: jj_la1[26] = jj_gen;
1644: jj_consume_token(-1);
1645: throw new ParseException();
1646: }
1647: jjtree.closeNodeScope(jjtn000, true);
1648: jjtc000 = false;
1649: jjtn000.setTypePattern(pattern.image);
1650: } catch (Throwable jjte000) {
1651: if (jjtc000) {
1652: jjtree.clearNodeScope(jjtn000);
1653: jjtc000 = false;
1654: } else {
1655: jjtree.popNode();
1656: }
1657: if (jjte000 instanceof RuntimeException) {
1658: {
1659: if (true)
1660: throw (RuntimeException) jjte000;
1661: }
1662: }
1663: if (jjte000 instanceof ParseException) {
1664: {
1665: if (true)
1666: throw (ParseException) jjte000;
1667: }
1668: }
1669: {
1670: if (true)
1671: throw (Error) jjte000;
1672: }
1673: } finally {
1674: if (jjtc000) {
1675: jjtree.closeNodeScope(jjtn000, true);
1676: }
1677: }
1678: }
1679:
1680: /**
1681: * Method pattern.
1682: *
1683: * @TODO: split class name and method name.
1684: * @TODO: handle '+'.
1685: * @TODO: put method name, return type and declaring class in different nodes.
1686: */
1687: static final public void MethodPattern() throws ParseException {
1688: /*@bgen(jjtree) MethodPattern */
1689: ASTMethodPattern jjtn000 = new ASTMethodPattern(
1690: JJTMETHODPATTERN);
1691: boolean jjtc000 = true;
1692: jjtree.openNodeScope(jjtn000);
1693: Token returnType, name;
1694: try {
1695: label_15: while (true) {
1696: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1697: case METHOD_PUBLIC:
1698: case METHOD_PROTECTED:
1699: case METHOD_PRIVATE:
1700: case METHOD_STATIC:
1701: case METHOD_ABSTRACT:
1702: case METHOD_FINAL:
1703: case METHOD_NATIVE:
1704: case METHOD_SYNCHRONIZED:
1705: case METHOD_NOT:
1706: ;
1707: break;
1708: default:
1709: jj_la1[27] = jj_gen;
1710: break label_15;
1711: }
1712: MethodModifier();
1713: }
1714: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1715: case METHOD_CLASS_PATTERN:
1716: returnType = jj_consume_token(METHOD_CLASS_PATTERN);
1717: break;
1718: case METHOD_ARRAY_CLASS_PATTERN:
1719: returnType = jj_consume_token(METHOD_ARRAY_CLASS_PATTERN);
1720: break;
1721: default:
1722: jj_la1[28] = jj_gen;
1723: jj_consume_token(-1);
1724: throw new ParseException();
1725: }
1726: jjtn000.setReturnTypePattern(returnType.image);
1727: name = jj_consume_token(METHOD_CLASS_PATTERN);
1728: jjtn000.setFullNamePattern(name.image);
1729: Parameters();
1730: } catch (Throwable jjte000) {
1731: if (jjtc000) {
1732: jjtree.clearNodeScope(jjtn000);
1733: jjtc000 = false;
1734: } else {
1735: jjtree.popNode();
1736: }
1737: if (jjte000 instanceof RuntimeException) {
1738: {
1739: if (true)
1740: throw (RuntimeException) jjte000;
1741: }
1742: }
1743: if (jjte000 instanceof ParseException) {
1744: {
1745: if (true)
1746: throw (ParseException) jjte000;
1747: }
1748: }
1749: {
1750: if (true)
1751: throw (Error) jjte000;
1752: }
1753: } finally {
1754: if (jjtc000) {
1755: jjtree.closeNodeScope(jjtn000, true);
1756: }
1757: }
1758: }
1759:
1760: /**
1761: * Constructor pattern.
1762: *
1763: * @TODO: split class name and constructor name ('new').
1764: * @TODO: handle '+'.
1765: * @TODO: put declaring class in a different node.
1766: */
1767: static final public void ConstructorPattern() throws ParseException {
1768: /*@bgen(jjtree) ConstructorPattern */
1769: ASTConstructorPattern jjtn000 = new ASTConstructorPattern(
1770: JJTCONSTRUCTORPATTERN);
1771: boolean jjtc000 = true;
1772: jjtree.openNodeScope(jjtn000);
1773: Token name;
1774: try {
1775: label_16: while (true) {
1776: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1777: case METHOD_PUBLIC:
1778: case METHOD_PROTECTED:
1779: case METHOD_PRIVATE:
1780: case METHOD_SYNCHRONIZED:
1781: case METHOD_NOT:
1782: ;
1783: break;
1784: default:
1785: jj_la1[29] = jj_gen;
1786: break label_16;
1787: }
1788: ConstructorModifier();
1789: }
1790: name = jj_consume_token(METHOD_CLASS_PATTERN);
1791: if (!name.image.endsWith("new")) {
1792: {
1793: if (true)
1794: throw new RuntimeException(
1795: "constructor pattern must have 'new' as method name");
1796: }
1797: }
1798: jjtn000.setFullNamePattern(name.image);
1799: Parameters();
1800: } catch (Throwable jjte000) {
1801: if (jjtc000) {
1802: jjtree.clearNodeScope(jjtn000);
1803: jjtc000 = false;
1804: } else {
1805: jjtree.popNode();
1806: }
1807: if (jjte000 instanceof RuntimeException) {
1808: {
1809: if (true)
1810: throw (RuntimeException) jjte000;
1811: }
1812: }
1813: if (jjte000 instanceof ParseException) {
1814: {
1815: if (true)
1816: throw (ParseException) jjte000;
1817: }
1818: }
1819: {
1820: if (true)
1821: throw (Error) jjte000;
1822: }
1823: } finally {
1824: if (jjtc000) {
1825: jjtree.closeNodeScope(jjtn000, true);
1826: }
1827: }
1828: }
1829:
1830: /**
1831: * Field pattern.
1832: *
1833: * @TODO: split class name and field name.
1834: * @TODO: handle '+'.
1835: * @TODO: put field name, field type and declaring class in different nodes.
1836: */
1837: static final public void FieldPattern() throws ParseException {
1838: /*@bgen(jjtree) FieldPattern */
1839: ASTFieldPattern jjtn000 = new ASTFieldPattern(JJTFIELDPATTERN);
1840: boolean jjtc000 = true;
1841: jjtree.openNodeScope(jjtn000);
1842: Token type, name;
1843: try {
1844: label_17: while (true) {
1845: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1846: case FIELD_PRIVATE:
1847: case FIELD_PROTECTED:
1848: case FIELD_PUBLIC:
1849: case FIELD_STATIC:
1850: case FIELD_ABSTRACT:
1851: case FIELD_FINAL:
1852: case FIELD_TRANSIENT:
1853: case FIELD_NOT:
1854: ;
1855: break;
1856: default:
1857: jj_la1[30] = jj_gen;
1858: break label_17;
1859: }
1860: FieldModifier();
1861: }
1862: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1863: case FIELD_CLASS_PATTERN:
1864: type = jj_consume_token(FIELD_CLASS_PATTERN);
1865: break;
1866: case FIELD_ARRAY_CLASS_PATTERN:
1867: type = jj_consume_token(FIELD_ARRAY_CLASS_PATTERN);
1868: break;
1869: default:
1870: jj_la1[31] = jj_gen;
1871: jj_consume_token(-1);
1872: throw new ParseException();
1873: }
1874: jjtn000.setFieldTypePattern(type.image);
1875: name = jj_consume_token(FIELD_CLASS_PATTERN);
1876: jjtree.closeNodeScope(jjtn000, true);
1877: jjtc000 = false;
1878: jjtn000.setFullNamePattern(name.image);
1879: } catch (Throwable jjte000) {
1880: if (jjtc000) {
1881: jjtree.clearNodeScope(jjtn000);
1882: jjtc000 = false;
1883: } else {
1884: jjtree.popNode();
1885: }
1886: if (jjte000 instanceof RuntimeException) {
1887: {
1888: if (true)
1889: throw (RuntimeException) jjte000;
1890: }
1891: }
1892: if (jjte000 instanceof ParseException) {
1893: {
1894: if (true)
1895: throw (ParseException) jjte000;
1896: }
1897: }
1898: {
1899: if (true)
1900: throw (Error) jjte000;
1901: }
1902: } finally {
1903: if (jjtc000) {
1904: jjtree.closeNodeScope(jjtn000, true);
1905: }
1906: }
1907: }
1908:
1909: /**
1910: * Parameters.
1911: */
1912: static final public void Parameters() throws ParseException {
1913: jj_consume_token(METHOD_PARAMETER_START);
1914: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1915: case EAGER_WILDCARD:
1916: case METHOD_CLASS_PATTERN:
1917: case METHOD_ARRAY_CLASS_PATTERN:
1918: Parameter();
1919: label_18: while (true) {
1920: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1921: case COMMA:
1922: ;
1923: break;
1924: default:
1925: jj_la1[32] = jj_gen;
1926: break label_18;
1927: }
1928: jj_consume_token(COMMA);
1929: Parameter();
1930: }
1931: break;
1932: default:
1933: jj_la1[33] = jj_gen;
1934: ;
1935: }
1936: jj_consume_token(METHOD_PARAMETER_END);
1937: }
1938:
1939: /**
1940: * Parameter pattern.
1941: */
1942: static final public void Parameter() throws ParseException {
1943: /*@bgen(jjtree) Parameter */
1944: ASTParameter jjtn000 = new ASTParameter(JJTPARAMETER);
1945: boolean jjtc000 = true;
1946: jjtree.openNodeScope(jjtn000);
1947: Token parameter;
1948: try {
1949: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1950: case METHOD_CLASS_PATTERN:
1951: parameter = jj_consume_token(METHOD_CLASS_PATTERN);
1952: break;
1953: case METHOD_ARRAY_CLASS_PATTERN:
1954: parameter = jj_consume_token(METHOD_ARRAY_CLASS_PATTERN);
1955: break;
1956: case EAGER_WILDCARD:
1957: parameter = jj_consume_token(EAGER_WILDCARD);
1958: break;
1959: default:
1960: jj_la1[34] = jj_gen;
1961: jj_consume_token(-1);
1962: throw new ParseException();
1963: }
1964: jjtree.closeNodeScope(jjtn000, true);
1965: jjtc000 = false;
1966: jjtn000.setTypePattern(parameter.image);
1967: } finally {
1968: if (jjtc000) {
1969: jjtree.closeNodeScope(jjtn000, true);
1970: }
1971: }
1972: }
1973:
1974: /**
1975: * ArgsParameters.
1976: */
1977: static final public void ArgsParameters() throws ParseException {
1978: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1979: case EAGER_WILDCARD:
1980: case ARG_PATTERN:
1981: case ARG_ARRAY_PATTERN:
1982: ArgParameter();
1983: break;
1984: default:
1985: jj_la1[35] = jj_gen;
1986: ;
1987: }
1988: label_19: while (true) {
1989: if (jj_2_18(2)) {
1990: ;
1991: } else {
1992: break label_19;
1993: }
1994: jj_consume_token(COMMA);
1995: ArgsParameters();
1996: }
1997: }
1998:
1999: /**
2000: * ArgParameter.
2001: */
2002: static final public void ArgParameter() throws ParseException {
2003: /*@bgen(jjtree) ArgParameter */
2004: ASTArgParameter jjtn000 = new ASTArgParameter(JJTARGPARAMETER);
2005: boolean jjtc000 = true;
2006: jjtree.openNodeScope(jjtn000);
2007: Token t;
2008: try {
2009: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2010: case ARG_PATTERN:
2011: t = jj_consume_token(ARG_PATTERN);
2012: break;
2013: case ARG_ARRAY_PATTERN:
2014: t = jj_consume_token(ARG_ARRAY_PATTERN);
2015: break;
2016: case EAGER_WILDCARD:
2017: t = jj_consume_token(EAGER_WILDCARD);
2018: break;
2019: default:
2020: jj_la1[36] = jj_gen;
2021: jj_consume_token(-1);
2022: throw new ParseException();
2023: }
2024: jjtree.closeNodeScope(jjtn000, true);
2025: jjtc000 = false;
2026: jjtn000.setTypePattern(t.image);
2027: } finally {
2028: if (jjtc000) {
2029: jjtree.closeNodeScope(jjtn000, true);
2030: }
2031: }
2032: }
2033:
2034: /**
2035: * Class annotation.
2036: */
2037: static final public void ClassAttribute() throws ParseException {
2038: /*@bgen(jjtree) Attribute */
2039: ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
2040: boolean jjtc000 = true;
2041: jjtree.openNodeScope(jjtn000);
2042: Token annotation;
2043: try {
2044: label_20: while (true) {
2045: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2046: case CLASS_NOT:
2047: ;
2048: break;
2049: default:
2050: jj_la1[37] = jj_gen;
2051: break label_20;
2052: }
2053: jj_consume_token(CLASS_NOT);
2054: jjtn000.toggleNot();
2055: }
2056: annotation = jj_consume_token(CLASS_ATTRIBUTE);
2057: jjtree.closeNodeScope(jjtn000, true);
2058: jjtc000 = false;
2059: jjtn000.setName(annotation.image);
2060: } finally {
2061: if (jjtc000) {
2062: jjtree.closeNodeScope(jjtn000, true);
2063: }
2064: }
2065: }
2066:
2067: /**
2068: * Method annotation.
2069: */
2070: static final public void MethodAttribute() throws ParseException {
2071: /*@bgen(jjtree) Attribute */
2072: ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
2073: boolean jjtc000 = true;
2074: jjtree.openNodeScope(jjtn000);
2075: Token annotation;
2076: try {
2077: label_21: while (true) {
2078: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2079: case METHOD_NOT:
2080: ;
2081: break;
2082: default:
2083: jj_la1[38] = jj_gen;
2084: break label_21;
2085: }
2086: jj_consume_token(METHOD_NOT);
2087: jjtn000.toggleNot();
2088: }
2089: annotation = jj_consume_token(METHOD_ANNOTATION);
2090: jjtree.closeNodeScope(jjtn000, true);
2091: jjtc000 = false;
2092: jjtn000.setName(annotation.image);
2093: } finally {
2094: if (jjtc000) {
2095: jjtree.closeNodeScope(jjtn000, true);
2096: }
2097: }
2098: }
2099:
2100: /**
2101: * Field annotation.
2102: */
2103: static final public void FieldAttribute() throws ParseException {
2104: /*@bgen(jjtree) Attribute */
2105: ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
2106: boolean jjtc000 = true;
2107: jjtree.openNodeScope(jjtn000);
2108: Token annotation;
2109: try {
2110: label_22: while (true) {
2111: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2112: case FIELD_NOT:
2113: ;
2114: break;
2115: default:
2116: jj_la1[39] = jj_gen;
2117: break label_22;
2118: }
2119: jj_consume_token(FIELD_NOT);
2120: jjtn000.toggleNot();
2121: }
2122: annotation = jj_consume_token(FIELD_ANNOTATION);
2123: jjtree.closeNodeScope(jjtn000, true);
2124: jjtc000 = false;
2125: jjtn000.setName(annotation.image);
2126: } finally {
2127: if (jjtc000) {
2128: jjtree.closeNodeScope(jjtn000, true);
2129: }
2130: }
2131: }
2132:
2133: /**
2134: * Class modifier.
2135: */
2136: static final public void ClassModifier() throws ParseException {
2137: /*@bgen(jjtree) Modifier */
2138: ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
2139: boolean jjtc000 = true;
2140: jjtree.openNodeScope(jjtn000);
2141: try {
2142: label_23: while (true) {
2143: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2144: case CLASS_NOT:
2145: ;
2146: break;
2147: default:
2148: jj_la1[40] = jj_gen;
2149: break label_23;
2150: }
2151: jj_consume_token(CLASS_NOT);
2152: jjtn000.toggleNot();
2153: }
2154: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2155: case CLASS_PUBLIC:
2156: jj_consume_token(CLASS_PUBLIC);
2157: jjtree.closeNodeScope(jjtn000, true);
2158: jjtc000 = false;
2159: jjtn000.setModifier(Modifier.PUBLIC);
2160: break;
2161: case CLASS_PROTECTED:
2162: jj_consume_token(CLASS_PROTECTED);
2163: jjtree.closeNodeScope(jjtn000, true);
2164: jjtc000 = false;
2165: jjtn000.setModifier(Modifier.PROTECTED);
2166: break;
2167: case CLASS_PRIVATE:
2168: jj_consume_token(CLASS_PRIVATE);
2169: jjtree.closeNodeScope(jjtn000, true);
2170: jjtc000 = false;
2171: jjtn000.setModifier(Modifier.PRIVATE);
2172: break;
2173: case CLASS_STATIC:
2174: jj_consume_token(CLASS_STATIC);
2175: jjtree.closeNodeScope(jjtn000, true);
2176: jjtc000 = false;
2177: jjtn000.setModifier(Modifier.STATIC);
2178: break;
2179: case CLASS_ABSTRACT:
2180: jj_consume_token(CLASS_ABSTRACT);
2181: jjtree.closeNodeScope(jjtn000, true);
2182: jjtc000 = false;
2183: jjtn000.setModifier(Modifier.ABSTRACT);
2184: break;
2185: case CLASS_FINAL:
2186: jj_consume_token(CLASS_FINAL);
2187: jjtree.closeNodeScope(jjtn000, true);
2188: jjtc000 = false;
2189: jjtn000.setModifier(Modifier.FINAL);
2190: break;
2191: default:
2192: jj_la1[41] = jj_gen;
2193: jj_consume_token(-1);
2194: throw new ParseException();
2195: }
2196: } finally {
2197: if (jjtc000) {
2198: jjtree.closeNodeScope(jjtn000, true);
2199: }
2200: }
2201: }
2202:
2203: /**
2204: * Method modifier.
2205: */
2206: static final public void StaticInitializationPatternModifier()
2207: throws ParseException {
2208: /*@bgen(jjtree) Modifier */
2209: ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
2210: boolean jjtc000 = true;
2211: jjtree.openNodeScope(jjtn000);
2212: try {
2213: label_24: while (true) {
2214: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2215: case METHOD_NOT:
2216: ;
2217: break;
2218: default:
2219: jj_la1[42] = jj_gen;
2220: break label_24;
2221: }
2222: jj_consume_token(METHOD_NOT);
2223: jjtn000.toggleNot();
2224: }
2225: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2226: case METHOD_PUBLIC:
2227: jj_consume_token(METHOD_PUBLIC);
2228: jjtree.closeNodeScope(jjtn000, true);
2229: jjtc000 = false;
2230: jjtn000.setModifier(Modifier.PUBLIC);
2231: break;
2232: case METHOD_PROTECTED:
2233: jj_consume_token(METHOD_PROTECTED);
2234: jjtree.closeNodeScope(jjtn000, true);
2235: jjtc000 = false;
2236: jjtn000.setModifier(Modifier.PROTECTED);
2237: break;
2238: case METHOD_PRIVATE:
2239: jj_consume_token(METHOD_PRIVATE);
2240: jjtree.closeNodeScope(jjtn000, true);
2241: jjtc000 = false;
2242: jjtn000.setModifier(Modifier.PRIVATE);
2243: break;
2244: case METHOD_STATIC:
2245: jj_consume_token(METHOD_STATIC);
2246: jjtree.closeNodeScope(jjtn000, true);
2247: jjtc000 = false;
2248: jjtn000.setModifier(Modifier.STATIC);
2249: break;
2250: case METHOD_ABSTRACT:
2251: jj_consume_token(METHOD_ABSTRACT);
2252: jjtree.closeNodeScope(jjtn000, true);
2253: jjtc000 = false;
2254: jjtn000.setModifier(Modifier.ABSTRACT);
2255: break;
2256: case METHOD_FINAL:
2257: jj_consume_token(METHOD_FINAL);
2258: jjtree.closeNodeScope(jjtn000, true);
2259: jjtc000 = false;
2260: jjtn000.setModifier(Modifier.FINAL);
2261: break;
2262: default:
2263: jj_la1[43] = jj_gen;
2264: jj_consume_token(-1);
2265: throw new ParseException();
2266: }
2267: } finally {
2268: if (jjtc000) {
2269: jjtree.closeNodeScope(jjtn000, true);
2270: }
2271: }
2272: }
2273:
2274: /**
2275: * Method modifier.
2276: */
2277: static final public void MethodModifier() throws ParseException {
2278: /*@bgen(jjtree) Modifier */
2279: ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
2280: boolean jjtc000 = true;
2281: jjtree.openNodeScope(jjtn000);
2282: try {
2283: label_25: while (true) {
2284: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2285: case METHOD_NOT:
2286: ;
2287: break;
2288: default:
2289: jj_la1[44] = jj_gen;
2290: break label_25;
2291: }
2292: jj_consume_token(METHOD_NOT);
2293: jjtn000.toggleNot();
2294: }
2295: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2296: case METHOD_PUBLIC:
2297: jj_consume_token(METHOD_PUBLIC);
2298: jjtree.closeNodeScope(jjtn000, true);
2299: jjtc000 = false;
2300: jjtn000.setModifier(Modifier.PUBLIC);
2301: break;
2302: case METHOD_PROTECTED:
2303: jj_consume_token(METHOD_PROTECTED);
2304: jjtree.closeNodeScope(jjtn000, true);
2305: jjtc000 = false;
2306: jjtn000.setModifier(Modifier.PROTECTED);
2307: break;
2308: case METHOD_PRIVATE:
2309: jj_consume_token(METHOD_PRIVATE);
2310: jjtree.closeNodeScope(jjtn000, true);
2311: jjtc000 = false;
2312: jjtn000.setModifier(Modifier.PRIVATE);
2313: break;
2314: case METHOD_STATIC:
2315: jj_consume_token(METHOD_STATIC);
2316: jjtree.closeNodeScope(jjtn000, true);
2317: jjtc000 = false;
2318: jjtn000.setModifier(Modifier.STATIC);
2319: break;
2320: case METHOD_ABSTRACT:
2321: jj_consume_token(METHOD_ABSTRACT);
2322: jjtree.closeNodeScope(jjtn000, true);
2323: jjtc000 = false;
2324: jjtn000.setModifier(Modifier.ABSTRACT);
2325: break;
2326: case METHOD_FINAL:
2327: jj_consume_token(METHOD_FINAL);
2328: jjtree.closeNodeScope(jjtn000, true);
2329: jjtc000 = false;
2330: jjtn000.setModifier(Modifier.FINAL);
2331: break;
2332: case METHOD_NATIVE:
2333: jj_consume_token(METHOD_NATIVE);
2334: jjtree.closeNodeScope(jjtn000, true);
2335: jjtc000 = false;
2336: jjtn000.setModifier(Modifier.NATIVE);
2337: break;
2338: case METHOD_SYNCHRONIZED:
2339: jj_consume_token(METHOD_SYNCHRONIZED);
2340: jjtree.closeNodeScope(jjtn000, true);
2341: jjtc000 = false;
2342: jjtn000.setModifier(Modifier.SYNCHRONIZED);
2343: break;
2344: default:
2345: jj_la1[45] = jj_gen;
2346: jj_consume_token(-1);
2347: throw new ParseException();
2348: }
2349: } finally {
2350: if (jjtc000) {
2351: jjtree.closeNodeScope(jjtn000, true);
2352: }
2353: }
2354: }
2355:
2356: /**
2357: * Constructor modifier.
2358: */
2359: static final public void ConstructorModifier()
2360: throws ParseException {
2361: /*@bgen(jjtree) Modifier */
2362: ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
2363: boolean jjtc000 = true;
2364: jjtree.openNodeScope(jjtn000);
2365: try {
2366: label_26: while (true) {
2367: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2368: case METHOD_NOT:
2369: ;
2370: break;
2371: default:
2372: jj_la1[46] = jj_gen;
2373: break label_26;
2374: }
2375: jj_consume_token(METHOD_NOT);
2376: jjtn000.toggleNot();
2377: }
2378: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2379: case METHOD_PUBLIC:
2380: jj_consume_token(METHOD_PUBLIC);
2381: jjtree.closeNodeScope(jjtn000, true);
2382: jjtc000 = false;
2383: jjtn000.setModifier(Modifier.PUBLIC);
2384: break;
2385: case METHOD_PROTECTED:
2386: jj_consume_token(METHOD_PROTECTED);
2387: jjtree.closeNodeScope(jjtn000, true);
2388: jjtc000 = false;
2389: jjtn000.setModifier(Modifier.PROTECTED);
2390: break;
2391: case METHOD_PRIVATE:
2392: jj_consume_token(METHOD_PRIVATE);
2393: jjtree.closeNodeScope(jjtn000, true);
2394: jjtc000 = false;
2395: jjtn000.setModifier(Modifier.PRIVATE);
2396: break;
2397: case METHOD_SYNCHRONIZED:
2398: jj_consume_token(METHOD_SYNCHRONIZED);
2399: jjtree.closeNodeScope(jjtn000, true);
2400: jjtc000 = false;
2401: jjtn000.setModifier(Modifier.SYNCHRONIZED);
2402: break;
2403: default:
2404: jj_la1[47] = jj_gen;
2405: jj_consume_token(-1);
2406: throw new ParseException();
2407: }
2408: } finally {
2409: if (jjtc000) {
2410: jjtree.closeNodeScope(jjtn000, true);
2411: }
2412: }
2413: }
2414:
2415: /**
2416: * Field modifier.
2417: */
2418: static final public void FieldModifier() throws ParseException {
2419: /*@bgen(jjtree) Modifier */
2420: ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
2421: boolean jjtc000 = true;
2422: jjtree.openNodeScope(jjtn000);
2423: try {
2424: label_27: while (true) {
2425: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2426: case FIELD_NOT:
2427: ;
2428: break;
2429: default:
2430: jj_la1[48] = jj_gen;
2431: break label_27;
2432: }
2433: jj_consume_token(FIELD_NOT);
2434: jjtn000.toggleNot();
2435: }
2436: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2437: case FIELD_PUBLIC:
2438: jj_consume_token(FIELD_PUBLIC);
2439: jjtree.closeNodeScope(jjtn000, true);
2440: jjtc000 = false;
2441: jjtn000.setModifier(Modifier.PUBLIC);
2442: break;
2443: case FIELD_PROTECTED:
2444: jj_consume_token(FIELD_PROTECTED);
2445: jjtree.closeNodeScope(jjtn000, true);
2446: jjtc000 = false;
2447: jjtn000.setModifier(Modifier.PROTECTED);
2448: break;
2449: case FIELD_PRIVATE:
2450: jj_consume_token(FIELD_PRIVATE);
2451: jjtree.closeNodeScope(jjtn000, true);
2452: jjtc000 = false;
2453: jjtn000.setModifier(Modifier.PRIVATE);
2454: break;
2455: case FIELD_STATIC:
2456: jj_consume_token(FIELD_STATIC);
2457: jjtree.closeNodeScope(jjtn000, true);
2458: jjtc000 = false;
2459: jjtn000.setModifier(Modifier.STATIC);
2460: break;
2461: case FIELD_ABSTRACT:
2462: jj_consume_token(FIELD_ABSTRACT);
2463: jjtree.closeNodeScope(jjtn000, true);
2464: jjtc000 = false;
2465: jjtn000.setModifier(Modifier.ABSTRACT);
2466: break;
2467: case FIELD_FINAL:
2468: jj_consume_token(FIELD_FINAL);
2469: jjtree.closeNodeScope(jjtn000, true);
2470: jjtc000 = false;
2471: jjtn000.setModifier(Modifier.FINAL);
2472: break;
2473: case FIELD_TRANSIENT:
2474: jj_consume_token(FIELD_TRANSIENT);
2475: jjtree.closeNodeScope(jjtn000, true);
2476: jjtc000 = false;
2477: jjtn000.setModifier(Modifier.TRANSIENT);
2478: break;
2479: default:
2480: jj_la1[49] = jj_gen;
2481: jj_consume_token(-1);
2482: throw new ParseException();
2483: }
2484: } finally {
2485: if (jjtc000) {
2486: jjtree.closeNodeScope(jjtn000, true);
2487: }
2488: }
2489: }
2490:
2491: static final private boolean jj_2_1(int xla) {
2492: jj_la = xla;
2493: jj_lastpos = jj_scanpos = token;
2494: try {
2495: return !jj_3_1();
2496: } catch (LookaheadSuccess ls) {
2497: return true;
2498: } finally {
2499: jj_save(0, xla);
2500: }
2501: }
2502:
2503: static final private boolean jj_2_2(int xla) {
2504: jj_la = xla;
2505: jj_lastpos = jj_scanpos = token;
2506: try {
2507: return !jj_3_2();
2508: } catch (LookaheadSuccess ls) {
2509: return true;
2510: } finally {
2511: jj_save(1, xla);
2512: }
2513: }
2514:
2515: static final private boolean jj_2_3(int xla) {
2516: jj_la = xla;
2517: jj_lastpos = jj_scanpos = token;
2518: try {
2519: return !jj_3_3();
2520: } catch (LookaheadSuccess ls) {
2521: return true;
2522: } finally {
2523: jj_save(2, xla);
2524: }
2525: }
2526:
2527: static final private boolean jj_2_4(int xla) {
2528: jj_la = xla;
2529: jj_lastpos = jj_scanpos = token;
2530: try {
2531: return !jj_3_4();
2532: } catch (LookaheadSuccess ls) {
2533: return true;
2534: } finally {
2535: jj_save(3, xla);
2536: }
2537: }
2538:
2539: static final private boolean jj_2_5(int xla) {
2540: jj_la = xla;
2541: jj_lastpos = jj_scanpos = token;
2542: try {
2543: return !jj_3_5();
2544: } catch (LookaheadSuccess ls) {
2545: return true;
2546: } finally {
2547: jj_save(4, xla);
2548: }
2549: }
2550:
2551: static final private boolean jj_2_6(int xla) {
2552: jj_la = xla;
2553: jj_lastpos = jj_scanpos = token;
2554: try {
2555: return !jj_3_6();
2556: } catch (LookaheadSuccess ls) {
2557: return true;
2558: } finally {
2559: jj_save(5, xla);
2560: }
2561: }
2562:
2563: static final private boolean jj_2_7(int xla) {
2564: jj_la = xla;
2565: jj_lastpos = jj_scanpos = token;
2566: try {
2567: return !jj_3_7();
2568: } catch (LookaheadSuccess ls) {
2569: return true;
2570: } finally {
2571: jj_save(6, xla);
2572: }
2573: }
2574:
2575: static final private boolean jj_2_8(int xla) {
2576: jj_la = xla;
2577: jj_lastpos = jj_scanpos = token;
2578: try {
2579: return !jj_3_8();
2580: } catch (LookaheadSuccess ls) {
2581: return true;
2582: } finally {
2583: jj_save(7, xla);
2584: }
2585: }
2586:
2587: static final private boolean jj_2_9(int xla) {
2588: jj_la = xla;
2589: jj_lastpos = jj_scanpos = token;
2590: try {
2591: return !jj_3_9();
2592: } catch (LookaheadSuccess ls) {
2593: return true;
2594: } finally {
2595: jj_save(8, xla);
2596: }
2597: }
2598:
2599: static final private boolean jj_2_10(int xla) {
2600: jj_la = xla;
2601: jj_lastpos = jj_scanpos = token;
2602: try {
2603: return !jj_3_10();
2604: } catch (LookaheadSuccess ls) {
2605: return true;
2606: } finally {
2607: jj_save(9, xla);
2608: }
2609: }
2610:
2611: static final private boolean jj_2_11(int xla) {
2612: jj_la = xla;
2613: jj_lastpos = jj_scanpos = token;
2614: try {
2615: return !jj_3_11();
2616: } catch (LookaheadSuccess ls) {
2617: return true;
2618: } finally {
2619: jj_save(10, xla);
2620: }
2621: }
2622:
2623: static final private boolean jj_2_12(int xla) {
2624: jj_la = xla;
2625: jj_lastpos = jj_scanpos = token;
2626: try {
2627: return !jj_3_12();
2628: } catch (LookaheadSuccess ls) {
2629: return true;
2630: } finally {
2631: jj_save(11, xla);
2632: }
2633: }
2634:
2635: static final private boolean jj_2_13(int xla) {
2636: jj_la = xla;
2637: jj_lastpos = jj_scanpos = token;
2638: try {
2639: return !jj_3_13();
2640: } catch (LookaheadSuccess ls) {
2641: return true;
2642: } finally {
2643: jj_save(12, xla);
2644: }
2645: }
2646:
2647: static final private boolean jj_2_14(int xla) {
2648: jj_la = xla;
2649: jj_lastpos = jj_scanpos = token;
2650: try {
2651: return !jj_3_14();
2652: } catch (LookaheadSuccess ls) {
2653: return true;
2654: } finally {
2655: jj_save(13, xla);
2656: }
2657: }
2658:
2659: static final private boolean jj_2_15(int xla) {
2660: jj_la = xla;
2661: jj_lastpos = jj_scanpos = token;
2662: try {
2663: return !jj_3_15();
2664: } catch (LookaheadSuccess ls) {
2665: return true;
2666: } finally {
2667: jj_save(14, xla);
2668: }
2669: }
2670:
2671: static final private boolean jj_2_16(int xla) {
2672: jj_la = xla;
2673: jj_lastpos = jj_scanpos = token;
2674: try {
2675: return !jj_3_16();
2676: } catch (LookaheadSuccess ls) {
2677: return true;
2678: } finally {
2679: jj_save(15, xla);
2680: }
2681: }
2682:
2683: static final private boolean jj_2_17(int xla) {
2684: jj_la = xla;
2685: jj_lastpos = jj_scanpos = token;
2686: try {
2687: return !jj_3_17();
2688: } catch (LookaheadSuccess ls) {
2689: return true;
2690: } finally {
2691: jj_save(16, xla);
2692: }
2693: }
2694:
2695: static final private boolean jj_2_18(int xla) {
2696: jj_la = xla;
2697: jj_lastpos = jj_scanpos = token;
2698: try {
2699: return !jj_3_18();
2700: } catch (LookaheadSuccess ls) {
2701: return true;
2702: } finally {
2703: jj_save(17, xla);
2704: }
2705: }
2706:
2707: static final private boolean jj_3R_47() {
2708: Token xsp;
2709: xsp = jj_scanpos;
2710: if (jj_scan_token(82)) {
2711: jj_scanpos = xsp;
2712: if (jj_scan_token(83)) {
2713: jj_scanpos = xsp;
2714: if (jj_scan_token(7))
2715: return true;
2716: }
2717: }
2718: return false;
2719: }
2720:
2721: static final private boolean jj_3R_77() {
2722: if (jj_scan_token(HAS_METHOD))
2723: return true;
2724: return false;
2725: }
2726:
2727: static final private boolean jj_3_3() {
2728: if (jj_3R_30())
2729: return true;
2730: return false;
2731: }
2732:
2733: static final private boolean jj_3_15() {
2734: if (jj_3R_30())
2735: return true;
2736: return false;
2737: }
2738:
2739: static final private boolean jj_3R_46() {
2740: if (jj_3R_55())
2741: return true;
2742: Token xsp;
2743: while (true) {
2744: xsp = jj_scanpos;
2745: if (jj_3R_56()) {
2746: jj_scanpos = xsp;
2747: break;
2748: }
2749: }
2750: return false;
2751: }
2752:
2753: static final private boolean jj_3R_75() {
2754: if (jj_scan_token(EXECUTION))
2755: return true;
2756: return false;
2757: }
2758:
2759: static final private boolean jj_3R_41() {
2760: if (jj_3R_47())
2761: return true;
2762: return false;
2763: }
2764:
2765: static final private boolean jj_3R_34() {
2766: Token xsp;
2767: xsp = jj_scanpos;
2768: if (jj_3R_41())
2769: jj_scanpos = xsp;
2770: while (true) {
2771: xsp = jj_scanpos;
2772: if (jj_3_18()) {
2773: jj_scanpos = xsp;
2774: break;
2775: }
2776: }
2777: return false;
2778: }
2779:
2780: static final private boolean jj_3R_91() {
2781: if (jj_scan_token(ARGS))
2782: return true;
2783: return false;
2784: }
2785:
2786: static final private boolean jj_3R_90() {
2787: Token xsp;
2788: xsp = jj_scanpos;
2789: if (jj_scan_token(27)) {
2790: jj_scanpos = xsp;
2791: if (jj_scan_token(28))
2792: return true;
2793: }
2794: return false;
2795: }
2796:
2797: static final private boolean jj_3R_83() {
2798: Token xsp;
2799: xsp = jj_scanpos;
2800: if (jj_3_14()) {
2801: jj_scanpos = xsp;
2802: if (jj_3R_91())
2803: return true;
2804: }
2805: return false;
2806: }
2807:
2808: static final private boolean jj_3_14() {
2809: if (jj_scan_token(ARGS))
2810: return true;
2811: if (jj_scan_token(ARGS_END))
2812: return true;
2813: return false;
2814: }
2815:
2816: static final private boolean jj_3R_55() {
2817: Token xsp;
2818: xsp = jj_scanpos;
2819: if (jj_scan_token(54)) {
2820: jj_scanpos = xsp;
2821: if (jj_scan_token(55)) {
2822: jj_scanpos = xsp;
2823: if (jj_scan_token(7))
2824: return true;
2825: }
2826: }
2827: return false;
2828: }
2829:
2830: static final private boolean jj_3R_71() {
2831: if (jj_3R_88())
2832: return true;
2833: return false;
2834: }
2835:
2836: static final private boolean jj_3R_70() {
2837: if (jj_3R_87())
2838: return true;
2839: return false;
2840: }
2841:
2842: static final private boolean jj_3R_72() {
2843: if (jj_3R_89())
2844: return true;
2845: return false;
2846: }
2847:
2848: static final private boolean jj_3R_69() {
2849: if (jj_3R_86())
2850: return true;
2851: return false;
2852: }
2853:
2854: static final private boolean jj_3R_73() {
2855: if (jj_3R_90())
2856: return true;
2857: return false;
2858: }
2859:
2860: static final private boolean jj_3R_87() {
2861: if (jj_scan_token(CFLOW_BELOW))
2862: return true;
2863: return false;
2864: }
2865:
2866: static final private boolean jj_3R_68() {
2867: if (jj_3R_85())
2868: return true;
2869: return false;
2870: }
2871:
2872: static final private boolean jj_3R_67() {
2873: if (jj_3R_84())
2874: return true;
2875: return false;
2876: }
2877:
2878: static final private boolean jj_3R_66() {
2879: if (jj_3R_83())
2880: return true;
2881: return false;
2882: }
2883:
2884: static final private boolean jj_3R_38() {
2885: if (jj_scan_token(METHOD_PARAMETER_START))
2886: return true;
2887: Token xsp;
2888: xsp = jj_scanpos;
2889: if (jj_3R_46())
2890: jj_scanpos = xsp;
2891: if (jj_scan_token(METHOD_PARAMETER_END))
2892: return true;
2893: return false;
2894: }
2895:
2896: static final private boolean jj_3R_65() {
2897: if (jj_3R_82())
2898: return true;
2899: return false;
2900: }
2901:
2902: static final private boolean jj_3R_86() {
2903: if (jj_scan_token(CFLOW))
2904: return true;
2905: return false;
2906: }
2907:
2908: static final private boolean jj_3R_64() {
2909: if (jj_3R_81())
2910: return true;
2911: return false;
2912: }
2913:
2914: static final private boolean jj_3R_63() {
2915: if (jj_3R_80())
2916: return true;
2917: return false;
2918: }
2919:
2920: static final private boolean jj_3R_44() {
2921: if (jj_3R_49())
2922: return true;
2923: return false;
2924: }
2925:
2926: static final private boolean jj_3R_62() {
2927: if (jj_3R_79())
2928: return true;
2929: return false;
2930: }
2931:
2932: static final private boolean jj_3R_61() {
2933: if (jj_3R_78())
2934: return true;
2935: return false;
2936: }
2937:
2938: static final private boolean jj_3R_60() {
2939: if (jj_3R_77())
2940: return true;
2941: return false;
2942: }
2943:
2944: static final private boolean jj_3R_59() {
2945: if (jj_3R_76())
2946: return true;
2947: return false;
2948: }
2949:
2950: static final private boolean jj_3_13() {
2951: if (jj_3R_33())
2952: return true;
2953: return false;
2954: }
2955:
2956: static final private boolean jj_3R_88() {
2957: if (jj_scan_token(STATIC_INITIALIZATION))
2958: return true;
2959: return false;
2960: }
2961:
2962: static final private boolean jj_3R_58() {
2963: if (jj_3R_75())
2964: return true;
2965: return false;
2966: }
2967:
2968: static final private boolean jj_3R_49() {
2969: Token xsp;
2970: xsp = jj_scanpos;
2971: if (jj_3R_57()) {
2972: jj_scanpos = xsp;
2973: if (jj_3R_58()) {
2974: jj_scanpos = xsp;
2975: if (jj_3R_59()) {
2976: jj_scanpos = xsp;
2977: if (jj_3R_60()) {
2978: jj_scanpos = xsp;
2979: if (jj_3R_61()) {
2980: jj_scanpos = xsp;
2981: if (jj_3R_62()) {
2982: jj_scanpos = xsp;
2983: if (jj_3R_63()) {
2984: jj_scanpos = xsp;
2985: if (jj_3R_64()) {
2986: jj_scanpos = xsp;
2987: if (jj_3R_65()) {
2988: jj_scanpos = xsp;
2989: if (jj_3R_66()) {
2990: jj_scanpos = xsp;
2991: if (jj_3R_67()) {
2992: jj_scanpos = xsp;
2993: if (jj_3R_68()) {
2994: jj_scanpos = xsp;
2995: if (jj_3R_69()) {
2996: jj_scanpos = xsp;
2997: if (jj_3R_70()) {
2998: jj_scanpos = xsp;
2999: if (jj_3R_71()) {
3000: jj_scanpos = xsp;
3001: if (jj_3R_72()) {
3002: jj_scanpos = xsp;
3003: if (jj_3R_73())
3004: return true;
3005: }
3006: }
3007: }
3008: }
3009: }
3010: }
3011: }
3012: }
3013: }
3014: }
3015: }
3016: }
3017: }
3018: }
3019: }
3020: }
3021: return false;
3022: }
3023:
3024: static final private boolean jj_3R_57() {
3025: if (jj_3R_74())
3026: return true;
3027: return false;
3028: }
3029:
3030: static final private boolean jj_3_11() {
3031: if (jj_3R_31())
3032: return true;
3033: return false;
3034: }
3035:
3036: static final private boolean jj_3_12() {
3037: if (jj_3R_30())
3038: return true;
3039: return false;
3040: }
3041:
3042: static final private boolean jj_3R_43() {
3043: if (jj_scan_token(86))
3044: return true;
3045: return false;
3046: }
3047:
3048: static final private boolean jj_3_2() {
3049: if (jj_scan_token(OR))
3050: return true;
3051: if (jj_3R_29())
3052: return true;
3053: return false;
3054: }
3055:
3056: static final private boolean jj_3R_37() {
3057: if (jj_3R_45())
3058: return true;
3059: return false;
3060: }
3061:
3062: static final private boolean jj_3R_31() {
3063: Token xsp;
3064: while (true) {
3065: xsp = jj_scanpos;
3066: if (jj_3R_37()) {
3067: jj_scanpos = xsp;
3068: break;
3069: }
3070: }
3071: if (jj_scan_token(METHOD_CLASS_PATTERN))
3072: return true;
3073: if (jj_3R_38())
3074: return true;
3075: return false;
3076: }
3077:
3078: static final private boolean jj_3R_48() {
3079: if (jj_scan_token(NOT))
3080: return true;
3081: return false;
3082: }
3083:
3084: static final private boolean jj_3_1() {
3085: if (jj_scan_token(AND))
3086: return true;
3087: if (jj_3R_28())
3088: return true;
3089: return false;
3090: }
3091:
3092: static final private boolean jj_3R_42() {
3093: if (jj_3R_48())
3094: return true;
3095: return false;
3096: }
3097:
3098: static final private boolean jj_3R_35() {
3099: Token xsp;
3100: xsp = jj_scanpos;
3101: if (jj_3R_42()) {
3102: jj_scanpos = xsp;
3103: if (jj_3R_43()) {
3104: jj_scanpos = xsp;
3105: if (jj_3R_44())
3106: return true;
3107: }
3108: }
3109: return false;
3110: }
3111:
3112: static final private boolean jj_3_10() {
3113: if (jj_3R_30())
3114: return true;
3115: return false;
3116: }
3117:
3118: static final private boolean jj_3R_28() {
3119: if (jj_3R_35())
3120: return true;
3121: return false;
3122: }
3123:
3124: static final private boolean jj_3R_29() {
3125: if (jj_3R_28())
3126: return true;
3127: return false;
3128: }
3129:
3130: static final private boolean jj_3R_76() {
3131: if (jj_scan_token(WITHIN_CODE))
3132: return true;
3133: return false;
3134: }
3135:
3136: static final private boolean jj_3_9() {
3137: if (jj_3R_33())
3138: return true;
3139: return false;
3140: }
3141:
3142: static final private boolean jj_3R_81() {
3143: if (jj_scan_token(WITHIN))
3144: return true;
3145: return false;
3146: }
3147:
3148: static final private boolean jj_3R_82() {
3149: if (jj_scan_token(HANDLER))
3150: return true;
3151: return false;
3152: }
3153:
3154: static final private boolean jj_3R_89() {
3155: if (jj_scan_token(IF))
3156: return true;
3157: return false;
3158: }
3159:
3160: static final private boolean jj_3_8() {
3161: if (jj_3R_32())
3162: return true;
3163: return false;
3164: }
3165:
3166: static final private boolean jj_3R_39() {
3167: if (jj_scan_token(FIELD_NOT))
3168: return true;
3169: return false;
3170: }
3171:
3172: static final private boolean jj_3R_32() {
3173: Token xsp;
3174: while (true) {
3175: xsp = jj_scanpos;
3176: if (jj_3R_39()) {
3177: jj_scanpos = xsp;
3178: break;
3179: }
3180: }
3181: if (jj_scan_token(FIELD_ANNOTATION))
3182: return true;
3183: return false;
3184: }
3185:
3186: static final private boolean jj_3R_79() {
3187: if (jj_scan_token(GET))
3188: return true;
3189: return false;
3190: }
3191:
3192: static final private boolean jj_3R_85() {
3193: if (jj_scan_token(THIS))
3194: return true;
3195: return false;
3196: }
3197:
3198: static final private boolean jj_3_7() {
3199: if (jj_3R_32())
3200: return true;
3201: return false;
3202: }
3203:
3204: static final private boolean jj_3R_78() {
3205: if (jj_scan_token(SET))
3206: return true;
3207: return false;
3208: }
3209:
3210: static final private boolean jj_3_6() {
3211: if (jj_3R_31())
3212: return true;
3213: return false;
3214: }
3215:
3216: static final private boolean jj_3R_36() {
3217: if (jj_scan_token(METHOD_NOT))
3218: return true;
3219: return false;
3220: }
3221:
3222: static final private boolean jj_3R_30() {
3223: Token xsp;
3224: while (true) {
3225: xsp = jj_scanpos;
3226: if (jj_3R_36()) {
3227: jj_scanpos = xsp;
3228: break;
3229: }
3230: }
3231: if (jj_scan_token(METHOD_ANNOTATION))
3232: return true;
3233: return false;
3234: }
3235:
3236: static final private boolean jj_3R_54() {
3237: if (jj_scan_token(METHOD_SYNCHRONIZED))
3238: return true;
3239: return false;
3240: }
3241:
3242: static final private boolean jj_3R_84() {
3243: if (jj_scan_token(TARGET))
3244: return true;
3245: return false;
3246: }
3247:
3248: static final private boolean jj_3R_53() {
3249: if (jj_scan_token(METHOD_PRIVATE))
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_51() {
3261: if (jj_scan_token(METHOD_PUBLIC))
3262: return true;
3263: return false;
3264: }
3265:
3266: static final private boolean jj_3_5() {
3267: if (jj_3R_30())
3268: return true;
3269: return false;
3270: }
3271:
3272: static final private boolean jj_3R_74() {
3273: if (jj_scan_token(CALL))
3274: return true;
3275: return false;
3276: }
3277:
3278: static final private boolean jj_3_17() {
3279: if (jj_3R_32())
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_80() {
3311: if (jj_scan_token(HAS_FIELD))
3312: return true;
3313: return false;
3314: }
3315:
3316: static final private boolean jj_3R_45() {
3317: Token xsp;
3318: while (true) {
3319: xsp = jj_scanpos;
3320: if (jj_3R_50()) {
3321: jj_scanpos = xsp;
3322: break;
3323: }
3324: }
3325: xsp = jj_scanpos;
3326: if (jj_3R_51()) {
3327: jj_scanpos = xsp;
3328: if (jj_3R_52()) {
3329: jj_scanpos = xsp;
3330: if (jj_3R_53()) {
3331: jj_scanpos = xsp;
3332: if (jj_3R_54())
3333: return true;
3334: }
3335: }
3336: }
3337: return false;
3338: }
3339:
3340: static final private boolean jj_3_4() {
3341: if (jj_3R_31())
3342: return true;
3343: return false;
3344: }
3345:
3346: static final private boolean jj_3_16() {
3347: if (jj_3R_31())
3348: return true;
3349: return false;
3350: }
3351:
3352: static final private boolean jj_3_18() {
3353: if (jj_scan_token(COMMA))
3354: return true;
3355: if (jj_3R_34())
3356: return true;
3357: return false;
3358: }
3359:
3360: static final private boolean jj_3R_56() {
3361: if (jj_scan_token(COMMA))
3362: return true;
3363: return false;
3364: }
3365:
3366: static private boolean jj_initialized_once = false;
3367: static public ExpressionParserTokenManager token_source;
3368: static SimpleCharStream jj_input_stream;
3369: static public Token token, jj_nt;
3370: static private int jj_ntk;
3371: static private Token jj_scanpos, jj_lastpos;
3372: static private int jj_la;
3373: static public boolean lookingAhead = false;
3374: static private boolean jj_semLA;
3375: static private int jj_gen;
3376: static final private int[] jj_la1 = new int[50];
3377: static private int[] jj_la1_0;
3378: static private int[] jj_la1_1;
3379: static private int[] jj_la1_2;
3380:
3381: static {
3382: jj_la1_0();
3383: jj_la1_1();
3384: jj_la1_2();
3385: }
3386:
3387: private static void jj_la1_0() {
3388: jj_la1_0 = new int[] { 0x1ffffc00, 0x1ffff800, 0x18000000,
3389: 0x88, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3390: 0xe0000080, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe0000080,
3391: 0x200000, 0x0, 0x0, 0x0, 0x0, 0xe0000000, 0x80, 0x0,
3392: 0x0, 0x0, 0x0, 0x0, 0x8, 0x80, 0x80, 0x80, 0x80, 0x0,
3393: 0x0, 0x0, 0x0, 0xe0000000, 0x0, 0x0, 0x0, 0x0, 0x0,
3394: 0x0, 0x0, 0x0, };
3395: }
3396:
3397: private static void jj_la1_1() {
3398: jj_la1_1 = new int[] { 0x0, 0x0, 0x0, 0x0, 0xcbfc00, 0xcbfc00,
3399: 0x4cbfc00, 0xcbfc00, 0xcbfc00, 0x4cbfc00, 0xf0000000,
3400: 0xf0000000, 0x2f, 0xcbfc00, 0xcbfc00, 0x4cbfc00,
3401: 0x4dffc00, 0x48fc00, 0x8fc00, 0x2f, 0x0, 0xcbfc00,
3402: 0xcbfc00, 0x4cbfc00, 0xf0000000, 0xf, 0x20, 0xbfc00,
3403: 0xc00000, 0xa1c00, 0xf0000000, 0x0, 0x0, 0xc00000,
3404: 0xc00000, 0x0, 0x0, 0x8, 0x80000, 0x0, 0x8, 0x7,
3405: 0x80000, 0xfc00, 0x80000, 0x3fc00, 0x80000, 0x21c00,
3406: 0x0, 0xf0000000, };
3407: }
3408:
3409: private static void jj_la1_2() {
3410: jj_la1_2 = new int[] { 0x400000, 0x0, 0x0, 0x2c0000, 0x0, 0x0,
3411: 0x800000, 0x0, 0x0, 0x800000, 0xcf, 0xcf, 0x0, 0x0,
3412: 0x0, 0x800000, 0x800000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
3413: 0x800000, 0xcf, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf, 0xc0,
3414: 0x0, 0x0, 0x0, 0xc0000, 0xc0000, 0x0, 0x0, 0x8, 0x0,
3415: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x7, };
3416: }
3417:
3418: static final private JJCalls[] jj_2_rtns = new JJCalls[18];
3419: static private boolean jj_rescan = false;
3420: static private int jj_gc = 0;
3421:
3422: public ExpressionParser(java.io.InputStream stream) {
3423: if (jj_initialized_once) {
3424: System.out
3425: .println("ERROR: Second call to constructor of static parser. You must");
3426: System.out
3427: .println(" either use ReInit() or set the JavaCC option STATIC to false");
3428: System.out.println(" during parser generation.");
3429: throw new Error();
3430: }
3431: jj_initialized_once = true;
3432: jj_input_stream = new SimpleCharStream(stream, 1, 1);
3433: token_source = new ExpressionParserTokenManager(jj_input_stream);
3434: token = new Token();
3435: jj_ntk = -1;
3436: jj_gen = 0;
3437: for (int i = 0; i < 50; i++)
3438: jj_la1[i] = -1;
3439: for (int i = 0; i < jj_2_rtns.length; i++)
3440: jj_2_rtns[i] = new JJCalls();
3441: }
3442:
3443: static public void ReInit(java.io.InputStream stream) {
3444: jj_input_stream.ReInit(stream, 1, 1);
3445: token_source.ReInit(jj_input_stream);
3446: token = new Token();
3447: jj_ntk = -1;
3448: jjtree.reset();
3449: jj_gen = 0;
3450: for (int i = 0; i < 50; i++)
3451: jj_la1[i] = -1;
3452: for (int i = 0; i < jj_2_rtns.length; i++)
3453: jj_2_rtns[i] = new JJCalls();
3454: }
3455:
3456: public ExpressionParser(java.io.Reader stream) {
3457: if (jj_initialized_once) {
3458: System.out
3459: .println("ERROR: Second call to constructor of static parser. You must");
3460: System.out
3461: .println(" either use ReInit() or set the JavaCC option STATIC to false");
3462: System.out.println(" during parser generation.");
3463: throw new Error();
3464: }
3465: jj_initialized_once = true;
3466: jj_input_stream = new SimpleCharStream(stream, 1, 1);
3467: token_source = new ExpressionParserTokenManager(jj_input_stream);
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: static public void ReInit(java.io.Reader stream) {
3478: jj_input_stream.ReInit(stream, 1, 1);
3479: token_source.ReInit(jj_input_stream);
3480: token = new Token();
3481: jj_ntk = -1;
3482: jjtree.reset();
3483: jj_gen = 0;
3484: for (int i = 0; i < 50; i++)
3485: jj_la1[i] = -1;
3486: for (int i = 0; i < jj_2_rtns.length; i++)
3487: jj_2_rtns[i] = new JJCalls();
3488: }
3489:
3490: public ExpressionParser(ExpressionParserTokenManager tm) {
3491: if (jj_initialized_once) {
3492: System.out
3493: .println("ERROR: Second call to constructor of static parser. You must");
3494: System.out
3495: .println(" either use ReInit() or set the JavaCC option STATIC to false");
3496: System.out.println(" during parser generation.");
3497: throw new Error();
3498: }
3499: jj_initialized_once = true;
3500: token_source = tm;
3501: token = new Token();
3502: jj_ntk = -1;
3503: jj_gen = 0;
3504: for (int i = 0; i < 50; i++)
3505: jj_la1[i] = -1;
3506: for (int i = 0; i < jj_2_rtns.length; i++)
3507: jj_2_rtns[i] = new JJCalls();
3508: }
3509:
3510: public void ReInit(ExpressionParserTokenManager tm) {
3511: token_source = tm;
3512: token = new Token();
3513: jj_ntk = -1;
3514: jjtree.reset();
3515: jj_gen = 0;
3516: for (int i = 0; i < 50; i++)
3517: jj_la1[i] = -1;
3518: for (int i = 0; i < jj_2_rtns.length; i++)
3519: jj_2_rtns[i] = new JJCalls();
3520: }
3521:
3522: static final private Token jj_consume_token(int kind)
3523: throws ParseException {
3524: Token oldToken;
3525: if ((oldToken = token).next != null)
3526: token = token.next;
3527: else
3528: token = token.next = token_source.getNextToken();
3529: jj_ntk = -1;
3530: if (token.kind == kind) {
3531: jj_gen++;
3532: if (++jj_gc > 100) {
3533: jj_gc = 0;
3534: for (int i = 0; i < jj_2_rtns.length; i++) {
3535: JJCalls c = jj_2_rtns[i];
3536: while (c != null) {
3537: if (c.gen < jj_gen)
3538: c.first = null;
3539: c = c.next;
3540: }
3541: }
3542: }
3543: return token;
3544: }
3545: token = oldToken;
3546: jj_kind = kind;
3547: throw generateParseException();
3548: }
3549:
3550: static final class LookaheadSuccess extends java.lang.Error {
3551: }
3552:
3553: static final private LookaheadSuccess jj_ls = new LookaheadSuccess();
3554:
3555: static final private boolean jj_scan_token(int kind) {
3556: if (jj_scanpos == jj_lastpos) {
3557: jj_la--;
3558: if (jj_scanpos.next == null) {
3559: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
3560: .getNextToken();
3561: } else {
3562: jj_lastpos = jj_scanpos = jj_scanpos.next;
3563: }
3564: } else {
3565: jj_scanpos = jj_scanpos.next;
3566: }
3567: if (jj_rescan) {
3568: int i = 0;
3569: Token tok = token;
3570: while (tok != null && tok != jj_scanpos) {
3571: i++;
3572: tok = tok.next;
3573: }
3574: if (tok != null)
3575: jj_add_error_token(kind, i);
3576: }
3577: if (jj_scanpos.kind != kind)
3578: return true;
3579: if (jj_la == 0 && jj_scanpos == jj_lastpos)
3580: throw jj_ls;
3581: return false;
3582: }
3583:
3584: static final public Token getNextToken() {
3585: if (token.next != null)
3586: token = token.next;
3587: else
3588: token = token.next = token_source.getNextToken();
3589: jj_ntk = -1;
3590: jj_gen++;
3591: return token;
3592: }
3593:
3594: static final public Token getToken(int index) {
3595: Token t = lookingAhead ? jj_scanpos : token;
3596: for (int i = 0; i < index; i++) {
3597: if (t.next != null)
3598: t = t.next;
3599: else
3600: t = t.next = token_source.getNextToken();
3601: }
3602: return t;
3603: }
3604:
3605: static final private int jj_ntk() {
3606: if ((jj_nt = token.next) == null)
3607: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
3608: else
3609: return (jj_ntk = jj_nt.kind);
3610: }
3611:
3612: static private java.util.Vector jj_expentries = new java.util.Vector();
3613: static private int[] jj_expentry;
3614: static private int jj_kind = -1;
3615: static private int[] jj_lasttokens = new int[100];
3616: static private int jj_endpos;
3617:
3618: static private void jj_add_error_token(int kind, int pos) {
3619: if (pos >= 100)
3620: return;
3621: if (pos == jj_endpos + 1) {
3622: jj_lasttokens[jj_endpos++] = kind;
3623: } else if (jj_endpos != 0) {
3624: jj_expentry = new int[jj_endpos];
3625: for (int i = 0; i < jj_endpos; i++) {
3626: jj_expentry[i] = jj_lasttokens[i];
3627: }
3628: boolean exists = false;
3629: for (java.util.Enumeration e = jj_expentries.elements(); e
3630: .hasMoreElements();) {
3631: int[] oldentry = (int[]) (e.nextElement());
3632: if (oldentry.length == jj_expentry.length) {
3633: exists = true;
3634: for (int i = 0; i < jj_expentry.length; i++) {
3635: if (oldentry[i] != jj_expentry[i]) {
3636: exists = false;
3637: break;
3638: }
3639: }
3640: if (exists)
3641: break;
3642: }
3643: }
3644: if (!exists)
3645: jj_expentries.addElement(jj_expentry);
3646: if (pos != 0)
3647: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3648: }
3649: }
3650:
3651: static public ParseException generateParseException() {
3652: jj_expentries.removeAllElements();
3653: boolean[] la1tokens = new boolean[88];
3654: for (int i = 0; i < 88; i++) {
3655: la1tokens[i] = false;
3656: }
3657: if (jj_kind >= 0) {
3658: la1tokens[jj_kind] = true;
3659: jj_kind = -1;
3660: }
3661: for (int i = 0; i < 50; i++) {
3662: if (jj_la1[i] == jj_gen) {
3663: for (int j = 0; j < 32; j++) {
3664: if ((jj_la1_0[i] & (1 << j)) != 0) {
3665: la1tokens[j] = true;
3666: }
3667: if ((jj_la1_1[i] & (1 << j)) != 0) {
3668: la1tokens[32 + j] = true;
3669: }
3670: if ((jj_la1_2[i] & (1 << j)) != 0) {
3671: la1tokens[64 + j] = true;
3672: }
3673: }
3674: }
3675: }
3676: for (int i = 0; i < 88; i++) {
3677: if (la1tokens[i]) {
3678: jj_expentry = new int[1];
3679: jj_expentry[0] = i;
3680: jj_expentries.addElement(jj_expentry);
3681: }
3682: }
3683: jj_endpos = 0;
3684: jj_rescan_token();
3685: jj_add_error_token(0, 0);
3686: int[][] exptokseq = new int[jj_expentries.size()][];
3687: for (int i = 0; i < jj_expentries.size(); i++) {
3688: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
3689: }
3690: return new ParseException(token, exptokseq, tokenImage);
3691: }
3692:
3693: static final public void enable_tracing() {
3694: }
3695:
3696: static final public void disable_tracing() {
3697: }
3698:
3699: static final private void jj_rescan_token() {
3700: jj_rescan = true;
3701: for (int i = 0; i < 18; i++) {
3702: JJCalls p = jj_2_rtns[i];
3703: do {
3704: if (p.gen > jj_gen) {
3705: jj_la = p.arg;
3706: jj_lastpos = jj_scanpos = p.first;
3707: switch (i) {
3708: case 0:
3709: jj_3_1();
3710: break;
3711: case 1:
3712: jj_3_2();
3713: break;
3714: case 2:
3715: jj_3_3();
3716: break;
3717: case 3:
3718: jj_3_4();
3719: break;
3720: case 4:
3721: jj_3_5();
3722: break;
3723: case 5:
3724: jj_3_6();
3725: break;
3726: case 6:
3727: jj_3_7();
3728: break;
3729: case 7:
3730: jj_3_8();
3731: break;
3732: case 8:
3733: jj_3_9();
3734: break;
3735: case 9:
3736: jj_3_10();
3737: break;
3738: case 10:
3739: jj_3_11();
3740: break;
3741: case 11:
3742: jj_3_12();
3743: break;
3744: case 12:
3745: jj_3_13();
3746: break;
3747: case 13:
3748: jj_3_14();
3749: break;
3750: case 14:
3751: jj_3_15();
3752: break;
3753: case 15:
3754: jj_3_16();
3755: break;
3756: case 16:
3757: jj_3_17();
3758: break;
3759: case 17:
3760: jj_3_18();
3761: break;
3762: }
3763: }
3764: p = p.next;
3765: } while (p != null);
3766: }
3767: jj_rescan = false;
3768: }
3769:
3770: static final private void jj_save(int index, int xla) {
3771: JJCalls p = jj_2_rtns[index];
3772: while (p.gen > jj_gen) {
3773: if (p.next == null) {
3774: p = p.next = new JJCalls();
3775: break;
3776: }
3777: p = p.next;
3778: }
3779: p.gen = jj_gen + xla - jj_la;
3780: p.first = token;
3781: p.arg = xla;
3782: }
3783:
3784: static final class JJCalls {
3785: int gen;
3786: Token first;
3787: int arg;
3788: JJCalls next;
3789: }
3790:
3791: }
|