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