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