0001: /* Generated By:JavaCC: Do not edit this line. JoSQLParserTokenManager.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: import org.josql.Query;
0009: import org.josql.internal.OrderBy;
0010: import org.josql.internal.Limit;
0011: import org.josql.internal.Utilities;
0012: import org.josql.internal.ColumnReference;
0013: import org.josql.expressions.*;
0014:
0015: public class JoSQLParserTokenManager implements JoSQLParserConstants {
0016: public java.io.PrintStream debugStream = System.out;
0017:
0018: public void setDebugStream(java.io.PrintStream ds) {
0019: debugStream = ds;
0020: }
0021:
0022: private final int jjStopStringLiteralDfa_0(int pos, long active0,
0023: long active1) {
0024: switch (pos) {
0025: case 0:
0026: if ((active0 & 0x2000000000L) != 0L
0027: || (active1 & 0x100L) != 0L)
0028: return 12;
0029: if ((active1 & 0x200L) != 0L)
0030: return 25;
0031: if ((active0 & 0x10000000000000L) != 0L)
0032: return 8;
0033: if ((active0 & 0x1fffffffe0L) != 0L) {
0034: jjmatchedKind = 38;
0035: return 33;
0036: }
0037: return -1;
0038: case 1:
0039: if ((active0 & 0x1fff7bb800L) != 0L) {
0040: if (jjmatchedPos != 1) {
0041: jjmatchedKind = 38;
0042: jjmatchedPos = 1;
0043: }
0044: return 33;
0045: }
0046: if ((active0 & 0x8447e0L) != 0L)
0047: return 33;
0048: return -1;
0049: case 2:
0050: if ((active0 & 0x1010007800L) != 0L)
0051: return 33;
0052: if ((active0 & 0xfefff8000L) != 0L) {
0053: jjmatchedKind = 38;
0054: jjmatchedPos = 2;
0055: return 33;
0056: }
0057: return -1;
0058: case 3:
0059: if ((active0 & 0xfcff40000L) != 0L) {
0060: jjmatchedKind = 38;
0061: jjmatchedPos = 3;
0062: return 33;
0063: }
0064: if ((active0 & 0x200b8000L) != 0L)
0065: return 33;
0066: return -1;
0067: case 4:
0068: if ((active0 & 0xa40f00000L) != 0L)
0069: return 33;
0070: if ((active0 & 0x58f040000L) != 0L) {
0071: if (jjmatchedPos != 4) {
0072: jjmatchedKind = 38;
0073: jjmatchedPos = 4;
0074: }
0075: return 33;
0076: }
0077: return -1;
0078: case 5:
0079: if ((active0 & 0xa00000000L) != 0L) {
0080: if (jjmatchedPos != 5) {
0081: jjmatchedKind = 38;
0082: jjmatchedPos = 5;
0083: }
0084: return 1;
0085: }
0086: if ((active0 & 0x403040000L) != 0L)
0087: return 33;
0088: if ((active0 & 0x18c000000L) != 0L) {
0089: if (jjmatchedPos != 5) {
0090: jjmatchedKind = 38;
0091: jjmatchedPos = 5;
0092: }
0093: return 33;
0094: }
0095: return -1;
0096: case 6:
0097: if ((active0 & 0x8000000L) != 0L) {
0098: jjmatchedKind = 38;
0099: jjmatchedPos = 6;
0100: return 33;
0101: }
0102: if ((active0 & 0xe00000000L) != 0L) {
0103: jjmatchedKind = 38;
0104: jjmatchedPos = 6;
0105: return 1;
0106: }
0107: if ((active0 & 0x184000000L) != 0L)
0108: return 33;
0109: return -1;
0110: case 7:
0111: if ((active0 & 0x8000000L) != 0L)
0112: return 33;
0113: if ((active0 & 0xe00000000L) != 0L) {
0114: jjmatchedKind = 38;
0115: jjmatchedPos = 7;
0116: return 1;
0117: }
0118: return -1;
0119: case 8:
0120: if ((active0 & 0xe00000000L) != 0L) {
0121: jjmatchedKind = 38;
0122: jjmatchedPos = 8;
0123: return 1;
0124: }
0125: return -1;
0126: case 9:
0127: if ((active0 & 0xe00000000L) != 0L) {
0128: jjmatchedKind = 38;
0129: jjmatchedPos = 9;
0130: return 1;
0131: }
0132: return -1;
0133: case 10:
0134: if ((active0 & 0xe00000000L) != 0L) {
0135: jjmatchedKind = 38;
0136: jjmatchedPos = 10;
0137: return 1;
0138: }
0139: return -1;
0140: case 11:
0141: if ((active0 & 0xe00000000L) != 0L) {
0142: jjmatchedKind = 38;
0143: jjmatchedPos = 11;
0144: return 1;
0145: }
0146: return -1;
0147: case 12:
0148: if ((active0 & 0x200000000L) != 0L)
0149: return 1;
0150: if ((active0 & 0xc00000000L) != 0L) {
0151: jjmatchedKind = 38;
0152: jjmatchedPos = 12;
0153: return 1;
0154: }
0155: return -1;
0156: case 13:
0157: if ((active0 & 0x400000000L) != 0L)
0158: return 1;
0159: if ((active0 & 0x800000000L) != 0L) {
0160: jjmatchedKind = 38;
0161: jjmatchedPos = 13;
0162: return 1;
0163: }
0164: return -1;
0165: case 14:
0166: if ((active0 & 0x800000000L) != 0L) {
0167: jjmatchedKind = 38;
0168: jjmatchedPos = 14;
0169: return 1;
0170: }
0171: return -1;
0172: default:
0173: return -1;
0174: }
0175: }
0176:
0177: private final int jjStartNfa_0(int pos, long active0, long active1) {
0178: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
0179: active1), pos + 1);
0180: }
0181:
0182: private final int jjStopAtPos(int pos, int kind) {
0183: jjmatchedKind = kind;
0184: jjmatchedPos = pos;
0185: return pos + 1;
0186: }
0187:
0188: private final int jjStartNfaWithStates_0(int pos, int kind,
0189: int state) {
0190: jjmatchedKind = kind;
0191: jjmatchedPos = pos;
0192: try {
0193: curChar = input_stream.readChar();
0194: } catch (java.io.IOException e) {
0195: return pos + 1;
0196: }
0197: return jjMoveNfa_0(state, pos + 1);
0198: }
0199:
0200: private final int jjMoveStringLiteralDfa0_0() {
0201: switch (curChar) {
0202: case 33:
0203: return jjMoveStringLiteralDfa1_0(0x0L, 0x40L);
0204: case 36:
0205: return jjStopAtPos(0, 63);
0206: case 37:
0207: return jjStopAtPos(0, 74);
0208: case 40:
0209: return jjStopAtPos(0, 59);
0210: case 41:
0211: return jjStopAtPos(0, 60);
0212: case 42:
0213: return jjStopAtPos(0, 56);
0214: case 43:
0215: return jjStopAtPos(0, 71);
0216: case 44:
0217: return jjStopAtPos(0, 55);
0218: case 45:
0219: jjmatchedKind = 72;
0220: return jjMoveStringLiteralDfa1_0(0x2000000000L, 0x0L);
0221: case 46:
0222: return jjStartNfaWithStates_0(0, 52, 8);
0223: case 47:
0224: return jjStartNfaWithStates_0(0, 73, 25);
0225: case 58:
0226: jjmatchedKind = 49;
0227: return jjMoveStringLiteralDfa1_0(0x4000000000000L, 0x0L);
0228: case 59:
0229: return jjStopAtPos(0, 54);
0230: case 60:
0231: jjmatchedKind = 65;
0232: return jjMoveStringLiteralDfa1_0(0x0L, 0x30L);
0233: case 61:
0234: return jjStopAtPos(0, 66);
0235: case 62:
0236: jjmatchedKind = 64;
0237: return jjMoveStringLiteralDfa1_0(0x0L, 0x8L);
0238: case 63:
0239: return jjStopAtPos(0, 51);
0240: case 64:
0241: return jjStopAtPos(0, 53);
0242: case 91:
0243: return jjStopAtPos(0, 57);
0244: case 93:
0245: return jjStopAtPos(0, 58);
0246: case 65:
0247: case 97:
0248: return jjMoveStringLiteralDfa1_0(0x5820L, 0x0L);
0249: case 66:
0250: case 98:
0251: return jjMoveStringLiteralDfa1_0(0x4000040L, 0x0L);
0252: case 68:
0253: case 100:
0254: return jjMoveStringLiteralDfa1_0(0x8008000L, 0x0L);
0255: case 69:
0256: case 101:
0257: return jjMoveStringLiteralDfa1_0(0x80000000L, 0x0L);
0258: case 70:
0259: case 102:
0260: return jjMoveStringLiteralDfa1_0(0x40080000L, 0x0L);
0261: case 71:
0262: case 103:
0263: return jjMoveStringLiteralDfa1_0(0x800200000L, 0x0L);
0264: case 72:
0265: case 104:
0266: return jjMoveStringLiteralDfa1_0(0x402000000L, 0x0L);
0267: case 73:
0268: case 105:
0269: return jjMoveStringLiteralDfa1_0(0x40180L, 0x0L);
0270: case 76:
0271: case 108:
0272: return jjMoveStringLiteralDfa1_0(0x420000L, 0x0L);
0273: case 78:
0274: case 110:
0275: return jjMoveStringLiteralDfa1_0(0x1000012000L, 0x0L);
0276: case 79:
0277: case 111:
0278: return jjMoveStringLiteralDfa1_0(0x800600L, 0x0L);
0279: case 82:
0280: case 114:
0281: return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);
0282: case 83:
0283: case 115:
0284: return jjMoveStringLiteralDfa1_0(0x1000000L, 0x0L);
0285: case 84:
0286: case 116:
0287: return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
0288: case 85:
0289: case 117:
0290: return jjMoveStringLiteralDfa1_0(0x10000000L, 0x0L);
0291: case 87:
0292: case 119:
0293: return jjMoveStringLiteralDfa1_0(0x200100000L, 0x0L);
0294: case 123:
0295: return jjStopAtPos(0, 61);
0296: case 125:
0297: return jjStopAtPos(0, 62);
0298: default:
0299: return jjMoveNfa_0(2, 0);
0300: }
0301: }
0302:
0303: private final int jjMoveStringLiteralDfa1_0(long active0,
0304: long active1) {
0305: try {
0306: curChar = input_stream.readChar();
0307: } catch (java.io.IOException e) {
0308: jjStopStringLiteralDfa_0(0, active0, active1);
0309: return 1;
0310: }
0311: switch (curChar) {
0312: case 61:
0313: if ((active1 & 0x8L) != 0L)
0314: return jjStopAtPos(1, 67);
0315: else if ((active1 & 0x10L) != 0L)
0316: return jjStopAtPos(1, 68);
0317: else if ((active1 & 0x40L) != 0L)
0318: return jjStopAtPos(1, 70);
0319: break;
0320: case 62:
0321: if ((active0 & 0x2000000000L) != 0L)
0322: return jjStopAtPos(1, 37);
0323: else if ((active1 & 0x20L) != 0L)
0324: return jjStopAtPos(1, 69);
0325: break;
0326: case 95:
0327: if ((active0 & 0x4000000000000L) != 0L)
0328: return jjStopAtPos(1, 50);
0329: break;
0330: case 65:
0331: case 97:
0332: return jjMoveStringLiteralDfa2_0(active0, 0x442000000L,
0333: active1, 0L);
0334: case 69:
0335: case 101:
0336: return jjMoveStringLiteralDfa2_0(active0, 0x1105008000L,
0337: active1, 0L);
0338: case 72:
0339: case 104:
0340: return jjMoveStringLiteralDfa2_0(active0, 0x200100000L,
0341: active1, 0L);
0342: case 73:
0343: case 105:
0344: return jjMoveStringLiteralDfa2_0(active0, 0x8420000L,
0345: active1, 0L);
0346: case 76:
0347: case 108:
0348: return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1,
0349: 0L);
0350: case 78:
0351: case 110:
0352: if ((active0 & 0x100L) != 0L) {
0353: jjmatchedKind = 8;
0354: jjmatchedPos = 1;
0355: } else if ((active0 & 0x400L) != 0L)
0356: return jjStartNfaWithStates_0(1, 10, 33);
0357: return jjMoveStringLiteralDfa2_0(active0, 0x41000L,
0358: active1, 0L);
0359: case 79:
0360: case 111:
0361: return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1,
0362: 0L);
0363: case 82:
0364: case 114:
0365: if ((active0 & 0x200L) != 0L) {
0366: jjmatchedKind = 9;
0367: jjmatchedPos = 1;
0368: }
0369: return jjMoveStringLiteralDfa2_0(active0, 0x820a80000L,
0370: active1, 0L);
0371: case 83:
0372: case 115:
0373: if ((active0 & 0x20L) != 0L) {
0374: jjmatchedKind = 5;
0375: jjmatchedPos = 1;
0376: } else if ((active0 & 0x80L) != 0L)
0377: return jjStartNfaWithStates_0(1, 7, 33);
0378: return jjMoveStringLiteralDfa2_0(active0, 0x10004000L,
0379: active1, 0L);
0380: case 85:
0381: case 117:
0382: return jjMoveStringLiteralDfa2_0(active0, 0x10000L,
0383: active1, 0L);
0384: case 88:
0385: case 120:
0386: return jjMoveStringLiteralDfa2_0(active0, 0x80000000L,
0387: active1, 0L);
0388: case 89:
0389: case 121:
0390: if ((active0 & 0x40L) != 0L)
0391: return jjStartNfaWithStates_0(1, 6, 33);
0392: break;
0393: default:
0394: break;
0395: }
0396: return jjStartNfa_0(0, active0, active1);
0397: }
0398:
0399: private final int jjMoveStringLiteralDfa2_0(long old0,
0400: long active0, long old1, long active1) {
0401: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0402: return jjStartNfa_0(0, old0, old1);
0403: try {
0404: curChar = input_stream.readChar();
0405: } catch (java.io.IOException e) {
0406: jjStopStringLiteralDfa_0(1, active0, 0L);
0407: return 2;
0408: }
0409: switch (curChar) {
0410: case 67:
0411: case 99:
0412: if ((active0 & 0x4000L) != 0L)
0413: return jjStartNfaWithStates_0(2, 14, 33);
0414: break;
0415: case 68:
0416: case 100:
0417: if ((active0 & 0x1000L) != 0L)
0418: return jjStartNfaWithStates_0(2, 12, 33);
0419: return jjMoveStringLiteralDfa3_0(active0, 0x800000L);
0420: case 69:
0421: case 101:
0422: if ((active0 & 0x10000000L) != 0L)
0423: return jjStartNfaWithStates_0(2, 28, 33);
0424: return jjMoveStringLiteralDfa3_0(active0, 0x280100000L);
0425: case 75:
0426: case 107:
0427: return jjMoveStringLiteralDfa3_0(active0, 0x20000L);
0428: case 76:
0429: case 108:
0430: if ((active0 & 0x800L) != 0L)
0431: return jjStartNfaWithStates_0(2, 11, 33);
0432: return jjMoveStringLiteralDfa3_0(active0, 0x41050000L);
0433: case 77:
0434: case 109:
0435: return jjMoveStringLiteralDfa3_0(active0, 0x400000L);
0436: case 79:
0437: case 111:
0438: return jjMoveStringLiteralDfa3_0(active0, 0x800280000L);
0439: case 83:
0440: case 115:
0441: return jjMoveStringLiteralDfa3_0(active0, 0x108008000L);
0442: case 84:
0443: case 116:
0444: if ((active0 & 0x2000L) != 0L)
0445: return jjStartNfaWithStates_0(2, 13, 33);
0446: return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);
0447: case 85:
0448: case 117:
0449: return jjMoveStringLiteralDfa3_0(active0, 0x20000000L);
0450: case 86:
0451: case 118:
0452: return jjMoveStringLiteralDfa3_0(active0, 0x402000000L);
0453: case 87:
0454: case 119:
0455: if ((active0 & 0x1000000000L) != 0L)
0456: return jjStartNfaWithStates_0(2, 36, 33);
0457: break;
0458: default:
0459: break;
0460: }
0461: return jjStartNfa_0(1, active0, 0L);
0462: }
0463:
0464: private final int jjMoveStringLiteralDfa3_0(long old0, long active0) {
0465: if (((active0 &= old0)) == 0L)
0466: return jjStartNfa_0(1, old0, 0L);
0467: try {
0468: curChar = input_stream.readChar();
0469: } catch (java.io.IOException e) {
0470: jjStopStringLiteralDfa_0(2, active0, 0L);
0471: return 3;
0472: }
0473: switch (curChar) {
0474: case 67:
0475: case 99:
0476: if ((active0 & 0x8000L) != 0L)
0477: return jjStartNfaWithStates_0(3, 15, 33);
0478: return jjMoveStringLiteralDfa4_0(active0, 0x80000000L);
0479: case 69:
0480: case 101:
0481: if ((active0 & 0x20000L) != 0L)
0482: return jjStartNfaWithStates_0(3, 17, 33);
0483: else if ((active0 & 0x20000000L) != 0L)
0484: return jjStartNfaWithStates_0(3, 29, 33);
0485: return jjMoveStringLiteralDfa4_0(active0, 0x1800000L);
0486: case 73:
0487: case 105:
0488: return jjMoveStringLiteralDfa4_0(active0, 0x402440000L);
0489: case 76:
0490: case 108:
0491: if ((active0 & 0x10000L) != 0L)
0492: return jjStartNfaWithStates_0(3, 16, 33);
0493: break;
0494: case 77:
0495: case 109:
0496: if ((active0 & 0x80000L) != 0L)
0497: return jjStartNfaWithStates_0(3, 19, 33);
0498: break;
0499: case 82:
0500: case 114:
0501: return jjMoveStringLiteralDfa4_0(active0, 0x200100000L);
0502: case 83:
0503: case 115:
0504: return jjMoveStringLiteralDfa4_0(active0, 0x40000000L);
0505: case 84:
0506: case 116:
0507: return jjMoveStringLiteralDfa4_0(active0, 0x8000000L);
0508: case 85:
0509: case 117:
0510: return jjMoveStringLiteralDfa4_0(active0, 0x900200000L);
0511: case 87:
0512: case 119:
0513: return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
0514: default:
0515: break;
0516: }
0517: return jjStartNfa_0(2, active0, 0L);
0518: }
0519:
0520: private final int jjMoveStringLiteralDfa4_0(long old0, long active0) {
0521: if (((active0 &= old0)) == 0L)
0522: return jjStartNfa_0(2, old0, 0L);
0523: try {
0524: curChar = input_stream.readChar();
0525: } catch (java.io.IOException e) {
0526: jjStopStringLiteralDfa_0(3, active0, 0L);
0527: return 4;
0528: }
0529: switch (curChar) {
0530: case 67:
0531: case 99:
0532: return jjMoveStringLiteralDfa5_0(active0, 0x1000000L);
0533: case 69:
0534: case 101:
0535: if ((active0 & 0x100000L) != 0L) {
0536: jjmatchedKind = 20;
0537: jjmatchedPos = 4;
0538: } else if ((active0 & 0x40000000L) != 0L)
0539: return jjStartNfaWithStates_0(4, 30, 33);
0540: return jjMoveStringLiteralDfa5_0(active0, 0x204000000L);
0541: case 73:
0542: case 105:
0543: return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
0544: case 75:
0545: case 107:
0546: return jjMoveStringLiteralDfa5_0(active0, 0x40000L);
0547: case 76:
0548: case 108:
0549: return jjMoveStringLiteralDfa5_0(active0, 0x100000000L);
0550: case 78:
0551: case 110:
0552: return jjMoveStringLiteralDfa5_0(active0, 0x402000000L);
0553: case 80:
0554: case 112:
0555: if ((active0 & 0x200000L) != 0L) {
0556: jjmatchedKind = 21;
0557: jjmatchedPos = 4;
0558: }
0559: return jjMoveStringLiteralDfa5_0(active0, 0x800000000L);
0560: case 82:
0561: case 114:
0562: if ((active0 & 0x800000L) != 0L)
0563: return jjStartNfaWithStates_0(4, 23, 33);
0564: break;
0565: case 84:
0566: case 116:
0567: if ((active0 & 0x400000L) != 0L)
0568: return jjStartNfaWithStates_0(4, 22, 33);
0569: break;
0570: case 85:
0571: case 117:
0572: return jjMoveStringLiteralDfa5_0(active0, 0x80000000L);
0573: default:
0574: break;
0575: }
0576: return jjStartNfa_0(3, active0, 0L);
0577: }
0578:
0579: private final int jjMoveStringLiteralDfa5_0(long old0, long active0) {
0580: if (((active0 &= old0)) == 0L)
0581: return jjStartNfa_0(3, old0, 0L);
0582: try {
0583: curChar = input_stream.readChar();
0584: } catch (java.io.IOException e) {
0585: jjStopStringLiteralDfa_0(4, active0, 0L);
0586: return 5;
0587: }
0588: switch (curChar) {
0589: case 95:
0590: return jjMoveStringLiteralDfa6_0(active0, 0xa00000000L);
0591: case 69:
0592: case 101:
0593: if ((active0 & 0x40000L) != 0L)
0594: return jjStartNfaWithStates_0(5, 18, 33);
0595: return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
0596: case 71:
0597: case 103:
0598: if ((active0 & 0x2000000L) != 0L) {
0599: jjmatchedKind = 25;
0600: jjmatchedPos = 5;
0601: }
0602: return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);
0603: case 78:
0604: case 110:
0605: return jjMoveStringLiteralDfa6_0(active0, 0x8000000L);
0606: case 84:
0607: case 116:
0608: if ((active0 & 0x1000000L) != 0L)
0609: return jjStartNfaWithStates_0(5, 24, 33);
0610: return jjMoveStringLiteralDfa6_0(active0, 0x180000000L);
0611: default:
0612: break;
0613: }
0614: return jjStartNfa_0(4, active0, 0L);
0615: }
0616:
0617: private final int jjMoveStringLiteralDfa6_0(long old0, long active0) {
0618: if (((active0 &= old0)) == 0L)
0619: return jjStartNfa_0(4, old0, 0L);
0620: try {
0621: curChar = input_stream.readChar();
0622: } catch (java.io.IOException e) {
0623: jjStopStringLiteralDfa_0(5, active0, 0L);
0624: return 6;
0625: }
0626: switch (curChar) {
0627: case 95:
0628: return jjMoveStringLiteralDfa7_0(active0, 0x400000000L);
0629: case 66:
0630: case 98:
0631: return jjMoveStringLiteralDfa7_0(active0, 0x800000000L);
0632: case 67:
0633: case 99:
0634: return jjMoveStringLiteralDfa7_0(active0, 0x8000000L);
0635: case 69:
0636: case 101:
0637: if ((active0 & 0x80000000L) != 0L)
0638: return jjStartNfaWithStates_0(6, 31, 33);
0639: break;
0640: case 78:
0641: case 110:
0642: if ((active0 & 0x4000000L) != 0L)
0643: return jjStartNfaWithStates_0(6, 26, 33);
0644: break;
0645: case 82:
0646: case 114:
0647: return jjMoveStringLiteralDfa7_0(active0, 0x200000000L);
0648: case 83:
0649: case 115:
0650: if ((active0 & 0x100000000L) != 0L)
0651: return jjStartNfaWithStates_0(6, 32, 33);
0652: break;
0653: default:
0654: break;
0655: }
0656: return jjStartNfa_0(5, active0, 0L);
0657: }
0658:
0659: private final int jjMoveStringLiteralDfa7_0(long old0, long active0) {
0660: if (((active0 &= old0)) == 0L)
0661: return jjStartNfa_0(5, old0, 0L);
0662: try {
0663: curChar = input_stream.readChar();
0664: } catch (java.io.IOException e) {
0665: jjStopStringLiteralDfa_0(6, active0, 0L);
0666: return 7;
0667: }
0668: switch (curChar) {
0669: case 69:
0670: case 101:
0671: return jjMoveStringLiteralDfa8_0(active0, 0x200000000L);
0672: case 82:
0673: case 114:
0674: return jjMoveStringLiteralDfa8_0(active0, 0x400000000L);
0675: case 84:
0676: case 116:
0677: if ((active0 & 0x8000000L) != 0L)
0678: return jjStartNfaWithStates_0(7, 27, 33);
0679: break;
0680: case 89:
0681: case 121:
0682: return jjMoveStringLiteralDfa8_0(active0, 0x800000000L);
0683: default:
0684: break;
0685: }
0686: return jjStartNfa_0(6, active0, 0L);
0687: }
0688:
0689: private final int jjMoveStringLiteralDfa8_0(long old0, long active0) {
0690: if (((active0 &= old0)) == 0L)
0691: return jjStartNfa_0(6, old0, 0L);
0692: try {
0693: curChar = input_stream.readChar();
0694: } catch (java.io.IOException e) {
0695: jjStopStringLiteralDfa_0(7, active0, 0L);
0696: return 8;
0697: }
0698: switch (curChar) {
0699: case 95:
0700: return jjMoveStringLiteralDfa9_0(active0, 0x800000000L);
0701: case 69:
0702: case 101:
0703: return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
0704: case 83:
0705: case 115:
0706: return jjMoveStringLiteralDfa9_0(active0, 0x200000000L);
0707: default:
0708: break;
0709: }
0710: return jjStartNfa_0(7, active0, 0L);
0711: }
0712:
0713: private final int jjMoveStringLiteralDfa9_0(long old0, long active0) {
0714: if (((active0 &= old0)) == 0L)
0715: return jjStartNfa_0(7, old0, 0L);
0716: try {
0717: curChar = input_stream.readChar();
0718: } catch (java.io.IOException e) {
0719: jjStopStringLiteralDfa_0(8, active0, 0L);
0720: return 9;
0721: }
0722: switch (curChar) {
0723: case 82:
0724: case 114:
0725: return jjMoveStringLiteralDfa10_0(active0, 0x800000000L);
0726: case 83:
0727: case 115:
0728: return jjMoveStringLiteralDfa10_0(active0, 0x400000000L);
0729: case 85:
0730: case 117:
0731: return jjMoveStringLiteralDfa10_0(active0, 0x200000000L);
0732: default:
0733: break;
0734: }
0735: return jjStartNfa_0(8, active0, 0L);
0736: }
0737:
0738: private final int jjMoveStringLiteralDfa10_0(long old0, long active0) {
0739: if (((active0 &= old0)) == 0L)
0740: return jjStartNfa_0(8, old0, 0L);
0741: try {
0742: curChar = input_stream.readChar();
0743: } catch (java.io.IOException e) {
0744: jjStopStringLiteralDfa_0(9, active0, 0L);
0745: return 10;
0746: }
0747: switch (curChar) {
0748: case 69:
0749: case 101:
0750: return jjMoveStringLiteralDfa11_0(active0, 0x800000000L);
0751: case 76:
0752: case 108:
0753: return jjMoveStringLiteralDfa11_0(active0, 0x200000000L);
0754: case 85:
0755: case 117:
0756: return jjMoveStringLiteralDfa11_0(active0, 0x400000000L);
0757: default:
0758: break;
0759: }
0760: return jjStartNfa_0(9, active0, 0L);
0761: }
0762:
0763: private final int jjMoveStringLiteralDfa11_0(long old0, long active0) {
0764: if (((active0 &= old0)) == 0L)
0765: return jjStartNfa_0(9, old0, 0L);
0766: try {
0767: curChar = input_stream.readChar();
0768: } catch (java.io.IOException e) {
0769: jjStopStringLiteralDfa_0(10, active0, 0L);
0770: return 11;
0771: }
0772: switch (curChar) {
0773: case 76:
0774: case 108:
0775: return jjMoveStringLiteralDfa12_0(active0, 0x400000000L);
0776: case 83:
0777: case 115:
0778: return jjMoveStringLiteralDfa12_0(active0, 0x800000000L);
0779: case 84:
0780: case 116:
0781: return jjMoveStringLiteralDfa12_0(active0, 0x200000000L);
0782: default:
0783: break;
0784: }
0785: return jjStartNfa_0(10, active0, 0L);
0786: }
0787:
0788: private final int jjMoveStringLiteralDfa12_0(long old0, long active0) {
0789: if (((active0 &= old0)) == 0L)
0790: return jjStartNfa_0(10, old0, 0L);
0791: try {
0792: curChar = input_stream.readChar();
0793: } catch (java.io.IOException e) {
0794: jjStopStringLiteralDfa_0(11, active0, 0L);
0795: return 12;
0796: }
0797: switch (curChar) {
0798: case 83:
0799: case 115:
0800: if ((active0 & 0x200000000L) != 0L)
0801: return jjStartNfaWithStates_0(12, 33, 1);
0802: break;
0803: case 84:
0804: case 116:
0805: return jjMoveStringLiteralDfa13_0(active0, 0x400000000L);
0806: case 85:
0807: case 117:
0808: return jjMoveStringLiteralDfa13_0(active0, 0x800000000L);
0809: default:
0810: break;
0811: }
0812: return jjStartNfa_0(11, active0, 0L);
0813: }
0814:
0815: private final int jjMoveStringLiteralDfa13_0(long old0, long active0) {
0816: if (((active0 &= old0)) == 0L)
0817: return jjStartNfa_0(11, old0, 0L);
0818: try {
0819: curChar = input_stream.readChar();
0820: } catch (java.io.IOException e) {
0821: jjStopStringLiteralDfa_0(12, active0, 0L);
0822: return 13;
0823: }
0824: switch (curChar) {
0825: case 76:
0826: case 108:
0827: return jjMoveStringLiteralDfa14_0(active0, 0x800000000L);
0828: case 83:
0829: case 115:
0830: if ((active0 & 0x400000000L) != 0L)
0831: return jjStartNfaWithStates_0(13, 34, 1);
0832: break;
0833: default:
0834: break;
0835: }
0836: return jjStartNfa_0(12, active0, 0L);
0837: }
0838:
0839: private final int jjMoveStringLiteralDfa14_0(long old0, long active0) {
0840: if (((active0 &= old0)) == 0L)
0841: return jjStartNfa_0(12, old0, 0L);
0842: try {
0843: curChar = input_stream.readChar();
0844: } catch (java.io.IOException e) {
0845: jjStopStringLiteralDfa_0(13, active0, 0L);
0846: return 14;
0847: }
0848: switch (curChar) {
0849: case 84:
0850: case 116:
0851: return jjMoveStringLiteralDfa15_0(active0, 0x800000000L);
0852: default:
0853: break;
0854: }
0855: return jjStartNfa_0(13, active0, 0L);
0856: }
0857:
0858: private final int jjMoveStringLiteralDfa15_0(long old0, long active0) {
0859: if (((active0 &= old0)) == 0L)
0860: return jjStartNfa_0(13, old0, 0L);
0861: try {
0862: curChar = input_stream.readChar();
0863: } catch (java.io.IOException e) {
0864: jjStopStringLiteralDfa_0(14, active0, 0L);
0865: return 15;
0866: }
0867: switch (curChar) {
0868: case 83:
0869: case 115:
0870: if ((active0 & 0x800000000L) != 0L)
0871: return jjStartNfaWithStates_0(15, 35, 1);
0872: break;
0873: default:
0874: break;
0875: }
0876: return jjStartNfa_0(14, active0, 0L);
0877: }
0878:
0879: private final void jjCheckNAdd(int state) {
0880: if (jjrounds[state] != jjround) {
0881: jjstateSet[jjnewStateCnt++] = state;
0882: jjrounds[state] = jjround;
0883: }
0884: }
0885:
0886: private final void jjAddStates(int start, int end) {
0887: do {
0888: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0889: } while (start++ != end);
0890: }
0891:
0892: private final void jjCheckNAddTwoStates(int state1, int state2) {
0893: jjCheckNAdd(state1);
0894: jjCheckNAdd(state2);
0895: }
0896:
0897: private final void jjCheckNAddStates(int start, int end) {
0898: do {
0899: jjCheckNAdd(jjnextStates[start]);
0900: } while (start++ != end);
0901: }
0902:
0903: private final void jjCheckNAddStates(int start) {
0904: jjCheckNAdd(jjnextStates[start]);
0905: jjCheckNAdd(jjnextStates[start + 1]);
0906: }
0907:
0908: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0909: 0xffffffffffffffffL, 0xffffffffffffffffL,
0910: 0xffffffffffffffffL };
0911: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0912: 0xffffffffffffffffL };
0913:
0914: private final int jjMoveNfa_0(int startState, int curPos) {
0915: int[] nextStates;
0916: int startsAt = 0;
0917: jjnewStateCnt = 33;
0918: int i = 1;
0919: jjstateSet[0] = startState;
0920: int j, kind = 0x7fffffff;
0921: for (;;) {
0922: if (++jjround == 0x7fffffff)
0923: ReInitRounds();
0924: if (curChar < 64) {
0925: long l = 1L << curChar;
0926: MatchLoop: do {
0927: switch (jjstateSet[--i]) {
0928: case 2:
0929: if ((0x3ff000000000000L & l) != 0L) {
0930: if (kind > 45)
0931: kind = 45;
0932: jjCheckNAddStates(0, 2);
0933: } else if (curChar == 47)
0934: jjAddStates(3, 4);
0935: else if (curChar == 34)
0936: jjCheckNAddStates(5, 8);
0937: else if (curChar == 45)
0938: jjstateSet[jjnewStateCnt++] = 12;
0939: else if (curChar == 46)
0940: jjCheckNAdd(8);
0941: else if (curChar == 39)
0942: jjCheckNAddTwoStates(3, 4);
0943: break;
0944: case 25:
0945: if (curChar == 42)
0946: jjCheckNAddTwoStates(28, 29);
0947: else if (curChar == 47) {
0948: if (kind > 47)
0949: kind = 47;
0950: jjCheckNAdd(26);
0951: }
0952: break;
0953: case 33:
0954: case 1:
0955: if ((0x3ff001000000000L & l) == 0L)
0956: break;
0957: if (kind > 38)
0958: kind = 38;
0959: jjCheckNAdd(1);
0960: break;
0961: case 3:
0962: if ((0xffffff7fffffffffL & l) != 0L)
0963: jjCheckNAddTwoStates(3, 4);
0964: break;
0965: case 4:
0966: if (curChar != 39)
0967: break;
0968: if (kind > 41)
0969: kind = 41;
0970: jjstateSet[jjnewStateCnt++] = 5;
0971: break;
0972: case 5:
0973: if (curChar == 39)
0974: jjCheckNAddTwoStates(6, 4);
0975: break;
0976: case 6:
0977: if ((0xffffff7fffffffffL & l) != 0L)
0978: jjCheckNAddTwoStates(6, 4);
0979: break;
0980: case 7:
0981: if (curChar == 46)
0982: jjCheckNAdd(8);
0983: break;
0984: case 8:
0985: if ((0x3ff000000000000L & l) == 0L)
0986: break;
0987: if (kind > 44)
0988: kind = 44;
0989: jjCheckNAddTwoStates(8, 9);
0990: break;
0991: case 10:
0992: if ((0x280000000000L & l) != 0L)
0993: jjCheckNAdd(11);
0994: break;
0995: case 11:
0996: if ((0x3ff000000000000L & l) == 0L)
0997: break;
0998: if (kind > 44)
0999: kind = 44;
1000: jjCheckNAdd(11);
1001: break;
1002: case 12:
1003: if (curChar == 45 && kind > 47)
1004: kind = 47;
1005: break;
1006: case 13:
1007: if (curChar == 45)
1008: jjstateSet[jjnewStateCnt++] = 12;
1009: break;
1010: case 14:
1011: if (curChar == 34)
1012: jjCheckNAddStates(5, 8);
1013: break;
1014: case 15:
1015: if ((0xfffffffbffffffffL & l) != 0L)
1016: jjCheckNAddTwoStates(15, 16);
1017: break;
1018: case 16:
1019: if (curChar != 34)
1020: break;
1021: if (kind > 42)
1022: kind = 42;
1023: jjstateSet[jjnewStateCnt++] = 17;
1024: break;
1025: case 17:
1026: if (curChar == 34)
1027: jjCheckNAddTwoStates(18, 16);
1028: break;
1029: case 18:
1030: if ((0xfffffffbffffffffL & l) != 0L)
1031: jjCheckNAddTwoStates(18, 16);
1032: break;
1033: case 19:
1034: if ((0xfffffffbffffdbffL & l) != 0L)
1035: jjCheckNAddTwoStates(19, 20);
1036: break;
1037: case 20:
1038: if (curChar == 34 && kind > 43)
1039: kind = 43;
1040: break;
1041: case 21:
1042: if ((0x3ff000000000000L & l) == 0L)
1043: break;
1044: if (kind > 45)
1045: kind = 45;
1046: jjCheckNAddStates(0, 2);
1047: break;
1048: case 22:
1049: if ((0x3ff000000000000L & l) != 0L)
1050: jjCheckNAddTwoStates(22, 7);
1051: break;
1052: case 23:
1053: if ((0x3ff000000000000L & l) == 0L)
1054: break;
1055: if (kind > 45)
1056: kind = 45;
1057: jjCheckNAdd(23);
1058: break;
1059: case 24:
1060: if (curChar == 47)
1061: jjAddStates(3, 4);
1062: break;
1063: case 26:
1064: if ((0xffffffffffffdbffL & l) == 0L)
1065: break;
1066: if (kind > 47)
1067: kind = 47;
1068: jjCheckNAdd(26);
1069: break;
1070: case 27:
1071: if (curChar == 42)
1072: jjCheckNAddTwoStates(28, 29);
1073: break;
1074: case 28:
1075: if ((0xfffffbffffffffffL & l) != 0L)
1076: jjCheckNAddTwoStates(28, 29);
1077: break;
1078: case 29:
1079: if (curChar == 42)
1080: jjCheckNAddStates(9, 11);
1081: break;
1082: case 30:
1083: if ((0xffff7bffffffffffL & l) != 0L)
1084: jjCheckNAddTwoStates(31, 29);
1085: break;
1086: case 31:
1087: if ((0xfffffbffffffffffL & l) != 0L)
1088: jjCheckNAddTwoStates(31, 29);
1089: break;
1090: case 32:
1091: if (curChar == 47 && kind > 48)
1092: kind = 48;
1093: break;
1094: default:
1095: break;
1096: }
1097: } while (i != startsAt);
1098: } else if (curChar < 128) {
1099: long l = 1L << (curChar & 077);
1100: MatchLoop: do {
1101: switch (jjstateSet[--i]) {
1102: case 2:
1103: case 0:
1104: if ((0x7fffffe07fffffeL & l) == 0L)
1105: break;
1106: if (kind > 38)
1107: kind = 38;
1108: jjCheckNAddTwoStates(0, 1);
1109: break;
1110: case 33:
1111: if ((0x7fffffe87fffffeL & l) != 0L) {
1112: if (kind > 38)
1113: kind = 38;
1114: jjCheckNAdd(1);
1115: }
1116: if ((0x7fffffe07fffffeL & l) != 0L) {
1117: if (kind > 38)
1118: kind = 38;
1119: jjCheckNAddTwoStates(0, 1);
1120: }
1121: break;
1122: case 1:
1123: if ((0x7fffffe87fffffeL & l) == 0L)
1124: break;
1125: if (kind > 38)
1126: kind = 38;
1127: jjCheckNAdd(1);
1128: break;
1129: case 3:
1130: jjCheckNAddTwoStates(3, 4);
1131: break;
1132: case 6:
1133: jjCheckNAddTwoStates(6, 4);
1134: break;
1135: case 9:
1136: if ((0x2000000020L & l) != 0L)
1137: jjAddStates(12, 13);
1138: break;
1139: case 15:
1140: jjCheckNAddTwoStates(15, 16);
1141: break;
1142: case 18:
1143: jjCheckNAddTwoStates(18, 16);
1144: break;
1145: case 19:
1146: jjAddStates(14, 15);
1147: break;
1148: case 26:
1149: if (kind > 47)
1150: kind = 47;
1151: jjstateSet[jjnewStateCnt++] = 26;
1152: break;
1153: case 28:
1154: jjCheckNAddTwoStates(28, 29);
1155: break;
1156: case 30:
1157: case 31:
1158: jjCheckNAddTwoStates(31, 29);
1159: break;
1160: default:
1161: break;
1162: }
1163: } while (i != startsAt);
1164: } else {
1165: int hiByte = (int) (curChar >> 8);
1166: int i1 = hiByte >> 6;
1167: long l1 = 1L << (hiByte & 077);
1168: int i2 = (curChar & 0xff) >> 6;
1169: long l2 = 1L << (curChar & 077);
1170: MatchLoop: do {
1171: switch (jjstateSet[--i]) {
1172: case 3:
1173: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1174: jjCheckNAddTwoStates(3, 4);
1175: break;
1176: case 6:
1177: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1178: jjCheckNAddTwoStates(6, 4);
1179: break;
1180: case 15:
1181: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1182: jjCheckNAddTwoStates(15, 16);
1183: break;
1184: case 18:
1185: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1186: jjCheckNAddTwoStates(18, 16);
1187: break;
1188: case 19:
1189: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1190: jjAddStates(14, 15);
1191: break;
1192: case 26:
1193: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1194: break;
1195: if (kind > 47)
1196: kind = 47;
1197: jjstateSet[jjnewStateCnt++] = 26;
1198: break;
1199: case 28:
1200: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1201: jjCheckNAddTwoStates(28, 29);
1202: break;
1203: case 30:
1204: case 31:
1205: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1206: jjCheckNAddTwoStates(31, 29);
1207: break;
1208: default:
1209: break;
1210: }
1211: } while (i != startsAt);
1212: }
1213: if (kind != 0x7fffffff) {
1214: jjmatchedKind = kind;
1215: jjmatchedPos = curPos;
1216: kind = 0x7fffffff;
1217: }
1218: ++curPos;
1219: if ((i = jjnewStateCnt) == (startsAt = 33 - (jjnewStateCnt = startsAt)))
1220: return curPos;
1221: try {
1222: curChar = input_stream.readChar();
1223: } catch (java.io.IOException e) {
1224: return curPos;
1225: }
1226: }
1227: }
1228:
1229: static final int[] jjnextStates = { 22, 7, 23, 25, 27, 15, 16, 19,
1230: 20, 29, 30, 32, 10, 11, 19, 20, };
1231:
1232: private static final boolean jjCanMove_0(int hiByte, int i1,
1233: int i2, long l1, long l2) {
1234: switch (hiByte) {
1235: case 0:
1236: return ((jjbitVec2[i2] & l2) != 0L);
1237: default:
1238: if ((jjbitVec0[i1] & l1) != 0L)
1239: return true;
1240: return false;
1241: }
1242: }
1243:
1244: public static final String[] jjstrLiteralImages = { "", null, null,
1245: null, null, null, null, null, null, null, null, null, null,
1246: null, null, null, null, null, null, null, null, null, null,
1247: null, null, null, null, null, null, null, null, null, null,
1248: null, null, null, null, "\55\76", null, null, null, null,
1249: null, null, null, null, null, null, null, "\72", "\72\137",
1250: "\77", "\56", "\100", "\73", "\54", "\52", "\133", "\135",
1251: "\50", "\51", "\173", "\175", "\44", "\76", "\74", "\75",
1252: "\76\75", "\74\75", "\74\76", "\41\75", "\53", "\55",
1253: "\57", "\45", };
1254: public static final String[] lexStateNames = { "DEFAULT", };
1255: static final long[] jjtoToken = { 0xfffe3e7fffffffe1L, 0x7ffL, };
1256: static final long[] jjtoSkip = { 0x180000000001eL, 0x0L, };
1257: static final long[] jjtoSpecial = { 0x1800000000000L, 0x0L, };
1258: protected JavaCharStream input_stream;
1259: private final int[] jjrounds = new int[33];
1260: private final int[] jjstateSet = new int[66];
1261: protected char curChar;
1262:
1263: public JoSQLParserTokenManager(JavaCharStream stream) {
1264: if (JavaCharStream.staticFlag)
1265: throw new Error(
1266: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1267: input_stream = stream;
1268: }
1269:
1270: public JoSQLParserTokenManager(JavaCharStream stream, int lexState) {
1271: this (stream);
1272: SwitchTo(lexState);
1273: }
1274:
1275: public void ReInit(JavaCharStream stream) {
1276: jjmatchedPos = jjnewStateCnt = 0;
1277: curLexState = defaultLexState;
1278: input_stream = stream;
1279: ReInitRounds();
1280: }
1281:
1282: private final void ReInitRounds() {
1283: int i;
1284: jjround = 0x80000001;
1285: for (i = 33; i-- > 0;)
1286: jjrounds[i] = 0x80000000;
1287: }
1288:
1289: public void ReInit(JavaCharStream stream, int lexState) {
1290: ReInit(stream);
1291: SwitchTo(lexState);
1292: }
1293:
1294: public void SwitchTo(int lexState) {
1295: if (lexState >= 1 || lexState < 0)
1296: throw new TokenMgrError(
1297: "Error: Ignoring invalid lexical state : "
1298: + lexState + ". State unchanged.",
1299: TokenMgrError.INVALID_LEXICAL_STATE);
1300: else
1301: curLexState = lexState;
1302: }
1303:
1304: protected Token jjFillToken() {
1305: Token t = Token.newToken(jjmatchedKind);
1306: t.kind = jjmatchedKind;
1307: String im = jjstrLiteralImages[jjmatchedKind];
1308: t.image = (im == null) ? input_stream.GetImage() : im;
1309: t.beginLine = input_stream.getBeginLine();
1310: t.beginColumn = input_stream.getBeginColumn();
1311: t.endLine = input_stream.getEndLine();
1312: t.endColumn = input_stream.getEndColumn();
1313: return t;
1314: }
1315:
1316: int curLexState = 0;
1317: int defaultLexState = 0;
1318: int jjnewStateCnt;
1319: int jjround;
1320: int jjmatchedPos;
1321: int jjmatchedKind;
1322:
1323: public Token getNextToken() {
1324: int kind;
1325: Token specialToken = null;
1326: Token matchedToken;
1327: int curPos = 0;
1328:
1329: EOFLoop: for (;;) {
1330: try {
1331: curChar = input_stream.BeginToken();
1332: } catch (java.io.IOException e) {
1333: jjmatchedKind = 0;
1334: matchedToken = jjFillToken();
1335: matchedToken.specialToken = specialToken;
1336: return matchedToken;
1337: }
1338:
1339: try {
1340: input_stream.backup(0);
1341: while (curChar <= 32
1342: && (0x100002600L & (1L << curChar)) != 0L)
1343: curChar = input_stream.BeginToken();
1344: } catch (java.io.IOException e1) {
1345: continue EOFLoop;
1346: }
1347: jjmatchedKind = 0x7fffffff;
1348: jjmatchedPos = 0;
1349: curPos = jjMoveStringLiteralDfa0_0();
1350: if (jjmatchedKind != 0x7fffffff) {
1351: if (jjmatchedPos + 1 < curPos)
1352: input_stream.backup(curPos - jjmatchedPos - 1);
1353: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1354: matchedToken = jjFillToken();
1355: matchedToken.specialToken = specialToken;
1356: return matchedToken;
1357: } else {
1358: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1359: matchedToken = jjFillToken();
1360: if (specialToken == null)
1361: specialToken = matchedToken;
1362: else {
1363: matchedToken.specialToken = specialToken;
1364: specialToken = (specialToken.next = matchedToken);
1365: }
1366: }
1367: continue EOFLoop;
1368: }
1369: }
1370: int error_line = input_stream.getEndLine();
1371: int error_column = input_stream.getEndColumn();
1372: String error_after = null;
1373: boolean EOFSeen = false;
1374: try {
1375: input_stream.readChar();
1376: input_stream.backup(1);
1377: } catch (java.io.IOException e1) {
1378: EOFSeen = true;
1379: error_after = curPos <= 1 ? "" : input_stream
1380: .GetImage();
1381: if (curChar == '\n' || curChar == '\r') {
1382: error_line++;
1383: error_column = 0;
1384: } else
1385: error_column++;
1386: }
1387: if (!EOFSeen) {
1388: input_stream.backup(1);
1389: error_after = curPos <= 1 ? "" : input_stream
1390: .GetImage();
1391: }
1392: throw new TokenMgrError(EOFSeen, curLexState, error_line,
1393: error_column, error_after, curChar,
1394: TokenMgrError.LEXICAL_ERROR);
1395: }
1396: }
1397:
1398: }
|