0001: /* Generated By:JJTree&JavaCC: Do not edit this line. EJBQL.java */
0002: package org.objectweb.speedo.query.ejb.parser;
0003:
0004: public class EJBQL/*@bgen(jjtree)*/implements EJBQLTreeConstants,
0005: EJBQLConstants {/*@bgen(jjtree)*/
0006: protected JJTEJBQLState jjtree = new JJTEJBQLState();
0007:
0008: public static void main(String args[]) throws ParseException {
0009: EJBQL parser;
0010: if (args.length == 0) {
0011: System.out
0012: .println("EJBQL Parser : Reading from standard input . . .");
0013: parser = new EJBQL(System.in);
0014: } else if (args.length == 1) {
0015: System.out.println("EJBQL Parser : Reading from file "
0016: + args[0] + " . . .");
0017: try {
0018: parser = new EJBQL(new java.io.FileInputStream(args[0]));
0019: } catch (java.io.FileNotFoundException e) {
0020: System.out.println("EJBQL Parser : File " + args[0]
0021: + " not found.");
0022: return;
0023: }
0024: } else {
0025: System.out.println("EJBQL Parser : Usage is one of:");
0026: System.out
0027: .println(" java org.objectweb.speedo.query.ejb.EJBQL < inputfile");
0028: System.out.println("OR");
0029: System.out
0030: .println(" java org.objectweb.speedo.query.ejb.EJBQL inputfile");
0031: return;
0032: }
0033: try {
0034: SimpleNode sn = parser.EJBQL();
0035: sn.dump("");
0036: System.out
0037: .println("EJBQL Parser : Java program parsed successfully.");
0038: } catch (ParseException e) {
0039: System.out
0040: .println("EJBQL Parser : Encountered errors during parse.");
0041: e.printStackTrace();
0042: }
0043: }
0044:
0045: final public SimpleNode EJBQL() throws ParseException {
0046: /*@bgen(jjtree) EJBQL */
0047: ASTEJBQL jjtn000 = new ASTEJBQL(JJTEJBQL);
0048: boolean jjtc000 = true;
0049: jjtree.openNodeScope(jjtn000);
0050: try {
0051: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0052: case DELETE:
0053: case SELECT:
0054: case UPDATE:
0055: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0056: case SELECT:
0057: SelectStatement();
0058: break;
0059: case UPDATE:
0060: UpdateStatement();
0061: break;
0062: case DELETE:
0063: DeleteStatement();
0064: break;
0065: default:
0066: jj_la1[0] = jj_gen;
0067: jj_consume_token(-1);
0068: throw new ParseException();
0069: }
0070: break;
0071: default:
0072: jj_la1[1] = jj_gen;
0073: ;
0074: }
0075: jj_consume_token(0);
0076: jjtree.closeNodeScope(jjtn000, true);
0077: jjtc000 = false;
0078: {
0079: if (true)
0080: return jjtn000;
0081: }
0082: } catch (Throwable jjte000) {
0083: if (jjtc000) {
0084: jjtree.clearNodeScope(jjtn000);
0085: jjtc000 = false;
0086: } else {
0087: jjtree.popNode();
0088: }
0089: if (jjte000 instanceof RuntimeException) {
0090: {
0091: if (true)
0092: throw (RuntimeException) jjte000;
0093: }
0094: }
0095: if (jjte000 instanceof ParseException) {
0096: {
0097: if (true)
0098: throw (ParseException) jjte000;
0099: }
0100: }
0101: {
0102: if (true)
0103: throw (Error) jjte000;
0104: }
0105: } finally {
0106: if (jjtc000) {
0107: jjtree.closeNodeScope(jjtn000, true);
0108: }
0109: }
0110: throw new Error("Missing return statement in function");
0111: }
0112:
0113: final public void SelectStatement() throws ParseException {
0114: /*@bgen(jjtree) SelectStatement */
0115: ASTSelectStatement jjtn000 = new ASTSelectStatement(
0116: JJTSELECTSTATEMENT);
0117: boolean jjtc000 = true;
0118: jjtree.openNodeScope(jjtn000);
0119: try {
0120: SelectClause();
0121: FromClause();
0122: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0123: case WHERE:
0124: WhereClause();
0125: break;
0126: default:
0127: jj_la1[2] = jj_gen;
0128: ;
0129: }
0130: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0131: case GROUP:
0132: GroupByClause();
0133: break;
0134: default:
0135: jj_la1[3] = jj_gen;
0136: ;
0137: }
0138: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0139: case HAVING:
0140: HavingClause();
0141: break;
0142: default:
0143: jj_la1[4] = jj_gen;
0144: ;
0145: }
0146: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0147: case ORDERBY:
0148: OrderByClause();
0149: break;
0150: default:
0151: jj_la1[5] = jj_gen;
0152: ;
0153: }
0154: } catch (Throwable jjte000) {
0155: if (jjtc000) {
0156: jjtree.clearNodeScope(jjtn000);
0157: jjtc000 = false;
0158: } else {
0159: jjtree.popNode();
0160: }
0161: if (jjte000 instanceof RuntimeException) {
0162: {
0163: if (true)
0164: throw (RuntimeException) jjte000;
0165: }
0166: }
0167: if (jjte000 instanceof ParseException) {
0168: {
0169: if (true)
0170: throw (ParseException) jjte000;
0171: }
0172: }
0173: {
0174: if (true)
0175: throw (Error) jjte000;
0176: }
0177: } finally {
0178: if (jjtc000) {
0179: jjtree.closeNodeScope(jjtn000, true);
0180: }
0181: }
0182: }
0183:
0184: final public void UpdateStatement() throws ParseException {
0185: /*@bgen(jjtree) UpdateStatement */
0186: ASTUpdateStatement jjtn000 = new ASTUpdateStatement(
0187: JJTUPDATESTATEMENT);
0188: boolean jjtc000 = true;
0189: jjtree.openNodeScope(jjtn000);
0190: try {
0191: UpdateClause();
0192: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0193: case WHERE:
0194: WhereClause();
0195: break;
0196: default:
0197: jj_la1[6] = jj_gen;
0198: ;
0199: }
0200: } catch (Throwable jjte000) {
0201: if (jjtc000) {
0202: jjtree.clearNodeScope(jjtn000);
0203: jjtc000 = false;
0204: } else {
0205: jjtree.popNode();
0206: }
0207: if (jjte000 instanceof RuntimeException) {
0208: {
0209: if (true)
0210: throw (RuntimeException) jjte000;
0211: }
0212: }
0213: if (jjte000 instanceof ParseException) {
0214: {
0215: if (true)
0216: throw (ParseException) jjte000;
0217: }
0218: }
0219: {
0220: if (true)
0221: throw (Error) jjte000;
0222: }
0223: } finally {
0224: if (jjtc000) {
0225: jjtree.closeNodeScope(jjtn000, true);
0226: }
0227: }
0228: }
0229:
0230: final public void DeleteStatement() throws ParseException {
0231: /*@bgen(jjtree) DeleteStatement */
0232: ASTDeleteStatement jjtn000 = new ASTDeleteStatement(
0233: JJTDELETESTATEMENT);
0234: boolean jjtc000 = true;
0235: jjtree.openNodeScope(jjtn000);
0236: try {
0237: DeleteClause();
0238: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0239: case WHERE:
0240: WhereClause();
0241: break;
0242: default:
0243: jj_la1[7] = jj_gen;
0244: ;
0245: }
0246: } catch (Throwable jjte000) {
0247: if (jjtc000) {
0248: jjtree.clearNodeScope(jjtn000);
0249: jjtc000 = false;
0250: } else {
0251: jjtree.popNode();
0252: }
0253: if (jjte000 instanceof RuntimeException) {
0254: {
0255: if (true)
0256: throw (RuntimeException) jjte000;
0257: }
0258: }
0259: if (jjte000 instanceof ParseException) {
0260: {
0261: if (true)
0262: throw (ParseException) jjte000;
0263: }
0264: }
0265: {
0266: if (true)
0267: throw (Error) jjte000;
0268: }
0269: } finally {
0270: if (jjtc000) {
0271: jjtree.closeNodeScope(jjtn000, true);
0272: }
0273: }
0274: }
0275:
0276: final public void FromClause() throws ParseException {
0277: /*@bgen(jjtree) FromClause */
0278: ASTFromClause jjtn000 = new ASTFromClause(JJTFROMCLAUSE);
0279: boolean jjtc000 = true;
0280: jjtree.openNodeScope(jjtn000);
0281: try {
0282: jj_consume_token(FROM);
0283: IdentificationVariableDeclaration();
0284: label_1: while (true) {
0285: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0286: case COMMA:
0287: ;
0288: break;
0289: default:
0290: jj_la1[8] = jj_gen;
0291: break label_1;
0292: }
0293: jj_consume_token(COMMA);
0294: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0295: case IDENTIFIER:
0296: IdentificationVariableDeclaration();
0297: break;
0298: case IN:
0299: CollectionMemberDeclaration();
0300: break;
0301: default:
0302: jj_la1[9] = jj_gen;
0303: jj_consume_token(-1);
0304: throw new ParseException();
0305: }
0306: }
0307: } catch (Throwable jjte000) {
0308: if (jjtc000) {
0309: jjtree.clearNodeScope(jjtn000);
0310: jjtc000 = false;
0311: } else {
0312: jjtree.popNode();
0313: }
0314: if (jjte000 instanceof RuntimeException) {
0315: {
0316: if (true)
0317: throw (RuntimeException) jjte000;
0318: }
0319: }
0320: if (jjte000 instanceof ParseException) {
0321: {
0322: if (true)
0323: throw (ParseException) jjte000;
0324: }
0325: }
0326: {
0327: if (true)
0328: throw (Error) jjte000;
0329: }
0330: } finally {
0331: if (jjtc000) {
0332: jjtree.closeNodeScope(jjtn000, true);
0333: }
0334: }
0335: }
0336:
0337: final public void IdentificationVariableDeclaration()
0338: throws ParseException {
0339: /*@bgen(jjtree) IdentificationVariableDeclaration */
0340: ASTIdentificationVariableDeclaration jjtn000 = new ASTIdentificationVariableDeclaration(
0341: JJTIDENTIFICATIONVARIABLEDECLARATION);
0342: boolean jjtc000 = true;
0343: jjtree.openNodeScope(jjtn000);
0344: try {
0345: RangeVariableDeclaration();
0346: label_2: while (true) {
0347: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0348: case INNER:
0349: case JOIN:
0350: case LEFT:
0351: ;
0352: break;
0353: default:
0354: jj_la1[10] = jj_gen;
0355: break label_2;
0356: }
0357: JoinSpec();
0358: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0359: case IDENTIFIER:
0360: Join();
0361: break;
0362: case FETCH:
0363: FetchJoin();
0364: break;
0365: default:
0366: jj_la1[11] = jj_gen;
0367: jj_consume_token(-1);
0368: throw new ParseException();
0369: }
0370: }
0371: } catch (Throwable jjte000) {
0372: if (jjtc000) {
0373: jjtree.clearNodeScope(jjtn000);
0374: jjtc000 = false;
0375: } else {
0376: jjtree.popNode();
0377: }
0378: if (jjte000 instanceof RuntimeException) {
0379: {
0380: if (true)
0381: throw (RuntimeException) jjte000;
0382: }
0383: }
0384: if (jjte000 instanceof ParseException) {
0385: {
0386: if (true)
0387: throw (ParseException) jjte000;
0388: }
0389: }
0390: {
0391: if (true)
0392: throw (Error) jjte000;
0393: }
0394: } finally {
0395: if (jjtc000) {
0396: jjtree.closeNodeScope(jjtn000, true);
0397: }
0398: }
0399: }
0400:
0401: final public void RangeVariableDeclaration() throws ParseException {
0402: /*@bgen(jjtree) RangeVariableDeclaration */
0403: ASTRangeVariableDeclaration jjtn000 = new ASTRangeVariableDeclaration(
0404: JJTRANGEVARIABLEDECLARATION);
0405: boolean jjtc000 = true;
0406: jjtree.openNodeScope(jjtn000);
0407: try {
0408: AbstractSchemaName();
0409: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0410: case AS:
0411: jj_consume_token(AS);
0412: break;
0413: default:
0414: jj_la1[12] = jj_gen;
0415: ;
0416: }
0417: IdentificationVariable();
0418: } catch (Throwable jjte000) {
0419: if (jjtc000) {
0420: jjtree.clearNodeScope(jjtn000);
0421: jjtc000 = false;
0422: } else {
0423: jjtree.popNode();
0424: }
0425: if (jjte000 instanceof RuntimeException) {
0426: {
0427: if (true)
0428: throw (RuntimeException) jjte000;
0429: }
0430: }
0431: if (jjte000 instanceof ParseException) {
0432: {
0433: if (true)
0434: throw (ParseException) jjte000;
0435: }
0436: }
0437: {
0438: if (true)
0439: throw (Error) jjte000;
0440: }
0441: } finally {
0442: if (jjtc000) {
0443: jjtree.closeNodeScope(jjtn000, true);
0444: }
0445: }
0446: }
0447:
0448: final public void Join() throws ParseException {
0449: /*@bgen(jjtree) Join */
0450: ASTJoin jjtn000 = new ASTJoin(JJTJOIN);
0451: boolean jjtc000 = true;
0452: jjtree.openNodeScope(jjtn000);
0453: try {
0454: PathExpression();
0455: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0456: case AS:
0457: jj_consume_token(AS);
0458: break;
0459: default:
0460: jj_la1[13] = jj_gen;
0461: ;
0462: }
0463: IdentificationVariable();
0464: } catch (Throwable jjte000) {
0465: if (jjtc000) {
0466: jjtree.clearNodeScope(jjtn000);
0467: jjtc000 = false;
0468: } else {
0469: jjtree.popNode();
0470: }
0471: if (jjte000 instanceof RuntimeException) {
0472: {
0473: if (true)
0474: throw (RuntimeException) jjte000;
0475: }
0476: }
0477: if (jjte000 instanceof ParseException) {
0478: {
0479: if (true)
0480: throw (ParseException) jjte000;
0481: }
0482: }
0483: {
0484: if (true)
0485: throw (Error) jjte000;
0486: }
0487: } finally {
0488: if (jjtc000) {
0489: jjtree.closeNodeScope(jjtn000, true);
0490: }
0491: }
0492: }
0493:
0494: final public void FetchJoin() throws ParseException {
0495: /*@bgen(jjtree) FetchJoin */
0496: ASTFetchJoin jjtn000 = new ASTFetchJoin(JJTFETCHJOIN);
0497: boolean jjtc000 = true;
0498: jjtree.openNodeScope(jjtn000);
0499: try {
0500: jj_consume_token(FETCH);
0501: PathExpression();
0502: } catch (Throwable jjte000) {
0503: if (jjtc000) {
0504: jjtree.clearNodeScope(jjtn000);
0505: jjtc000 = false;
0506: } else {
0507: jjtree.popNode();
0508: }
0509: if (jjte000 instanceof RuntimeException) {
0510: {
0511: if (true)
0512: throw (RuntimeException) jjte000;
0513: }
0514: }
0515: if (jjte000 instanceof ParseException) {
0516: {
0517: if (true)
0518: throw (ParseException) jjte000;
0519: }
0520: }
0521: {
0522: if (true)
0523: throw (Error) jjte000;
0524: }
0525: } finally {
0526: if (jjtc000) {
0527: jjtree.closeNodeScope(jjtn000, true);
0528: }
0529: }
0530: }
0531:
0532: final public void JoinSpec() throws ParseException {
0533: /*@bgen(jjtree) JoinSpec */
0534: ASTJoinSpec jjtn000 = new ASTJoinSpec(JJTJOINSPEC);
0535: boolean jjtc000 = true;
0536: jjtree.openNodeScope(jjtn000);
0537: try {
0538: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0539: case INNER:
0540: case LEFT:
0541: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0542: case LEFT:
0543: jj_consume_token(LEFT);
0544: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0545: case OUTER:
0546: jj_consume_token(OUTER);
0547: break;
0548: default:
0549: jj_la1[14] = jj_gen;
0550: ;
0551: }
0552: break;
0553: case INNER:
0554: jj_consume_token(INNER);
0555: break;
0556: default:
0557: jj_la1[15] = jj_gen;
0558: jj_consume_token(-1);
0559: throw new ParseException();
0560: }
0561: break;
0562: default:
0563: jj_la1[16] = jj_gen;
0564: ;
0565: }
0566: jj_consume_token(JOIN);
0567: } finally {
0568: if (jjtc000) {
0569: jjtree.closeNodeScope(jjtn000, true);
0570: }
0571: }
0572: }
0573:
0574: final public void CollectionMemberDeclaration()
0575: throws ParseException {
0576: /*@bgen(jjtree) CollectionMemberDeclaration */
0577: ASTCollectionMemberDeclaration jjtn000 = new ASTCollectionMemberDeclaration(
0578: JJTCOLLECTIONMEMBERDECLARATION);
0579: boolean jjtc000 = true;
0580: jjtree.openNodeScope(jjtn000);
0581: try {
0582: jj_consume_token(IN);
0583: jj_consume_token(LPAREN);
0584: PathExpression();
0585: jj_consume_token(RPAREN);
0586: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0587: case AS:
0588: jj_consume_token(AS);
0589: break;
0590: default:
0591: jj_la1[17] = jj_gen;
0592: ;
0593: }
0594: IdentificationVariable();
0595: } catch (Throwable jjte000) {
0596: if (jjtc000) {
0597: jjtree.clearNodeScope(jjtn000);
0598: jjtc000 = false;
0599: } else {
0600: jjtree.popNode();
0601: }
0602: if (jjte000 instanceof RuntimeException) {
0603: {
0604: if (true)
0605: throw (RuntimeException) jjte000;
0606: }
0607: }
0608: if (jjte000 instanceof ParseException) {
0609: {
0610: if (true)
0611: throw (ParseException) jjte000;
0612: }
0613: }
0614: {
0615: if (true)
0616: throw (Error) jjte000;
0617: }
0618: } finally {
0619: if (jjtc000) {
0620: jjtree.closeNodeScope(jjtn000, true);
0621: }
0622: }
0623: }
0624:
0625: final public void PathExpression() throws ParseException {
0626: /*@bgen(jjtree) PathExpression */
0627: ASTPathExpression jjtn000 = new ASTPathExpression(
0628: JJTPATHEXPRESSION);
0629: boolean jjtc000 = true;
0630: jjtree.openNodeScope(jjtn000);
0631: Token t;
0632: try {
0633: t = jj_consume_token(IDENTIFIER);
0634: jjtn000.value = t.image;
0635: jj_consume_token(DOT);
0636: t = jj_consume_token(IDENTIFIER);
0637: jjtn000.value = (String) jjtn000.value + "." + t.image;
0638: label_3: while (true) {
0639: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0640: case DOT:
0641: ;
0642: break;
0643: default:
0644: jj_la1[18] = jj_gen;
0645: break label_3;
0646: }
0647: jj_consume_token(DOT);
0648: t = jj_consume_token(IDENTIFIER);
0649: jjtn000.value = (String) jjtn000.value + "." + t.image;
0650: }
0651: } finally {
0652: if (jjtc000) {
0653: jjtree.closeNodeScope(jjtn000, true);
0654: }
0655: }
0656: }
0657:
0658: final public void UpdateClause() throws ParseException {
0659: /*@bgen(jjtree) UpdateClause */
0660: ASTUpdateClause jjtn000 = new ASTUpdateClause(JJTUPDATECLAUSE);
0661: boolean jjtc000 = true;
0662: jjtree.openNodeScope(jjtn000);
0663: try {
0664: jj_consume_token(UPDATE);
0665: AbstractSchemaName();
0666: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0667: case AS:
0668: case IDENTIFIER:
0669: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0670: case AS:
0671: jj_consume_token(AS);
0672: break;
0673: default:
0674: jj_la1[19] = jj_gen;
0675: ;
0676: }
0677: IdentificationVariable();
0678: break;
0679: default:
0680: jj_la1[20] = jj_gen;
0681: ;
0682: }
0683: jj_consume_token(SET);
0684: UpdateItem();
0685: label_4: while (true) {
0686: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0687: case COMMA:
0688: ;
0689: break;
0690: default:
0691: jj_la1[21] = jj_gen;
0692: break label_4;
0693: }
0694: jj_consume_token(COMMA);
0695: UpdateItem();
0696: }
0697: } catch (Throwable jjte000) {
0698: if (jjtc000) {
0699: jjtree.clearNodeScope(jjtn000);
0700: jjtc000 = false;
0701: } else {
0702: jjtree.popNode();
0703: }
0704: if (jjte000 instanceof RuntimeException) {
0705: {
0706: if (true)
0707: throw (RuntimeException) jjte000;
0708: }
0709: }
0710: if (jjte000 instanceof ParseException) {
0711: {
0712: if (true)
0713: throw (ParseException) jjte000;
0714: }
0715: }
0716: {
0717: if (true)
0718: throw (Error) jjte000;
0719: }
0720: } finally {
0721: if (jjtc000) {
0722: jjtree.closeNodeScope(jjtn000, true);
0723: }
0724: }
0725: }
0726:
0727: final public void UpdateItem() throws ParseException {
0728: /*@bgen(jjtree) UpdateItem */
0729: ASTUpdateItem jjtn000 = new ASTUpdateItem(JJTUPDATEITEM);
0730: boolean jjtc000 = true;
0731: jjtree.openNodeScope(jjtn000);
0732: try {
0733: if (jj_2_1(2147483647)) {
0734: PathExpression();
0735: } else {
0736: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0737: case IDENTIFIER:
0738: IdentificationVariable();
0739: break;
0740: default:
0741: jj_la1[22] = jj_gen;
0742: jj_consume_token(-1);
0743: throw new ParseException();
0744: }
0745: }
0746: jj_consume_token(EQ);
0747: NewValue();
0748: } catch (Throwable jjte000) {
0749: if (jjtc000) {
0750: jjtree.clearNodeScope(jjtn000);
0751: jjtc000 = false;
0752: } else {
0753: jjtree.popNode();
0754: }
0755: if (jjte000 instanceof RuntimeException) {
0756: {
0757: if (true)
0758: throw (RuntimeException) jjte000;
0759: }
0760: }
0761: if (jjte000 instanceof ParseException) {
0762: {
0763: if (true)
0764: throw (ParseException) jjte000;
0765: }
0766: }
0767: {
0768: if (true)
0769: throw (Error) jjte000;
0770: }
0771: } finally {
0772: if (jjtc000) {
0773: jjtree.closeNodeScope(jjtn000, true);
0774: }
0775: }
0776: }
0777:
0778: final public void NewValue() throws ParseException {
0779: /*@bgen(jjtree) NewValue */
0780: ASTNewValue jjtn000 = new ASTNewValue(JJTNEWVALUE);
0781: boolean jjtc000 = true;
0782: jjtree.openNodeScope(jjtn000);
0783: try {
0784: if (jj_2_2(3)) {
0785: SimpleArithmeticExpression();
0786: } else if (jj_2_3(3)) {
0787: StringPrimary();
0788: } else if (jj_2_4(3)) {
0789: DatetimePrimary();
0790: } else if (jj_2_5(3)) {
0791: BooleanPrimary();
0792: } else {
0793: jj_consume_token(-1);
0794: throw new ParseException();
0795: }
0796: } catch (Throwable jjte000) {
0797: if (jjtc000) {
0798: jjtree.clearNodeScope(jjtn000);
0799: jjtc000 = false;
0800: } else {
0801: jjtree.popNode();
0802: }
0803: if (jjte000 instanceof RuntimeException) {
0804: {
0805: if (true)
0806: throw (RuntimeException) jjte000;
0807: }
0808: }
0809: if (jjte000 instanceof ParseException) {
0810: {
0811: if (true)
0812: throw (ParseException) jjte000;
0813: }
0814: }
0815: {
0816: if (true)
0817: throw (Error) jjte000;
0818: }
0819: } finally {
0820: if (jjtc000) {
0821: jjtree.closeNodeScope(jjtn000, true);
0822: }
0823: }
0824: }
0825:
0826: final public void DeleteClause() throws ParseException {
0827: /*@bgen(jjtree) DeleteClause */
0828: ASTDeleteClause jjtn000 = new ASTDeleteClause(JJTDELETECLAUSE);
0829: boolean jjtc000 = true;
0830: jjtree.openNodeScope(jjtn000);
0831: try {
0832: jj_consume_token(DELETE);
0833: jj_consume_token(FROM);
0834: AbstractSchemaName();
0835: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0836: case AS:
0837: case IDENTIFIER:
0838: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0839: case AS:
0840: jj_consume_token(AS);
0841: break;
0842: default:
0843: jj_la1[23] = jj_gen;
0844: ;
0845: }
0846: IdentificationVariable();
0847: break;
0848: default:
0849: jj_la1[24] = jj_gen;
0850: ;
0851: }
0852: } catch (Throwable jjte000) {
0853: if (jjtc000) {
0854: jjtree.clearNodeScope(jjtn000);
0855: jjtc000 = false;
0856: } else {
0857: jjtree.popNode();
0858: }
0859: if (jjte000 instanceof RuntimeException) {
0860: {
0861: if (true)
0862: throw (RuntimeException) jjte000;
0863: }
0864: }
0865: if (jjte000 instanceof ParseException) {
0866: {
0867: if (true)
0868: throw (ParseException) jjte000;
0869: }
0870: }
0871: {
0872: if (true)
0873: throw (Error) jjte000;
0874: }
0875: } finally {
0876: if (jjtc000) {
0877: jjtree.closeNodeScope(jjtn000, true);
0878: }
0879: }
0880: }
0881:
0882: final public void SelectClause() throws ParseException {
0883: /*@bgen(jjtree) SelectClause */
0884: ASTSelectClause jjtn000 = new ASTSelectClause(JJTSELECTCLAUSE);
0885: boolean jjtc000 = true;
0886: jjtree.openNodeScope(jjtn000);
0887: try {
0888: jj_consume_token(SELECT);
0889: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0890: case DISTINCT:
0891: jj_consume_token(DISTINCT);
0892: jjtn000.distinct = true;
0893: break;
0894: default:
0895: jj_la1[25] = jj_gen;
0896: ;
0897: }
0898: SelectExpression();
0899: label_5: while (true) {
0900: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0901: case COMMA:
0902: ;
0903: break;
0904: default:
0905: jj_la1[26] = jj_gen;
0906: break label_5;
0907: }
0908: jj_consume_token(COMMA);
0909: SelectExpression();
0910: }
0911: } catch (Throwable jjte000) {
0912: if (jjtc000) {
0913: jjtree.clearNodeScope(jjtn000);
0914: jjtc000 = false;
0915: } else {
0916: jjtree.popNode();
0917: }
0918: if (jjte000 instanceof RuntimeException) {
0919: {
0920: if (true)
0921: throw (RuntimeException) jjte000;
0922: }
0923: }
0924: if (jjte000 instanceof ParseException) {
0925: {
0926: if (true)
0927: throw (ParseException) jjte000;
0928: }
0929: }
0930: {
0931: if (true)
0932: throw (Error) jjte000;
0933: }
0934: } finally {
0935: if (jjtc000) {
0936: jjtree.closeNodeScope(jjtn000, true);
0937: }
0938: }
0939: }
0940:
0941: final public void SelectExpression() throws ParseException {
0942: /*@bgen(jjtree) SelectExpression */
0943: ASTSelectExpression jjtn000 = new ASTSelectExpression(
0944: JJTSELECTEXPRESSION);
0945: boolean jjtc000 = true;
0946: jjtree.openNodeScope(jjtn000);
0947: try {
0948: if (jj_2_6(2147483647)) {
0949: PathExpression();
0950: } else {
0951: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0952: case AVG:
0953: case COUNT:
0954: case MAX:
0955: case MIN:
0956: case SUM:
0957: AggregateSelectExpression();
0958: break;
0959: case IDENTIFIER:
0960: IdentificationVariable();
0961: break;
0962: case OBJECT:
0963: jj_consume_token(OBJECT);
0964: jj_consume_token(LPAREN);
0965: IdentificationVariable();
0966: jj_consume_token(RPAREN);
0967: break;
0968: case NEW:
0969: ConstructorExpression();
0970: break;
0971: default:
0972: jj_la1[27] = jj_gen;
0973: jj_consume_token(-1);
0974: throw new ParseException();
0975: }
0976: }
0977: } catch (Throwable jjte000) {
0978: if (jjtc000) {
0979: jjtree.clearNodeScope(jjtn000);
0980: jjtc000 = false;
0981: } else {
0982: jjtree.popNode();
0983: }
0984: if (jjte000 instanceof RuntimeException) {
0985: {
0986: if (true)
0987: throw (RuntimeException) jjte000;
0988: }
0989: }
0990: if (jjte000 instanceof ParseException) {
0991: {
0992: if (true)
0993: throw (ParseException) jjte000;
0994: }
0995: }
0996: {
0997: if (true)
0998: throw (Error) jjte000;
0999: }
1000: } finally {
1001: if (jjtc000) {
1002: jjtree.closeNodeScope(jjtn000, true);
1003: }
1004: }
1005: }
1006:
1007: final public void ConstructorExpression() throws ParseException {
1008: /*@bgen(jjtree) ConstructorExpression */
1009: ASTConstructorExpression jjtn000 = new ASTConstructorExpression(
1010: JJTCONSTRUCTOREXPRESSION);
1011: boolean jjtc000 = true;
1012: jjtree.openNodeScope(jjtn000);
1013: try {
1014: jj_consume_token(NEW);
1015: ConstructorName();
1016: jj_consume_token(LPAREN);
1017: ConstructorItem();
1018: label_6: while (true) {
1019: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1020: case COMMA:
1021: ;
1022: break;
1023: default:
1024: jj_la1[28] = jj_gen;
1025: break label_6;
1026: }
1027: jj_consume_token(COMMA);
1028: ConstructorItem();
1029: }
1030: jj_consume_token(RPAREN);
1031: } catch (Throwable jjte000) {
1032: if (jjtc000) {
1033: jjtree.clearNodeScope(jjtn000);
1034: jjtc000 = false;
1035: } else {
1036: jjtree.popNode();
1037: }
1038: if (jjte000 instanceof RuntimeException) {
1039: {
1040: if (true)
1041: throw (RuntimeException) jjte000;
1042: }
1043: }
1044: if (jjte000 instanceof ParseException) {
1045: {
1046: if (true)
1047: throw (ParseException) jjte000;
1048: }
1049: }
1050: {
1051: if (true)
1052: throw (Error) jjte000;
1053: }
1054: } finally {
1055: if (jjtc000) {
1056: jjtree.closeNodeScope(jjtn000, true);
1057: }
1058: }
1059: }
1060:
1061: final public void ConstructorItem() throws ParseException {
1062: /*@bgen(jjtree) ConstructorItem */
1063: ASTConstructorItem jjtn000 = new ASTConstructorItem(
1064: JJTCONSTRUCTORITEM);
1065: boolean jjtc000 = true;
1066: jjtree.openNodeScope(jjtn000);
1067: try {
1068: if (jj_2_7(2147483647)) {
1069: PathExpression();
1070: } else if (jj_2_8(2147483647)) {
1071: AggregateSelectExpression();
1072: } else {
1073: jj_consume_token(-1);
1074: throw new ParseException();
1075: }
1076: } catch (Throwable jjte000) {
1077: if (jjtc000) {
1078: jjtree.clearNodeScope(jjtn000);
1079: jjtc000 = false;
1080: } else {
1081: jjtree.popNode();
1082: }
1083: if (jjte000 instanceof RuntimeException) {
1084: {
1085: if (true)
1086: throw (RuntimeException) jjte000;
1087: }
1088: }
1089: if (jjte000 instanceof ParseException) {
1090: {
1091: if (true)
1092: throw (ParseException) jjte000;
1093: }
1094: }
1095: {
1096: if (true)
1097: throw (Error) jjte000;
1098: }
1099: } finally {
1100: if (jjtc000) {
1101: jjtree.closeNodeScope(jjtn000, true);
1102: }
1103: }
1104: }
1105:
1106: final public void ConstructorName() throws ParseException {
1107: /*@bgen(jjtree) ConstructorName */
1108: ASTConstructorName jjtn000 = new ASTConstructorName(
1109: JJTCONSTRUCTORNAME);
1110: boolean jjtc000 = true;
1111: jjtree.openNodeScope(jjtn000);
1112: try {
1113: if (jj_2_9(2147483647)) {
1114: PathExpression();
1115: } else {
1116: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1117: case IDENTIFIER:
1118: IdentificationVariable();
1119: break;
1120: default:
1121: jj_la1[29] = jj_gen;
1122: jj_consume_token(-1);
1123: throw new ParseException();
1124: }
1125: }
1126: } catch (Throwable jjte000) {
1127: if (jjtc000) {
1128: jjtree.clearNodeScope(jjtn000);
1129: jjtc000 = false;
1130: } else {
1131: jjtree.popNode();
1132: }
1133: if (jjte000 instanceof RuntimeException) {
1134: {
1135: if (true)
1136: throw (RuntimeException) jjte000;
1137: }
1138: }
1139: if (jjte000 instanceof ParseException) {
1140: {
1141: if (true)
1142: throw (ParseException) jjte000;
1143: }
1144: }
1145: {
1146: if (true)
1147: throw (Error) jjte000;
1148: }
1149: } finally {
1150: if (jjtc000) {
1151: jjtree.closeNodeScope(jjtn000, true);
1152: }
1153: }
1154: }
1155:
1156: final public void AggregateSelectExpression() throws ParseException {
1157: /*@bgen(jjtree) AggregateSelectExpression */
1158: ASTAggregateSelectExpression jjtn000 = new ASTAggregateSelectExpression(
1159: JJTAGGREGATESELECTEXPRESSION);
1160: boolean jjtc000 = true;
1161: jjtree.openNodeScope(jjtn000);
1162: Token t;
1163: try {
1164: if (jj_2_11(2)) {
1165: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1166: case AVG:
1167: t = jj_consume_token(AVG);
1168: break;
1169: case MAX:
1170: t = jj_consume_token(MAX);
1171: break;
1172: case MIN:
1173: t = jj_consume_token(MIN);
1174: break;
1175: case SUM:
1176: t = jj_consume_token(SUM);
1177: break;
1178: default:
1179: jj_la1[30] = jj_gen;
1180: jj_consume_token(-1);
1181: throw new ParseException();
1182: }
1183: jjtn000.ops.add(new Integer(t.kind));
1184: jj_consume_token(LPAREN);
1185: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1186: case DISTINCT:
1187: jj_consume_token(DISTINCT);
1188: jjtn000.distinct = true;
1189: break;
1190: default:
1191: jj_la1[31] = jj_gen;
1192: ;
1193: }
1194: PathExpression();
1195: jj_consume_token(RPAREN);
1196: } else {
1197: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1198: case COUNT:
1199: t = jj_consume_token(COUNT);
1200: jjtn000.ops.add(new Integer(t.kind));
1201: jj_consume_token(LPAREN);
1202: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1203: case DISTINCT:
1204: jj_consume_token(DISTINCT);
1205: jjtn000.distinct = true;
1206: break;
1207: default:
1208: jj_la1[32] = jj_gen;
1209: ;
1210: }
1211: if (jj_2_10(2147483647)) {
1212: PathExpression();
1213: } else {
1214: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1215: case IDENTIFIER:
1216: IdentificationVariable();
1217: break;
1218: default:
1219: jj_la1[33] = jj_gen;
1220: jj_consume_token(-1);
1221: throw new ParseException();
1222: }
1223: }
1224: jj_consume_token(RPAREN);
1225: break;
1226: default:
1227: jj_la1[34] = jj_gen;
1228: jj_consume_token(-1);
1229: throw new ParseException();
1230: }
1231: }
1232: } catch (Throwable jjte000) {
1233: if (jjtc000) {
1234: jjtree.clearNodeScope(jjtn000);
1235: jjtc000 = false;
1236: } else {
1237: jjtree.popNode();
1238: }
1239: if (jjte000 instanceof RuntimeException) {
1240: {
1241: if (true)
1242: throw (RuntimeException) jjte000;
1243: }
1244: }
1245: if (jjte000 instanceof ParseException) {
1246: {
1247: if (true)
1248: throw (ParseException) jjte000;
1249: }
1250: }
1251: {
1252: if (true)
1253: throw (Error) jjte000;
1254: }
1255: } finally {
1256: if (jjtc000) {
1257: jjtree.closeNodeScope(jjtn000, true);
1258: }
1259: }
1260: }
1261:
1262: final public void WhereClause() throws ParseException {
1263: /*@bgen(jjtree) WhereClause */
1264: ASTWhereClause jjtn000 = new ASTWhereClause(JJTWHERECLAUSE);
1265: boolean jjtc000 = true;
1266: jjtree.openNodeScope(jjtn000);
1267: try {
1268: jj_consume_token(WHERE);
1269: ConditionalExpression();
1270: } catch (Throwable jjte000) {
1271: if (jjtc000) {
1272: jjtree.clearNodeScope(jjtn000);
1273: jjtc000 = false;
1274: } else {
1275: jjtree.popNode();
1276: }
1277: if (jjte000 instanceof RuntimeException) {
1278: {
1279: if (true)
1280: throw (RuntimeException) jjte000;
1281: }
1282: }
1283: if (jjte000 instanceof ParseException) {
1284: {
1285: if (true)
1286: throw (ParseException) jjte000;
1287: }
1288: }
1289: {
1290: if (true)
1291: throw (Error) jjte000;
1292: }
1293: } finally {
1294: if (jjtc000) {
1295: jjtree.closeNodeScope(jjtn000, true);
1296: }
1297: }
1298: }
1299:
1300: final public void GroupByClause() throws ParseException {
1301: /*@bgen(jjtree) GroupByClause */
1302: ASTGroupByClause jjtn000 = new ASTGroupByClause(
1303: JJTGROUPBYCLAUSE);
1304: boolean jjtc000 = true;
1305: jjtree.openNodeScope(jjtn000);
1306: try {
1307: jj_consume_token(GROUP);
1308: jj_consume_token(BY);
1309: GroupByItem();
1310: label_7: while (true) {
1311: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1312: case COMMA:
1313: ;
1314: break;
1315: default:
1316: jj_la1[35] = jj_gen;
1317: break label_7;
1318: }
1319: jj_consume_token(COMMA);
1320: GroupByItem();
1321: }
1322: } catch (Throwable jjte000) {
1323: if (jjtc000) {
1324: jjtree.clearNodeScope(jjtn000);
1325: jjtc000 = false;
1326: } else {
1327: jjtree.popNode();
1328: }
1329: if (jjte000 instanceof RuntimeException) {
1330: {
1331: if (true)
1332: throw (RuntimeException) jjte000;
1333: }
1334: }
1335: if (jjte000 instanceof ParseException) {
1336: {
1337: if (true)
1338: throw (ParseException) jjte000;
1339: }
1340: }
1341: {
1342: if (true)
1343: throw (Error) jjte000;
1344: }
1345: } finally {
1346: if (jjtc000) {
1347: jjtree.closeNodeScope(jjtn000, true);
1348: }
1349: }
1350: }
1351:
1352: final public void GroupByItem() throws ParseException {
1353: /*@bgen(jjtree) GroupByItem */
1354: ASTGroupByItem jjtn000 = new ASTGroupByItem(JJTGROUPBYITEM);
1355: boolean jjtc000 = true;
1356: jjtree.openNodeScope(jjtn000);
1357: try {
1358: PathExpression();
1359: } catch (Throwable jjte000) {
1360: if (jjtc000) {
1361: jjtree.clearNodeScope(jjtn000);
1362: jjtc000 = false;
1363: } else {
1364: jjtree.popNode();
1365: }
1366: if (jjte000 instanceof RuntimeException) {
1367: {
1368: if (true)
1369: throw (RuntimeException) jjte000;
1370: }
1371: }
1372: if (jjte000 instanceof ParseException) {
1373: {
1374: if (true)
1375: throw (ParseException) jjte000;
1376: }
1377: }
1378: {
1379: if (true)
1380: throw (Error) jjte000;
1381: }
1382: } finally {
1383: if (jjtc000) {
1384: jjtree.closeNodeScope(jjtn000, true);
1385: }
1386: }
1387: }
1388:
1389: final public void HavingClause() throws ParseException {
1390: /*@bgen(jjtree) HavingClause */
1391: ASTHavingClause jjtn000 = new ASTHavingClause(JJTHAVINGCLAUSE);
1392: boolean jjtc000 = true;
1393: jjtree.openNodeScope(jjtn000);
1394: try {
1395: jj_consume_token(HAVING);
1396: ConditionalExpression();
1397: } catch (Throwable jjte000) {
1398: if (jjtc000) {
1399: jjtree.clearNodeScope(jjtn000);
1400: jjtc000 = false;
1401: } else {
1402: jjtree.popNode();
1403: }
1404: if (jjte000 instanceof RuntimeException) {
1405: {
1406: if (true)
1407: throw (RuntimeException) jjte000;
1408: }
1409: }
1410: if (jjte000 instanceof ParseException) {
1411: {
1412: if (true)
1413: throw (ParseException) jjte000;
1414: }
1415: }
1416: {
1417: if (true)
1418: throw (Error) jjte000;
1419: }
1420: } finally {
1421: if (jjtc000) {
1422: jjtree.closeNodeScope(jjtn000, true);
1423: }
1424: }
1425: }
1426:
1427: final public void OrderByClause() throws ParseException {
1428: /*@bgen(jjtree) OrderByClause */
1429: ASTOrderByClause jjtn000 = new ASTOrderByClause(
1430: JJTORDERBYCLAUSE);
1431: boolean jjtc000 = true;
1432: jjtree.openNodeScope(jjtn000);
1433: try {
1434: jj_consume_token(ORDERBY);
1435: OrderByItem();
1436: label_8: while (true) {
1437: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1438: case COMMA:
1439: ;
1440: break;
1441: default:
1442: jj_la1[36] = jj_gen;
1443: break label_8;
1444: }
1445: jj_consume_token(COMMA);
1446: OrderByItem();
1447: }
1448: } catch (Throwable jjte000) {
1449: if (jjtc000) {
1450: jjtree.clearNodeScope(jjtn000);
1451: jjtc000 = false;
1452: } else {
1453: jjtree.popNode();
1454: }
1455: if (jjte000 instanceof RuntimeException) {
1456: {
1457: if (true)
1458: throw (RuntimeException) jjte000;
1459: }
1460: }
1461: if (jjte000 instanceof ParseException) {
1462: {
1463: if (true)
1464: throw (ParseException) jjte000;
1465: }
1466: }
1467: {
1468: if (true)
1469: throw (Error) jjte000;
1470: }
1471: } finally {
1472: if (jjtc000) {
1473: jjtree.closeNodeScope(jjtn000, true);
1474: }
1475: }
1476: }
1477:
1478: final public void OrderByItem() throws ParseException {
1479: /*@bgen(jjtree) OrderByItem */
1480: ASTOrderByItem jjtn000 = new ASTOrderByItem(JJTORDERBYITEM);
1481: boolean jjtc000 = true;
1482: jjtree.openNodeScope(jjtn000);
1483: try {
1484: PathExpression();
1485: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1486: case ASC:
1487: case DESC:
1488: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1489: case ASC:
1490: jj_consume_token(ASC);
1491: jjtn000.asc = true;
1492: break;
1493: case DESC:
1494: jj_consume_token(DESC);
1495: jjtn000.asc = false;
1496: break;
1497: default:
1498: jj_la1[37] = jj_gen;
1499: jj_consume_token(-1);
1500: throw new ParseException();
1501: }
1502: break;
1503: default:
1504: jj_la1[38] = jj_gen;
1505: ;
1506: }
1507: } catch (Throwable jjte000) {
1508: if (jjtc000) {
1509: jjtree.clearNodeScope(jjtn000);
1510: jjtc000 = false;
1511: } else {
1512: jjtree.popNode();
1513: }
1514: if (jjte000 instanceof RuntimeException) {
1515: {
1516: if (true)
1517: throw (RuntimeException) jjte000;
1518: }
1519: }
1520: if (jjte000 instanceof ParseException) {
1521: {
1522: if (true)
1523: throw (ParseException) jjte000;
1524: }
1525: }
1526: {
1527: if (true)
1528: throw (Error) jjte000;
1529: }
1530: } finally {
1531: if (jjtc000) {
1532: jjtree.closeNodeScope(jjtn000, true);
1533: }
1534: }
1535: }
1536:
1537: final public void SubQuery() throws ParseException {
1538: /*@bgen(jjtree) SubQuery */
1539: ASTSubQuery jjtn000 = new ASTSubQuery(JJTSUBQUERY);
1540: boolean jjtc000 = true;
1541: jjtree.openNodeScope(jjtn000);
1542: try {
1543: SimpleSelectClause();
1544: SubqueryFromClause();
1545: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1546: case WHERE:
1547: WhereClause();
1548: break;
1549: default:
1550: jj_la1[39] = jj_gen;
1551: ;
1552: }
1553: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1554: case GROUP:
1555: GroupByClause();
1556: break;
1557: default:
1558: jj_la1[40] = jj_gen;
1559: ;
1560: }
1561: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1562: case HAVING:
1563: HavingClause();
1564: break;
1565: default:
1566: jj_la1[41] = jj_gen;
1567: ;
1568: }
1569: } catch (Throwable jjte000) {
1570: if (jjtc000) {
1571: jjtree.clearNodeScope(jjtn000);
1572: jjtc000 = false;
1573: } else {
1574: jjtree.popNode();
1575: }
1576: if (jjte000 instanceof RuntimeException) {
1577: {
1578: if (true)
1579: throw (RuntimeException) jjte000;
1580: }
1581: }
1582: if (jjte000 instanceof ParseException) {
1583: {
1584: if (true)
1585: throw (ParseException) jjte000;
1586: }
1587: }
1588: {
1589: if (true)
1590: throw (Error) jjte000;
1591: }
1592: } finally {
1593: if (jjtc000) {
1594: jjtree.closeNodeScope(jjtn000, true);
1595: }
1596: }
1597: }
1598:
1599: final public void SubqueryFromClause() throws ParseException {
1600: /*@bgen(jjtree) SubqueryFromClause */
1601: ASTSubqueryFromClause jjtn000 = new ASTSubqueryFromClause(
1602: JJTSUBQUERYFROMCLAUSE);
1603: boolean jjtc000 = true;
1604: jjtree.openNodeScope(jjtn000);
1605: try {
1606: jj_consume_token(FROM);
1607: SubselectIdentificationVariableDeclaration();
1608: label_9: while (true) {
1609: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1610: case COMMA:
1611: ;
1612: break;
1613: default:
1614: jj_la1[42] = jj_gen;
1615: break label_9;
1616: }
1617: jj_consume_token(COMMA);
1618: SubselectIdentificationVariableDeclaration();
1619: }
1620: } catch (Throwable jjte000) {
1621: if (jjtc000) {
1622: jjtree.clearNodeScope(jjtn000);
1623: jjtc000 = false;
1624: } else {
1625: jjtree.popNode();
1626: }
1627: if (jjte000 instanceof RuntimeException) {
1628: {
1629: if (true)
1630: throw (RuntimeException) jjte000;
1631: }
1632: }
1633: if (jjte000 instanceof ParseException) {
1634: {
1635: if (true)
1636: throw (ParseException) jjte000;
1637: }
1638: }
1639: {
1640: if (true)
1641: throw (Error) jjte000;
1642: }
1643: } finally {
1644: if (jjtc000) {
1645: jjtree.closeNodeScope(jjtn000, true);
1646: }
1647: }
1648: }
1649:
1650: final public void SubselectIdentificationVariableDeclaration()
1651: throws ParseException {
1652: /*@bgen(jjtree) SubselectIdentificationVariableDeclaration */
1653: ASTSubselectIdentificationVariableDeclaration jjtn000 = new ASTSubselectIdentificationVariableDeclaration(
1654: JJTSUBSELECTIDENTIFICATIONVARIABLEDECLARATION);
1655: boolean jjtc000 = true;
1656: jjtree.openNodeScope(jjtn000);
1657: try {
1658: if (jj_2_12(2)) {
1659: PathExpression();
1660: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1661: case AS:
1662: jj_consume_token(AS);
1663: break;
1664: default:
1665: jj_la1[43] = jj_gen;
1666: ;
1667: }
1668: IdentificationVariable();
1669: } else if (jj_2_13(2147483647)) {
1670: IdentificationVariableDeclaration();
1671: } else {
1672: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1673: case IN:
1674: CollectionMemberDeclaration();
1675: break;
1676: default:
1677: jj_la1[44] = jj_gen;
1678: jj_consume_token(-1);
1679: throw new ParseException();
1680: }
1681: }
1682: } catch (Throwable jjte000) {
1683: if (jjtc000) {
1684: jjtree.clearNodeScope(jjtn000);
1685: jjtc000 = false;
1686: } else {
1687: jjtree.popNode();
1688: }
1689: if (jjte000 instanceof RuntimeException) {
1690: {
1691: if (true)
1692: throw (RuntimeException) jjte000;
1693: }
1694: }
1695: if (jjte000 instanceof ParseException) {
1696: {
1697: if (true)
1698: throw (ParseException) jjte000;
1699: }
1700: }
1701: {
1702: if (true)
1703: throw (Error) jjte000;
1704: }
1705: } finally {
1706: if (jjtc000) {
1707: jjtree.closeNodeScope(jjtn000, true);
1708: }
1709: }
1710: }
1711:
1712: final public void SimpleSelectClause() throws ParseException {
1713: /*@bgen(jjtree) SimpleSelectClause */
1714: ASTSimpleSelectClause jjtn000 = new ASTSimpleSelectClause(
1715: JJTSIMPLESELECTCLAUSE);
1716: boolean jjtc000 = true;
1717: jjtree.openNodeScope(jjtn000);
1718: try {
1719: jj_consume_token(SELECT);
1720: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1721: case DISTINCT:
1722: jj_consume_token(DISTINCT);
1723: break;
1724: default:
1725: jj_la1[45] = jj_gen;
1726: ;
1727: }
1728: SimpleSelectExpression();
1729: } catch (Throwable jjte000) {
1730: if (jjtc000) {
1731: jjtree.clearNodeScope(jjtn000);
1732: jjtc000 = false;
1733: } else {
1734: jjtree.popNode();
1735: }
1736: if (jjte000 instanceof RuntimeException) {
1737: {
1738: if (true)
1739: throw (RuntimeException) jjte000;
1740: }
1741: }
1742: if (jjte000 instanceof ParseException) {
1743: {
1744: if (true)
1745: throw (ParseException) jjte000;
1746: }
1747: }
1748: {
1749: if (true)
1750: throw (Error) jjte000;
1751: }
1752: } finally {
1753: if (jjtc000) {
1754: jjtree.closeNodeScope(jjtn000, true);
1755: }
1756: }
1757: }
1758:
1759: final public void SimpleSelectExpression() throws ParseException {
1760: /*@bgen(jjtree) SimpleSelectExpression */
1761: ASTSimpleSelectExpression jjtn000 = new ASTSimpleSelectExpression(
1762: JJTSIMPLESELECTEXPRESSION);
1763: boolean jjtc000 = true;
1764: jjtree.openNodeScope(jjtn000);
1765: try {
1766: if (jj_2_14(2147483647)) {
1767: PathExpression();
1768: } else if (jj_2_15(2147483647)) {
1769: AggregateSelectExpression();
1770: } else {
1771: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1772: case IDENTIFIER:
1773: IdentificationVariable();
1774: break;
1775: default:
1776: jj_la1[46] = jj_gen;
1777: jj_consume_token(-1);
1778: throw new ParseException();
1779: }
1780: }
1781: } catch (Throwable jjte000) {
1782: if (jjtc000) {
1783: jjtree.clearNodeScope(jjtn000);
1784: jjtc000 = false;
1785: } else {
1786: jjtree.popNode();
1787: }
1788: if (jjte000 instanceof RuntimeException) {
1789: {
1790: if (true)
1791: throw (RuntimeException) jjte000;
1792: }
1793: }
1794: if (jjte000 instanceof ParseException) {
1795: {
1796: if (true)
1797: throw (ParseException) jjte000;
1798: }
1799: }
1800: {
1801: if (true)
1802: throw (Error) jjte000;
1803: }
1804: } finally {
1805: if (jjtc000) {
1806: jjtree.closeNodeScope(jjtn000, true);
1807: }
1808: }
1809: }
1810:
1811: final public void ConditionalExpression() throws ParseException {
1812: /*@bgen(jjtree) ConditionalExpression */
1813: ASTConditionalExpression jjtn000 = new ASTConditionalExpression(
1814: JJTCONDITIONALEXPRESSION);
1815: boolean jjtc000 = true;
1816: jjtree.openNodeScope(jjtn000);
1817: try {
1818: ConditionalTerm();
1819: label_10: while (true) {
1820: if (jj_2_16(2147483647)) {
1821: ;
1822: } else {
1823: break label_10;
1824: }
1825: jj_consume_token(OR);
1826: ConditionalExpression();
1827: }
1828: } catch (Throwable jjte000) {
1829: if (jjtc000) {
1830: jjtree.clearNodeScope(jjtn000);
1831: jjtc000 = false;
1832: } else {
1833: jjtree.popNode();
1834: }
1835: if (jjte000 instanceof RuntimeException) {
1836: {
1837: if (true)
1838: throw (RuntimeException) jjte000;
1839: }
1840: }
1841: if (jjte000 instanceof ParseException) {
1842: {
1843: if (true)
1844: throw (ParseException) jjte000;
1845: }
1846: }
1847: {
1848: if (true)
1849: throw (Error) jjte000;
1850: }
1851: } finally {
1852: if (jjtc000) {
1853: jjtree.closeNodeScope(jjtn000, true);
1854: }
1855: }
1856: }
1857:
1858: final public void ConditionalTerm() throws ParseException {
1859: /*@bgen(jjtree) ConditionalTerm */
1860: ASTConditionalTerm jjtn000 = new ASTConditionalTerm(
1861: JJTCONDITIONALTERM);
1862: boolean jjtc000 = true;
1863: jjtree.openNodeScope(jjtn000);
1864: try {
1865: ConditionalFactor();
1866: label_11: while (true) {
1867: if (jj_2_17(2147483647)) {
1868: ;
1869: } else {
1870: break label_11;
1871: }
1872: jj_consume_token(AND);
1873: ConditionalTerm();
1874: }
1875: } catch (Throwable jjte000) {
1876: if (jjtc000) {
1877: jjtree.clearNodeScope(jjtn000);
1878: jjtc000 = false;
1879: } else {
1880: jjtree.popNode();
1881: }
1882: if (jjte000 instanceof RuntimeException) {
1883: {
1884: if (true)
1885: throw (RuntimeException) jjte000;
1886: }
1887: }
1888: if (jjte000 instanceof ParseException) {
1889: {
1890: if (true)
1891: throw (ParseException) jjte000;
1892: }
1893: }
1894: {
1895: if (true)
1896: throw (Error) jjte000;
1897: }
1898: } finally {
1899: if (jjtc000) {
1900: jjtree.closeNodeScope(jjtn000, true);
1901: }
1902: }
1903: }
1904:
1905: final public void ConditionalFactor() throws ParseException {
1906: /*@bgen(jjtree) ConditionalFactor */
1907: ASTConditionalFactor jjtn000 = new ASTConditionalFactor(
1908: JJTCONDITIONALFACTOR);
1909: boolean jjtc000 = true;
1910: jjtree.openNodeScope(jjtn000);
1911: try {
1912: if (jj_2_18(2147483647)) {
1913: jj_consume_token(NOT);
1914: jjtn000.not = true;
1915: } else {
1916: ;
1917: }
1918: ConditionalPrimary();
1919: } catch (Throwable jjte000) {
1920: if (jjtc000) {
1921: jjtree.clearNodeScope(jjtn000);
1922: jjtc000 = false;
1923: } else {
1924: jjtree.popNode();
1925: }
1926: if (jjte000 instanceof RuntimeException) {
1927: {
1928: if (true)
1929: throw (RuntimeException) jjte000;
1930: }
1931: }
1932: if (jjte000 instanceof ParseException) {
1933: {
1934: if (true)
1935: throw (ParseException) jjte000;
1936: }
1937: }
1938: {
1939: if (true)
1940: throw (Error) jjte000;
1941: }
1942: } finally {
1943: if (jjtc000) {
1944: jjtree.closeNodeScope(jjtn000, true);
1945: }
1946: }
1947: }
1948:
1949: final public void ConditionalPrimary() throws ParseException {
1950: /*@bgen(jjtree) ConditionalPrimary */
1951: ASTConditionalPrimary jjtn000 = new ASTConditionalPrimary(
1952: JJTCONDITIONALPRIMARY);
1953: boolean jjtc000 = true;
1954: jjtree.openNodeScope(jjtn000);
1955: try {
1956: if (jj_2_19(2147483647)) {
1957: jj_consume_token(LPAREN);
1958: ConditionalExpression();
1959: jj_consume_token(RPAREN);
1960: } else {
1961: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1962: case MINUS:
1963: case PLUS:
1964: case LPAREN:
1965: case ABS:
1966: case AVG:
1967: case CONCAT:
1968: case COUNT:
1969: case CURRENT_DATE:
1970: case CURRENT_TIME:
1971: case CURRENT_TIMESTAMP:
1972: case EXISTS:
1973: case LENGTH:
1974: case LOCATE:
1975: case LOWER:
1976: case MAX:
1977: case MIN:
1978: case MOD:
1979: case NOT:
1980: case SIZE:
1981: case SQRT:
1982: case SUBSTRING:
1983: case SUM:
1984: case TRIM:
1985: case UPPER:
1986: case named_parameter:
1987: case string_literal:
1988: case input_parameter:
1989: case FALSE:
1990: case TRUE:
1991: case INTEGER_LITERAL:
1992: case FLOATING_POINT_LITERAL:
1993: case IDENTIFIER:
1994: SimpleCondExpression();
1995: break;
1996: default:
1997: jj_la1[47] = jj_gen;
1998: jj_consume_token(-1);
1999: throw new ParseException();
2000: }
2001: }
2002: } catch (Throwable jjte000) {
2003: if (jjtc000) {
2004: jjtree.clearNodeScope(jjtn000);
2005: jjtc000 = false;
2006: } else {
2007: jjtree.popNode();
2008: }
2009: if (jjte000 instanceof RuntimeException) {
2010: {
2011: if (true)
2012: throw (RuntimeException) jjte000;
2013: }
2014: }
2015: if (jjte000 instanceof ParseException) {
2016: {
2017: if (true)
2018: throw (ParseException) jjte000;
2019: }
2020: }
2021: {
2022: if (true)
2023: throw (Error) jjte000;
2024: }
2025: } finally {
2026: if (jjtc000) {
2027: jjtree.closeNodeScope(jjtn000, true);
2028: }
2029: }
2030: }
2031:
2032: final public void SimpleCondExpression() throws ParseException {
2033: /*@bgen(jjtree) SimpleCondExpression */
2034: ASTSimpleCondExpression jjtn000 = new ASTSimpleCondExpression(
2035: JJTSIMPLECONDEXPRESSION);
2036: boolean jjtc000 = true;
2037: jjtree.openNodeScope(jjtn000);
2038: try {
2039: if (jj_2_20(2147483647)) {
2040: ComparisonExpression();
2041: } else if (jj_2_21(2147483647)) {
2042: BetweenExpression();
2043: } else if (jj_2_22(2147483647)) {
2044: LikeExpression();
2045: } else if (jj_2_23(2147483647)) {
2046: InExpression();
2047: } else if (jj_2_24(2147483647)) {
2048: NullComparisonExpression();
2049: } else if (jj_2_25(2147483647)) {
2050: EmptyCollectionComparisonExpression();
2051: } else if (jj_2_26(2147483647)) {
2052: CollectionMemberExpression();
2053: } else if (jj_2_27(2147483647)) {
2054: ExistsExpression();
2055: } else {
2056: jj_consume_token(-1);
2057: throw new ParseException();
2058: }
2059: } catch (Throwable jjte000) {
2060: if (jjtc000) {
2061: jjtree.clearNodeScope(jjtn000);
2062: jjtc000 = false;
2063: } else {
2064: jjtree.popNode();
2065: }
2066: if (jjte000 instanceof RuntimeException) {
2067: {
2068: if (true)
2069: throw (RuntimeException) jjte000;
2070: }
2071: }
2072: if (jjte000 instanceof ParseException) {
2073: {
2074: if (true)
2075: throw (ParseException) jjte000;
2076: }
2077: }
2078: {
2079: if (true)
2080: throw (Error) jjte000;
2081: }
2082: } finally {
2083: if (jjtc000) {
2084: jjtree.closeNodeScope(jjtn000, true);
2085: }
2086: }
2087: }
2088:
2089: final public void BetweenExpression() throws ParseException {
2090: /*@bgen(jjtree) BetweenExpression */
2091: ASTBetweenExpression jjtn000 = new ASTBetweenExpression(
2092: JJTBETWEENEXPRESSION);
2093: boolean jjtc000 = true;
2094: jjtree.openNodeScope(jjtn000);
2095: try {
2096: if (jj_2_28(3)) {
2097: ArithmeticExpression();
2098: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2099: case NOT:
2100: jj_consume_token(NOT);
2101: jjtn000.not = true;
2102: break;
2103: default:
2104: jj_la1[48] = jj_gen;
2105: ;
2106: }
2107: jj_consume_token(BETWEEN);
2108: ArithmeticExpression();
2109: jj_consume_token(AND);
2110: ArithmeticExpression();
2111: } else if (jj_2_29(3)) {
2112: StringExpression();
2113: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2114: case NOT:
2115: jj_consume_token(NOT);
2116: jjtn000.not = true;
2117: break;
2118: default:
2119: jj_la1[49] = jj_gen;
2120: ;
2121: }
2122: jj_consume_token(BETWEEN);
2123: StringExpression();
2124: jj_consume_token(AND);
2125: StringExpression();
2126: } else if (jj_2_30(3)) {
2127: DatetimeExpression();
2128: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2129: case NOT:
2130: jj_consume_token(NOT);
2131: jjtn000.not = true;
2132: break;
2133: default:
2134: jj_la1[50] = jj_gen;
2135: ;
2136: }
2137: jj_consume_token(BETWEEN);
2138: DatetimeExpression();
2139: jj_consume_token(AND);
2140: DatetimeExpression();
2141: } else {
2142: jj_consume_token(-1);
2143: throw new ParseException();
2144: }
2145: } catch (Throwable jjte000) {
2146: if (jjtc000) {
2147: jjtree.clearNodeScope(jjtn000);
2148: jjtc000 = false;
2149: } else {
2150: jjtree.popNode();
2151: }
2152: if (jjte000 instanceof RuntimeException) {
2153: {
2154: if (true)
2155: throw (RuntimeException) jjte000;
2156: }
2157: }
2158: if (jjte000 instanceof ParseException) {
2159: {
2160: if (true)
2161: throw (ParseException) jjte000;
2162: }
2163: }
2164: {
2165: if (true)
2166: throw (Error) jjte000;
2167: }
2168: } finally {
2169: if (jjtc000) {
2170: jjtree.closeNodeScope(jjtn000, true);
2171: }
2172: }
2173: }
2174:
2175: final public void InExpression() throws ParseException {
2176: /*@bgen(jjtree) InExpression */
2177: ASTInExpression jjtn000 = new ASTInExpression(JJTINEXPRESSION);
2178: boolean jjtc000 = true;
2179: jjtree.openNodeScope(jjtn000);
2180: try {
2181: PathExpression();
2182: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2183: case NOT:
2184: jj_consume_token(NOT);
2185: jjtn000.not = true;
2186: break;
2187: default:
2188: jj_la1[51] = jj_gen;
2189: ;
2190: }
2191: jj_consume_token(IN);
2192: jj_consume_token(LPAREN);
2193: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2194: case named_parameter:
2195: case string_literal:
2196: case input_parameter:
2197: case FALSE:
2198: case TRUE:
2199: case INTEGER_LITERAL:
2200: case FLOATING_POINT_LITERAL:
2201: InItem();
2202: jjtn000.eltnum = 1;
2203: label_12: while (true) {
2204: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2205: case COMMA:
2206: ;
2207: break;
2208: default:
2209: jj_la1[52] = jj_gen;
2210: break label_12;
2211: }
2212: jj_consume_token(COMMA);
2213: InItem();
2214: jjtn000.eltnum++;
2215: }
2216: break;
2217: case SELECT:
2218: SubQuery();
2219: break;
2220: default:
2221: jj_la1[53] = jj_gen;
2222: jj_consume_token(-1);
2223: throw new ParseException();
2224: }
2225: jj_consume_token(RPAREN);
2226: } catch (Throwable jjte000) {
2227: if (jjtc000) {
2228: jjtree.clearNodeScope(jjtn000);
2229: jjtc000 = false;
2230: } else {
2231: jjtree.popNode();
2232: }
2233: if (jjte000 instanceof RuntimeException) {
2234: {
2235: if (true)
2236: throw (RuntimeException) jjte000;
2237: }
2238: }
2239: if (jjte000 instanceof ParseException) {
2240: {
2241: if (true)
2242: throw (ParseException) jjte000;
2243: }
2244: }
2245: {
2246: if (true)
2247: throw (Error) jjte000;
2248: }
2249: } finally {
2250: if (jjtc000) {
2251: jjtree.closeNodeScope(jjtn000, true);
2252: }
2253: }
2254: }
2255:
2256: final public void InItem() throws ParseException {
2257: /*@bgen(jjtree) InItem */
2258: ASTInItem jjtn000 = new ASTInItem(JJTINITEM);
2259: boolean jjtc000 = true;
2260: jjtree.openNodeScope(jjtn000);
2261: try {
2262: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2263: case string_literal:
2264: case FALSE:
2265: case TRUE:
2266: case INTEGER_LITERAL:
2267: case FLOATING_POINT_LITERAL:
2268: Literal();
2269: break;
2270: case named_parameter:
2271: case input_parameter:
2272: InputParameter();
2273: break;
2274: default:
2275: jj_la1[54] = jj_gen;
2276: jj_consume_token(-1);
2277: throw new ParseException();
2278: }
2279: } catch (Throwable jjte000) {
2280: if (jjtc000) {
2281: jjtree.clearNodeScope(jjtn000);
2282: jjtc000 = false;
2283: } else {
2284: jjtree.popNode();
2285: }
2286: if (jjte000 instanceof RuntimeException) {
2287: {
2288: if (true)
2289: throw (RuntimeException) jjte000;
2290: }
2291: }
2292: if (jjte000 instanceof ParseException) {
2293: {
2294: if (true)
2295: throw (ParseException) jjte000;
2296: }
2297: }
2298: {
2299: if (true)
2300: throw (Error) jjte000;
2301: }
2302: } finally {
2303: if (jjtc000) {
2304: jjtree.closeNodeScope(jjtn000, true);
2305: }
2306: }
2307: }
2308:
2309: final public void LikeExpression() throws ParseException {
2310: /*@bgen(jjtree) LikeExpression */
2311: ASTLikeExpression jjtn000 = new ASTLikeExpression(
2312: JJTLIKEEXPRESSION);
2313: boolean jjtc000 = true;
2314: jjtree.openNodeScope(jjtn000);
2315: try {
2316: StringExpression();
2317: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2318: case NOT:
2319: jj_consume_token(NOT);
2320: jjtn000.not = true;
2321: break;
2322: default:
2323: jj_la1[55] = jj_gen;
2324: ;
2325: }
2326: jj_consume_token(LIKE);
2327: PatternValue();
2328: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2329: case ESCAPE:
2330: jj_consume_token(ESCAPE);
2331: jjtn000.third = true;
2332: EscapeCharacter();
2333: break;
2334: default:
2335: jj_la1[56] = jj_gen;
2336: ;
2337: }
2338: } catch (Throwable jjte000) {
2339: if (jjtc000) {
2340: jjtree.clearNodeScope(jjtn000);
2341: jjtc000 = false;
2342: } else {
2343: jjtree.popNode();
2344: }
2345: if (jjte000 instanceof RuntimeException) {
2346: {
2347: if (true)
2348: throw (RuntimeException) jjte000;
2349: }
2350: }
2351: if (jjte000 instanceof ParseException) {
2352: {
2353: if (true)
2354: throw (ParseException) jjte000;
2355: }
2356: }
2357: {
2358: if (true)
2359: throw (Error) jjte000;
2360: }
2361: } finally {
2362: if (jjtc000) {
2363: jjtree.closeNodeScope(jjtn000, true);
2364: }
2365: }
2366: }
2367:
2368: final public void NullComparisonExpression() throws ParseException {
2369: /*@bgen(jjtree) NullComparisonExpression */
2370: ASTNullComparisonExpression jjtn000 = new ASTNullComparisonExpression(
2371: JJTNULLCOMPARISONEXPRESSION);
2372: boolean jjtc000 = true;
2373: jjtree.openNodeScope(jjtn000);
2374: try {
2375: if (jj_2_31(2147483647)) {
2376: PathExpression();
2377: } else {
2378: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2379: case named_parameter:
2380: case input_parameter:
2381: InputParameter();
2382: break;
2383: default:
2384: jj_la1[57] = jj_gen;
2385: jj_consume_token(-1);
2386: throw new ParseException();
2387: }
2388: }
2389: jj_consume_token(IS);
2390: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2391: case NOT:
2392: jj_consume_token(NOT);
2393: jjtn000.not = true;
2394: break;
2395: default:
2396: jj_la1[58] = jj_gen;
2397: ;
2398: }
2399: jj_consume_token(NULL);
2400: } catch (Throwable jjte000) {
2401: if (jjtc000) {
2402: jjtree.clearNodeScope(jjtn000);
2403: jjtc000 = false;
2404: } else {
2405: jjtree.popNode();
2406: }
2407: if (jjte000 instanceof RuntimeException) {
2408: {
2409: if (true)
2410: throw (RuntimeException) jjte000;
2411: }
2412: }
2413: if (jjte000 instanceof ParseException) {
2414: {
2415: if (true)
2416: throw (ParseException) jjte000;
2417: }
2418: }
2419: {
2420: if (true)
2421: throw (Error) jjte000;
2422: }
2423: } finally {
2424: if (jjtc000) {
2425: jjtree.closeNodeScope(jjtn000, true);
2426: }
2427: }
2428: }
2429:
2430: final public void EmptyCollectionComparisonExpression()
2431: throws ParseException {
2432: /*@bgen(jjtree) EmptyCollectionComparisonExpression */
2433: ASTEmptyCollectionComparisonExpression jjtn000 = new ASTEmptyCollectionComparisonExpression(
2434: JJTEMPTYCOLLECTIONCOMPARISONEXPRESSION);
2435: boolean jjtc000 = true;
2436: jjtree.openNodeScope(jjtn000);
2437: try {
2438: PathExpression();
2439: jj_consume_token(IS);
2440: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2441: case NOT:
2442: jj_consume_token(NOT);
2443: jjtn000.not = true;
2444: break;
2445: default:
2446: jj_la1[59] = jj_gen;
2447: ;
2448: }
2449: jj_consume_token(EMPTY);
2450: } catch (Throwable jjte000) {
2451: if (jjtc000) {
2452: jjtree.clearNodeScope(jjtn000);
2453: jjtc000 = false;
2454: } else {
2455: jjtree.popNode();
2456: }
2457: if (jjte000 instanceof RuntimeException) {
2458: {
2459: if (true)
2460: throw (RuntimeException) jjte000;
2461: }
2462: }
2463: if (jjte000 instanceof ParseException) {
2464: {
2465: if (true)
2466: throw (ParseException) jjte000;
2467: }
2468: }
2469: {
2470: if (true)
2471: throw (Error) jjte000;
2472: }
2473: } finally {
2474: if (jjtc000) {
2475: jjtree.closeNodeScope(jjtn000, true);
2476: }
2477: }
2478: }
2479:
2480: final public void CollectionMemberExpression()
2481: throws ParseException {
2482: /*@bgen(jjtree) CollectionMemberExpression */
2483: ASTCollectionMemberExpression jjtn000 = new ASTCollectionMemberExpression(
2484: JJTCOLLECTIONMEMBEREXPRESSION);
2485: boolean jjtc000 = true;
2486: jjtree.openNodeScope(jjtn000);
2487: try {
2488: EntityExpression();
2489: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2490: case NOT:
2491: jj_consume_token(NOT);
2492: jjtn000.not = true;
2493: break;
2494: default:
2495: jj_la1[60] = jj_gen;
2496: ;
2497: }
2498: jj_consume_token(MEMBER);
2499: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2500: case OF:
2501: jj_consume_token(OF);
2502: break;
2503: default:
2504: jj_la1[61] = jj_gen;
2505: ;
2506: }
2507: PathExpression();
2508: } catch (Throwable jjte000) {
2509: if (jjtc000) {
2510: jjtree.clearNodeScope(jjtn000);
2511: jjtc000 = false;
2512: } else {
2513: jjtree.popNode();
2514: }
2515: if (jjte000 instanceof RuntimeException) {
2516: {
2517: if (true)
2518: throw (RuntimeException) jjte000;
2519: }
2520: }
2521: if (jjte000 instanceof ParseException) {
2522: {
2523: if (true)
2524: throw (ParseException) jjte000;
2525: }
2526: }
2527: {
2528: if (true)
2529: throw (Error) jjte000;
2530: }
2531: } finally {
2532: if (jjtc000) {
2533: jjtree.closeNodeScope(jjtn000, true);
2534: }
2535: }
2536: }
2537:
2538: final public void ExistsExpression() throws ParseException {
2539: /*@bgen(jjtree) ExistsExpression */
2540: ASTExistsExpression jjtn000 = new ASTExistsExpression(
2541: JJTEXISTSEXPRESSION);
2542: boolean jjtc000 = true;
2543: jjtree.openNodeScope(jjtn000);
2544: try {
2545: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2546: case NOT:
2547: jj_consume_token(NOT);
2548: jjtn000.not = true;
2549: break;
2550: default:
2551: jj_la1[62] = jj_gen;
2552: ;
2553: }
2554: jj_consume_token(EXISTS);
2555: jj_consume_token(LPAREN);
2556: SubQuery();
2557: jj_consume_token(RPAREN);
2558: } catch (Throwable jjte000) {
2559: if (jjtc000) {
2560: jjtree.clearNodeScope(jjtn000);
2561: jjtc000 = false;
2562: } else {
2563: jjtree.popNode();
2564: }
2565: if (jjte000 instanceof RuntimeException) {
2566: {
2567: if (true)
2568: throw (RuntimeException) jjte000;
2569: }
2570: }
2571: if (jjte000 instanceof ParseException) {
2572: {
2573: if (true)
2574: throw (ParseException) jjte000;
2575: }
2576: }
2577: {
2578: if (true)
2579: throw (Error) jjte000;
2580: }
2581: } finally {
2582: if (jjtc000) {
2583: jjtree.closeNodeScope(jjtn000, true);
2584: }
2585: }
2586: }
2587:
2588: final public void AllOrAnyExpression() throws ParseException {
2589: /*@bgen(jjtree) AllOrAnyExpression */
2590: ASTAllOrAnyExpression jjtn000 = new ASTAllOrAnyExpression(
2591: JJTALLORANYEXPRESSION);
2592: boolean jjtc000 = true;
2593: jjtree.openNodeScope(jjtn000);
2594: try {
2595: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2596: case ALL:
2597: jj_consume_token(ALL);
2598: break;
2599: case ANY:
2600: jj_consume_token(ANY);
2601: break;
2602: case SOME:
2603: jj_consume_token(SOME);
2604: break;
2605: default:
2606: jj_la1[63] = jj_gen;
2607: jj_consume_token(-1);
2608: throw new ParseException();
2609: }
2610: jj_consume_token(LPAREN);
2611: SubQuery();
2612: jj_consume_token(RPAREN);
2613: } catch (Throwable jjte000) {
2614: if (jjtc000) {
2615: jjtree.clearNodeScope(jjtn000);
2616: jjtc000 = false;
2617: } else {
2618: jjtree.popNode();
2619: }
2620: if (jjte000 instanceof RuntimeException) {
2621: {
2622: if (true)
2623: throw (RuntimeException) jjte000;
2624: }
2625: }
2626: if (jjte000 instanceof ParseException) {
2627: {
2628: if (true)
2629: throw (ParseException) jjte000;
2630: }
2631: }
2632: {
2633: if (true)
2634: throw (Error) jjte000;
2635: }
2636: } finally {
2637: if (jjtc000) {
2638: jjtree.closeNodeScope(jjtn000, true);
2639: }
2640: }
2641: }
2642:
2643: final public void ComparisonExpression() throws ParseException {
2644: /*@bgen(jjtree) ComparisonExpression */
2645: ASTComparisonExpression jjtn000 = new ASTComparisonExpression(
2646: JJTCOMPARISONEXPRESSION);
2647: boolean jjtc000 = true;
2648: jjtree.openNodeScope(jjtn000);
2649: Token t = null;
2650: try {
2651: if (jj_2_32(2147483647)) {
2652: ArithmeticExpression();
2653: ComparisonOperator();
2654: if (t != null)
2655: jjtn000.ops.add(new Integer(t.kind));
2656: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2657: case MINUS:
2658: case PLUS:
2659: case LPAREN:
2660: case ABS:
2661: case AVG:
2662: case COUNT:
2663: case LENGTH:
2664: case LOCATE:
2665: case MAX:
2666: case MIN:
2667: case MOD:
2668: case SIZE:
2669: case SQRT:
2670: case SUM:
2671: case named_parameter:
2672: case input_parameter:
2673: case INTEGER_LITERAL:
2674: case FLOATING_POINT_LITERAL:
2675: case IDENTIFIER:
2676: ArithmeticExpression();
2677: break;
2678: case ALL:
2679: case ANY:
2680: case SOME:
2681: AllOrAnyExpression();
2682: break;
2683: default:
2684: jj_la1[64] = jj_gen;
2685: jj_consume_token(-1);
2686: throw new ParseException();
2687: }
2688: } else if (jj_2_33(2147483647)) {
2689: StringExpression();
2690: ComparisonOperator();
2691: if (t != null)
2692: jjtn000.ops.add(new Integer(t.kind));
2693: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2694: case LPAREN:
2695: case CONCAT:
2696: case LOWER:
2697: case SUBSTRING:
2698: case TRIM:
2699: case UPPER:
2700: case named_parameter:
2701: case string_literal:
2702: case input_parameter:
2703: case IDENTIFIER:
2704: StringExpression();
2705: break;
2706: case ALL:
2707: case ANY:
2708: case SOME:
2709: AllOrAnyExpression();
2710: break;
2711: default:
2712: jj_la1[65] = jj_gen;
2713: jj_consume_token(-1);
2714: throw new ParseException();
2715: }
2716: } else if (jj_2_34(2147483647)) {
2717: BooleanExpression();
2718: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2719: case EQ:
2720: t = jj_consume_token(EQ);
2721: break;
2722: case NE:
2723: t = jj_consume_token(NE);
2724: break;
2725: default:
2726: jj_la1[66] = jj_gen;
2727: jj_consume_token(-1);
2728: throw new ParseException();
2729: }
2730: if (t != null)
2731: jjtn000.ops.add(new Integer(t.kind));
2732: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2733: case LPAREN:
2734: case named_parameter:
2735: case input_parameter:
2736: case FALSE:
2737: case TRUE:
2738: case IDENTIFIER:
2739: BooleanExpression();
2740: break;
2741: case ALL:
2742: case ANY:
2743: case SOME:
2744: AllOrAnyExpression();
2745: break;
2746: default:
2747: jj_la1[67] = jj_gen;
2748: jj_consume_token(-1);
2749: throw new ParseException();
2750: }
2751: } else if (jj_2_35(2147483647)) {
2752: DatetimeExpression();
2753: ComparisonOperator();
2754: if (t != null)
2755: jjtn000.ops.add(new Integer(t.kind));
2756: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2757: case LPAREN:
2758: case CURRENT_DATE:
2759: case CURRENT_TIME:
2760: case CURRENT_TIMESTAMP:
2761: case named_parameter:
2762: case input_parameter:
2763: case IDENTIFIER:
2764: DatetimeExpression();
2765: break;
2766: case ALL:
2767: case ANY:
2768: case SOME:
2769: AllOrAnyExpression();
2770: break;
2771: default:
2772: jj_la1[68] = jj_gen;
2773: jj_consume_token(-1);
2774: throw new ParseException();
2775: }
2776: } else if (jj_2_36(2147483647)) {
2777: EntityExpression();
2778: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2779: case EQ:
2780: t = jj_consume_token(EQ);
2781: break;
2782: case NE:
2783: t = jj_consume_token(NE);
2784: break;
2785: default:
2786: jj_la1[69] = jj_gen;
2787: jj_consume_token(-1);
2788: throw new ParseException();
2789: }
2790: if (t != null)
2791: jjtn000.ops.add(new Integer(t.kind));
2792: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2793: case named_parameter:
2794: case input_parameter:
2795: case IDENTIFIER:
2796: EntityExpression();
2797: break;
2798: case ALL:
2799: case ANY:
2800: case SOME:
2801: AllOrAnyExpression();
2802: break;
2803: default:
2804: jj_la1[70] = jj_gen;
2805: jj_consume_token(-1);
2806: throw new ParseException();
2807: }
2808: } else {
2809: jj_consume_token(-1);
2810: throw new ParseException();
2811: }
2812: } catch (Throwable jjte000) {
2813: if (jjtc000) {
2814: jjtree.clearNodeScope(jjtn000);
2815: jjtc000 = false;
2816: } else {
2817: jjtree.popNode();
2818: }
2819: if (jjte000 instanceof RuntimeException) {
2820: {
2821: if (true)
2822: throw (RuntimeException) jjte000;
2823: }
2824: }
2825: if (jjte000 instanceof ParseException) {
2826: {
2827: if (true)
2828: throw (ParseException) jjte000;
2829: }
2830: }
2831: {
2832: if (true)
2833: throw (Error) jjte000;
2834: }
2835: } finally {
2836: if (jjtc000) {
2837: jjtree.closeNodeScope(jjtn000, true);
2838: }
2839: }
2840: }
2841:
2842: final public void ComparisonOperator() throws ParseException {
2843: /*@bgen(jjtree) ComparisonOperator */
2844: ASTComparisonOperator jjtn000 = new ASTComparisonOperator(
2845: JJTCOMPARISONOPERATOR);
2846: boolean jjtc000 = true;
2847: jjtree.openNodeScope(jjtn000);
2848: try {
2849: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2850: case EQ:
2851: jj_consume_token(EQ);
2852: break;
2853: case GT:
2854: jj_consume_token(GT);
2855: break;
2856: case GE:
2857: jj_consume_token(GE);
2858: break;
2859: case LT:
2860: jj_consume_token(LT);
2861: break;
2862: case LE:
2863: jj_consume_token(LE);
2864: break;
2865: case NE:
2866: jj_consume_token(NE);
2867: break;
2868: default:
2869: jj_la1[71] = jj_gen;
2870: jj_consume_token(-1);
2871: throw new ParseException();
2872: }
2873: } finally {
2874: if (jjtc000) {
2875: jjtree.closeNodeScope(jjtn000, true);
2876: }
2877: }
2878: }
2879:
2880: final public void ArithmeticExpression() throws ParseException {
2881: /*@bgen(jjtree) ArithmeticExpression */
2882: ASTArithmeticExpression jjtn000 = new ASTArithmeticExpression(
2883: JJTARITHMETICEXPRESSION);
2884: boolean jjtc000 = true;
2885: jjtree.openNodeScope(jjtn000);
2886: try {
2887: if (jj_2_37(2147483647)) {
2888: SimpleArithmeticExpression();
2889: } else {
2890: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2891: case LPAREN:
2892: jj_consume_token(LPAREN);
2893: SubQuery();
2894: jj_consume_token(RPAREN);
2895: break;
2896: default:
2897: jj_la1[72] = jj_gen;
2898: jj_consume_token(-1);
2899: throw new ParseException();
2900: }
2901: }
2902: } catch (Throwable jjte000) {
2903: if (jjtc000) {
2904: jjtree.clearNodeScope(jjtn000);
2905: jjtc000 = false;
2906: } else {
2907: jjtree.popNode();
2908: }
2909: if (jjte000 instanceof RuntimeException) {
2910: {
2911: if (true)
2912: throw (RuntimeException) jjte000;
2913: }
2914: }
2915: if (jjte000 instanceof ParseException) {
2916: {
2917: if (true)
2918: throw (ParseException) jjte000;
2919: }
2920: }
2921: {
2922: if (true)
2923: throw (Error) jjte000;
2924: }
2925: } finally {
2926: if (jjtc000) {
2927: jjtree.closeNodeScope(jjtn000, true);
2928: }
2929: }
2930: }
2931:
2932: final public void SimpleArithmeticExpression()
2933: throws ParseException {
2934: /*@bgen(jjtree) SimpleArithmeticExpression */
2935: ASTSimpleArithmeticExpression jjtn000 = new ASTSimpleArithmeticExpression(
2936: JJTSIMPLEARITHMETICEXPRESSION);
2937: boolean jjtc000 = true;
2938: jjtree.openNodeScope(jjtn000);
2939: try {
2940: ArithmeticTerm();
2941: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2942: case MINUS:
2943: case PLUS:
2944: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2945: case PLUS:
2946: jj_consume_token(PLUS);
2947: break;
2948: case MINUS:
2949: jj_consume_token(MINUS);
2950: break;
2951: default:
2952: jj_la1[73] = jj_gen;
2953: jj_consume_token(-1);
2954: throw new ParseException();
2955: }
2956: if (jj_2_38(2147483647)) {
2957: ArithmeticTerm();
2958: } else if (jj_2_39(2147483647)) {
2959: SimpleArithmeticExpression();
2960: } else {
2961: jj_consume_token(-1);
2962: throw new ParseException();
2963: }
2964: break;
2965: default:
2966: jj_la1[74] = jj_gen;
2967: ;
2968: }
2969: } catch (Throwable jjte000) {
2970: if (jjtc000) {
2971: jjtree.clearNodeScope(jjtn000);
2972: jjtc000 = false;
2973: } else {
2974: jjtree.popNode();
2975: }
2976: if (jjte000 instanceof RuntimeException) {
2977: {
2978: if (true)
2979: throw (RuntimeException) jjte000;
2980: }
2981: }
2982: if (jjte000 instanceof ParseException) {
2983: {
2984: if (true)
2985: throw (ParseException) jjte000;
2986: }
2987: }
2988: {
2989: if (true)
2990: throw (Error) jjte000;
2991: }
2992: } finally {
2993: if (jjtc000) {
2994: jjtree.closeNodeScope(jjtn000, true);
2995: }
2996: }
2997: }
2998:
2999: final public void ArithmeticTerm() throws ParseException {
3000: /*@bgen(jjtree) ArithmeticTerm */
3001: ASTArithmeticTerm jjtn000 = new ASTArithmeticTerm(
3002: JJTARITHMETICTERM);
3003: boolean jjtc000 = true;
3004: jjtree.openNodeScope(jjtn000);
3005: Token t;
3006: try {
3007: ArithmeticFactor();
3008: label_13: while (true) {
3009: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3010: case MULT:
3011: case DIV:
3012: ;
3013: break;
3014: default:
3015: jj_la1[75] = jj_gen;
3016: break label_13;
3017: }
3018: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3019: case MULT:
3020: t = jj_consume_token(MULT);
3021: break;
3022: case DIV:
3023: t = jj_consume_token(DIV);
3024: break;
3025: default:
3026: jj_la1[76] = jj_gen;
3027: jj_consume_token(-1);
3028: throw new ParseException();
3029: }
3030: if (t != null)
3031: jjtn000.ops.add(new Integer(t.kind));
3032: ArithmeticFactor();
3033: }
3034: } catch (Throwable jjte000) {
3035: if (jjtc000) {
3036: jjtree.clearNodeScope(jjtn000);
3037: jjtc000 = false;
3038: } else {
3039: jjtree.popNode();
3040: }
3041: if (jjte000 instanceof RuntimeException) {
3042: {
3043: if (true)
3044: throw (RuntimeException) jjte000;
3045: }
3046: }
3047: if (jjte000 instanceof ParseException) {
3048: {
3049: if (true)
3050: throw (ParseException) jjte000;
3051: }
3052: }
3053: {
3054: if (true)
3055: throw (Error) jjte000;
3056: }
3057: } finally {
3058: if (jjtc000) {
3059: jjtree.closeNodeScope(jjtn000, true);
3060: }
3061: }
3062: }
3063:
3064: final public void ArithmeticFactor() throws ParseException {
3065: /*@bgen(jjtree) ArithmeticFactor */
3066: ASTArithmeticFactor jjtn000 = new ASTArithmeticFactor(
3067: JJTARITHMETICFACTOR);
3068: boolean jjtc000 = true;
3069: jjtree.openNodeScope(jjtn000);
3070: Token t = null;
3071: try {
3072: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3073: case MINUS:
3074: case PLUS:
3075: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3076: case PLUS:
3077: t = jj_consume_token(PLUS);
3078: break;
3079: case MINUS:
3080: t = jj_consume_token(MINUS);
3081: break;
3082: default:
3083: jj_la1[77] = jj_gen;
3084: jj_consume_token(-1);
3085: throw new ParseException();
3086: }
3087: break;
3088: default:
3089: jj_la1[78] = jj_gen;
3090: ;
3091: }
3092: ArithmeticPrimary();
3093: jjtree.closeNodeScope(jjtn000, true);
3094: jjtc000 = false;
3095: jjtn000.ops.add(new Integer((t != null) ? t.kind
3096: : EJBQLConstants.PLUS));
3097: } catch (Throwable jjte000) {
3098: if (jjtc000) {
3099: jjtree.clearNodeScope(jjtn000);
3100: jjtc000 = false;
3101: } else {
3102: jjtree.popNode();
3103: }
3104: if (jjte000 instanceof RuntimeException) {
3105: {
3106: if (true)
3107: throw (RuntimeException) jjte000;
3108: }
3109: }
3110: if (jjte000 instanceof ParseException) {
3111: {
3112: if (true)
3113: throw (ParseException) jjte000;
3114: }
3115: }
3116: {
3117: if (true)
3118: throw (Error) jjte000;
3119: }
3120: } finally {
3121: if (jjtc000) {
3122: jjtree.closeNodeScope(jjtn000, true);
3123: }
3124: }
3125: }
3126:
3127: final public void ArithmeticPrimary() throws ParseException {
3128: /*@bgen(jjtree) ArithmeticPrimary */
3129: ASTArithmeticPrimary jjtn000 = new ASTArithmeticPrimary(
3130: JJTARITHMETICPRIMARY);
3131: boolean jjtc000 = true;
3132: jjtree.openNodeScope(jjtn000);
3133: try {
3134: if (jj_2_40(2147483647)) {
3135: PathExpression();
3136: } else {
3137: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3138: case INTEGER_LITERAL:
3139: case FLOATING_POINT_LITERAL:
3140: NumericLiteral();
3141: break;
3142: case LPAREN:
3143: jj_consume_token(LPAREN);
3144: SimpleArithmeticExpression();
3145: jj_consume_token(RPAREN);
3146: break;
3147: case named_parameter:
3148: case input_parameter:
3149: InputParameter();
3150: break;
3151: case ABS:
3152: case LENGTH:
3153: case LOCATE:
3154: case MOD:
3155: case SIZE:
3156: case SQRT:
3157: FunctionsReturningNumerics();
3158: break;
3159: default:
3160: jj_la1[79] = jj_gen;
3161: if (jj_2_41(2147483647)) {
3162: AggregateSelectExpression();
3163: } else {
3164: jj_consume_token(-1);
3165: throw new ParseException();
3166: }
3167: }
3168: }
3169: } catch (Throwable jjte000) {
3170: if (jjtc000) {
3171: jjtree.clearNodeScope(jjtn000);
3172: jjtc000 = false;
3173: } else {
3174: jjtree.popNode();
3175: }
3176: if (jjte000 instanceof RuntimeException) {
3177: {
3178: if (true)
3179: throw (RuntimeException) jjte000;
3180: }
3181: }
3182: if (jjte000 instanceof ParseException) {
3183: {
3184: if (true)
3185: throw (ParseException) jjte000;
3186: }
3187: }
3188: {
3189: if (true)
3190: throw (Error) jjte000;
3191: }
3192: } finally {
3193: if (jjtc000) {
3194: jjtree.closeNodeScope(jjtn000, true);
3195: }
3196: }
3197: }
3198:
3199: final public void StringExpression() throws ParseException {
3200: /*@bgen(jjtree) StringExpression */
3201: ASTStringExpression jjtn000 = new ASTStringExpression(
3202: JJTSTRINGEXPRESSION);
3203: boolean jjtc000 = true;
3204: jjtree.openNodeScope(jjtn000);
3205: try {
3206: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3207: case CONCAT:
3208: case LOWER:
3209: case SUBSTRING:
3210: case TRIM:
3211: case UPPER:
3212: case named_parameter:
3213: case string_literal:
3214: case input_parameter:
3215: case IDENTIFIER:
3216: StringPrimary();
3217: break;
3218: case LPAREN:
3219: jj_consume_token(LPAREN);
3220: SubQuery();
3221: jj_consume_token(RPAREN);
3222: break;
3223: default:
3224: jj_la1[80] = jj_gen;
3225: jj_consume_token(-1);
3226: throw new ParseException();
3227: }
3228: } catch (Throwable jjte000) {
3229: if (jjtc000) {
3230: jjtree.clearNodeScope(jjtn000);
3231: jjtc000 = false;
3232: } else {
3233: jjtree.popNode();
3234: }
3235: if (jjte000 instanceof RuntimeException) {
3236: {
3237: if (true)
3238: throw (RuntimeException) jjte000;
3239: }
3240: }
3241: if (jjte000 instanceof ParseException) {
3242: {
3243: if (true)
3244: throw (ParseException) jjte000;
3245: }
3246: }
3247: {
3248: if (true)
3249: throw (Error) jjte000;
3250: }
3251: } finally {
3252: if (jjtc000) {
3253: jjtree.closeNodeScope(jjtn000, true);
3254: }
3255: }
3256: }
3257:
3258: final public void StringPrimary() throws ParseException {
3259: /*@bgen(jjtree) StringPrimary */
3260: ASTStringPrimary jjtn000 = new ASTStringPrimary(
3261: JJTSTRINGPRIMARY);
3262: boolean jjtc000 = true;
3263: jjtree.openNodeScope(jjtn000);
3264: try {
3265: if (jj_2_42(2147483647)) {
3266: PathExpression();
3267: } else {
3268: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3269: case string_literal:
3270: StringLiteral();
3271: break;
3272: case named_parameter:
3273: case input_parameter:
3274: InputParameter();
3275: break;
3276: case CONCAT:
3277: case LOWER:
3278: case SUBSTRING:
3279: case TRIM:
3280: case UPPER:
3281: FunctionsReturningStrings();
3282: break;
3283: default:
3284: jj_la1[81] = jj_gen;
3285: jj_consume_token(-1);
3286: throw new ParseException();
3287: }
3288: }
3289: } catch (Throwable jjte000) {
3290: if (jjtc000) {
3291: jjtree.clearNodeScope(jjtn000);
3292: jjtc000 = false;
3293: } else {
3294: jjtree.popNode();
3295: }
3296: if (jjte000 instanceof RuntimeException) {
3297: {
3298: if (true)
3299: throw (RuntimeException) jjte000;
3300: }
3301: }
3302: if (jjte000 instanceof ParseException) {
3303: {
3304: if (true)
3305: throw (ParseException) jjte000;
3306: }
3307: }
3308: {
3309: if (true)
3310: throw (Error) jjte000;
3311: }
3312: } finally {
3313: if (jjtc000) {
3314: jjtree.closeNodeScope(jjtn000, true);
3315: }
3316: }
3317: }
3318:
3319: final public void DatetimeExpression() throws ParseException {
3320: /*@bgen(jjtree) DatetimeExpression */
3321: ASTDatetimeExpression jjtn000 = new ASTDatetimeExpression(
3322: JJTDATETIMEEXPRESSION);
3323: boolean jjtc000 = true;
3324: jjtree.openNodeScope(jjtn000);
3325: try {
3326: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3327: case CURRENT_DATE:
3328: case CURRENT_TIME:
3329: case CURRENT_TIMESTAMP:
3330: case named_parameter:
3331: case input_parameter:
3332: case IDENTIFIER:
3333: DatetimePrimary();
3334: break;
3335: case LPAREN:
3336: jj_consume_token(LPAREN);
3337: SubQuery();
3338: jj_consume_token(RPAREN);
3339: break;
3340: default:
3341: jj_la1[82] = jj_gen;
3342: jj_consume_token(-1);
3343: throw new ParseException();
3344: }
3345: } catch (Throwable jjte000) {
3346: if (jjtc000) {
3347: jjtree.clearNodeScope(jjtn000);
3348: jjtc000 = false;
3349: } else {
3350: jjtree.popNode();
3351: }
3352: if (jjte000 instanceof RuntimeException) {
3353: {
3354: if (true)
3355: throw (RuntimeException) jjte000;
3356: }
3357: }
3358: if (jjte000 instanceof ParseException) {
3359: {
3360: if (true)
3361: throw (ParseException) jjte000;
3362: }
3363: }
3364: {
3365: if (true)
3366: throw (Error) jjte000;
3367: }
3368: } finally {
3369: if (jjtc000) {
3370: jjtree.closeNodeScope(jjtn000, true);
3371: }
3372: }
3373: }
3374:
3375: final public void DatetimePrimary() throws ParseException {
3376: /*@bgen(jjtree) DatetimePrimary */
3377: ASTDatetimePrimary jjtn000 = new ASTDatetimePrimary(
3378: JJTDATETIMEPRIMARY);
3379: boolean jjtc000 = true;
3380: jjtree.openNodeScope(jjtn000);
3381: try {
3382: if (jj_2_43(2147483647)) {
3383: PathExpression();
3384: } else {
3385: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3386: case named_parameter:
3387: case input_parameter:
3388: InputParameter();
3389: break;
3390: case CURRENT_DATE:
3391: case CURRENT_TIME:
3392: case CURRENT_TIMESTAMP:
3393: FunctionsReturningDateTime();
3394: break;
3395: default:
3396: jj_la1[83] = jj_gen;
3397: jj_consume_token(-1);
3398: throw new ParseException();
3399: }
3400: }
3401: } catch (Throwable jjte000) {
3402: if (jjtc000) {
3403: jjtree.clearNodeScope(jjtn000);
3404: jjtc000 = false;
3405: } else {
3406: jjtree.popNode();
3407: }
3408: if (jjte000 instanceof RuntimeException) {
3409: {
3410: if (true)
3411: throw (RuntimeException) jjte000;
3412: }
3413: }
3414: if (jjte000 instanceof ParseException) {
3415: {
3416: if (true)
3417: throw (ParseException) jjte000;
3418: }
3419: }
3420: {
3421: if (true)
3422: throw (Error) jjte000;
3423: }
3424: } finally {
3425: if (jjtc000) {
3426: jjtree.closeNodeScope(jjtn000, true);
3427: }
3428: }
3429: }
3430:
3431: final public void BooleanExpression() throws ParseException {
3432: /*@bgen(jjtree) BooleanExpression */
3433: ASTBooleanExpression jjtn000 = new ASTBooleanExpression(
3434: JJTBOOLEANEXPRESSION);
3435: boolean jjtc000 = true;
3436: jjtree.openNodeScope(jjtn000);
3437: try {
3438: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3439: case named_parameter:
3440: case input_parameter:
3441: case FALSE:
3442: case TRUE:
3443: case IDENTIFIER:
3444: BooleanPrimary();
3445: break;
3446: case LPAREN:
3447: jj_consume_token(LPAREN);
3448: SubQuery();
3449: jj_consume_token(RPAREN);
3450: break;
3451: default:
3452: jj_la1[84] = jj_gen;
3453: jj_consume_token(-1);
3454: throw new ParseException();
3455: }
3456: } catch (Throwable jjte000) {
3457: if (jjtc000) {
3458: jjtree.clearNodeScope(jjtn000);
3459: jjtc000 = false;
3460: } else {
3461: jjtree.popNode();
3462: }
3463: if (jjte000 instanceof RuntimeException) {
3464: {
3465: if (true)
3466: throw (RuntimeException) jjte000;
3467: }
3468: }
3469: if (jjte000 instanceof ParseException) {
3470: {
3471: if (true)
3472: throw (ParseException) jjte000;
3473: }
3474: }
3475: {
3476: if (true)
3477: throw (Error) jjte000;
3478: }
3479: } finally {
3480: if (jjtc000) {
3481: jjtree.closeNodeScope(jjtn000, true);
3482: }
3483: }
3484: }
3485:
3486: final public void BooleanPrimary() throws ParseException {
3487: /*@bgen(jjtree) BooleanPrimary */
3488: ASTBooleanPrimary jjtn000 = new ASTBooleanPrimary(
3489: JJTBOOLEANPRIMARY);
3490: boolean jjtc000 = true;
3491: jjtree.openNodeScope(jjtn000);
3492: Token t = null;
3493: try {
3494: if (jj_2_44(2147483647)) {
3495: PathExpression();
3496: } else {
3497: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3498: case FALSE:
3499: case TRUE:
3500: BooleanLiteral();
3501: break;
3502: case named_parameter:
3503: case input_parameter:
3504: InputParameter();
3505: jjtree.closeNodeScope(jjtn000, true);
3506: jjtc000 = false;
3507: if (t != null)
3508: jjtn000.ops.add(new Integer(t.kind));
3509: break;
3510: default:
3511: jj_la1[85] = jj_gen;
3512: jj_consume_token(-1);
3513: throw new ParseException();
3514: }
3515: }
3516: } catch (Throwable jjte000) {
3517: if (jjtc000) {
3518: jjtree.clearNodeScope(jjtn000);
3519: jjtc000 = false;
3520: } else {
3521: jjtree.popNode();
3522: }
3523: if (jjte000 instanceof RuntimeException) {
3524: {
3525: if (true)
3526: throw (RuntimeException) jjte000;
3527: }
3528: }
3529: if (jjte000 instanceof ParseException) {
3530: {
3531: if (true)
3532: throw (ParseException) jjte000;
3533: }
3534: }
3535: {
3536: if (true)
3537: throw (Error) jjte000;
3538: }
3539: } finally {
3540: if (jjtc000) {
3541: jjtree.closeNodeScope(jjtn000, true);
3542: }
3543: }
3544: }
3545:
3546: final public void EntityExpression() throws ParseException {
3547: /*@bgen(jjtree) EntityExpression */
3548: ASTEntityExpression jjtn000 = new ASTEntityExpression(
3549: JJTENTITYEXPRESSION);
3550: boolean jjtc000 = true;
3551: jjtree.openNodeScope(jjtn000);
3552: try {
3553: if (jj_2_45(2147483647)) {
3554: PathExpression();
3555: } else {
3556: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3557: case IDENTIFIER:
3558: IdentificationVariable();
3559: break;
3560: case named_parameter:
3561: case input_parameter:
3562: InputParameter();
3563: break;
3564: default:
3565: jj_la1[86] = jj_gen;
3566: jj_consume_token(-1);
3567: throw new ParseException();
3568: }
3569: }
3570: } catch (Throwable jjte000) {
3571: if (jjtc000) {
3572: jjtree.clearNodeScope(jjtn000);
3573: jjtc000 = false;
3574: } else {
3575: jjtree.popNode();
3576: }
3577: if (jjte000 instanceof RuntimeException) {
3578: {
3579: if (true)
3580: throw (RuntimeException) jjte000;
3581: }
3582: }
3583: if (jjte000 instanceof ParseException) {
3584: {
3585: if (true)
3586: throw (ParseException) jjte000;
3587: }
3588: }
3589: {
3590: if (true)
3591: throw (Error) jjte000;
3592: }
3593: } finally {
3594: if (jjtc000) {
3595: jjtree.closeNodeScope(jjtn000, true);
3596: }
3597: }
3598: }
3599:
3600: final public void FunctionsReturningNumerics()
3601: throws ParseException {
3602: /*@bgen(jjtree) FunctionsReturningNumerics */
3603: ASTFunctionsReturningNumerics jjtn000 = new ASTFunctionsReturningNumerics(
3604: JJTFUNCTIONSRETURNINGNUMERICS);
3605: boolean jjtc000 = true;
3606: jjtree.openNodeScope(jjtn000);
3607: Token t;
3608: try {
3609: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3610: case LENGTH:
3611: t = jj_consume_token(LENGTH);
3612: jjtn000.ops.add(new Integer(t.kind));
3613: jj_consume_token(LPAREN);
3614: StringPrimary();
3615: jj_consume_token(RPAREN);
3616: break;
3617: case LOCATE:
3618: t = jj_consume_token(LOCATE);
3619: jjtn000.ops.add(new Integer(t.kind));
3620: jj_consume_token(LPAREN);
3621: StringPrimary();
3622: jj_consume_token(COMMA);
3623: StringPrimary();
3624: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3625: case COMMA:
3626: jj_consume_token(COMMA);
3627: jjtn000.third = true;
3628: SimpleArithmeticExpression();
3629: break;
3630: default:
3631: jj_la1[87] = jj_gen;
3632: ;
3633: }
3634: jj_consume_token(RPAREN);
3635: break;
3636: case ABS:
3637: t = jj_consume_token(ABS);
3638: jjtn000.ops.add(new Integer(t.kind));
3639: jj_consume_token(LPAREN);
3640: SimpleArithmeticExpression();
3641: jj_consume_token(RPAREN);
3642: break;
3643: case SQRT:
3644: t = jj_consume_token(SQRT);
3645: jjtn000.ops.add(new Integer(t.kind));
3646: jj_consume_token(LPAREN);
3647: SimpleArithmeticExpression();
3648: jj_consume_token(RPAREN);
3649: break;
3650: case MOD:
3651: t = jj_consume_token(MOD);
3652: jjtn000.ops.add(new Integer(t.kind));
3653: jj_consume_token(LPAREN);
3654: SimpleArithmeticExpression();
3655: jj_consume_token(COMMA);
3656: SimpleArithmeticExpression();
3657: jj_consume_token(RPAREN);
3658: break;
3659: case SIZE:
3660: t = jj_consume_token(SIZE);
3661: jjtn000.ops.add(new Integer(t.kind));
3662: jj_consume_token(LPAREN);
3663: PathExpression();
3664: jj_consume_token(RPAREN);
3665: break;
3666: default:
3667: jj_la1[88] = jj_gen;
3668: jj_consume_token(-1);
3669: throw new ParseException();
3670: }
3671: } catch (Throwable jjte000) {
3672: if (jjtc000) {
3673: jjtree.clearNodeScope(jjtn000);
3674: jjtc000 = false;
3675: } else {
3676: jjtree.popNode();
3677: }
3678: if (jjte000 instanceof RuntimeException) {
3679: {
3680: if (true)
3681: throw (RuntimeException) jjte000;
3682: }
3683: }
3684: if (jjte000 instanceof ParseException) {
3685: {
3686: if (true)
3687: throw (ParseException) jjte000;
3688: }
3689: }
3690: {
3691: if (true)
3692: throw (Error) jjte000;
3693: }
3694: } finally {
3695: if (jjtc000) {
3696: jjtree.closeNodeScope(jjtn000, true);
3697: }
3698: }
3699: }
3700:
3701: final public void FunctionsReturningDateTime()
3702: throws ParseException {
3703: /*@bgen(jjtree) FunctionsReturningDateTime */
3704: ASTFunctionsReturningDateTime jjtn000 = new ASTFunctionsReturningDateTime(
3705: JJTFUNCTIONSRETURNINGDATETIME);
3706: boolean jjtc000 = true;
3707: jjtree.openNodeScope(jjtn000);
3708: try {
3709: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3710: case CURRENT_DATE:
3711: jj_consume_token(CURRENT_DATE);
3712: break;
3713: case CURRENT_TIME:
3714: jj_consume_token(CURRENT_TIME);
3715: break;
3716: case CURRENT_TIMESTAMP:
3717: jj_consume_token(CURRENT_TIMESTAMP);
3718: break;
3719: default:
3720: jj_la1[89] = jj_gen;
3721: jj_consume_token(-1);
3722: throw new ParseException();
3723: }
3724: } finally {
3725: if (jjtc000) {
3726: jjtree.closeNodeScope(jjtn000, true);
3727: }
3728: }
3729: }
3730:
3731: final public void FunctionsReturningStrings() throws ParseException {
3732: /*@bgen(jjtree) FunctionsReturningStrings */
3733: ASTFunctionsReturningStrings jjtn000 = new ASTFunctionsReturningStrings(
3734: JJTFUNCTIONSRETURNINGSTRINGS);
3735: boolean jjtc000 = true;
3736: jjtree.openNodeScope(jjtn000);
3737: Token t;
3738: try {
3739: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3740: case CONCAT:
3741: t = jj_consume_token(CONCAT);
3742: jjtn000.ops.add(new Integer(t.kind));
3743: jj_consume_token(LPAREN);
3744: StringPrimary();
3745: jj_consume_token(COMMA);
3746: StringPrimary();
3747: jj_consume_token(RPAREN);
3748: break;
3749: case SUBSTRING:
3750: t = jj_consume_token(SUBSTRING);
3751: jjtn000.ops.add(new Integer(t.kind));
3752: jj_consume_token(LPAREN);
3753: StringPrimary();
3754: jj_consume_token(COMMA);
3755: SimpleArithmeticExpression();
3756: jj_consume_token(COMMA);
3757: SimpleArithmeticExpression();
3758: jj_consume_token(RPAREN);
3759: break;
3760: case TRIM:
3761: t = jj_consume_token(TRIM);
3762: jjtn000.ops.add(new Integer(t.kind));
3763: jj_consume_token(LPAREN);
3764: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3765: case BOTH:
3766: case FROM:
3767: case LEADING:
3768: case TRAILING:
3769: case string_literal:
3770: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3771: case BOTH:
3772: case LEADING:
3773: case TRAILING:
3774: TrimSpecification();
3775: break;
3776: default:
3777: jj_la1[90] = jj_gen;
3778: ;
3779: }
3780: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3781: case string_literal:
3782: TrimCharacter();
3783: break;
3784: default:
3785: jj_la1[91] = jj_gen;
3786: ;
3787: }
3788: jj_consume_token(FROM);
3789: break;
3790: default:
3791: jj_la1[92] = jj_gen;
3792: ;
3793: }
3794: StringPrimary();
3795: jj_consume_token(RPAREN);
3796: break;
3797: case LOWER:
3798: t = jj_consume_token(LOWER);
3799: jjtn000.ops.add(new Integer(t.kind));
3800: jj_consume_token(LPAREN);
3801: StringPrimary();
3802: jj_consume_token(RPAREN);
3803: break;
3804: case UPPER:
3805: t = jj_consume_token(UPPER);
3806: jjtn000.ops.add(new Integer(t.kind));
3807: jj_consume_token(LPAREN);
3808: StringPrimary();
3809: jj_consume_token(RPAREN);
3810: break;
3811: default:
3812: jj_la1[93] = jj_gen;
3813: jj_consume_token(-1);
3814: throw new ParseException();
3815: }
3816: } catch (Throwable jjte000) {
3817: if (jjtc000) {
3818: jjtree.clearNodeScope(jjtn000);
3819: jjtc000 = false;
3820: } else {
3821: jjtree.popNode();
3822: }
3823: if (jjte000 instanceof RuntimeException) {
3824: {
3825: if (true)
3826: throw (RuntimeException) jjte000;
3827: }
3828: }
3829: if (jjte000 instanceof ParseException) {
3830: {
3831: if (true)
3832: throw (ParseException) jjte000;
3833: }
3834: }
3835: {
3836: if (true)
3837: throw (Error) jjte000;
3838: }
3839: } finally {
3840: if (jjtc000) {
3841: jjtree.closeNodeScope(jjtn000, true);
3842: }
3843: }
3844: }
3845:
3846: final public void TrimSpecification() throws ParseException {
3847: /*@bgen(jjtree) TrimSpecification */
3848: ASTTrimSpecification jjtn000 = new ASTTrimSpecification(
3849: JJTTRIMSPECIFICATION);
3850: boolean jjtc000 = true;
3851: jjtree.openNodeScope(jjtn000);
3852: try {
3853: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3854: case LEADING:
3855: jj_consume_token(LEADING);
3856: break;
3857: case TRAILING:
3858: jj_consume_token(TRAILING);
3859: break;
3860: case BOTH:
3861: jj_consume_token(BOTH);
3862: break;
3863: default:
3864: jj_la1[94] = jj_gen;
3865: jj_consume_token(-1);
3866: throw new ParseException();
3867: }
3868: } finally {
3869: if (jjtc000) {
3870: jjtree.closeNodeScope(jjtn000, true);
3871: }
3872: }
3873: }
3874:
3875: //TODO check with final spec. Best guess.
3876: final public void TrimCharacter() throws ParseException {
3877: /*@bgen(jjtree) TrimCharacter */
3878: ASTTrimCharacter jjtn000 = new ASTTrimCharacter(
3879: JJTTRIMCHARACTER);
3880: boolean jjtc000 = true;
3881: jjtree.openNodeScope(jjtn000);
3882: try {
3883: StringLiteral();
3884: } catch (Throwable jjte000) {
3885: if (jjtc000) {
3886: jjtree.clearNodeScope(jjtn000);
3887: jjtc000 = false;
3888: } else {
3889: jjtree.popNode();
3890: }
3891: if (jjte000 instanceof RuntimeException) {
3892: {
3893: if (true)
3894: throw (RuntimeException) jjte000;
3895: }
3896: }
3897: if (jjte000 instanceof ParseException) {
3898: {
3899: if (true)
3900: throw (ParseException) jjte000;
3901: }
3902: }
3903: {
3904: if (true)
3905: throw (Error) jjte000;
3906: }
3907: } finally {
3908: if (jjtc000) {
3909: jjtree.closeNodeScope(jjtn000, true);
3910: }
3911: }
3912: }
3913:
3914: final public void PatternValue() throws ParseException {
3915: /*@bgen(jjtree) PatternValue */
3916: ASTPatternValue jjtn000 = new ASTPatternValue(JJTPATTERNVALUE);
3917: boolean jjtc000 = true;
3918: jjtree.openNodeScope(jjtn000);
3919: try {
3920: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3921: case string_literal:
3922: StringLiteral();
3923: break;
3924: case named_parameter:
3925: case input_parameter:
3926: InputParameter();
3927: break;
3928: default:
3929: jj_la1[95] = jj_gen;
3930: jj_consume_token(-1);
3931: throw new ParseException();
3932: }
3933: } catch (Throwable jjte000) {
3934: if (jjtc000) {
3935: jjtree.clearNodeScope(jjtn000);
3936: jjtc000 = false;
3937: } else {
3938: jjtree.popNode();
3939: }
3940: if (jjte000 instanceof RuntimeException) {
3941: {
3942: if (true)
3943: throw (RuntimeException) jjte000;
3944: }
3945: }
3946: if (jjte000 instanceof ParseException) {
3947: {
3948: if (true)
3949: throw (ParseException) jjte000;
3950: }
3951: }
3952: {
3953: if (true)
3954: throw (Error) jjte000;
3955: }
3956: } finally {
3957: if (jjtc000) {
3958: jjtree.closeNodeScope(jjtn000, true);
3959: }
3960: }
3961: }
3962:
3963: final public void EscapeCharacter() throws ParseException {
3964: /*@bgen(jjtree) EscapeCharacter */
3965: ASTEscapeCharacter jjtn000 = new ASTEscapeCharacter(
3966: JJTESCAPECHARACTER);
3967: boolean jjtc000 = true;
3968: jjtree.openNodeScope(jjtn000);
3969: try {
3970: StringLiteral();
3971: } catch (Throwable jjte000) {
3972: if (jjtc000) {
3973: jjtree.clearNodeScope(jjtn000);
3974: jjtc000 = false;
3975: } else {
3976: jjtree.popNode();
3977: }
3978: if (jjte000 instanceof RuntimeException) {
3979: {
3980: if (true)
3981: throw (RuntimeException) jjte000;
3982: }
3983: }
3984: if (jjte000 instanceof ParseException) {
3985: {
3986: if (true)
3987: throw (ParseException) jjte000;
3988: }
3989: }
3990: {
3991: if (true)
3992: throw (Error) jjte000;
3993: }
3994: } finally {
3995: if (jjtc000) {
3996: jjtree.closeNodeScope(jjtn000, true);
3997: }
3998: }
3999: }
4000:
4001: final public void AbstractSchemaName() throws ParseException {
4002: /*@bgen(jjtree) AbstractSchemaName */
4003: ASTAbstractSchemaName jjtn000 = new ASTAbstractSchemaName(
4004: JJTABSTRACTSCHEMANAME);
4005: boolean jjtc000 = true;
4006: jjtree.openNodeScope(jjtn000);
4007: Token t;
4008: try {
4009: t = jj_consume_token(IDENTIFIER);
4010: jjtree.closeNodeScope(jjtn000, true);
4011: jjtc000 = false;
4012: jjtn000.value = t.image;
4013: } finally {
4014: if (jjtc000) {
4015: jjtree.closeNodeScope(jjtn000, true);
4016: }
4017: }
4018: }
4019:
4020: final public void IdentificationVariable() throws ParseException {
4021: /*@bgen(jjtree) IdentificationVariable */
4022: ASTIdentificationVariable jjtn000 = new ASTIdentificationVariable(
4023: JJTIDENTIFICATIONVARIABLE);
4024: boolean jjtc000 = true;
4025: jjtree.openNodeScope(jjtn000);
4026: Token t;
4027: try {
4028: t = jj_consume_token(IDENTIFIER);
4029: jjtree.closeNodeScope(jjtn000, true);
4030: jjtc000 = false;
4031: jjtn000.value = t.image;
4032: } finally {
4033: if (jjtc000) {
4034: jjtree.closeNodeScope(jjtn000, true);
4035: }
4036: }
4037: }
4038:
4039: final public void Literal() throws ParseException {
4040: /*@bgen(jjtree) Literal */
4041: ASTLiteral jjtn000 = new ASTLiteral(JJTLITERAL);
4042: boolean jjtc000 = true;
4043: jjtree.openNodeScope(jjtn000);
4044: try {
4045: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4046: case string_literal:
4047: StringLiteral();
4048: break;
4049: case INTEGER_LITERAL:
4050: case FLOATING_POINT_LITERAL:
4051: NumericLiteral();
4052: break;
4053: case FALSE:
4054: case TRUE:
4055: BooleanLiteral();
4056: break;
4057: default:
4058: jj_la1[96] = jj_gen;
4059: jj_consume_token(-1);
4060: throw new ParseException();
4061: }
4062: } catch (Throwable jjte000) {
4063: if (jjtc000) {
4064: jjtree.clearNodeScope(jjtn000);
4065: jjtc000 = false;
4066: } else {
4067: jjtree.popNode();
4068: }
4069: if (jjte000 instanceof RuntimeException) {
4070: {
4071: if (true)
4072: throw (RuntimeException) jjte000;
4073: }
4074: }
4075: if (jjte000 instanceof ParseException) {
4076: {
4077: if (true)
4078: throw (ParseException) jjte000;
4079: }
4080: }
4081: {
4082: if (true)
4083: throw (Error) jjte000;
4084: }
4085: } finally {
4086: if (jjtc000) {
4087: jjtree.closeNodeScope(jjtn000, true);
4088: }
4089: }
4090: }
4091:
4092: final public void StringLiteral() throws ParseException {
4093: /*@bgen(jjtree) StringLiteral */
4094: ASTStringLiteral jjtn000 = new ASTStringLiteral(
4095: JJTSTRINGLITERAL);
4096: boolean jjtc000 = true;
4097: jjtree.openNodeScope(jjtn000);
4098: Token t;
4099: try {
4100: t = jj_consume_token(string_literal);
4101: jjtree.closeNodeScope(jjtn000, true);
4102: jjtc000 = false;
4103: jjtn000.value = t.image.substring(1, t.image.length() - 1);
4104: } finally {
4105: if (jjtc000) {
4106: jjtree.closeNodeScope(jjtn000, true);
4107: }
4108: }
4109: }
4110:
4111: final public void NumericLiteral() throws ParseException {
4112: /*@bgen(jjtree) NumericLiteral */
4113: ASTNumericLiteral jjtn000 = new ASTNumericLiteral(
4114: JJTNUMERICLITERAL);
4115: boolean jjtc000 = true;
4116: jjtree.openNodeScope(jjtn000);
4117: try {
4118: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4119: case INTEGER_LITERAL:
4120: IntegerLiteral();
4121: break;
4122: case FLOATING_POINT_LITERAL:
4123: FloatingPointLiteral();
4124: break;
4125: default:
4126: jj_la1[97] = jj_gen;
4127: jj_consume_token(-1);
4128: throw new ParseException();
4129: }
4130: } catch (Throwable jjte000) {
4131: if (jjtc000) {
4132: jjtree.clearNodeScope(jjtn000);
4133: jjtc000 = false;
4134: } else {
4135: jjtree.popNode();
4136: }
4137: if (jjte000 instanceof RuntimeException) {
4138: {
4139: if (true)
4140: throw (RuntimeException) jjte000;
4141: }
4142: }
4143: if (jjte000 instanceof ParseException) {
4144: {
4145: if (true)
4146: throw (ParseException) jjte000;
4147: }
4148: }
4149: {
4150: if (true)
4151: throw (Error) jjte000;
4152: }
4153: } finally {
4154: if (jjtc000) {
4155: jjtree.closeNodeScope(jjtn000, true);
4156: }
4157: }
4158: }
4159:
4160: final public void IntegerLiteral() throws ParseException {
4161: /*@bgen(jjtree) IntegerLiteral */
4162: ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(
4163: JJTINTEGERLITERAL);
4164: boolean jjtc000 = true;
4165: jjtree.openNodeScope(jjtn000);
4166: Token t;
4167: try {
4168: t = jj_consume_token(INTEGER_LITERAL);
4169: jjtree.closeNodeScope(jjtn000, true);
4170: jjtc000 = false;
4171: jjtn000.value = new Long(t.image);
4172: } finally {
4173: if (jjtc000) {
4174: jjtree.closeNodeScope(jjtn000, true);
4175: }
4176: }
4177: }
4178:
4179: final public void FloatingPointLiteral() throws ParseException {
4180: /*@bgen(jjtree) FloatingPointLiteral */
4181: ASTFloatingPointLiteral jjtn000 = new ASTFloatingPointLiteral(
4182: JJTFLOATINGPOINTLITERAL);
4183: boolean jjtc000 = true;
4184: jjtree.openNodeScope(jjtn000);
4185: Token t;
4186: try {
4187: t = jj_consume_token(FLOATING_POINT_LITERAL);
4188: jjtree.closeNodeScope(jjtn000, true);
4189: jjtc000 = false;
4190: jjtn000.value = new Double(t.image);
4191: } finally {
4192: if (jjtc000) {
4193: jjtree.closeNodeScope(jjtn000, true);
4194: }
4195: }
4196: }
4197:
4198: final public void BooleanLiteral() throws ParseException {
4199: /*@bgen(jjtree) BooleanLiteral */
4200: ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(
4201: JJTBOOLEANLITERAL);
4202: boolean jjtc000 = true;
4203: jjtree.openNodeScope(jjtn000);
4204: Token t;
4205: try {
4206: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4207: case TRUE:
4208: t = jj_consume_token(TRUE);
4209: jjtree.closeNodeScope(jjtn000, true);
4210: jjtc000 = false;
4211: jjtn000.value = Boolean.TRUE;
4212: break;
4213: case FALSE:
4214: t = jj_consume_token(FALSE);
4215: jjtree.closeNodeScope(jjtn000, true);
4216: jjtc000 = false;
4217: jjtn000.value = Boolean.FALSE;
4218: break;
4219: default:
4220: jj_la1[98] = jj_gen;
4221: jj_consume_token(-1);
4222: throw new ParseException();
4223: }
4224: } finally {
4225: if (jjtc000) {
4226: jjtree.closeNodeScope(jjtn000, true);
4227: }
4228: }
4229: }
4230:
4231: final public void InputParameter() throws ParseException {
4232: /*@bgen(jjtree) InputParameter */
4233: ASTInputParameter jjtn000 = new ASTInputParameter(
4234: JJTINPUTPARAMETER);
4235: boolean jjtc000 = true;
4236: jjtree.openNodeScope(jjtn000);
4237: try {
4238: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4239: case input_parameter:
4240: PositionalParameter();
4241: break;
4242: case named_parameter:
4243: NamedParameter();
4244: break;
4245: default:
4246: jj_la1[99] = jj_gen;
4247: jj_consume_token(-1);
4248: throw new ParseException();
4249: }
4250: } catch (Throwable jjte000) {
4251: if (jjtc000) {
4252: jjtree.clearNodeScope(jjtn000);
4253: jjtc000 = false;
4254: } else {
4255: jjtree.popNode();
4256: }
4257: if (jjte000 instanceof RuntimeException) {
4258: {
4259: if (true)
4260: throw (RuntimeException) jjte000;
4261: }
4262: }
4263: if (jjte000 instanceof ParseException) {
4264: {
4265: if (true)
4266: throw (ParseException) jjte000;
4267: }
4268: }
4269: {
4270: if (true)
4271: throw (Error) jjte000;
4272: }
4273: } finally {
4274: if (jjtc000) {
4275: jjtree.closeNodeScope(jjtn000, true);
4276: }
4277: }
4278: }
4279:
4280: final public void PositionalParameter() throws ParseException {
4281: /*@bgen(jjtree) PositionalParameter */
4282: ASTPositionalParameter jjtn000 = new ASTPositionalParameter(
4283: JJTPOSITIONALPARAMETER);
4284: boolean jjtc000 = true;
4285: jjtree.openNodeScope(jjtn000);
4286: Token t;
4287: try {
4288: t = jj_consume_token(input_parameter);
4289: jjtree.closeNodeScope(jjtn000, true);
4290: jjtc000 = false;
4291: jjtn000.value = new Integer(t.image.substring(1));
4292: } finally {
4293: if (jjtc000) {
4294: jjtree.closeNodeScope(jjtn000, true);
4295: }
4296: }
4297: }
4298:
4299: final public void NamedParameter() throws ParseException {
4300: /*@bgen(jjtree) NamedParameter */
4301: ASTNamedParameter jjtn000 = new ASTNamedParameter(
4302: JJTNAMEDPARAMETER);
4303: boolean jjtc000 = true;
4304: jjtree.openNodeScope(jjtn000);
4305: Token t;
4306: try {
4307: t = jj_consume_token(named_parameter);
4308: jjtree.closeNodeScope(jjtn000, true);
4309: jjtc000 = false;
4310: jjtn000.value = new String(t.image.substring(1));
4311: } finally {
4312: if (jjtc000) {
4313: jjtree.closeNodeScope(jjtn000, true);
4314: }
4315: }
4316: }
4317:
4318: final private boolean jj_2_1(int xla) {
4319: jj_la = xla;
4320: jj_lastpos = jj_scanpos = token;
4321: try {
4322: return !jj_3_1();
4323: } catch (LookaheadSuccess ls) {
4324: return true;
4325: } finally {
4326: jj_save(0, xla);
4327: }
4328: }
4329:
4330: final private boolean jj_2_2(int xla) {
4331: jj_la = xla;
4332: jj_lastpos = jj_scanpos = token;
4333: try {
4334: return !jj_3_2();
4335: } catch (LookaheadSuccess ls) {
4336: return true;
4337: } finally {
4338: jj_save(1, xla);
4339: }
4340: }
4341:
4342: final private boolean jj_2_3(int xla) {
4343: jj_la = xla;
4344: jj_lastpos = jj_scanpos = token;
4345: try {
4346: return !jj_3_3();
4347: } catch (LookaheadSuccess ls) {
4348: return true;
4349: } finally {
4350: jj_save(2, xla);
4351: }
4352: }
4353:
4354: final private boolean jj_2_4(int xla) {
4355: jj_la = xla;
4356: jj_lastpos = jj_scanpos = token;
4357: try {
4358: return !jj_3_4();
4359: } catch (LookaheadSuccess ls) {
4360: return true;
4361: } finally {
4362: jj_save(3, xla);
4363: }
4364: }
4365:
4366: final private boolean jj_2_5(int xla) {
4367: jj_la = xla;
4368: jj_lastpos = jj_scanpos = token;
4369: try {
4370: return !jj_3_5();
4371: } catch (LookaheadSuccess ls) {
4372: return true;
4373: } finally {
4374: jj_save(4, xla);
4375: }
4376: }
4377:
4378: final private boolean jj_2_6(int xla) {
4379: jj_la = xla;
4380: jj_lastpos = jj_scanpos = token;
4381: try {
4382: return !jj_3_6();
4383: } catch (LookaheadSuccess ls) {
4384: return true;
4385: } finally {
4386: jj_save(5, xla);
4387: }
4388: }
4389:
4390: final private boolean jj_2_7(int xla) {
4391: jj_la = xla;
4392: jj_lastpos = jj_scanpos = token;
4393: try {
4394: return !jj_3_7();
4395: } catch (LookaheadSuccess ls) {
4396: return true;
4397: } finally {
4398: jj_save(6, xla);
4399: }
4400: }
4401:
4402: final private boolean jj_2_8(int xla) {
4403: jj_la = xla;
4404: jj_lastpos = jj_scanpos = token;
4405: try {
4406: return !jj_3_8();
4407: } catch (LookaheadSuccess ls) {
4408: return true;
4409: } finally {
4410: jj_save(7, xla);
4411: }
4412: }
4413:
4414: final private boolean jj_2_9(int xla) {
4415: jj_la = xla;
4416: jj_lastpos = jj_scanpos = token;
4417: try {
4418: return !jj_3_9();
4419: } catch (LookaheadSuccess ls) {
4420: return true;
4421: } finally {
4422: jj_save(8, xla);
4423: }
4424: }
4425:
4426: final private boolean jj_2_10(int xla) {
4427: jj_la = xla;
4428: jj_lastpos = jj_scanpos = token;
4429: try {
4430: return !jj_3_10();
4431: } catch (LookaheadSuccess ls) {
4432: return true;
4433: } finally {
4434: jj_save(9, xla);
4435: }
4436: }
4437:
4438: final private boolean jj_2_11(int xla) {
4439: jj_la = xla;
4440: jj_lastpos = jj_scanpos = token;
4441: try {
4442: return !jj_3_11();
4443: } catch (LookaheadSuccess ls) {
4444: return true;
4445: } finally {
4446: jj_save(10, xla);
4447: }
4448: }
4449:
4450: final private boolean jj_2_12(int xla) {
4451: jj_la = xla;
4452: jj_lastpos = jj_scanpos = token;
4453: try {
4454: return !jj_3_12();
4455: } catch (LookaheadSuccess ls) {
4456: return true;
4457: } finally {
4458: jj_save(11, xla);
4459: }
4460: }
4461:
4462: final private boolean jj_2_13(int xla) {
4463: jj_la = xla;
4464: jj_lastpos = jj_scanpos = token;
4465: try {
4466: return !jj_3_13();
4467: } catch (LookaheadSuccess ls) {
4468: return true;
4469: } finally {
4470: jj_save(12, xla);
4471: }
4472: }
4473:
4474: final private boolean jj_2_14(int xla) {
4475: jj_la = xla;
4476: jj_lastpos = jj_scanpos = token;
4477: try {
4478: return !jj_3_14();
4479: } catch (LookaheadSuccess ls) {
4480: return true;
4481: } finally {
4482: jj_save(13, xla);
4483: }
4484: }
4485:
4486: final private boolean jj_2_15(int xla) {
4487: jj_la = xla;
4488: jj_lastpos = jj_scanpos = token;
4489: try {
4490: return !jj_3_15();
4491: } catch (LookaheadSuccess ls) {
4492: return true;
4493: } finally {
4494: jj_save(14, xla);
4495: }
4496: }
4497:
4498: final private boolean jj_2_16(int xla) {
4499: jj_la = xla;
4500: jj_lastpos = jj_scanpos = token;
4501: try {
4502: return !jj_3_16();
4503: } catch (LookaheadSuccess ls) {
4504: return true;
4505: } finally {
4506: jj_save(15, xla);
4507: }
4508: }
4509:
4510: final private boolean jj_2_17(int xla) {
4511: jj_la = xla;
4512: jj_lastpos = jj_scanpos = token;
4513: try {
4514: return !jj_3_17();
4515: } catch (LookaheadSuccess ls) {
4516: return true;
4517: } finally {
4518: jj_save(16, xla);
4519: }
4520: }
4521:
4522: final private boolean jj_2_18(int xla) {
4523: jj_la = xla;
4524: jj_lastpos = jj_scanpos = token;
4525: try {
4526: return !jj_3_18();
4527: } catch (LookaheadSuccess ls) {
4528: return true;
4529: } finally {
4530: jj_save(17, xla);
4531: }
4532: }
4533:
4534: final private boolean jj_2_19(int xla) {
4535: jj_la = xla;
4536: jj_lastpos = jj_scanpos = token;
4537: try {
4538: return !jj_3_19();
4539: } catch (LookaheadSuccess ls) {
4540: return true;
4541: } finally {
4542: jj_save(18, xla);
4543: }
4544: }
4545:
4546: final private boolean jj_2_20(int xla) {
4547: jj_la = xla;
4548: jj_lastpos = jj_scanpos = token;
4549: try {
4550: return !jj_3_20();
4551: } catch (LookaheadSuccess ls) {
4552: return true;
4553: } finally {
4554: jj_save(19, xla);
4555: }
4556: }
4557:
4558: final private boolean jj_2_21(int xla) {
4559: jj_la = xla;
4560: jj_lastpos = jj_scanpos = token;
4561: try {
4562: return !jj_3_21();
4563: } catch (LookaheadSuccess ls) {
4564: return true;
4565: } finally {
4566: jj_save(20, xla);
4567: }
4568: }
4569:
4570: final private boolean jj_2_22(int xla) {
4571: jj_la = xla;
4572: jj_lastpos = jj_scanpos = token;
4573: try {
4574: return !jj_3_22();
4575: } catch (LookaheadSuccess ls) {
4576: return true;
4577: } finally {
4578: jj_save(21, xla);
4579: }
4580: }
4581:
4582: final private boolean jj_2_23(int xla) {
4583: jj_la = xla;
4584: jj_lastpos = jj_scanpos = token;
4585: try {
4586: return !jj_3_23();
4587: } catch (LookaheadSuccess ls) {
4588: return true;
4589: } finally {
4590: jj_save(22, xla);
4591: }
4592: }
4593:
4594: final private boolean jj_2_24(int xla) {
4595: jj_la = xla;
4596: jj_lastpos = jj_scanpos = token;
4597: try {
4598: return !jj_3_24();
4599: } catch (LookaheadSuccess ls) {
4600: return true;
4601: } finally {
4602: jj_save(23, xla);
4603: }
4604: }
4605:
4606: final private boolean jj_2_25(int xla) {
4607: jj_la = xla;
4608: jj_lastpos = jj_scanpos = token;
4609: try {
4610: return !jj_3_25();
4611: } catch (LookaheadSuccess ls) {
4612: return true;
4613: } finally {
4614: jj_save(24, xla);
4615: }
4616: }
4617:
4618: final private boolean jj_2_26(int xla) {
4619: jj_la = xla;
4620: jj_lastpos = jj_scanpos = token;
4621: try {
4622: return !jj_3_26();
4623: } catch (LookaheadSuccess ls) {
4624: return true;
4625: } finally {
4626: jj_save(25, xla);
4627: }
4628: }
4629:
4630: final private boolean jj_2_27(int xla) {
4631: jj_la = xla;
4632: jj_lastpos = jj_scanpos = token;
4633: try {
4634: return !jj_3_27();
4635: } catch (LookaheadSuccess ls) {
4636: return true;
4637: } finally {
4638: jj_save(26, xla);
4639: }
4640: }
4641:
4642: final private boolean jj_2_28(int xla) {
4643: jj_la = xla;
4644: jj_lastpos = jj_scanpos = token;
4645: try {
4646: return !jj_3_28();
4647: } catch (LookaheadSuccess ls) {
4648: return true;
4649: } finally {
4650: jj_save(27, xla);
4651: }
4652: }
4653:
4654: final private boolean jj_2_29(int xla) {
4655: jj_la = xla;
4656: jj_lastpos = jj_scanpos = token;
4657: try {
4658: return !jj_3_29();
4659: } catch (LookaheadSuccess ls) {
4660: return true;
4661: } finally {
4662: jj_save(28, xla);
4663: }
4664: }
4665:
4666: final private boolean jj_2_30(int xla) {
4667: jj_la = xla;
4668: jj_lastpos = jj_scanpos = token;
4669: try {
4670: return !jj_3_30();
4671: } catch (LookaheadSuccess ls) {
4672: return true;
4673: } finally {
4674: jj_save(29, xla);
4675: }
4676: }
4677:
4678: final private boolean jj_2_31(int xla) {
4679: jj_la = xla;
4680: jj_lastpos = jj_scanpos = token;
4681: try {
4682: return !jj_3_31();
4683: } catch (LookaheadSuccess ls) {
4684: return true;
4685: } finally {
4686: jj_save(30, xla);
4687: }
4688: }
4689:
4690: final private boolean jj_2_32(int xla) {
4691: jj_la = xla;
4692: jj_lastpos = jj_scanpos = token;
4693: try {
4694: return !jj_3_32();
4695: } catch (LookaheadSuccess ls) {
4696: return true;
4697: } finally {
4698: jj_save(31, xla);
4699: }
4700: }
4701:
4702: final private boolean jj_2_33(int xla) {
4703: jj_la = xla;
4704: jj_lastpos = jj_scanpos = token;
4705: try {
4706: return !jj_3_33();
4707: } catch (LookaheadSuccess ls) {
4708: return true;
4709: } finally {
4710: jj_save(32, xla);
4711: }
4712: }
4713:
4714: final private boolean jj_2_34(int xla) {
4715: jj_la = xla;
4716: jj_lastpos = jj_scanpos = token;
4717: try {
4718: return !jj_3_34();
4719: } catch (LookaheadSuccess ls) {
4720: return true;
4721: } finally {
4722: jj_save(33, xla);
4723: }
4724: }
4725:
4726: final private boolean jj_2_35(int xla) {
4727: jj_la = xla;
4728: jj_lastpos = jj_scanpos = token;
4729: try {
4730: return !jj_3_35();
4731: } catch (LookaheadSuccess ls) {
4732: return true;
4733: } finally {
4734: jj_save(34, xla);
4735: }
4736: }
4737:
4738: final private boolean jj_2_36(int xla) {
4739: jj_la = xla;
4740: jj_lastpos = jj_scanpos = token;
4741: try {
4742: return !jj_3_36();
4743: } catch (LookaheadSuccess ls) {
4744: return true;
4745: } finally {
4746: jj_save(35, xla);
4747: }
4748: }
4749:
4750: final private boolean jj_2_37(int xla) {
4751: jj_la = xla;
4752: jj_lastpos = jj_scanpos = token;
4753: try {
4754: return !jj_3_37();
4755: } catch (LookaheadSuccess ls) {
4756: return true;
4757: } finally {
4758: jj_save(36, xla);
4759: }
4760: }
4761:
4762: final private boolean jj_2_38(int xla) {
4763: jj_la = xla;
4764: jj_lastpos = jj_scanpos = token;
4765: try {
4766: return !jj_3_38();
4767: } catch (LookaheadSuccess ls) {
4768: return true;
4769: } finally {
4770: jj_save(37, xla);
4771: }
4772: }
4773:
4774: final private boolean jj_2_39(int xla) {
4775: jj_la = xla;
4776: jj_lastpos = jj_scanpos = token;
4777: try {
4778: return !jj_3_39();
4779: } catch (LookaheadSuccess ls) {
4780: return true;
4781: } finally {
4782: jj_save(38, xla);
4783: }
4784: }
4785:
4786: final private boolean jj_2_40(int xla) {
4787: jj_la = xla;
4788: jj_lastpos = jj_scanpos = token;
4789: try {
4790: return !jj_3_40();
4791: } catch (LookaheadSuccess ls) {
4792: return true;
4793: } finally {
4794: jj_save(39, xla);
4795: }
4796: }
4797:
4798: final private boolean jj_2_41(int xla) {
4799: jj_la = xla;
4800: jj_lastpos = jj_scanpos = token;
4801: try {
4802: return !jj_3_41();
4803: } catch (LookaheadSuccess ls) {
4804: return true;
4805: } finally {
4806: jj_save(40, xla);
4807: }
4808: }
4809:
4810: final private boolean jj_2_42(int xla) {
4811: jj_la = xla;
4812: jj_lastpos = jj_scanpos = token;
4813: try {
4814: return !jj_3_42();
4815: } catch (LookaheadSuccess ls) {
4816: return true;
4817: } finally {
4818: jj_save(41, xla);
4819: }
4820: }
4821:
4822: final private boolean jj_2_43(int xla) {
4823: jj_la = xla;
4824: jj_lastpos = jj_scanpos = token;
4825: try {
4826: return !jj_3_43();
4827: } catch (LookaheadSuccess ls) {
4828: return true;
4829: } finally {
4830: jj_save(42, xla);
4831: }
4832: }
4833:
4834: final private boolean jj_2_44(int xla) {
4835: jj_la = xla;
4836: jj_lastpos = jj_scanpos = token;
4837: try {
4838: return !jj_3_44();
4839: } catch (LookaheadSuccess ls) {
4840: return true;
4841: } finally {
4842: jj_save(43, xla);
4843: }
4844: }
4845:
4846: final private boolean jj_2_45(int xla) {
4847: jj_la = xla;
4848: jj_lastpos = jj_scanpos = token;
4849: try {
4850: return !jj_3_45();
4851: } catch (LookaheadSuccess ls) {
4852: return true;
4853: } finally {
4854: jj_save(44, xla);
4855: }
4856: }
4857:
4858: final private boolean jj_3R_77() {
4859: if (jj_scan_token(NOT))
4860: return true;
4861: return false;
4862: }
4863:
4864: final private boolean jj_3R_25() {
4865: if (jj_3R_33())
4866: return true;
4867: Token xsp;
4868: xsp = jj_scanpos;
4869: if (jj_3R_74())
4870: jj_scanpos = xsp;
4871: if (jj_scan_token(LIKE))
4872: return true;
4873: if (jj_3R_75())
4874: return true;
4875: xsp = jj_scanpos;
4876: if (jj_3R_76())
4877: jj_scanpos = xsp;
4878: return false;
4879: }
4880:
4881: final private boolean jj_3R_133() {
4882: if (jj_scan_token(COMMA))
4883: return true;
4884: if (jj_3R_132())
4885: return true;
4886: return false;
4887: }
4888:
4889: final private boolean jj_3R_79() {
4890: if (jj_3R_86())
4891: return true;
4892: return false;
4893: }
4894:
4895: final private boolean jj_3R_155() {
4896: if (jj_3R_174())
4897: return true;
4898: return false;
4899: }
4900:
4901: final private boolean jj_3R_132() {
4902: Token xsp;
4903: xsp = jj_scanpos;
4904: if (jj_3R_155()) {
4905: jj_scanpos = xsp;
4906: if (jj_3R_156())
4907: return true;
4908: }
4909: return false;
4910: }
4911:
4912: final private boolean jj_3R_78() {
4913: if (jj_3R_132())
4914: return true;
4915: Token xsp;
4916: while (true) {
4917: xsp = jj_scanpos;
4918: if (jj_3R_133()) {
4919: jj_scanpos = xsp;
4920: break;
4921: }
4922: }
4923: return false;
4924: }
4925:
4926: final private boolean jj_3R_138() {
4927: if (jj_3R_162())
4928: return true;
4929: return false;
4930: }
4931:
4932: final private boolean jj_3_15() {
4933: if (jj_3R_19())
4934: return true;
4935: return false;
4936: }
4937:
4938: final private boolean jj_3R_26() {
4939: if (jj_3R_14())
4940: return true;
4941: Token xsp;
4942: xsp = jj_scanpos;
4943: if (jj_3R_77())
4944: jj_scanpos = xsp;
4945: if (jj_scan_token(IN))
4946: return true;
4947: if (jj_scan_token(LPAREN))
4948: return true;
4949: xsp = jj_scanpos;
4950: if (jj_3R_78()) {
4951: jj_scanpos = xsp;
4952: if (jj_3R_79())
4953: return true;
4954: }
4955: if (jj_scan_token(RPAREN))
4956: return true;
4957: return false;
4958: }
4959:
4960: final private boolean jj_3_30() {
4961: if (jj_3R_35())
4962: return true;
4963: Token xsp;
4964: xsp = jj_scanpos;
4965: if (jj_3R_36())
4966: jj_scanpos = xsp;
4967: if (jj_scan_token(BETWEEN))
4968: return true;
4969: if (jj_3R_35())
4970: return true;
4971: if (jj_scan_token(AND))
4972: return true;
4973: if (jj_3R_35())
4974: return true;
4975: return false;
4976: }
4977:
4978: final private boolean jj_3_27() {
4979: if (jj_3R_30())
4980: return true;
4981: return false;
4982: }
4983:
4984: final private boolean jj_3_26() {
4985: if (jj_3R_29())
4986: return true;
4987: return false;
4988: }
4989:
4990: final private boolean jj_3_25() {
4991: if (jj_3R_28())
4992: return true;
4993: return false;
4994: }
4995:
4996: final private boolean jj_3_29() {
4997: if (jj_3R_33())
4998: return true;
4999: Token xsp;
5000: xsp = jj_scanpos;
5001: if (jj_3R_34())
5002: jj_scanpos = xsp;
5003: if (jj_scan_token(BETWEEN))
5004: return true;
5005: if (jj_3R_33())
5006: return true;
5007: if (jj_scan_token(AND))
5008: return true;
5009: if (jj_3R_33())
5010: return true;
5011: return false;
5012: }
5013:
5014: final private boolean jj_3_24() {
5015: if (jj_3R_27())
5016: return true;
5017: return false;
5018: }
5019:
5020: final private boolean jj_3R_176() {
5021: if (jj_3R_19())
5022: return true;
5023: return false;
5024: }
5025:
5026: final private boolean jj_3_23() {
5027: if (jj_3R_26())
5028: return true;
5029: return false;
5030: }
5031:
5032: final private boolean jj_3_22() {
5033: if (jj_3R_25())
5034: return true;
5035: return false;
5036: }
5037:
5038: final private boolean jj_3R_24() {
5039: Token xsp;
5040: xsp = jj_scanpos;
5041: if (jj_3_28()) {
5042: jj_scanpos = xsp;
5043: if (jj_3_29()) {
5044: jj_scanpos = xsp;
5045: if (jj_3_30())
5046: return true;
5047: }
5048: }
5049: return false;
5050: }
5051:
5052: final private boolean jj_3_21() {
5053: if (jj_3R_24())
5054: return true;
5055: return false;
5056: }
5057:
5058: final private boolean jj_3_28() {
5059: if (jj_3R_31())
5060: return true;
5061: Token xsp;
5062: xsp = jj_scanpos;
5063: if (jj_3R_32())
5064: jj_scanpos = xsp;
5065: if (jj_scan_token(BETWEEN))
5066: return true;
5067: if (jj_3R_31())
5068: return true;
5069: if (jj_scan_token(AND))
5070: return true;
5071: if (jj_3R_31())
5072: return true;
5073: return false;
5074: }
5075:
5076: final private boolean jj_3_17() {
5077: if (jj_scan_token(AND))
5078: return true;
5079: if (jj_3R_22())
5080: return true;
5081: return false;
5082: }
5083:
5084: final private boolean jj_3_20() {
5085: if (jj_3R_23())
5086: return true;
5087: return false;
5088: }
5089:
5090: final private boolean jj_3R_193() {
5091: if (jj_3R_30())
5092: return true;
5093: return false;
5094: }
5095:
5096: final private boolean jj_3R_192() {
5097: if (jj_3R_29())
5098: return true;
5099: return false;
5100: }
5101:
5102: final private boolean jj_3R_191() {
5103: if (jj_3R_28())
5104: return true;
5105: return false;
5106: }
5107:
5108: final private boolean jj_3R_190() {
5109: if (jj_3R_27())
5110: return true;
5111: return false;
5112: }
5113:
5114: final private boolean jj_3R_189() {
5115: if (jj_3R_26())
5116: return true;
5117: return false;
5118: }
5119:
5120: final private boolean jj_3R_137() {
5121: if (jj_3R_161())
5122: return true;
5123: return false;
5124: }
5125:
5126: final private boolean jj_3_16() {
5127: if (jj_scan_token(OR))
5128: return true;
5129: if (jj_3R_21())
5130: return true;
5131: return false;
5132: }
5133:
5134: final private boolean jj_3R_188() {
5135: if (jj_3R_25())
5136: return true;
5137: return false;
5138: }
5139:
5140: final private boolean jj_3R_187() {
5141: if (jj_3R_24())
5142: return true;
5143: return false;
5144: }
5145:
5146: final private boolean jj_3R_159() {
5147: if (jj_scan_token(COMMA))
5148: return true;
5149: if (jj_3R_158())
5150: return true;
5151: return false;
5152: }
5153:
5154: final private boolean jj_3_19() {
5155: if (jj_scan_token(LPAREN))
5156: return true;
5157: if (jj_3R_21())
5158: return true;
5159: if (jj_scan_token(RPAREN))
5160: return true;
5161: return false;
5162: }
5163:
5164: final private boolean jj_3R_68() {
5165: if (jj_scan_token(AND))
5166: return true;
5167: if (jj_3R_22())
5168: return true;
5169: return false;
5170: }
5171:
5172: final private boolean jj_3R_186() {
5173: if (jj_3R_23())
5174: return true;
5175: return false;
5176: }
5177:
5178: final private boolean jj_3R_173() {
5179: Token xsp;
5180: xsp = jj_scanpos;
5181: if (jj_3R_186()) {
5182: jj_scanpos = xsp;
5183: if (jj_3R_187()) {
5184: jj_scanpos = xsp;
5185: if (jj_3R_188()) {
5186: jj_scanpos = xsp;
5187: if (jj_3R_189()) {
5188: jj_scanpos = xsp;
5189: if (jj_3R_190()) {
5190: jj_scanpos = xsp;
5191: if (jj_3R_191()) {
5192: jj_scanpos = xsp;
5193: if (jj_3R_192()) {
5194: jj_scanpos = xsp;
5195: if (jj_3R_193())
5196: return true;
5197: }
5198: }
5199: }
5200: }
5201: }
5202: }
5203: }
5204: return false;
5205: }
5206:
5207: final private boolean jj_3R_154() {
5208: if (jj_3R_173())
5209: return true;
5210: return false;
5211: }
5212:
5213: final private boolean jj_3_18() {
5214: if (jj_scan_token(NOT))
5215: return true;
5216: return false;
5217: }
5218:
5219: final private boolean jj_3R_66() {
5220: if (jj_scan_token(OR))
5221: return true;
5222: if (jj_3R_21())
5223: return true;
5224: return false;
5225: }
5226:
5227: final private boolean jj_3R_153() {
5228: if (jj_scan_token(LPAREN))
5229: return true;
5230: if (jj_3R_21())
5231: return true;
5232: if (jj_scan_token(RPAREN))
5233: return true;
5234: return false;
5235: }
5236:
5237: final private boolean jj_3R_118() {
5238: Token xsp;
5239: xsp = jj_scanpos;
5240: if (jj_3R_153()) {
5241: jj_scanpos = xsp;
5242: if (jj_3R_154())
5243: return true;
5244: }
5245: return false;
5246: }
5247:
5248: final private boolean jj_3R_117() {
5249: if (jj_scan_token(NOT))
5250: return true;
5251: return false;
5252: }
5253:
5254: final private boolean jj_3R_136() {
5255: if (jj_3R_160())
5256: return true;
5257: return false;
5258: }
5259:
5260: final private boolean jj_3R_67() {
5261: Token xsp;
5262: xsp = jj_scanpos;
5263: if (jj_3R_117())
5264: jj_scanpos = xsp;
5265: if (jj_3R_118())
5266: return true;
5267: return false;
5268: }
5269:
5270: final private boolean jj_3R_22() {
5271: if (jj_3R_67())
5272: return true;
5273: Token xsp;
5274: while (true) {
5275: xsp = jj_scanpos;
5276: if (jj_3R_68()) {
5277: jj_scanpos = xsp;
5278: break;
5279: }
5280: }
5281: return false;
5282: }
5283:
5284: final private boolean jj_3_14() {
5285: if (jj_3R_14())
5286: return true;
5287: return false;
5288: }
5289:
5290: final private boolean jj_3R_21() {
5291: if (jj_3R_22())
5292: return true;
5293: Token xsp;
5294: while (true) {
5295: xsp = jj_scanpos;
5296: if (jj_3R_66()) {
5297: jj_scanpos = xsp;
5298: break;
5299: }
5300: }
5301: return false;
5302: }
5303:
5304: final private boolean jj_3R_175() {
5305: if (jj_3R_14())
5306: return true;
5307: return false;
5308: }
5309:
5310: final private boolean jj_3R_157() {
5311: Token xsp;
5312: xsp = jj_scanpos;
5313: if (jj_3R_175()) {
5314: jj_scanpos = xsp;
5315: if (jj_3R_176()) {
5316: jj_scanpos = xsp;
5317: if (jj_3R_177())
5318: return true;
5319: }
5320: }
5321: return false;
5322: }
5323:
5324: final private boolean jj_3_13() {
5325: if (jj_3R_20())
5326: return true;
5327: return false;
5328: }
5329:
5330: final private boolean jj_3R_134() {
5331: if (jj_scan_token(SELECT))
5332: return true;
5333: Token xsp;
5334: xsp = jj_scanpos;
5335: if (jj_scan_token(37))
5336: jj_scanpos = xsp;
5337: if (jj_3R_157())
5338: return true;
5339: return false;
5340: }
5341:
5342: final private boolean jj_3R_179() {
5343: if (jj_3R_197())
5344: return true;
5345: return false;
5346: }
5347:
5348: final private boolean jj_3R_178() {
5349: if (jj_3R_20())
5350: return true;
5351: return false;
5352: }
5353:
5354: final private boolean jj_3R_158() {
5355: Token xsp;
5356: xsp = jj_scanpos;
5357: if (jj_3_12()) {
5358: jj_scanpos = xsp;
5359: if (jj_3R_178()) {
5360: jj_scanpos = xsp;
5361: if (jj_3R_179())
5362: return true;
5363: }
5364: }
5365: return false;
5366: }
5367:
5368: final private boolean jj_3_12() {
5369: if (jj_3R_14())
5370: return true;
5371: Token xsp;
5372: xsp = jj_scanpos;
5373: if (jj_scan_token(24))
5374: jj_scanpos = xsp;
5375: if (jj_3R_113())
5376: return true;
5377: return false;
5378: }
5379:
5380: final private boolean jj_3R_111() {
5381: if (jj_3R_113())
5382: return true;
5383: return false;
5384: }
5385:
5386: final private boolean jj_3R_142() {
5387: if (jj_3R_170())
5388: return true;
5389: return false;
5390: }
5391:
5392: final private boolean jj_3R_135() {
5393: if (jj_scan_token(FROM))
5394: return true;
5395: if (jj_3R_158())
5396: return true;
5397: Token xsp;
5398: while (true) {
5399: xsp = jj_scanpos;
5400: if (jj_3R_159()) {
5401: jj_scanpos = xsp;
5402: break;
5403: }
5404: }
5405: return false;
5406: }
5407:
5408: final private boolean jj_3R_86() {
5409: if (jj_3R_134())
5410: return true;
5411: if (jj_3R_135())
5412: return true;
5413: Token xsp;
5414: xsp = jj_scanpos;
5415: if (jj_3R_136())
5416: jj_scanpos = xsp;
5417: xsp = jj_scanpos;
5418: if (jj_3R_137())
5419: jj_scanpos = xsp;
5420: xsp = jj_scanpos;
5421: if (jj_3R_138())
5422: jj_scanpos = xsp;
5423: return false;
5424: }
5425:
5426: final private boolean jj_3R_181() {
5427: if (jj_scan_token(COMMA))
5428: return true;
5429: if (jj_3R_180())
5430: return true;
5431: return false;
5432: }
5433:
5434: final private boolean jj_3R_170() {
5435: if (jj_scan_token(named_parameter))
5436: return true;
5437: return false;
5438: }
5439:
5440: final private boolean jj_3R_169() {
5441: if (jj_scan_token(input_parameter))
5442: return true;
5443: return false;
5444: }
5445:
5446: final private boolean jj_3_8() {
5447: if (jj_3R_19())
5448: return true;
5449: return false;
5450: }
5451:
5452: final private boolean jj_3R_162() {
5453: if (jj_scan_token(HAVING))
5454: return true;
5455: if (jj_3R_21())
5456: return true;
5457: return false;
5458: }
5459:
5460: final private boolean jj_3R_141() {
5461: if (jj_3R_169())
5462: return true;
5463: return false;
5464: }
5465:
5466: final private boolean jj_3R_104() {
5467: Token xsp;
5468: xsp = jj_scanpos;
5469: if (jj_3R_141()) {
5470: jj_scanpos = xsp;
5471: if (jj_3R_142())
5472: return true;
5473: }
5474: return false;
5475: }
5476:
5477: final private boolean jj_3R_196() {
5478: if (jj_3R_107())
5479: return true;
5480: return false;
5481: }
5482:
5483: final private boolean jj_3R_185() {
5484: if (jj_3R_207())
5485: return true;
5486: return false;
5487: }
5488:
5489: final private boolean jj_3R_149() {
5490: if (jj_scan_token(FALSE))
5491: return true;
5492: return false;
5493: }
5494:
5495: final private boolean jj_3R_199() {
5496: if (jj_3R_209())
5497: return true;
5498: return false;
5499: }
5500:
5501: final private boolean jj_3R_180() {
5502: if (jj_3R_14())
5503: return true;
5504: return false;
5505: }
5506:
5507: final private boolean jj_3R_148() {
5508: if (jj_scan_token(TRUE))
5509: return true;
5510: return false;
5511: }
5512:
5513: final private boolean jj_3R_107() {
5514: Token xsp;
5515: xsp = jj_scanpos;
5516: if (jj_3R_148()) {
5517: jj_scanpos = xsp;
5518: if (jj_3R_149())
5519: return true;
5520: }
5521: return false;
5522: }
5523:
5524: final private boolean jj_3R_210() {
5525: if (jj_scan_token(COMMA))
5526: return true;
5527: if (jj_3R_15())
5528: return true;
5529: return false;
5530: }
5531:
5532: final private boolean jj_3_10() {
5533: if (jj_3R_14())
5534: return true;
5535: return false;
5536: }
5537:
5538: final private boolean jj_3R_161() {
5539: if (jj_scan_token(GROUP))
5540: return true;
5541: if (jj_scan_token(BY))
5542: return true;
5543: if (jj_3R_180())
5544: return true;
5545: Token xsp;
5546: while (true) {
5547: xsp = jj_scanpos;
5548: if (jj_3R_181()) {
5549: jj_scanpos = xsp;
5550: break;
5551: }
5552: }
5553: return false;
5554: }
5555:
5556: final private boolean jj_3R_209() {
5557: if (jj_scan_token(FLOATING_POINT_LITERAL))
5558: return true;
5559: return false;
5560: }
5561:
5562: final private boolean jj_3R_160() {
5563: if (jj_scan_token(WHERE))
5564: return true;
5565: if (jj_3R_21())
5566: return true;
5567: return false;
5568: }
5569:
5570: final private boolean jj_3R_208() {
5571: if (jj_scan_token(INTEGER_LITERAL))
5572: return true;
5573: return false;
5574: }
5575:
5576: final private boolean jj_3R_110() {
5577: if (jj_3R_14())
5578: return true;
5579: return false;
5580: }
5581:
5582: final private boolean jj_3R_195() {
5583: if (jj_3R_182())
5584: return true;
5585: return false;
5586: }
5587:
5588: final private boolean jj_3R_109() {
5589: if (jj_scan_token(DISTINCT))
5590: return true;
5591: return false;
5592: }
5593:
5594: final private boolean jj_3R_198() {
5595: if (jj_3R_208())
5596: return true;
5597: return false;
5598: }
5599:
5600: final private boolean jj_3R_182() {
5601: Token xsp;
5602: xsp = jj_scanpos;
5603: if (jj_3R_198()) {
5604: jj_scanpos = xsp;
5605: if (jj_3R_199())
5606: return true;
5607: }
5608: return false;
5609: }
5610:
5611: final private boolean jj_3R_184() {
5612: if (jj_3R_206())
5613: return true;
5614: return false;
5615: }
5616:
5617: final private boolean jj_3R_63() {
5618: if (jj_scan_token(COUNT))
5619: return true;
5620: if (jj_scan_token(LPAREN))
5621: return true;
5622: Token xsp;
5623: xsp = jj_scanpos;
5624: if (jj_3R_109())
5625: jj_scanpos = xsp;
5626: xsp = jj_scanpos;
5627: if (jj_3R_110()) {
5628: jj_scanpos = xsp;
5629: if (jj_3R_111())
5630: return true;
5631: }
5632: if (jj_scan_token(RPAREN))
5633: return true;
5634: return false;
5635: }
5636:
5637: final private boolean jj_3R_108() {
5638: if (jj_scan_token(DISTINCT))
5639: return true;
5640: return false;
5641: }
5642:
5643: final private boolean jj_3R_171() {
5644: Token xsp;
5645: xsp = jj_scanpos;
5646: if (jj_3R_184())
5647: jj_scanpos = xsp;
5648: xsp = jj_scanpos;
5649: if (jj_3R_185())
5650: jj_scanpos = xsp;
5651: if (jj_scan_token(FROM))
5652: return true;
5653: return false;
5654: }
5655:
5656: final private boolean jj_3R_103() {
5657: if (jj_scan_token(string_literal))
5658: return true;
5659: return false;
5660: }
5661:
5662: final private boolean jj_3_9() {
5663: if (jj_3R_14())
5664: return true;
5665: return false;
5666: }
5667:
5668: final private boolean jj_3R_19() {
5669: Token xsp;
5670: xsp = jj_scanpos;
5671: if (jj_3_11()) {
5672: jj_scanpos = xsp;
5673: if (jj_3R_63())
5674: return true;
5675: }
5676: return false;
5677: }
5678:
5679: final private boolean jj_3_11() {
5680: Token xsp;
5681: xsp = jj_scanpos;
5682: if (jj_scan_token(26)) {
5683: jj_scanpos = xsp;
5684: if (jj_scan_token(56)) {
5685: jj_scanpos = xsp;
5686: if (jj_scan_token(58)) {
5687: jj_scanpos = xsp;
5688: if (jj_scan_token(74))
5689: return true;
5690: }
5691: }
5692: }
5693: if (jj_scan_token(LPAREN))
5694: return true;
5695: xsp = jj_scanpos;
5696: if (jj_3R_108())
5697: jj_scanpos = xsp;
5698: if (jj_3R_14())
5699: return true;
5700: if (jj_scan_token(RPAREN))
5701: return true;
5702: return false;
5703: }
5704:
5705: final private boolean jj_3R_194() {
5706: if (jj_3R_103())
5707: return true;
5708: return false;
5709: }
5710:
5711: final private boolean jj_3R_174() {
5712: Token xsp;
5713: xsp = jj_scanpos;
5714: if (jj_3R_194()) {
5715: jj_scanpos = xsp;
5716: if (jj_3R_195()) {
5717: jj_scanpos = xsp;
5718: if (jj_3R_196())
5719: return true;
5720: }
5721: }
5722: return false;
5723: }
5724:
5725: final private boolean jj_3_7() {
5726: if (jj_3R_14())
5727: return true;
5728: return false;
5729: }
5730:
5731: final private boolean jj_3R_113() {
5732: if (jj_scan_token(IDENTIFIER))
5733: return true;
5734: return false;
5735: }
5736:
5737: final private boolean jj_3R_130() {
5738: if (jj_3R_104())
5739: return true;
5740: return false;
5741: }
5742:
5743: final private boolean jj_3_6() {
5744: if (jj_3R_14())
5745: return true;
5746: return false;
5747: }
5748:
5749: final private boolean jj_3R_112() {
5750: if (jj_scan_token(IDENTIFIER))
5751: return true;
5752: return false;
5753: }
5754:
5755: final private boolean jj_3R_131() {
5756: if (jj_3R_103())
5757: return true;
5758: return false;
5759: }
5760:
5761: final private boolean jj_3R_129() {
5762: if (jj_3R_103())
5763: return true;
5764: return false;
5765: }
5766:
5767: final private boolean jj_3R_75() {
5768: Token xsp;
5769: xsp = jj_scanpos;
5770: if (jj_3R_129()) {
5771: jj_scanpos = xsp;
5772: if (jj_3R_130())
5773: return true;
5774: }
5775: return false;
5776: }
5777:
5778: final private boolean jj_3R_207() {
5779: if (jj_3R_103())
5780: return true;
5781: return false;
5782: }
5783:
5784: final private boolean jj_3R_206() {
5785: Token xsp;
5786: xsp = jj_scanpos;
5787: if (jj_scan_token(49)) {
5788: jj_scanpos = xsp;
5789: if (jj_scan_token(75)) {
5790: jj_scanpos = xsp;
5791: if (jj_scan_token(28))
5792: return true;
5793: }
5794: }
5795: return false;
5796: }
5797:
5798: final private boolean jj_3_1() {
5799: if (jj_3R_14())
5800: return true;
5801: return false;
5802: }
5803:
5804: final private boolean jj_3_5() {
5805: if (jj_3R_18())
5806: return true;
5807: return false;
5808: }
5809:
5810: final private boolean jj_3_4() {
5811: if (jj_3R_17())
5812: return true;
5813: return false;
5814: }
5815:
5816: final private boolean jj_3_3() {
5817: if (jj_3R_16())
5818: return true;
5819: return false;
5820: }
5821:
5822: final private boolean jj_3R_147() {
5823: if (jj_scan_token(UPPER))
5824: return true;
5825: if (jj_scan_token(LPAREN))
5826: return true;
5827: if (jj_3R_16())
5828: return true;
5829: if (jj_scan_token(RPAREN))
5830: return true;
5831: return false;
5832: }
5833:
5834: final private boolean jj_3R_146() {
5835: if (jj_scan_token(LOWER))
5836: return true;
5837: if (jj_scan_token(LPAREN))
5838: return true;
5839: if (jj_3R_16())
5840: return true;
5841: if (jj_scan_token(RPAREN))
5842: return true;
5843: return false;
5844: }
5845:
5846: final private boolean jj_3R_145() {
5847: if (jj_scan_token(TRIM))
5848: return true;
5849: if (jj_scan_token(LPAREN))
5850: return true;
5851: Token xsp;
5852: xsp = jj_scanpos;
5853: if (jj_3R_171())
5854: jj_scanpos = xsp;
5855: if (jj_3R_16())
5856: return true;
5857: if (jj_scan_token(RPAREN))
5858: return true;
5859: return false;
5860: }
5861:
5862: final private boolean jj_3_2() {
5863: if (jj_3R_15())
5864: return true;
5865: return false;
5866: }
5867:
5868: final private boolean jj_3R_144() {
5869: if (jj_scan_token(SUBSTRING))
5870: return true;
5871: if (jj_scan_token(LPAREN))
5872: return true;
5873: if (jj_3R_16())
5874: return true;
5875: if (jj_scan_token(COMMA))
5876: return true;
5877: if (jj_3R_15())
5878: return true;
5879: if (jj_scan_token(COMMA))
5880: return true;
5881: if (jj_3R_15())
5882: return true;
5883: if (jj_scan_token(RPAREN))
5884: return true;
5885: return false;
5886: }
5887:
5888: final private boolean jj_3R_126() {
5889: if (jj_3R_93())
5890: return true;
5891: return false;
5892: }
5893:
5894: final private boolean jj_3R_143() {
5895: if (jj_scan_token(CONCAT))
5896: return true;
5897: if (jj_scan_token(LPAREN))
5898: return true;
5899: if (jj_3R_16())
5900: return true;
5901: if (jj_scan_token(COMMA))
5902: return true;
5903: if (jj_3R_16())
5904: return true;
5905: if (jj_scan_token(RPAREN))
5906: return true;
5907: return false;
5908: }
5909:
5910: final private boolean jj_3R_120() {
5911: if (jj_3R_93())
5912: return true;
5913: return false;
5914: }
5915:
5916: final private boolean jj_3R_105() {
5917: Token xsp;
5918: xsp = jj_scanpos;
5919: if (jj_3R_143()) {
5920: jj_scanpos = xsp;
5921: if (jj_3R_144()) {
5922: jj_scanpos = xsp;
5923: if (jj_3R_145()) {
5924: jj_scanpos = xsp;
5925: if (jj_3R_146()) {
5926: jj_scanpos = xsp;
5927: if (jj_3R_147())
5928: return true;
5929: }
5930: }
5931: }
5932: }
5933: return false;
5934: }
5935:
5936: final private boolean jj_3R_116() {
5937: if (jj_3R_152())
5938: return true;
5939: return false;
5940: }
5941:
5942: final private boolean jj_3R_128() {
5943: if (jj_3R_93())
5944: return true;
5945: return false;
5946: }
5947:
5948: final private boolean jj_3R_122() {
5949: if (jj_3R_93())
5950: return true;
5951: return false;
5952: }
5953:
5954: final private boolean jj_3R_106() {
5955: Token xsp;
5956: xsp = jj_scanpos;
5957: if (jj_scan_token(32)) {
5958: jj_scanpos = xsp;
5959: if (jj_scan_token(33)) {
5960: jj_scanpos = xsp;
5961: if (jj_scan_token(34))
5962: return true;
5963: }
5964: }
5965: return false;
5966: }
5967:
5968: final private boolean jj_3R_124() {
5969: if (jj_3R_93())
5970: return true;
5971: return false;
5972: }
5973:
5974: final private boolean jj_3R_205() {
5975: if (jj_scan_token(SIZE))
5976: return true;
5977: if (jj_scan_token(LPAREN))
5978: return true;
5979: if (jj_3R_14())
5980: return true;
5981: if (jj_scan_token(RPAREN))
5982: return true;
5983: return false;
5984: }
5985:
5986: final private boolean jj_3R_204() {
5987: if (jj_scan_token(MOD))
5988: return true;
5989: if (jj_scan_token(LPAREN))
5990: return true;
5991: if (jj_3R_15())
5992: return true;
5993: if (jj_scan_token(COMMA))
5994: return true;
5995: if (jj_3R_15())
5996: return true;
5997: if (jj_scan_token(RPAREN))
5998: return true;
5999: return false;
6000: }
6001:
6002: final private boolean jj_3R_115() {
6003: if (jj_3R_151())
6004: return true;
6005: return false;
6006: }
6007:
6008: final private boolean jj_3R_203() {
6009: if (jj_scan_token(SQRT))
6010: return true;
6011: if (jj_scan_token(LPAREN))
6012: return true;
6013: if (jj_3R_15())
6014: return true;
6015: if (jj_scan_token(RPAREN))
6016: return true;
6017: return false;
6018: }
6019:
6020: final private boolean jj_3R_62() {
6021: if (jj_3R_104())
6022: return true;
6023: return false;
6024: }
6025:
6026: final private boolean jj_3R_202() {
6027: if (jj_scan_token(ABS))
6028: return true;
6029: if (jj_scan_token(LPAREN))
6030: return true;
6031: if (jj_3R_15())
6032: return true;
6033: if (jj_scan_token(RPAREN))
6034: return true;
6035: return false;
6036: }
6037:
6038: final private boolean jj_3R_51() {
6039: if (jj_scan_token(DOT))
6040: return true;
6041: if (jj_scan_token(IDENTIFIER))
6042: return true;
6043: return false;
6044: }
6045:
6046: final private boolean jj_3R_201() {
6047: if (jj_scan_token(LOCATE))
6048: return true;
6049: if (jj_scan_token(LPAREN))
6050: return true;
6051: if (jj_3R_16())
6052: return true;
6053: if (jj_scan_token(COMMA))
6054: return true;
6055: if (jj_3R_16())
6056: return true;
6057: Token xsp;
6058: xsp = jj_scanpos;
6059: if (jj_3R_210())
6060: jj_scanpos = xsp;
6061: if (jj_scan_token(RPAREN))
6062: return true;
6063: return false;
6064: }
6065:
6066: final private boolean jj_3_45() {
6067: if (jj_3R_14())
6068: return true;
6069: return false;
6070: }
6071:
6072: final private boolean jj_3R_14() {
6073: if (jj_scan_token(IDENTIFIER))
6074: return true;
6075: if (jj_scan_token(DOT))
6076: return true;
6077: if (jj_scan_token(IDENTIFIER))
6078: return true;
6079: Token xsp;
6080: while (true) {
6081: xsp = jj_scanpos;
6082: if (jj_3R_51()) {
6083: jj_scanpos = xsp;
6084: break;
6085: }
6086: }
6087: return false;
6088: }
6089:
6090: final private boolean jj_3_39() {
6091: if (jj_3R_15())
6092: return true;
6093: return false;
6094: }
6095:
6096: final private boolean jj_3R_200() {
6097: if (jj_scan_token(LENGTH))
6098: return true;
6099: if (jj_scan_token(LPAREN))
6100: return true;
6101: if (jj_3R_16())
6102: return true;
6103: if (jj_scan_token(RPAREN))
6104: return true;
6105: return false;
6106: }
6107:
6108: final private boolean jj_3R_183() {
6109: Token xsp;
6110: xsp = jj_scanpos;
6111: if (jj_3R_200()) {
6112: jj_scanpos = xsp;
6113: if (jj_3R_201()) {
6114: jj_scanpos = xsp;
6115: if (jj_3R_202()) {
6116: jj_scanpos = xsp;
6117: if (jj_3R_203()) {
6118: jj_scanpos = xsp;
6119: if (jj_3R_204()) {
6120: jj_scanpos = xsp;
6121: if (jj_3R_205())
6122: return true;
6123: }
6124: }
6125: }
6126: }
6127: }
6128: return false;
6129: }
6130:
6131: final private boolean jj_3R_125() {
6132: if (jj_3R_35())
6133: return true;
6134: return false;
6135: }
6136:
6137: final private boolean jj_3R_95() {
6138: if (jj_scan_token(LPAREN))
6139: return true;
6140: if (jj_3R_86())
6141: return true;
6142: if (jj_scan_token(RPAREN))
6143: return true;
6144: return false;
6145: }
6146:
6147: final private boolean jj_3R_98() {
6148: if (jj_3R_104())
6149: return true;
6150: return false;
6151: }
6152:
6153: final private boolean jj_3R_97() {
6154: if (jj_3R_113())
6155: return true;
6156: return false;
6157: }
6158:
6159: final private boolean jj_3R_197() {
6160: if (jj_scan_token(IN))
6161: return true;
6162: if (jj_scan_token(LPAREN))
6163: return true;
6164: if (jj_3R_14())
6165: return true;
6166: if (jj_scan_token(RPAREN))
6167: return true;
6168: Token xsp;
6169: xsp = jj_scanpos;
6170: if (jj_scan_token(24))
6171: jj_scanpos = xsp;
6172: if (jj_3R_113())
6173: return true;
6174: return false;
6175: }
6176:
6177: final private boolean jj_3R_65() {
6178: if (jj_3R_114())
6179: return true;
6180: Token xsp;
6181: xsp = jj_scanpos;
6182: if (jj_3R_115()) {
6183: jj_scanpos = xsp;
6184: if (jj_3R_116())
6185: return true;
6186: }
6187: return false;
6188: }
6189:
6190: final private boolean jj_3_44() {
6191: if (jj_3R_14())
6192: return true;
6193: return false;
6194: }
6195:
6196: final private boolean jj_3R_119() {
6197: if (jj_3R_31())
6198: return true;
6199: return false;
6200: }
6201:
6202: final private boolean jj_3R_47() {
6203: Token xsp;
6204: xsp = jj_scanpos;
6205: if (jj_3R_96()) {
6206: jj_scanpos = xsp;
6207: if (jj_3R_97()) {
6208: jj_scanpos = xsp;
6209: if (jj_3R_98())
6210: return true;
6211: }
6212: }
6213: return false;
6214: }
6215:
6216: final private boolean jj_3R_96() {
6217: if (jj_3R_14())
6218: return true;
6219: return false;
6220: }
6221:
6222: final private boolean jj_3R_127() {
6223: if (jj_3R_47())
6224: return true;
6225: return false;
6226: }
6227:
6228: final private boolean jj_3R_121() {
6229: if (jj_3R_33())
6230: return true;
6231: return false;
6232: }
6233:
6234: final private boolean jj_3R_102() {
6235: if (jj_3R_15())
6236: return true;
6237: return false;
6238: }
6239:
6240: final private boolean jj_3R_172() {
6241: if (jj_scan_token(LEFT))
6242: return true;
6243: Token xsp;
6244: xsp = jj_scanpos;
6245: if (jj_scan_token(67))
6246: jj_scanpos = xsp;
6247: return false;
6248: }
6249:
6250: final private boolean jj_3R_150() {
6251: Token xsp;
6252: xsp = jj_scanpos;
6253: if (jj_3R_172()) {
6254: jj_scanpos = xsp;
6255: if (jj_scan_token(46))
6256: return true;
6257: }
6258: return false;
6259: }
6260:
6261: final private boolean jj_3R_123() {
6262: if (jj_3R_42())
6263: return true;
6264: return false;
6265: }
6266:
6267: final private boolean jj_3R_114() {
6268: Token xsp;
6269: xsp = jj_scanpos;
6270: if (jj_3R_150())
6271: jj_scanpos = xsp;
6272: if (jj_scan_token(JOIN))
6273: return true;
6274: return false;
6275: }
6276:
6277: final private boolean jj_3R_61() {
6278: if (jj_3R_107())
6279: return true;
6280: return false;
6281: }
6282:
6283: final private boolean jj_3R_18() {
6284: Token xsp;
6285: xsp = jj_scanpos;
6286: if (jj_3R_60()) {
6287: jj_scanpos = xsp;
6288: if (jj_3R_61()) {
6289: jj_scanpos = xsp;
6290: if (jj_3R_62())
6291: return true;
6292: }
6293: }
6294: return false;
6295: }
6296:
6297: final private boolean jj_3R_60() {
6298: if (jj_3R_14())
6299: return true;
6300: return false;
6301: }
6302:
6303: final private boolean jj_3R_92() {
6304: if (jj_scan_token(LPAREN))
6305: return true;
6306: if (jj_3R_86())
6307: return true;
6308: if (jj_scan_token(RPAREN))
6309: return true;
6310: return false;
6311: }
6312:
6313: final private boolean jj_3R_152() {
6314: if (jj_scan_token(FETCH))
6315: return true;
6316: if (jj_3R_14())
6317: return true;
6318: return false;
6319: }
6320:
6321: final private boolean jj_3_43() {
6322: if (jj_3R_14())
6323: return true;
6324: return false;
6325: }
6326:
6327: final private boolean jj_3R_42() {
6328: Token xsp;
6329: xsp = jj_scanpos;
6330: if (jj_3R_94()) {
6331: jj_scanpos = xsp;
6332: if (jj_3R_95())
6333: return true;
6334: }
6335: return false;
6336: }
6337:
6338: final private boolean jj_3R_94() {
6339: if (jj_3R_18())
6340: return true;
6341: return false;
6342: }
6343:
6344: final private boolean jj_3R_151() {
6345: if (jj_3R_14())
6346: return true;
6347: Token xsp;
6348: xsp = jj_scanpos;
6349: if (jj_scan_token(24))
6350: jj_scanpos = xsp;
6351: if (jj_3R_113())
6352: return true;
6353: return false;
6354: }
6355:
6356: final private boolean jj_3R_59() {
6357: if (jj_3R_106())
6358: return true;
6359: return false;
6360: }
6361:
6362: final private boolean jj_3R_46() {
6363: if (jj_3R_93())
6364: return true;
6365: return false;
6366: }
6367:
6368: final private boolean jj_3R_58() {
6369: if (jj_3R_104())
6370: return true;
6371: return false;
6372: }
6373:
6374: final private boolean jj_3R_64() {
6375: if (jj_3R_112())
6376: return true;
6377: Token xsp;
6378: xsp = jj_scanpos;
6379: if (jj_scan_token(24))
6380: jj_scanpos = xsp;
6381: if (jj_3R_113())
6382: return true;
6383: return false;
6384: }
6385:
6386: final private boolean jj_3R_17() {
6387: Token xsp;
6388: xsp = jj_scanpos;
6389: if (jj_3R_57()) {
6390: jj_scanpos = xsp;
6391: if (jj_3R_58()) {
6392: jj_scanpos = xsp;
6393: if (jj_3R_59())
6394: return true;
6395: }
6396: }
6397: return false;
6398: }
6399:
6400: final private boolean jj_3R_57() {
6401: if (jj_3R_14())
6402: return true;
6403: return false;
6404: }
6405:
6406: final private boolean jj_3R_39() {
6407: if (jj_3R_93())
6408: return true;
6409: return false;
6410: }
6411:
6412: final private boolean jj_3R_90() {
6413: if (jj_scan_token(LPAREN))
6414: return true;
6415: if (jj_3R_86())
6416: return true;
6417: if (jj_scan_token(RPAREN))
6418: return true;
6419: return false;
6420: }
6421:
6422: final private boolean jj_3R_20() {
6423: if (jj_3R_64())
6424: return true;
6425: Token xsp;
6426: while (true) {
6427: xsp = jj_scanpos;
6428: if (jj_3R_65()) {
6429: jj_scanpos = xsp;
6430: break;
6431: }
6432: }
6433: return false;
6434: }
6435:
6436: final private boolean jj_3_42() {
6437: if (jj_3R_14())
6438: return true;
6439: return false;
6440: }
6441:
6442: final private boolean jj_3R_41() {
6443: if (jj_3R_93())
6444: return true;
6445: return false;
6446: }
6447:
6448: final private boolean jj_3R_35() {
6449: Token xsp;
6450: xsp = jj_scanpos;
6451: if (jj_3R_91()) {
6452: jj_scanpos = xsp;
6453: if (jj_3R_92())
6454: return true;
6455: }
6456: return false;
6457: }
6458:
6459: final private boolean jj_3R_91() {
6460: if (jj_3R_17())
6461: return true;
6462: return false;
6463: }
6464:
6465: final private boolean jj_3R_49() {
6466: if (jj_3R_93())
6467: return true;
6468: return false;
6469: }
6470:
6471: final private boolean jj_3R_44() {
6472: if (jj_3R_93())
6473: return true;
6474: return false;
6475: }
6476:
6477: final private boolean jj_3R_56() {
6478: if (jj_3R_105())
6479: return true;
6480: return false;
6481: }
6482:
6483: final private boolean jj_3R_55() {
6484: if (jj_3R_104())
6485: return true;
6486: return false;
6487: }
6488:
6489: final private boolean jj_3R_54() {
6490: if (jj_3R_103())
6491: return true;
6492: return false;
6493: }
6494:
6495: final private boolean jj_3R_16() {
6496: Token xsp;
6497: xsp = jj_scanpos;
6498: if (jj_3R_53()) {
6499: jj_scanpos = xsp;
6500: if (jj_3R_54()) {
6501: jj_scanpos = xsp;
6502: if (jj_3R_55()) {
6503: jj_scanpos = xsp;
6504: if (jj_3R_56())
6505: return true;
6506: }
6507: }
6508: }
6509: return false;
6510: }
6511:
6512: final private boolean jj_3_41() {
6513: if (jj_3R_19())
6514: return true;
6515: return false;
6516: }
6517:
6518: final private boolean jj_3R_53() {
6519: if (jj_3R_14())
6520: return true;
6521: return false;
6522: }
6523:
6524: final private boolean jj_3_38() {
6525: if (jj_3R_50())
6526: return true;
6527: return false;
6528: }
6529:
6530: final private boolean jj_3R_45() {
6531: if (jj_3R_35())
6532: return true;
6533: return false;
6534: }
6535:
6536: final private boolean jj_3R_33() {
6537: Token xsp;
6538: xsp = jj_scanpos;
6539: if (jj_3R_89()) {
6540: jj_scanpos = xsp;
6541: if (jj_3R_90())
6542: return true;
6543: }
6544: return false;
6545: }
6546:
6547: final private boolean jj_3R_89() {
6548: if (jj_3R_16())
6549: return true;
6550: return false;
6551: }
6552:
6553: final private boolean jj_3_40() {
6554: if (jj_3R_14())
6555: return true;
6556: return false;
6557: }
6558:
6559: final private boolean jj_3R_168() {
6560: if (jj_3R_19())
6561: return true;
6562: return false;
6563: }
6564:
6565: final private boolean jj_3R_167() {
6566: if (jj_3R_183())
6567: return true;
6568: return false;
6569: }
6570:
6571: final private boolean jj_3R_38() {
6572: if (jj_3R_31())
6573: return true;
6574: return false;
6575: }
6576:
6577: final private boolean jj_3R_40() {
6578: if (jj_3R_33())
6579: return true;
6580: return false;
6581: }
6582:
6583: final private boolean jj_3R_166() {
6584: if (jj_3R_104())
6585: return true;
6586: return false;
6587: }
6588:
6589: final private boolean jj_3R_100() {
6590: Token xsp;
6591: xsp = jj_scanpos;
6592: if (jj_scan_token(6)) {
6593: jj_scanpos = xsp;
6594: if (jj_scan_token(11))
6595: return true;
6596: }
6597: if (jj_3R_99())
6598: return true;
6599: return false;
6600: }
6601:
6602: final private boolean jj_3R_101() {
6603: if (jj_3R_50())
6604: return true;
6605: return false;
6606: }
6607:
6608: final private boolean jj_3R_165() {
6609: if (jj_scan_token(LPAREN))
6610: return true;
6611: if (jj_3R_15())
6612: return true;
6613: if (jj_scan_token(RPAREN))
6614: return true;
6615: return false;
6616: }
6617:
6618: final private boolean jj_3R_164() {
6619: if (jj_3R_182())
6620: return true;
6621: return false;
6622: }
6623:
6624: final private boolean jj_3R_48() {
6625: if (jj_3R_47())
6626: return true;
6627: return false;
6628: }
6629:
6630: final private boolean jj_3R_163() {
6631: if (jj_3R_14())
6632: return true;
6633: return false;
6634: }
6635:
6636: final private boolean jj_3R_140() {
6637: Token xsp;
6638: xsp = jj_scanpos;
6639: if (jj_3R_163()) {
6640: jj_scanpos = xsp;
6641: if (jj_3R_164()) {
6642: jj_scanpos = xsp;
6643: if (jj_3R_165()) {
6644: jj_scanpos = xsp;
6645: if (jj_3R_166()) {
6646: jj_scanpos = xsp;
6647: if (jj_3R_167()) {
6648: jj_scanpos = xsp;
6649: if (jj_3R_168())
6650: return true;
6651: }
6652: }
6653: }
6654: }
6655: }
6656: return false;
6657: }
6658:
6659: final private boolean jj_3R_43() {
6660: if (jj_3R_42())
6661: return true;
6662: return false;
6663: }
6664:
6665: final private boolean jj_3R_139() {
6666: Token xsp;
6667: xsp = jj_scanpos;
6668: if (jj_scan_token(8)) {
6669: jj_scanpos = xsp;
6670: if (jj_scan_token(5))
6671: return true;
6672: }
6673: return false;
6674: }
6675:
6676: final private boolean jj_3R_99() {
6677: Token xsp;
6678: xsp = jj_scanpos;
6679: if (jj_3R_139())
6680: jj_scanpos = xsp;
6681: if (jj_3R_140())
6682: return true;
6683: return false;
6684: }
6685:
6686: final private boolean jj_3R_50() {
6687: if (jj_3R_99())
6688: return true;
6689: Token xsp;
6690: while (true) {
6691: xsp = jj_scanpos;
6692: if (jj_3R_100()) {
6693: jj_scanpos = xsp;
6694: break;
6695: }
6696: }
6697: return false;
6698: }
6699:
6700: final private boolean jj_3R_52() {
6701: Token xsp;
6702: xsp = jj_scanpos;
6703: if (jj_scan_token(8)) {
6704: jj_scanpos = xsp;
6705: if (jj_scan_token(5))
6706: return true;
6707: }
6708: xsp = jj_scanpos;
6709: if (jj_3R_101()) {
6710: jj_scanpos = xsp;
6711: if (jj_3R_102())
6712: return true;
6713: }
6714: return false;
6715: }
6716:
6717: final private boolean jj_3_37() {
6718: if (jj_3R_15())
6719: return true;
6720: return false;
6721: }
6722:
6723: final private boolean jj_3R_15() {
6724: if (jj_3R_50())
6725: return true;
6726: Token xsp;
6727: xsp = jj_scanpos;
6728: if (jj_3R_52())
6729: jj_scanpos = xsp;
6730: return false;
6731: }
6732:
6733: final private boolean jj_3R_88() {
6734: if (jj_scan_token(LPAREN))
6735: return true;
6736: if (jj_3R_86())
6737: return true;
6738: if (jj_scan_token(RPAREN))
6739: return true;
6740: return false;
6741: }
6742:
6743: final private boolean jj_3R_31() {
6744: Token xsp;
6745: xsp = jj_scanpos;
6746: if (jj_3R_87()) {
6747: jj_scanpos = xsp;
6748: if (jj_3R_88())
6749: return true;
6750: }
6751: return false;
6752: }
6753:
6754: final private boolean jj_3R_87() {
6755: if (jj_3R_15())
6756: return true;
6757: return false;
6758: }
6759:
6760: final private boolean jj_3_36() {
6761: if (jj_3R_47())
6762: return true;
6763: Token xsp;
6764: xsp = jj_scanpos;
6765: if (jj_scan_token(9)) {
6766: jj_scanpos = xsp;
6767: if (jj_scan_token(16))
6768: return true;
6769: }
6770: xsp = jj_scanpos;
6771: if (jj_3R_48()) {
6772: jj_scanpos = xsp;
6773: if (jj_3R_49())
6774: return true;
6775: }
6776: return false;
6777: }
6778:
6779: final private boolean jj_3_35() {
6780: if (jj_3R_35())
6781: return true;
6782: if (jj_3R_37())
6783: return true;
6784: Token xsp;
6785: xsp = jj_scanpos;
6786: if (jj_3R_45()) {
6787: jj_scanpos = xsp;
6788: if (jj_3R_46())
6789: return true;
6790: }
6791: return false;
6792: }
6793:
6794: final private boolean jj_3_34() {
6795: if (jj_3R_42())
6796: return true;
6797: Token xsp;
6798: xsp = jj_scanpos;
6799: if (jj_scan_token(9)) {
6800: jj_scanpos = xsp;
6801: if (jj_scan_token(16))
6802: return true;
6803: }
6804: xsp = jj_scanpos;
6805: if (jj_3R_43()) {
6806: jj_scanpos = xsp;
6807: if (jj_3R_44())
6808: return true;
6809: }
6810: return false;
6811: }
6812:
6813: final private boolean jj_3R_81() {
6814: if (jj_3R_104())
6815: return true;
6816: return false;
6817: }
6818:
6819: final private boolean jj_3R_37() {
6820: Token xsp;
6821: xsp = jj_scanpos;
6822: if (jj_scan_token(9)) {
6823: jj_scanpos = xsp;
6824: if (jj_scan_token(13)) {
6825: jj_scanpos = xsp;
6826: if (jj_scan_token(7)) {
6827: jj_scanpos = xsp;
6828: if (jj_scan_token(18)) {
6829: jj_scanpos = xsp;
6830: if (jj_scan_token(10)) {
6831: jj_scanpos = xsp;
6832: if (jj_scan_token(16))
6833: return true;
6834: }
6835: }
6836: }
6837: }
6838: }
6839: return false;
6840: }
6841:
6842: final private boolean jj_3_33() {
6843: if (jj_3R_33())
6844: return true;
6845: if (jj_3R_37())
6846: return true;
6847: Token xsp;
6848: xsp = jj_scanpos;
6849: if (jj_3R_40()) {
6850: jj_scanpos = xsp;
6851: if (jj_3R_41())
6852: return true;
6853: }
6854: return false;
6855: }
6856:
6857: final private boolean jj_3_32() {
6858: if (jj_3R_31())
6859: return true;
6860: if (jj_3R_37())
6861: return true;
6862: Token xsp;
6863: xsp = jj_scanpos;
6864: if (jj_3R_38()) {
6865: jj_scanpos = xsp;
6866: if (jj_3R_39())
6867: return true;
6868: }
6869: return false;
6870: }
6871:
6872: final private boolean jj_3R_73() {
6873: if (jj_3R_47())
6874: return true;
6875: Token xsp;
6876: xsp = jj_scanpos;
6877: if (jj_scan_token(9)) {
6878: jj_scanpos = xsp;
6879: if (jj_scan_token(16))
6880: return true;
6881: }
6882: xsp = jj_scanpos;
6883: if (jj_3R_127()) {
6884: jj_scanpos = xsp;
6885: if (jj_3R_128())
6886: return true;
6887: }
6888: return false;
6889: }
6890:
6891: final private boolean jj_3R_72() {
6892: if (jj_3R_35())
6893: return true;
6894: if (jj_3R_37())
6895: return true;
6896: Token xsp;
6897: xsp = jj_scanpos;
6898: if (jj_3R_125()) {
6899: jj_scanpos = xsp;
6900: if (jj_3R_126())
6901: return true;
6902: }
6903: return false;
6904: }
6905:
6906: final private boolean jj_3R_71() {
6907: if (jj_3R_42())
6908: return true;
6909: Token xsp;
6910: xsp = jj_scanpos;
6911: if (jj_scan_token(9)) {
6912: jj_scanpos = xsp;
6913: if (jj_scan_token(16))
6914: return true;
6915: }
6916: xsp = jj_scanpos;
6917: if (jj_3R_123()) {
6918: jj_scanpos = xsp;
6919: if (jj_3R_124())
6920: return true;
6921: }
6922: return false;
6923: }
6924:
6925: final private boolean jj_3R_70() {
6926: if (jj_3R_33())
6927: return true;
6928: if (jj_3R_37())
6929: return true;
6930: Token xsp;
6931: xsp = jj_scanpos;
6932: if (jj_3R_121()) {
6933: jj_scanpos = xsp;
6934: if (jj_3R_122())
6935: return true;
6936: }
6937: return false;
6938: }
6939:
6940: final private boolean jj_3R_177() {
6941: if (jj_3R_113())
6942: return true;
6943: return false;
6944: }
6945:
6946: final private boolean jj_3R_23() {
6947: Token xsp;
6948: xsp = jj_scanpos;
6949: if (jj_3R_69()) {
6950: jj_scanpos = xsp;
6951: if (jj_3R_70()) {
6952: jj_scanpos = xsp;
6953: if (jj_3R_71()) {
6954: jj_scanpos = xsp;
6955: if (jj_3R_72()) {
6956: jj_scanpos = xsp;
6957: if (jj_3R_73())
6958: return true;
6959: }
6960: }
6961: }
6962: }
6963: return false;
6964: }
6965:
6966: final private boolean jj_3R_69() {
6967: if (jj_3R_31())
6968: return true;
6969: if (jj_3R_37())
6970: return true;
6971: Token xsp;
6972: xsp = jj_scanpos;
6973: if (jj_3R_119()) {
6974: jj_scanpos = xsp;
6975: if (jj_3R_120())
6976: return true;
6977: }
6978: return false;
6979: }
6980:
6981: final private boolean jj_3R_93() {
6982: Token xsp;
6983: xsp = jj_scanpos;
6984: if (jj_scan_token(21)) {
6985: jj_scanpos = xsp;
6986: if (jj_scan_token(23)) {
6987: jj_scanpos = xsp;
6988: if (jj_scan_token(71))
6989: return true;
6990: }
6991: }
6992: if (jj_scan_token(LPAREN))
6993: return true;
6994: if (jj_3R_86())
6995: return true;
6996: if (jj_scan_token(RPAREN))
6997: return true;
6998: return false;
6999: }
7000:
7001: final private boolean jj_3R_85() {
7002: if (jj_scan_token(NOT))
7003: return true;
7004: return false;
7005: }
7006:
7007: final private boolean jj_3R_30() {
7008: Token xsp;
7009: xsp = jj_scanpos;
7010: if (jj_3R_85())
7011: jj_scanpos = xsp;
7012: if (jj_scan_token(EXISTS))
7013: return true;
7014: if (jj_scan_token(LPAREN))
7015: return true;
7016: if (jj_3R_86())
7017: return true;
7018: if (jj_scan_token(RPAREN))
7019: return true;
7020: return false;
7021: }
7022:
7023: final private boolean jj_3R_76() {
7024: if (jj_scan_token(ESCAPE))
7025: return true;
7026: if (jj_3R_131())
7027: return true;
7028: return false;
7029: }
7030:
7031: final private boolean jj_3R_84() {
7032: if (jj_scan_token(NOT))
7033: return true;
7034: return false;
7035: }
7036:
7037: final private boolean jj_3R_29() {
7038: if (jj_3R_47())
7039: return true;
7040: Token xsp;
7041: xsp = jj_scanpos;
7042: if (jj_3R_84())
7043: jj_scanpos = xsp;
7044: if (jj_scan_token(MEMBER))
7045: return true;
7046: xsp = jj_scanpos;
7047: if (jj_scan_token(64))
7048: jj_scanpos = xsp;
7049: if (jj_3R_14())
7050: return true;
7051: return false;
7052: }
7053:
7054: final private boolean jj_3R_74() {
7055: if (jj_scan_token(NOT))
7056: return true;
7057: return false;
7058: }
7059:
7060: final private boolean jj_3R_83() {
7061: if (jj_scan_token(NOT))
7062: return true;
7063: return false;
7064: }
7065:
7066: final private boolean jj_3_31() {
7067: if (jj_3R_14())
7068: return true;
7069: return false;
7070: }
7071:
7072: final private boolean jj_3R_36() {
7073: if (jj_scan_token(NOT))
7074: return true;
7075: return false;
7076: }
7077:
7078: final private boolean jj_3R_28() {
7079: if (jj_3R_14())
7080: return true;
7081: if (jj_scan_token(IS))
7082: return true;
7083: Token xsp;
7084: xsp = jj_scanpos;
7085: if (jj_3R_83())
7086: jj_scanpos = xsp;
7087: if (jj_scan_token(EMPTY))
7088: return true;
7089: return false;
7090: }
7091:
7092: final private boolean jj_3R_82() {
7093: if (jj_scan_token(NOT))
7094: return true;
7095: return false;
7096: }
7097:
7098: final private boolean jj_3R_34() {
7099: if (jj_scan_token(NOT))
7100: return true;
7101: return false;
7102: }
7103:
7104: final private boolean jj_3R_32() {
7105: if (jj_scan_token(NOT))
7106: return true;
7107: return false;
7108: }
7109:
7110: final private boolean jj_3R_80() {
7111: if (jj_3R_14())
7112: return true;
7113: return false;
7114: }
7115:
7116: final private boolean jj_3R_27() {
7117: Token xsp;
7118: xsp = jj_scanpos;
7119: if (jj_3R_80()) {
7120: jj_scanpos = xsp;
7121: if (jj_3R_81())
7122: return true;
7123: }
7124: if (jj_scan_token(IS))
7125: return true;
7126: xsp = jj_scanpos;
7127: if (jj_3R_82())
7128: jj_scanpos = xsp;
7129: if (jj_scan_token(NULL))
7130: return true;
7131: return false;
7132: }
7133:
7134: final private boolean jj_3R_156() {
7135: if (jj_3R_104())
7136: return true;
7137: return false;
7138: }
7139:
7140: public EJBQLTokenManager token_source;
7141: SimpleCharStream jj_input_stream;
7142: public Token token, jj_nt;
7143: private int jj_ntk;
7144: private Token jj_scanpos, jj_lastpos;
7145: private int jj_la;
7146: public boolean lookingAhead = false;
7147: private boolean jj_semLA;
7148: private int jj_gen;
7149: final private int[] jj_la1 = new int[100];
7150: static private int[] jj_la1_0;
7151: static private int[] jj_la1_1;
7152: static private int[] jj_la1_2;
7153: static {
7154: jj_la1_0();
7155: jj_la1_1();
7156: jj_la1_2();
7157: }
7158:
7159: private static void jj_la1_0() {
7160: jj_la1_0 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
7161: 0x4000, 0x0, 0x0, 0x0, 0x1000000, 0x1000000, 0x0, 0x0,
7162: 0x0, 0x1000000, 0x1000, 0x1000000, 0x1000000, 0x4000,
7163: 0x0, 0x1000000, 0x1000000, 0x0, 0x4000, 0x84000000,
7164: 0x4000, 0x0, 0x4000000, 0x0, 0x0, 0x0, 0x80000000,
7165: 0x4000, 0x4000, 0x2000000, 0x2000000, 0x0, 0x0, 0x0,
7166: 0x4000, 0x1000000, 0x0, 0x0, 0x0, 0xc4120120, 0x0, 0x0,
7167: 0x0, 0x0, 0x4000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
7168: 0x0, 0x0, 0x0, 0xa00000, 0x84b20120, 0x40a20000,
7169: 0x10200, 0xa20000, 0xa20000, 0x10200, 0xa00000,
7170: 0x52680, 0x20000, 0x120, 0x120, 0x840, 0x840, 0x120,
7171: 0x120, 0x120000, 0x40020000, 0x40000000, 0x20000, 0x0,
7172: 0x20000, 0x0, 0x0, 0x4000, 0x100000, 0x0, 0x10000000,
7173: 0x0, 0x10000000, 0x40000000, 0x10000000, 0x0, 0x0, 0x0,
7174: 0x0, 0x0, };
7175: }
7176:
7177: private static void jj_la1_1() {
7178: jj_la1_1 = new int[] { 0x8, 0x8, 0x0, 0x800, 0x1000, 0x0, 0x0,
7179: 0x0, 0x0, 0x2000, 0x54000, 0x200, 0x0, 0x0, 0x0,
7180: 0x44000, 0x44000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
7181: 0x0, 0x20, 0x0, 0x95000000, 0x0, 0x0, 0x5000000, 0x20,
7182: 0x20, 0x0, 0x0, 0x0, 0x0, 0x10, 0x10, 0x0, 0x800,
7183: 0x1000, 0x0, 0x0, 0x2000, 0x20, 0x0, 0x2dc80107,
7184: 0x20000000, 0x20000000, 0x20000000, 0x20000000, 0x0,
7185: 0x0, 0x0, 0x20000000, 0x80, 0x0, 0x20000000,
7186: 0x20000000, 0x20000000, 0x0, 0x20000000, 0x0,
7187: 0xd480000, 0x800000, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0,
7188: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8480000, 0x800000,
7189: 0x800000, 0x7, 0x7, 0x0, 0x0, 0x0, 0x0, 0x8480000, 0x7,
7190: 0x20000, 0x0, 0x20400, 0x800000, 0x20000, 0x0, 0x0,
7191: 0x0, 0x0, 0x0, };
7192: }
7193:
7194: private static void jj_la1_2() {
7195: jj_la1_2 = new int[] { 0x2010, 0x2010, 0x8000, 0x0, 0x0, 0x4,
7196: 0x8000, 0x8000, 0x0, 0x8000000, 0x0, 0x8000000, 0x0,
7197: 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8000000, 0x0,
7198: 0x8000000, 0x0, 0x8000000, 0x0, 0x0, 0x8000400, 0x0,
7199: 0x8000000, 0x400, 0x0, 0x0, 0x8000000, 0x0, 0x0, 0x0,
7200: 0x0, 0x0, 0x8000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
7201: 0x8000000, 0xa3f5740, 0x0, 0x0, 0x0, 0x0, 0x0,
7202: 0x23f0010, 0x23f0000, 0x0, 0x0, 0x50000, 0x0, 0x0, 0x0,
7203: 0x1, 0x0, 0x80, 0xa2505c0, 0x8075280, 0x0, 0x81d0080,
7204: 0x8050080, 0x0, 0x8050080, 0x0, 0x0, 0x0, 0x0, 0x0,
7205: 0x0, 0x0, 0x0, 0x2250140, 0x8075200, 0x75200,
7206: 0x8050000, 0x50000, 0x81d0000, 0x1d0000, 0x8050000,
7207: 0x0, 0x140, 0x0, 0x800, 0x20000, 0x20800, 0x5200,
7208: 0x800, 0x70000, 0x23a0000, 0x2200000, 0x180000,
7209: 0x50000, };
7210: }
7211:
7212: final private JJCalls[] jj_2_rtns = new JJCalls[45];
7213: private boolean jj_rescan = false;
7214: private int jj_gc = 0;
7215:
7216: public EJBQL(java.io.InputStream stream) {
7217: jj_input_stream = new SimpleCharStream(stream, 1, 1);
7218: token_source = new EJBQLTokenManager(jj_input_stream);
7219: token = new Token();
7220: jj_ntk = -1;
7221: jj_gen = 0;
7222: for (int i = 0; i < 100; i++)
7223: jj_la1[i] = -1;
7224: for (int i = 0; i < jj_2_rtns.length; i++)
7225: jj_2_rtns[i] = new JJCalls();
7226: }
7227:
7228: public void ReInit(java.io.InputStream stream) {
7229: jj_input_stream.ReInit(stream, 1, 1);
7230: token_source.ReInit(jj_input_stream);
7231: token = new Token();
7232: jj_ntk = -1;
7233: jjtree.reset();
7234: jj_gen = 0;
7235: for (int i = 0; i < 100; i++)
7236: jj_la1[i] = -1;
7237: for (int i = 0; i < jj_2_rtns.length; i++)
7238: jj_2_rtns[i] = new JJCalls();
7239: }
7240:
7241: public EJBQL(java.io.Reader stream) {
7242: jj_input_stream = new SimpleCharStream(stream, 1, 1);
7243: token_source = new EJBQLTokenManager(jj_input_stream);
7244: token = new Token();
7245: jj_ntk = -1;
7246: jj_gen = 0;
7247: for (int i = 0; i < 100; i++)
7248: jj_la1[i] = -1;
7249: for (int i = 0; i < jj_2_rtns.length; i++)
7250: jj_2_rtns[i] = new JJCalls();
7251: }
7252:
7253: public void ReInit(java.io.Reader stream) {
7254: jj_input_stream.ReInit(stream, 1, 1);
7255: token_source.ReInit(jj_input_stream);
7256: token = new Token();
7257: jj_ntk = -1;
7258: jjtree.reset();
7259: jj_gen = 0;
7260: for (int i = 0; i < 100; i++)
7261: jj_la1[i] = -1;
7262: for (int i = 0; i < jj_2_rtns.length; i++)
7263: jj_2_rtns[i] = new JJCalls();
7264: }
7265:
7266: public EJBQL(EJBQLTokenManager tm) {
7267: token_source = tm;
7268: token = new Token();
7269: jj_ntk = -1;
7270: jj_gen = 0;
7271: for (int i = 0; i < 100; i++)
7272: jj_la1[i] = -1;
7273: for (int i = 0; i < jj_2_rtns.length; i++)
7274: jj_2_rtns[i] = new JJCalls();
7275: }
7276:
7277: public void ReInit(EJBQLTokenManager tm) {
7278: token_source = tm;
7279: token = new Token();
7280: jj_ntk = -1;
7281: jjtree.reset();
7282: jj_gen = 0;
7283: for (int i = 0; i < 100; i++)
7284: jj_la1[i] = -1;
7285: for (int i = 0; i < jj_2_rtns.length; i++)
7286: jj_2_rtns[i] = new JJCalls();
7287: }
7288:
7289: final private Token jj_consume_token(int kind)
7290: throws ParseException {
7291: Token oldToken;
7292: if ((oldToken = token).next != null)
7293: token = token.next;
7294: else
7295: token = token.next = token_source.getNextToken();
7296: jj_ntk = -1;
7297: if (token.kind == kind) {
7298: jj_gen++;
7299: if (++jj_gc > 100) {
7300: jj_gc = 0;
7301: for (int i = 0; i < jj_2_rtns.length; i++) {
7302: JJCalls c = jj_2_rtns[i];
7303: while (c != null) {
7304: if (c.gen < jj_gen)
7305: c.first = null;
7306: c = c.next;
7307: }
7308: }
7309: }
7310: return token;
7311: }
7312: token = oldToken;
7313: jj_kind = kind;
7314: throw generateParseException();
7315: }
7316:
7317: static private final class LookaheadSuccess extends java.lang.Error {
7318: }
7319:
7320: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
7321:
7322: final private boolean jj_scan_token(int kind) {
7323: if (jj_scanpos == jj_lastpos) {
7324: jj_la--;
7325: if (jj_scanpos.next == null) {
7326: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
7327: .getNextToken();
7328: } else {
7329: jj_lastpos = jj_scanpos = jj_scanpos.next;
7330: }
7331: } else {
7332: jj_scanpos = jj_scanpos.next;
7333: }
7334: if (jj_rescan) {
7335: int i = 0;
7336: Token tok = token;
7337: while (tok != null && tok != jj_scanpos) {
7338: i++;
7339: tok = tok.next;
7340: }
7341: if (tok != null)
7342: jj_add_error_token(kind, i);
7343: }
7344: if (jj_scanpos.kind != kind)
7345: return true;
7346: if (jj_la == 0 && jj_scanpos == jj_lastpos)
7347: throw jj_ls;
7348: return false;
7349: }
7350:
7351: final public Token getNextToken() {
7352: if (token.next != null)
7353: token = token.next;
7354: else
7355: token = token.next = token_source.getNextToken();
7356: jj_ntk = -1;
7357: jj_gen++;
7358: return token;
7359: }
7360:
7361: final public Token getToken(int index) {
7362: Token t = lookingAhead ? jj_scanpos : token;
7363: for (int i = 0; i < index; i++) {
7364: if (t.next != null)
7365: t = t.next;
7366: else
7367: t = t.next = token_source.getNextToken();
7368: }
7369: return t;
7370: }
7371:
7372: final private int jj_ntk() {
7373: if ((jj_nt = token.next) == null)
7374: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
7375: else
7376: return (jj_ntk = jj_nt.kind);
7377: }
7378:
7379: private java.util.Vector jj_expentries = new java.util.Vector();
7380: private int[] jj_expentry;
7381: private int jj_kind = -1;
7382: private int[] jj_lasttokens = new int[100];
7383: private int jj_endpos;
7384:
7385: private void jj_add_error_token(int kind, int pos) {
7386: if (pos >= 100)
7387: return;
7388: if (pos == jj_endpos + 1) {
7389: jj_lasttokens[jj_endpos++] = kind;
7390: } else if (jj_endpos != 0) {
7391: jj_expentry = new int[jj_endpos];
7392: for (int i = 0; i < jj_endpos; i++) {
7393: jj_expentry[i] = jj_lasttokens[i];
7394: }
7395: boolean exists = false;
7396: for (java.util.Enumeration e = jj_expentries.elements(); e
7397: .hasMoreElements();) {
7398: int[] oldentry = (int[]) (e.nextElement());
7399: if (oldentry.length == jj_expentry.length) {
7400: exists = true;
7401: for (int i = 0; i < jj_expentry.length; i++) {
7402: if (oldentry[i] != jj_expentry[i]) {
7403: exists = false;
7404: break;
7405: }
7406: }
7407: if (exists)
7408: break;
7409: }
7410: }
7411: if (!exists)
7412: jj_expentries.addElement(jj_expentry);
7413: if (pos != 0)
7414: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
7415: }
7416: }
7417:
7418: public ParseException generateParseException() {
7419: jj_expentries.removeAllElements();
7420: boolean[] la1tokens = new boolean[94];
7421: for (int i = 0; i < 94; i++) {
7422: la1tokens[i] = false;
7423: }
7424: if (jj_kind >= 0) {
7425: la1tokens[jj_kind] = true;
7426: jj_kind = -1;
7427: }
7428: for (int i = 0; i < 100; i++) {
7429: if (jj_la1[i] == jj_gen) {
7430: for (int j = 0; j < 32; j++) {
7431: if ((jj_la1_0[i] & (1 << j)) != 0) {
7432: la1tokens[j] = true;
7433: }
7434: if ((jj_la1_1[i] & (1 << j)) != 0) {
7435: la1tokens[32 + j] = true;
7436: }
7437: if ((jj_la1_2[i] & (1 << j)) != 0) {
7438: la1tokens[64 + j] = true;
7439: }
7440: }
7441: }
7442: }
7443: for (int i = 0; i < 94; i++) {
7444: if (la1tokens[i]) {
7445: jj_expentry = new int[1];
7446: jj_expentry[0] = i;
7447: jj_expentries.addElement(jj_expentry);
7448: }
7449: }
7450: jj_endpos = 0;
7451: jj_rescan_token();
7452: jj_add_error_token(0, 0);
7453: int[][] exptokseq = new int[jj_expentries.size()][];
7454: for (int i = 0; i < jj_expentries.size(); i++) {
7455: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
7456: }
7457: return new ParseException(token, exptokseq, tokenImage);
7458: }
7459:
7460: final public void enable_tracing() {
7461: }
7462:
7463: final public void disable_tracing() {
7464: }
7465:
7466: final private void jj_rescan_token() {
7467: jj_rescan = true;
7468: for (int i = 0; i < 45; i++) {
7469: JJCalls p = jj_2_rtns[i];
7470: do {
7471: if (p.gen > jj_gen) {
7472: jj_la = p.arg;
7473: jj_lastpos = jj_scanpos = p.first;
7474: switch (i) {
7475: case 0:
7476: jj_3_1();
7477: break;
7478: case 1:
7479: jj_3_2();
7480: break;
7481: case 2:
7482: jj_3_3();
7483: break;
7484: case 3:
7485: jj_3_4();
7486: break;
7487: case 4:
7488: jj_3_5();
7489: break;
7490: case 5:
7491: jj_3_6();
7492: break;
7493: case 6:
7494: jj_3_7();
7495: break;
7496: case 7:
7497: jj_3_8();
7498: break;
7499: case 8:
7500: jj_3_9();
7501: break;
7502: case 9:
7503: jj_3_10();
7504: break;
7505: case 10:
7506: jj_3_11();
7507: break;
7508: case 11:
7509: jj_3_12();
7510: break;
7511: case 12:
7512: jj_3_13();
7513: break;
7514: case 13:
7515: jj_3_14();
7516: break;
7517: case 14:
7518: jj_3_15();
7519: break;
7520: case 15:
7521: jj_3_16();
7522: break;
7523: case 16:
7524: jj_3_17();
7525: break;
7526: case 17:
7527: jj_3_18();
7528: break;
7529: case 18:
7530: jj_3_19();
7531: break;
7532: case 19:
7533: jj_3_20();
7534: break;
7535: case 20:
7536: jj_3_21();
7537: break;
7538: case 21:
7539: jj_3_22();
7540: break;
7541: case 22:
7542: jj_3_23();
7543: break;
7544: case 23:
7545: jj_3_24();
7546: break;
7547: case 24:
7548: jj_3_25();
7549: break;
7550: case 25:
7551: jj_3_26();
7552: break;
7553: case 26:
7554: jj_3_27();
7555: break;
7556: case 27:
7557: jj_3_28();
7558: break;
7559: case 28:
7560: jj_3_29();
7561: break;
7562: case 29:
7563: jj_3_30();
7564: break;
7565: case 30:
7566: jj_3_31();
7567: break;
7568: case 31:
7569: jj_3_32();
7570: break;
7571: case 32:
7572: jj_3_33();
7573: break;
7574: case 33:
7575: jj_3_34();
7576: break;
7577: case 34:
7578: jj_3_35();
7579: break;
7580: case 35:
7581: jj_3_36();
7582: break;
7583: case 36:
7584: jj_3_37();
7585: break;
7586: case 37:
7587: jj_3_38();
7588: break;
7589: case 38:
7590: jj_3_39();
7591: break;
7592: case 39:
7593: jj_3_40();
7594: break;
7595: case 40:
7596: jj_3_41();
7597: break;
7598: case 41:
7599: jj_3_42();
7600: break;
7601: case 42:
7602: jj_3_43();
7603: break;
7604: case 43:
7605: jj_3_44();
7606: break;
7607: case 44:
7608: jj_3_45();
7609: break;
7610: }
7611: }
7612: p = p.next;
7613: } while (p != null);
7614: }
7615: jj_rescan = false;
7616: }
7617:
7618: final private void jj_save(int index, int xla) {
7619: JJCalls p = jj_2_rtns[index];
7620: while (p.gen > jj_gen) {
7621: if (p.next == null) {
7622: p = p.next = new JJCalls();
7623: break;
7624: }
7625: p = p.next;
7626: }
7627: p.gen = jj_gen + xla - jj_la;
7628: p.first = token;
7629: p.arg = xla;
7630: }
7631:
7632: static final class JJCalls {
7633: int gen;
7634: Token first;
7635: int arg;
7636: JJCalls next;
7637: }
7638:
7639: }
|