0001: /* Generated By:JavaCC: Do not edit this line. SQLConditionParserTokenManager.java */
0002: package org.netbeans.modules.sql.framework.parser.conditionparser;
0003:
0004: public class SQLConditionParserTokenManager implements
0005: SQLConditionParserConstants {
0006: public java.io.PrintStream debugStream = System.out;
0007:
0008: public void setDebugStream(java.io.PrintStream ds) {
0009: debugStream = ds;
0010: }
0011:
0012: private final int jjStopStringLiteralDfa_0(int pos, long active0,
0013: long active1) {
0014: switch (pos) {
0015: case 0:
0016: if ((active1 & 0x40000000000L) != 0L)
0017: return 0;
0018: if ((active0 & 0xffffffffffffff80L) != 0L
0019: || (active1 & 0xfffL) != 0L) {
0020: jjmatchedKind = 84;
0021: return 71;
0022: }
0023: if ((active1 & 0x10000000000L) != 0L)
0024: return 6;
0025: if ((active1 & 0x10000000L) != 0L)
0026: return 17;
0027: return -1;
0028: case 1:
0029: if ((active0 & 0xffc3fc05ffffb780L) != 0L
0030: || (active1 & 0xdffL) != 0L) {
0031: if (jjmatchedPos != 1) {
0032: jjmatchedKind = 84;
0033: jjmatchedPos = 1;
0034: }
0035: return 71;
0036: }
0037: if ((active0 & 0x3c03fa00004800L) != 0L
0038: || (active1 & 0x200L) != 0L)
0039: return 71;
0040: return -1;
0041: case 2:
0042: if ((active0 & 0xf7f375f5f7ffb200L) != 0L
0043: || (active1 & 0xdffL) != 0L) {
0044: jjmatchedKind = 84;
0045: jjmatchedPos = 2;
0046: return 71;
0047: }
0048: if ((active0 & 0x800880008000d80L) != 0L)
0049: return 71;
0050: return -1;
0051: case 3:
0052: if ((active0 & 0x77f240f5b17f3200L) != 0L
0053: || (active1 & 0xc56L) != 0L) {
0054: jjmatchedKind = 84;
0055: jjmatchedPos = 3;
0056: return 71;
0057: }
0058: if ((active0 & 0x8001350046808000L) != 0L
0059: || (active1 & 0x1a9L) != 0L)
0060: return 71;
0061: return -1;
0062: case 4:
0063: if ((active0 & 0x36a20095117e2000L) != 0L
0064: || (active1 & 0xc16L) != 0L) {
0065: jjmatchedKind = 84;
0066: jjmatchedPos = 4;
0067: return 71;
0068: }
0069: if ((active0 & 0x41504060a0011200L) != 0L
0070: || (active1 & 0x40L) != 0L)
0071: return 71;
0072: return -1;
0073: case 5:
0074: if ((active0 & 0x24a00014013c2000L) != 0L
0075: || (active1 & 0xc00L) != 0L) {
0076: jjmatchedKind = 84;
0077: jjmatchedPos = 5;
0078: return 71;
0079: }
0080: if ((active0 & 0x1202008110420000L) != 0L
0081: || (active1 & 0x16L) != 0L)
0082: return 71;
0083: return -1;
0084: case 6:
0085: if ((active0 & 0x420001401340000L) != 0L
0086: || (active1 & 0xc00L) != 0L) {
0087: jjmatchedKind = 84;
0088: jjmatchedPos = 6;
0089: return 71;
0090: }
0091: if ((active0 & 0x2080000000082000L) != 0L)
0092: return 71;
0093: return -1;
0094: case 7:
0095: if ((active0 & 0x20001400240000L) != 0L
0096: || (active1 & 0xc00L) != 0L) {
0097: jjmatchedKind = 84;
0098: jjmatchedPos = 7;
0099: return 71;
0100: }
0101: if ((active0 & 0x400000001100000L) != 0L)
0102: return 71;
0103: return -1;
0104: case 8:
0105: if ((active0 & 0x20000000240000L) != 0L
0106: || (active1 & 0xc00L) != 0L) {
0107: jjmatchedKind = 84;
0108: jjmatchedPos = 8;
0109: return 71;
0110: }
0111: if ((active0 & 0x1400000000L) != 0L)
0112: return 71;
0113: return -1;
0114: case 9:
0115: if ((active0 & 0x20000000000000L) != 0L
0116: || (active1 & 0xc00L) != 0L) {
0117: jjmatchedKind = 84;
0118: jjmatchedPos = 9;
0119: return 71;
0120: }
0121: if ((active0 & 0x240000L) != 0L)
0122: return 71;
0123: return -1;
0124: case 10:
0125: if ((active0 & 0x20000000000000L) != 0L
0126: || (active1 & 0xc00L) != 0L) {
0127: jjmatchedKind = 84;
0128: jjmatchedPos = 10;
0129: return 71;
0130: }
0131: return -1;
0132: case 11:
0133: if ((active1 & 0x800L) != 0L) {
0134: jjmatchedKind = 84;
0135: jjmatchedPos = 11;
0136: return 71;
0137: }
0138: if ((active0 & 0x20000000000000L) != 0L
0139: || (active1 & 0x400L) != 0L)
0140: return 71;
0141: return -1;
0142: case 12:
0143: if ((active1 & 0x800L) != 0L) {
0144: jjmatchedKind = 84;
0145: jjmatchedPos = 12;
0146: return 71;
0147: }
0148: return -1;
0149: case 13:
0150: if ((active1 & 0x800L) != 0L) {
0151: jjmatchedKind = 84;
0152: jjmatchedPos = 13;
0153: return 71;
0154: }
0155: return -1;
0156: case 14:
0157: if ((active1 & 0x800L) != 0L) {
0158: jjmatchedKind = 84;
0159: jjmatchedPos = 14;
0160: return 71;
0161: }
0162: return -1;
0163: case 15:
0164: if ((active1 & 0x800L) != 0L) {
0165: jjmatchedKind = 84;
0166: jjmatchedPos = 15;
0167: return 71;
0168: }
0169: return -1;
0170: default:
0171: return -1;
0172: }
0173: }
0174:
0175: private final int jjStartNfa_0(int pos, long active0, long active1) {
0176: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
0177: active1), pos + 1);
0178: }
0179:
0180: private final int jjStopAtPos(int pos, int kind) {
0181: jjmatchedKind = kind;
0182: jjmatchedPos = pos;
0183: return pos + 1;
0184: }
0185:
0186: private final int jjStartNfaWithStates_0(int pos, int kind,
0187: int state) {
0188: jjmatchedKind = kind;
0189: jjmatchedPos = pos;
0190: try {
0191: curChar = input_stream.readChar();
0192: } catch (java.io.IOException e) {
0193: return pos + 1;
0194: }
0195: return jjMoveNfa_0(state, pos + 1);
0196: }
0197:
0198: private final int jjMoveStringLiteralDfa0_0() {
0199: switch (curChar) {
0200: case 33:
0201: return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000L);
0202: case 40:
0203: jjmatchedKind = 101;
0204: return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000L);
0205: case 41:
0206: return jjStopAtPos(0, 102);
0207: case 42:
0208: return jjStopAtPos(0, 103);
0209: case 43:
0210: return jjStopAtPos(0, 105);
0211: case 44:
0212: return jjStopAtPos(0, 89);
0213: case 45:
0214: return jjStartNfaWithStates_0(0, 106, 0);
0215: case 46:
0216: return jjStartNfaWithStates_0(0, 92, 17);
0217: case 47:
0218: return jjStartNfaWithStates_0(0, 104, 6);
0219: case 58:
0220: return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000L);
0221: case 59:
0222: return jjStopAtPos(0, 91);
0223: case 60:
0224: jjmatchedKind = 93;
0225: return jjMoveStringLiteralDfa1_0(0x0L, 0x840000000L);
0226: case 61:
0227: return jjStopAtPos(0, 97);
0228: case 62:
0229: jjmatchedKind = 95;
0230: return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000L);
0231: case 63:
0232: return jjStopAtPos(0, 107);
0233: case 65:
0234: case 97:
0235: return jjMoveStringLiteralDfa1_0(0xf80L, 0x200L);
0236: case 66:
0237: case 98:
0238: return jjMoveStringLiteralDfa1_0(0x7000L, 0x0L);
0239: case 67:
0240: case 99:
0241: return jjMoveStringLiteralDfa1_0(0x78000L, 0xd00L);
0242: case 68:
0243: case 100:
0244: return jjMoveStringLiteralDfa1_0(0x3f80000L, 0x0L);
0245: case 69:
0246: case 101:
0247: return jjMoveStringLiteralDfa1_0(0x1c000000L, 0x0L);
0248: case 70:
0249: case 102:
0250: return jjMoveStringLiteralDfa1_0(0x60000000L, 0x0L);
0251: case 71:
0252: case 103:
0253: return jjMoveStringLiteralDfa1_0(0x80000000L, 0x0L);
0254: case 72:
0255: case 104:
0256: return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);
0257: case 73:
0258: case 105:
0259: return jjMoveStringLiteralDfa1_0(0x3fe00000000L, 0x0L);
0260: case 74:
0261: case 106:
0262: return jjMoveStringLiteralDfa1_0(0x40000000000L, 0x0L);
0263: case 75:
0264: case 107:
0265: return jjMoveStringLiteralDfa1_0(0x80000000000L, 0x0L);
0266: case 76:
0267: case 108:
0268: return jjMoveStringLiteralDfa1_0(0x700000000000L, 0x0L);
0269: case 78:
0270: case 110:
0271: return jjMoveStringLiteralDfa1_0(0x1800000000000L, 0x0L);
0272: case 79:
0273: case 111:
0274: return jjMoveStringLiteralDfa1_0(0x7e000000000000L, 0x0L);
0275: case 80:
0276: case 112:
0277: return jjMoveStringLiteralDfa1_0(0x80000000000000L, 0x0L);
0278: case 82:
0279: case 114:
0280: return jjMoveStringLiteralDfa1_0(0x100000000000000L, 0x0L);
0281: case 83:
0282: case 115:
0283: return jjMoveStringLiteralDfa1_0(0x3e00000000000000L, 0x0L);
0284: case 84:
0285: case 116:
0286: return jjMoveStringLiteralDfa1_0(0xc000000000000000L, 0x1L);
0287: case 85:
0288: case 117:
0289: return jjMoveStringLiteralDfa1_0(0x0L, 0xeL);
0290: case 86:
0291: case 118:
0292: return jjMoveStringLiteralDfa1_0(0x0L, 0x10L);
0293: case 87:
0294: case 119:
0295: return jjMoveStringLiteralDfa1_0(0x0L, 0xe0L);
0296: case 124:
0297: return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L);
0298: default:
0299: return jjMoveNfa_0(5, 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 43:
0313: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0314: 0x1000000000L);
0315: case 61:
0316: if ((active1 & 0x1000000L) != 0L)
0317: return jjStopAtPos(1, 88);
0318: else if ((active1 & 0x40000000L) != 0L)
0319: return jjStopAtPos(1, 94);
0320: else if ((active1 & 0x100000000L) != 0L)
0321: return jjStopAtPos(1, 96);
0322: else if ((active1 & 0x400000000L) != 0L)
0323: return jjStopAtPos(1, 98);
0324: break;
0325: case 62:
0326: if ((active1 & 0x800000000L) != 0L)
0327: return jjStopAtPos(1, 99);
0328: break;
0329: case 65:
0330: case 97:
0331: return jjMoveStringLiteralDfa2_0(active0,
0332: 0x4000000120008000L, active1, 0x110L);
0333: case 68:
0334: case 100:
0335: return jjMoveStringLiteralDfa2_0(active0, 0x80L, active1,
0336: 0L);
0337: case 69:
0338: case 101:
0339: return jjMoveStringLiteralDfa2_0(active0,
0340: 0xe00180000f83000L, active1, 0L);
0341: case 70:
0342: case 102:
0343: if ((active0 & 0x200000000L) != 0L)
0344: return jjStartNfaWithStates_0(1, 33, 71);
0345: return jjMoveStringLiteralDfa2_0(active0, 0x2000000000000L,
0346: active1, 0L);
0347: case 72:
0348: case 104:
0349: return jjMoveStringLiteralDfa2_0(active0,
0350: 0x8000000000010000L, active1, 0x60L);
0351: case 73:
0352: case 105:
0353: return jjMoveStringLiteralDfa2_0(active0,
0354: 0x100600001000000L, active1, 0x80L);
0355: case 76:
0356: case 108:
0357: return jjMoveStringLiteralDfa2_0(active0, 0x4000300L,
0358: active1, 0L);
0359: case 77:
0360: case 109:
0361: return jjMoveStringLiteralDfa2_0(active0, 0x400000000L,
0362: active1, 0L);
0363: case 78:
0364: case 110:
0365: if ((active0 & 0x800000000L) != 0L) {
0366: jjmatchedKind = 35;
0367: jjmatchedPos = 1;
0368: } else if ((active0 & 0x4000000000000L) != 0L)
0369: return jjStartNfaWithStates_0(1, 50, 71);
0370: return jjMoveStringLiteralDfa2_0(active0, 0x1f008000400L,
0371: active1, 0x2L);
0372: case 79:
0373: case 111:
0374: return jjMoveStringLiteralDfa2_0(active0, 0x840000040000L,
0375: active1, 0L);
0376: case 80:
0377: case 112:
0378: return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4L);
0379: case 82:
0380: case 114:
0381: if ((active0 & 0x8000000000000L) != 0L) {
0382: jjmatchedKind = 51;
0383: jjmatchedPos = 1;
0384: }
0385: return jjMoveStringLiteralDfa2_0(active0,
0386: 0xb00000c2020000L, active1, 0x1L);
0387: case 83:
0388: case 115:
0389: if ((active0 & 0x20000000000L) != 0L)
0390: return jjStartNfaWithStates_0(1, 41, 71);
0391: else if ((active1 & 0x200L) != 0L) {
0392: jjmatchedKind = 73;
0393: jjmatchedPos = 1;
0394: }
0395: return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1,
0396: 0x8L);
0397: case 84:
0398: case 116:
0399: return jjMoveStringLiteralDfa2_0(active0,
0400: 0x1000000000000000L, active1, 0L);
0401: case 85:
0402: case 117:
0403: return jjMoveStringLiteralDfa2_0(active0,
0404: 0x41000000000000L, active1, 0xc00L);
0405: case 88:
0406: case 120:
0407: return jjMoveStringLiteralDfa2_0(active0, 0x10000000L,
0408: active1, 0L);
0409: case 89:
0410: case 121:
0411: if ((active0 & 0x4000L) != 0L)
0412: return jjStartNfaWithStates_0(1, 14, 71);
0413: return jjMoveStringLiteralDfa2_0(active0,
0414: 0x2000000000000000L, active1, 0L);
0415: case 124:
0416: if ((active1 & 0x4000000L) != 0L)
0417: return jjStopAtPos(1, 90);
0418: break;
0419: default:
0420: break;
0421: }
0422: return jjStartNfa_0(0, active0, active1);
0423: }
0424:
0425: private final int jjMoveStringLiteralDfa2_0(long old0,
0426: long active0, long old1, long active1) {
0427: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0428: return jjStartNfa_0(0, old0, old1);
0429: try {
0430: curChar = input_stream.readChar();
0431: } catch (java.io.IOException e) {
0432: jjStopStringLiteralDfa_0(1, active0, active1);
0433: return 2;
0434: }
0435: switch (curChar) {
0436: case 41:
0437: if ((active1 & 0x1000000000L) != 0L)
0438: return jjStopAtPos(2, 100);
0439: break;
0440: case 65:
0441: case 97:
0442: return jjMoveStringLiteralDfa3_0(active0,
0443: 0x1000000000000000L, active1, 0L);
0444: case 66:
0445: case 98:
0446: return jjMoveStringLiteralDfa3_0(active0,
0447: 0x4000000000000000L, active1, 0L);
0448: case 67:
0449: case 99:
0450: if ((active0 & 0x800L) != 0L)
0451: return jjStartNfaWithStates_0(2, 11, 71);
0452: break;
0453: case 68:
0454: case 100:
0455: if ((active0 & 0x80L) != 0L)
0456: return jjStartNfaWithStates_0(2, 7, 71);
0457: else if ((active0 & 0x400L) != 0L)
0458: return jjStartNfaWithStates_0(2, 10, 71);
0459: else if ((active0 & 0x8000000L) != 0L)
0460: return jjStartNfaWithStates_0(2, 27, 71);
0461: return jjMoveStringLiteralDfa3_0(active0,
0462: 0x10002000000000L, active1, 0x4L);
0463: case 69:
0464: case 101:
0465: return jjMoveStringLiteralDfa3_0(active0,
0466: 0x8000000000030000L, active1, 0x68L);
0467: case 70:
0468: case 102:
0469: return jjMoveStringLiteralDfa3_0(active0, 0x2100000380000L,
0470: active1, 0L);
0471: case 71:
0472: case 103:
0473: return jjMoveStringLiteralDfa3_0(active0,
0474: 0x120000000001000L, active1, 0L);
0475: case 73:
0476: case 105:
0477: return jjMoveStringLiteralDfa3_0(active0,
0478: 0x80041010000000L, active1, 0x2L);
0479: case 75:
0480: case 107:
0481: return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L,
0482: active1, 0L);
0483: case 76:
0484: case 108:
0485: if ((active0 & 0x100L) != 0L)
0486: return jjStartNfaWithStates_0(2, 8, 71);
0487: return jjMoveStringLiteralDfa3_0(active0,
0488: 0x201000020400000L, active1, 0x10L);
0489: case 77:
0490: case 109:
0491: return jjMoveStringLiteralDfa3_0(active0, 0x400400000000L,
0492: active1, 0L);
0493: case 78:
0494: case 110:
0495: return jjMoveStringLiteralDfa3_0(active0, 0x4000040000L,
0496: active1, 0L);
0497: case 79:
0498: case 111:
0499: return jjMoveStringLiteralDfa3_0(active0, 0xc2000000L,
0500: active1, 0L);
0501: case 81:
0502: case 113:
0503: return jjMoveStringLiteralDfa3_0(active0,
0504: 0x400000000000000L, active1, 0L);
0505: case 82:
0506: case 114:
0507: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
0508: 0xc00L);
0509: case 83:
0510: case 115:
0511: return jjMoveStringLiteralDfa3_0(active0,
0512: 0x2000008005808000L, active1, 0x100L);
0513: case 84:
0514: case 116:
0515: if ((active0 & 0x800000000000L) != 0L)
0516: return jjStartNfaWithStates_0(2, 47, 71);
0517: else if ((active0 & 0x800000000000000L) != 0L)
0518: return jjStartNfaWithStates_0(2, 59, 71);
0519: return jjMoveStringLiteralDfa3_0(active0,
0520: 0x40010000002200L, active1, 0x80L);
0521: case 85:
0522: case 117:
0523: return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1L);
0524: case 86:
0525: case 118:
0526: return jjMoveStringLiteralDfa3_0(active0, 0x100000000L,
0527: active1, 0L);
0528: case 89:
0529: case 121:
0530: if ((active0 & 0x80000000000L) != 0L)
0531: return jjStartNfaWithStates_0(2, 43, 71);
0532: break;
0533: default:
0534: break;
0535: }
0536: return jjStartNfa_0(1, active0, active1);
0537: }
0538:
0539: private final int jjMoveStringLiteralDfa3_0(long old0,
0540: long active0, long old1, long active1) {
0541: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0542: return jjStartNfa_0(1, old0, old1);
0543: try {
0544: curChar = input_stream.readChar();
0545: } catch (java.io.IOException e) {
0546: jjStopStringLiteralDfa_0(2, active0, active1);
0547: return 3;
0548: }
0549: switch (curChar) {
0550: case 65:
0551: case 97:
0552: return jjMoveStringLiteralDfa4_0(active0,
0553: 0x200000000a0000L, active1, 0x4L);
0554: case 67:
0555: case 99:
0556: if ((active0 & 0x800000L) != 0L)
0557: return jjStartNfaWithStates_0(3, 23, 71);
0558: return jjMoveStringLiteralDfa4_0(active0, 0x10000L,
0559: active1, 0L);
0560: case 68:
0561: case 100:
0562: return jjMoveStringLiteralDfa4_0(active0,
0563: 0x2000000000000000L, active1, 0L);
0564: case 69:
0565: case 101:
0566: if ((active0 & 0x8000L) != 0L)
0567: return jjStartNfaWithStates_0(3, 15, 71);
0568: else if ((active0 & 0x4000000L) != 0L)
0569: return jjStartNfaWithStates_0(3, 26, 71);
0570: else if ((active0 & 0x200000000000L) != 0L)
0571: return jjStartNfaWithStates_0(3, 45, 71);
0572: else if ((active1 & 0x1L) != 0L)
0573: return jjStartNfaWithStates_0(3, 64, 71);
0574: return jjMoveStringLiteralDfa4_0(active0,
0575: 0x25000e400700200L, active1, 0L);
0576: case 72:
0577: case 104:
0578: if ((active1 & 0x80L) != 0L)
0579: return jjStartNfaWithStates_0(3, 71, 71);
0580: return jjMoveStringLiteralDfa4_0(active0,
0581: 0x100000000000000L, active1, 0L);
0582: case 73:
0583: case 105:
0584: return jjMoveStringLiteralDfa4_0(active0, 0x400100001000L,
0585: active1, 0L);
0586: case 76:
0587: case 108:
0588: if ((active0 & 0x1000000000000L) != 0L)
0589: return jjStartNfaWithStates_0(3, 48, 71);
0590: return jjMoveStringLiteralDfa4_0(active0,
0591: 0x4000000000000000L, active1, 0L);
0592: case 77:
0593: case 109:
0594: if ((active0 & 0x40000000L) != 0L)
0595: return jjStartNfaWithStates_0(3, 30, 71);
0596: return jjMoveStringLiteralDfa4_0(active0,
0597: 0x80000000000000L, active1, 0L);
0598: case 78:
0599: case 110:
0600: if ((active0 & 0x40000000000L) != 0L)
0601: return jjStartNfaWithStates_0(3, 42, 71);
0602: else if ((active0 & 0x8000000000000000L) != 0L)
0603: return jjStartNfaWithStates_0(3, 63, 71);
0604: else if ((active1 & 0x20L) != 0L)
0605: return jjStartNfaWithStates_0(3, 69, 71);
0606: break;
0607: case 79:
0608: case 111:
0609: if ((active0 & 0x10000000000L) != 0L)
0610: return jjStartNfaWithStates_0(3, 40, 71);
0611: break;
0612: case 80:
0613: case 112:
0614: if ((active0 & 0x2000000L) != 0L)
0615: return jjStartNfaWithStates_0(3, 25, 71);
0616: break;
0617: case 81:
0618: case 113:
0619: return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x2L);
0620: case 82:
0621: case 114:
0622: if ((active1 & 0x8L) != 0L)
0623: return jjStartNfaWithStates_0(3, 67, 71);
0624: return jjMoveStringLiteralDfa4_0(active0,
0625: 0x1000000000000000L, active1, 0xc40L);
0626: case 83:
0627: case 115:
0628: return jjMoveStringLiteralDfa4_0(active0, 0x2000030040000L,
0629: active1, 0L);
0630: case 84:
0631: case 116:
0632: if ((active0 & 0x100000000000L) != 0L)
0633: return jjStartNfaWithStates_0(3, 44, 71);
0634: else if ((active1 & 0x100L) != 0L)
0635: return jjStartNfaWithStates_0(3, 72, 71);
0636: return jjMoveStringLiteralDfa4_0(active0, 0x1001000000L,
0637: active1, 0L);
0638: case 85:
0639: case 117:
0640: return jjMoveStringLiteralDfa4_0(active0,
0641: 0x400000080000000L, active1, 0x10L);
0642: case 87:
0643: case 119:
0644: return jjMoveStringLiteralDfa4_0(active0, 0x2000L, active1,
0645: 0L);
0646: default:
0647: break;
0648: }
0649: return jjStartNfa_0(2, active0, active1);
0650: }
0651:
0652: private final int jjMoveStringLiteralDfa4_0(long old0,
0653: long active0, long old1, long active1) {
0654: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0655: return jjStartNfa_0(2, old0, old1);
0656: try {
0657: curChar = input_stream.readChar();
0658: } catch (java.io.IOException e) {
0659: jjStopStringLiteralDfa_0(3, active0, active1);
0660: return 4;
0661: }
0662: switch (curChar) {
0663: case 65:
0664: case 97:
0665: return jjMoveStringLiteralDfa5_0(active0,
0666: 0x2080000000000000L, active1, 0L);
0667: case 67:
0668: case 99:
0669: return jjMoveStringLiteralDfa5_0(active0,
0670: 0x200000000000000L, active1, 0L);
0671: case 68:
0672: case 100:
0673: return jjMoveStringLiteralDfa5_0(active0, 0x400000000L,
0674: active1, 0L);
0675: case 69:
0676: case 101:
0677: if ((active0 & 0x20000000L) != 0L)
0678: return jjStartNfaWithStates_0(4, 29, 71);
0679: else if ((active0 & 0x4000000000000000L) != 0L)
0680: return jjStartNfaWithStates_0(4, 62, 71);
0681: else if ((active1 & 0x40L) != 0L)
0682: return jjStartNfaWithStates_0(4, 70, 71);
0683: return jjMoveStringLiteralDfa5_0(active0,
0684: 0x402000000002000L, active1, 0xc10L);
0685: case 73:
0686: case 105:
0687: return jjMoveStringLiteralDfa5_0(active0, 0x1001000000L,
0688: active1, 0L);
0689: case 75:
0690: case 107:
0691: if ((active0 & 0x10000L) != 0L)
0692: return jjStartNfaWithStates_0(4, 16, 71);
0693: break;
0694: case 78:
0695: case 110:
0696: if ((active0 & 0x1000L) != 0L)
0697: return jjStartNfaWithStates_0(4, 12, 71);
0698: return jjMoveStringLiteralDfa5_0(active0,
0699: 0x20000100000000L, active1, 0L);
0700: case 80:
0701: case 112:
0702: if ((active0 & 0x80000000L) != 0L)
0703: return jjStartNfaWithStates_0(4, 31, 71);
0704: break;
0705: case 82:
0706: case 114:
0707: if ((active0 & 0x200L) != 0L)
0708: return jjStartNfaWithStates_0(4, 9, 71);
0709: else if ((active0 & 0x4000000000L) != 0L)
0710: return jjStartNfaWithStates_0(4, 38, 71);
0711: else if ((active0 & 0x10000000000000L) != 0L)
0712: return jjStartNfaWithStates_0(4, 52, 71);
0713: else if ((active0 & 0x40000000000000L) != 0L)
0714: return jjStartNfaWithStates_0(4, 54, 71);
0715: return jjMoveStringLiteralDfa5_0(active0, 0x8000300000L,
0716: active1, 0L);
0717: case 84:
0718: case 116:
0719: if ((active0 & 0x400000000000L) != 0L)
0720: return jjStartNfaWithStates_0(4, 46, 71);
0721: else if ((active0 & 0x100000000000000L) != 0L)
0722: return jjStartNfaWithStates_0(4, 56, 71);
0723: return jjMoveStringLiteralDfa5_0(active0,
0724: 0x1000000010460000L, active1, 0x4L);
0725: case 85:
0726: case 117:
0727: return jjMoveStringLiteralDfa5_0(active0, 0x80000L,
0728: active1, 0x2L);
0729: case 88:
0730: case 120:
0731: if ((active0 & 0x2000000000L) != 0L)
0732: return jjStartNfaWithStates_0(4, 37, 71);
0733: break;
0734: default:
0735: break;
0736: }
0737: return jjStartNfa_0(3, active0, active1);
0738: }
0739:
0740: private final int jjMoveStringLiteralDfa5_0(long old0,
0741: long active0, long old1, long active1) {
0742: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0743: return jjStartNfa_0(3, old0, old1);
0744: try {
0745: curChar = input_stream.readChar();
0746: } catch (java.io.IOException e) {
0747: jjStopStringLiteralDfa_0(4, active0, active1);
0748: return 5;
0749: }
0750: switch (curChar) {
0751: case 65:
0752: case 97:
0753: return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L,
0754: active1, 0L);
0755: case 69:
0756: case 101:
0757: if ((active0 & 0x20000L) != 0L)
0758: return jjStartNfaWithStates_0(5, 17, 71);
0759: else if ((active0 & 0x400000L) != 0L)
0760: return jjStartNfaWithStates_0(5, 22, 71);
0761: else if ((active1 & 0x2L) != 0L)
0762: return jjStartNfaWithStates_0(5, 65, 71);
0763: else if ((active1 & 0x4L) != 0L)
0764: return jjStartNfaWithStates_0(5, 66, 71);
0765: return jjMoveStringLiteralDfa6_0(active0, 0x2000L, active1,
0766: 0L);
0767: case 71:
0768: case 103:
0769: if ((active0 & 0x100000000L) != 0L)
0770: return jjStartNfaWithStates_0(5, 32, 71);
0771: break;
0772: case 73:
0773: case 105:
0774: return jjMoveStringLiteralDfa6_0(active0,
0775: 0x20000400000000L, active1, 0L);
0776: case 76:
0777: case 108:
0778: return jjMoveStringLiteralDfa6_0(active0, 0x80000L,
0779: active1, 0L);
0780: case 78:
0781: case 110:
0782: return jjMoveStringLiteralDfa6_0(active0,
0783: 0x400000001000000L, active1, 0xc00L);
0784: case 82:
0785: case 114:
0786: return jjMoveStringLiteralDfa6_0(active0,
0787: 0x80000000340000L, active1, 0L);
0788: case 83:
0789: case 115:
0790: if ((active0 & 0x10000000L) != 0L)
0791: return jjStartNfaWithStates_0(5, 28, 71);
0792: else if ((active0 & 0x1000000000000000L) != 0L)
0793: return jjStartNfaWithStates_0(5, 60, 71);
0794: else if ((active1 & 0x10L) != 0L)
0795: return jjStartNfaWithStates_0(5, 68, 71);
0796: break;
0797: case 84:
0798: case 116:
0799: if ((active0 & 0x8000000000L) != 0L)
0800: return jjStartNfaWithStates_0(5, 39, 71);
0801: else if ((active0 & 0x2000000000000L) != 0L)
0802: return jjStartNfaWithStates_0(5, 49, 71);
0803: else if ((active0 & 0x200000000000000L) != 0L)
0804: return jjStartNfaWithStates_0(5, 57, 71);
0805: return jjMoveStringLiteralDfa6_0(active0,
0806: 0x2000000000000000L, active1, 0L);
0807: default:
0808: break;
0809: }
0810: return jjStartNfa_0(4, active0, active1);
0811: }
0812:
0813: private final int jjMoveStringLiteralDfa6_0(long old0,
0814: long active0, long old1, long active1) {
0815: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0816: return jjStartNfa_0(4, old0, old1);
0817: try {
0818: curChar = input_stream.readChar();
0819: } catch (java.io.IOException e) {
0820: jjStopStringLiteralDfa_0(5, active0, active1);
0821: return 6;
0822: }
0823: switch (curChar) {
0824: case 65:
0825: case 97:
0826: return jjMoveStringLiteralDfa7_0(active0, 0x400240000L,
0827: active1, 0L);
0828: case 67:
0829: case 99:
0830: return jjMoveStringLiteralDfa7_0(active0,
0831: 0x400000001000000L, active1, 0L);
0832: case 69:
0833: case 101:
0834: if ((active0 & 0x2000000000000000L) != 0L)
0835: return jjStartNfaWithStates_0(6, 61, 71);
0836: return jjMoveStringLiteralDfa7_0(active0, 0x100000L,
0837: active1, 0L);
0838: case 76:
0839: case 108:
0840: return jjMoveStringLiteralDfa7_0(active0, 0x1000000000L,
0841: active1, 0L);
0842: case 78:
0843: case 110:
0844: if ((active0 & 0x2000L) != 0L)
0845: return jjStartNfaWithStates_0(6, 13, 71);
0846: break;
0847: case 84:
0848: case 116:
0849: if ((active0 & 0x80000L) != 0L)
0850: return jjStartNfaWithStates_0(6, 19, 71);
0851: return jjMoveStringLiteralDfa7_0(active0, 0L, active1,
0852: 0xc00L);
0853: case 89:
0854: case 121:
0855: if ((active0 & 0x80000000000000L) != 0L)
0856: return jjStartNfaWithStates_0(6, 55, 71);
0857: break;
0858: case 90:
0859: case 122:
0860: return jjMoveStringLiteralDfa7_0(active0,
0861: 0x20000000000000L, active1, 0L);
0862: default:
0863: break;
0864: }
0865: return jjStartNfa_0(5, active0, active1);
0866: }
0867:
0868: private final int jjMoveStringLiteralDfa7_0(long old0,
0869: long active0, long old1, long active1) {
0870: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0871: return jjStartNfa_0(5, old0, old1);
0872: try {
0873: curChar = input_stream.readChar();
0874: } catch (java.io.IOException e) {
0875: jjStopStringLiteralDfa_0(6, active0, active1);
0876: return 7;
0877: }
0878: switch (curChar) {
0879: case 95:
0880: return jjMoveStringLiteralDfa8_0(active0, 0L, active1,
0881: 0xc00L);
0882: case 65:
0883: case 97:
0884: return jjMoveStringLiteralDfa8_0(active0,
0885: 0x20000000000000L, active1, 0L);
0886: case 66:
0887: case 98:
0888: return jjMoveStringLiteralDfa8_0(active0, 0x200000L,
0889: active1, 0L);
0890: case 68:
0891: case 100:
0892: if ((active0 & 0x100000L) != 0L)
0893: return jjStartNfaWithStates_0(7, 20, 71);
0894: break;
0895: case 69:
0896: case 101:
0897: if ((active0 & 0x400000000000000L) != 0L)
0898: return jjStartNfaWithStates_0(7, 58, 71);
0899: break;
0900: case 73:
0901: case 105:
0902: return jjMoveStringLiteralDfa8_0(active0, 0x40000L,
0903: active1, 0L);
0904: case 76:
0905: case 108:
0906: return jjMoveStringLiteralDfa8_0(active0, 0x1000000000L,
0907: active1, 0L);
0908: case 84:
0909: case 116:
0910: if ((active0 & 0x1000000L) != 0L)
0911: return jjStartNfaWithStates_0(7, 24, 71);
0912: return jjMoveStringLiteralDfa8_0(active0, 0x400000000L,
0913: active1, 0L);
0914: default:
0915: break;
0916: }
0917: return jjStartNfa_0(6, active0, active1);
0918: }
0919:
0920: private final int jjMoveStringLiteralDfa8_0(long old0,
0921: long active0, long old1, long active1) {
0922: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0923: return jjStartNfa_0(6, old0, old1);
0924: try {
0925: curChar = input_stream.readChar();
0926: } catch (java.io.IOException e) {
0927: jjStopStringLiteralDfa_0(7, active0, active1);
0928: return 8;
0929: }
0930: switch (curChar) {
0931: case 68:
0932: case 100:
0933: return jjMoveStringLiteralDfa9_0(active0, 0L, active1,
0934: 0x400L);
0935: case 69:
0936: case 101:
0937: if ((active0 & 0x400000000L) != 0L)
0938: return jjStartNfaWithStates_0(8, 34, 71);
0939: break;
0940: case 76:
0941: case 108:
0942: return jjMoveStringLiteralDfa9_0(active0, 0x200000L,
0943: active1, 0L);
0944: case 78:
0945: case 110:
0946: return jjMoveStringLiteralDfa9_0(active0, 0x40000L,
0947: active1, 0L);
0948: case 84:
0949: case 116:
0950: return jjMoveStringLiteralDfa9_0(active0,
0951: 0x20000000000000L, active1, 0x800L);
0952: case 89:
0953: case 121:
0954: if ((active0 & 0x1000000000L) != 0L)
0955: return jjStartNfaWithStates_0(8, 36, 71);
0956: break;
0957: default:
0958: break;
0959: }
0960: return jjStartNfa_0(7, active0, active1);
0961: }
0962:
0963: private final int jjMoveStringLiteralDfa9_0(long old0,
0964: long active0, long old1, long active1) {
0965: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0966: return jjStartNfa_0(7, old0, old1);
0967: try {
0968: curChar = input_stream.readChar();
0969: } catch (java.io.IOException e) {
0970: jjStopStringLiteralDfa_0(8, active0, active1);
0971: return 9;
0972: }
0973: switch (curChar) {
0974: case 65:
0975: case 97:
0976: return jjMoveStringLiteralDfa10_0(active0, 0L, active1,
0977: 0x400L);
0978: case 69:
0979: case 101:
0980: if ((active0 & 0x200000L) != 0L)
0981: return jjStartNfaWithStates_0(9, 21, 71);
0982: break;
0983: case 73:
0984: case 105:
0985: return jjMoveStringLiteralDfa10_0(active0,
0986: 0x20000000000000L, active1, 0x800L);
0987: case 84:
0988: case 116:
0989: if ((active0 & 0x40000L) != 0L)
0990: return jjStartNfaWithStates_0(9, 18, 71);
0991: break;
0992: default:
0993: break;
0994: }
0995: return jjStartNfa_0(8, active0, active1);
0996: }
0997:
0998: private final int jjMoveStringLiteralDfa10_0(long old0,
0999: long active0, long old1, long active1) {
1000: if (((active0 &= old0) | (active1 &= old1)) == 0L)
1001: return jjStartNfa_0(8, old0, old1);
1002: try {
1003: curChar = input_stream.readChar();
1004: } catch (java.io.IOException e) {
1005: jjStopStringLiteralDfa_0(9, active0, active1);
1006: return 10;
1007: }
1008: switch (curChar) {
1009: case 77:
1010: case 109:
1011: return jjMoveStringLiteralDfa11_0(active0, 0L, active1,
1012: 0x800L);
1013: case 79:
1014: case 111:
1015: return jjMoveStringLiteralDfa11_0(active0,
1016: 0x20000000000000L, active1, 0L);
1017: case 84:
1018: case 116:
1019: return jjMoveStringLiteralDfa11_0(active0, 0L, active1,
1020: 0x400L);
1021: default:
1022: break;
1023: }
1024: return jjStartNfa_0(9, active0, active1);
1025: }
1026:
1027: private final int jjMoveStringLiteralDfa11_0(long old0,
1028: long active0, long old1, long active1) {
1029: if (((active0 &= old0) | (active1 &= old1)) == 0L)
1030: return jjStartNfa_0(9, old0, old1);
1031: try {
1032: curChar = input_stream.readChar();
1033: } catch (java.io.IOException e) {
1034: jjStopStringLiteralDfa_0(10, active0, active1);
1035: return 11;
1036: }
1037: switch (curChar) {
1038: case 69:
1039: case 101:
1040: if ((active1 & 0x400L) != 0L)
1041: return jjStartNfaWithStates_0(11, 74, 71);
1042: return jjMoveStringLiteralDfa12_0(active0, 0L, active1,
1043: 0x800L);
1044: case 78:
1045: case 110:
1046: if ((active0 & 0x20000000000000L) != 0L)
1047: return jjStartNfaWithStates_0(11, 53, 71);
1048: break;
1049: default:
1050: break;
1051: }
1052: return jjStartNfa_0(10, active0, active1);
1053: }
1054:
1055: private final int jjMoveStringLiteralDfa12_0(long old0,
1056: long active0, long old1, long active1) {
1057: if (((active0 &= old0) | (active1 &= old1)) == 0L)
1058: return jjStartNfa_0(10, old0, old1);
1059: try {
1060: curChar = input_stream.readChar();
1061: } catch (java.io.IOException e) {
1062: jjStopStringLiteralDfa_0(11, 0L, active1);
1063: return 12;
1064: }
1065: switch (curChar) {
1066: case 83:
1067: case 115:
1068: return jjMoveStringLiteralDfa13_0(active1, 0x800L);
1069: default:
1070: break;
1071: }
1072: return jjStartNfa_0(11, 0L, active1);
1073: }
1074:
1075: private final int jjMoveStringLiteralDfa13_0(long old1, long active1) {
1076: if (((active1 &= old1)) == 0L)
1077: return jjStartNfa_0(11, 0L, old1);
1078: try {
1079: curChar = input_stream.readChar();
1080: } catch (java.io.IOException e) {
1081: jjStopStringLiteralDfa_0(12, 0L, active1);
1082: return 13;
1083: }
1084: switch (curChar) {
1085: case 84:
1086: case 116:
1087: return jjMoveStringLiteralDfa14_0(active1, 0x800L);
1088: default:
1089: break;
1090: }
1091: return jjStartNfa_0(12, 0L, active1);
1092: }
1093:
1094: private final int jjMoveStringLiteralDfa14_0(long old1, long active1) {
1095: if (((active1 &= old1)) == 0L)
1096: return jjStartNfa_0(12, 0L, old1);
1097: try {
1098: curChar = input_stream.readChar();
1099: } catch (java.io.IOException e) {
1100: jjStopStringLiteralDfa_0(13, 0L, active1);
1101: return 14;
1102: }
1103: switch (curChar) {
1104: case 65:
1105: case 97:
1106: return jjMoveStringLiteralDfa15_0(active1, 0x800L);
1107: default:
1108: break;
1109: }
1110: return jjStartNfa_0(13, 0L, active1);
1111: }
1112:
1113: private final int jjMoveStringLiteralDfa15_0(long old1, long active1) {
1114: if (((active1 &= old1)) == 0L)
1115: return jjStartNfa_0(13, 0L, old1);
1116: try {
1117: curChar = input_stream.readChar();
1118: } catch (java.io.IOException e) {
1119: jjStopStringLiteralDfa_0(14, 0L, active1);
1120: return 15;
1121: }
1122: switch (curChar) {
1123: case 77:
1124: case 109:
1125: return jjMoveStringLiteralDfa16_0(active1, 0x800L);
1126: default:
1127: break;
1128: }
1129: return jjStartNfa_0(14, 0L, active1);
1130: }
1131:
1132: private final int jjMoveStringLiteralDfa16_0(long old1, long active1) {
1133: if (((active1 &= old1)) == 0L)
1134: return jjStartNfa_0(14, 0L, old1);
1135: try {
1136: curChar = input_stream.readChar();
1137: } catch (java.io.IOException e) {
1138: jjStopStringLiteralDfa_0(15, 0L, active1);
1139: return 16;
1140: }
1141: switch (curChar) {
1142: case 80:
1143: case 112:
1144: if ((active1 & 0x800L) != 0L)
1145: return jjStartNfaWithStates_0(16, 75, 71);
1146: break;
1147: default:
1148: break;
1149: }
1150: return jjStartNfa_0(15, 0L, active1);
1151: }
1152:
1153: private final void jjCheckNAdd(int state) {
1154: if (jjrounds[state] != jjround) {
1155: jjstateSet[jjnewStateCnt++] = state;
1156: jjrounds[state] = jjround;
1157: }
1158: }
1159:
1160: private final void jjAddStates(int start, int end) {
1161: do {
1162: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1163: } while (start++ != end);
1164: }
1165:
1166: private final void jjCheckNAddTwoStates(int state1, int state2) {
1167: jjCheckNAdd(state1);
1168: jjCheckNAdd(state2);
1169: }
1170:
1171: private final void jjCheckNAddStates(int start, int end) {
1172: do {
1173: jjCheckNAdd(jjnextStates[start]);
1174: } while (start++ != end);
1175: }
1176:
1177: //private final void jjCheckNAddStates(int start)
1178: //{
1179: // jjCheckNAdd(jjnextStates[start]);
1180: // jjCheckNAdd(jjnextStates[start + 1]);
1181: //}
1182: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
1183: 0xffffffffffffffffL, 0xffffffffffffffffL,
1184: 0xffffffffffffffffL };
1185: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
1186: 0xffffffffffffffffL };
1187:
1188: private final int jjMoveNfa_0(int startState, int curPos) {
1189: //int[] nextStates;
1190: int startsAt = 0;
1191: jjnewStateCnt = 71;
1192: int i = 1;
1193: jjstateSet[0] = startState;
1194: //int j;
1195: int kind = 0x7fffffff;
1196: for (;;) {
1197: if (++jjround == 0x7fffffff)
1198: ReInitRounds();
1199: if (curChar < 64) {
1200: long l = 1L << curChar;
1201: //MatchLoop:
1202: do {
1203: switch (jjstateSet[--i]) {
1204: case 5:
1205: if ((0x3ff000000000000L & l) != 0L) {
1206: if (kind > 80)
1207: kind = 80;
1208: jjCheckNAddStates(0, 7);
1209: } else if ((0x1800000000L & l) != 0L) {
1210: if (kind > 84)
1211: kind = 84;
1212: jjCheckNAddStates(8, 18);
1213: } else if (curChar == 39)
1214: jjCheckNAddStates(19, 21);
1215: else if (curChar == 46)
1216: jjCheckNAdd(17);
1217: else if (curChar == 47)
1218: jjstateSet[jjnewStateCnt++] = 6;
1219: else if (curChar == 45)
1220: jjstateSet[jjnewStateCnt++] = 0;
1221: if (curChar == 36)
1222: jjCheckNAdd(14);
1223: break;
1224: case 71:
1225: if ((0x3ff001800000000L & l) != 0L) {
1226: if (kind > 84)
1227: kind = 84;
1228: jjCheckNAdd(53);
1229: } else if (curChar == 46)
1230: jjCheckNAdd(50);
1231: if ((0x3ff001800000000L & l) != 0L)
1232: jjCheckNAddTwoStates(48, 49);
1233: else if (curChar == 46)
1234: jjCheckNAdd(42);
1235: if ((0x3ff001800000000L & l) != 0L)
1236: jjCheckNAddTwoStates(40, 41);
1237: else if (curChar == 46)
1238: jjCheckNAdd(31);
1239: if ((0x3ff001800000000L & l) != 0L)
1240: jjCheckNAddTwoStates(29, 30);
1241: if ((0x1800000000L & l) != 0L) {
1242: if (kind > 84)
1243: kind = 84;
1244: jjCheckNAddTwoStates(52, 53);
1245: }
1246: if ((0x1800000000L & l) != 0L)
1247: jjCheckNAddStates(22, 24);
1248: if ((0x1800000000L & l) != 0L)
1249: jjCheckNAddStates(25, 27);
1250: if ((0x1800000000L & l) != 0L)
1251: jjCheckNAddStates(28, 30);
1252: break;
1253: case 0:
1254: if (curChar == 45)
1255: jjCheckNAddStates(31, 33);
1256: break;
1257: case 1:
1258: if ((0xffffffffffffdbffL & l) != 0L)
1259: jjCheckNAddStates(31, 33);
1260: break;
1261: case 2:
1262: if ((0x2400L & l) != 0L && kind > 5)
1263: kind = 5;
1264: break;
1265: case 3:
1266: if (curChar == 10 && kind > 5)
1267: kind = 5;
1268: break;
1269: case 4:
1270: if (curChar == 13)
1271: jjstateSet[jjnewStateCnt++] = 3;
1272: break;
1273: case 6:
1274: if (curChar == 42)
1275: jjCheckNAddTwoStates(7, 8);
1276: break;
1277: case 7:
1278: if ((0xfffffbffffffffffL & l) != 0L)
1279: jjCheckNAddTwoStates(7, 8);
1280: break;
1281: case 8:
1282: if (curChar == 42)
1283: jjCheckNAddStates(34, 36);
1284: break;
1285: case 9:
1286: if ((0xffff7bffffffffffL & l) != 0L)
1287: jjCheckNAddTwoStates(10, 8);
1288: break;
1289: case 10:
1290: if ((0xfffffbffffffffffL & l) != 0L)
1291: jjCheckNAddTwoStates(10, 8);
1292: break;
1293: case 11:
1294: if (curChar == 47 && kind > 6)
1295: kind = 6;
1296: break;
1297: case 12:
1298: if (curChar == 47)
1299: jjstateSet[jjnewStateCnt++] = 6;
1300: break;
1301: case 13:
1302: if (curChar == 36)
1303: jjCheckNAdd(14);
1304: break;
1305: case 14:
1306: if ((0x1800000000L & l) == 0L)
1307: break;
1308: if (kind > 76)
1309: kind = 76;
1310: jjCheckNAddTwoStates(14, 15);
1311: break;
1312: case 15:
1313: if ((0x3ff001800000000L & l) == 0L)
1314: break;
1315: if (kind > 76)
1316: kind = 76;
1317: jjCheckNAdd(15);
1318: break;
1319: case 16:
1320: if (curChar == 46)
1321: jjCheckNAdd(17);
1322: break;
1323: case 17:
1324: if ((0x3ff000000000000L & l) == 0L)
1325: break;
1326: if (kind > 81)
1327: kind = 81;
1328: jjCheckNAddTwoStates(17, 18);
1329: break;
1330: case 19:
1331: if ((0x280000000000L & l) != 0L)
1332: jjCheckNAdd(20);
1333: break;
1334: case 20:
1335: if ((0x3ff000000000000L & l) == 0L)
1336: break;
1337: if (kind > 81)
1338: kind = 81;
1339: jjCheckNAdd(20);
1340: break;
1341: case 21:
1342: if (curChar == 39)
1343: jjCheckNAddStates(19, 21);
1344: break;
1345: case 22:
1346: if ((0xffffff7fffffffffL & l) != 0L)
1347: jjCheckNAddStates(19, 21);
1348: break;
1349: case 23:
1350: if (curChar == 39)
1351: jjCheckNAddStates(37, 39);
1352: break;
1353: case 24:
1354: if (curChar == 39)
1355: jjstateSet[jjnewStateCnt++] = 23;
1356: break;
1357: case 25:
1358: if ((0xffffff7fffffffffL & l) != 0L)
1359: jjCheckNAddStates(37, 39);
1360: break;
1361: case 26:
1362: if (curChar == 39 && kind > 83)
1363: kind = 83;
1364: break;
1365: case 27:
1366: if ((0x1800000000L & l) == 0L)
1367: break;
1368: if (kind > 84)
1369: kind = 84;
1370: jjCheckNAddStates(8, 18);
1371: break;
1372: case 28:
1373: if ((0x1800000000L & l) != 0L)
1374: jjCheckNAddStates(28, 30);
1375: break;
1376: case 29:
1377: if ((0x3ff001800000000L & l) != 0L)
1378: jjCheckNAddTwoStates(29, 30);
1379: break;
1380: case 30:
1381: if (curChar == 46)
1382: jjCheckNAdd(31);
1383: break;
1384: case 31:
1385: if ((0x1800000000L & l) != 0L)
1386: jjCheckNAddStates(40, 42);
1387: break;
1388: case 32:
1389: if ((0x3ff001800000000L & l) != 0L)
1390: jjCheckNAddTwoStates(32, 33);
1391: break;
1392: case 33:
1393: if (curChar == 46)
1394: jjCheckNAdd(34);
1395: break;
1396: case 34:
1397: if ((0x1800000000L & l) != 0L)
1398: jjCheckNAddStates(43, 45);
1399: break;
1400: case 35:
1401: if ((0x3ff001800000000L & l) != 0L)
1402: jjCheckNAddTwoStates(35, 36);
1403: break;
1404: case 36:
1405: if (curChar == 46)
1406: jjCheckNAdd(37);
1407: break;
1408: case 37:
1409: if ((0x1800000000L & l) == 0L)
1410: break;
1411: if (kind > 77)
1412: kind = 77;
1413: jjCheckNAddTwoStates(37, 38);
1414: break;
1415: case 38:
1416: if ((0x3ff001800000000L & l) == 0L)
1417: break;
1418: if (kind > 77)
1419: kind = 77;
1420: jjCheckNAdd(38);
1421: break;
1422: case 39:
1423: if ((0x1800000000L & l) != 0L)
1424: jjCheckNAddStates(25, 27);
1425: break;
1426: case 40:
1427: if ((0x3ff001800000000L & l) != 0L)
1428: jjCheckNAddTwoStates(40, 41);
1429: break;
1430: case 41:
1431: if (curChar == 46)
1432: jjCheckNAdd(42);
1433: break;
1434: case 42:
1435: if ((0x1800000000L & l) != 0L)
1436: jjCheckNAddStates(46, 48);
1437: break;
1438: case 43:
1439: if ((0x3ff001800000000L & l) != 0L)
1440: jjCheckNAddTwoStates(43, 44);
1441: break;
1442: case 44:
1443: if (curChar == 46)
1444: jjCheckNAdd(45);
1445: break;
1446: case 45:
1447: if ((0x1800000000L & l) == 0L)
1448: break;
1449: if (kind > 78)
1450: kind = 78;
1451: jjCheckNAddTwoStates(45, 46);
1452: break;
1453: case 46:
1454: if ((0x3ff001800000000L & l) == 0L)
1455: break;
1456: if (kind > 78)
1457: kind = 78;
1458: jjCheckNAdd(46);
1459: break;
1460: case 47:
1461: if ((0x1800000000L & l) != 0L)
1462: jjCheckNAddStates(22, 24);
1463: break;
1464: case 48:
1465: if ((0x3ff001800000000L & l) != 0L)
1466: jjCheckNAddTwoStates(48, 49);
1467: break;
1468: case 49:
1469: if (curChar == 46)
1470: jjCheckNAdd(50);
1471: break;
1472: case 50:
1473: if ((0x1800000000L & l) == 0L)
1474: break;
1475: if (kind > 79)
1476: kind = 79;
1477: jjCheckNAddTwoStates(50, 51);
1478: break;
1479: case 51:
1480: if ((0x3ff001800000000L & l) == 0L)
1481: break;
1482: if (kind > 79)
1483: kind = 79;
1484: jjCheckNAdd(51);
1485: break;
1486: case 52:
1487: if ((0x1800000000L & l) == 0L)
1488: break;
1489: if (kind > 84)
1490: kind = 84;
1491: jjCheckNAddTwoStates(52, 53);
1492: break;
1493: case 53:
1494: if ((0x3ff001800000000L & l) == 0L)
1495: break;
1496: if (kind > 84)
1497: kind = 84;
1498: jjCheckNAdd(53);
1499: break;
1500: case 54:
1501: if ((0x3ff000000000000L & l) == 0L)
1502: break;
1503: if (kind > 80)
1504: kind = 80;
1505: jjCheckNAddStates(0, 7);
1506: break;
1507: case 55:
1508: if ((0x3ff000000000000L & l) == 0L)
1509: break;
1510: if (kind > 80)
1511: kind = 80;
1512: jjCheckNAdd(55);
1513: break;
1514: case 56:
1515: if ((0x3ff000000000000L & l) != 0L)
1516: jjCheckNAddTwoStates(56, 57);
1517: break;
1518: case 57:
1519: if (curChar == 46)
1520: jjCheckNAdd(58);
1521: break;
1522: case 58:
1523: if ((0x3ff000000000000L & l) == 0L)
1524: break;
1525: if (kind > 81)
1526: kind = 81;
1527: jjCheckNAddTwoStates(58, 59);
1528: break;
1529: case 60:
1530: if ((0x280000000000L & l) != 0L)
1531: jjCheckNAdd(61);
1532: break;
1533: case 61:
1534: if ((0x3ff000000000000L & l) == 0L)
1535: break;
1536: if (kind > 81)
1537: kind = 81;
1538: jjCheckNAdd(61);
1539: break;
1540: case 62:
1541: if ((0x3ff000000000000L & l) != 0L)
1542: jjCheckNAddTwoStates(62, 63);
1543: break;
1544: case 64:
1545: if ((0x280000000000L & l) != 0L)
1546: jjCheckNAdd(65);
1547: break;
1548: case 65:
1549: if ((0x3ff000000000000L & l) == 0L)
1550: break;
1551: if (kind > 81)
1552: kind = 81;
1553: jjCheckNAdd(65);
1554: break;
1555: case 66:
1556: if ((0x3ff000000000000L & l) == 0L)
1557: break;
1558: if (kind > 81)
1559: kind = 81;
1560: jjCheckNAddTwoStates(66, 67);
1561: break;
1562: case 68:
1563: if ((0x280000000000L & l) != 0L)
1564: jjCheckNAdd(69);
1565: break;
1566: case 69:
1567: if ((0x3ff000000000000L & l) == 0L)
1568: break;
1569: if (kind > 81)
1570: kind = 81;
1571: jjCheckNAdd(69);
1572: break;
1573: case 70:
1574: if ((0x3ff000000000000L & l) == 0L)
1575: break;
1576: if (kind > 87)
1577: kind = 87;
1578: jjCheckNAdd(70);
1579: break;
1580: default:
1581: break;
1582: }
1583: } while (i != startsAt);
1584: } else if (curChar < 128) {
1585: long l = 1L << (curChar & 077);
1586: //MatchLoop:
1587: do {
1588: switch (jjstateSet[--i]) {
1589: case 5:
1590: if ((0x7fffffe87fffffeL & l) == 0L)
1591: break;
1592: if (kind > 84)
1593: kind = 84;
1594: jjCheckNAddStates(8, 18);
1595: break;
1596: case 71:
1597: if ((0x7fffffe87fffffeL & l) != 0L) {
1598: if (kind > 84)
1599: kind = 84;
1600: jjCheckNAdd(53);
1601: }
1602: if ((0x7fffffe87fffffeL & l) != 0L) {
1603: if (kind > 84)
1604: kind = 84;
1605: jjCheckNAddTwoStates(52, 53);
1606: }
1607: if ((0x7fffffe87fffffeL & l) != 0L)
1608: jjCheckNAddTwoStates(48, 49);
1609: if ((0x7fffffe87fffffeL & l) != 0L)
1610: jjCheckNAddStates(22, 24);
1611: if ((0x7fffffe87fffffeL & l) != 0L)
1612: jjCheckNAddTwoStates(40, 41);
1613: if ((0x7fffffe87fffffeL & l) != 0L)
1614: jjCheckNAddStates(25, 27);
1615: if ((0x7fffffe87fffffeL & l) != 0L)
1616: jjCheckNAddTwoStates(29, 30);
1617: if ((0x7fffffe87fffffeL & l) != 0L)
1618: jjCheckNAddStates(28, 30);
1619: break;
1620: case 1:
1621: jjAddStates(31, 33);
1622: break;
1623: case 7:
1624: jjCheckNAddTwoStates(7, 8);
1625: break;
1626: case 9:
1627: case 10:
1628: jjCheckNAddTwoStates(10, 8);
1629: break;
1630: case 14:
1631: if ((0x7fffffe87fffffeL & l) == 0L)
1632: break;
1633: if (kind > 76)
1634: kind = 76;
1635: jjCheckNAddTwoStates(14, 15);
1636: break;
1637: case 15:
1638: if ((0x7fffffe87fffffeL & l) == 0L)
1639: break;
1640: if (kind > 76)
1641: kind = 76;
1642: jjCheckNAdd(15);
1643: break;
1644: case 18:
1645: if ((0x2000000020L & l) != 0L)
1646: jjAddStates(49, 50);
1647: break;
1648: case 22:
1649: jjCheckNAddStates(19, 21);
1650: break;
1651: case 25:
1652: jjCheckNAddStates(37, 39);
1653: break;
1654: case 28:
1655: if ((0x7fffffe87fffffeL & l) != 0L)
1656: jjCheckNAddStates(28, 30);
1657: break;
1658: case 29:
1659: if ((0x7fffffe87fffffeL & l) != 0L)
1660: jjCheckNAddTwoStates(29, 30);
1661: break;
1662: case 31:
1663: if ((0x7fffffe87fffffeL & l) != 0L)
1664: jjCheckNAddStates(40, 42);
1665: break;
1666: case 32:
1667: if ((0x7fffffe87fffffeL & l) != 0L)
1668: jjCheckNAddTwoStates(32, 33);
1669: break;
1670: case 34:
1671: if ((0x7fffffe87fffffeL & l) != 0L)
1672: jjCheckNAddStates(43, 45);
1673: break;
1674: case 35:
1675: if ((0x7fffffe87fffffeL & l) != 0L)
1676: jjCheckNAddTwoStates(35, 36);
1677: break;
1678: case 37:
1679: if ((0x7fffffe87fffffeL & l) == 0L)
1680: break;
1681: if (kind > 77)
1682: kind = 77;
1683: jjCheckNAddTwoStates(37, 38);
1684: break;
1685: case 38:
1686: if ((0x7fffffe87fffffeL & l) == 0L)
1687: break;
1688: if (kind > 77)
1689: kind = 77;
1690: jjCheckNAdd(38);
1691: break;
1692: case 39:
1693: if ((0x7fffffe87fffffeL & l) != 0L)
1694: jjCheckNAddStates(25, 27);
1695: break;
1696: case 40:
1697: if ((0x7fffffe87fffffeL & l) != 0L)
1698: jjCheckNAddTwoStates(40, 41);
1699: break;
1700: case 42:
1701: if ((0x7fffffe87fffffeL & l) != 0L)
1702: jjCheckNAddStates(46, 48);
1703: break;
1704: case 43:
1705: if ((0x7fffffe87fffffeL & l) != 0L)
1706: jjCheckNAddTwoStates(43, 44);
1707: break;
1708: case 45:
1709: if ((0x7fffffe87fffffeL & l) == 0L)
1710: break;
1711: if (kind > 78)
1712: kind = 78;
1713: jjCheckNAddTwoStates(45, 46);
1714: break;
1715: case 46:
1716: if ((0x7fffffe87fffffeL & l) == 0L)
1717: break;
1718: if (kind > 78)
1719: kind = 78;
1720: jjCheckNAdd(46);
1721: break;
1722: case 47:
1723: if ((0x7fffffe87fffffeL & l) != 0L)
1724: jjCheckNAddStates(22, 24);
1725: break;
1726: case 48:
1727: if ((0x7fffffe87fffffeL & l) != 0L)
1728: jjCheckNAddTwoStates(48, 49);
1729: break;
1730: case 50:
1731: if ((0x7fffffe87fffffeL & l) == 0L)
1732: break;
1733: if (kind > 79)
1734: kind = 79;
1735: jjCheckNAddTwoStates(50, 51);
1736: break;
1737: case 51:
1738: if ((0x7fffffe87fffffeL & l) == 0L)
1739: break;
1740: if (kind > 79)
1741: kind = 79;
1742: jjCheckNAdd(51);
1743: break;
1744: case 52:
1745: if ((0x7fffffe87fffffeL & l) == 0L)
1746: break;
1747: if (kind > 84)
1748: kind = 84;
1749: jjCheckNAddTwoStates(52, 53);
1750: break;
1751: case 53:
1752: if ((0x7fffffe87fffffeL & l) == 0L)
1753: break;
1754: if (kind > 84)
1755: kind = 84;
1756: jjCheckNAdd(53);
1757: break;
1758: case 59:
1759: if ((0x2000000020L & l) != 0L)
1760: jjAddStates(51, 52);
1761: break;
1762: case 63:
1763: if ((0x2000000020L & l) != 0L)
1764: jjAddStates(53, 54);
1765: break;
1766: case 67:
1767: if ((0x2000000020L & l) != 0L)
1768: jjAddStates(55, 56);
1769: break;
1770: default:
1771: break;
1772: }
1773: } while (i != startsAt);
1774: } else {
1775: int hiByte = (int) (curChar >> 8);
1776: int i1 = hiByte >> 6;
1777: long l1 = 1L << (hiByte & 077);
1778: int i2 = (curChar & 0xff) >> 6;
1779: long l2 = 1L << (curChar & 077);
1780: //MatchLoop:
1781: do {
1782: switch (jjstateSet[--i]) {
1783: case 1:
1784: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1785: jjAddStates(31, 33);
1786: break;
1787: case 7:
1788: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1789: jjCheckNAddTwoStates(7, 8);
1790: break;
1791: case 9:
1792: case 10:
1793: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1794: jjCheckNAddTwoStates(10, 8);
1795: break;
1796: case 22:
1797: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1798: jjCheckNAddStates(19, 21);
1799: break;
1800: case 25:
1801: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1802: jjCheckNAddStates(37, 39);
1803: break;
1804: default:
1805: break;
1806: }
1807: } while (i != startsAt);
1808: }
1809: if (kind != 0x7fffffff) {
1810: jjmatchedKind = kind;
1811: jjmatchedPos = curPos;
1812: kind = 0x7fffffff;
1813: }
1814: ++curPos;
1815: if ((i = jjnewStateCnt) == (startsAt = 71 - (jjnewStateCnt = startsAt)))
1816: return curPos;
1817: try {
1818: curChar = input_stream.readChar();
1819: } catch (java.io.IOException e) {
1820: return curPos;
1821: }
1822: }
1823: }
1824:
1825: static final int[] jjnextStates = { 55, 56, 57, 62, 63, 66, 67, 70,
1826: 28, 29, 30, 39, 40, 41, 47, 48, 49, 52, 53, 22, 24, 26, 47,
1827: 48, 49, 39, 40, 41, 28, 29, 30, 1, 2, 4, 8, 9, 11, 24, 25,
1828: 26, 31, 32, 33, 34, 35, 36, 42, 43, 44, 19, 20, 60, 61, 64,
1829: 65, 68, 69, };
1830:
1831: private static final boolean jjCanMove_0(int hiByte, int i1,
1832: int i2, long l1, long l2) {
1833: switch (hiByte) {
1834: case 0:
1835: return ((jjbitVec2[i2] & l2) != 0L);
1836: default:
1837: if ((jjbitVec0[i1] & l1) != 0L)
1838: return true;
1839: return false;
1840: }
1841: }
1842:
1843: public static final String[] jjstrLiteralImages = { "", null, null,
1844: null, null, null, null, null, null, null, null, null, null,
1845: null, null, null, null, null, null, null, null, null, null,
1846: null, null, null, null, null, null, null, null, null, null,
1847: null, null, null, null, null, null, null, null, null, null,
1848: null, null, null, null, null, null, null, null, null, null,
1849: null, null, null, null, null, null, null, null, null, null,
1850: null, null, null, null, null, null, null, null, null, null,
1851: null, null, null, null, null, null, null, null, null, null,
1852: null, null, null, null, null, "\72\75", "\54", "\174\174",
1853: "\73", "\56", "\74", "\74\75", "\76", "\76\75", "\75",
1854: "\41\75", "\74\76", "\50\53\51", "\50", "\51", "\52",
1855: "\57", "\53", "\55", "\77", };
1856: public static final String[] lexStateNames = { "DEFAULT", };
1857: static final long[] jjtoToken = { 0xffffffffffffff81L,
1858: 0xfffff9bffffL, };
1859: static final long[] jjtoSkip = { 0x7eL, 0x0L, };
1860: protected SimpleCharStream input_stream;
1861: private final int[] jjrounds = new int[71];
1862: private final int[] jjstateSet = new int[142];
1863: protected char curChar;
1864:
1865: public SQLConditionParserTokenManager(SimpleCharStream stream) {
1866: if (SimpleCharStream.staticFlag)
1867: throw new Error(
1868: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1869: input_stream = stream;
1870: }
1871:
1872: public SQLConditionParserTokenManager(SimpleCharStream stream,
1873: int lexState) {
1874: this (stream);
1875: SwitchTo(lexState);
1876: }
1877:
1878: public void ReInit(SimpleCharStream stream) {
1879: jjmatchedPos = jjnewStateCnt = 0;
1880: curLexState = defaultLexState;
1881: input_stream = stream;
1882: ReInitRounds();
1883: }
1884:
1885: private final void ReInitRounds() {
1886: int i;
1887: jjround = 0x80000001;
1888: for (i = 71; i-- > 0;)
1889: jjrounds[i] = 0x80000000;
1890: }
1891:
1892: public void ReInit(SimpleCharStream stream, int lexState) {
1893: ReInit(stream);
1894: SwitchTo(lexState);
1895: }
1896:
1897: public void SwitchTo(int lexState) {
1898: if (lexState >= 1 || lexState < 0)
1899: throw new TokenMgrError(
1900: "Error: Ignoring invalid lexical state : "
1901: + lexState + ". State unchanged.",
1902: TokenMgrError.INVALID_LEXICAL_STATE);
1903: else
1904: curLexState = lexState;
1905: }
1906:
1907: protected Token jjFillToken() {
1908: Token t = Token.newToken(jjmatchedKind);
1909: t.kind = jjmatchedKind;
1910: String im = jjstrLiteralImages[jjmatchedKind];
1911: t.image = (im == null) ? input_stream.GetImage() : im;
1912: t.beginLine = input_stream.getBeginLine();
1913: t.beginColumn = input_stream.getBeginColumn();
1914: t.endLine = input_stream.getEndLine();
1915: t.endColumn = input_stream.getEndColumn();
1916: return t;
1917: }
1918:
1919: int curLexState = 0;
1920: int defaultLexState = 0;
1921: int jjnewStateCnt;
1922: int jjround;
1923: int jjmatchedPos;
1924: int jjmatchedKind;
1925:
1926: public Token getNextToken() {
1927: //int kind;
1928: //Token specialToken = null;
1929: Token matchedToken;
1930: int curPos = 0;
1931:
1932: EOFLoop: for (;;) {
1933: try {
1934: curChar = input_stream.BeginToken();
1935: } catch (java.io.IOException e) {
1936: jjmatchedKind = 0;
1937: matchedToken = jjFillToken();
1938: return matchedToken;
1939: }
1940:
1941: try {
1942: input_stream.backup(0);
1943: while (curChar <= 32
1944: && (0x100002600L & (1L << curChar)) != 0L)
1945: curChar = input_stream.BeginToken();
1946: } catch (java.io.IOException e1) {
1947: continue EOFLoop;
1948: }
1949: jjmatchedKind = 0x7fffffff;
1950: jjmatchedPos = 0;
1951: curPos = jjMoveStringLiteralDfa0_0();
1952: if (jjmatchedKind != 0x7fffffff) {
1953: if (jjmatchedPos + 1 < curPos)
1954: input_stream.backup(curPos - jjmatchedPos - 1);
1955: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1956: matchedToken = jjFillToken();
1957: return matchedToken;
1958: } else {
1959: continue EOFLoop;
1960: }
1961: }
1962: int error_line = input_stream.getEndLine();
1963: int error_column = input_stream.getEndColumn();
1964: String error_after = null;
1965: boolean EOFSeen = false;
1966: try {
1967: input_stream.readChar();
1968: input_stream.backup(1);
1969: } catch (java.io.IOException e1) {
1970: EOFSeen = true;
1971: error_after = curPos <= 1 ? "" : input_stream
1972: .GetImage();
1973: if (curChar == '\n' || curChar == '\r') {
1974: error_line++;
1975: error_column = 0;
1976: } else
1977: error_column++;
1978: }
1979: if (!EOFSeen) {
1980: input_stream.backup(1);
1981: error_after = curPos <= 1 ? "" : input_stream
1982: .GetImage();
1983: }
1984: throw new TokenMgrError(EOFSeen, curLexState, error_line,
1985: error_column, error_after, curChar,
1986: TokenMgrError.LEXICAL_ERROR);
1987: }
1988: }
1989:
1990: }
|