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