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