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