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