0001: /* Generated By:JavaCC: Do not edit this line. EJBQLParser.java */
0002: package com.versant.core.ejb.query;
0003:
0004: public class EJBQLParser implements EJBQLParserConstants {
0005:
0006: public static void main(String[] args) {
0007: try {
0008: EJBQLParser parser = new EJBQLParser(System.in);
0009: System.out.println("Type some input and Ctrl-D to parse :");
0010: Node q = parser.ejbqlQuery();
0011: System.out.println("\nparser.ejbqlQuery():\n" + q);
0012: } catch (Exception x) {
0013: x.printStackTrace(System.out);
0014: System.exit(1);
0015: }
0016: }
0017:
0018: final public Node ejbqlQuery() throws ParseException {
0019: Node q;
0020: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0021: case SELECT:
0022: q = selectStatement();
0023: break;
0024: case UPDATE:
0025: q = updateStatement();
0026: break;
0027: case DELETE:
0028: q = deleteStatement();
0029: break;
0030: default:
0031: jj_la1[0] = jj_gen;
0032: jj_consume_token(-1);
0033: throw new ParseException();
0034: }
0035: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0036: case 0:
0037: jj_consume_token(0);
0038: break;
0039: case SEMICOLON:
0040: jj_consume_token(SEMICOLON);
0041: break;
0042: default:
0043: jj_la1[1] = jj_gen;
0044: jj_consume_token(-1);
0045: throw new ParseException();
0046: }
0047: {
0048: if (true)
0049: return q;
0050: }
0051: throw new Error("Missing return statement in function");
0052: }
0053:
0054: final public SelectNode selectStatement() throws ParseException {
0055: boolean distinct = false;
0056: Node selectList = null, fromList = null, orderBy = null, where = null;
0057: Node cur, prev;
0058: Node groupBy = null, having = null;
0059: jj_consume_token(SELECT);
0060: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0061: case DISTINCT:
0062: jj_consume_token(DISTINCT);
0063: distinct = true;
0064: break;
0065: default:
0066: jj_la1[2] = jj_gen;
0067: ;
0068: }
0069: selectList = selectExpression();
0070: prev = selectList;
0071: label_1: while (true) {
0072: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0073: case COMMA:
0074: ;
0075: break;
0076: default:
0077: jj_la1[3] = jj_gen;
0078: break label_1;
0079: }
0080: jj_consume_token(COMMA);
0081: cur = selectExpression();
0082: prev.setNext(cur);
0083: prev = cur;
0084: }
0085: fromList = fromClause();
0086: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0087: case WHERE:
0088: jj_consume_token(WHERE);
0089: where = conditionalExpression();
0090: break;
0091: default:
0092: jj_la1[4] = jj_gen;
0093: ;
0094: }
0095: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0096: case GROUP:
0097: groupBy = groupByClause();
0098: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0099: case HAVING:
0100: jj_consume_token(HAVING);
0101: having = conditionalExpression();
0102: break;
0103: default:
0104: jj_la1[5] = jj_gen;
0105: ;
0106: }
0107: break;
0108: default:
0109: jj_la1[6] = jj_gen;
0110: ;
0111: }
0112: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0113: case ORDER:
0114: orderBy = orderByClause();
0115: break;
0116: default:
0117: jj_la1[7] = jj_gen;
0118: ;
0119: }
0120: {
0121: if (true)
0122: return new SelectNode(distinct, selectList, fromList,
0123: where, groupBy, having, orderBy);
0124: }
0125: throw new Error("Missing return statement in function");
0126: }
0127:
0128: final public DeleteNode deleteStatement() throws ParseException {
0129: Token schemaName, id = null;
0130: SetNode updateList, prev, cur;
0131: Node where = null;
0132: jj_consume_token(DELETE);
0133: jj_consume_token(FROM);
0134: schemaName = jj_consume_token(IDENTIFIER);
0135: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0136: case AS:
0137: case IDENTIFIER:
0138: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0139: case AS:
0140: jj_consume_token(AS);
0141: break;
0142: default:
0143: jj_la1[8] = jj_gen;
0144: ;
0145: }
0146: id = jj_consume_token(IDENTIFIER);
0147: break;
0148: default:
0149: jj_la1[9] = jj_gen;
0150: ;
0151: }
0152: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0153: case WHERE:
0154: jj_consume_token(WHERE);
0155: where = conditionalExpression();
0156: break;
0157: default:
0158: jj_la1[10] = jj_gen;
0159: ;
0160: }
0161: {
0162: if (true)
0163: return new DeleteNode(schemaName.image,
0164: id == null ? null : id.image, where);
0165: }
0166: throw new Error("Missing return statement in function");
0167: }
0168:
0169: final public UpdateNode updateStatement() throws ParseException {
0170: Token schemaName, id = null;
0171: SetNode updateList, prev, cur;
0172: Node where = null;
0173: jj_consume_token(UPDATE);
0174: schemaName = jj_consume_token(IDENTIFIER);
0175: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0176: case AS:
0177: case IDENTIFIER:
0178: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0179: case AS:
0180: jj_consume_token(AS);
0181: break;
0182: default:
0183: jj_la1[11] = jj_gen;
0184: ;
0185: }
0186: id = jj_consume_token(IDENTIFIER);
0187: break;
0188: default:
0189: jj_la1[12] = jj_gen;
0190: ;
0191: }
0192: jj_consume_token(SET);
0193: updateList = updateExpression();
0194: prev = updateList;
0195: label_2: while (true) {
0196: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0197: case COMMA:
0198: ;
0199: break;
0200: default:
0201: jj_la1[13] = jj_gen;
0202: break label_2;
0203: }
0204: jj_consume_token(COMMA);
0205: cur = updateExpression();
0206: prev.setNext(cur);
0207: prev = cur;
0208: }
0209: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0210: case WHERE:
0211: jj_consume_token(WHERE);
0212: where = conditionalExpression();
0213: break;
0214: default:
0215: jj_la1[14] = jj_gen;
0216: ;
0217: }
0218: {
0219: if (true)
0220: return new UpdateNode(schemaName.image,
0221: id == null ? null : id.image, updateList, where);
0222: }
0223: throw new Error("Missing return statement in function");
0224: }
0225:
0226: final public SetNode updateExpression() throws ParseException {
0227: Token id = null, field;
0228: Node value;
0229: if (jj_2_1(2)) {
0230: id = jj_consume_token(IDENTIFIER);
0231: jj_consume_token(DOT);
0232: } else {
0233: ;
0234: }
0235: field = jj_consume_token(IDENTIFIER);
0236: jj_consume_token(EQ);
0237: value = expression();
0238: {
0239: if (true)
0240: return new SetNode(id == null ? null : id.image,
0241: field.image, value);
0242: }
0243: throw new Error("Missing return statement in function");
0244: }
0245:
0246: final public Node fromClause() throws ParseException {
0247: Node fromList = null, cur, prev;
0248: jj_consume_token(FROM);
0249: fromList = identificationVarDeclaration();
0250: prev = fromList;
0251: label_3: while (true) {
0252: if (jj_2_2(2)) {
0253: ;
0254: } else {
0255: break label_3;
0256: }
0257: jj_consume_token(COMMA);
0258: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0259: case IDENTIFIER:
0260: cur = identificationVarDeclaration();
0261: break;
0262: case IN:
0263: cur = collectionMemberDeclaration();
0264: break;
0265: default:
0266: jj_la1[15] = jj_gen;
0267: jj_consume_token(-1);
0268: throw new ParseException();
0269: }
0270: prev.setNext(cur);
0271: prev = cur;
0272: }
0273: {
0274: if (true)
0275: return fromList;
0276: }
0277: throw new Error("Missing return statement in function");
0278: }
0279:
0280: final public Node orderByClause() throws ParseException {
0281: Node list = null, cur, prev;
0282: jj_consume_token(ORDER);
0283: jj_consume_token(BY);
0284: list = pathExpression(PathNode.ORDER_BY);
0285: prev = list;
0286: label_4: while (true) {
0287: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0288: case COMMA:
0289: ;
0290: break;
0291: default:
0292: jj_la1[16] = jj_gen;
0293: break label_4;
0294: }
0295: jj_consume_token(COMMA);
0296: cur = pathExpression(PathNode.ORDER_BY);
0297: prev.setNext(cur);
0298: prev = cur;
0299: }
0300: {
0301: if (true)
0302: return list;
0303: }
0304: throw new Error("Missing return statement in function");
0305: }
0306:
0307: final public Node groupByClause() throws ParseException {
0308: Node list = null, cur, prev;
0309: jj_consume_token(GROUP);
0310: jj_consume_token(BY);
0311: list = pathExpression(PathNode.GROUP_BY);
0312: prev = list;
0313: label_5: while (true) {
0314: if (jj_2_3(2)) {
0315: ;
0316: } else {
0317: break label_5;
0318: }
0319: jj_consume_token(COMMA);
0320: cur = pathExpression(PathNode.GROUP_BY);
0321: prev.setNext(cur);
0322: prev = cur;
0323: }
0324: {
0325: if (true)
0326: return list;
0327: }
0328: throw new Error("Missing return statement in function");
0329: }
0330:
0331: final public Node selectExpression() throws ParseException {
0332: Node e;
0333: Token t;
0334: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0335: case IDENTIFIER:
0336: e = pathExpression(PathNode.SELECT);
0337: break;
0338: case OBJECT:
0339: jj_consume_token(OBJECT);
0340: jj_consume_token(LPAREN);
0341: t = jj_consume_token(IDENTIFIER);
0342: jj_consume_token(RPAREN);
0343: e = new ObjectNode(t.image);
0344: break;
0345: case AVG:
0346: case MAX:
0347: case MIN:
0348: case SUM:
0349: case COUNT:
0350: e = aggregateSelectExpression();
0351: break;
0352: case NEW:
0353: e = constructorExpression();
0354: break;
0355: default:
0356: jj_la1[17] = jj_gen;
0357: jj_consume_token(-1);
0358: throw new ParseException();
0359: }
0360: {
0361: if (true)
0362: return e;
0363: }
0364: throw new Error("Missing return statement in function");
0365: }
0366:
0367: final public PathNode pathExpression(int parentType)
0368: throws ParseException {
0369: PathNode e = new PathNode(parentType);
0370: Token t;
0371: t = jj_consume_token(IDENTIFIER);
0372: e.add(t.image);
0373: label_6: while (true) {
0374: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0375: case DOT:
0376: ;
0377: break;
0378: default:
0379: jj_la1[18] = jj_gen;
0380: break label_6;
0381: }
0382: jj_consume_token(DOT);
0383: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0384: case IDENTIFIER:
0385: t = jj_consume_token(IDENTIFIER);
0386: break;
0387: case SELECT:
0388: case FROM:
0389: case DISTINCT:
0390: case OBJECT:
0391: case LEFT:
0392: case OUTER:
0393: case INNER:
0394: case JOIN:
0395: case FETCH:
0396: case IN:
0397: case AS:
0398: case UPDATE:
0399: case SET:
0400: case DELETE:
0401: case NEW:
0402: case AVG:
0403: case MAX:
0404: case MIN:
0405: case SUM:
0406: case COUNT:
0407: case WHERE:
0408: case GROUP:
0409: case BY:
0410: case HAVING:
0411: case OR:
0412: case AND:
0413: case NOT:
0414: case BETWEEN:
0415: case LIKE:
0416: case ESCAPE:
0417: case IS:
0418: case EMPTY:
0419: case MEMBER:
0420: case OF:
0421: case EXISTS:
0422: case ALL:
0423: case ANY:
0424: case SOME:
0425: case CONCAT:
0426: case SUBSTRING:
0427: case TRIM:
0428: case LOWER:
0429: case UPPER:
0430: case LEADING:
0431: case TRAILING:
0432: case BOTH:
0433: case LENGTH:
0434: case LOCATE:
0435: case ABS:
0436: case SQRT:
0437: case MOD:
0438: case BIT_LENGTH:
0439: case CURRENT_DATE:
0440: case CURRENT_TIME:
0441: case CURRENT_TIMESTAMP:
0442: case ORDER:
0443: case ASC:
0444: case DESC:
0445: t = reservedWord();
0446: break;
0447: default:
0448: jj_la1[19] = jj_gen;
0449: jj_consume_token(-1);
0450: throw new ParseException();
0451: }
0452: e.add(t.image);
0453: }
0454: {
0455: if (true)
0456: return e;
0457: }
0458: throw new Error("Missing return statement in function");
0459: }
0460:
0461: final public AggregateNode aggregateSelectExpression()
0462: throws ParseException {
0463: int op;
0464: boolean distinct = false;
0465: PathNode path;
0466: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0467: case AVG:
0468: jj_consume_token(AVG);
0469: op = AggregateNode.AVG;
0470: break;
0471: case MAX:
0472: jj_consume_token(MAX);
0473: op = AggregateNode.MAX;
0474: break;
0475: case MIN:
0476: jj_consume_token(MIN);
0477: op = AggregateNode.MIN;
0478: break;
0479: case SUM:
0480: jj_consume_token(SUM);
0481: op = AggregateNode.SUM;
0482: break;
0483: case COUNT:
0484: jj_consume_token(COUNT);
0485: op = AggregateNode.COUNT;
0486: break;
0487: default:
0488: jj_la1[20] = jj_gen;
0489: jj_consume_token(-1);
0490: throw new ParseException();
0491: }
0492: jj_consume_token(LPAREN);
0493: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0494: case DISTINCT:
0495: jj_consume_token(DISTINCT);
0496: distinct = true;
0497: break;
0498: default:
0499: jj_la1[21] = jj_gen;
0500: ;
0501: }
0502: path = pathExpression(PathNode.AGGREGATE);
0503: jj_consume_token(RPAREN);
0504: {
0505: if (true)
0506: return new AggregateNode(op, distinct, path);
0507: }
0508: throw new Error("Missing return statement in function");
0509: }
0510:
0511: final public ConstructorNode constructorExpression()
0512: throws ParseException {
0513: Token t;
0514: ConstructorNode e;
0515: Node cur, prev;
0516: jj_consume_token(NEW);
0517: t = jj_consume_token(IDENTIFIER);
0518: jj_consume_token(LPAREN);
0519: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0520: case IDENTIFIER:
0521: prev = pathExpression(PathNode.CONSTRUCTOR);
0522: break;
0523: case AVG:
0524: case MAX:
0525: case MIN:
0526: case SUM:
0527: case COUNT:
0528: prev = aggregateSelectExpression();
0529: break;
0530: default:
0531: jj_la1[22] = jj_gen;
0532: jj_consume_token(-1);
0533: throw new ParseException();
0534: }
0535: e = new ConstructorNode(t.image, prev);
0536: label_7: while (true) {
0537: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0538: case COMMA:
0539: ;
0540: break;
0541: default:
0542: jj_la1[23] = jj_gen;
0543: break label_7;
0544: }
0545: jj_consume_token(COMMA);
0546: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0547: case IDENTIFIER:
0548: cur = pathExpression(PathNode.CONSTRUCTOR);
0549: break;
0550: case AVG:
0551: case MAX:
0552: case MIN:
0553: case SUM:
0554: case COUNT:
0555: cur = aggregateSelectExpression();
0556: break;
0557: default:
0558: jj_la1[24] = jj_gen;
0559: jj_consume_token(-1);
0560: throw new ParseException();
0561: }
0562: prev.setNext(cur);
0563: prev = cur;
0564: }
0565: jj_consume_token(RPAREN);
0566: {
0567: if (true)
0568: return e;
0569: }
0570: throw new Error("Missing return statement in function");
0571: }
0572:
0573: final public IdentificationVarNode identificationVarDeclaration()
0574: throws ParseException {
0575: Token t, t2;
0576: JoinNode list = null, prev = null, cur;
0577: t = jj_consume_token(IDENTIFIER);
0578: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0579: case AS:
0580: jj_consume_token(AS);
0581: break;
0582: default:
0583: jj_la1[25] = jj_gen;
0584: ;
0585: }
0586: t2 = jj_consume_token(IDENTIFIER);
0587: label_8: while (true) {
0588: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0589: case LEFT:
0590: case INNER:
0591: case JOIN:
0592: ;
0593: break;
0594: default:
0595: jj_la1[26] = jj_gen;
0596: break label_8;
0597: }
0598: cur = join();
0599: if (list == null) {
0600: list = prev = cur;
0601: } else {
0602: prev.setNext(cur);
0603: prev = cur;
0604: }
0605: }
0606: {
0607: if (true)
0608: return new IdentificationVarNode(t.image, t2.image,
0609: list);
0610: }
0611: throw new Error("Missing return statement in function");
0612: }
0613:
0614: final public JoinNode join() throws ParseException {
0615: boolean outer = false;
0616: PathNode path;
0617: Token t = null;
0618: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0619: case LEFT:
0620: case INNER:
0621: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0622: case LEFT:
0623: jj_consume_token(LEFT);
0624: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0625: case OUTER:
0626: jj_consume_token(OUTER);
0627: break;
0628: default:
0629: jj_la1[27] = jj_gen;
0630: ;
0631: }
0632: outer = true;
0633: break;
0634: case INNER:
0635: jj_consume_token(INNER);
0636: break;
0637: default:
0638: jj_la1[28] = jj_gen;
0639: jj_consume_token(-1);
0640: throw new ParseException();
0641: }
0642: break;
0643: default:
0644: jj_la1[29] = jj_gen;
0645: ;
0646: }
0647: jj_consume_token(JOIN);
0648: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0649: case FETCH:
0650: jj_consume_token(FETCH);
0651: path = pathExpression(PathNode.JOIN);
0652: break;
0653: case IDENTIFIER:
0654: path = pathExpression(PathNode.JOIN);
0655: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0656: case AS:
0657: jj_consume_token(AS);
0658: break;
0659: default:
0660: jj_la1[30] = jj_gen;
0661: ;
0662: }
0663: t = jj_consume_token(IDENTIFIER);
0664: break;
0665: default:
0666: jj_la1[31] = jj_gen;
0667: jj_consume_token(-1);
0668: throw new ParseException();
0669: }
0670: {
0671: if (true)
0672: return new JoinNode(outer, t == null, path,
0673: t == null ? null : t.image);
0674: }
0675: throw new Error("Missing return statement in function");
0676: }
0677:
0678: final public CollectionMemberNode collectionMemberDeclaration()
0679: throws ParseException {
0680: PathNode path;
0681: Token t;
0682: jj_consume_token(IN);
0683: jj_consume_token(LPAREN);
0684: path = pathExpression(PathNode.COLLECTION_MEMBER);
0685: jj_consume_token(RPAREN);
0686: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0687: case AS:
0688: jj_consume_token(AS);
0689: break;
0690: default:
0691: jj_la1[32] = jj_gen;
0692: ;
0693: }
0694: t = jj_consume_token(IDENTIFIER);
0695: {
0696: if (true)
0697: return new CollectionMemberNode(path, t.image);
0698: }
0699: throw new Error("Missing return statement in function");
0700: }
0701:
0702: final public Node conditionalExpression() throws ParseException {
0703: Node e, e2;
0704: e = conditionalTerm();
0705: if (jj_2_4(2)) {
0706: jj_consume_token(OR);
0707: e2 = conditionalExpression();
0708: e.setNext(e2);
0709: e = new OrNode(e);
0710: } else {
0711: ;
0712: }
0713: {
0714: if (true)
0715: return e;
0716: }
0717: throw new Error("Missing return statement in function");
0718: }
0719:
0720: final public Node conditionalTerm() throws ParseException {
0721: Node e, e2;
0722: e = conditionalFactor();
0723: if (jj_2_5(2)) {
0724: jj_consume_token(AND);
0725: e2 = conditionalTerm();
0726: e.setNext(e2);
0727: e = new AndNode(e);
0728: } else {
0729: ;
0730: }
0731: {
0732: if (true)
0733: return e;
0734: }
0735: throw new Error("Missing return statement in function");
0736: }
0737:
0738: final public Node conditionalFactor() throws ParseException {
0739: Node e;
0740: boolean not = false;
0741: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0742: case NOT:
0743: jj_consume_token(NOT);
0744: not = true;
0745: break;
0746: default:
0747: jj_la1[33] = jj_gen;
0748: ;
0749: }
0750: if (jj_2_6(2)) {
0751: e = simpleCondExpression();
0752: } else {
0753: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0754: case LPAREN:
0755: jj_consume_token(LPAREN);
0756: e = conditionalExpression();
0757: jj_consume_token(RPAREN);
0758: e = new ParenNode(e);
0759: break;
0760: default:
0761: jj_la1[34] = jj_gen;
0762: jj_consume_token(-1);
0763: throw new ParseException();
0764: }
0765: }
0766: {
0767: if (true)
0768: return not ? new NotNode(e) : e;
0769: }
0770: throw new Error("Missing return statement in function");
0771: }
0772:
0773: final public Node simpleCondExpression() throws ParseException {
0774: Node left, e;
0775: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0776: case LPAREN:
0777: case QUESTION:
0778: case COLON:
0779: case CONCAT:
0780: case SUBSTRING:
0781: case TRIM:
0782: case LOWER:
0783: case UPPER:
0784: case LENGTH:
0785: case LOCATE:
0786: case ABS:
0787: case SQRT:
0788: case MOD:
0789: case BIT_LENGTH:
0790: case CURRENT_DATE:
0791: case CURRENT_TIME:
0792: case CURRENT_TIMESTAMP:
0793: case DECIMAL_LITERAL:
0794: case HEX_LITERAL:
0795: case FLOATING_POINT_LITERAL:
0796: case CHARACTER_LITERAL:
0797: case BOOLEAN_LITERAL:
0798: case STRING_LITERAL:
0799: case IDENTIFIER:
0800: case 93:
0801: case 94:
0802: left = expression();
0803: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0804: case EQ:
0805: case LT:
0806: case LE:
0807: case GT:
0808: case GE:
0809: case NE:
0810: e = compExpression(left);
0811: break;
0812: default:
0813: jj_la1[35] = jj_gen;
0814: if (jj_2_7(2)) {
0815: e = betweenExpression(left);
0816: } else if (jj_2_8(2)) {
0817: e = likeExpression(left);
0818: } else if (jj_2_9(2)) {
0819: e = inExpression(left);
0820: } else {
0821: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0822: case MEMBER:
0823: e = memberCompExpression(left);
0824: break;
0825: default:
0826: jj_la1[36] = jj_gen;
0827: if (jj_2_10(3)) {
0828: e = emptyCompExpression(left);
0829: } else {
0830: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0831: case IS:
0832: e = nullCompExpression(left);
0833: break;
0834: default:
0835: jj_la1[37] = jj_gen;
0836: jj_consume_token(-1);
0837: throw new ParseException();
0838: }
0839: }
0840: }
0841: }
0842: }
0843: break;
0844: case EXISTS:
0845: e = existsExpression();
0846: break;
0847: default:
0848: jj_la1[38] = jj_gen;
0849: jj_consume_token(-1);
0850: throw new ParseException();
0851: }
0852: {
0853: if (true)
0854: return e;
0855: }
0856: throw new Error("Missing return statement in function");
0857: }
0858:
0859: final public Node betweenExpression(Node arg) throws ParseException {
0860: Node from, to;
0861: boolean not = false;
0862: jj_consume_token(BETWEEN);
0863: from = expression();
0864: jj_consume_token(AND);
0865: to = expression();
0866: {
0867: if (true)
0868: return new BetweenNode(arg, not, from, to);
0869: }
0870: throw new Error("Missing return statement in function");
0871: }
0872:
0873: final public Node inExpression(Node path) throws ParseException {
0874: boolean not = false;
0875: Node list;
0876: jj_consume_token(IN);
0877: jj_consume_token(LPAREN);
0878: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0879: case SELECT:
0880: list = subquery();
0881: break;
0882: case QUESTION:
0883: case COLON:
0884: case DECIMAL_LITERAL:
0885: case HEX_LITERAL:
0886: case FLOATING_POINT_LITERAL:
0887: case CHARACTER_LITERAL:
0888: case BOOLEAN_LITERAL:
0889: case STRING_LITERAL:
0890: list = inList();
0891: break;
0892: default:
0893: jj_la1[39] = jj_gen;
0894: jj_consume_token(-1);
0895: throw new ParseException();
0896: }
0897: jj_consume_token(RPAREN);
0898: {
0899: if (true)
0900: return new InNode(path, not, list);
0901: }
0902: throw new Error("Missing return statement in function");
0903: }
0904:
0905: final public Node inList() throws ParseException {
0906: Node list = null, prev = null, cur;
0907: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0908: case DECIMAL_LITERAL:
0909: case HEX_LITERAL:
0910: case FLOATING_POINT_LITERAL:
0911: case CHARACTER_LITERAL:
0912: case BOOLEAN_LITERAL:
0913: case STRING_LITERAL:
0914: cur = literal();
0915: break;
0916: case QUESTION:
0917: case COLON:
0918: cur = inputParameter();
0919: break;
0920: default:
0921: jj_la1[40] = jj_gen;
0922: jj_consume_token(-1);
0923: throw new ParseException();
0924: }
0925: list = prev = cur;
0926: label_9: while (true) {
0927: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0928: case COMMA:
0929: ;
0930: break;
0931: default:
0932: jj_la1[41] = jj_gen;
0933: break label_9;
0934: }
0935: jj_consume_token(COMMA);
0936: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0937: case DECIMAL_LITERAL:
0938: case HEX_LITERAL:
0939: case FLOATING_POINT_LITERAL:
0940: case CHARACTER_LITERAL:
0941: case BOOLEAN_LITERAL:
0942: case STRING_LITERAL:
0943: cur = literal();
0944: break;
0945: case QUESTION:
0946: case COLON:
0947: cur = inputParameter();
0948: break;
0949: default:
0950: jj_la1[42] = jj_gen;
0951: jj_consume_token(-1);
0952: throw new ParseException();
0953: }
0954: prev.setNext(cur);
0955: prev = cur;
0956: }
0957: {
0958: if (true)
0959: return list;
0960: }
0961: throw new Error("Missing return statement in function");
0962: }
0963:
0964: final public LiteralNode literal() throws ParseException {
0965: LiteralNode e;
0966: Token t;
0967: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0968: case DECIMAL_LITERAL:
0969: t = jj_consume_token(DECIMAL_LITERAL);
0970: e = new LiteralNode(LiteralNode.LONG, t.image);
0971: break;
0972: case HEX_LITERAL:
0973: t = jj_consume_token(HEX_LITERAL);
0974: e = new LiteralNode(LiteralNode.LONG, t.image);
0975: break;
0976: case FLOATING_POINT_LITERAL:
0977: t = jj_consume_token(FLOATING_POINT_LITERAL);
0978: e = new LiteralNode(LiteralNode.DOUBLE, t.image);
0979: break;
0980: case CHARACTER_LITERAL:
0981: t = jj_consume_token(CHARACTER_LITERAL);
0982: e = new LiteralNode(LiteralNode.STRING, t.image);
0983: break;
0984: case STRING_LITERAL:
0985: t = jj_consume_token(STRING_LITERAL);
0986: e = new LiteralNode(LiteralNode.STRING, t.image);
0987: break;
0988: case BOOLEAN_LITERAL:
0989: t = jj_consume_token(BOOLEAN_LITERAL);
0990: e = new LiteralNode(LiteralNode.BOOLEAN, t.image);
0991: break;
0992: default:
0993: jj_la1[43] = jj_gen;
0994: jj_consume_token(-1);
0995: throw new ParseException();
0996: }
0997: {
0998: if (true)
0999: return e;
1000: }
1001: throw new Error("Missing return statement in function");
1002: }
1003:
1004: final public ParameterNode inputParameter() throws ParseException {
1005: Token t;
1006: boolean positional = false;
1007: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1008: case QUESTION:
1009: jj_consume_token(QUESTION);
1010: t = jj_consume_token(DECIMAL_LITERAL);
1011: positional = true;
1012: break;
1013: case COLON:
1014: jj_consume_token(COLON);
1015: t = jj_consume_token(IDENTIFIER);
1016: break;
1017: default:
1018: jj_la1[44] = jj_gen;
1019: jj_consume_token(-1);
1020: throw new ParseException();
1021: }
1022: {
1023: if (true)
1024: return new ParameterNode(positional, t.image);
1025: }
1026: throw new Error("Missing return statement in function");
1027: }
1028:
1029: final public LikeNode likeExpression(Node path)
1030: throws ParseException {
1031: boolean not = false;
1032: Node pattern, escape = null;
1033: jj_consume_token(LIKE);
1034: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1035: case DECIMAL_LITERAL:
1036: case HEX_LITERAL:
1037: case FLOATING_POINT_LITERAL:
1038: case CHARACTER_LITERAL:
1039: case BOOLEAN_LITERAL:
1040: case STRING_LITERAL:
1041: pattern = literal();
1042: break;
1043: case QUESTION:
1044: case COLON:
1045: pattern = inputParameter();
1046: break;
1047: default:
1048: jj_la1[45] = jj_gen;
1049: jj_consume_token(-1);
1050: throw new ParseException();
1051: }
1052: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1053: case ESCAPE:
1054: jj_consume_token(ESCAPE);
1055: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1056: case DECIMAL_LITERAL:
1057: case HEX_LITERAL:
1058: case FLOATING_POINT_LITERAL:
1059: case CHARACTER_LITERAL:
1060: case BOOLEAN_LITERAL:
1061: case STRING_LITERAL:
1062: escape = literal();
1063: break;
1064: case QUESTION:
1065: case COLON:
1066: escape = inputParameter();
1067: break;
1068: default:
1069: jj_la1[46] = jj_gen;
1070: jj_consume_token(-1);
1071: throw new ParseException();
1072: }
1073: break;
1074: default:
1075: jj_la1[47] = jj_gen;
1076: ;
1077: }
1078: {
1079: if (true)
1080: return new LikeNode(path, not, pattern, escape);
1081: }
1082: throw new Error("Missing return statement in function");
1083: }
1084:
1085: final public NullCompNode nullCompExpression(Node arg)
1086: throws ParseException {
1087: boolean not = false;
1088: jj_consume_token(IS);
1089: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1090: case NOT:
1091: jj_consume_token(NOT);
1092: not = true;
1093: break;
1094: default:
1095: jj_la1[48] = jj_gen;
1096: ;
1097: }
1098: jj_consume_token(NULL);
1099: {
1100: if (true)
1101: return new NullCompNode(arg, not);
1102: }
1103: throw new Error("Missing return statement in function");
1104: }
1105:
1106: final public EmptyCompNode emptyCompExpression(Node path)
1107: throws ParseException {
1108: boolean not = false;
1109: jj_consume_token(IS);
1110: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1111: case NOT:
1112: jj_consume_token(NOT);
1113: not = true;
1114: break;
1115: default:
1116: jj_la1[49] = jj_gen;
1117: ;
1118: }
1119: jj_consume_token(EMPTY);
1120: {
1121: if (true)
1122: return new EmptyCompNode(path, not);
1123: }
1124: throw new Error("Missing return statement in function");
1125: }
1126:
1127: final public MemberCompNode memberCompExpression(Node arg)
1128: throws ParseException {
1129: boolean not = false;
1130: PathNode path;
1131: jj_consume_token(MEMBER);
1132: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1133: case OF:
1134: jj_consume_token(OF);
1135: break;
1136: default:
1137: jj_la1[50] = jj_gen;
1138: ;
1139: }
1140: path = pathExpression(PathNode.WHERE);
1141: {
1142: if (true)
1143: return new MemberCompNode(arg, not, path);
1144: }
1145: throw new Error("Missing return statement in function");
1146: }
1147:
1148: final public ExistsNode existsExpression() throws ParseException {
1149: boolean not = false;
1150: SelectNode sub;
1151: jj_consume_token(EXISTS);
1152: jj_consume_token(LPAREN);
1153: sub = subquery();
1154: jj_consume_token(RPAREN);
1155: {
1156: if (true)
1157: return new ExistsNode(not, sub);
1158: }
1159: throw new Error("Missing return statement in function");
1160: }
1161:
1162: final public SelectNode subquery() throws ParseException {
1163: boolean distinct = false;
1164: Node selectList = null, fromList = null, where = null, groupBy = null;
1165: Node having = null;
1166: jj_consume_token(SELECT);
1167: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1168: case DISTINCT:
1169: jj_consume_token(DISTINCT);
1170: distinct = true;
1171: break;
1172: default:
1173: jj_la1[51] = jj_gen;
1174: ;
1175: }
1176: selectList = selectExpression();
1177: fromList = fromClause();
1178: if (jj_2_11(2)) {
1179: jj_consume_token(WHERE);
1180: where = conditionalExpression();
1181: } else {
1182: ;
1183: }
1184: if (jj_2_12(2)) {
1185: groupBy = groupByClause();
1186: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1187: case HAVING:
1188: jj_consume_token(HAVING);
1189: having = conditionalExpression();
1190: break;
1191: default:
1192: jj_la1[52] = jj_gen;
1193: ;
1194: }
1195: } else {
1196: ;
1197: }
1198: {
1199: if (true)
1200: return new SelectNode(distinct, selectList, fromList,
1201: where, groupBy, having, null);
1202: }
1203: throw new Error("Missing return statement in function");
1204: }
1205:
1206: final public AllOrAnyNode allOrAnyExpression()
1207: throws ParseException {
1208: boolean all = false;
1209: SelectNode sub;
1210: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1211: case ALL:
1212: jj_consume_token(ALL);
1213: all = true;
1214: break;
1215: case ANY:
1216: jj_consume_token(ANY);
1217: break;
1218: case SOME:
1219: jj_consume_token(SOME);
1220: break;
1221: default:
1222: jj_la1[53] = jj_gen;
1223: jj_consume_token(-1);
1224: throw new ParseException();
1225: }
1226: jj_consume_token(LPAREN);
1227: sub = subquery();
1228: jj_consume_token(RPAREN);
1229: {
1230: if (true)
1231: return new AllOrAnyNode(all, sub);
1232: }
1233: throw new Error("Missing return statement in function");
1234: }
1235:
1236: final public Node compExpression(Node left) throws ParseException {
1237: Node right;
1238: int op;
1239: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1240: case EQ:
1241: jj_consume_token(EQ);
1242: op = CompNode.EQ;
1243: break;
1244: case LT:
1245: jj_consume_token(LT);
1246: op = CompNode.LT;
1247: break;
1248: case LE:
1249: jj_consume_token(LE);
1250: op = CompNode.LE;
1251: break;
1252: case GT:
1253: jj_consume_token(GT);
1254: op = CompNode.GT;
1255: break;
1256: case GE:
1257: jj_consume_token(GE);
1258: op = CompNode.GE;
1259: break;
1260: case NE:
1261: jj_consume_token(NE);
1262: op = CompNode.NE;
1263: break;
1264: default:
1265: jj_la1[54] = jj_gen;
1266: jj_consume_token(-1);
1267: throw new ParseException();
1268: }
1269: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1270: case LPAREN:
1271: case QUESTION:
1272: case COLON:
1273: case CONCAT:
1274: case SUBSTRING:
1275: case TRIM:
1276: case LOWER:
1277: case UPPER:
1278: case LENGTH:
1279: case LOCATE:
1280: case ABS:
1281: case SQRT:
1282: case MOD:
1283: case BIT_LENGTH:
1284: case CURRENT_DATE:
1285: case CURRENT_TIME:
1286: case CURRENT_TIMESTAMP:
1287: case DECIMAL_LITERAL:
1288: case HEX_LITERAL:
1289: case FLOATING_POINT_LITERAL:
1290: case CHARACTER_LITERAL:
1291: case BOOLEAN_LITERAL:
1292: case STRING_LITERAL:
1293: case IDENTIFIER:
1294: case 93:
1295: case 94:
1296: right = expression();
1297: break;
1298: case ALL:
1299: case ANY:
1300: case SOME:
1301: right = allOrAnyExpression();
1302: break;
1303: default:
1304: jj_la1[55] = jj_gen;
1305: jj_consume_token(-1);
1306: throw new ParseException();
1307: }
1308: {
1309: if (true)
1310: return new CompNode(left, op, right);
1311: }
1312: throw new Error("Missing return statement in function");
1313: }
1314:
1315: final public Node expression() throws ParseException {
1316: Node left, right;
1317: int op;
1318: left = term();
1319: if (jj_2_13(2)) {
1320: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1321: case 93:
1322: jj_consume_token(93);
1323: op = AddNode.ADD;
1324: break;
1325: case 94:
1326: jj_consume_token(94);
1327: op = AddNode.SUBTRACT;
1328: break;
1329: default:
1330: jj_la1[56] = jj_gen;
1331: jj_consume_token(-1);
1332: throw new ParseException();
1333: }
1334: right = expression();
1335: left = new AddNode(left, op, right);
1336: } else {
1337: ;
1338: }
1339: {
1340: if (true)
1341: return left;
1342: }
1343: throw new Error("Missing return statement in function");
1344: }
1345:
1346: final public Node term() throws ParseException {
1347: Node left, right;
1348: int op;
1349: left = factor();
1350: if (jj_2_14(2)) {
1351: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1352: case 95:
1353: jj_consume_token(95);
1354: op = MultiplyNode.MULTIPLY;
1355: break;
1356: case 96:
1357: jj_consume_token(96);
1358: op = MultiplyNode.DIVIDE;
1359: break;
1360: default:
1361: jj_la1[57] = jj_gen;
1362: jj_consume_token(-1);
1363: throw new ParseException();
1364: }
1365: right = term();
1366: left = new MultiplyNode(left, op, right);
1367: } else {
1368: ;
1369: }
1370: {
1371: if (true)
1372: return left;
1373: }
1374: throw new Error("Missing return statement in function");
1375: }
1376:
1377: final public Node factor() throws ParseException {
1378: boolean neg = false;
1379: Node e;
1380: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1381: case 93:
1382: case 94:
1383: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1384: case 93:
1385: jj_consume_token(93);
1386: break;
1387: case 94:
1388: jj_consume_token(94);
1389: neg = true;
1390: break;
1391: default:
1392: jj_la1[58] = jj_gen;
1393: jj_consume_token(-1);
1394: throw new ParseException();
1395: }
1396: break;
1397: default:
1398: jj_la1[59] = jj_gen;
1399: ;
1400: }
1401: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1402: case IDENTIFIER:
1403: e = pathExpression(PathNode.WHERE);
1404: break;
1405: case DECIMAL_LITERAL:
1406: case HEX_LITERAL:
1407: case FLOATING_POINT_LITERAL:
1408: case CHARACTER_LITERAL:
1409: case BOOLEAN_LITERAL:
1410: case STRING_LITERAL:
1411: e = literal();
1412: break;
1413: case LPAREN:
1414: jj_consume_token(LPAREN);
1415: e = subquery();
1416: jj_consume_token(RPAREN);
1417: break;
1418: case QUESTION:
1419: case COLON:
1420: e = inputParameter();
1421: break;
1422: case LENGTH:
1423: case LOCATE:
1424: case ABS:
1425: case SQRT:
1426: case MOD:
1427: case BIT_LENGTH:
1428: e = numericFunction();
1429: break;
1430: case CONCAT:
1431: case SUBSTRING:
1432: case TRIM:
1433: case LOWER:
1434: case UPPER:
1435: e = stringFunction();
1436: break;
1437: case CURRENT_DATE:
1438: case CURRENT_TIME:
1439: case CURRENT_TIMESTAMP:
1440: e = dateFunction();
1441: break;
1442: default:
1443: jj_la1[60] = jj_gen;
1444: jj_consume_token(-1);
1445: throw new ParseException();
1446: }
1447: {
1448: if (true)
1449: return neg ? new UnaryMinusNode(e) : e;
1450: }
1451: throw new Error("Missing return statement in function");
1452: }
1453:
1454: final public StringFunctionNode stringFunction()
1455: throws ParseException {
1456: Node arg1, arg2, arg3;
1457: int trimSpec = 0;
1458: LiteralNode trimChar = null;
1459: StringFunctionNode f;
1460: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1461: case CONCAT:
1462: jj_consume_token(CONCAT);
1463: jj_consume_token(LPAREN);
1464: arg1 = expression();
1465: jj_consume_token(COMMA);
1466: arg2 = expression();
1467: arg1.setNext(arg2);
1468: f = new StringFunctionNode(StringFunctionNode.CONCAT, arg1);
1469: break;
1470: case SUBSTRING:
1471: jj_consume_token(SUBSTRING);
1472: jj_consume_token(LPAREN);
1473: arg1 = expression();
1474: jj_consume_token(COMMA);
1475: arg2 = expression();
1476: arg1.setNext(arg2);
1477: jj_consume_token(COMMA);
1478: arg3 = expression();
1479: arg2.setNext(arg3);
1480: f = new StringFunctionNode(StringFunctionNode.SUBSTRING,
1481: arg1);
1482: break;
1483: case LOWER:
1484: jj_consume_token(LOWER);
1485: jj_consume_token(LPAREN);
1486: arg1 = expression();
1487: f = new StringFunctionNode(StringFunctionNode.LOWER, arg1);
1488: break;
1489: case UPPER:
1490: jj_consume_token(UPPER);
1491: jj_consume_token(LPAREN);
1492: arg1 = expression();
1493: f = new StringFunctionNode(StringFunctionNode.UPPER, arg1);
1494: break;
1495: case TRIM:
1496: jj_consume_token(TRIM);
1497: jj_consume_token(LPAREN);
1498: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1499: case LEADING:
1500: case TRAILING:
1501: case BOTH:
1502: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1503: case LEADING:
1504: jj_consume_token(LEADING);
1505: trimSpec = StringFunctionNode.TRIM_LEADING;
1506: break;
1507: case TRAILING:
1508: jj_consume_token(TRAILING);
1509: trimSpec = StringFunctionNode.TRIM_TRAILING;
1510: break;
1511: case BOTH:
1512: jj_consume_token(BOTH);
1513: trimSpec = StringFunctionNode.TRIM_BOTH;
1514: break;
1515: default:
1516: jj_la1[61] = jj_gen;
1517: jj_consume_token(-1);
1518: throw new ParseException();
1519: }
1520: trimChar = literal();
1521: jj_consume_token(FROM);
1522: break;
1523: default:
1524: jj_la1[62] = jj_gen;
1525: ;
1526: }
1527: arg1 = expression();
1528: f = new StringFunctionNode(trimSpec, trimChar, arg1);
1529: break;
1530: default:
1531: jj_la1[63] = jj_gen;
1532: jj_consume_token(-1);
1533: throw new ParseException();
1534: }
1535: jj_consume_token(RPAREN);
1536: {
1537: if (true)
1538: return f;
1539: }
1540: throw new Error("Missing return statement in function");
1541: }
1542:
1543: final public NumericFunctionNode numericFunction()
1544: throws ParseException {
1545: Node arg1, arg2, arg3;
1546: NumericFunctionNode f;
1547: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1548: case LENGTH:
1549: jj_consume_token(LENGTH);
1550: jj_consume_token(LENGTH);
1551: arg1 = expression();
1552: f = new NumericFunctionNode(NumericFunctionNode.LENGTH,
1553: arg1);
1554: break;
1555: case ABS:
1556: jj_consume_token(ABS);
1557: jj_consume_token(ABS);
1558: arg1 = expression();
1559: f = new NumericFunctionNode(NumericFunctionNode.ABS, arg1);
1560: break;
1561: case SQRT:
1562: jj_consume_token(SQRT);
1563: jj_consume_token(SQRT);
1564: arg1 = expression();
1565: f = new NumericFunctionNode(NumericFunctionNode.SQRT, arg1);
1566: break;
1567: case BIT_LENGTH:
1568: jj_consume_token(BIT_LENGTH);
1569: jj_consume_token(BIT_LENGTH);
1570: arg1 = expression();
1571: f = new NumericFunctionNode(NumericFunctionNode.BIT_LENGTH,
1572: arg1);
1573: break;
1574: case MOD:
1575: jj_consume_token(MOD);
1576: jj_consume_token(MOD);
1577: arg1 = expression();
1578: jj_consume_token(COMMA);
1579: arg2 = expression();
1580: arg1.setNext(arg2);
1581: f = new NumericFunctionNode(NumericFunctionNode.MOD, arg1);
1582: break;
1583: case LOCATE:
1584: jj_consume_token(LOCATE);
1585: jj_consume_token(LOCATE);
1586: arg1 = expression();
1587: jj_consume_token(COMMA);
1588: arg2 = expression();
1589: arg1.setNext(arg2);
1590: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1591: case COMMA:
1592: jj_consume_token(COMMA);
1593: arg3 = expression();
1594: arg2.setNext(arg3);
1595: break;
1596: default:
1597: jj_la1[64] = jj_gen;
1598: ;
1599: }
1600: f = new NumericFunctionNode(NumericFunctionNode.LOCATE,
1601: arg1);
1602: break;
1603: default:
1604: jj_la1[65] = jj_gen;
1605: jj_consume_token(-1);
1606: throw new ParseException();
1607: }
1608: jj_consume_token(RPAREN);
1609: {
1610: if (true)
1611: return f;
1612: }
1613: throw new Error("Missing return statement in function");
1614: }
1615:
1616: final public DateFunctionNode dateFunction() throws ParseException {
1617: int function;
1618: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1619: case CURRENT_DATE:
1620: jj_consume_token(CURRENT_DATE);
1621: function = DateFunctionNode.CURRENT_DATE;
1622: break;
1623: case CURRENT_TIME:
1624: jj_consume_token(CURRENT_TIME);
1625: function = DateFunctionNode.CURRENT_TIME;
1626: break;
1627: case CURRENT_TIMESTAMP:
1628: jj_consume_token(CURRENT_TIMESTAMP);
1629: function = DateFunctionNode.CURRENT_TIMESTAMP;
1630: break;
1631: default:
1632: jj_la1[66] = jj_gen;
1633: jj_consume_token(-1);
1634: throw new ParseException();
1635: }
1636: {
1637: if (true)
1638: return new DateFunctionNode(function);
1639: }
1640: throw new Error("Missing return statement in function");
1641: }
1642:
1643: final public Token reservedWord() throws ParseException {
1644: Token t;
1645: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1646: case SELECT:
1647: t = jj_consume_token(SELECT);
1648: break;
1649: case FROM:
1650: t = jj_consume_token(FROM);
1651: break;
1652: case DISTINCT:
1653: t = jj_consume_token(DISTINCT);
1654: break;
1655: case OBJECT:
1656: t = jj_consume_token(OBJECT);
1657: break;
1658: case LEFT:
1659: t = jj_consume_token(LEFT);
1660: break;
1661: case OUTER:
1662: t = jj_consume_token(OUTER);
1663: break;
1664: case INNER:
1665: t = jj_consume_token(INNER);
1666: break;
1667: case JOIN:
1668: t = jj_consume_token(JOIN);
1669: break;
1670: case FETCH:
1671: t = jj_consume_token(FETCH);
1672: break;
1673: case IN:
1674: t = jj_consume_token(IN);
1675: break;
1676: case AS:
1677: t = jj_consume_token(AS);
1678: break;
1679: case UPDATE:
1680: t = jj_consume_token(UPDATE);
1681: break;
1682: case SET:
1683: t = jj_consume_token(SET);
1684: break;
1685: case DELETE:
1686: t = jj_consume_token(DELETE);
1687: break;
1688: case NEW:
1689: t = jj_consume_token(NEW);
1690: break;
1691: case AVG:
1692: t = jj_consume_token(AVG);
1693: break;
1694: case MAX:
1695: t = jj_consume_token(MAX);
1696: break;
1697: case MIN:
1698: t = jj_consume_token(MIN);
1699: break;
1700: case SUM:
1701: t = jj_consume_token(SUM);
1702: break;
1703: case COUNT:
1704: t = jj_consume_token(COUNT);
1705: break;
1706: case WHERE:
1707: t = jj_consume_token(WHERE);
1708: break;
1709: case GROUP:
1710: t = jj_consume_token(GROUP);
1711: break;
1712: case BY:
1713: t = jj_consume_token(BY);
1714: break;
1715: case HAVING:
1716: t = jj_consume_token(HAVING);
1717: break;
1718: case OR:
1719: t = jj_consume_token(OR);
1720: break;
1721: case AND:
1722: t = jj_consume_token(AND);
1723: break;
1724: case NOT:
1725: t = jj_consume_token(NOT);
1726: break;
1727: case BETWEEN:
1728: t = jj_consume_token(BETWEEN);
1729: break;
1730: case LIKE:
1731: t = jj_consume_token(LIKE);
1732: break;
1733: case ESCAPE:
1734: t = jj_consume_token(ESCAPE);
1735: break;
1736: case IS:
1737: t = jj_consume_token(IS);
1738: break;
1739: case EMPTY:
1740: t = jj_consume_token(EMPTY);
1741: break;
1742: case MEMBER:
1743: t = jj_consume_token(MEMBER);
1744: break;
1745: case OF:
1746: t = jj_consume_token(OF);
1747: break;
1748: case EXISTS:
1749: t = jj_consume_token(EXISTS);
1750: break;
1751: case ALL:
1752: t = jj_consume_token(ALL);
1753: break;
1754: case ANY:
1755: t = jj_consume_token(ANY);
1756: break;
1757: case SOME:
1758: t = jj_consume_token(SOME);
1759: break;
1760: case CONCAT:
1761: t = jj_consume_token(CONCAT);
1762: break;
1763: case SUBSTRING:
1764: t = jj_consume_token(SUBSTRING);
1765: break;
1766: case TRIM:
1767: t = jj_consume_token(TRIM);
1768: break;
1769: case LOWER:
1770: t = jj_consume_token(LOWER);
1771: break;
1772: case UPPER:
1773: t = jj_consume_token(UPPER);
1774: break;
1775: case LEADING:
1776: t = jj_consume_token(LEADING);
1777: break;
1778: case TRAILING:
1779: t = jj_consume_token(TRAILING);
1780: break;
1781: case BOTH:
1782: t = jj_consume_token(BOTH);
1783: break;
1784: case LENGTH:
1785: t = jj_consume_token(LENGTH);
1786: break;
1787: case LOCATE:
1788: t = jj_consume_token(LOCATE);
1789: break;
1790: case ABS:
1791: t = jj_consume_token(ABS);
1792: break;
1793: case SQRT:
1794: t = jj_consume_token(SQRT);
1795: break;
1796: case MOD:
1797: t = jj_consume_token(MOD);
1798: break;
1799: case BIT_LENGTH:
1800: t = jj_consume_token(BIT_LENGTH);
1801: break;
1802: case CURRENT_DATE:
1803: t = jj_consume_token(CURRENT_DATE);
1804: break;
1805: case CURRENT_TIME:
1806: t = jj_consume_token(CURRENT_TIME);
1807: break;
1808: case CURRENT_TIMESTAMP:
1809: t = jj_consume_token(CURRENT_TIMESTAMP);
1810: break;
1811: case ORDER:
1812: t = jj_consume_token(ORDER);
1813: break;
1814: case ASC:
1815: t = jj_consume_token(ASC);
1816: break;
1817: case DESC:
1818: t = jj_consume_token(DESC);
1819: break;
1820: default:
1821: jj_la1[67] = jj_gen;
1822: jj_consume_token(-1);
1823: throw new ParseException();
1824: }
1825: {
1826: if (true)
1827: return t;
1828: }
1829: throw new Error("Missing return statement in function");
1830: }
1831:
1832: final private boolean jj_2_1(int xla) {
1833: jj_la = xla;
1834: jj_lastpos = jj_scanpos = token;
1835: try {
1836: return !jj_3_1();
1837: } catch (LookaheadSuccess ls) {
1838: return true;
1839: } finally {
1840: jj_save(0, xla);
1841: }
1842: }
1843:
1844: final private boolean jj_2_2(int xla) {
1845: jj_la = xla;
1846: jj_lastpos = jj_scanpos = token;
1847: try {
1848: return !jj_3_2();
1849: } catch (LookaheadSuccess ls) {
1850: return true;
1851: } finally {
1852: jj_save(1, xla);
1853: }
1854: }
1855:
1856: final private boolean jj_2_3(int xla) {
1857: jj_la = xla;
1858: jj_lastpos = jj_scanpos = token;
1859: try {
1860: return !jj_3_3();
1861: } catch (LookaheadSuccess ls) {
1862: return true;
1863: } finally {
1864: jj_save(2, xla);
1865: }
1866: }
1867:
1868: final private boolean jj_2_4(int xla) {
1869: jj_la = xla;
1870: jj_lastpos = jj_scanpos = token;
1871: try {
1872: return !jj_3_4();
1873: } catch (LookaheadSuccess ls) {
1874: return true;
1875: } finally {
1876: jj_save(3, xla);
1877: }
1878: }
1879:
1880: final private boolean jj_2_5(int xla) {
1881: jj_la = xla;
1882: jj_lastpos = jj_scanpos = token;
1883: try {
1884: return !jj_3_5();
1885: } catch (LookaheadSuccess ls) {
1886: return true;
1887: } finally {
1888: jj_save(4, xla);
1889: }
1890: }
1891:
1892: final private boolean jj_2_6(int xla) {
1893: jj_la = xla;
1894: jj_lastpos = jj_scanpos = token;
1895: try {
1896: return !jj_3_6();
1897: } catch (LookaheadSuccess ls) {
1898: return true;
1899: } finally {
1900: jj_save(5, xla);
1901: }
1902: }
1903:
1904: final private boolean jj_2_7(int xla) {
1905: jj_la = xla;
1906: jj_lastpos = jj_scanpos = token;
1907: try {
1908: return !jj_3_7();
1909: } catch (LookaheadSuccess ls) {
1910: return true;
1911: } finally {
1912: jj_save(6, xla);
1913: }
1914: }
1915:
1916: final private boolean jj_2_8(int xla) {
1917: jj_la = xla;
1918: jj_lastpos = jj_scanpos = token;
1919: try {
1920: return !jj_3_8();
1921: } catch (LookaheadSuccess ls) {
1922: return true;
1923: } finally {
1924: jj_save(7, xla);
1925: }
1926: }
1927:
1928: final private boolean jj_2_9(int xla) {
1929: jj_la = xla;
1930: jj_lastpos = jj_scanpos = token;
1931: try {
1932: return !jj_3_9();
1933: } catch (LookaheadSuccess ls) {
1934: return true;
1935: } finally {
1936: jj_save(8, xla);
1937: }
1938: }
1939:
1940: final private boolean jj_2_10(int xla) {
1941: jj_la = xla;
1942: jj_lastpos = jj_scanpos = token;
1943: try {
1944: return !jj_3_10();
1945: } catch (LookaheadSuccess ls) {
1946: return true;
1947: } finally {
1948: jj_save(9, xla);
1949: }
1950: }
1951:
1952: final private boolean jj_2_11(int xla) {
1953: jj_la = xla;
1954: jj_lastpos = jj_scanpos = token;
1955: try {
1956: return !jj_3_11();
1957: } catch (LookaheadSuccess ls) {
1958: return true;
1959: } finally {
1960: jj_save(10, xla);
1961: }
1962: }
1963:
1964: final private boolean jj_2_12(int xla) {
1965: jj_la = xla;
1966: jj_lastpos = jj_scanpos = token;
1967: try {
1968: return !jj_3_12();
1969: } catch (LookaheadSuccess ls) {
1970: return true;
1971: } finally {
1972: jj_save(11, xla);
1973: }
1974: }
1975:
1976: final private boolean jj_2_13(int xla) {
1977: jj_la = xla;
1978: jj_lastpos = jj_scanpos = token;
1979: try {
1980: return !jj_3_13();
1981: } catch (LookaheadSuccess ls) {
1982: return true;
1983: } finally {
1984: jj_save(12, xla);
1985: }
1986: }
1987:
1988: final private boolean jj_2_14(int xla) {
1989: jj_la = xla;
1990: jj_lastpos = jj_scanpos = token;
1991: try {
1992: return !jj_3_14();
1993: } catch (LookaheadSuccess ls) {
1994: return true;
1995: } finally {
1996: jj_save(13, xla);
1997: }
1998: }
1999:
2000: final private boolean jj_3_12() {
2001: if (jj_3R_20())
2002: return true;
2003: return false;
2004: }
2005:
2006: final private boolean jj_3_11() {
2007: if (jj_scan_token(WHERE))
2008: return true;
2009: if (jj_3R_13())
2010: return true;
2011: return false;
2012: }
2013:
2014: final private boolean jj_3R_87() {
2015: if (jj_scan_token(SELECT))
2016: return true;
2017: return false;
2018: }
2019:
2020: final private boolean jj_3R_41() {
2021: if (jj_scan_token(EXISTS))
2022: return true;
2023: if (jj_scan_token(LPAREN))
2024: return true;
2025: return false;
2026: }
2027:
2028: final private boolean jj_3R_27() {
2029: if (jj_scan_token(IDENTIFIER))
2030: return true;
2031: return false;
2032: }
2033:
2034: final private boolean jj_3R_86() {
2035: if (jj_scan_token(CURRENT_TIMESTAMP))
2036: return true;
2037: return false;
2038: }
2039:
2040: final private boolean jj_3R_85() {
2041: if (jj_scan_token(CURRENT_TIME))
2042: return true;
2043: return false;
2044: }
2045:
2046: final private boolean jj_3R_84() {
2047: if (jj_scan_token(CURRENT_DATE))
2048: return true;
2049: return false;
2050: }
2051:
2052: final private boolean jj_3R_33() {
2053: if (jj_3R_43())
2054: return true;
2055: return false;
2056: }
2057:
2058: final private boolean jj_3R_53() {
2059: if (jj_scan_token(MEMBER))
2060: return true;
2061: return false;
2062: }
2063:
2064: final private boolean jj_3R_66() {
2065: Token xsp;
2066: xsp = jj_scanpos;
2067: if (jj_3R_84()) {
2068: jj_scanpos = xsp;
2069: if (jj_3R_85()) {
2070: jj_scanpos = xsp;
2071: if (jj_3R_86())
2072: return true;
2073: }
2074: }
2075: return false;
2076: }
2077:
2078: final private boolean jj_3R_34() {
2079: if (jj_scan_token(NOT))
2080: return true;
2081: return false;
2082: }
2083:
2084: final private boolean jj_3R_19() {
2085: if (jj_scan_token(IS))
2086: return true;
2087: Token xsp;
2088: xsp = jj_scanpos;
2089: if (jj_3R_34())
2090: jj_scanpos = xsp;
2091: if (jj_scan_token(EMPTY))
2092: return true;
2093: return false;
2094: }
2095:
2096: final private boolean jj_3R_78() {
2097: if (jj_scan_token(LOCATE))
2098: return true;
2099: if (jj_scan_token(LOCATE))
2100: return true;
2101: return false;
2102: }
2103:
2104: final private boolean jj_3R_77() {
2105: if (jj_scan_token(MOD))
2106: return true;
2107: if (jj_scan_token(MOD))
2108: return true;
2109: return false;
2110: }
2111:
2112: final private boolean jj_3R_54() {
2113: if (jj_scan_token(IS))
2114: return true;
2115: return false;
2116: }
2117:
2118: final private boolean jj_3R_32() {
2119: if (jj_3R_42())
2120: return true;
2121: return false;
2122: }
2123:
2124: final private boolean jj_3R_76() {
2125: if (jj_scan_token(BIT_LENGTH))
2126: return true;
2127: if (jj_scan_token(BIT_LENGTH))
2128: return true;
2129: return false;
2130: }
2131:
2132: final private boolean jj_3R_75() {
2133: if (jj_scan_token(SQRT))
2134: return true;
2135: if (jj_scan_token(SQRT))
2136: return true;
2137: return false;
2138: }
2139:
2140: final private boolean jj_3R_17() {
2141: if (jj_scan_token(LIKE))
2142: return true;
2143: Token xsp;
2144: xsp = jj_scanpos;
2145: if (jj_3R_32()) {
2146: jj_scanpos = xsp;
2147: if (jj_3R_33())
2148: return true;
2149: }
2150: return false;
2151: }
2152:
2153: final private boolean jj_3R_74() {
2154: if (jj_scan_token(ABS))
2155: return true;
2156: if (jj_scan_token(ABS))
2157: return true;
2158: return false;
2159: }
2160:
2161: final private boolean jj_3R_73() {
2162: if (jj_scan_token(LENGTH))
2163: return true;
2164: if (jj_scan_token(LENGTH))
2165: return true;
2166: return false;
2167: }
2168:
2169: final private boolean jj_3R_62() {
2170: if (jj_scan_token(COLON))
2171: return true;
2172: if (jj_scan_token(IDENTIFIER))
2173: return true;
2174: return false;
2175: }
2176:
2177: final private boolean jj_3R_64() {
2178: Token xsp;
2179: xsp = jj_scanpos;
2180: if (jj_3R_73()) {
2181: jj_scanpos = xsp;
2182: if (jj_3R_74()) {
2183: jj_scanpos = xsp;
2184: if (jj_3R_75()) {
2185: jj_scanpos = xsp;
2186: if (jj_3R_76()) {
2187: jj_scanpos = xsp;
2188: if (jj_3R_77()) {
2189: jj_scanpos = xsp;
2190: if (jj_3R_78())
2191: return true;
2192: }
2193: }
2194: }
2195: }
2196: }
2197: return false;
2198: }
2199:
2200: final private boolean jj_3R_61() {
2201: if (jj_scan_token(QUESTION))
2202: return true;
2203: if (jj_scan_token(DECIMAL_LITERAL))
2204: return true;
2205: return false;
2206: }
2207:
2208: final private boolean jj_3R_88() {
2209: if (jj_scan_token(DOT))
2210: return true;
2211: return false;
2212: }
2213:
2214: final private boolean jj_3R_43() {
2215: Token xsp;
2216: xsp = jj_scanpos;
2217: if (jj_3R_61()) {
2218: jj_scanpos = xsp;
2219: if (jj_3R_62())
2220: return true;
2221: }
2222: return false;
2223: }
2224:
2225: final private boolean jj_3R_12() {
2226: if (jj_scan_token(IDENTIFIER))
2227: return true;
2228: Token xsp;
2229: while (true) {
2230: xsp = jj_scanpos;
2231: if (jj_3R_88()) {
2232: jj_scanpos = xsp;
2233: break;
2234: }
2235: }
2236: return false;
2237: }
2238:
2239: final private boolean jj_3R_60() {
2240: if (jj_scan_token(BOOLEAN_LITERAL))
2241: return true;
2242: return false;
2243: }
2244:
2245: final private boolean jj_3R_59() {
2246: if (jj_scan_token(STRING_LITERAL))
2247: return true;
2248: return false;
2249: }
2250:
2251: final private boolean jj_3R_58() {
2252: if (jj_scan_token(CHARACTER_LITERAL))
2253: return true;
2254: return false;
2255: }
2256:
2257: final private boolean jj_3R_57() {
2258: if (jj_scan_token(FLOATING_POINT_LITERAL))
2259: return true;
2260: return false;
2261: }
2262:
2263: final private boolean jj_3R_56() {
2264: if (jj_scan_token(HEX_LITERAL))
2265: return true;
2266: return false;
2267: }
2268:
2269: final private boolean jj_3R_55() {
2270: if (jj_scan_token(DECIMAL_LITERAL))
2271: return true;
2272: return false;
2273: }
2274:
2275: final private boolean jj_3R_42() {
2276: Token xsp;
2277: xsp = jj_scanpos;
2278: if (jj_3R_55()) {
2279: jj_scanpos = xsp;
2280: if (jj_3R_56()) {
2281: jj_scanpos = xsp;
2282: if (jj_3R_57()) {
2283: jj_scanpos = xsp;
2284: if (jj_3R_58()) {
2285: jj_scanpos = xsp;
2286: if (jj_3R_59()) {
2287: jj_scanpos = xsp;
2288: if (jj_3R_60())
2289: return true;
2290: }
2291: }
2292: }
2293: }
2294: }
2295: return false;
2296: }
2297:
2298: final private boolean jj_3R_83() {
2299: if (jj_scan_token(TRIM))
2300: return true;
2301: if (jj_scan_token(LPAREN))
2302: return true;
2303: return false;
2304: }
2305:
2306: final private boolean jj_3R_82() {
2307: if (jj_scan_token(UPPER))
2308: return true;
2309: if (jj_scan_token(LPAREN))
2310: return true;
2311: return false;
2312: }
2313:
2314: final private boolean jj_3R_81() {
2315: if (jj_scan_token(LOWER))
2316: return true;
2317: if (jj_scan_token(LPAREN))
2318: return true;
2319: return false;
2320: }
2321:
2322: final private boolean jj_3_3() {
2323: if (jj_scan_token(COMMA))
2324: return true;
2325: if (jj_3R_12())
2326: return true;
2327: return false;
2328: }
2329:
2330: final private boolean jj_3R_20() {
2331: if (jj_scan_token(GROUP))
2332: return true;
2333: if (jj_scan_token(BY))
2334: return true;
2335: return false;
2336: }
2337:
2338: final private boolean jj_3R_80() {
2339: if (jj_scan_token(SUBSTRING))
2340: return true;
2341: if (jj_scan_token(LPAREN))
2342: return true;
2343: return false;
2344: }
2345:
2346: final private boolean jj_3R_79() {
2347: if (jj_scan_token(CONCAT))
2348: return true;
2349: if (jj_scan_token(LPAREN))
2350: return true;
2351: return false;
2352: }
2353:
2354: final private boolean jj_3R_65() {
2355: Token xsp;
2356: xsp = jj_scanpos;
2357: if (jj_3R_79()) {
2358: jj_scanpos = xsp;
2359: if (jj_3R_80()) {
2360: jj_scanpos = xsp;
2361: if (jj_3R_81()) {
2362: jj_scanpos = xsp;
2363: if (jj_3R_82()) {
2364: jj_scanpos = xsp;
2365: if (jj_3R_83())
2366: return true;
2367: }
2368: }
2369: }
2370: }
2371: return false;
2372: }
2373:
2374: final private boolean jj_3R_18() {
2375: if (jj_scan_token(IN))
2376: return true;
2377: if (jj_scan_token(LPAREN))
2378: return true;
2379: return false;
2380: }
2381:
2382: final private boolean jj_3R_11() {
2383: if (jj_3R_28())
2384: return true;
2385: return false;
2386: }
2387:
2388: final private boolean jj_3R_10() {
2389: if (jj_3R_27())
2390: return true;
2391: return false;
2392: }
2393:
2394: final private boolean jj_3R_16() {
2395: if (jj_scan_token(BETWEEN))
2396: return true;
2397: if (jj_3R_23())
2398: return true;
2399: return false;
2400: }
2401:
2402: final private boolean jj_3R_51() {
2403: if (jj_3R_66())
2404: return true;
2405: return false;
2406: }
2407:
2408: final private boolean jj_3R_63() {
2409: if (jj_scan_token(94))
2410: return true;
2411: return false;
2412: }
2413:
2414: final private boolean jj_3R_50() {
2415: if (jj_3R_65())
2416: return true;
2417: return false;
2418: }
2419:
2420: final private boolean jj_3_2() {
2421: if (jj_scan_token(COMMA))
2422: return true;
2423: Token xsp;
2424: xsp = jj_scanpos;
2425: if (jj_3R_10()) {
2426: jj_scanpos = xsp;
2427: if (jj_3R_11())
2428: return true;
2429: }
2430: return false;
2431: }
2432:
2433: final private boolean jj_3R_49() {
2434: if (jj_3R_64())
2435: return true;
2436: return false;
2437: }
2438:
2439: final private boolean jj_3R_48() {
2440: if (jj_3R_43())
2441: return true;
2442: return false;
2443: }
2444:
2445: final private boolean jj_3R_47() {
2446: if (jj_scan_token(LPAREN))
2447: return true;
2448: if (jj_3R_87())
2449: return true;
2450: return false;
2451: }
2452:
2453: final private boolean jj_3R_24() {
2454: if (jj_scan_token(95))
2455: return true;
2456: return false;
2457: }
2458:
2459: final private boolean jj_3R_46() {
2460: if (jj_3R_42())
2461: return true;
2462: return false;
2463: }
2464:
2465: final private boolean jj_3R_45() {
2466: if (jj_3R_12())
2467: return true;
2468: return false;
2469: }
2470:
2471: final private boolean jj_3R_40() {
2472: if (jj_3R_54())
2473: return true;
2474: return false;
2475: }
2476:
2477: final private boolean jj_3R_44() {
2478: Token xsp;
2479: xsp = jj_scanpos;
2480: if (jj_scan_token(93)) {
2481: jj_scanpos = xsp;
2482: if (jj_3R_63())
2483: return true;
2484: }
2485: return false;
2486: }
2487:
2488: final private boolean jj_3_10() {
2489: if (jj_3R_19())
2490: return true;
2491: return false;
2492: }
2493:
2494: final private boolean jj_3R_31() {
2495: if (jj_3R_41())
2496: return true;
2497: return false;
2498: }
2499:
2500: final private boolean jj_3R_39() {
2501: if (jj_3R_53())
2502: return true;
2503: return false;
2504: }
2505:
2506: final private boolean jj_3R_35() {
2507: Token xsp;
2508: xsp = jj_scanpos;
2509: if (jj_3R_44())
2510: jj_scanpos = xsp;
2511: xsp = jj_scanpos;
2512: if (jj_3R_45()) {
2513: jj_scanpos = xsp;
2514: if (jj_3R_46()) {
2515: jj_scanpos = xsp;
2516: if (jj_3R_47()) {
2517: jj_scanpos = xsp;
2518: if (jj_3R_48()) {
2519: jj_scanpos = xsp;
2520: if (jj_3R_49()) {
2521: jj_scanpos = xsp;
2522: if (jj_3R_50()) {
2523: jj_scanpos = xsp;
2524: if (jj_3R_51())
2525: return true;
2526: }
2527: }
2528: }
2529: }
2530: }
2531: }
2532: return false;
2533: }
2534:
2535: final private boolean jj_3_9() {
2536: if (jj_3R_18())
2537: return true;
2538: return false;
2539: }
2540:
2541: final private boolean jj_3_8() {
2542: if (jj_3R_17())
2543: return true;
2544: return false;
2545: }
2546:
2547: final private boolean jj_3_7() {
2548: if (jj_3R_16())
2549: return true;
2550: return false;
2551: }
2552:
2553: final private boolean jj_3_1() {
2554: if (jj_scan_token(IDENTIFIER))
2555: return true;
2556: if (jj_scan_token(DOT))
2557: return true;
2558: return false;
2559: }
2560:
2561: final private boolean jj_3R_38() {
2562: if (jj_3R_52())
2563: return true;
2564: return false;
2565: }
2566:
2567: final private boolean jj_3R_25() {
2568: if (jj_scan_token(96))
2569: return true;
2570: return false;
2571: }
2572:
2573: final private boolean jj_3R_21() {
2574: if (jj_scan_token(93))
2575: return true;
2576: return false;
2577: }
2578:
2579: final private boolean jj_3R_30() {
2580: if (jj_3R_23())
2581: return true;
2582: Token xsp;
2583: xsp = jj_scanpos;
2584: if (jj_3R_38()) {
2585: jj_scanpos = xsp;
2586: if (jj_3_7()) {
2587: jj_scanpos = xsp;
2588: if (jj_3_8()) {
2589: jj_scanpos = xsp;
2590: if (jj_3_9()) {
2591: jj_scanpos = xsp;
2592: if (jj_3R_39()) {
2593: jj_scanpos = xsp;
2594: if (jj_3_10()) {
2595: jj_scanpos = xsp;
2596: if (jj_3R_40())
2597: return true;
2598: }
2599: }
2600: }
2601: }
2602: }
2603: }
2604: return false;
2605: }
2606:
2607: final private boolean jj_3_14() {
2608: Token xsp;
2609: xsp = jj_scanpos;
2610: if (jj_3R_24()) {
2611: jj_scanpos = xsp;
2612: if (jj_3R_25())
2613: return true;
2614: }
2615: if (jj_3R_26())
2616: return true;
2617: return false;
2618: }
2619:
2620: final private boolean jj_3R_15() {
2621: Token xsp;
2622: xsp = jj_scanpos;
2623: if (jj_3R_30()) {
2624: jj_scanpos = xsp;
2625: if (jj_3R_31())
2626: return true;
2627: }
2628: return false;
2629: }
2630:
2631: final private boolean jj_3R_26() {
2632: if (jj_3R_35())
2633: return true;
2634: Token xsp;
2635: xsp = jj_scanpos;
2636: if (jj_3_14())
2637: jj_scanpos = xsp;
2638: return false;
2639: }
2640:
2641: final private boolean jj_3R_37() {
2642: if (jj_scan_token(LPAREN))
2643: return true;
2644: return false;
2645: }
2646:
2647: final private boolean jj_3R_22() {
2648: if (jj_scan_token(94))
2649: return true;
2650: return false;
2651: }
2652:
2653: final private boolean jj_3_6() {
2654: if (jj_3R_15())
2655: return true;
2656: return false;
2657: }
2658:
2659: final private boolean jj_3R_36() {
2660: if (jj_scan_token(NOT))
2661: return true;
2662: return false;
2663: }
2664:
2665: final private boolean jj_3_13() {
2666: Token xsp;
2667: xsp = jj_scanpos;
2668: if (jj_3R_21()) {
2669: jj_scanpos = xsp;
2670: if (jj_3R_22())
2671: return true;
2672: }
2673: if (jj_3R_23())
2674: return true;
2675: return false;
2676: }
2677:
2678: final private boolean jj_3R_29() {
2679: Token xsp;
2680: xsp = jj_scanpos;
2681: if (jj_3R_36())
2682: jj_scanpos = xsp;
2683: xsp = jj_scanpos;
2684: if (jj_3_6()) {
2685: jj_scanpos = xsp;
2686: if (jj_3R_37())
2687: return true;
2688: }
2689: return false;
2690: }
2691:
2692: final private boolean jj_3R_23() {
2693: if (jj_3R_26())
2694: return true;
2695: Token xsp;
2696: xsp = jj_scanpos;
2697: if (jj_3_13())
2698: jj_scanpos = xsp;
2699: return false;
2700: }
2701:
2702: final private boolean jj_3_5() {
2703: if (jj_scan_token(AND))
2704: return true;
2705: if (jj_3R_14())
2706: return true;
2707: return false;
2708: }
2709:
2710: final private boolean jj_3R_14() {
2711: if (jj_3R_29())
2712: return true;
2713: return false;
2714: }
2715:
2716: final private boolean jj_3R_72() {
2717: if (jj_scan_token(NE))
2718: return true;
2719: return false;
2720: }
2721:
2722: final private boolean jj_3R_71() {
2723: if (jj_scan_token(GE))
2724: return true;
2725: return false;
2726: }
2727:
2728: final private boolean jj_3R_70() {
2729: if (jj_scan_token(GT))
2730: return true;
2731: return false;
2732: }
2733:
2734: final private boolean jj_3R_69() {
2735: if (jj_scan_token(LE))
2736: return true;
2737: return false;
2738: }
2739:
2740: final private boolean jj_3R_68() {
2741: if (jj_scan_token(LT))
2742: return true;
2743: return false;
2744: }
2745:
2746: final private boolean jj_3_4() {
2747: if (jj_scan_token(OR))
2748: return true;
2749: if (jj_3R_13())
2750: return true;
2751: return false;
2752: }
2753:
2754: final private boolean jj_3R_67() {
2755: if (jj_scan_token(EQ))
2756: return true;
2757: return false;
2758: }
2759:
2760: final private boolean jj_3R_13() {
2761: if (jj_3R_14())
2762: return true;
2763: return false;
2764: }
2765:
2766: final private boolean jj_3R_52() {
2767: Token xsp;
2768: xsp = jj_scanpos;
2769: if (jj_3R_67()) {
2770: jj_scanpos = xsp;
2771: if (jj_3R_68()) {
2772: jj_scanpos = xsp;
2773: if (jj_3R_69()) {
2774: jj_scanpos = xsp;
2775: if (jj_3R_70()) {
2776: jj_scanpos = xsp;
2777: if (jj_3R_71()) {
2778: jj_scanpos = xsp;
2779: if (jj_3R_72())
2780: return true;
2781: }
2782: }
2783: }
2784: }
2785: }
2786: return false;
2787: }
2788:
2789: final private boolean jj_3R_28() {
2790: if (jj_scan_token(IN))
2791: return true;
2792: return false;
2793: }
2794:
2795: public EJBQLParserTokenManager token_source;
2796: JavaCharStream jj_input_stream;
2797: public Token token, jj_nt;
2798: private int jj_ntk;
2799: private Token jj_scanpos, jj_lastpos;
2800: private int jj_la;
2801: public boolean lookingAhead = false;
2802: private boolean jj_semLA;
2803: private int jj_gen;
2804: final private int[] jj_la1 = new int[68];
2805: static private int[] jj_la1_0;
2806: static private int[] jj_la1_1;
2807: static private int[] jj_la1_2;
2808: static private int[] jj_la1_3;
2809: static {
2810: jj_la1_0();
2811: jj_la1_1();
2812: jj_la1_2();
2813: jj_la1_3();
2814: }
2815:
2816: private static void jj_la1_0() {
2817: jj_la1_0 = new int[] { 0x800000, 0x1001, 0x2000000, 0x2000,
2818: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2000,
2819: 0x0, 0x0, 0x2000, 0x4000000, 0x4000, 0xff800000, 0x0,
2820: 0x2000000, 0x0, 0x2000, 0x0, 0x0, 0x68000000,
2821: 0x10000000, 0x28000000, 0x28000000, 0x0, 0x80000000,
2822: 0x0, 0x0, 0x40, 0x7e0000, 0x0, 0x0, 0x18040, 0x818000,
2823: 0x18000, 0x2000, 0x18000, 0x0, 0x18000, 0x18000,
2824: 0x18000, 0x0, 0x0, 0x0, 0x0, 0x2000000, 0x0, 0x0,
2825: 0x7e0000, 0x18040, 0x0, 0x0, 0x0, 0x0, 0x18040, 0x0,
2826: 0x0, 0x0, 0x2000, 0x0, 0x0, 0xff800000, };
2827: }
2828:
2829: private static void jj_la1_1() {
2830: jj_la1_1 = new int[] { 0x14, 0x0, 0x0, 0x0, 0x800, 0x4000,
2831: 0x1000, 0x0, 0x2, 0x2, 0x800, 0x2, 0x2, 0x0, 0x800,
2832: 0x1, 0x0, 0x7e0, 0x0, 0xffffffff, 0x7c0, 0x0, 0x7c0,
2833: 0x0, 0x7c0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x2,
2834: 0x20000, 0x0, 0x0, 0x800000, 0x200000, 0xe2000000, 0x0,
2835: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x100000, 0x20000,
2836: 0x20000, 0x1000000, 0x0, 0x4000, 0x1c000000, 0x0,
2837: 0xfc000000, 0x0, 0x0, 0x0, 0x0, 0xe0000000, 0x0, 0x0,
2838: 0xe0000000, 0x0, 0x0, 0x0, 0xffffffff, };
2839: }
2840:
2841: private static void jj_la1_2() {
2842: jj_la1_2 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2843: 0x4000, 0x0, 0x4000000, 0x0, 0x0, 0x4000000, 0x0, 0x0,
2844: 0x4000000, 0x0, 0x4000000, 0x0, 0x401ffff, 0x0, 0x0,
2845: 0x4000000, 0x0, 0x4000000, 0x0, 0x0, 0x0, 0x0, 0x0,
2846: 0x0, 0x4000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2847: 0x67563fe3, 0x3560000, 0x3560000, 0x0, 0x3560000,
2848: 0x3560000, 0x0, 0x3560000, 0x3560000, 0x0, 0x0, 0x0,
2849: 0x0, 0x0, 0x0, 0x0, 0x0, 0x67563fe3, 0x60000000,
2850: 0x80000000, 0x60000000, 0x60000000, 0x7563fe3, 0x1c,
2851: 0x1c, 0x3, 0x0, 0x7e0, 0x3800, 0x1ffff, };
2852: }
2853:
2854: private static void jj_la1_3() {
2855: jj_la1_3 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2856: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2857: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2858: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2859: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2860: 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0,
2861: 0x0, 0x0, 0x0, 0x0, 0x0, };
2862: }
2863:
2864: final private JJCalls[] jj_2_rtns = new JJCalls[14];
2865: private boolean jj_rescan = false;
2866: private int jj_gc = 0;
2867:
2868: public EJBQLParser(java.io.InputStream stream) {
2869: jj_input_stream = new JavaCharStream(stream, 1, 1);
2870: token_source = new EJBQLParserTokenManager(jj_input_stream);
2871: token = new Token();
2872: jj_ntk = -1;
2873: jj_gen = 0;
2874: for (int i = 0; i < 68; i++)
2875: jj_la1[i] = -1;
2876: for (int i = 0; i < jj_2_rtns.length; i++)
2877: jj_2_rtns[i] = new JJCalls();
2878: }
2879:
2880: public void ReInit(java.io.InputStream stream) {
2881: jj_input_stream.ReInit(stream, 1, 1);
2882: token_source.ReInit(jj_input_stream);
2883: token = new Token();
2884: jj_ntk = -1;
2885: jj_gen = 0;
2886: for (int i = 0; i < 68; i++)
2887: jj_la1[i] = -1;
2888: for (int i = 0; i < jj_2_rtns.length; i++)
2889: jj_2_rtns[i] = new JJCalls();
2890: }
2891:
2892: public EJBQLParser(java.io.Reader stream) {
2893: jj_input_stream = new JavaCharStream(stream, 1, 1);
2894: token_source = new EJBQLParserTokenManager(jj_input_stream);
2895: token = new Token();
2896: jj_ntk = -1;
2897: jj_gen = 0;
2898: for (int i = 0; i < 68; i++)
2899: jj_la1[i] = -1;
2900: for (int i = 0; i < jj_2_rtns.length; i++)
2901: jj_2_rtns[i] = new JJCalls();
2902: }
2903:
2904: public void ReInit(java.io.Reader stream) {
2905: jj_input_stream.ReInit(stream, 1, 1);
2906: token_source.ReInit(jj_input_stream);
2907: token = new Token();
2908: jj_ntk = -1;
2909: jj_gen = 0;
2910: for (int i = 0; i < 68; i++)
2911: jj_la1[i] = -1;
2912: for (int i = 0; i < jj_2_rtns.length; i++)
2913: jj_2_rtns[i] = new JJCalls();
2914: }
2915:
2916: public EJBQLParser(EJBQLParserTokenManager tm) {
2917: token_source = tm;
2918: token = new Token();
2919: jj_ntk = -1;
2920: jj_gen = 0;
2921: for (int i = 0; i < 68; i++)
2922: jj_la1[i] = -1;
2923: for (int i = 0; i < jj_2_rtns.length; i++)
2924: jj_2_rtns[i] = new JJCalls();
2925: }
2926:
2927: public void ReInit(EJBQLParserTokenManager tm) {
2928: token_source = tm;
2929: token = new Token();
2930: jj_ntk = -1;
2931: jj_gen = 0;
2932: for (int i = 0; i < 68; i++)
2933: jj_la1[i] = -1;
2934: for (int i = 0; i < jj_2_rtns.length; i++)
2935: jj_2_rtns[i] = new JJCalls();
2936: }
2937:
2938: final private Token jj_consume_token(int kind)
2939: throws ParseException {
2940: Token oldToken;
2941: if ((oldToken = token).next != null)
2942: token = token.next;
2943: else
2944: token = token.next = token_source.getNextToken();
2945: jj_ntk = -1;
2946: if (token.kind == kind) {
2947: jj_gen++;
2948: if (++jj_gc > 100) {
2949: jj_gc = 0;
2950: for (int i = 0; i < jj_2_rtns.length; i++) {
2951: JJCalls c = jj_2_rtns[i];
2952: while (c != null) {
2953: if (c.gen < jj_gen)
2954: c.first = null;
2955: c = c.next;
2956: }
2957: }
2958: }
2959: return token;
2960: }
2961: token = oldToken;
2962: jj_kind = kind;
2963: throw generateParseException();
2964: }
2965:
2966: static private final class LookaheadSuccess extends java.lang.Error {
2967: }
2968:
2969: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
2970:
2971: final private boolean jj_scan_token(int kind) {
2972: if (jj_scanpos == jj_lastpos) {
2973: jj_la--;
2974: if (jj_scanpos.next == null) {
2975: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
2976: .getNextToken();
2977: } else {
2978: jj_lastpos = jj_scanpos = jj_scanpos.next;
2979: }
2980: } else {
2981: jj_scanpos = jj_scanpos.next;
2982: }
2983: if (jj_rescan) {
2984: int i = 0;
2985: Token tok = token;
2986: while (tok != null && tok != jj_scanpos) {
2987: i++;
2988: tok = tok.next;
2989: }
2990: if (tok != null)
2991: jj_add_error_token(kind, i);
2992: }
2993: if (jj_scanpos.kind != kind)
2994: return true;
2995: if (jj_la == 0 && jj_scanpos == jj_lastpos)
2996: throw jj_ls;
2997: return false;
2998: }
2999:
3000: final public Token getNextToken() {
3001: if (token.next != null)
3002: token = token.next;
3003: else
3004: token = token.next = token_source.getNextToken();
3005: jj_ntk = -1;
3006: jj_gen++;
3007: return token;
3008: }
3009:
3010: final public Token getToken(int index) {
3011: Token t = lookingAhead ? jj_scanpos : token;
3012: for (int i = 0; i < index; i++) {
3013: if (t.next != null)
3014: t = t.next;
3015: else
3016: t = t.next = token_source.getNextToken();
3017: }
3018: return t;
3019: }
3020:
3021: final private int jj_ntk() {
3022: if ((jj_nt = token.next) == null)
3023: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
3024: else
3025: return (jj_ntk = jj_nt.kind);
3026: }
3027:
3028: private java.util.Vector jj_expentries = new java.util.Vector();
3029: private int[] jj_expentry;
3030: private int jj_kind = -1;
3031: private int[] jj_lasttokens = new int[100];
3032: private int jj_endpos;
3033:
3034: private void jj_add_error_token(int kind, int pos) {
3035: if (pos >= 100)
3036: return;
3037: if (pos == jj_endpos + 1) {
3038: jj_lasttokens[jj_endpos++] = kind;
3039: } else if (jj_endpos != 0) {
3040: jj_expentry = new int[jj_endpos];
3041: for (int i = 0; i < jj_endpos; i++) {
3042: jj_expentry[i] = jj_lasttokens[i];
3043: }
3044: boolean exists = false;
3045: for (java.util.Enumeration e = jj_expentries.elements(); e
3046: .hasMoreElements();) {
3047: int[] oldentry = (int[]) (e.nextElement());
3048: if (oldentry.length == jj_expentry.length) {
3049: exists = true;
3050: for (int i = 0; i < jj_expentry.length; i++) {
3051: if (oldentry[i] != jj_expentry[i]) {
3052: exists = false;
3053: break;
3054: }
3055: }
3056: if (exists)
3057: break;
3058: }
3059: }
3060: if (!exists)
3061: jj_expentries.addElement(jj_expentry);
3062: if (pos != 0)
3063: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
3064: }
3065: }
3066:
3067: public ParseException generateParseException() {
3068: jj_expentries.removeAllElements();
3069: boolean[] la1tokens = new boolean[97];
3070: for (int i = 0; i < 97; i++) {
3071: la1tokens[i] = false;
3072: }
3073: if (jj_kind >= 0) {
3074: la1tokens[jj_kind] = true;
3075: jj_kind = -1;
3076: }
3077: for (int i = 0; i < 68; i++) {
3078: if (jj_la1[i] == jj_gen) {
3079: for (int j = 0; j < 32; j++) {
3080: if ((jj_la1_0[i] & (1 << j)) != 0) {
3081: la1tokens[j] = true;
3082: }
3083: if ((jj_la1_1[i] & (1 << j)) != 0) {
3084: la1tokens[32 + j] = true;
3085: }
3086: if ((jj_la1_2[i] & (1 << j)) != 0) {
3087: la1tokens[64 + j] = true;
3088: }
3089: if ((jj_la1_3[i] & (1 << j)) != 0) {
3090: la1tokens[96 + j] = true;
3091: }
3092: }
3093: }
3094: }
3095: for (int i = 0; i < 97; i++) {
3096: if (la1tokens[i]) {
3097: jj_expentry = new int[1];
3098: jj_expentry[0] = i;
3099: jj_expentries.addElement(jj_expentry);
3100: }
3101: }
3102: jj_endpos = 0;
3103: jj_rescan_token();
3104: jj_add_error_token(0, 0);
3105: int[][] exptokseq = new int[jj_expentries.size()][];
3106: for (int i = 0; i < jj_expentries.size(); i++) {
3107: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
3108: }
3109: return new ParseException(token, exptokseq, tokenImage);
3110: }
3111:
3112: final public void enable_tracing() {
3113: }
3114:
3115: final public void disable_tracing() {
3116: }
3117:
3118: final private void jj_rescan_token() {
3119: jj_rescan = true;
3120: for (int i = 0; i < 14; i++) {
3121: JJCalls p = jj_2_rtns[i];
3122: do {
3123: if (p.gen > jj_gen) {
3124: jj_la = p.arg;
3125: jj_lastpos = jj_scanpos = p.first;
3126: switch (i) {
3127: case 0:
3128: jj_3_1();
3129: break;
3130: case 1:
3131: jj_3_2();
3132: break;
3133: case 2:
3134: jj_3_3();
3135: break;
3136: case 3:
3137: jj_3_4();
3138: break;
3139: case 4:
3140: jj_3_5();
3141: break;
3142: case 5:
3143: jj_3_6();
3144: break;
3145: case 6:
3146: jj_3_7();
3147: break;
3148: case 7:
3149: jj_3_8();
3150: break;
3151: case 8:
3152: jj_3_9();
3153: break;
3154: case 9:
3155: jj_3_10();
3156: break;
3157: case 10:
3158: jj_3_11();
3159: break;
3160: case 11:
3161: jj_3_12();
3162: break;
3163: case 12:
3164: jj_3_13();
3165: break;
3166: case 13:
3167: jj_3_14();
3168: break;
3169: }
3170: }
3171: p = p.next;
3172: } while (p != null);
3173: }
3174: jj_rescan = false;
3175: }
3176:
3177: final private void jj_save(int index, int xla) {
3178: JJCalls p = jj_2_rtns[index];
3179: while (p.gen > jj_gen) {
3180: if (p.next == null) {
3181: p = p.next = new JJCalls();
3182: break;
3183: }
3184: p = p.next;
3185: }
3186: p.gen = jj_gen + xla - jj_la;
3187: p.first = token;
3188: p.arg = xla;
3189: }
3190:
3191: static final class JJCalls {
3192: int gen;
3193: Token first;
3194: int arg;
3195: JJCalls next;
3196: }
3197:
3198: }
|