0001: /* Generated By:JavaCC: Do not edit this line. EJBQLParserTokenManager.java */
0002: package com.versant.core.ejb.query;
0003:
0004: public class EJBQLParserTokenManager implements EJBQLParserConstants {
0005: public java.io.PrintStream debugStream = System.out;
0006:
0007: public void setDebugStream(java.io.PrintStream ds) {
0008: debugStream = ds;
0009: }
0010:
0011: private final int jjStopStringLiteralDfa_0(int pos, long active0,
0012: long active1) {
0013: switch (pos) {
0014: case 0:
0015: if ((active0 & 0x4000L) != 0L)
0016: return 44;
0017: return -1;
0018: default:
0019: return -1;
0020: }
0021: }
0022:
0023: private final int jjStartNfa_0(int pos, long active0, long active1) {
0024: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
0025: active1), pos + 1);
0026: }
0027:
0028: private final int jjStopAtPos(int pos, int kind) {
0029: jjmatchedKind = kind;
0030: jjmatchedPos = pos;
0031: return pos + 1;
0032: }
0033:
0034: private final int jjStartNfaWithStates_0(int pos, int kind,
0035: int state) {
0036: jjmatchedKind = kind;
0037: jjmatchedPos = pos;
0038: try {
0039: curChar = input_stream.readChar();
0040: } catch (java.io.IOException e) {
0041: return pos + 1;
0042: }
0043: return jjMoveNfa_0(state, pos + 1);
0044: }
0045:
0046: private final int jjMoveStringLiteralDfa0_0() {
0047: switch (curChar) {
0048: case 40:
0049: return jjStopAtPos(0, 6);
0050: case 41:
0051: return jjStopAtPos(0, 7);
0052: case 42:
0053: return jjStopAtPos(0, 95);
0054: case 43:
0055: return jjStopAtPos(0, 93);
0056: case 44:
0057: return jjStopAtPos(0, 13);
0058: case 45:
0059: return jjStopAtPos(0, 94);
0060: case 46:
0061: return jjStartNfaWithStates_0(0, 14, 44);
0062: case 47:
0063: return jjStopAtPos(0, 96);
0064: case 58:
0065: return jjStopAtPos(0, 16);
0066: case 59:
0067: return jjStopAtPos(0, 12);
0068: case 60:
0069: jjmatchedKind = 18;
0070: return jjMoveStringLiteralDfa1_0(0x480000L);
0071: case 61:
0072: return jjStopAtPos(0, 17);
0073: case 62:
0074: jjmatchedKind = 20;
0075: return jjMoveStringLiteralDfa1_0(0x200000L);
0076: case 63:
0077: return jjStopAtPos(0, 15);
0078: case 91:
0079: return jjStopAtPos(0, 10);
0080: case 93:
0081: return jjStopAtPos(0, 11);
0082: case 123:
0083: return jjStopAtPos(0, 8);
0084: case 125:
0085: return jjStopAtPos(0, 9);
0086: default:
0087: return jjMoveNfa_0(3, 0);
0088: }
0089: }
0090:
0091: private final int jjMoveStringLiteralDfa1_0(long active0) {
0092: try {
0093: curChar = input_stream.readChar();
0094: } catch (java.io.IOException e) {
0095: jjStopStringLiteralDfa_0(0, active0, 0L);
0096: return 1;
0097: }
0098: switch (curChar) {
0099: case 61:
0100: if ((active0 & 0x80000L) != 0L)
0101: return jjStopAtPos(1, 19);
0102: else if ((active0 & 0x200000L) != 0L)
0103: return jjStopAtPos(1, 21);
0104: break;
0105: case 62:
0106: if ((active0 & 0x400000L) != 0L)
0107: return jjStopAtPos(1, 22);
0108: break;
0109: default:
0110: break;
0111: }
0112: return jjStartNfa_0(0, active0, 0L);
0113: }
0114:
0115: private final void jjCheckNAdd(int state) {
0116: if (jjrounds[state] != jjround) {
0117: jjstateSet[jjnewStateCnt++] = state;
0118: jjrounds[state] = jjround;
0119: }
0120: }
0121:
0122: private final void jjAddStates(int start, int end) {
0123: do {
0124: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0125: } while (start++ != end);
0126: }
0127:
0128: private final void jjCheckNAddTwoStates(int state1, int state2) {
0129: jjCheckNAdd(state1);
0130: jjCheckNAdd(state2);
0131: }
0132:
0133: private final void jjCheckNAddStates(int start, int end) {
0134: do {
0135: jjCheckNAdd(jjnextStates[start]);
0136: } while (start++ != end);
0137: }
0138:
0139: private final void jjCheckNAddStates(int start) {
0140: jjCheckNAdd(jjnextStates[start]);
0141: jjCheckNAdd(jjnextStates[start + 1]);
0142: }
0143:
0144: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0145: 0xffffffffffffffffL, 0xffffffffffffffffL,
0146: 0xffffffffffffffffL };
0147: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0148: 0xffffffffffffffffL };
0149:
0150: private final int jjMoveNfa_0(int startState, int curPos) {
0151: int[] nextStates;
0152: int startsAt = 0;
0153: jjnewStateCnt = 567;
0154: int i = 1;
0155: jjstateSet[0] = startState;
0156: int j, kind = 0x7fffffff;
0157: for (;;) {
0158: if (++jjround == 0x7fffffff)
0159: ReInitRounds();
0160: if (curChar < 64) {
0161: long l = 1L << curChar;
0162: MatchLoop: do {
0163: switch (jjstateSet[--i]) {
0164: case 3:
0165: if ((0x3ff000000000000L & l) != 0L)
0166: jjCheckNAddStates(0, 6);
0167: else if (curChar == 34)
0168: jjCheckNAddStates(7, 9);
0169: else if (curChar == 39)
0170: jjCheckNAddStates(10, 12);
0171: else if (curChar == 46)
0172: jjCheckNAdd(44);
0173: if ((0x3fe000000000000L & l) != 0L) {
0174: if (kind > 81)
0175: kind = 81;
0176: jjCheckNAddTwoStates(41, 42);
0177: } else if (curChar == 48) {
0178: if (kind > 83)
0179: kind = 83;
0180: jjCheckNAddTwoStates(563, 566);
0181: }
0182: break;
0183: case 40:
0184: if ((0x3fe000000000000L & l) == 0L)
0185: break;
0186: if (kind > 81)
0187: kind = 81;
0188: jjCheckNAddTwoStates(41, 42);
0189: break;
0190: case 41:
0191: if ((0x3ff000000000000L & l) == 0L)
0192: break;
0193: if (kind > 81)
0194: kind = 81;
0195: jjCheckNAddTwoStates(41, 42);
0196: break;
0197: case 43:
0198: if (curChar == 46)
0199: jjCheckNAdd(44);
0200: break;
0201: case 44:
0202: if ((0x3ff000000000000L & l) == 0L)
0203: break;
0204: if (kind > 84)
0205: kind = 84;
0206: jjCheckNAddStates(13, 15);
0207: break;
0208: case 46:
0209: if ((0x280000000000L & l) != 0L)
0210: jjCheckNAdd(47);
0211: break;
0212: case 47:
0213: if ((0x3ff000000000000L & l) == 0L)
0214: break;
0215: if (kind > 84)
0216: kind = 84;
0217: jjCheckNAddTwoStates(47, 48);
0218: break;
0219: case 49:
0220: if (curChar == 39)
0221: jjCheckNAddStates(10, 12);
0222: break;
0223: case 50:
0224: if ((0xffffff7fffffdbffL & l) != 0L)
0225: jjCheckNAddStates(10, 12);
0226: break;
0227: case 52:
0228: if ((0x8400000000L & l) != 0L)
0229: jjCheckNAddStates(10, 12);
0230: break;
0231: case 53:
0232: if (curChar == 39 && kind > 86)
0233: kind = 86;
0234: break;
0235: case 54:
0236: if ((0xff000000000000L & l) != 0L)
0237: jjCheckNAddStates(16, 19);
0238: break;
0239: case 55:
0240: if ((0xff000000000000L & l) != 0L)
0241: jjCheckNAddStates(10, 12);
0242: break;
0243: case 56:
0244: if ((0xf000000000000L & l) != 0L)
0245: jjstateSet[jjnewStateCnt++] = 57;
0246: break;
0247: case 57:
0248: if ((0xff000000000000L & l) != 0L)
0249: jjCheckNAdd(55);
0250: break;
0251: case 58:
0252: if (curChar == 34)
0253: jjCheckNAddStates(7, 9);
0254: break;
0255: case 59:
0256: if ((0xfffffffbffffdbffL & l) != 0L)
0257: jjCheckNAddStates(7, 9);
0258: break;
0259: case 61:
0260: if ((0x8400000000L & l) != 0L)
0261: jjCheckNAddStates(7, 9);
0262: break;
0263: case 62:
0264: if (curChar == 34 && kind > 89)
0265: kind = 89;
0266: break;
0267: case 63:
0268: if ((0xff000000000000L & l) != 0L)
0269: jjCheckNAddStates(20, 23);
0270: break;
0271: case 64:
0272: if ((0xff000000000000L & l) != 0L)
0273: jjCheckNAddStates(7, 9);
0274: break;
0275: case 65:
0276: if ((0xf000000000000L & l) != 0L)
0277: jjstateSet[jjnewStateCnt++] = 66;
0278: break;
0279: case 66:
0280: if ((0xff000000000000L & l) != 0L)
0281: jjCheckNAdd(64);
0282: break;
0283: case 68:
0284: if ((0x3ff000000000000L & l) == 0L)
0285: break;
0286: if (kind > 90)
0287: kind = 90;
0288: jjstateSet[jjnewStateCnt++] = 68;
0289: break;
0290: case 69:
0291: if ((0x3ff000000000000L & l) != 0L)
0292: jjCheckNAddStates(0, 6);
0293: break;
0294: case 70:
0295: if ((0x3ff000000000000L & l) != 0L)
0296: jjCheckNAddTwoStates(70, 71);
0297: break;
0298: case 71:
0299: if (curChar != 46)
0300: break;
0301: if (kind > 84)
0302: kind = 84;
0303: jjCheckNAddStates(24, 26);
0304: break;
0305: case 72:
0306: if ((0x3ff000000000000L & l) == 0L)
0307: break;
0308: if (kind > 84)
0309: kind = 84;
0310: jjCheckNAddStates(24, 26);
0311: break;
0312: case 74:
0313: if ((0x280000000000L & l) != 0L)
0314: jjCheckNAdd(75);
0315: break;
0316: case 75:
0317: if ((0x3ff000000000000L & l) == 0L)
0318: break;
0319: if (kind > 84)
0320: kind = 84;
0321: jjCheckNAddTwoStates(75, 48);
0322: break;
0323: case 76:
0324: if ((0x3ff000000000000L & l) != 0L)
0325: jjCheckNAddTwoStates(76, 77);
0326: break;
0327: case 78:
0328: if ((0x280000000000L & l) != 0L)
0329: jjCheckNAdd(79);
0330: break;
0331: case 79:
0332: if ((0x3ff000000000000L & l) == 0L)
0333: break;
0334: if (kind > 84)
0335: kind = 84;
0336: jjCheckNAddTwoStates(79, 48);
0337: break;
0338: case 80:
0339: if ((0x3ff000000000000L & l) != 0L)
0340: jjCheckNAddStates(27, 29);
0341: break;
0342: case 82:
0343: if ((0x280000000000L & l) != 0L)
0344: jjCheckNAdd(83);
0345: break;
0346: case 83:
0347: if ((0x3ff000000000000L & l) != 0L)
0348: jjCheckNAddTwoStates(83, 48);
0349: break;
0350: case 562:
0351: if (curChar != 48)
0352: break;
0353: if (kind > 83)
0354: kind = 83;
0355: jjCheckNAddTwoStates(563, 566);
0356: break;
0357: case 564:
0358: if ((0x3ff000000000000L & l) == 0L)
0359: break;
0360: if (kind > 82)
0361: kind = 82;
0362: jjAddStates(30, 31);
0363: break;
0364: case 566:
0365: if ((0xff000000000000L & l) == 0L)
0366: break;
0367: if (kind > 83)
0368: kind = 83;
0369: jjCheckNAdd(566);
0370: break;
0371: default:
0372: break;
0373: }
0374: } while (i != startsAt);
0375: } else if (curChar < 128) {
0376: long l = 1L << (curChar & 077);
0377: MatchLoop: do {
0378: switch (jjstateSet[--i]) {
0379: case 3:
0380: if ((0x7fffffe87fffffeL & l) != 0L) {
0381: if (kind > 90)
0382: kind = 90;
0383: jjCheckNAdd(68);
0384: }
0385: if (curChar == 116)
0386: jjAddStates(32, 34);
0387: else if (curChar == 84)
0388: jjAddStates(35, 36);
0389: else if (curChar == 101)
0390: jjAddStates(37, 39);
0391: else if (curChar == 69)
0392: jjAddStates(40, 42);
0393: else if (curChar == 98)
0394: jjAddStates(43, 46);
0395: else if (curChar == 66)
0396: jjAddStates(47, 50);
0397: else if (curChar == 99)
0398: jjAddStates(51, 55);
0399: else if (curChar == 67)
0400: jjAddStates(56, 60);
0401: else if (curChar == 109)
0402: jjAddStates(61, 64);
0403: else if (curChar == 77)
0404: jjAddStates(65, 68);
0405: else if (curChar == 110)
0406: jjAddStates(69, 71);
0407: else if (curChar == 78)
0408: jjAddStates(72, 74);
0409: else if (curChar == 117)
0410: jjAddStates(75, 76);
0411: else if (curChar == 85)
0412: jjAddStates(77, 78);
0413: else if (curChar == 97)
0414: jjAddStates(79, 85);
0415: else if (curChar == 65)
0416: jjAddStates(86, 92);
0417: else if (curChar == 105)
0418: jjAddStates(93, 95);
0419: else if (curChar == 73)
0420: jjAddStates(96, 98);
0421: else if (curChar == 108)
0422: jjAddStates(99, 104);
0423: else if (curChar == 76)
0424: jjAddStates(105, 110);
0425: else if (curChar == 111)
0426: jjAddStates(111, 115);
0427: else if (curChar == 79)
0428: jjAddStates(116, 120);
0429: else if (curChar == 100)
0430: jjAddStates(121, 123);
0431: else if (curChar == 68)
0432: jjAddStates(124, 126);
0433: else if (curChar == 102)
0434: jjAddStates(127, 129);
0435: else if (curChar == 70)
0436: jjAddStates(130, 131);
0437: else if (curChar == 115)
0438: jjAddStates(132, 137);
0439: else if (curChar == 83)
0440: jjAddStates(138, 143);
0441: else if (curChar == 104)
0442: jjstateSet[jjnewStateCnt++] = 38;
0443: else if (curChar == 72)
0444: jjstateSet[jjnewStateCnt++] = 32;
0445: else if (curChar == 103)
0446: jjstateSet[jjnewStateCnt++] = 26;
0447: else if (curChar == 71)
0448: jjstateSet[jjnewStateCnt++] = 21;
0449: else if (curChar == 119)
0450: jjstateSet[jjnewStateCnt++] = 16;
0451: else if (curChar == 87)
0452: jjstateSet[jjnewStateCnt++] = 11;
0453: else if (curChar == 106)
0454: jjstateSet[jjnewStateCnt++] = 6;
0455: else if (curChar == 74)
0456: jjstateSet[jjnewStateCnt++] = 2;
0457: break;
0458: case 0:
0459: if (curChar == 78 && kind > 30)
0460: kind = 30;
0461: break;
0462: case 1:
0463: if (curChar == 73)
0464: jjstateSet[jjnewStateCnt++] = 0;
0465: break;
0466: case 2:
0467: if (curChar == 79)
0468: jjstateSet[jjnewStateCnt++] = 1;
0469: break;
0470: case 4:
0471: if (curChar == 110 && kind > 30)
0472: kind = 30;
0473: break;
0474: case 5:
0475: if (curChar == 105)
0476: jjstateSet[jjnewStateCnt++] = 4;
0477: break;
0478: case 6:
0479: if (curChar == 111)
0480: jjstateSet[jjnewStateCnt++] = 5;
0481: break;
0482: case 7:
0483: if (curChar == 106)
0484: jjstateSet[jjnewStateCnt++] = 6;
0485: break;
0486: case 8:
0487: if (curChar == 69 && kind > 43)
0488: kind = 43;
0489: break;
0490: case 9:
0491: if (curChar == 82)
0492: jjstateSet[jjnewStateCnt++] = 8;
0493: break;
0494: case 10:
0495: if (curChar == 69)
0496: jjstateSet[jjnewStateCnt++] = 9;
0497: break;
0498: case 11:
0499: if (curChar == 72)
0500: jjstateSet[jjnewStateCnt++] = 10;
0501: break;
0502: case 12:
0503: if (curChar == 87)
0504: jjstateSet[jjnewStateCnt++] = 11;
0505: break;
0506: case 13:
0507: if (curChar == 101 && kind > 43)
0508: kind = 43;
0509: break;
0510: case 14:
0511: if (curChar == 114)
0512: jjstateSet[jjnewStateCnt++] = 13;
0513: break;
0514: case 15:
0515: if (curChar == 101)
0516: jjstateSet[jjnewStateCnt++] = 14;
0517: break;
0518: case 16:
0519: if (curChar == 104)
0520: jjstateSet[jjnewStateCnt++] = 15;
0521: break;
0522: case 17:
0523: if (curChar == 119)
0524: jjstateSet[jjnewStateCnt++] = 16;
0525: break;
0526: case 18:
0527: if (curChar == 80 && kind > 44)
0528: kind = 44;
0529: break;
0530: case 19:
0531: if (curChar == 85)
0532: jjstateSet[jjnewStateCnt++] = 18;
0533: break;
0534: case 20:
0535: if (curChar == 79)
0536: jjstateSet[jjnewStateCnt++] = 19;
0537: break;
0538: case 21:
0539: if (curChar == 82)
0540: jjstateSet[jjnewStateCnt++] = 20;
0541: break;
0542: case 22:
0543: if (curChar == 71)
0544: jjstateSet[jjnewStateCnt++] = 21;
0545: break;
0546: case 23:
0547: if (curChar == 112 && kind > 44)
0548: kind = 44;
0549: break;
0550: case 24:
0551: if (curChar == 117)
0552: jjstateSet[jjnewStateCnt++] = 23;
0553: break;
0554: case 25:
0555: if (curChar == 111)
0556: jjstateSet[jjnewStateCnt++] = 24;
0557: break;
0558: case 26:
0559: if (curChar == 114)
0560: jjstateSet[jjnewStateCnt++] = 25;
0561: break;
0562: case 27:
0563: if (curChar == 103)
0564: jjstateSet[jjnewStateCnt++] = 26;
0565: break;
0566: case 28:
0567: if (curChar == 71 && kind > 46)
0568: kind = 46;
0569: break;
0570: case 29:
0571: if (curChar == 78)
0572: jjstateSet[jjnewStateCnt++] = 28;
0573: break;
0574: case 30:
0575: if (curChar == 73)
0576: jjstateSet[jjnewStateCnt++] = 29;
0577: break;
0578: case 31:
0579: if (curChar == 86)
0580: jjstateSet[jjnewStateCnt++] = 30;
0581: break;
0582: case 32:
0583: if (curChar == 65)
0584: jjstateSet[jjnewStateCnt++] = 31;
0585: break;
0586: case 33:
0587: if (curChar == 72)
0588: jjstateSet[jjnewStateCnt++] = 32;
0589: break;
0590: case 34:
0591: if (curChar == 103 && kind > 46)
0592: kind = 46;
0593: break;
0594: case 35:
0595: if (curChar == 110)
0596: jjstateSet[jjnewStateCnt++] = 34;
0597: break;
0598: case 36:
0599: if (curChar == 105)
0600: jjstateSet[jjnewStateCnt++] = 35;
0601: break;
0602: case 37:
0603: if (curChar == 118)
0604: jjstateSet[jjnewStateCnt++] = 36;
0605: break;
0606: case 38:
0607: if (curChar == 97)
0608: jjstateSet[jjnewStateCnt++] = 37;
0609: break;
0610: case 39:
0611: if (curChar == 104)
0612: jjstateSet[jjnewStateCnt++] = 38;
0613: break;
0614: case 42:
0615: if ((0x100000001000L & l) != 0L && kind > 81)
0616: kind = 81;
0617: break;
0618: case 45:
0619: if ((0x2000000020L & l) != 0L)
0620: jjAddStates(144, 145);
0621: break;
0622: case 48:
0623: if ((0x5000000050L & l) != 0L && kind > 84)
0624: kind = 84;
0625: break;
0626: case 50:
0627: if ((0xffffffffefffffffL & l) != 0L)
0628: jjCheckNAddStates(10, 12);
0629: break;
0630: case 51:
0631: if (curChar == 92)
0632: jjAddStates(146, 148);
0633: break;
0634: case 52:
0635: if ((0x14404410000000L & l) != 0L)
0636: jjCheckNAddStates(10, 12);
0637: break;
0638: case 59:
0639: if ((0xffffffffefffffffL & l) != 0L)
0640: jjCheckNAddStates(7, 9);
0641: break;
0642: case 60:
0643: if (curChar == 92)
0644: jjAddStates(149, 151);
0645: break;
0646: case 61:
0647: if ((0x14404410000000L & l) != 0L)
0648: jjCheckNAddStates(7, 9);
0649: break;
0650: case 67:
0651: case 68:
0652: if ((0x7fffffe87fffffeL & l) == 0L)
0653: break;
0654: if (kind > 90)
0655: kind = 90;
0656: jjCheckNAdd(68);
0657: break;
0658: case 73:
0659: if ((0x2000000020L & l) != 0L)
0660: jjAddStates(152, 153);
0661: break;
0662: case 77:
0663: if ((0x2000000020L & l) != 0L)
0664: jjAddStates(154, 155);
0665: break;
0666: case 81:
0667: if ((0x2000000020L & l) != 0L)
0668: jjAddStates(156, 157);
0669: break;
0670: case 84:
0671: if (curChar == 83)
0672: jjAddStates(138, 143);
0673: break;
0674: case 85:
0675: if (curChar == 84 && kind > 23)
0676: kind = 23;
0677: break;
0678: case 86:
0679: if (curChar == 67)
0680: jjstateSet[jjnewStateCnt++] = 85;
0681: break;
0682: case 87:
0683: if (curChar == 69)
0684: jjstateSet[jjnewStateCnt++] = 86;
0685: break;
0686: case 88:
0687: if (curChar == 76)
0688: jjstateSet[jjnewStateCnt++] = 87;
0689: break;
0690: case 89:
0691: if (curChar == 69)
0692: jjstateSet[jjnewStateCnt++] = 88;
0693: break;
0694: case 90:
0695: if (curChar == 84 && kind > 35)
0696: kind = 35;
0697: break;
0698: case 91:
0699: if (curChar == 69)
0700: jjstateSet[jjnewStateCnt++] = 90;
0701: break;
0702: case 92:
0703: if (curChar == 77 && kind > 41)
0704: kind = 41;
0705: break;
0706: case 93:
0707: if (curChar == 85)
0708: jjstateSet[jjnewStateCnt++] = 92;
0709: break;
0710: case 94:
0711: if (curChar == 69 && kind > 60)
0712: kind = 60;
0713: break;
0714: case 95:
0715: if (curChar == 77)
0716: jjstateSet[jjnewStateCnt++] = 94;
0717: break;
0718: case 96:
0719: if (curChar == 79)
0720: jjstateSet[jjnewStateCnt++] = 95;
0721: break;
0722: case 97:
0723: if (curChar == 71 && kind > 62)
0724: kind = 62;
0725: break;
0726: case 98:
0727: if (curChar == 78)
0728: jjstateSet[jjnewStateCnt++] = 97;
0729: break;
0730: case 99:
0731: if (curChar == 73)
0732: jjstateSet[jjnewStateCnt++] = 98;
0733: break;
0734: case 100:
0735: if (curChar == 82)
0736: jjstateSet[jjnewStateCnt++] = 99;
0737: break;
0738: case 101:
0739: if (curChar == 84)
0740: jjstateSet[jjnewStateCnt++] = 100;
0741: break;
0742: case 102:
0743: if (curChar == 83)
0744: jjstateSet[jjnewStateCnt++] = 101;
0745: break;
0746: case 103:
0747: if (curChar == 66)
0748: jjstateSet[jjnewStateCnt++] = 102;
0749: break;
0750: case 104:
0751: if (curChar == 85)
0752: jjstateSet[jjnewStateCnt++] = 103;
0753: break;
0754: case 105:
0755: if (curChar == 84 && kind > 72)
0756: kind = 72;
0757: break;
0758: case 106:
0759: if (curChar == 82)
0760: jjstateSet[jjnewStateCnt++] = 105;
0761: break;
0762: case 107:
0763: if (curChar == 81)
0764: jjstateSet[jjnewStateCnt++] = 106;
0765: break;
0766: case 108:
0767: if (curChar == 115)
0768: jjAddStates(132, 137);
0769: break;
0770: case 109:
0771: if (curChar == 116 && kind > 23)
0772: kind = 23;
0773: break;
0774: case 110:
0775: if (curChar == 99)
0776: jjstateSet[jjnewStateCnt++] = 109;
0777: break;
0778: case 111:
0779: if (curChar == 101)
0780: jjstateSet[jjnewStateCnt++] = 110;
0781: break;
0782: case 112:
0783: if (curChar == 108)
0784: jjstateSet[jjnewStateCnt++] = 111;
0785: break;
0786: case 113:
0787: if (curChar == 101)
0788: jjstateSet[jjnewStateCnt++] = 112;
0789: break;
0790: case 114:
0791: if (curChar == 116 && kind > 35)
0792: kind = 35;
0793: break;
0794: case 115:
0795: if (curChar == 101)
0796: jjstateSet[jjnewStateCnt++] = 114;
0797: break;
0798: case 116:
0799: if (curChar == 109 && kind > 41)
0800: kind = 41;
0801: break;
0802: case 117:
0803: if (curChar == 117)
0804: jjstateSet[jjnewStateCnt++] = 116;
0805: break;
0806: case 118:
0807: if (curChar == 101 && kind > 60)
0808: kind = 60;
0809: break;
0810: case 119:
0811: if (curChar == 109)
0812: jjstateSet[jjnewStateCnt++] = 118;
0813: break;
0814: case 120:
0815: if (curChar == 111)
0816: jjstateSet[jjnewStateCnt++] = 119;
0817: break;
0818: case 121:
0819: if (curChar == 103 && kind > 62)
0820: kind = 62;
0821: break;
0822: case 122:
0823: if (curChar == 110)
0824: jjstateSet[jjnewStateCnt++] = 121;
0825: break;
0826: case 123:
0827: if (curChar == 105)
0828: jjstateSet[jjnewStateCnt++] = 122;
0829: break;
0830: case 124:
0831: if (curChar == 114)
0832: jjstateSet[jjnewStateCnt++] = 123;
0833: break;
0834: case 125:
0835: if (curChar == 116)
0836: jjstateSet[jjnewStateCnt++] = 124;
0837: break;
0838: case 126:
0839: if (curChar == 115)
0840: jjstateSet[jjnewStateCnt++] = 125;
0841: break;
0842: case 127:
0843: if (curChar == 98)
0844: jjstateSet[jjnewStateCnt++] = 126;
0845: break;
0846: case 128:
0847: if (curChar == 117)
0848: jjstateSet[jjnewStateCnt++] = 127;
0849: break;
0850: case 129:
0851: if (curChar == 116 && kind > 72)
0852: kind = 72;
0853: break;
0854: case 130:
0855: if (curChar == 114)
0856: jjstateSet[jjnewStateCnt++] = 129;
0857: break;
0858: case 131:
0859: if (curChar == 113)
0860: jjstateSet[jjnewStateCnt++] = 130;
0861: break;
0862: case 132:
0863: if (curChar == 70)
0864: jjAddStates(130, 131);
0865: break;
0866: case 133:
0867: if (curChar == 77 && kind > 24)
0868: kind = 24;
0869: break;
0870: case 134:
0871: if (curChar == 79)
0872: jjstateSet[jjnewStateCnt++] = 133;
0873: break;
0874: case 135:
0875: if (curChar == 82)
0876: jjstateSet[jjnewStateCnt++] = 134;
0877: break;
0878: case 136:
0879: if (curChar == 72 && kind > 31)
0880: kind = 31;
0881: break;
0882: case 137:
0883: if (curChar == 67)
0884: jjstateSet[jjnewStateCnt++] = 136;
0885: break;
0886: case 138:
0887: if (curChar == 84)
0888: jjstateSet[jjnewStateCnt++] = 137;
0889: break;
0890: case 139:
0891: if (curChar == 69)
0892: jjstateSet[jjnewStateCnt++] = 138;
0893: break;
0894: case 140:
0895: if (curChar == 102)
0896: jjAddStates(127, 129);
0897: break;
0898: case 141:
0899: if (curChar == 109 && kind > 24)
0900: kind = 24;
0901: break;
0902: case 142:
0903: if (curChar == 111)
0904: jjstateSet[jjnewStateCnt++] = 141;
0905: break;
0906: case 143:
0907: if (curChar == 114)
0908: jjstateSet[jjnewStateCnt++] = 142;
0909: break;
0910: case 144:
0911: if (curChar == 104 && kind > 31)
0912: kind = 31;
0913: break;
0914: case 145:
0915: if (curChar == 99)
0916: jjstateSet[jjnewStateCnt++] = 144;
0917: break;
0918: case 146:
0919: if (curChar == 116)
0920: jjstateSet[jjnewStateCnt++] = 145;
0921: break;
0922: case 147:
0923: if (curChar == 101)
0924: jjstateSet[jjnewStateCnt++] = 146;
0925: break;
0926: case 148:
0927: if (curChar == 101 && kind > 88)
0928: kind = 88;
0929: break;
0930: case 149:
0931: if (curChar == 115)
0932: jjCheckNAdd(148);
0933: break;
0934: case 150:
0935: if (curChar == 108)
0936: jjstateSet[jjnewStateCnt++] = 149;
0937: break;
0938: case 151:
0939: if (curChar == 97)
0940: jjstateSet[jjnewStateCnt++] = 150;
0941: break;
0942: case 152:
0943: if (curChar == 68)
0944: jjAddStates(124, 126);
0945: break;
0946: case 153:
0947: if (curChar == 84 && kind > 25)
0948: kind = 25;
0949: break;
0950: case 154:
0951: if (curChar == 67)
0952: jjstateSet[jjnewStateCnt++] = 153;
0953: break;
0954: case 155:
0955: if (curChar == 78)
0956: jjstateSet[jjnewStateCnt++] = 154;
0957: break;
0958: case 156:
0959: if (curChar == 73)
0960: jjstateSet[jjnewStateCnt++] = 155;
0961: break;
0962: case 157:
0963: if (curChar == 84)
0964: jjstateSet[jjnewStateCnt++] = 156;
0965: break;
0966: case 158:
0967: if (curChar == 83)
0968: jjstateSet[jjnewStateCnt++] = 157;
0969: break;
0970: case 159:
0971: if (curChar == 73)
0972: jjstateSet[jjnewStateCnt++] = 158;
0973: break;
0974: case 160:
0975: if (curChar == 69 && kind > 36)
0976: kind = 36;
0977: break;
0978: case 161:
0979: if (curChar == 84)
0980: jjstateSet[jjnewStateCnt++] = 160;
0981: break;
0982: case 162:
0983: if (curChar == 69)
0984: jjstateSet[jjnewStateCnt++] = 161;
0985: break;
0986: case 163:
0987: if (curChar == 76)
0988: jjstateSet[jjnewStateCnt++] = 162;
0989: break;
0990: case 164:
0991: if (curChar == 69)
0992: jjstateSet[jjnewStateCnt++] = 163;
0993: break;
0994: case 165:
0995: if (curChar == 67 && kind > 80)
0996: kind = 80;
0997: break;
0998: case 166:
0999: if (curChar == 83)
1000: jjstateSet[jjnewStateCnt++] = 165;
1001: break;
1002: case 167:
1003: if (curChar == 69)
1004: jjstateSet[jjnewStateCnt++] = 166;
1005: break;
1006: case 168:
1007: if (curChar == 100)
1008: jjAddStates(121, 123);
1009: break;
1010: case 169:
1011: if (curChar == 116 && kind > 25)
1012: kind = 25;
1013: break;
1014: case 170:
1015: if (curChar == 99)
1016: jjstateSet[jjnewStateCnt++] = 169;
1017: break;
1018: case 171:
1019: if (curChar == 110)
1020: jjstateSet[jjnewStateCnt++] = 170;
1021: break;
1022: case 172:
1023: if (curChar == 105)
1024: jjstateSet[jjnewStateCnt++] = 171;
1025: break;
1026: case 173:
1027: if (curChar == 116)
1028: jjstateSet[jjnewStateCnt++] = 172;
1029: break;
1030: case 174:
1031: if (curChar == 115)
1032: jjstateSet[jjnewStateCnt++] = 173;
1033: break;
1034: case 175:
1035: if (curChar == 105)
1036: jjstateSet[jjnewStateCnt++] = 174;
1037: break;
1038: case 176:
1039: if (curChar == 101 && kind > 36)
1040: kind = 36;
1041: break;
1042: case 177:
1043: if (curChar == 116)
1044: jjstateSet[jjnewStateCnt++] = 176;
1045: break;
1046: case 178:
1047: if (curChar == 101)
1048: jjstateSet[jjnewStateCnt++] = 177;
1049: break;
1050: case 179:
1051: if (curChar == 108)
1052: jjstateSet[jjnewStateCnt++] = 178;
1053: break;
1054: case 180:
1055: if (curChar == 101)
1056: jjstateSet[jjnewStateCnt++] = 179;
1057: break;
1058: case 181:
1059: if (curChar == 99 && kind > 80)
1060: kind = 80;
1061: break;
1062: case 182:
1063: if (curChar == 115)
1064: jjstateSet[jjnewStateCnt++] = 181;
1065: break;
1066: case 183:
1067: if (curChar == 101)
1068: jjstateSet[jjnewStateCnt++] = 182;
1069: break;
1070: case 184:
1071: if (curChar == 79)
1072: jjAddStates(116, 120);
1073: break;
1074: case 185:
1075: if (curChar == 84 && kind > 26)
1076: kind = 26;
1077: break;
1078: case 186:
1079: if (curChar == 67)
1080: jjstateSet[jjnewStateCnt++] = 185;
1081: break;
1082: case 187:
1083: if (curChar == 69)
1084: jjstateSet[jjnewStateCnt++] = 186;
1085: break;
1086: case 188:
1087: if (curChar == 74)
1088: jjstateSet[jjnewStateCnt++] = 187;
1089: break;
1090: case 189:
1091: if (curChar == 66)
1092: jjstateSet[jjnewStateCnt++] = 188;
1093: break;
1094: case 190:
1095: if (curChar == 82 && kind > 28)
1096: kind = 28;
1097: break;
1098: case 191:
1099: if (curChar == 69)
1100: jjstateSet[jjnewStateCnt++] = 190;
1101: break;
1102: case 192:
1103: if (curChar == 84)
1104: jjstateSet[jjnewStateCnt++] = 191;
1105: break;
1106: case 193:
1107: if (curChar == 85)
1108: jjstateSet[jjnewStateCnt++] = 192;
1109: break;
1110: case 194:
1111: if (curChar == 82 && kind > 47)
1112: kind = 47;
1113: break;
1114: case 195:
1115: if (curChar == 70 && kind > 56)
1116: kind = 56;
1117: break;
1118: case 196:
1119: if (curChar == 82 && kind > 78)
1120: kind = 78;
1121: break;
1122: case 197:
1123: if (curChar == 69)
1124: jjstateSet[jjnewStateCnt++] = 196;
1125: break;
1126: case 198:
1127: if (curChar == 68)
1128: jjstateSet[jjnewStateCnt++] = 197;
1129: break;
1130: case 199:
1131: if (curChar == 82)
1132: jjstateSet[jjnewStateCnt++] = 198;
1133: break;
1134: case 200:
1135: if (curChar == 111)
1136: jjAddStates(111, 115);
1137: break;
1138: case 201:
1139: if (curChar == 116 && kind > 26)
1140: kind = 26;
1141: break;
1142: case 202:
1143: if (curChar == 99)
1144: jjstateSet[jjnewStateCnt++] = 201;
1145: break;
1146: case 203:
1147: if (curChar == 101)
1148: jjstateSet[jjnewStateCnt++] = 202;
1149: break;
1150: case 204:
1151: if (curChar == 106)
1152: jjstateSet[jjnewStateCnt++] = 203;
1153: break;
1154: case 205:
1155: if (curChar == 98)
1156: jjstateSet[jjnewStateCnt++] = 204;
1157: break;
1158: case 206:
1159: if (curChar == 114 && kind > 28)
1160: kind = 28;
1161: break;
1162: case 207:
1163: if (curChar == 101)
1164: jjstateSet[jjnewStateCnt++] = 206;
1165: break;
1166: case 208:
1167: if (curChar == 116)
1168: jjstateSet[jjnewStateCnt++] = 207;
1169: break;
1170: case 209:
1171: if (curChar == 117)
1172: jjstateSet[jjnewStateCnt++] = 208;
1173: break;
1174: case 210:
1175: if (curChar == 114 && kind > 47)
1176: kind = 47;
1177: break;
1178: case 211:
1179: if (curChar == 102 && kind > 56)
1180: kind = 56;
1181: break;
1182: case 212:
1183: if (curChar == 114 && kind > 78)
1184: kind = 78;
1185: break;
1186: case 213:
1187: if (curChar == 101)
1188: jjstateSet[jjnewStateCnt++] = 212;
1189: break;
1190: case 214:
1191: if (curChar == 100)
1192: jjstateSet[jjnewStateCnt++] = 213;
1193: break;
1194: case 215:
1195: if (curChar == 114)
1196: jjstateSet[jjnewStateCnt++] = 214;
1197: break;
1198: case 216:
1199: if (curChar == 76)
1200: jjAddStates(105, 110);
1201: break;
1202: case 217:
1203: if (curChar == 84 && kind > 27)
1204: kind = 27;
1205: break;
1206: case 218:
1207: if (curChar == 70)
1208: jjstateSet[jjnewStateCnt++] = 217;
1209: break;
1210: case 219:
1211: if (curChar == 69)
1212: jjstateSet[jjnewStateCnt++] = 218;
1213: break;
1214: case 220:
1215: if (curChar == 69 && kind > 51)
1216: kind = 51;
1217: break;
1218: case 221:
1219: if (curChar == 75)
1220: jjstateSet[jjnewStateCnt++] = 220;
1221: break;
1222: case 222:
1223: if (curChar == 73)
1224: jjstateSet[jjnewStateCnt++] = 221;
1225: break;
1226: case 223:
1227: if (curChar == 82 && kind > 64)
1228: kind = 64;
1229: break;
1230: case 224:
1231: if (curChar == 69)
1232: jjstateSet[jjnewStateCnt++] = 223;
1233: break;
1234: case 225:
1235: if (curChar == 87)
1236: jjstateSet[jjnewStateCnt++] = 224;
1237: break;
1238: case 226:
1239: if (curChar == 79)
1240: jjstateSet[jjnewStateCnt++] = 225;
1241: break;
1242: case 227:
1243: if (curChar == 71 && kind > 66)
1244: kind = 66;
1245: break;
1246: case 228:
1247: if (curChar == 78)
1248: jjstateSet[jjnewStateCnt++] = 227;
1249: break;
1250: case 229:
1251: if (curChar == 73)
1252: jjstateSet[jjnewStateCnt++] = 228;
1253: break;
1254: case 230:
1255: if (curChar == 68)
1256: jjstateSet[jjnewStateCnt++] = 229;
1257: break;
1258: case 231:
1259: if (curChar == 65)
1260: jjstateSet[jjnewStateCnt++] = 230;
1261: break;
1262: case 232:
1263: if (curChar == 69)
1264: jjstateSet[jjnewStateCnt++] = 231;
1265: break;
1266: case 233:
1267: if (curChar == 72 && kind > 69)
1268: kind = 69;
1269: break;
1270: case 234:
1271: if (curChar == 84)
1272: jjstateSet[jjnewStateCnt++] = 233;
1273: break;
1274: case 235:
1275: if (curChar == 71)
1276: jjstateSet[jjnewStateCnt++] = 234;
1277: break;
1278: case 236:
1279: if (curChar == 78)
1280: jjstateSet[jjnewStateCnt++] = 235;
1281: break;
1282: case 237:
1283: if (curChar == 69)
1284: jjstateSet[jjnewStateCnt++] = 236;
1285: break;
1286: case 238:
1287: if (curChar == 69 && kind > 70)
1288: kind = 70;
1289: break;
1290: case 239:
1291: if (curChar == 84)
1292: jjstateSet[jjnewStateCnt++] = 238;
1293: break;
1294: case 240:
1295: if (curChar == 65)
1296: jjstateSet[jjnewStateCnt++] = 239;
1297: break;
1298: case 241:
1299: if (curChar == 67)
1300: jjstateSet[jjnewStateCnt++] = 240;
1301: break;
1302: case 242:
1303: if (curChar == 79)
1304: jjstateSet[jjnewStateCnt++] = 241;
1305: break;
1306: case 243:
1307: if (curChar == 108)
1308: jjAddStates(99, 104);
1309: break;
1310: case 244:
1311: if (curChar == 116 && kind > 27)
1312: kind = 27;
1313: break;
1314: case 245:
1315: if (curChar == 102)
1316: jjstateSet[jjnewStateCnt++] = 244;
1317: break;
1318: case 246:
1319: if (curChar == 101)
1320: jjstateSet[jjnewStateCnt++] = 245;
1321: break;
1322: case 247:
1323: if (curChar == 101 && kind > 51)
1324: kind = 51;
1325: break;
1326: case 248:
1327: if (curChar == 107)
1328: jjstateSet[jjnewStateCnt++] = 247;
1329: break;
1330: case 249:
1331: if (curChar == 105)
1332: jjstateSet[jjnewStateCnt++] = 248;
1333: break;
1334: case 250:
1335: if (curChar == 114 && kind > 64)
1336: kind = 64;
1337: break;
1338: case 251:
1339: if (curChar == 101)
1340: jjstateSet[jjnewStateCnt++] = 250;
1341: break;
1342: case 252:
1343: if (curChar == 119)
1344: jjstateSet[jjnewStateCnt++] = 251;
1345: break;
1346: case 253:
1347: if (curChar == 111)
1348: jjstateSet[jjnewStateCnt++] = 252;
1349: break;
1350: case 254:
1351: if (curChar == 103 && kind > 66)
1352: kind = 66;
1353: break;
1354: case 255:
1355: if (curChar == 110)
1356: jjstateSet[jjnewStateCnt++] = 254;
1357: break;
1358: case 256:
1359: if (curChar == 105)
1360: jjstateSet[jjnewStateCnt++] = 255;
1361: break;
1362: case 257:
1363: if (curChar == 100)
1364: jjstateSet[jjnewStateCnt++] = 256;
1365: break;
1366: case 258:
1367: if (curChar == 97)
1368: jjstateSet[jjnewStateCnt++] = 257;
1369: break;
1370: case 259:
1371: if (curChar == 101)
1372: jjstateSet[jjnewStateCnt++] = 258;
1373: break;
1374: case 260:
1375: if (curChar == 104 && kind > 69)
1376: kind = 69;
1377: break;
1378: case 261:
1379: if (curChar == 116)
1380: jjstateSet[jjnewStateCnt++] = 260;
1381: break;
1382: case 262:
1383: if (curChar == 103)
1384: jjstateSet[jjnewStateCnt++] = 261;
1385: break;
1386: case 263:
1387: if (curChar == 110)
1388: jjstateSet[jjnewStateCnt++] = 262;
1389: break;
1390: case 264:
1391: if (curChar == 101)
1392: jjstateSet[jjnewStateCnt++] = 263;
1393: break;
1394: case 265:
1395: if (curChar == 101 && kind > 70)
1396: kind = 70;
1397: break;
1398: case 266:
1399: if (curChar == 116)
1400: jjstateSet[jjnewStateCnt++] = 265;
1401: break;
1402: case 267:
1403: if (curChar == 97)
1404: jjstateSet[jjnewStateCnt++] = 266;
1405: break;
1406: case 268:
1407: if (curChar == 99)
1408: jjstateSet[jjnewStateCnt++] = 267;
1409: break;
1410: case 269:
1411: if (curChar == 111)
1412: jjstateSet[jjnewStateCnt++] = 268;
1413: break;
1414: case 270:
1415: if (curChar == 73)
1416: jjAddStates(96, 98);
1417: break;
1418: case 271:
1419: if (curChar == 82 && kind > 29)
1420: kind = 29;
1421: break;
1422: case 272:
1423: if (curChar == 69)
1424: jjstateSet[jjnewStateCnt++] = 271;
1425: break;
1426: case 273:
1427: if (curChar == 78)
1428: jjstateSet[jjnewStateCnt++] = 272;
1429: break;
1430: case 274:
1431: if (curChar == 78)
1432: jjstateSet[jjnewStateCnt++] = 273;
1433: break;
1434: case 275:
1435: if (curChar == 78 && kind > 32)
1436: kind = 32;
1437: break;
1438: case 276:
1439: if (curChar == 83 && kind > 53)
1440: kind = 53;
1441: break;
1442: case 277:
1443: if (curChar == 105)
1444: jjAddStates(93, 95);
1445: break;
1446: case 278:
1447: if (curChar == 114 && kind > 29)
1448: kind = 29;
1449: break;
1450: case 279:
1451: if (curChar == 101)
1452: jjstateSet[jjnewStateCnt++] = 278;
1453: break;
1454: case 280:
1455: if (curChar == 110)
1456: jjstateSet[jjnewStateCnt++] = 279;
1457: break;
1458: case 281:
1459: if (curChar == 110)
1460: jjstateSet[jjnewStateCnt++] = 280;
1461: break;
1462: case 282:
1463: if (curChar == 110 && kind > 32)
1464: kind = 32;
1465: break;
1466: case 283:
1467: if (curChar == 115 && kind > 53)
1468: kind = 53;
1469: break;
1470: case 284:
1471: if (curChar == 65)
1472: jjAddStates(86, 92);
1473: break;
1474: case 285:
1475: if (curChar == 83 && kind > 33)
1476: kind = 33;
1477: break;
1478: case 286:
1479: if (curChar == 71 && kind > 38)
1480: kind = 38;
1481: break;
1482: case 287:
1483: if (curChar == 86)
1484: jjstateSet[jjnewStateCnt++] = 286;
1485: break;
1486: case 288:
1487: if (curChar == 68 && kind > 48)
1488: kind = 48;
1489: break;
1490: case 289:
1491: if (curChar == 78)
1492: jjstateSet[jjnewStateCnt++] = 288;
1493: break;
1494: case 290:
1495: if (curChar == 76 && kind > 58)
1496: kind = 58;
1497: break;
1498: case 291:
1499: if (curChar == 76)
1500: jjstateSet[jjnewStateCnt++] = 290;
1501: break;
1502: case 292:
1503: if (curChar == 89 && kind > 59)
1504: kind = 59;
1505: break;
1506: case 293:
1507: if (curChar == 78)
1508: jjstateSet[jjnewStateCnt++] = 292;
1509: break;
1510: case 294:
1511: if (curChar == 83 && kind > 71)
1512: kind = 71;
1513: break;
1514: case 295:
1515: if (curChar == 66)
1516: jjstateSet[jjnewStateCnt++] = 294;
1517: break;
1518: case 296:
1519: if (curChar == 67 && kind > 79)
1520: kind = 79;
1521: break;
1522: case 297:
1523: if (curChar == 83)
1524: jjstateSet[jjnewStateCnt++] = 296;
1525: break;
1526: case 298:
1527: if (curChar == 97)
1528: jjAddStates(79, 85);
1529: break;
1530: case 299:
1531: if (curChar == 115 && kind > 33)
1532: kind = 33;
1533: break;
1534: case 300:
1535: if (curChar == 103 && kind > 38)
1536: kind = 38;
1537: break;
1538: case 301:
1539: if (curChar == 118)
1540: jjstateSet[jjnewStateCnt++] = 300;
1541: break;
1542: case 302:
1543: if (curChar == 100 && kind > 48)
1544: kind = 48;
1545: break;
1546: case 303:
1547: if (curChar == 110)
1548: jjstateSet[jjnewStateCnt++] = 302;
1549: break;
1550: case 304:
1551: if (curChar == 108 && kind > 58)
1552: kind = 58;
1553: break;
1554: case 305:
1555: if (curChar == 108)
1556: jjstateSet[jjnewStateCnt++] = 304;
1557: break;
1558: case 306:
1559: if (curChar == 121 && kind > 59)
1560: kind = 59;
1561: break;
1562: case 307:
1563: if (curChar == 110)
1564: jjstateSet[jjnewStateCnt++] = 306;
1565: break;
1566: case 308:
1567: if (curChar == 115 && kind > 71)
1568: kind = 71;
1569: break;
1570: case 309:
1571: if (curChar == 98)
1572: jjstateSet[jjnewStateCnt++] = 308;
1573: break;
1574: case 310:
1575: if (curChar == 99 && kind > 79)
1576: kind = 79;
1577: break;
1578: case 311:
1579: if (curChar == 115)
1580: jjstateSet[jjnewStateCnt++] = 310;
1581: break;
1582: case 312:
1583: if (curChar == 85)
1584: jjAddStates(77, 78);
1585: break;
1586: case 313:
1587: if (curChar == 69 && kind > 34)
1588: kind = 34;
1589: break;
1590: case 314:
1591: if (curChar == 84)
1592: jjstateSet[jjnewStateCnt++] = 313;
1593: break;
1594: case 315:
1595: if (curChar == 65)
1596: jjstateSet[jjnewStateCnt++] = 314;
1597: break;
1598: case 316:
1599: if (curChar == 68)
1600: jjstateSet[jjnewStateCnt++] = 315;
1601: break;
1602: case 317:
1603: if (curChar == 80)
1604: jjstateSet[jjnewStateCnt++] = 316;
1605: break;
1606: case 318:
1607: if (curChar == 82 && kind > 65)
1608: kind = 65;
1609: break;
1610: case 319:
1611: if (curChar == 69)
1612: jjstateSet[jjnewStateCnt++] = 318;
1613: break;
1614: case 320:
1615: if (curChar == 80)
1616: jjstateSet[jjnewStateCnt++] = 319;
1617: break;
1618: case 321:
1619: if (curChar == 80)
1620: jjstateSet[jjnewStateCnt++] = 320;
1621: break;
1622: case 322:
1623: if (curChar == 117)
1624: jjAddStates(75, 76);
1625: break;
1626: case 323:
1627: if (curChar == 101 && kind > 34)
1628: kind = 34;
1629: break;
1630: case 324:
1631: if (curChar == 116)
1632: jjstateSet[jjnewStateCnt++] = 323;
1633: break;
1634: case 325:
1635: if (curChar == 97)
1636: jjstateSet[jjnewStateCnt++] = 324;
1637: break;
1638: case 326:
1639: if (curChar == 100)
1640: jjstateSet[jjnewStateCnt++] = 325;
1641: break;
1642: case 327:
1643: if (curChar == 112)
1644: jjstateSet[jjnewStateCnt++] = 326;
1645: break;
1646: case 328:
1647: if (curChar == 114 && kind > 65)
1648: kind = 65;
1649: break;
1650: case 329:
1651: if (curChar == 101)
1652: jjstateSet[jjnewStateCnt++] = 328;
1653: break;
1654: case 330:
1655: if (curChar == 112)
1656: jjstateSet[jjnewStateCnt++] = 329;
1657: break;
1658: case 331:
1659: if (curChar == 112)
1660: jjstateSet[jjnewStateCnt++] = 330;
1661: break;
1662: case 332:
1663: if (curChar == 78)
1664: jjAddStates(72, 74);
1665: break;
1666: case 333:
1667: if (curChar == 87 && kind > 37)
1668: kind = 37;
1669: break;
1670: case 334:
1671: if (curChar == 69)
1672: jjstateSet[jjnewStateCnt++] = 333;
1673: break;
1674: case 335:
1675: if (curChar == 84 && kind > 49)
1676: kind = 49;
1677: break;
1678: case 336:
1679: if (curChar == 79)
1680: jjstateSet[jjnewStateCnt++] = 335;
1681: break;
1682: case 337:
1683: if (curChar == 76 && kind > 87)
1684: kind = 87;
1685: break;
1686: case 338:
1687: if (curChar == 76)
1688: jjstateSet[jjnewStateCnt++] = 337;
1689: break;
1690: case 339:
1691: if (curChar == 85)
1692: jjstateSet[jjnewStateCnt++] = 338;
1693: break;
1694: case 340:
1695: if (curChar == 110)
1696: jjAddStates(69, 71);
1697: break;
1698: case 341:
1699: if (curChar == 119 && kind > 37)
1700: kind = 37;
1701: break;
1702: case 342:
1703: if (curChar == 101)
1704: jjstateSet[jjnewStateCnt++] = 341;
1705: break;
1706: case 343:
1707: if (curChar == 116 && kind > 49)
1708: kind = 49;
1709: break;
1710: case 344:
1711: if (curChar == 111)
1712: jjstateSet[jjnewStateCnt++] = 343;
1713: break;
1714: case 345:
1715: if (curChar == 108 && kind > 87)
1716: kind = 87;
1717: break;
1718: case 346:
1719: if (curChar == 108)
1720: jjstateSet[jjnewStateCnt++] = 345;
1721: break;
1722: case 347:
1723: if (curChar == 117)
1724: jjstateSet[jjnewStateCnt++] = 346;
1725: break;
1726: case 348:
1727: if (curChar == 77)
1728: jjAddStates(65, 68);
1729: break;
1730: case 349:
1731: if (curChar == 88 && kind > 39)
1732: kind = 39;
1733: break;
1734: case 350:
1735: if (curChar == 65)
1736: jjstateSet[jjnewStateCnt++] = 349;
1737: break;
1738: case 351:
1739: if (curChar == 78 && kind > 40)
1740: kind = 40;
1741: break;
1742: case 352:
1743: if (curChar == 73)
1744: jjstateSet[jjnewStateCnt++] = 351;
1745: break;
1746: case 353:
1747: if (curChar == 82 && kind > 55)
1748: kind = 55;
1749: break;
1750: case 354:
1751: if (curChar == 69)
1752: jjstateSet[jjnewStateCnt++] = 353;
1753: break;
1754: case 355:
1755: if (curChar == 66)
1756: jjstateSet[jjnewStateCnt++] = 354;
1757: break;
1758: case 356:
1759: if (curChar == 77)
1760: jjstateSet[jjnewStateCnt++] = 355;
1761: break;
1762: case 357:
1763: if (curChar == 69)
1764: jjstateSet[jjnewStateCnt++] = 356;
1765: break;
1766: case 358:
1767: if (curChar == 68 && kind > 73)
1768: kind = 73;
1769: break;
1770: case 359:
1771: if (curChar == 79)
1772: jjstateSet[jjnewStateCnt++] = 358;
1773: break;
1774: case 360:
1775: if (curChar == 109)
1776: jjAddStates(61, 64);
1777: break;
1778: case 361:
1779: if (curChar == 120 && kind > 39)
1780: kind = 39;
1781: break;
1782: case 362:
1783: if (curChar == 97)
1784: jjstateSet[jjnewStateCnt++] = 361;
1785: break;
1786: case 363:
1787: if (curChar == 110 && kind > 40)
1788: kind = 40;
1789: break;
1790: case 364:
1791: if (curChar == 105)
1792: jjstateSet[jjnewStateCnt++] = 363;
1793: break;
1794: case 365:
1795: if (curChar == 114 && kind > 55)
1796: kind = 55;
1797: break;
1798: case 366:
1799: if (curChar == 101)
1800: jjstateSet[jjnewStateCnt++] = 365;
1801: break;
1802: case 367:
1803: if (curChar == 98)
1804: jjstateSet[jjnewStateCnt++] = 366;
1805: break;
1806: case 368:
1807: if (curChar == 109)
1808: jjstateSet[jjnewStateCnt++] = 367;
1809: break;
1810: case 369:
1811: if (curChar == 101)
1812: jjstateSet[jjnewStateCnt++] = 368;
1813: break;
1814: case 370:
1815: if (curChar == 100 && kind > 73)
1816: kind = 73;
1817: break;
1818: case 371:
1819: if (curChar == 111)
1820: jjstateSet[jjnewStateCnt++] = 370;
1821: break;
1822: case 372:
1823: if (curChar == 67)
1824: jjAddStates(56, 60);
1825: break;
1826: case 373:
1827: if (curChar == 84 && kind > 42)
1828: kind = 42;
1829: break;
1830: case 374:
1831: if (curChar == 78)
1832: jjstateSet[jjnewStateCnt++] = 373;
1833: break;
1834: case 375:
1835: if (curChar == 85)
1836: jjstateSet[jjnewStateCnt++] = 374;
1837: break;
1838: case 376:
1839: if (curChar == 79)
1840: jjstateSet[jjnewStateCnt++] = 375;
1841: break;
1842: case 377:
1843: if (curChar == 84 && kind > 61)
1844: kind = 61;
1845: break;
1846: case 378:
1847: if (curChar == 65)
1848: jjstateSet[jjnewStateCnt++] = 377;
1849: break;
1850: case 379:
1851: if (curChar == 67)
1852: jjstateSet[jjnewStateCnt++] = 378;
1853: break;
1854: case 380:
1855: if (curChar == 78)
1856: jjstateSet[jjnewStateCnt++] = 379;
1857: break;
1858: case 381:
1859: if (curChar == 79)
1860: jjstateSet[jjnewStateCnt++] = 380;
1861: break;
1862: case 382:
1863: if (curChar == 69 && kind > 75)
1864: kind = 75;
1865: break;
1866: case 383:
1867: if (curChar == 84)
1868: jjstateSet[jjnewStateCnt++] = 382;
1869: break;
1870: case 384:
1871: if (curChar == 65)
1872: jjstateSet[jjnewStateCnt++] = 383;
1873: break;
1874: case 385:
1875: if (curChar == 68)
1876: jjstateSet[jjnewStateCnt++] = 384;
1877: break;
1878: case 386:
1879: if (curChar == 95)
1880: jjstateSet[jjnewStateCnt++] = 385;
1881: break;
1882: case 387:
1883: if (curChar == 84)
1884: jjstateSet[jjnewStateCnt++] = 386;
1885: break;
1886: case 388:
1887: if (curChar == 78)
1888: jjstateSet[jjnewStateCnt++] = 387;
1889: break;
1890: case 389:
1891: if (curChar == 69)
1892: jjstateSet[jjnewStateCnt++] = 388;
1893: break;
1894: case 390:
1895: if (curChar == 82)
1896: jjstateSet[jjnewStateCnt++] = 389;
1897: break;
1898: case 391:
1899: if (curChar == 82)
1900: jjstateSet[jjnewStateCnt++] = 390;
1901: break;
1902: case 392:
1903: if (curChar == 85)
1904: jjstateSet[jjnewStateCnt++] = 391;
1905: break;
1906: case 393:
1907: if (curChar == 69 && kind > 76)
1908: kind = 76;
1909: break;
1910: case 394:
1911: if (curChar == 77)
1912: jjstateSet[jjnewStateCnt++] = 393;
1913: break;
1914: case 395:
1915: if (curChar == 73)
1916: jjstateSet[jjnewStateCnt++] = 394;
1917: break;
1918: case 396:
1919: if (curChar == 84)
1920: jjstateSet[jjnewStateCnt++] = 395;
1921: break;
1922: case 397:
1923: if (curChar == 95)
1924: jjstateSet[jjnewStateCnt++] = 396;
1925: break;
1926: case 398:
1927: if (curChar == 84)
1928: jjstateSet[jjnewStateCnt++] = 397;
1929: break;
1930: case 399:
1931: if (curChar == 78)
1932: jjstateSet[jjnewStateCnt++] = 398;
1933: break;
1934: case 400:
1935: if (curChar == 69)
1936: jjstateSet[jjnewStateCnt++] = 399;
1937: break;
1938: case 401:
1939: if (curChar == 82)
1940: jjstateSet[jjnewStateCnt++] = 400;
1941: break;
1942: case 402:
1943: if (curChar == 82)
1944: jjstateSet[jjnewStateCnt++] = 401;
1945: break;
1946: case 403:
1947: if (curChar == 85)
1948: jjstateSet[jjnewStateCnt++] = 402;
1949: break;
1950: case 404:
1951: if (curChar == 80 && kind > 77)
1952: kind = 77;
1953: break;
1954: case 405:
1955: if (curChar == 77)
1956: jjstateSet[jjnewStateCnt++] = 404;
1957: break;
1958: case 406:
1959: if (curChar == 65)
1960: jjstateSet[jjnewStateCnt++] = 405;
1961: break;
1962: case 407:
1963: if (curChar == 84)
1964: jjstateSet[jjnewStateCnt++] = 406;
1965: break;
1966: case 408:
1967: if (curChar == 83)
1968: jjstateSet[jjnewStateCnt++] = 407;
1969: break;
1970: case 409:
1971: if (curChar == 69)
1972: jjstateSet[jjnewStateCnt++] = 408;
1973: break;
1974: case 410:
1975: if (curChar == 77)
1976: jjstateSet[jjnewStateCnt++] = 409;
1977: break;
1978: case 411:
1979: if (curChar == 73)
1980: jjstateSet[jjnewStateCnt++] = 410;
1981: break;
1982: case 412:
1983: if (curChar == 84)
1984: jjstateSet[jjnewStateCnt++] = 411;
1985: break;
1986: case 413:
1987: if (curChar == 95)
1988: jjstateSet[jjnewStateCnt++] = 412;
1989: break;
1990: case 414:
1991: if (curChar == 84)
1992: jjstateSet[jjnewStateCnt++] = 413;
1993: break;
1994: case 415:
1995: if (curChar == 78)
1996: jjstateSet[jjnewStateCnt++] = 414;
1997: break;
1998: case 416:
1999: if (curChar == 69)
2000: jjstateSet[jjnewStateCnt++] = 415;
2001: break;
2002: case 417:
2003: if (curChar == 82)
2004: jjstateSet[jjnewStateCnt++] = 416;
2005: break;
2006: case 418:
2007: if (curChar == 82)
2008: jjstateSet[jjnewStateCnt++] = 417;
2009: break;
2010: case 419:
2011: if (curChar == 85)
2012: jjstateSet[jjnewStateCnt++] = 418;
2013: break;
2014: case 420:
2015: if (curChar == 99)
2016: jjAddStates(51, 55);
2017: break;
2018: case 421:
2019: if (curChar == 116 && kind > 42)
2020: kind = 42;
2021: break;
2022: case 422:
2023: if (curChar == 110)
2024: jjstateSet[jjnewStateCnt++] = 421;
2025: break;
2026: case 423:
2027: if (curChar == 117)
2028: jjstateSet[jjnewStateCnt++] = 422;
2029: break;
2030: case 424:
2031: if (curChar == 111)
2032: jjstateSet[jjnewStateCnt++] = 423;
2033: break;
2034: case 425:
2035: if (curChar == 116 && kind > 61)
2036: kind = 61;
2037: break;
2038: case 426:
2039: if (curChar == 97)
2040: jjstateSet[jjnewStateCnt++] = 425;
2041: break;
2042: case 427:
2043: if (curChar == 99)
2044: jjstateSet[jjnewStateCnt++] = 426;
2045: break;
2046: case 428:
2047: if (curChar == 110)
2048: jjstateSet[jjnewStateCnt++] = 427;
2049: break;
2050: case 429:
2051: if (curChar == 111)
2052: jjstateSet[jjnewStateCnt++] = 428;
2053: break;
2054: case 430:
2055: if (curChar == 101 && kind > 75)
2056: kind = 75;
2057: break;
2058: case 431:
2059: if (curChar == 116)
2060: jjstateSet[jjnewStateCnt++] = 430;
2061: break;
2062: case 432:
2063: if (curChar == 97)
2064: jjstateSet[jjnewStateCnt++] = 431;
2065: break;
2066: case 433:
2067: if (curChar == 100)
2068: jjstateSet[jjnewStateCnt++] = 432;
2069: break;
2070: case 434:
2071: if (curChar == 95)
2072: jjstateSet[jjnewStateCnt++] = 433;
2073: break;
2074: case 435:
2075: if (curChar == 116)
2076: jjstateSet[jjnewStateCnt++] = 434;
2077: break;
2078: case 436:
2079: if (curChar == 110)
2080: jjstateSet[jjnewStateCnt++] = 435;
2081: break;
2082: case 437:
2083: if (curChar == 101)
2084: jjstateSet[jjnewStateCnt++] = 436;
2085: break;
2086: case 438:
2087: if (curChar == 114)
2088: jjstateSet[jjnewStateCnt++] = 437;
2089: break;
2090: case 439:
2091: if (curChar == 114)
2092: jjstateSet[jjnewStateCnt++] = 438;
2093: break;
2094: case 440:
2095: if (curChar == 117)
2096: jjstateSet[jjnewStateCnt++] = 439;
2097: break;
2098: case 441:
2099: if (curChar == 101 && kind > 76)
2100: kind = 76;
2101: break;
2102: case 442:
2103: if (curChar == 109)
2104: jjstateSet[jjnewStateCnt++] = 441;
2105: break;
2106: case 443:
2107: if (curChar == 105)
2108: jjstateSet[jjnewStateCnt++] = 442;
2109: break;
2110: case 444:
2111: if (curChar == 116)
2112: jjstateSet[jjnewStateCnt++] = 443;
2113: break;
2114: case 445:
2115: if (curChar == 95)
2116: jjstateSet[jjnewStateCnt++] = 444;
2117: break;
2118: case 446:
2119: if (curChar == 116)
2120: jjstateSet[jjnewStateCnt++] = 445;
2121: break;
2122: case 447:
2123: if (curChar == 110)
2124: jjstateSet[jjnewStateCnt++] = 446;
2125: break;
2126: case 448:
2127: if (curChar == 101)
2128: jjstateSet[jjnewStateCnt++] = 447;
2129: break;
2130: case 449:
2131: if (curChar == 114)
2132: jjstateSet[jjnewStateCnt++] = 448;
2133: break;
2134: case 450:
2135: if (curChar == 114)
2136: jjstateSet[jjnewStateCnt++] = 449;
2137: break;
2138: case 451:
2139: if (curChar == 117)
2140: jjstateSet[jjnewStateCnt++] = 450;
2141: break;
2142: case 452:
2143: if (curChar == 112 && kind > 77)
2144: kind = 77;
2145: break;
2146: case 453:
2147: if (curChar == 109)
2148: jjstateSet[jjnewStateCnt++] = 452;
2149: break;
2150: case 454:
2151: if (curChar == 97)
2152: jjstateSet[jjnewStateCnt++] = 453;
2153: break;
2154: case 455:
2155: if (curChar == 116)
2156: jjstateSet[jjnewStateCnt++] = 454;
2157: break;
2158: case 456:
2159: if (curChar == 115)
2160: jjstateSet[jjnewStateCnt++] = 455;
2161: break;
2162: case 457:
2163: if (curChar == 101)
2164: jjstateSet[jjnewStateCnt++] = 456;
2165: break;
2166: case 458:
2167: if (curChar == 109)
2168: jjstateSet[jjnewStateCnt++] = 457;
2169: break;
2170: case 459:
2171: if (curChar == 105)
2172: jjstateSet[jjnewStateCnt++] = 458;
2173: break;
2174: case 460:
2175: if (curChar == 116)
2176: jjstateSet[jjnewStateCnt++] = 459;
2177: break;
2178: case 461:
2179: if (curChar == 95)
2180: jjstateSet[jjnewStateCnt++] = 460;
2181: break;
2182: case 462:
2183: if (curChar == 116)
2184: jjstateSet[jjnewStateCnt++] = 461;
2185: break;
2186: case 463:
2187: if (curChar == 110)
2188: jjstateSet[jjnewStateCnt++] = 462;
2189: break;
2190: case 464:
2191: if (curChar == 101)
2192: jjstateSet[jjnewStateCnt++] = 463;
2193: break;
2194: case 465:
2195: if (curChar == 114)
2196: jjstateSet[jjnewStateCnt++] = 464;
2197: break;
2198: case 466:
2199: if (curChar == 114)
2200: jjstateSet[jjnewStateCnt++] = 465;
2201: break;
2202: case 467:
2203: if (curChar == 117)
2204: jjstateSet[jjnewStateCnt++] = 466;
2205: break;
2206: case 468:
2207: if (curChar == 66)
2208: jjAddStates(47, 50);
2209: break;
2210: case 469:
2211: if (curChar == 89 && kind > 45)
2212: kind = 45;
2213: break;
2214: case 470:
2215: if (curChar == 78 && kind > 50)
2216: kind = 50;
2217: break;
2218: case 471:
2219: if (curChar == 69)
2220: jjstateSet[jjnewStateCnt++] = 470;
2221: break;
2222: case 472:
2223: if (curChar == 69)
2224: jjstateSet[jjnewStateCnt++] = 471;
2225: break;
2226: case 473:
2227: if (curChar == 87)
2228: jjstateSet[jjnewStateCnt++] = 472;
2229: break;
2230: case 474:
2231: if (curChar == 84)
2232: jjstateSet[jjnewStateCnt++] = 473;
2233: break;
2234: case 475:
2235: if (curChar == 69)
2236: jjstateSet[jjnewStateCnt++] = 474;
2237: break;
2238: case 476:
2239: if (curChar == 72 && kind > 68)
2240: kind = 68;
2241: break;
2242: case 477:
2243: if (curChar == 84)
2244: jjstateSet[jjnewStateCnt++] = 476;
2245: break;
2246: case 478:
2247: if (curChar == 79)
2248: jjstateSet[jjnewStateCnt++] = 477;
2249: break;
2250: case 479:
2251: if (curChar == 72 && kind > 74)
2252: kind = 74;
2253: break;
2254: case 480:
2255: if (curChar == 84)
2256: jjstateSet[jjnewStateCnt++] = 479;
2257: break;
2258: case 481:
2259: if (curChar == 71)
2260: jjstateSet[jjnewStateCnt++] = 480;
2261: break;
2262: case 482:
2263: if (curChar == 78)
2264: jjstateSet[jjnewStateCnt++] = 481;
2265: break;
2266: case 483:
2267: if (curChar == 69)
2268: jjstateSet[jjnewStateCnt++] = 482;
2269: break;
2270: case 484:
2271: if (curChar == 76)
2272: jjstateSet[jjnewStateCnt++] = 483;
2273: break;
2274: case 485:
2275: if (curChar == 95)
2276: jjstateSet[jjnewStateCnt++] = 484;
2277: break;
2278: case 486:
2279: if (curChar == 84)
2280: jjstateSet[jjnewStateCnt++] = 485;
2281: break;
2282: case 487:
2283: if (curChar == 73)
2284: jjstateSet[jjnewStateCnt++] = 486;
2285: break;
2286: case 488:
2287: if (curChar == 98)
2288: jjAddStates(43, 46);
2289: break;
2290: case 489:
2291: if (curChar == 121 && kind > 45)
2292: kind = 45;
2293: break;
2294: case 490:
2295: if (curChar == 110 && kind > 50)
2296: kind = 50;
2297: break;
2298: case 491:
2299: if (curChar == 101)
2300: jjstateSet[jjnewStateCnt++] = 490;
2301: break;
2302: case 492:
2303: if (curChar == 101)
2304: jjstateSet[jjnewStateCnt++] = 491;
2305: break;
2306: case 493:
2307: if (curChar == 119)
2308: jjstateSet[jjnewStateCnt++] = 492;
2309: break;
2310: case 494:
2311: if (curChar == 116)
2312: jjstateSet[jjnewStateCnt++] = 493;
2313: break;
2314: case 495:
2315: if (curChar == 101)
2316: jjstateSet[jjnewStateCnt++] = 494;
2317: break;
2318: case 496:
2319: if (curChar == 104 && kind > 68)
2320: kind = 68;
2321: break;
2322: case 497:
2323: if (curChar == 116)
2324: jjstateSet[jjnewStateCnt++] = 496;
2325: break;
2326: case 498:
2327: if (curChar == 111)
2328: jjstateSet[jjnewStateCnt++] = 497;
2329: break;
2330: case 499:
2331: if (curChar == 104 && kind > 74)
2332: kind = 74;
2333: break;
2334: case 500:
2335: if (curChar == 116)
2336: jjstateSet[jjnewStateCnt++] = 499;
2337: break;
2338: case 501:
2339: if (curChar == 103)
2340: jjstateSet[jjnewStateCnt++] = 500;
2341: break;
2342: case 502:
2343: if (curChar == 110)
2344: jjstateSet[jjnewStateCnt++] = 501;
2345: break;
2346: case 503:
2347: if (curChar == 101)
2348: jjstateSet[jjnewStateCnt++] = 502;
2349: break;
2350: case 504:
2351: if (curChar == 108)
2352: jjstateSet[jjnewStateCnt++] = 503;
2353: break;
2354: case 505:
2355: if (curChar == 95)
2356: jjstateSet[jjnewStateCnt++] = 504;
2357: break;
2358: case 506:
2359: if (curChar == 116)
2360: jjstateSet[jjnewStateCnt++] = 505;
2361: break;
2362: case 507:
2363: if (curChar == 105)
2364: jjstateSet[jjnewStateCnt++] = 506;
2365: break;
2366: case 508:
2367: if (curChar == 69)
2368: jjAddStates(40, 42);
2369: break;
2370: case 509:
2371: if (curChar == 69 && kind > 52)
2372: kind = 52;
2373: break;
2374: case 510:
2375: if (curChar == 80)
2376: jjstateSet[jjnewStateCnt++] = 509;
2377: break;
2378: case 511:
2379: if (curChar == 65)
2380: jjstateSet[jjnewStateCnt++] = 510;
2381: break;
2382: case 512:
2383: if (curChar == 67)
2384: jjstateSet[jjnewStateCnt++] = 511;
2385: break;
2386: case 513:
2387: if (curChar == 83)
2388: jjstateSet[jjnewStateCnt++] = 512;
2389: break;
2390: case 514:
2391: if (curChar == 89 && kind > 54)
2392: kind = 54;
2393: break;
2394: case 515:
2395: if (curChar == 84)
2396: jjstateSet[jjnewStateCnt++] = 514;
2397: break;
2398: case 516:
2399: if (curChar == 80)
2400: jjstateSet[jjnewStateCnt++] = 515;
2401: break;
2402: case 517:
2403: if (curChar == 77)
2404: jjstateSet[jjnewStateCnt++] = 516;
2405: break;
2406: case 518:
2407: if (curChar == 83 && kind > 57)
2408: kind = 57;
2409: break;
2410: case 519:
2411: if (curChar == 84)
2412: jjstateSet[jjnewStateCnt++] = 518;
2413: break;
2414: case 520:
2415: if (curChar == 83)
2416: jjstateSet[jjnewStateCnt++] = 519;
2417: break;
2418: case 521:
2419: if (curChar == 73)
2420: jjstateSet[jjnewStateCnt++] = 520;
2421: break;
2422: case 522:
2423: if (curChar == 88)
2424: jjstateSet[jjnewStateCnt++] = 521;
2425: break;
2426: case 523:
2427: if (curChar == 101)
2428: jjAddStates(37, 39);
2429: break;
2430: case 524:
2431: if (curChar == 101 && kind > 52)
2432: kind = 52;
2433: break;
2434: case 525:
2435: if (curChar == 112)
2436: jjstateSet[jjnewStateCnt++] = 524;
2437: break;
2438: case 526:
2439: if (curChar == 97)
2440: jjstateSet[jjnewStateCnt++] = 525;
2441: break;
2442: case 527:
2443: if (curChar == 99)
2444: jjstateSet[jjnewStateCnt++] = 526;
2445: break;
2446: case 528:
2447: if (curChar == 115)
2448: jjstateSet[jjnewStateCnt++] = 527;
2449: break;
2450: case 529:
2451: if (curChar == 121 && kind > 54)
2452: kind = 54;
2453: break;
2454: case 530:
2455: if (curChar == 116)
2456: jjstateSet[jjnewStateCnt++] = 529;
2457: break;
2458: case 531:
2459: if (curChar == 112)
2460: jjstateSet[jjnewStateCnt++] = 530;
2461: break;
2462: case 532:
2463: if (curChar == 109)
2464: jjstateSet[jjnewStateCnt++] = 531;
2465: break;
2466: case 533:
2467: if (curChar == 115 && kind > 57)
2468: kind = 57;
2469: break;
2470: case 534:
2471: if (curChar == 116)
2472: jjstateSet[jjnewStateCnt++] = 533;
2473: break;
2474: case 535:
2475: if (curChar == 115)
2476: jjstateSet[jjnewStateCnt++] = 534;
2477: break;
2478: case 536:
2479: if (curChar == 105)
2480: jjstateSet[jjnewStateCnt++] = 535;
2481: break;
2482: case 537:
2483: if (curChar == 120)
2484: jjstateSet[jjnewStateCnt++] = 536;
2485: break;
2486: case 538:
2487: if (curChar == 84)
2488: jjAddStates(35, 36);
2489: break;
2490: case 539:
2491: if (curChar == 77 && kind > 63)
2492: kind = 63;
2493: break;
2494: case 540:
2495: if (curChar == 73)
2496: jjstateSet[jjnewStateCnt++] = 539;
2497: break;
2498: case 541:
2499: if (curChar == 82)
2500: jjstateSet[jjnewStateCnt++] = 540;
2501: break;
2502: case 542:
2503: if (curChar == 71 && kind > 67)
2504: kind = 67;
2505: break;
2506: case 543:
2507: if (curChar == 78)
2508: jjstateSet[jjnewStateCnt++] = 542;
2509: break;
2510: case 544:
2511: if (curChar == 73)
2512: jjstateSet[jjnewStateCnt++] = 543;
2513: break;
2514: case 545:
2515: if (curChar == 76)
2516: jjstateSet[jjnewStateCnt++] = 544;
2517: break;
2518: case 546:
2519: if (curChar == 73)
2520: jjstateSet[jjnewStateCnt++] = 545;
2521: break;
2522: case 547:
2523: if (curChar == 65)
2524: jjstateSet[jjnewStateCnt++] = 546;
2525: break;
2526: case 548:
2527: if (curChar == 82)
2528: jjstateSet[jjnewStateCnt++] = 547;
2529: break;
2530: case 549:
2531: if (curChar == 116)
2532: jjAddStates(32, 34);
2533: break;
2534: case 550:
2535: if (curChar == 109 && kind > 63)
2536: kind = 63;
2537: break;
2538: case 551:
2539: if (curChar == 105)
2540: jjstateSet[jjnewStateCnt++] = 550;
2541: break;
2542: case 552:
2543: if (curChar == 114)
2544: jjstateSet[jjnewStateCnt++] = 551;
2545: break;
2546: case 553:
2547: if (curChar == 103 && kind > 67)
2548: kind = 67;
2549: break;
2550: case 554:
2551: if (curChar == 110)
2552: jjstateSet[jjnewStateCnt++] = 553;
2553: break;
2554: case 555:
2555: if (curChar == 105)
2556: jjstateSet[jjnewStateCnt++] = 554;
2557: break;
2558: case 556:
2559: if (curChar == 108)
2560: jjstateSet[jjnewStateCnt++] = 555;
2561: break;
2562: case 557:
2563: if (curChar == 105)
2564: jjstateSet[jjnewStateCnt++] = 556;
2565: break;
2566: case 558:
2567: if (curChar == 97)
2568: jjstateSet[jjnewStateCnt++] = 557;
2569: break;
2570: case 559:
2571: if (curChar == 114)
2572: jjstateSet[jjnewStateCnt++] = 558;
2573: break;
2574: case 560:
2575: if (curChar == 117)
2576: jjCheckNAdd(148);
2577: break;
2578: case 561:
2579: if (curChar == 114)
2580: jjstateSet[jjnewStateCnt++] = 560;
2581: break;
2582: case 563:
2583: if ((0x100000001000000L & l) != 0L)
2584: jjCheckNAdd(564);
2585: break;
2586: case 564:
2587: if ((0x7e0000007eL & l) == 0L)
2588: break;
2589: if (kind > 82)
2590: kind = 82;
2591: jjCheckNAddTwoStates(564, 565);
2592: break;
2593: case 565:
2594: if ((0x100000001000L & l) != 0L && kind > 82)
2595: kind = 82;
2596: break;
2597: default:
2598: break;
2599: }
2600: } while (i != startsAt);
2601: } else {
2602: int hiByte = (int) (curChar >> 8);
2603: int i1 = hiByte >> 6;
2604: long l1 = 1L << (hiByte & 077);
2605: int i2 = (curChar & 0xff) >> 6;
2606: long l2 = 1L << (curChar & 077);
2607: MatchLoop: do {
2608: switch (jjstateSet[--i]) {
2609: case 50:
2610: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2611: jjAddStates(10, 12);
2612: break;
2613: case 59:
2614: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2615: jjAddStates(7, 9);
2616: break;
2617: default:
2618: break;
2619: }
2620: } while (i != startsAt);
2621: }
2622: if (kind != 0x7fffffff) {
2623: jjmatchedKind = kind;
2624: jjmatchedPos = curPos;
2625: kind = 0x7fffffff;
2626: }
2627: ++curPos;
2628: if ((i = jjnewStateCnt) == (startsAt = 567 - (jjnewStateCnt = startsAt)))
2629: return curPos;
2630: try {
2631: curChar = input_stream.readChar();
2632: } catch (java.io.IOException e) {
2633: return curPos;
2634: }
2635: }
2636: }
2637:
2638: static final int[] jjnextStates = { 70, 71, 76, 77, 80, 81, 48, 59,
2639: 60, 62, 50, 51, 53, 44, 45, 48, 50, 51, 55, 53, 59, 60, 64,
2640: 62, 72, 73, 48, 80, 81, 48, 564, 565, 552, 559, 561, 541,
2641: 548, 528, 532, 537, 513, 517, 522, 489, 495, 498, 507, 469,
2642: 475, 478, 487, 424, 429, 440, 451, 467, 376, 381, 392, 403,
2643: 419, 362, 364, 369, 371, 350, 352, 357, 359, 342, 344, 347,
2644: 334, 336, 339, 327, 331, 317, 321, 299, 301, 303, 305, 307,
2645: 309, 311, 285, 287, 289, 291, 293, 295, 297, 281, 282, 283,
2646: 274, 275, 276, 246, 249, 253, 259, 264, 269, 219, 222, 226,
2647: 232, 237, 242, 205, 209, 210, 211, 215, 189, 193, 194, 195,
2648: 199, 175, 180, 183, 159, 164, 167, 143, 147, 151, 135, 139,
2649: 113, 115, 117, 120, 128, 131, 89, 91, 93, 96, 104, 107, 46,
2650: 47, 52, 54, 56, 61, 63, 65, 74, 75, 78, 79, 82, 83, };
2651:
2652: private static final boolean jjCanMove_0(int hiByte, int i1,
2653: int i2, long l1, long l2) {
2654: switch (hiByte) {
2655: case 0:
2656: return ((jjbitVec2[i2] & l2) != 0L);
2657: default:
2658: if ((jjbitVec0[i1] & l1) != 0L)
2659: return true;
2660: return false;
2661: }
2662: }
2663:
2664: public static final String[] jjstrLiteralImages = { "", null, null,
2665: null, null, null, "\50", "\51", "\173", "\175", "\133",
2666: "\135", "\73", "\54", "\56", "\77", "\72", "\75", "\74",
2667: "\74\75", "\76", "\76\75", "\74\76", null, null, null,
2668: null, null, null, null, null, null, null, null, null, null,
2669: null, null, null, null, null, null, null, null, null, null,
2670: null, null, null, null, null, null, null, null, null, null,
2671: null, null, null, null, null, null, null, null, null, null,
2672: null, null, null, null, null, null, null, null, null, null,
2673: null, null, null, null, null, null, null, null, null, null,
2674: null, null, null, null, null, null, null, "\53", "\55",
2675: "\52", "\57", };
2676: public static final String[] lexStateNames = { "DEFAULT", };
2677: static final long[] jjtoToken = { 0xffffffffffffffc1L,
2678: 0x1e7dfffffL, };
2679: static final long[] jjtoSkip = { 0x3eL, 0x0L, };
2680: protected JavaCharStream input_stream;
2681: private final int[] jjrounds = new int[567];
2682: private final int[] jjstateSet = new int[1134];
2683: protected char curChar;
2684:
2685: public EJBQLParserTokenManager(JavaCharStream stream) {
2686: if (JavaCharStream.staticFlag)
2687: throw new Error(
2688: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
2689: input_stream = stream;
2690: }
2691:
2692: public EJBQLParserTokenManager(JavaCharStream stream, int lexState) {
2693: this (stream);
2694: SwitchTo(lexState);
2695: }
2696:
2697: public void ReInit(JavaCharStream stream) {
2698: jjmatchedPos = jjnewStateCnt = 0;
2699: curLexState = defaultLexState;
2700: input_stream = stream;
2701: ReInitRounds();
2702: }
2703:
2704: private final void ReInitRounds() {
2705: int i;
2706: jjround = 0x80000001;
2707: for (i = 567; i-- > 0;)
2708: jjrounds[i] = 0x80000000;
2709: }
2710:
2711: public void ReInit(JavaCharStream stream, int lexState) {
2712: ReInit(stream);
2713: SwitchTo(lexState);
2714: }
2715:
2716: public void SwitchTo(int lexState) {
2717: if (lexState >= 1 || lexState < 0)
2718: throw new TokenMgrError(
2719: "Error: Ignoring invalid lexical state : "
2720: + lexState + ". State unchanged.",
2721: TokenMgrError.INVALID_LEXICAL_STATE);
2722: else
2723: curLexState = lexState;
2724: }
2725:
2726: protected Token jjFillToken() {
2727: Token t = Token.newToken(jjmatchedKind);
2728: t.kind = jjmatchedKind;
2729: String im = jjstrLiteralImages[jjmatchedKind];
2730: t.image = (im == null) ? input_stream.GetImage() : im;
2731: t.beginLine = input_stream.getBeginLine();
2732: t.beginColumn = input_stream.getBeginColumn();
2733: t.endLine = input_stream.getEndLine();
2734: t.endColumn = input_stream.getEndColumn();
2735: return t;
2736: }
2737:
2738: int curLexState = 0;
2739: int defaultLexState = 0;
2740: int jjnewStateCnt;
2741: int jjround;
2742: int jjmatchedPos;
2743: int jjmatchedKind;
2744:
2745: public Token getNextToken() {
2746: int kind;
2747: Token specialToken = null;
2748: Token matchedToken;
2749: int curPos = 0;
2750:
2751: EOFLoop: for (;;) {
2752: try {
2753: curChar = input_stream.BeginToken();
2754: } catch (java.io.IOException e) {
2755: jjmatchedKind = 0;
2756: matchedToken = jjFillToken();
2757: return matchedToken;
2758: }
2759:
2760: try {
2761: input_stream.backup(0);
2762: while (curChar <= 32
2763: && (0x100003600L & (1L << curChar)) != 0L)
2764: curChar = input_stream.BeginToken();
2765: } catch (java.io.IOException e1) {
2766: continue EOFLoop;
2767: }
2768: jjmatchedKind = 0x7fffffff;
2769: jjmatchedPos = 0;
2770: curPos = jjMoveStringLiteralDfa0_0();
2771: if (jjmatchedKind != 0x7fffffff) {
2772: if (jjmatchedPos + 1 < curPos)
2773: input_stream.backup(curPos - jjmatchedPos - 1);
2774: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
2775: matchedToken = jjFillToken();
2776: return matchedToken;
2777: } else {
2778: continue EOFLoop;
2779: }
2780: }
2781: int error_line = input_stream.getEndLine();
2782: int error_column = input_stream.getEndColumn();
2783: String error_after = null;
2784: boolean EOFSeen = false;
2785: try {
2786: input_stream.readChar();
2787: input_stream.backup(1);
2788: } catch (java.io.IOException e1) {
2789: EOFSeen = true;
2790: error_after = curPos <= 1 ? "" : input_stream
2791: .GetImage();
2792: if (curChar == '\n' || curChar == '\r') {
2793: error_line++;
2794: error_column = 0;
2795: } else
2796: error_column++;
2797: }
2798: if (!EOFSeen) {
2799: input_stream.backup(1);
2800: error_after = curPos <= 1 ? "" : input_stream
2801: .GetImage();
2802: }
2803: throw new TokenMgrError(EOFSeen, curLexState, error_line,
2804: error_column, error_after, curChar,
2805: TokenMgrError.LEXICAL_ERROR);
2806: }
2807: }
2808:
2809: }
|