0001: /* Generated By:JJTree&JavaCC: Do not edit this line. CSSParserTokenManager.java */
0002: package org.netbeans.modules.css.parser;
0003:
0004: import java.util.*;
0005:
0006: /** Token Manager. */
0007: public class CSSParserTokenManager implements CSSParserConstants {
0008:
0009: /** Debug output. */
0010: public java.io.PrintStream debugStream = System.out;
0011:
0012: /** Set debug output. */
0013: public void setDebugStream(java.io.PrintStream ds) {
0014: debugStream = ds;
0015: }
0016:
0017: private final int jjStopStringLiteralDfa_0(int pos, long active0) {
0018: switch (pos) {
0019: case 0:
0020: if ((active0 & 0x40000800000000L) != 0L) {
0021: jjmatchedKind = 56;
0022: return 433;
0023: }
0024: if ((active0 & 0x1f0000000L) != 0L)
0025: return 61;
0026: if ((active0 & 0x100L) != 0L)
0027: return 434;
0028: if ((active0 & 0x2004000L) != 0L)
0029: return 312;
0030: return -1;
0031: case 1:
0032: if ((active0 & 0x40000800000000L) != 0L) {
0033: jjmatchedKind = 56;
0034: jjmatchedPos = 1;
0035: return 433;
0036: }
0037: if ((active0 & 0x1f0000000L) != 0L) {
0038: jjmatchedKind = 33;
0039: jjmatchedPos = 1;
0040: return 435;
0041: }
0042: return -1;
0043: case 2:
0044: if ((active0 & 0x40000800000000L) != 0L) {
0045: jjmatchedKind = 56;
0046: jjmatchedPos = 2;
0047: return 433;
0048: }
0049: if ((active0 & 0x1f0000000L) != 0L) {
0050: jjmatchedKind = 33;
0051: jjmatchedPos = 2;
0052: return 435;
0053: }
0054: return -1;
0055: case 3:
0056: if ((active0 & 0x800000000L) != 0L) {
0057: jjmatchedKind = 56;
0058: jjmatchedPos = 3;
0059: return 433;
0060: }
0061: if ((active0 & 0x1f0000000L) != 0L) {
0062: jjmatchedKind = 33;
0063: jjmatchedPos = 3;
0064: return 435;
0065: }
0066: return -1;
0067: case 4:
0068: if ((active0 & 0x800000000L) != 0L) {
0069: jjmatchedKind = 56;
0070: jjmatchedPos = 4;
0071: return 433;
0072: }
0073: if ((active0 & 0x20000000L) != 0L)
0074: return 435;
0075: if ((active0 & 0x1d0000000L) != 0L) {
0076: jjmatchedKind = 33;
0077: jjmatchedPos = 4;
0078: return 435;
0079: }
0080: return -1;
0081: case 5:
0082: if ((active0 & 0x800000000L) != 0L) {
0083: jjmatchedKind = 56;
0084: jjmatchedPos = 5;
0085: return 433;
0086: }
0087: if ((active0 & 0x190000000L) != 0L) {
0088: jjmatchedKind = 33;
0089: jjmatchedPos = 5;
0090: return 435;
0091: }
0092: if ((active0 & 0x40000000L) != 0L)
0093: return 435;
0094: return -1;
0095: case 6:
0096: if ((active0 & 0x180000000L) != 0L) {
0097: jjmatchedKind = 33;
0098: jjmatchedPos = 6;
0099: return 435;
0100: }
0101: if ((active0 & 0x800000000L) != 0L)
0102: return 433;
0103: if ((active0 & 0x10000000L) != 0L)
0104: return 435;
0105: return -1;
0106: case 7:
0107: if ((active0 & 0x100000000L) != 0L)
0108: return 435;
0109: if ((active0 & 0x80000000L) != 0L) {
0110: jjmatchedKind = 33;
0111: jjmatchedPos = 7;
0112: return 435;
0113: }
0114: return -1;
0115: case 8:
0116: if ((active0 & 0x80000000L) != 0L) {
0117: jjmatchedKind = 33;
0118: jjmatchedPos = 8;
0119: return 435;
0120: }
0121: return -1;
0122: default:
0123: return -1;
0124: }
0125: }
0126:
0127: private final int jjStartNfa_0(int pos, long active0) {
0128: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0),
0129: pos + 1);
0130: }
0131:
0132: private int jjStopAtPos(int pos, int kind) {
0133: jjmatchedKind = kind;
0134: jjmatchedPos = pos;
0135: return pos + 1;
0136: }
0137:
0138: private int jjMoveStringLiteralDfa0_0() {
0139: switch (curChar) {
0140: case 41:
0141: return jjStopAtPos(0, 21);
0142: case 42:
0143: return jjStopAtPos(0, 11);
0144: case 43:
0145: return jjStopAtPos(0, 13);
0146: case 44:
0147: return jjStopAtPos(0, 7);
0148: case 45:
0149: jjmatchedKind = 14;
0150: return jjMoveStringLiteralDfa1_0(0x2000000L);
0151: case 46:
0152: return jjStartNfaWithStates_0(0, 8, 434);
0153: case 47:
0154: jjmatchedKind = 12;
0155: return jjMoveStringLiteralDfa1_0(0x4L);
0156: case 58:
0157: return jjStopAtPos(0, 10);
0158: case 59:
0159: return jjStopAtPos(0, 9);
0160: case 60:
0161: return jjMoveStringLiteralDfa1_0(0x1000000L);
0162: case 61:
0163: return jjStopAtPos(0, 15);
0164: case 62:
0165: return jjStopAtPos(0, 16);
0166: case 64:
0167: return jjMoveStringLiteralDfa1_0(0x1f0000000L);
0168: case 91:
0169: return jjStopAtPos(0, 17);
0170: case 93:
0171: return jjStopAtPos(0, 18);
0172: case 73:
0173: case 105:
0174: return jjMoveStringLiteralDfa1_0(0x800000000L);
0175: case 82:
0176: case 114:
0177: return jjMoveStringLiteralDfa1_0(0x40000000000000L);
0178: case 123:
0179: return jjStopAtPos(0, 5);
0180: case 124:
0181: return jjMoveStringLiteralDfa1_0(0x8000000L);
0182: case 125:
0183: return jjStopAtPos(0, 6);
0184: case 126:
0185: return jjMoveStringLiteralDfa1_0(0x4000000L);
0186: default:
0187: return jjMoveNfa_0(1, 0);
0188: }
0189: }
0190:
0191: private int jjMoveStringLiteralDfa1_0(long active0) {
0192: try {
0193: curChar = input_stream.readChar();
0194: } catch (java.io.IOException e) {
0195: jjStopStringLiteralDfa_0(0, active0);
0196: return 1;
0197: }
0198: switch (curChar) {
0199: case 33:
0200: return jjMoveStringLiteralDfa2_0(active0, 0x1000000L);
0201: case 42:
0202: if ((active0 & 0x4L) != 0L)
0203: return jjStopAtPos(1, 2);
0204: break;
0205: case 45:
0206: return jjMoveStringLiteralDfa2_0(active0, 0x2000000L);
0207: case 61:
0208: if ((active0 & 0x4000000L) != 0L)
0209: return jjStopAtPos(1, 26);
0210: else if ((active0 & 0x8000000L) != 0L)
0211: return jjStopAtPos(1, 27);
0212: break;
0213: case 67:
0214: case 99:
0215: return jjMoveStringLiteralDfa2_0(active0, 0x100000000L);
0216: case 70:
0217: case 102:
0218: return jjMoveStringLiteralDfa2_0(active0, 0x80000000L);
0219: case 71:
0220: case 103:
0221: return jjMoveStringLiteralDfa2_0(active0, 0x40000000000000L);
0222: case 73:
0223: case 105:
0224: return jjMoveStringLiteralDfa2_0(active0, 0x10000000L);
0225: case 77:
0226: case 109:
0227: return jjMoveStringLiteralDfa2_0(active0, 0x40000000L);
0228: case 78:
0229: case 110:
0230: return jjMoveStringLiteralDfa2_0(active0, 0x800000000L);
0231: case 80:
0232: case 112:
0233: return jjMoveStringLiteralDfa2_0(active0, 0x20000000L);
0234: default:
0235: break;
0236: }
0237: return jjStartNfa_0(0, active0);
0238: }
0239:
0240: private int jjMoveStringLiteralDfa2_0(long old0, long active0) {
0241: if (((active0 &= old0)) == 0L)
0242: return jjStartNfa_0(0, old0);
0243: try {
0244: curChar = input_stream.readChar();
0245: } catch (java.io.IOException e) {
0246: jjStopStringLiteralDfa_0(1, active0);
0247: return 2;
0248: }
0249: switch (curChar) {
0250: case 45:
0251: return jjMoveStringLiteralDfa3_0(active0, 0x1000000L);
0252: case 62:
0253: if ((active0 & 0x2000000L) != 0L)
0254: return jjStopAtPos(2, 25);
0255: break;
0256: case 65:
0257: case 97:
0258: return jjMoveStringLiteralDfa3_0(active0, 0x20000000L);
0259: case 66:
0260: case 98:
0261: return jjMoveStringLiteralDfa3_0(active0, 0x40000000000000L);
0262: case 69:
0263: case 101:
0264: return jjMoveStringLiteralDfa3_0(active0, 0x40000000L);
0265: case 72:
0266: case 104:
0267: return jjMoveStringLiteralDfa3_0(active0, 0x900000000L);
0268: case 77:
0269: case 109:
0270: return jjMoveStringLiteralDfa3_0(active0, 0x10000000L);
0271: case 79:
0272: case 111:
0273: return jjMoveStringLiteralDfa3_0(active0, 0x80000000L);
0274: default:
0275: break;
0276: }
0277: return jjStartNfa_0(1, active0);
0278: }
0279:
0280: private int jjMoveStringLiteralDfa3_0(long old0, long active0) {
0281: if (((active0 &= old0)) == 0L)
0282: return jjStartNfa_0(1, old0);
0283: try {
0284: curChar = input_stream.readChar();
0285: } catch (java.io.IOException e) {
0286: jjStopStringLiteralDfa_0(2, active0);
0287: return 3;
0288: }
0289: switch (curChar) {
0290: case 40:
0291: if ((active0 & 0x40000000000000L) != 0L)
0292: return jjStopAtPos(3, 54);
0293: break;
0294: case 45:
0295: if ((active0 & 0x1000000L) != 0L)
0296: return jjStopAtPos(3, 24);
0297: break;
0298: case 65:
0299: case 97:
0300: return jjMoveStringLiteralDfa4_0(active0, 0x100000000L);
0301: case 68:
0302: case 100:
0303: return jjMoveStringLiteralDfa4_0(active0, 0x40000000L);
0304: case 69:
0305: case 101:
0306: return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
0307: case 71:
0308: case 103:
0309: return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
0310: case 78:
0311: case 110:
0312: return jjMoveStringLiteralDfa4_0(active0, 0x80000000L);
0313: case 80:
0314: case 112:
0315: return jjMoveStringLiteralDfa4_0(active0, 0x10000000L);
0316: default:
0317: break;
0318: }
0319: return jjStartNfa_0(2, active0);
0320: }
0321:
0322: private int jjMoveStringLiteralDfa4_0(long old0, long active0) {
0323: if (((active0 &= old0)) == 0L)
0324: return jjStartNfa_0(2, old0);
0325: try {
0326: curChar = input_stream.readChar();
0327: } catch (java.io.IOException e) {
0328: jjStopStringLiteralDfa_0(3, active0);
0329: return 4;
0330: }
0331: switch (curChar) {
0332: case 69:
0333: case 101:
0334: if ((active0 & 0x20000000L) != 0L)
0335: return jjStartNfaWithStates_0(4, 29, 435);
0336: break;
0337: case 73:
0338: case 105:
0339: return jjMoveStringLiteralDfa5_0(active0, 0x40000000L);
0340: case 79:
0341: case 111:
0342: return jjMoveStringLiteralDfa5_0(active0, 0x10000000L);
0343: case 82:
0344: case 114:
0345: return jjMoveStringLiteralDfa5_0(active0, 0x900000000L);
0346: case 84:
0347: case 116:
0348: return jjMoveStringLiteralDfa5_0(active0, 0x80000000L);
0349: default:
0350: break;
0351: }
0352: return jjStartNfa_0(3, active0);
0353: }
0354:
0355: private int jjMoveStringLiteralDfa5_0(long old0, long active0) {
0356: if (((active0 &= old0)) == 0L)
0357: return jjStartNfa_0(3, old0);
0358: try {
0359: curChar = input_stream.readChar();
0360: } catch (java.io.IOException e) {
0361: jjStopStringLiteralDfa_0(4, active0);
0362: return 5;
0363: }
0364: switch (curChar) {
0365: case 45:
0366: return jjMoveStringLiteralDfa6_0(active0, 0x80000000L);
0367: case 65:
0368: case 97:
0369: if ((active0 & 0x40000000L) != 0L)
0370: return jjStartNfaWithStates_0(5, 30, 435);
0371: break;
0372: case 73:
0373: case 105:
0374: return jjMoveStringLiteralDfa6_0(active0, 0x800000000L);
0375: case 82:
0376: case 114:
0377: return jjMoveStringLiteralDfa6_0(active0, 0x10000000L);
0378: case 83:
0379: case 115:
0380: return jjMoveStringLiteralDfa6_0(active0, 0x100000000L);
0381: default:
0382: break;
0383: }
0384: return jjStartNfa_0(4, active0);
0385: }
0386:
0387: private int jjMoveStringLiteralDfa6_0(long old0, long active0) {
0388: if (((active0 &= old0)) == 0L)
0389: return jjStartNfa_0(4, old0);
0390: try {
0391: curChar = input_stream.readChar();
0392: } catch (java.io.IOException e) {
0393: jjStopStringLiteralDfa_0(5, active0);
0394: return 6;
0395: }
0396: switch (curChar) {
0397: case 69:
0398: case 101:
0399: return jjMoveStringLiteralDfa7_0(active0, 0x100000000L);
0400: case 70:
0401: case 102:
0402: return jjMoveStringLiteralDfa7_0(active0, 0x80000000L);
0403: case 84:
0404: case 116:
0405: if ((active0 & 0x10000000L) != 0L)
0406: return jjStartNfaWithStates_0(6, 28, 435);
0407: else if ((active0 & 0x800000000L) != 0L)
0408: return jjStartNfaWithStates_0(6, 35, 433);
0409: break;
0410: default:
0411: break;
0412: }
0413: return jjStartNfa_0(5, active0);
0414: }
0415:
0416: private int jjMoveStringLiteralDfa7_0(long old0, long active0) {
0417: if (((active0 &= old0)) == 0L)
0418: return jjStartNfa_0(5, old0);
0419: try {
0420: curChar = input_stream.readChar();
0421: } catch (java.io.IOException e) {
0422: jjStopStringLiteralDfa_0(6, active0);
0423: return 7;
0424: }
0425: switch (curChar) {
0426: case 65:
0427: case 97:
0428: return jjMoveStringLiteralDfa8_0(active0, 0x80000000L);
0429: case 84:
0430: case 116:
0431: if ((active0 & 0x100000000L) != 0L)
0432: return jjStartNfaWithStates_0(7, 32, 435);
0433: break;
0434: default:
0435: break;
0436: }
0437: return jjStartNfa_0(6, active0);
0438: }
0439:
0440: private int jjMoveStringLiteralDfa8_0(long old0, long active0) {
0441: if (((active0 &= old0)) == 0L)
0442: return jjStartNfa_0(6, old0);
0443: try {
0444: curChar = input_stream.readChar();
0445: } catch (java.io.IOException e) {
0446: jjStopStringLiteralDfa_0(7, active0);
0447: return 8;
0448: }
0449: switch (curChar) {
0450: case 67:
0451: case 99:
0452: return jjMoveStringLiteralDfa9_0(active0, 0x80000000L);
0453: default:
0454: break;
0455: }
0456: return jjStartNfa_0(7, active0);
0457: }
0458:
0459: private int jjMoveStringLiteralDfa9_0(long old0, long active0) {
0460: if (((active0 &= old0)) == 0L)
0461: return jjStartNfa_0(7, old0);
0462: try {
0463: curChar = input_stream.readChar();
0464: } catch (java.io.IOException e) {
0465: jjStopStringLiteralDfa_0(8, active0);
0466: return 9;
0467: }
0468: switch (curChar) {
0469: case 69:
0470: case 101:
0471: if ((active0 & 0x80000000L) != 0L)
0472: return jjStartNfaWithStates_0(9, 31, 435);
0473: break;
0474: default:
0475: break;
0476: }
0477: return jjStartNfa_0(8, active0);
0478: }
0479:
0480: private int jjStartNfaWithStates_0(int pos, int kind, int state) {
0481: jjmatchedKind = kind;
0482: jjmatchedPos = pos;
0483: try {
0484: curChar = input_stream.readChar();
0485: } catch (java.io.IOException e) {
0486: return pos + 1;
0487: }
0488: return jjMoveNfa_0(state, pos + 1);
0489: }
0490:
0491: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0492: 0xffffffffffffffffL, 0xffffffffffffffffL,
0493: 0xffffffffffffffffL };
0494: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0495: 0xffffffffffffffffL };
0496:
0497: private int jjMoveNfa_0(int startState, int curPos) {
0498: //int[] nextStates; // not used
0499: int startsAt = 0;
0500: jjnewStateCnt = 433;
0501: int i = 1;
0502: jjstateSet[0] = startState;
0503: //int j; // not used
0504: int kind = 0x7fffffff;
0505: for (;;) {
0506: if (++jjround == 0x7fffffff)
0507: ReInitRounds();
0508: if (curChar < 64) {
0509: long l = 1L << curChar;
0510: do {
0511: switch (jjstateSet[--i]) {
0512: case 1:
0513: if ((0x3ff000000000000L & l) != 0L) {
0514: if (kind > 53)
0515: kind = 53;
0516: jjCheckNAddStates(0, 75);
0517: } else if ((0x100003600L & l) != 0L) {
0518: if (kind > 1)
0519: kind = 1;
0520: jjCheckNAdd(0);
0521: } else if (curChar == 45)
0522: jjAddStates(76, 79);
0523: else if (curChar == 46)
0524: jjCheckNAddStates(80, 98);
0525: else if (curChar == 33)
0526: jjCheckNAddTwoStates(93, 102);
0527: else if (curChar == 39)
0528: jjCheckNAddStates(99, 101);
0529: else if (curChar == 34)
0530: jjCheckNAddStates(102, 104);
0531: else if (curChar == 35)
0532: jjCheckNAddTwoStates(2, 3);
0533: break;
0534: case 434:
0535: if ((0x3ff000000000000L & l) != 0L) {
0536: if (kind > 58)
0537: kind = 58;
0538: jjCheckNAdd(310);
0539: }
0540: if ((0x3ff000000000000L & l) != 0L) {
0541: if (kind > 53)
0542: kind = 53;
0543: jjCheckNAdd(309);
0544: }
0545: if ((0x3ff000000000000L & l) != 0L)
0546: jjCheckNAddTwoStates(307, 308);
0547: if ((0x3ff000000000000L & l) != 0L)
0548: jjCheckNAddStates(105, 108);
0549: if ((0x3ff000000000000L & l) != 0L)
0550: jjCheckNAddTwoStates(271, 274);
0551: if ((0x3ff000000000000L & l) != 0L)
0552: jjCheckNAddTwoStates(268, 270);
0553: if ((0x3ff000000000000L & l) != 0L)
0554: jjCheckNAddTwoStates(266, 267);
0555: if ((0x3ff000000000000L & l) != 0L)
0556: jjCheckNAddTwoStates(263, 265);
0557: if ((0x3ff000000000000L & l) != 0L)
0558: jjCheckNAddTwoStates(258, 262);
0559: if ((0x3ff000000000000L & l) != 0L)
0560: jjCheckNAddTwoStates(254, 257);
0561: if ((0x3ff000000000000L & l) != 0L)
0562: jjCheckNAddTwoStates(250, 253);
0563: if ((0x3ff000000000000L & l) != 0L)
0564: jjCheckNAddTwoStates(247, 249);
0565: if ((0x3ff000000000000L & l) != 0L)
0566: jjCheckNAddTwoStates(244, 246);
0567: if ((0x3ff000000000000L & l) != 0L)
0568: jjCheckNAddTwoStates(241, 243);
0569: if ((0x3ff000000000000L & l) != 0L)
0570: jjCheckNAddTwoStates(238, 240);
0571: if ((0x3ff000000000000L & l) != 0L)
0572: jjCheckNAddTwoStates(235, 237);
0573: if ((0x3ff000000000000L & l) != 0L)
0574: jjCheckNAddTwoStates(232, 234);
0575: if ((0x3ff000000000000L & l) != 0L)
0576: jjCheckNAddTwoStates(229, 231);
0577: if ((0x3ff000000000000L & l) != 0L)
0578: jjCheckNAddTwoStates(226, 228);
0579: break;
0580: case 61:
0581: if (curChar == 45)
0582: jjAddStates(109, 110);
0583: break;
0584: case 433:
0585: if ((0x3ff200000000000L & l) != 0L) {
0586: if (kind > 56)
0587: kind = 56;
0588: jjCheckNAddTwoStates(331, 332);
0589: } else if (curChar == 40) {
0590: if (kind > 55)
0591: kind = 55;
0592: }
0593: if ((0x3ff200000000000L & l) != 0L)
0594: jjCheckNAddStates(111, 113);
0595: break;
0596: case 435:
0597: case 63:
0598: if ((0x3ff200000000000L & l) == 0L)
0599: break;
0600: if (kind > 33)
0601: kind = 33;
0602: jjCheckNAddTwoStates(63, 64);
0603: break;
0604: case 0:
0605: if ((0x100003600L & l) == 0L)
0606: break;
0607: if (kind > 1)
0608: kind = 1;
0609: jjCheckNAdd(0);
0610: break;
0611: case 2:
0612: if ((0x3ff200000000000L & l) == 0L)
0613: break;
0614: if (kind > 19)
0615: kind = 19;
0616: jjCheckNAddTwoStates(2, 3);
0617: break;
0618: case 4:
0619: if ((0xffffffff00000000L & l) == 0L)
0620: break;
0621: if (kind > 19)
0622: kind = 19;
0623: jjCheckNAddTwoStates(2, 3);
0624: break;
0625: case 5:
0626: if ((0x3ff000000000000L & l) == 0L)
0627: break;
0628: if (kind > 19)
0629: kind = 19;
0630: jjCheckNAddStates(114, 121);
0631: break;
0632: case 6:
0633: if ((0x3ff000000000000L & l) == 0L)
0634: break;
0635: if (kind > 19)
0636: kind = 19;
0637: jjCheckNAddStates(122, 124);
0638: break;
0639: case 7:
0640: if ((0x100003600L & l) == 0L)
0641: break;
0642: if (kind > 19)
0643: kind = 19;
0644: jjCheckNAddTwoStates(2, 3);
0645: break;
0646: case 8:
0647: case 10:
0648: case 13:
0649: case 17:
0650: if ((0x3ff000000000000L & l) != 0L)
0651: jjCheckNAdd(6);
0652: break;
0653: case 9:
0654: if ((0x3ff000000000000L & l) != 0L)
0655: jjstateSet[jjnewStateCnt++] = 10;
0656: break;
0657: case 11:
0658: if ((0x3ff000000000000L & l) != 0L)
0659: jjstateSet[jjnewStateCnt++] = 12;
0660: break;
0661: case 12:
0662: if ((0x3ff000000000000L & l) != 0L)
0663: jjstateSet[jjnewStateCnt++] = 13;
0664: break;
0665: case 14:
0666: if ((0x3ff000000000000L & l) != 0L)
0667: jjstateSet[jjnewStateCnt++] = 15;
0668: break;
0669: case 15:
0670: if ((0x3ff000000000000L & l) != 0L)
0671: jjstateSet[jjnewStateCnt++] = 16;
0672: break;
0673: case 16:
0674: if ((0x3ff000000000000L & l) != 0L)
0675: jjstateSet[jjnewStateCnt++] = 17;
0676: break;
0677: case 18:
0678: if (curChar == 34)
0679: jjCheckNAddStates(102, 104);
0680: break;
0681: case 19:
0682: if ((0xfffffffb00000200L & l) != 0L)
0683: jjCheckNAddStates(102, 104);
0684: break;
0685: case 20:
0686: if (curChar == 34 && kind > 20)
0687: kind = 20;
0688: break;
0689: case 22:
0690: if ((0x3400L & l) != 0L)
0691: jjCheckNAddStates(102, 104);
0692: break;
0693: case 23:
0694: if (curChar == 10)
0695: jjCheckNAddStates(102, 104);
0696: break;
0697: case 24:
0698: if (curChar == 13)
0699: jjstateSet[jjnewStateCnt++] = 23;
0700: break;
0701: case 25:
0702: if ((0xffffffff00000000L & l) != 0L)
0703: jjCheckNAddStates(102, 104);
0704: break;
0705: case 26:
0706: if ((0x3ff000000000000L & l) != 0L)
0707: jjCheckNAddStates(125, 133);
0708: break;
0709: case 27:
0710: if ((0x3ff000000000000L & l) != 0L)
0711: jjCheckNAddStates(134, 137);
0712: break;
0713: case 28:
0714: if ((0x100003600L & l) != 0L)
0715: jjCheckNAddStates(102, 104);
0716: break;
0717: case 29:
0718: case 31:
0719: case 34:
0720: case 38:
0721: if ((0x3ff000000000000L & l) != 0L)
0722: jjCheckNAdd(27);
0723: break;
0724: case 30:
0725: if ((0x3ff000000000000L & l) != 0L)
0726: jjstateSet[jjnewStateCnt++] = 31;
0727: break;
0728: case 32:
0729: if ((0x3ff000000000000L & l) != 0L)
0730: jjstateSet[jjnewStateCnt++] = 33;
0731: break;
0732: case 33:
0733: if ((0x3ff000000000000L & l) != 0L)
0734: jjstateSet[jjnewStateCnt++] = 34;
0735: break;
0736: case 35:
0737: if ((0x3ff000000000000L & l) != 0L)
0738: jjstateSet[jjnewStateCnt++] = 36;
0739: break;
0740: case 36:
0741: if ((0x3ff000000000000L & l) != 0L)
0742: jjstateSet[jjnewStateCnt++] = 37;
0743: break;
0744: case 37:
0745: if ((0x3ff000000000000L & l) != 0L)
0746: jjstateSet[jjnewStateCnt++] = 38;
0747: break;
0748: case 39:
0749: if (curChar == 39)
0750: jjCheckNAddStates(99, 101);
0751: break;
0752: case 40:
0753: if ((0xffffff7f00000200L & l) != 0L)
0754: jjCheckNAddStates(99, 101);
0755: break;
0756: case 41:
0757: if (curChar == 39 && kind > 20)
0758: kind = 20;
0759: break;
0760: case 43:
0761: if ((0x3400L & l) != 0L)
0762: jjCheckNAddStates(99, 101);
0763: break;
0764: case 44:
0765: if (curChar == 10)
0766: jjCheckNAddStates(99, 101);
0767: break;
0768: case 45:
0769: if (curChar == 13)
0770: jjstateSet[jjnewStateCnt++] = 44;
0771: break;
0772: case 46:
0773: if ((0xffffffff00000000L & l) != 0L)
0774: jjCheckNAddStates(99, 101);
0775: break;
0776: case 47:
0777: if ((0x3ff000000000000L & l) != 0L)
0778: jjCheckNAddStates(138, 146);
0779: break;
0780: case 48:
0781: if ((0x3ff000000000000L & l) != 0L)
0782: jjCheckNAddStates(147, 150);
0783: break;
0784: case 49:
0785: if ((0x100003600L & l) != 0L)
0786: jjCheckNAddStates(99, 101);
0787: break;
0788: case 50:
0789: case 52:
0790: case 55:
0791: case 59:
0792: if ((0x3ff000000000000L & l) != 0L)
0793: jjCheckNAdd(48);
0794: break;
0795: case 51:
0796: if ((0x3ff000000000000L & l) != 0L)
0797: jjstateSet[jjnewStateCnt++] = 52;
0798: break;
0799: case 53:
0800: if ((0x3ff000000000000L & l) != 0L)
0801: jjstateSet[jjnewStateCnt++] = 54;
0802: break;
0803: case 54:
0804: if ((0x3ff000000000000L & l) != 0L)
0805: jjstateSet[jjnewStateCnt++] = 55;
0806: break;
0807: case 56:
0808: if ((0x3ff000000000000L & l) != 0L)
0809: jjstateSet[jjnewStateCnt++] = 57;
0810: break;
0811: case 57:
0812: if ((0x3ff000000000000L & l) != 0L)
0813: jjstateSet[jjnewStateCnt++] = 58;
0814: break;
0815: case 58:
0816: if ((0x3ff000000000000L & l) != 0L)
0817: jjstateSet[jjnewStateCnt++] = 59;
0818: break;
0819: case 65:
0820: if ((0xffffffff00000000L & l) == 0L)
0821: break;
0822: if (kind > 33)
0823: kind = 33;
0824: jjCheckNAddTwoStates(63, 64);
0825: break;
0826: case 66:
0827: if ((0x3ff000000000000L & l) == 0L)
0828: break;
0829: if (kind > 33)
0830: kind = 33;
0831: jjCheckNAddStates(151, 158);
0832: break;
0833: case 67:
0834: if ((0x3ff000000000000L & l) == 0L)
0835: break;
0836: if (kind > 33)
0837: kind = 33;
0838: jjCheckNAddStates(159, 161);
0839: break;
0840: case 68:
0841: if ((0x100003600L & l) == 0L)
0842: break;
0843: if (kind > 33)
0844: kind = 33;
0845: jjCheckNAddTwoStates(63, 64);
0846: break;
0847: case 69:
0848: case 71:
0849: case 74:
0850: case 78:
0851: if ((0x3ff000000000000L & l) != 0L)
0852: jjCheckNAdd(67);
0853: break;
0854: case 70:
0855: if ((0x3ff000000000000L & l) != 0L)
0856: jjstateSet[jjnewStateCnt++] = 71;
0857: break;
0858: case 72:
0859: if ((0x3ff000000000000L & l) != 0L)
0860: jjstateSet[jjnewStateCnt++] = 73;
0861: break;
0862: case 73:
0863: if ((0x3ff000000000000L & l) != 0L)
0864: jjstateSet[jjnewStateCnt++] = 74;
0865: break;
0866: case 75:
0867: if ((0x3ff000000000000L & l) != 0L)
0868: jjstateSet[jjnewStateCnt++] = 76;
0869: break;
0870: case 76:
0871: if ((0x3ff000000000000L & l) != 0L)
0872: jjstateSet[jjnewStateCnt++] = 77;
0873: break;
0874: case 77:
0875: if ((0x3ff000000000000L & l) != 0L)
0876: jjstateSet[jjnewStateCnt++] = 78;
0877: break;
0878: case 80:
0879: if ((0x3ff000000000000L & l) == 0L)
0880: break;
0881: if (kind > 33)
0882: kind = 33;
0883: jjCheckNAddStates(162, 169);
0884: break;
0885: case 81:
0886: if ((0x3ff000000000000L & l) == 0L)
0887: break;
0888: if (kind > 33)
0889: kind = 33;
0890: jjCheckNAddStates(170, 172);
0891: break;
0892: case 82:
0893: case 84:
0894: case 87:
0895: case 91:
0896: if ((0x3ff000000000000L & l) != 0L)
0897: jjCheckNAdd(81);
0898: break;
0899: case 83:
0900: if ((0x3ff000000000000L & l) != 0L)
0901: jjstateSet[jjnewStateCnt++] = 84;
0902: break;
0903: case 85:
0904: if ((0x3ff000000000000L & l) != 0L)
0905: jjstateSet[jjnewStateCnt++] = 86;
0906: break;
0907: case 86:
0908: if ((0x3ff000000000000L & l) != 0L)
0909: jjstateSet[jjnewStateCnt++] = 87;
0910: break;
0911: case 88:
0912: if ((0x3ff000000000000L & l) != 0L)
0913: jjstateSet[jjnewStateCnt++] = 89;
0914: break;
0915: case 89:
0916: if ((0x3ff000000000000L & l) != 0L)
0917: jjstateSet[jjnewStateCnt++] = 90;
0918: break;
0919: case 90:
0920: if ((0x3ff000000000000L & l) != 0L)
0921: jjstateSet[jjnewStateCnt++] = 91;
0922: break;
0923: case 92:
0924: if (curChar == 33)
0925: jjCheckNAddTwoStates(93, 102);
0926: break;
0927: case 93:
0928: if ((0x100003600L & l) != 0L)
0929: jjCheckNAddTwoStates(93, 102);
0930: break;
0931: case 104:
0932: if (curChar == 40)
0933: jjCheckNAddStates(173, 178);
0934: break;
0935: case 105:
0936: if ((0xfffffc7a00000000L & l) != 0L)
0937: jjCheckNAddStates(179, 182);
0938: break;
0939: case 106:
0940: if ((0x100003600L & l) != 0L)
0941: jjCheckNAddTwoStates(106, 107);
0942: break;
0943: case 107:
0944: if (curChar == 41 && kind > 23)
0945: kind = 23;
0946: break;
0947: case 109:
0948: if ((0xffffffff00000000L & l) != 0L)
0949: jjCheckNAddStates(179, 182);
0950: break;
0951: case 110:
0952: if ((0x3ff000000000000L & l) != 0L)
0953: jjCheckNAddStates(183, 191);
0954: break;
0955: case 111:
0956: if ((0x3ff000000000000L & l) != 0L)
0957: jjCheckNAddStates(192, 195);
0958: break;
0959: case 112:
0960: if ((0x100003600L & l) != 0L)
0961: jjCheckNAddStates(179, 182);
0962: break;
0963: case 113:
0964: case 115:
0965: case 118:
0966: case 122:
0967: if ((0x3ff000000000000L & l) != 0L)
0968: jjCheckNAdd(111);
0969: break;
0970: case 114:
0971: if ((0x3ff000000000000L & l) != 0L)
0972: jjstateSet[jjnewStateCnt++] = 115;
0973: break;
0974: case 116:
0975: if ((0x3ff000000000000L & l) != 0L)
0976: jjstateSet[jjnewStateCnt++] = 117;
0977: break;
0978: case 117:
0979: if ((0x3ff000000000000L & l) != 0L)
0980: jjstateSet[jjnewStateCnt++] = 118;
0981: break;
0982: case 119:
0983: if ((0x3ff000000000000L & l) != 0L)
0984: jjstateSet[jjnewStateCnt++] = 120;
0985: break;
0986: case 120:
0987: if ((0x3ff000000000000L & l) != 0L)
0988: jjstateSet[jjnewStateCnt++] = 121;
0989: break;
0990: case 121:
0991: if ((0x3ff000000000000L & l) != 0L)
0992: jjstateSet[jjnewStateCnt++] = 122;
0993: break;
0994: case 123:
0995: if (curChar == 39)
0996: jjCheckNAddStates(196, 198);
0997: break;
0998: case 124:
0999: if ((0xffffff7f00000200L & l) != 0L)
1000: jjCheckNAddStates(196, 198);
1001: break;
1002: case 125:
1003: if (curChar == 39)
1004: jjCheckNAddTwoStates(106, 107);
1005: break;
1006: case 127:
1007: if ((0x3400L & l) != 0L)
1008: jjCheckNAddStates(196, 198);
1009: break;
1010: case 128:
1011: if (curChar == 10)
1012: jjCheckNAddStates(196, 198);
1013: break;
1014: case 129:
1015: if (curChar == 13)
1016: jjstateSet[jjnewStateCnt++] = 128;
1017: break;
1018: case 130:
1019: if ((0xffffffff00000000L & l) != 0L)
1020: jjCheckNAddStates(196, 198);
1021: break;
1022: case 131:
1023: if ((0x3ff000000000000L & l) != 0L)
1024: jjCheckNAddStates(199, 207);
1025: break;
1026: case 132:
1027: if ((0x3ff000000000000L & l) != 0L)
1028: jjCheckNAddStates(208, 211);
1029: break;
1030: case 133:
1031: if ((0x100003600L & l) != 0L)
1032: jjCheckNAddStates(196, 198);
1033: break;
1034: case 134:
1035: case 136:
1036: case 139:
1037: case 143:
1038: if ((0x3ff000000000000L & l) != 0L)
1039: jjCheckNAdd(132);
1040: break;
1041: case 135:
1042: if ((0x3ff000000000000L & l) != 0L)
1043: jjstateSet[jjnewStateCnt++] = 136;
1044: break;
1045: case 137:
1046: if ((0x3ff000000000000L & l) != 0L)
1047: jjstateSet[jjnewStateCnt++] = 138;
1048: break;
1049: case 138:
1050: if ((0x3ff000000000000L & l) != 0L)
1051: jjstateSet[jjnewStateCnt++] = 139;
1052: break;
1053: case 140:
1054: if ((0x3ff000000000000L & l) != 0L)
1055: jjstateSet[jjnewStateCnt++] = 141;
1056: break;
1057: case 141:
1058: if ((0x3ff000000000000L & l) != 0L)
1059: jjstateSet[jjnewStateCnt++] = 142;
1060: break;
1061: case 142:
1062: if ((0x3ff000000000000L & l) != 0L)
1063: jjstateSet[jjnewStateCnt++] = 143;
1064: break;
1065: case 144:
1066: if (curChar == 34)
1067: jjCheckNAddStates(212, 214);
1068: break;
1069: case 145:
1070: if ((0xfffffffb00000200L & l) != 0L)
1071: jjCheckNAddStates(212, 214);
1072: break;
1073: case 146:
1074: if (curChar == 34)
1075: jjCheckNAddTwoStates(106, 107);
1076: break;
1077: case 148:
1078: if ((0x3400L & l) != 0L)
1079: jjCheckNAddStates(212, 214);
1080: break;
1081: case 149:
1082: if (curChar == 10)
1083: jjCheckNAddStates(212, 214);
1084: break;
1085: case 150:
1086: if (curChar == 13)
1087: jjstateSet[jjnewStateCnt++] = 149;
1088: break;
1089: case 151:
1090: if ((0xffffffff00000000L & l) != 0L)
1091: jjCheckNAddStates(212, 214);
1092: break;
1093: case 152:
1094: if ((0x3ff000000000000L & l) != 0L)
1095: jjCheckNAddStates(215, 223);
1096: break;
1097: case 153:
1098: if ((0x3ff000000000000L & l) != 0L)
1099: jjCheckNAddStates(224, 227);
1100: break;
1101: case 154:
1102: if ((0x100003600L & l) != 0L)
1103: jjCheckNAddStates(212, 214);
1104: break;
1105: case 155:
1106: case 157:
1107: case 160:
1108: case 164:
1109: if ((0x3ff000000000000L & l) != 0L)
1110: jjCheckNAdd(153);
1111: break;
1112: case 156:
1113: if ((0x3ff000000000000L & l) != 0L)
1114: jjstateSet[jjnewStateCnt++] = 157;
1115: break;
1116: case 158:
1117: if ((0x3ff000000000000L & l) != 0L)
1118: jjstateSet[jjnewStateCnt++] = 159;
1119: break;
1120: case 159:
1121: if ((0x3ff000000000000L & l) != 0L)
1122: jjstateSet[jjnewStateCnt++] = 160;
1123: break;
1124: case 161:
1125: if ((0x3ff000000000000L & l) != 0L)
1126: jjstateSet[jjnewStateCnt++] = 162;
1127: break;
1128: case 162:
1129: if ((0x3ff000000000000L & l) != 0L)
1130: jjstateSet[jjnewStateCnt++] = 163;
1131: break;
1132: case 163:
1133: if ((0x3ff000000000000L & l) != 0L)
1134: jjstateSet[jjnewStateCnt++] = 164;
1135: break;
1136: case 165:
1137: if ((0x100003600L & l) != 0L)
1138: jjCheckNAddStates(228, 234);
1139: break;
1140: case 168:
1141: if (curChar == 43)
1142: jjCheckNAddStates(235, 237);
1143: break;
1144: case 169:
1145: case 198:
1146: if (curChar == 63 && kind > 59)
1147: kind = 59;
1148: break;
1149: case 170:
1150: if ((0x3ff000000000000L & l) == 0L)
1151: break;
1152: if (kind > 59)
1153: kind = 59;
1154: jjCheckNAddStates(238, 246);
1155: break;
1156: case 171:
1157: if ((0x3ff000000000000L & l) != 0L)
1158: jjCheckNAdd(172);
1159: break;
1160: case 172:
1161: if (curChar == 45)
1162: jjstateSet[jjnewStateCnt++] = 173;
1163: break;
1164: case 173:
1165: if ((0x3ff000000000000L & l) == 0L)
1166: break;
1167: if (kind > 59)
1168: kind = 59;
1169: jjCheckNAddStates(247, 251);
1170: break;
1171: case 174:
1172: if ((0x3ff000000000000L & l) != 0L && kind > 59)
1173: kind = 59;
1174: break;
1175: case 175:
1176: case 177:
1177: case 180:
1178: case 184:
1179: if ((0x3ff000000000000L & l) != 0L)
1180: jjCheckNAdd(174);
1181: break;
1182: case 176:
1183: if ((0x3ff000000000000L & l) != 0L)
1184: jjstateSet[jjnewStateCnt++] = 177;
1185: break;
1186: case 178:
1187: if ((0x3ff000000000000L & l) != 0L)
1188: jjstateSet[jjnewStateCnt++] = 179;
1189: break;
1190: case 179:
1191: if ((0x3ff000000000000L & l) != 0L)
1192: jjstateSet[jjnewStateCnt++] = 180;
1193: break;
1194: case 181:
1195: if ((0x3ff000000000000L & l) != 0L)
1196: jjstateSet[jjnewStateCnt++] = 182;
1197: break;
1198: case 182:
1199: if ((0x3ff000000000000L & l) != 0L)
1200: jjstateSet[jjnewStateCnt++] = 183;
1201: break;
1202: case 183:
1203: if ((0x3ff000000000000L & l) != 0L)
1204: jjstateSet[jjnewStateCnt++] = 184;
1205: break;
1206: case 185:
1207: case 187:
1208: case 190:
1209: case 194:
1210: if ((0x3ff000000000000L & l) != 0L)
1211: jjCheckNAdd(171);
1212: break;
1213: case 186:
1214: if ((0x3ff000000000000L & l) != 0L)
1215: jjstateSet[jjnewStateCnt++] = 187;
1216: break;
1217: case 188:
1218: if ((0x3ff000000000000L & l) != 0L)
1219: jjstateSet[jjnewStateCnt++] = 189;
1220: break;
1221: case 189:
1222: if ((0x3ff000000000000L & l) != 0L)
1223: jjstateSet[jjnewStateCnt++] = 190;
1224: break;
1225: case 191:
1226: if ((0x3ff000000000000L & l) != 0L)
1227: jjstateSet[jjnewStateCnt++] = 192;
1228: break;
1229: case 192:
1230: if ((0x3ff000000000000L & l) != 0L)
1231: jjstateSet[jjnewStateCnt++] = 193;
1232: break;
1233: case 193:
1234: if ((0x3ff000000000000L & l) != 0L)
1235: jjstateSet[jjnewStateCnt++] = 194;
1236: break;
1237: case 195:
1238: if ((0x3ff000000000000L & l) == 0L)
1239: break;
1240: if (kind > 59)
1241: kind = 59;
1242: jjCheckNAddStates(252, 254);
1243: break;
1244: case 196:
1245: if ((0x3ff000000000000L & l) == 0L)
1246: break;
1247: if (kind > 59)
1248: kind = 59;
1249: jjCheckNAddStates(255, 257);
1250: break;
1251: case 197:
1252: if ((0x3ff000000000000L & l) == 0L)
1253: break;
1254: if (kind > 59)
1255: kind = 59;
1256: jjCheckNAddStates(258, 260);
1257: break;
1258: case 199:
1259: case 202:
1260: case 204:
1261: case 205:
1262: case 208:
1263: case 209:
1264: case 211:
1265: case 215:
1266: case 219:
1267: case 222:
1268: case 224:
1269: if (curChar == 63)
1270: jjCheckNAdd(198);
1271: break;
1272: case 200:
1273: if ((0x3ff000000000000L & l) == 0L)
1274: break;
1275: if (kind > 59)
1276: kind = 59;
1277: jjCheckNAddTwoStates(169, 174);
1278: break;
1279: case 201:
1280: if (curChar == 63)
1281: jjCheckNAddTwoStates(198, 202);
1282: break;
1283: case 203:
1284: if (curChar == 63)
1285: jjCheckNAddStates(261, 263);
1286: break;
1287: case 206:
1288: if (curChar == 63)
1289: jjstateSet[jjnewStateCnt++] = 205;
1290: break;
1291: case 207:
1292: if (curChar == 63)
1293: jjCheckNAddStates(264, 267);
1294: break;
1295: case 210:
1296: if (curChar == 63)
1297: jjstateSet[jjnewStateCnt++] = 209;
1298: break;
1299: case 212:
1300: if (curChar == 63)
1301: jjstateSet[jjnewStateCnt++] = 211;
1302: break;
1303: case 213:
1304: if (curChar == 63)
1305: jjstateSet[jjnewStateCnt++] = 212;
1306: break;
1307: case 214:
1308: if (curChar == 63)
1309: jjCheckNAddStates(268, 272);
1310: break;
1311: case 216:
1312: if (curChar == 63)
1313: jjstateSet[jjnewStateCnt++] = 215;
1314: break;
1315: case 217:
1316: if (curChar == 63)
1317: jjstateSet[jjnewStateCnt++] = 216;
1318: break;
1319: case 218:
1320: if (curChar == 63)
1321: jjstateSet[jjnewStateCnt++] = 217;
1322: break;
1323: case 220:
1324: if (curChar == 63)
1325: jjstateSet[jjnewStateCnt++] = 219;
1326: break;
1327: case 221:
1328: if (curChar == 63)
1329: jjstateSet[jjnewStateCnt++] = 220;
1330: break;
1331: case 223:
1332: if (curChar == 63)
1333: jjstateSet[jjnewStateCnt++] = 222;
1334: break;
1335: case 225:
1336: if (curChar == 46)
1337: jjCheckNAddStates(80, 98);
1338: break;
1339: case 226:
1340: if ((0x3ff000000000000L & l) != 0L)
1341: jjCheckNAddTwoStates(226, 228);
1342: break;
1343: case 229:
1344: if ((0x3ff000000000000L & l) != 0L)
1345: jjCheckNAddTwoStates(229, 231);
1346: break;
1347: case 232:
1348: if ((0x3ff000000000000L & l) != 0L)
1349: jjCheckNAddTwoStates(232, 234);
1350: break;
1351: case 235:
1352: if ((0x3ff000000000000L & l) != 0L)
1353: jjCheckNAddTwoStates(235, 237);
1354: break;
1355: case 238:
1356: if ((0x3ff000000000000L & l) != 0L)
1357: jjCheckNAddTwoStates(238, 240);
1358: break;
1359: case 241:
1360: if ((0x3ff000000000000L & l) != 0L)
1361: jjCheckNAddTwoStates(241, 243);
1362: break;
1363: case 244:
1364: if ((0x3ff000000000000L & l) != 0L)
1365: jjCheckNAddTwoStates(244, 246);
1366: break;
1367: case 247:
1368: if ((0x3ff000000000000L & l) != 0L)
1369: jjCheckNAddTwoStates(247, 249);
1370: break;
1371: case 250:
1372: if ((0x3ff000000000000L & l) != 0L)
1373: jjCheckNAddTwoStates(250, 253);
1374: break;
1375: case 254:
1376: if ((0x3ff000000000000L & l) != 0L)
1377: jjCheckNAddTwoStates(254, 257);
1378: break;
1379: case 258:
1380: if ((0x3ff000000000000L & l) != 0L)
1381: jjCheckNAddTwoStates(258, 262);
1382: break;
1383: case 263:
1384: if ((0x3ff000000000000L & l) != 0L)
1385: jjCheckNAddTwoStates(263, 265);
1386: break;
1387: case 266:
1388: if ((0x3ff000000000000L & l) != 0L)
1389: jjCheckNAddTwoStates(266, 267);
1390: break;
1391: case 268:
1392: if ((0x3ff000000000000L & l) != 0L)
1393: jjCheckNAddTwoStates(268, 270);
1394: break;
1395: case 271:
1396: if ((0x3ff000000000000L & l) != 0L)
1397: jjCheckNAddTwoStates(271, 274);
1398: break;
1399: case 275:
1400: if ((0x3ff000000000000L & l) != 0L)
1401: jjCheckNAddStates(105, 108);
1402: break;
1403: case 276:
1404: if (curChar == 45)
1405: jjCheckNAddTwoStates(277, 294);
1406: break;
1407: case 278:
1408: if ((0x3ff200000000000L & l) == 0L)
1409: break;
1410: if (kind > 51)
1411: kind = 51;
1412: jjCheckNAddTwoStates(278, 279);
1413: break;
1414: case 280:
1415: if ((0xffffffff00000000L & l) == 0L)
1416: break;
1417: if (kind > 51)
1418: kind = 51;
1419: jjCheckNAddTwoStates(278, 279);
1420: break;
1421: case 281:
1422: if ((0x3ff000000000000L & l) == 0L)
1423: break;
1424: if (kind > 51)
1425: kind = 51;
1426: jjCheckNAddStates(273, 280);
1427: break;
1428: case 282:
1429: if ((0x3ff000000000000L & l) == 0L)
1430: break;
1431: if (kind > 51)
1432: kind = 51;
1433: jjCheckNAddStates(281, 283);
1434: break;
1435: case 283:
1436: if ((0x100003600L & l) == 0L)
1437: break;
1438: if (kind > 51)
1439: kind = 51;
1440: jjCheckNAddTwoStates(278, 279);
1441: break;
1442: case 284:
1443: case 286:
1444: case 289:
1445: case 293:
1446: if ((0x3ff000000000000L & l) != 0L)
1447: jjCheckNAdd(282);
1448: break;
1449: case 285:
1450: if ((0x3ff000000000000L & l) != 0L)
1451: jjstateSet[jjnewStateCnt++] = 286;
1452: break;
1453: case 287:
1454: if ((0x3ff000000000000L & l) != 0L)
1455: jjstateSet[jjnewStateCnt++] = 288;
1456: break;
1457: case 288:
1458: if ((0x3ff000000000000L & l) != 0L)
1459: jjstateSet[jjnewStateCnt++] = 289;
1460: break;
1461: case 290:
1462: if ((0x3ff000000000000L & l) != 0L)
1463: jjstateSet[jjnewStateCnt++] = 291;
1464: break;
1465: case 291:
1466: if ((0x3ff000000000000L & l) != 0L)
1467: jjstateSet[jjnewStateCnt++] = 292;
1468: break;
1469: case 292:
1470: if ((0x3ff000000000000L & l) != 0L)
1471: jjstateSet[jjnewStateCnt++] = 293;
1472: break;
1473: case 295:
1474: if ((0x3ff000000000000L & l) == 0L)
1475: break;
1476: if (kind > 51)
1477: kind = 51;
1478: jjCheckNAddStates(284, 291);
1479: break;
1480: case 296:
1481: if ((0x3ff000000000000L & l) == 0L)
1482: break;
1483: if (kind > 51)
1484: kind = 51;
1485: jjCheckNAddStates(292, 294);
1486: break;
1487: case 297:
1488: case 299:
1489: case 302:
1490: case 306:
1491: if ((0x3ff000000000000L & l) != 0L)
1492: jjCheckNAdd(296);
1493: break;
1494: case 298:
1495: if ((0x3ff000000000000L & l) != 0L)
1496: jjstateSet[jjnewStateCnt++] = 299;
1497: break;
1498: case 300:
1499: if ((0x3ff000000000000L & l) != 0L)
1500: jjstateSet[jjnewStateCnt++] = 301;
1501: break;
1502: case 301:
1503: if ((0x3ff000000000000L & l) != 0L)
1504: jjstateSet[jjnewStateCnt++] = 302;
1505: break;
1506: case 303:
1507: if ((0x3ff000000000000L & l) != 0L)
1508: jjstateSet[jjnewStateCnt++] = 304;
1509: break;
1510: case 304:
1511: if ((0x3ff000000000000L & l) != 0L)
1512: jjstateSet[jjnewStateCnt++] = 305;
1513: break;
1514: case 305:
1515: if ((0x3ff000000000000L & l) != 0L)
1516: jjstateSet[jjnewStateCnt++] = 306;
1517: break;
1518: case 307:
1519: if ((0x3ff000000000000L & l) != 0L)
1520: jjCheckNAddTwoStates(307, 308);
1521: break;
1522: case 308:
1523: if (curChar == 37 && kind > 52)
1524: kind = 52;
1525: break;
1526: case 309:
1527: if ((0x3ff000000000000L & l) == 0L)
1528: break;
1529: if (kind > 53)
1530: kind = 53;
1531: jjCheckNAdd(309);
1532: break;
1533: case 310:
1534: if ((0x3ff000000000000L & l) == 0L)
1535: break;
1536: if (kind > 58)
1537: kind = 58;
1538: jjCheckNAdd(310);
1539: break;
1540: case 311:
1541: if (curChar == 45)
1542: jjAddStates(76, 79);
1543: break;
1544: case 313:
1545: if ((0x3ff200000000000L & l) != 0L)
1546: jjCheckNAddStates(111, 113);
1547: break;
1548: case 314:
1549: if (curChar == 40 && kind > 55)
1550: kind = 55;
1551: break;
1552: case 316:
1553: if ((0xffffffff00000000L & l) != 0L)
1554: jjCheckNAddStates(111, 113);
1555: break;
1556: case 317:
1557: if ((0x3ff000000000000L & l) != 0L)
1558: jjCheckNAddStates(295, 303);
1559: break;
1560: case 318:
1561: if ((0x3ff000000000000L & l) != 0L)
1562: jjCheckNAddStates(304, 307);
1563: break;
1564: case 319:
1565: if ((0x100003600L & l) != 0L)
1566: jjCheckNAddStates(111, 113);
1567: break;
1568: case 320:
1569: case 322:
1570: case 325:
1571: case 329:
1572: if ((0x3ff000000000000L & l) != 0L)
1573: jjCheckNAdd(318);
1574: break;
1575: case 321:
1576: if ((0x3ff000000000000L & l) != 0L)
1577: jjstateSet[jjnewStateCnt++] = 322;
1578: break;
1579: case 323:
1580: if ((0x3ff000000000000L & l) != 0L)
1581: jjstateSet[jjnewStateCnt++] = 324;
1582: break;
1583: case 324:
1584: if ((0x3ff000000000000L & l) != 0L)
1585: jjstateSet[jjnewStateCnt++] = 325;
1586: break;
1587: case 326:
1588: if ((0x3ff000000000000L & l) != 0L)
1589: jjstateSet[jjnewStateCnt++] = 327;
1590: break;
1591: case 327:
1592: if ((0x3ff000000000000L & l) != 0L)
1593: jjstateSet[jjnewStateCnt++] = 328;
1594: break;
1595: case 328:
1596: if ((0x3ff000000000000L & l) != 0L)
1597: jjstateSet[jjnewStateCnt++] = 329;
1598: break;
1599: case 331:
1600: if ((0x3ff200000000000L & l) == 0L)
1601: break;
1602: if (kind > 56)
1603: kind = 56;
1604: jjCheckNAddTwoStates(331, 332);
1605: break;
1606: case 333:
1607: if ((0xffffffff00000000L & l) == 0L)
1608: break;
1609: if (kind > 56)
1610: kind = 56;
1611: jjCheckNAddTwoStates(331, 332);
1612: break;
1613: case 334:
1614: if ((0x3ff000000000000L & l) == 0L)
1615: break;
1616: if (kind > 56)
1617: kind = 56;
1618: jjCheckNAddStates(308, 315);
1619: break;
1620: case 335:
1621: if ((0x3ff000000000000L & l) == 0L)
1622: break;
1623: if (kind > 56)
1624: kind = 56;
1625: jjCheckNAddStates(316, 318);
1626: break;
1627: case 336:
1628: if ((0x100003600L & l) == 0L)
1629: break;
1630: if (kind > 56)
1631: kind = 56;
1632: jjCheckNAddTwoStates(331, 332);
1633: break;
1634: case 337:
1635: case 339:
1636: case 342:
1637: case 346:
1638: if ((0x3ff000000000000L & l) != 0L)
1639: jjCheckNAdd(335);
1640: break;
1641: case 338:
1642: if ((0x3ff000000000000L & l) != 0L)
1643: jjstateSet[jjnewStateCnt++] = 339;
1644: break;
1645: case 340:
1646: if ((0x3ff000000000000L & l) != 0L)
1647: jjstateSet[jjnewStateCnt++] = 341;
1648: break;
1649: case 341:
1650: if ((0x3ff000000000000L & l) != 0L)
1651: jjstateSet[jjnewStateCnt++] = 342;
1652: break;
1653: case 343:
1654: if ((0x3ff000000000000L & l) != 0L)
1655: jjstateSet[jjnewStateCnt++] = 344;
1656: break;
1657: case 344:
1658: if ((0x3ff000000000000L & l) != 0L)
1659: jjstateSet[jjnewStateCnt++] = 345;
1660: break;
1661: case 345:
1662: if ((0x3ff000000000000L & l) != 0L)
1663: jjstateSet[jjnewStateCnt++] = 346;
1664: break;
1665: case 348:
1666: if ((0x3ff000000000000L & l) == 0L)
1667: break;
1668: if (kind > 56)
1669: kind = 56;
1670: jjCheckNAddStates(319, 326);
1671: break;
1672: case 349:
1673: if ((0x3ff000000000000L & l) == 0L)
1674: break;
1675: if (kind > 56)
1676: kind = 56;
1677: jjCheckNAddStates(327, 329);
1678: break;
1679: case 350:
1680: case 352:
1681: case 355:
1682: case 359:
1683: if ((0x3ff000000000000L & l) != 0L)
1684: jjCheckNAdd(349);
1685: break;
1686: case 351:
1687: if ((0x3ff000000000000L & l) != 0L)
1688: jjstateSet[jjnewStateCnt++] = 352;
1689: break;
1690: case 353:
1691: if ((0x3ff000000000000L & l) != 0L)
1692: jjstateSet[jjnewStateCnt++] = 354;
1693: break;
1694: case 354:
1695: if ((0x3ff000000000000L & l) != 0L)
1696: jjstateSet[jjnewStateCnt++] = 355;
1697: break;
1698: case 356:
1699: if ((0x3ff000000000000L & l) != 0L)
1700: jjstateSet[jjnewStateCnt++] = 357;
1701: break;
1702: case 357:
1703: if ((0x3ff000000000000L & l) != 0L)
1704: jjstateSet[jjnewStateCnt++] = 358;
1705: break;
1706: case 358:
1707: if ((0x3ff000000000000L & l) != 0L)
1708: jjstateSet[jjnewStateCnt++] = 359;
1709: break;
1710: case 361:
1711: if ((0x3ff000000000000L & l) != 0L)
1712: jjCheckNAddStates(330, 338);
1713: break;
1714: case 362:
1715: if ((0x3ff000000000000L & l) != 0L)
1716: jjCheckNAddStates(339, 342);
1717: break;
1718: case 363:
1719: case 365:
1720: case 368:
1721: case 372:
1722: if ((0x3ff000000000000L & l) != 0L)
1723: jjCheckNAdd(362);
1724: break;
1725: case 364:
1726: if ((0x3ff000000000000L & l) != 0L)
1727: jjstateSet[jjnewStateCnt++] = 365;
1728: break;
1729: case 366:
1730: if ((0x3ff000000000000L & l) != 0L)
1731: jjstateSet[jjnewStateCnt++] = 367;
1732: break;
1733: case 367:
1734: if ((0x3ff000000000000L & l) != 0L)
1735: jjstateSet[jjnewStateCnt++] = 368;
1736: break;
1737: case 369:
1738: if ((0x3ff000000000000L & l) != 0L)
1739: jjstateSet[jjnewStateCnt++] = 370;
1740: break;
1741: case 370:
1742: if ((0x3ff000000000000L & l) != 0L)
1743: jjstateSet[jjnewStateCnt++] = 371;
1744: break;
1745: case 371:
1746: if ((0x3ff000000000000L & l) != 0L)
1747: jjstateSet[jjnewStateCnt++] = 372;
1748: break;
1749: case 374:
1750: if ((0x3ff000000000000L & l) == 0L)
1751: break;
1752: if (kind > 53)
1753: kind = 53;
1754: jjCheckNAddStates(0, 75);
1755: break;
1756: case 375:
1757: if ((0x3ff000000000000L & l) != 0L)
1758: jjCheckNAddTwoStates(375, 228);
1759: break;
1760: case 376:
1761: if ((0x3ff000000000000L & l) != 0L)
1762: jjCheckNAddTwoStates(376, 377);
1763: break;
1764: case 377:
1765: if (curChar == 46)
1766: jjCheckNAdd(226);
1767: break;
1768: case 378:
1769: if ((0x3ff000000000000L & l) != 0L)
1770: jjCheckNAddTwoStates(378, 231);
1771: break;
1772: case 379:
1773: if ((0x3ff000000000000L & l) != 0L)
1774: jjCheckNAddTwoStates(379, 380);
1775: break;
1776: case 380:
1777: if (curChar == 46)
1778: jjCheckNAdd(229);
1779: break;
1780: case 381:
1781: if ((0x3ff000000000000L & l) != 0L)
1782: jjCheckNAddTwoStates(381, 234);
1783: break;
1784: case 382:
1785: if ((0x3ff000000000000L & l) != 0L)
1786: jjCheckNAddTwoStates(382, 383);
1787: break;
1788: case 383:
1789: if (curChar == 46)
1790: jjCheckNAdd(232);
1791: break;
1792: case 384:
1793: if ((0x3ff000000000000L & l) != 0L)
1794: jjCheckNAddTwoStates(384, 237);
1795: break;
1796: case 385:
1797: if ((0x3ff000000000000L & l) != 0L)
1798: jjCheckNAddTwoStates(385, 386);
1799: break;
1800: case 386:
1801: if (curChar == 46)
1802: jjCheckNAdd(235);
1803: break;
1804: case 387:
1805: if ((0x3ff000000000000L & l) != 0L)
1806: jjCheckNAddTwoStates(387, 240);
1807: break;
1808: case 388:
1809: if ((0x3ff000000000000L & l) != 0L)
1810: jjCheckNAddTwoStates(388, 389);
1811: break;
1812: case 389:
1813: if (curChar == 46)
1814: jjCheckNAdd(238);
1815: break;
1816: case 390:
1817: if ((0x3ff000000000000L & l) != 0L)
1818: jjCheckNAddTwoStates(390, 243);
1819: break;
1820: case 391:
1821: if ((0x3ff000000000000L & l) != 0L)
1822: jjCheckNAddTwoStates(391, 392);
1823: break;
1824: case 392:
1825: if (curChar == 46)
1826: jjCheckNAdd(241);
1827: break;
1828: case 393:
1829: if ((0x3ff000000000000L & l) != 0L)
1830: jjCheckNAddTwoStates(393, 246);
1831: break;
1832: case 394:
1833: if ((0x3ff000000000000L & l) != 0L)
1834: jjCheckNAddTwoStates(394, 395);
1835: break;
1836: case 395:
1837: if (curChar == 46)
1838: jjCheckNAdd(244);
1839: break;
1840: case 396:
1841: if ((0x3ff000000000000L & l) != 0L)
1842: jjCheckNAddTwoStates(396, 249);
1843: break;
1844: case 397:
1845: if ((0x3ff000000000000L & l) != 0L)
1846: jjCheckNAddTwoStates(397, 398);
1847: break;
1848: case 398:
1849: if (curChar == 46)
1850: jjCheckNAdd(247);
1851: break;
1852: case 399:
1853: if ((0x3ff000000000000L & l) != 0L)
1854: jjCheckNAddTwoStates(399, 253);
1855: break;
1856: case 400:
1857: if ((0x3ff000000000000L & l) != 0L)
1858: jjCheckNAddTwoStates(400, 401);
1859: break;
1860: case 401:
1861: if (curChar == 46)
1862: jjCheckNAdd(250);
1863: break;
1864: case 402:
1865: if ((0x3ff000000000000L & l) != 0L)
1866: jjCheckNAddTwoStates(402, 257);
1867: break;
1868: case 403:
1869: if ((0x3ff000000000000L & l) != 0L)
1870: jjCheckNAddTwoStates(403, 404);
1871: break;
1872: case 404:
1873: if (curChar == 46)
1874: jjCheckNAdd(254);
1875: break;
1876: case 405:
1877: if ((0x3ff000000000000L & l) != 0L)
1878: jjCheckNAddTwoStates(405, 262);
1879: break;
1880: case 406:
1881: if ((0x3ff000000000000L & l) != 0L)
1882: jjCheckNAddTwoStates(406, 407);
1883: break;
1884: case 407:
1885: if (curChar == 46)
1886: jjCheckNAdd(258);
1887: break;
1888: case 408:
1889: if ((0x3ff000000000000L & l) != 0L)
1890: jjCheckNAddTwoStates(408, 265);
1891: break;
1892: case 409:
1893: if ((0x3ff000000000000L & l) != 0L)
1894: jjCheckNAddTwoStates(409, 410);
1895: break;
1896: case 410:
1897: if (curChar == 46)
1898: jjCheckNAdd(263);
1899: break;
1900: case 411:
1901: if ((0x3ff000000000000L & l) != 0L)
1902: jjCheckNAddTwoStates(411, 267);
1903: break;
1904: case 412:
1905: if ((0x3ff000000000000L & l) != 0L)
1906: jjCheckNAddTwoStates(412, 413);
1907: break;
1908: case 413:
1909: if (curChar == 46)
1910: jjCheckNAdd(266);
1911: break;
1912: case 414:
1913: if ((0x3ff000000000000L & l) != 0L)
1914: jjCheckNAddTwoStates(414, 270);
1915: break;
1916: case 415:
1917: if ((0x3ff000000000000L & l) != 0L)
1918: jjCheckNAddTwoStates(415, 416);
1919: break;
1920: case 416:
1921: if (curChar == 46)
1922: jjCheckNAdd(268);
1923: break;
1924: case 417:
1925: if ((0x3ff000000000000L & l) != 0L)
1926: jjCheckNAddTwoStates(417, 274);
1927: break;
1928: case 418:
1929: if ((0x3ff000000000000L & l) != 0L)
1930: jjCheckNAddTwoStates(418, 419);
1931: break;
1932: case 419:
1933: if (curChar == 46)
1934: jjCheckNAdd(271);
1935: break;
1936: case 420:
1937: if ((0x3ff000000000000L & l) != 0L)
1938: jjCheckNAddStates(343, 346);
1939: break;
1940: case 421:
1941: if ((0x3ff000000000000L & l) != 0L)
1942: jjCheckNAddTwoStates(421, 422);
1943: break;
1944: case 422:
1945: if (curChar == 46)
1946: jjCheckNAdd(275);
1947: break;
1948: case 423:
1949: if ((0x3ff000000000000L & l) != 0L)
1950: jjCheckNAddTwoStates(423, 308);
1951: break;
1952: case 424:
1953: if ((0x3ff000000000000L & l) != 0L)
1954: jjCheckNAddTwoStates(424, 425);
1955: break;
1956: case 425:
1957: if (curChar == 46)
1958: jjCheckNAdd(307);
1959: break;
1960: case 426:
1961: if ((0x3ff000000000000L & l) == 0L)
1962: break;
1963: if (kind > 53)
1964: kind = 53;
1965: jjCheckNAdd(426);
1966: break;
1967: case 427:
1968: if ((0x3ff000000000000L & l) != 0L)
1969: jjCheckNAddTwoStates(427, 428);
1970: break;
1971: case 428:
1972: if (curChar == 46)
1973: jjCheckNAdd(309);
1974: break;
1975: case 429:
1976: if ((0x3ff000000000000L & l) == 0L)
1977: break;
1978: if (kind > 58)
1979: kind = 58;
1980: jjCheckNAdd(429);
1981: break;
1982: case 430:
1983: if ((0x3ff000000000000L & l) != 0L)
1984: jjCheckNAddTwoStates(430, 431);
1985: break;
1986: case 431:
1987: if (curChar == 46)
1988: jjCheckNAdd(310);
1989: break;
1990: default:
1991: break;
1992: }
1993: } while (i != startsAt);
1994: } else if (curChar < 128) {
1995: long l = 1L << (curChar & 077);
1996: do {
1997: switch (jjstateSet[--i]) {
1998: case 1:
1999: if ((0x7fffffe87fffffeL & l) != 0L) {
2000: if (kind > 56)
2001: kind = 56;
2002: jjCheckNAddStates(347, 351);
2003: } else if (curChar == 92)
2004: jjCheckNAddStates(352, 355);
2005: else if (curChar == 64)
2006: jjAddStates(356, 358);
2007: if ((0x20000000200000L & l) != 0L)
2008: jjAddStates(359, 360);
2009: break;
2010: case 61:
2011: if ((0x7fffffe87fffffeL & l) != 0L) {
2012: if (kind > 33)
2013: kind = 33;
2014: jjCheckNAddTwoStates(63, 64);
2015: } else if (curChar == 92)
2016: jjCheckNAddTwoStates(65, 80);
2017: break;
2018: case 433:
2019: if ((0x7fffffe87fffffeL & l) != 0L) {
2020: if (kind > 56)
2021: kind = 56;
2022: jjCheckNAddTwoStates(331, 332);
2023: } else if (curChar == 92)
2024: jjCheckNAddTwoStates(316, 317);
2025: if ((0x7fffffe87fffffeL & l) != 0L)
2026: jjCheckNAddStates(111, 113);
2027: else if (curChar == 92)
2028: jjCheckNAddTwoStates(333, 334);
2029: break;
2030: case 435:
2031: if ((0x7fffffe87fffffeL & l) != 0L) {
2032: if (kind > 33)
2033: kind = 33;
2034: jjCheckNAddTwoStates(63, 64);
2035: } else if (curChar == 92)
2036: jjCheckNAddTwoStates(65, 66);
2037: break;
2038: case 312:
2039: if ((0x7fffffe87fffffeL & l) != 0L) {
2040: if (kind > 56)
2041: kind = 56;
2042: jjCheckNAddTwoStates(331, 332);
2043: } else if (curChar == 92)
2044: jjCheckNAddTwoStates(316, 361);
2045: if ((0x7fffffe87fffffeL & l) != 0L)
2046: jjCheckNAddStates(111, 113);
2047: else if (curChar == 92)
2048: jjCheckNAddTwoStates(333, 348);
2049: break;
2050: case 2:
2051: if ((0x7fffffe87fffffeL & l) == 0L)
2052: break;
2053: if (kind > 19)
2054: kind = 19;
2055: jjCheckNAddTwoStates(2, 3);
2056: break;
2057: case 3:
2058: if (curChar == 92)
2059: jjAddStates(361, 362);
2060: break;
2061: case 4:
2062: if ((0x7fffffffffffffffL & l) == 0L)
2063: break;
2064: if (kind > 19)
2065: kind = 19;
2066: jjCheckNAddTwoStates(2, 3);
2067: break;
2068: case 5:
2069: if ((0x7e0000007eL & l) == 0L)
2070: break;
2071: if (kind > 19)
2072: kind = 19;
2073: jjCheckNAddStates(114, 121);
2074: break;
2075: case 6:
2076: if ((0x7e0000007eL & l) == 0L)
2077: break;
2078: if (kind > 19)
2079: kind = 19;
2080: jjCheckNAddStates(122, 124);
2081: break;
2082: case 8:
2083: case 10:
2084: case 13:
2085: case 17:
2086: if ((0x7e0000007eL & l) != 0L)
2087: jjCheckNAdd(6);
2088: break;
2089: case 9:
2090: if ((0x7e0000007eL & l) != 0L)
2091: jjstateSet[jjnewStateCnt++] = 10;
2092: break;
2093: case 11:
2094: if ((0x7e0000007eL & l) != 0L)
2095: jjstateSet[jjnewStateCnt++] = 12;
2096: break;
2097: case 12:
2098: if ((0x7e0000007eL & l) != 0L)
2099: jjstateSet[jjnewStateCnt++] = 13;
2100: break;
2101: case 14:
2102: if ((0x7e0000007eL & l) != 0L)
2103: jjstateSet[jjnewStateCnt++] = 15;
2104: break;
2105: case 15:
2106: if ((0x7e0000007eL & l) != 0L)
2107: jjstateSet[jjnewStateCnt++] = 16;
2108: break;
2109: case 16:
2110: if ((0x7e0000007eL & l) != 0L)
2111: jjstateSet[jjnewStateCnt++] = 17;
2112: break;
2113: case 19:
2114: case 25:
2115: if ((0x7fffffffffffffffL & l) != 0L)
2116: jjCheckNAddStates(102, 104);
2117: break;
2118: case 21:
2119: if (curChar == 92)
2120: jjAddStates(363, 366);
2121: break;
2122: case 26:
2123: if ((0x7e0000007eL & l) != 0L)
2124: jjCheckNAddStates(125, 133);
2125: break;
2126: case 27:
2127: if ((0x7e0000007eL & l) != 0L)
2128: jjCheckNAddStates(134, 137);
2129: break;
2130: case 29:
2131: case 31:
2132: case 34:
2133: case 38:
2134: if ((0x7e0000007eL & l) != 0L)
2135: jjCheckNAdd(27);
2136: break;
2137: case 30:
2138: if ((0x7e0000007eL & l) != 0L)
2139: jjstateSet[jjnewStateCnt++] = 31;
2140: break;
2141: case 32:
2142: if ((0x7e0000007eL & l) != 0L)
2143: jjstateSet[jjnewStateCnt++] = 33;
2144: break;
2145: case 33:
2146: if ((0x7e0000007eL & l) != 0L)
2147: jjstateSet[jjnewStateCnt++] = 34;
2148: break;
2149: case 35:
2150: if ((0x7e0000007eL & l) != 0L)
2151: jjstateSet[jjnewStateCnt++] = 36;
2152: break;
2153: case 36:
2154: if ((0x7e0000007eL & l) != 0L)
2155: jjstateSet[jjnewStateCnt++] = 37;
2156: break;
2157: case 37:
2158: if ((0x7e0000007eL & l) != 0L)
2159: jjstateSet[jjnewStateCnt++] = 38;
2160: break;
2161: case 40:
2162: case 46:
2163: if ((0x7fffffffffffffffL & l) != 0L)
2164: jjCheckNAddStates(99, 101);
2165: break;
2166: case 42:
2167: if (curChar == 92)
2168: jjAddStates(367, 370);
2169: break;
2170: case 47:
2171: if ((0x7e0000007eL & l) != 0L)
2172: jjCheckNAddStates(138, 146);
2173: break;
2174: case 48:
2175: if ((0x7e0000007eL & l) != 0L)
2176: jjCheckNAddStates(147, 150);
2177: break;
2178: case 50:
2179: case 52:
2180: case 55:
2181: case 59:
2182: if ((0x7e0000007eL & l) != 0L)
2183: jjCheckNAdd(48);
2184: break;
2185: case 51:
2186: if ((0x7e0000007eL & l) != 0L)
2187: jjstateSet[jjnewStateCnt++] = 52;
2188: break;
2189: case 53:
2190: if ((0x7e0000007eL & l) != 0L)
2191: jjstateSet[jjnewStateCnt++] = 54;
2192: break;
2193: case 54:
2194: if ((0x7e0000007eL & l) != 0L)
2195: jjstateSet[jjnewStateCnt++] = 55;
2196: break;
2197: case 56:
2198: if ((0x7e0000007eL & l) != 0L)
2199: jjstateSet[jjnewStateCnt++] = 57;
2200: break;
2201: case 57:
2202: if ((0x7e0000007eL & l) != 0L)
2203: jjstateSet[jjnewStateCnt++] = 58;
2204: break;
2205: case 58:
2206: if ((0x7e0000007eL & l) != 0L)
2207: jjstateSet[jjnewStateCnt++] = 59;
2208: break;
2209: case 60:
2210: if (curChar == 64)
2211: jjAddStates(356, 358);
2212: break;
2213: case 62:
2214: if ((0x7fffffe87fffffeL & l) == 0L)
2215: break;
2216: if (kind > 33)
2217: kind = 33;
2218: jjCheckNAddTwoStates(63, 64);
2219: break;
2220: case 63:
2221: if ((0x7fffffe87fffffeL & l) == 0L)
2222: break;
2223: if (kind > 33)
2224: kind = 33;
2225: jjCheckNAddTwoStates(63, 64);
2226: break;
2227: case 64:
2228: if (curChar == 92)
2229: jjCheckNAddTwoStates(65, 66);
2230: break;
2231: case 65:
2232: if ((0x7fffffffffffffffL & l) == 0L)
2233: break;
2234: if (kind > 33)
2235: kind = 33;
2236: jjCheckNAddTwoStates(63, 64);
2237: break;
2238: case 66:
2239: if ((0x7e0000007eL & l) == 0L)
2240: break;
2241: if (kind > 33)
2242: kind = 33;
2243: jjCheckNAddStates(151, 158);
2244: break;
2245: case 67:
2246: if ((0x7e0000007eL & l) == 0L)
2247: break;
2248: if (kind > 33)
2249: kind = 33;
2250: jjCheckNAddStates(159, 161);
2251: break;
2252: case 69:
2253: case 71:
2254: case 74:
2255: case 78:
2256: if ((0x7e0000007eL & l) != 0L)
2257: jjCheckNAdd(67);
2258: break;
2259: case 70:
2260: if ((0x7e0000007eL & l) != 0L)
2261: jjstateSet[jjnewStateCnt++] = 71;
2262: break;
2263: case 72:
2264: if ((0x7e0000007eL & l) != 0L)
2265: jjstateSet[jjnewStateCnt++] = 73;
2266: break;
2267: case 73:
2268: if ((0x7e0000007eL & l) != 0L)
2269: jjstateSet[jjnewStateCnt++] = 74;
2270: break;
2271: case 75:
2272: if ((0x7e0000007eL & l) != 0L)
2273: jjstateSet[jjnewStateCnt++] = 76;
2274: break;
2275: case 76:
2276: if ((0x7e0000007eL & l) != 0L)
2277: jjstateSet[jjnewStateCnt++] = 77;
2278: break;
2279: case 77:
2280: if ((0x7e0000007eL & l) != 0L)
2281: jjstateSet[jjnewStateCnt++] = 78;
2282: break;
2283: case 79:
2284: if (curChar == 92)
2285: jjCheckNAddTwoStates(65, 80);
2286: break;
2287: case 80:
2288: if ((0x7e0000007eL & l) == 0L)
2289: break;
2290: if (kind > 33)
2291: kind = 33;
2292: jjCheckNAddStates(162, 169);
2293: break;
2294: case 81:
2295: if ((0x7e0000007eL & l) == 0L)
2296: break;
2297: if (kind > 33)
2298: kind = 33;
2299: jjCheckNAddStates(170, 172);
2300: break;
2301: case 82:
2302: case 84:
2303: case 87:
2304: case 91:
2305: if ((0x7e0000007eL & l) != 0L)
2306: jjCheckNAdd(81);
2307: break;
2308: case 83:
2309: if ((0x7e0000007eL & l) != 0L)
2310: jjstateSet[jjnewStateCnt++] = 84;
2311: break;
2312: case 85:
2313: if ((0x7e0000007eL & l) != 0L)
2314: jjstateSet[jjnewStateCnt++] = 86;
2315: break;
2316: case 86:
2317: if ((0x7e0000007eL & l) != 0L)
2318: jjstateSet[jjnewStateCnt++] = 87;
2319: break;
2320: case 88:
2321: if ((0x7e0000007eL & l) != 0L)
2322: jjstateSet[jjnewStateCnt++] = 89;
2323: break;
2324: case 89:
2325: if ((0x7e0000007eL & l) != 0L)
2326: jjstateSet[jjnewStateCnt++] = 90;
2327: break;
2328: case 90:
2329: if ((0x7e0000007eL & l) != 0L)
2330: jjstateSet[jjnewStateCnt++] = 91;
2331: break;
2332: case 94:
2333: if ((0x10000000100000L & l) != 0L && kind > 34)
2334: kind = 34;
2335: break;
2336: case 95:
2337: if ((0x400000004000L & l) != 0L)
2338: jjstateSet[jjnewStateCnt++] = 94;
2339: break;
2340: case 96:
2341: if ((0x200000002L & l) != 0L)
2342: jjstateSet[jjnewStateCnt++] = 95;
2343: break;
2344: case 97:
2345: if ((0x10000000100000L & l) != 0L)
2346: jjstateSet[jjnewStateCnt++] = 96;
2347: break;
2348: case 98:
2349: if ((0x4000000040000L & l) != 0L)
2350: jjstateSet[jjnewStateCnt++] = 97;
2351: break;
2352: case 99:
2353: if ((0x800000008000L & l) != 0L)
2354: jjstateSet[jjnewStateCnt++] = 98;
2355: break;
2356: case 100:
2357: if ((0x1000000010000L & l) != 0L)
2358: jjstateSet[jjnewStateCnt++] = 99;
2359: break;
2360: case 101:
2361: if ((0x200000002000L & l) != 0L)
2362: jjstateSet[jjnewStateCnt++] = 100;
2363: break;
2364: case 102:
2365: if ((0x20000000200L & l) != 0L)
2366: jjstateSet[jjnewStateCnt++] = 101;
2367: break;
2368: case 103:
2369: if ((0x20000000200000L & l) != 0L)
2370: jjAddStates(359, 360);
2371: break;
2372: case 105:
2373: case 109:
2374: if ((0x7fffffffffffffffL & l) != 0L)
2375: jjCheckNAddStates(179, 182);
2376: break;
2377: case 108:
2378: if (curChar == 92)
2379: jjAddStates(371, 372);
2380: break;
2381: case 110:
2382: if ((0x7e0000007eL & l) != 0L)
2383: jjCheckNAddStates(183, 191);
2384: break;
2385: case 111:
2386: if ((0x7e0000007eL & l) != 0L)
2387: jjCheckNAddStates(192, 195);
2388: break;
2389: case 113:
2390: case 115:
2391: case 118:
2392: case 122:
2393: if ((0x7e0000007eL & l) != 0L)
2394: jjCheckNAdd(111);
2395: break;
2396: case 114:
2397: if ((0x7e0000007eL & l) != 0L)
2398: jjstateSet[jjnewStateCnt++] = 115;
2399: break;
2400: case 116:
2401: if ((0x7e0000007eL & l) != 0L)
2402: jjstateSet[jjnewStateCnt++] = 117;
2403: break;
2404: case 117:
2405: if ((0x7e0000007eL & l) != 0L)
2406: jjstateSet[jjnewStateCnt++] = 118;
2407: break;
2408: case 119:
2409: if ((0x7e0000007eL & l) != 0L)
2410: jjstateSet[jjnewStateCnt++] = 120;
2411: break;
2412: case 120:
2413: if ((0x7e0000007eL & l) != 0L)
2414: jjstateSet[jjnewStateCnt++] = 121;
2415: break;
2416: case 121:
2417: if ((0x7e0000007eL & l) != 0L)
2418: jjstateSet[jjnewStateCnt++] = 122;
2419: break;
2420: case 124:
2421: case 130:
2422: if ((0x7fffffffffffffffL & l) != 0L)
2423: jjCheckNAddStates(196, 198);
2424: break;
2425: case 126:
2426: if (curChar == 92)
2427: jjAddStates(373, 376);
2428: break;
2429: case 131:
2430: if ((0x7e0000007eL & l) != 0L)
2431: jjCheckNAddStates(199, 207);
2432: break;
2433: case 132:
2434: if ((0x7e0000007eL & l) != 0L)
2435: jjCheckNAddStates(208, 211);
2436: break;
2437: case 134:
2438: case 136:
2439: case 139:
2440: case 143:
2441: if ((0x7e0000007eL & l) != 0L)
2442: jjCheckNAdd(132);
2443: break;
2444: case 135:
2445: if ((0x7e0000007eL & l) != 0L)
2446: jjstateSet[jjnewStateCnt++] = 136;
2447: break;
2448: case 137:
2449: if ((0x7e0000007eL & l) != 0L)
2450: jjstateSet[jjnewStateCnt++] = 138;
2451: break;
2452: case 138:
2453: if ((0x7e0000007eL & l) != 0L)
2454: jjstateSet[jjnewStateCnt++] = 139;
2455: break;
2456: case 140:
2457: if ((0x7e0000007eL & l) != 0L)
2458: jjstateSet[jjnewStateCnt++] = 141;
2459: break;
2460: case 141:
2461: if ((0x7e0000007eL & l) != 0L)
2462: jjstateSet[jjnewStateCnt++] = 142;
2463: break;
2464: case 142:
2465: if ((0x7e0000007eL & l) != 0L)
2466: jjstateSet[jjnewStateCnt++] = 143;
2467: break;
2468: case 145:
2469: case 151:
2470: if ((0x7fffffffffffffffL & l) != 0L)
2471: jjCheckNAddStates(212, 214);
2472: break;
2473: case 147:
2474: if (curChar == 92)
2475: jjAddStates(377, 380);
2476: break;
2477: case 152:
2478: if ((0x7e0000007eL & l) != 0L)
2479: jjCheckNAddStates(215, 223);
2480: break;
2481: case 153:
2482: if ((0x7e0000007eL & l) != 0L)
2483: jjCheckNAddStates(224, 227);
2484: break;
2485: case 155:
2486: case 157:
2487: case 160:
2488: case 164:
2489: if ((0x7e0000007eL & l) != 0L)
2490: jjCheckNAdd(153);
2491: break;
2492: case 156:
2493: if ((0x7e0000007eL & l) != 0L)
2494: jjstateSet[jjnewStateCnt++] = 157;
2495: break;
2496: case 158:
2497: if ((0x7e0000007eL & l) != 0L)
2498: jjstateSet[jjnewStateCnt++] = 159;
2499: break;
2500: case 159:
2501: if ((0x7e0000007eL & l) != 0L)
2502: jjstateSet[jjnewStateCnt++] = 160;
2503: break;
2504: case 161:
2505: if ((0x7e0000007eL & l) != 0L)
2506: jjstateSet[jjnewStateCnt++] = 162;
2507: break;
2508: case 162:
2509: if ((0x7e0000007eL & l) != 0L)
2510: jjstateSet[jjnewStateCnt++] = 163;
2511: break;
2512: case 163:
2513: if ((0x7e0000007eL & l) != 0L)
2514: jjstateSet[jjnewStateCnt++] = 164;
2515: break;
2516: case 166:
2517: if ((0x100000001000L & l) != 0L)
2518: jjstateSet[jjnewStateCnt++] = 104;
2519: break;
2520: case 167:
2521: if ((0x4000000040000L & l) != 0L)
2522: jjstateSet[jjnewStateCnt++] = 166;
2523: break;
2524: case 170:
2525: if ((0x7e0000007eL & l) == 0L)
2526: break;
2527: if (kind > 59)
2528: kind = 59;
2529: jjCheckNAddStates(238, 246);
2530: break;
2531: case 171:
2532: if ((0x7e0000007eL & l) != 0L)
2533: jjCheckNAdd(172);
2534: break;
2535: case 173:
2536: if ((0x7e0000007eL & l) == 0L)
2537: break;
2538: if (kind > 59)
2539: kind = 59;
2540: jjCheckNAddStates(247, 251);
2541: break;
2542: case 174:
2543: if ((0x7e0000007eL & l) != 0L && kind > 59)
2544: kind = 59;
2545: break;
2546: case 175:
2547: case 177:
2548: case 180:
2549: case 184:
2550: if ((0x7e0000007eL & l) != 0L)
2551: jjCheckNAdd(174);
2552: break;
2553: case 176:
2554: if ((0x7e0000007eL & l) != 0L)
2555: jjstateSet[jjnewStateCnt++] = 177;
2556: break;
2557: case 178:
2558: if ((0x7e0000007eL & l) != 0L)
2559: jjstateSet[jjnewStateCnt++] = 179;
2560: break;
2561: case 179:
2562: if ((0x7e0000007eL & l) != 0L)
2563: jjstateSet[jjnewStateCnt++] = 180;
2564: break;
2565: case 181:
2566: if ((0x7e0000007eL & l) != 0L)
2567: jjstateSet[jjnewStateCnt++] = 182;
2568: break;
2569: case 182:
2570: if ((0x7e0000007eL & l) != 0L)
2571: jjstateSet[jjnewStateCnt++] = 183;
2572: break;
2573: case 183:
2574: if ((0x7e0000007eL & l) != 0L)
2575: jjstateSet[jjnewStateCnt++] = 184;
2576: break;
2577: case 185:
2578: case 187:
2579: case 190:
2580: case 194:
2581: if ((0x7e0000007eL & l) != 0L)
2582: jjCheckNAdd(171);
2583: break;
2584: case 186:
2585: if ((0x7e0000007eL & l) != 0L)
2586: jjstateSet[jjnewStateCnt++] = 187;
2587: break;
2588: case 188:
2589: if ((0x7e0000007eL & l) != 0L)
2590: jjstateSet[jjnewStateCnt++] = 189;
2591: break;
2592: case 189:
2593: if ((0x7e0000007eL & l) != 0L)
2594: jjstateSet[jjnewStateCnt++] = 190;
2595: break;
2596: case 191:
2597: if ((0x7e0000007eL & l) != 0L)
2598: jjstateSet[jjnewStateCnt++] = 192;
2599: break;
2600: case 192:
2601: if ((0x7e0000007eL & l) != 0L)
2602: jjstateSet[jjnewStateCnt++] = 193;
2603: break;
2604: case 193:
2605: if ((0x7e0000007eL & l) != 0L)
2606: jjstateSet[jjnewStateCnt++] = 194;
2607: break;
2608: case 195:
2609: if ((0x7e0000007eL & l) == 0L)
2610: break;
2611: if (kind > 59)
2612: kind = 59;
2613: jjCheckNAddStates(252, 254);
2614: break;
2615: case 196:
2616: if ((0x7e0000007eL & l) == 0L)
2617: break;
2618: if (kind > 59)
2619: kind = 59;
2620: jjCheckNAddStates(255, 257);
2621: break;
2622: case 197:
2623: if ((0x7e0000007eL & l) == 0L)
2624: break;
2625: if (kind > 59)
2626: kind = 59;
2627: jjCheckNAddStates(258, 260);
2628: break;
2629: case 200:
2630: if ((0x7e0000007eL & l) == 0L)
2631: break;
2632: if (kind > 59)
2633: kind = 59;
2634: jjCheckNAddTwoStates(169, 174);
2635: break;
2636: case 227:
2637: if ((0x200000002000L & l) != 0L && kind > 36)
2638: kind = 36;
2639: break;
2640: case 228:
2641: if ((0x2000000020L & l) != 0L)
2642: jjstateSet[jjnewStateCnt++] = 227;
2643: break;
2644: case 230:
2645: if ((0x100000001000000L & l) != 0L && kind > 37)
2646: kind = 37;
2647: break;
2648: case 231:
2649: if ((0x2000000020L & l) != 0L)
2650: jjstateSet[jjnewStateCnt++] = 230;
2651: break;
2652: case 233:
2653: if ((0x100000001000000L & l) != 0L && kind > 38)
2654: kind = 38;
2655: break;
2656: case 234:
2657: if ((0x1000000010000L & l) != 0L)
2658: jjstateSet[jjnewStateCnt++] = 233;
2659: break;
2660: case 236:
2661: if ((0x200000002000L & l) != 0L && kind > 39)
2662: kind = 39;
2663: break;
2664: case 237:
2665: if ((0x800000008L & l) != 0L)
2666: jjstateSet[jjnewStateCnt++] = 236;
2667: break;
2668: case 239:
2669: if ((0x200000002000L & l) != 0L && kind > 40)
2670: kind = 40;
2671: break;
2672: case 240:
2673: if ((0x200000002000L & l) != 0L)
2674: jjstateSet[jjnewStateCnt++] = 239;
2675: break;
2676: case 242:
2677: if ((0x400000004000L & l) != 0L && kind > 41)
2678: kind = 41;
2679: break;
2680: case 243:
2681: if ((0x20000000200L & l) != 0L)
2682: jjstateSet[jjnewStateCnt++] = 242;
2683: break;
2684: case 245:
2685: if ((0x10000000100000L & l) != 0L && kind > 42)
2686: kind = 42;
2687: break;
2688: case 246:
2689: if ((0x1000000010000L & l) != 0L)
2690: jjstateSet[jjnewStateCnt++] = 245;
2691: break;
2692: case 248:
2693: if ((0x800000008L & l) != 0L && kind > 43)
2694: kind = 43;
2695: break;
2696: case 249:
2697: if ((0x1000000010000L & l) != 0L)
2698: jjstateSet[jjnewStateCnt++] = 248;
2699: break;
2700: case 251:
2701: if ((0x8000000080L & l) != 0L && kind > 44)
2702: kind = 44;
2703: break;
2704: case 252:
2705: if ((0x2000000020L & l) != 0L)
2706: jjstateSet[jjnewStateCnt++] = 251;
2707: break;
2708: case 253:
2709: if ((0x1000000010L & l) != 0L)
2710: jjstateSet[jjnewStateCnt++] = 252;
2711: break;
2712: case 255:
2713: if ((0x1000000010L & l) != 0L && kind > 45)
2714: kind = 45;
2715: break;
2716: case 256:
2717: if ((0x200000002L & l) != 0L)
2718: jjstateSet[jjnewStateCnt++] = 255;
2719: break;
2720: case 257:
2721: if ((0x4000000040000L & l) != 0L)
2722: jjstateSet[jjnewStateCnt++] = 256;
2723: break;
2724: case 259:
2725: if ((0x1000000010L & l) != 0L && kind > 46)
2726: kind = 46;
2727: break;
2728: case 260:
2729: if ((0x200000002L & l) != 0L)
2730: jjstateSet[jjnewStateCnt++] = 259;
2731: break;
2732: case 261:
2733: if ((0x4000000040000L & l) != 0L)
2734: jjstateSet[jjnewStateCnt++] = 260;
2735: break;
2736: case 262:
2737: if ((0x8000000080L & l) != 0L)
2738: jjstateSet[jjnewStateCnt++] = 261;
2739: break;
2740: case 264:
2741: if ((0x8000000080000L & l) != 0L && kind > 47)
2742: kind = 47;
2743: break;
2744: case 265:
2745: if ((0x200000002000L & l) != 0L)
2746: jjstateSet[jjnewStateCnt++] = 264;
2747: break;
2748: case 267:
2749: if ((0x8000000080000L & l) != 0L && kind > 48)
2750: kind = 48;
2751: break;
2752: case 269:
2753: if ((0x400000004000000L & l) != 0L && kind > 49)
2754: kind = 49;
2755: break;
2756: case 270:
2757: if ((0x10000000100L & l) != 0L)
2758: jjstateSet[jjnewStateCnt++] = 269;
2759: break;
2760: case 272:
2761: if ((0x400000004000000L & l) != 0L && kind > 50)
2762: kind = 50;
2763: break;
2764: case 273:
2765: if ((0x10000000100L & l) != 0L)
2766: jjstateSet[jjnewStateCnt++] = 272;
2767: break;
2768: case 274:
2769: if ((0x80000000800L & l) != 0L)
2770: jjstateSet[jjnewStateCnt++] = 273;
2771: break;
2772: case 277:
2773: case 278:
2774: if ((0x7fffffe87fffffeL & l) == 0L)
2775: break;
2776: if (kind > 51)
2777: kind = 51;
2778: jjCheckNAddTwoStates(278, 279);
2779: break;
2780: case 279:
2781: if (curChar == 92)
2782: jjCheckNAddTwoStates(280, 281);
2783: break;
2784: case 280:
2785: if ((0x7fffffffffffffffL & l) == 0L)
2786: break;
2787: if (kind > 51)
2788: kind = 51;
2789: jjCheckNAddTwoStates(278, 279);
2790: break;
2791: case 281:
2792: if ((0x7e0000007eL & l) == 0L)
2793: break;
2794: if (kind > 51)
2795: kind = 51;
2796: jjCheckNAddStates(273, 280);
2797: break;
2798: case 282:
2799: if ((0x7e0000007eL & l) == 0L)
2800: break;
2801: if (kind > 51)
2802: kind = 51;
2803: jjCheckNAddStates(281, 283);
2804: break;
2805: case 284:
2806: case 286:
2807: case 289:
2808: case 293:
2809: if ((0x7e0000007eL & l) != 0L)
2810: jjCheckNAdd(282);
2811: break;
2812: case 285:
2813: if ((0x7e0000007eL & l) != 0L)
2814: jjstateSet[jjnewStateCnt++] = 286;
2815: break;
2816: case 287:
2817: if ((0x7e0000007eL & l) != 0L)
2818: jjstateSet[jjnewStateCnt++] = 288;
2819: break;
2820: case 288:
2821: if ((0x7e0000007eL & l) != 0L)
2822: jjstateSet[jjnewStateCnt++] = 289;
2823: break;
2824: case 290:
2825: if ((0x7e0000007eL & l) != 0L)
2826: jjstateSet[jjnewStateCnt++] = 291;
2827: break;
2828: case 291:
2829: if ((0x7e0000007eL & l) != 0L)
2830: jjstateSet[jjnewStateCnt++] = 292;
2831: break;
2832: case 292:
2833: if ((0x7e0000007eL & l) != 0L)
2834: jjstateSet[jjnewStateCnt++] = 293;
2835: break;
2836: case 294:
2837: if (curChar == 92)
2838: jjCheckNAddTwoStates(280, 295);
2839: break;
2840: case 295:
2841: if ((0x7e0000007eL & l) == 0L)
2842: break;
2843: if (kind > 51)
2844: kind = 51;
2845: jjCheckNAddStates(284, 291);
2846: break;
2847: case 296:
2848: if ((0x7e0000007eL & l) == 0L)
2849: break;
2850: if (kind > 51)
2851: kind = 51;
2852: jjCheckNAddStates(292, 294);
2853: break;
2854: case 297:
2855: case 299:
2856: case 302:
2857: case 306:
2858: if ((0x7e0000007eL & l) != 0L)
2859: jjCheckNAdd(296);
2860: break;
2861: case 298:
2862: if ((0x7e0000007eL & l) != 0L)
2863: jjstateSet[jjnewStateCnt++] = 299;
2864: break;
2865: case 300:
2866: if ((0x7e0000007eL & l) != 0L)
2867: jjstateSet[jjnewStateCnt++] = 301;
2868: break;
2869: case 301:
2870: if ((0x7e0000007eL & l) != 0L)
2871: jjstateSet[jjnewStateCnt++] = 302;
2872: break;
2873: case 303:
2874: if ((0x7e0000007eL & l) != 0L)
2875: jjstateSet[jjnewStateCnt++] = 304;
2876: break;
2877: case 304:
2878: if ((0x7e0000007eL & l) != 0L)
2879: jjstateSet[jjnewStateCnt++] = 305;
2880: break;
2881: case 305:
2882: if ((0x7e0000007eL & l) != 0L)
2883: jjstateSet[jjnewStateCnt++] = 306;
2884: break;
2885: case 313:
2886: if ((0x7fffffe87fffffeL & l) != 0L)
2887: jjCheckNAddStates(111, 113);
2888: break;
2889: case 315:
2890: if (curChar == 92)
2891: jjCheckNAddTwoStates(316, 317);
2892: break;
2893: case 316:
2894: if ((0x7fffffffffffffffL & l) != 0L)
2895: jjCheckNAddStates(111, 113);
2896: break;
2897: case 317:
2898: if ((0x7e0000007eL & l) != 0L)
2899: jjCheckNAddStates(295, 303);
2900: break;
2901: case 318:
2902: if ((0x7e0000007eL & l) != 0L)
2903: jjCheckNAddStates(304, 307);
2904: break;
2905: case 320:
2906: case 322:
2907: case 325:
2908: case 329:
2909: if ((0x7e0000007eL & l) != 0L)
2910: jjCheckNAdd(318);
2911: break;
2912: case 321:
2913: if ((0x7e0000007eL & l) != 0L)
2914: jjstateSet[jjnewStateCnt++] = 322;
2915: break;
2916: case 323:
2917: if ((0x7e0000007eL & l) != 0L)
2918: jjstateSet[jjnewStateCnt++] = 324;
2919: break;
2920: case 324:
2921: if ((0x7e0000007eL & l) != 0L)
2922: jjstateSet[jjnewStateCnt++] = 325;
2923: break;
2924: case 326:
2925: if ((0x7e0000007eL & l) != 0L)
2926: jjstateSet[jjnewStateCnt++] = 327;
2927: break;
2928: case 327:
2929: if ((0x7e0000007eL & l) != 0L)
2930: jjstateSet[jjnewStateCnt++] = 328;
2931: break;
2932: case 328:
2933: if ((0x7e0000007eL & l) != 0L)
2934: jjstateSet[jjnewStateCnt++] = 329;
2935: break;
2936: case 330:
2937: if ((0x7fffffe87fffffeL & l) == 0L)
2938: break;
2939: if (kind > 56)
2940: kind = 56;
2941: jjCheckNAddTwoStates(331, 332);
2942: break;
2943: case 331:
2944: if ((0x7fffffe87fffffeL & l) == 0L)
2945: break;
2946: if (kind > 56)
2947: kind = 56;
2948: jjCheckNAddTwoStates(331, 332);
2949: break;
2950: case 332:
2951: if (curChar == 92)
2952: jjCheckNAddTwoStates(333, 334);
2953: break;
2954: case 333:
2955: if ((0x7fffffffffffffffL & l) == 0L)
2956: break;
2957: if (kind > 56)
2958: kind = 56;
2959: jjCheckNAddTwoStates(331, 332);
2960: break;
2961: case 334:
2962: if ((0x7e0000007eL & l) == 0L)
2963: break;
2964: if (kind > 56)
2965: kind = 56;
2966: jjCheckNAddStates(308, 315);
2967: break;
2968: case 335:
2969: if ((0x7e0000007eL & l) == 0L)
2970: break;
2971: if (kind > 56)
2972: kind = 56;
2973: jjCheckNAddStates(316, 318);
2974: break;
2975: case 337:
2976: case 339:
2977: case 342:
2978: case 346:
2979: if ((0x7e0000007eL & l) != 0L)
2980: jjCheckNAdd(335);
2981: break;
2982: case 338:
2983: if ((0x7e0000007eL & l) != 0L)
2984: jjstateSet[jjnewStateCnt++] = 339;
2985: break;
2986: case 340:
2987: if ((0x7e0000007eL & l) != 0L)
2988: jjstateSet[jjnewStateCnt++] = 341;
2989: break;
2990: case 341:
2991: if ((0x7e0000007eL & l) != 0L)
2992: jjstateSet[jjnewStateCnt++] = 342;
2993: break;
2994: case 343:
2995: if ((0x7e0000007eL & l) != 0L)
2996: jjstateSet[jjnewStateCnt++] = 344;
2997: break;
2998: case 344:
2999: if ((0x7e0000007eL & l) != 0L)
3000: jjstateSet[jjnewStateCnt++] = 345;
3001: break;
3002: case 345:
3003: if ((0x7e0000007eL & l) != 0L)
3004: jjstateSet[jjnewStateCnt++] = 346;
3005: break;
3006: case 347:
3007: if (curChar == 92)
3008: jjCheckNAddTwoStates(333, 348);
3009: break;
3010: case 348:
3011: if ((0x7e0000007eL & l) == 0L)
3012: break;
3013: if (kind > 56)
3014: kind = 56;
3015: jjCheckNAddStates(319, 326);
3016: break;
3017: case 349:
3018: if ((0x7e0000007eL & l) == 0L)
3019: break;
3020: if (kind > 56)
3021: kind = 56;
3022: jjCheckNAddStates(327, 329);
3023: break;
3024: case 350:
3025: case 352:
3026: case 355:
3027: case 359:
3028: if ((0x7e0000007eL & l) != 0L)
3029: jjCheckNAdd(349);
3030: break;
3031: case 351:
3032: if ((0x7e0000007eL & l) != 0L)
3033: jjstateSet[jjnewStateCnt++] = 352;
3034: break;
3035: case 353:
3036: if ((0x7e0000007eL & l) != 0L)
3037: jjstateSet[jjnewStateCnt++] = 354;
3038: break;
3039: case 354:
3040: if ((0x7e0000007eL & l) != 0L)
3041: jjstateSet[jjnewStateCnt++] = 355;
3042: break;
3043: case 356:
3044: if ((0x7e0000007eL & l) != 0L)
3045: jjstateSet[jjnewStateCnt++] = 357;
3046: break;
3047: case 357:
3048: if ((0x7e0000007eL & l) != 0L)
3049: jjstateSet[jjnewStateCnt++] = 358;
3050: break;
3051: case 358:
3052: if ((0x7e0000007eL & l) != 0L)
3053: jjstateSet[jjnewStateCnt++] = 359;
3054: break;
3055: case 360:
3056: if (curChar == 92)
3057: jjCheckNAddTwoStates(316, 361);
3058: break;
3059: case 361:
3060: if ((0x7e0000007eL & l) != 0L)
3061: jjCheckNAddStates(330, 338);
3062: break;
3063: case 362:
3064: if ((0x7e0000007eL & l) != 0L)
3065: jjCheckNAddStates(339, 342);
3066: break;
3067: case 363:
3068: case 365:
3069: case 368:
3070: case 372:
3071: if ((0x7e0000007eL & l) != 0L)
3072: jjCheckNAdd(362);
3073: break;
3074: case 364:
3075: if ((0x7e0000007eL & l) != 0L)
3076: jjstateSet[jjnewStateCnt++] = 365;
3077: break;
3078: case 366:
3079: if ((0x7e0000007eL & l) != 0L)
3080: jjstateSet[jjnewStateCnt++] = 367;
3081: break;
3082: case 367:
3083: if ((0x7e0000007eL & l) != 0L)
3084: jjstateSet[jjnewStateCnt++] = 368;
3085: break;
3086: case 369:
3087: if ((0x7e0000007eL & l) != 0L)
3088: jjstateSet[jjnewStateCnt++] = 370;
3089: break;
3090: case 370:
3091: if ((0x7e0000007eL & l) != 0L)
3092: jjstateSet[jjnewStateCnt++] = 371;
3093: break;
3094: case 371:
3095: if ((0x7e0000007eL & l) != 0L)
3096: jjstateSet[jjnewStateCnt++] = 372;
3097: break;
3098: case 373:
3099: if ((0x7fffffe87fffffeL & l) == 0L)
3100: break;
3101: if (kind > 56)
3102: kind = 56;
3103: jjCheckNAddStates(347, 351);
3104: break;
3105: case 432:
3106: if (curChar == 92)
3107: jjCheckNAddStates(352, 355);
3108: break;
3109: default:
3110: break;
3111: }
3112: } while (i != startsAt);
3113: } else {
3114: int i2 = (curChar & 0xff) >> 6;
3115: long l2 = 1L << (curChar & 077);
3116: do {
3117: switch (jjstateSet[--i]) {
3118: case 1:
3119: if ((jjbitVec2[i2] & l2) == 0L)
3120: break;
3121: if (kind > 56)
3122: kind = 56;
3123: jjCheckNAddStates(347, 351);
3124: break;
3125: case 61:
3126: case 62:
3127: case 65:
3128: if ((jjbitVec2[i2] & l2) == 0L)
3129: break;
3130: if (kind > 33)
3131: kind = 33;
3132: jjCheckNAddTwoStates(63, 64);
3133: break;
3134: case 433:
3135: if ((jjbitVec2[i2] & l2) != 0L)
3136: jjCheckNAddStates(111, 113);
3137: if ((jjbitVec2[i2] & l2) != 0L) {
3138: if (kind > 56)
3139: kind = 56;
3140: jjCheckNAddTwoStates(331, 332);
3141: }
3142: break;
3143: case 435:
3144: case 63:
3145: if ((jjbitVec2[i2] & l2) == 0L)
3146: break;
3147: if (kind > 33)
3148: kind = 33;
3149: jjCheckNAddTwoStates(63, 64);
3150: break;
3151: case 312:
3152: if ((jjbitVec2[i2] & l2) != 0L)
3153: jjCheckNAddStates(111, 113);
3154: if ((jjbitVec2[i2] & l2) != 0L) {
3155: if (kind > 56)
3156: kind = 56;
3157: jjCheckNAddTwoStates(331, 332);
3158: }
3159: break;
3160: case 2:
3161: case 4:
3162: if ((jjbitVec2[i2] & l2) == 0L)
3163: break;
3164: if (kind > 19)
3165: kind = 19;
3166: jjCheckNAddTwoStates(2, 3);
3167: break;
3168: case 19:
3169: case 25:
3170: if ((jjbitVec2[i2] & l2) != 0L)
3171: jjCheckNAddStates(102, 104);
3172: break;
3173: case 40:
3174: case 46:
3175: if ((jjbitVec2[i2] & l2) != 0L)
3176: jjCheckNAddStates(99, 101);
3177: break;
3178: case 105:
3179: case 109:
3180: if ((jjbitVec2[i2] & l2) != 0L)
3181: jjCheckNAddStates(179, 182);
3182: break;
3183: case 124:
3184: case 130:
3185: if ((jjbitVec2[i2] & l2) != 0L)
3186: jjCheckNAddStates(196, 198);
3187: break;
3188: case 145:
3189: case 151:
3190: if ((jjbitVec2[i2] & l2) != 0L)
3191: jjCheckNAddStates(212, 214);
3192: break;
3193: case 277:
3194: case 278:
3195: case 280:
3196: if ((jjbitVec2[i2] & l2) == 0L)
3197: break;
3198: if (kind > 51)
3199: kind = 51;
3200: jjCheckNAddTwoStates(278, 279);
3201: break;
3202: case 313:
3203: case 316:
3204: if ((jjbitVec2[i2] & l2) != 0L)
3205: jjCheckNAddStates(111, 113);
3206: break;
3207: case 330:
3208: case 333:
3209: if ((jjbitVec2[i2] & l2) == 0L)
3210: break;
3211: if (kind > 56)
3212: kind = 56;
3213: jjCheckNAddTwoStates(331, 332);
3214: break;
3215: case 331:
3216: if ((jjbitVec2[i2] & l2) == 0L)
3217: break;
3218: if (kind > 56)
3219: kind = 56;
3220: jjCheckNAddTwoStates(331, 332);
3221: break;
3222: default:
3223: break;
3224: }
3225: } while (i != startsAt);
3226: }
3227: if (kind != 0x7fffffff) {
3228: jjmatchedKind = kind;
3229: jjmatchedPos = curPos;
3230: kind = 0x7fffffff;
3231: }
3232: ++curPos;
3233: if ((i = jjnewStateCnt) == (startsAt = 433 - (jjnewStateCnt = startsAt)))
3234: return curPos;
3235: try {
3236: curChar = input_stream.readChar();
3237: } catch (java.io.IOException e) {
3238: return curPos;
3239: }
3240: }
3241: }
3242:
3243: private int jjMoveStringLiteralDfa0_1() {
3244: switch (curChar) {
3245: case 42:
3246: return jjMoveStringLiteralDfa1_1(0x8L);
3247: default:
3248: return 1;
3249: }
3250: }
3251:
3252: private int jjMoveStringLiteralDfa1_1(long active0) {
3253: try {
3254: curChar = input_stream.readChar();
3255: } catch (java.io.IOException e) {
3256: return 1;
3257: }
3258: switch (curChar) {
3259: case 47:
3260: if ((active0 & 0x8L) != 0L)
3261: return jjStopAtPos(1, 3);
3262: break;
3263: default:
3264: return 2;
3265: }
3266: return 2;
3267: }
3268:
3269: static final int[] jjnextStates = { 375, 376, 377, 228, 378, 379,
3270: 380, 231, 381, 382, 383, 234, 384, 385, 386, 237, 387, 388,
3271: 389, 240, 390, 391, 392, 243, 393, 394, 395, 246, 396, 397,
3272: 398, 249, 399, 400, 401, 253, 402, 403, 404, 257, 405, 406,
3273: 407, 262, 408, 409, 410, 265, 411, 412, 413, 267, 414, 415,
3274: 416, 270, 417, 418, 419, 274, 420, 421, 422, 276, 277, 423,
3275: 424, 425, 308, 426, 427, 428, 429, 430, 431, 294, 312, 330,
3276: 347, 360, 226, 229, 232, 235, 238, 241, 244, 247, 250, 254,
3277: 258, 263, 266, 268, 271, 275, 307, 309, 310, 40, 41, 42,
3278: 19, 20, 21, 275, 276, 277, 294, 62, 79, 313, 314, 315, 2,
3279: 6, 8, 9, 11, 14, 7, 3, 2, 7, 3, 19, 27, 29, 30, 32, 35, 28,
3280: 20, 21, 19, 28, 20, 21, 40, 48, 50, 51, 53, 56, 49, 41, 42,
3281: 40, 49, 41, 42, 63, 67, 69, 70, 72, 75, 68, 64, 63, 68, 64,
3282: 81, 82, 83, 85, 88, 68, 63, 64, 68, 63, 64, 105, 123, 144,
3283: 107, 108, 165, 105, 106, 107, 108, 105, 111, 113, 114, 116,
3284: 119, 107, 108, 112, 105, 107, 108, 112, 124, 125, 126, 124,
3285: 132, 134, 135, 137, 140, 133, 125, 126, 124, 133, 125, 126,
3286: 145, 146, 147, 145, 153, 155, 156, 158, 161, 154, 146, 147,
3287: 145, 154, 146, 147, 105, 123, 144, 106, 107, 108, 165, 169,
3288: 170, 214, 171, 185, 186, 188, 191, 172, 169, 195, 207, 174,
3289: 175, 176, 178, 181, 169, 196, 203, 169, 197, 201, 169, 199,
3290: 200, 198, 204, 206, 198, 208, 210, 213, 218, 221, 223, 224,
3291: 198, 278, 282, 284, 285, 287, 290, 283, 279, 278, 283, 279,
3292: 296, 297, 298, 300, 303, 283, 278, 279, 283, 278, 279, 313,
3293: 318, 320, 321, 323, 326, 319, 314, 315, 313, 319, 314, 315,
3294: 331, 335, 337, 338, 340, 343, 336, 332, 331, 336, 332, 349,
3295: 350, 351, 353, 356, 336, 331, 332, 336, 331, 332, 362, 363,
3296: 364, 366, 369, 319, 313, 314, 315, 319, 313, 314, 315, 420,
3297: 276, 277, 294, 313, 314, 331, 332, 315, 316, 333, 348, 361,
3298: 61, 62, 79, 167, 168, 4, 5, 22, 24, 25, 26, 43, 45, 46, 47,
3299: 109, 110, 127, 129, 130, 131, 148, 150, 151, 152, };
3300:
3301: /** Token literal values. */
3302: public static final String[] jjstrLiteralImages = { "", null, null,
3303: null, null, "\173", "\175", "\54", "\56", "\73", "\72",
3304: "\52", "\57", "\53", "\55", "\75", "\76", "\133", "\135",
3305: null, null, "\51", null, null, "\74\41\55\55", "\55\55\76",
3306: "\176\75", "\174\75", null, null, null, null, null, null,
3307: null, null, null, null, null, null, null, null, null, null,
3308: null, null, null, null, null, null, null, null, null, null,
3309: null, null, null, null, null, null, null, null, null, null,
3310: null, null, null, null, null, null, null, null, null, null,
3311: null, null, null, null, };
3312:
3313: /** Lexer state names. */
3314: public static final String[] lexStateNames = { "DEFAULT",
3315: "COMMENT", };
3316:
3317: /** Lex State array. */
3318: public static final int[] jjnewLexState = { -1, -1, 1, 0, -1, -1,
3319: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3320: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3321: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3322: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3323: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, };
3324: static final long[] jjtoToken = { 0xdffffffffbfffe3L, 0x2000L, };
3325: static final long[] jjtoSkip = { 0x8L, 0x0L, };
3326: static final long[] jjtoMore = { 0x14L, 0x0L, };
3327: protected CharStream input_stream;
3328: private final int[] jjrounds = new int[433];
3329: private final int[] jjstateSet = new int[866];
3330: private final StringBuffer image = new StringBuffer();
3331: private int jjimageLen;
3332: private int lengthOfMatch;
3333: protected char curChar;
3334:
3335: /** Constructor. */
3336: public CSSParserTokenManager(CharStream stream) {
3337: input_stream = stream;
3338: }
3339:
3340: /** Constructor. */
3341: public CSSParserTokenManager(CharStream stream, int lexState) {
3342: this (stream);
3343: SwitchTo(lexState);
3344: }
3345:
3346: /** Reinitialise parser. */
3347: public void ReInit(CharStream stream) {
3348: jjmatchedPos = jjnewStateCnt = 0;
3349: curLexState = defaultLexState;
3350: input_stream = stream;
3351: ReInitRounds();
3352: }
3353:
3354: private void ReInitRounds() {
3355: int i;
3356: jjround = 0x80000001;
3357: for (i = 433; i-- > 0;)
3358: jjrounds[i] = 0x80000000;
3359: }
3360:
3361: /** Reinitialise parser. */
3362: public void ReInit(CharStream stream, int lexState) {
3363: ReInit(stream);
3364: SwitchTo(lexState);
3365: }
3366:
3367: /** Switch to specified lex state. */
3368: public void SwitchTo(int lexState) {
3369: if (lexState >= 2 || lexState < 0)
3370: throw new TokenMgrError(
3371: "Error: Ignoring invalid lexical state : "
3372: + lexState + ". State unchanged.",
3373: TokenMgrError.INVALID_LEXICAL_STATE);
3374: else
3375: curLexState = lexState;
3376: }
3377:
3378: protected Token jjFillToken() {
3379: final Token t;
3380: final String tokenImage;
3381: final int beginLine;
3382: final int endLine;
3383: final int beginColumn;
3384: final int endColumn;
3385: String im = jjstrLiteralImages[jjmatchedKind];
3386: tokenImage = (im == null) ? input_stream.GetImage() : im;
3387: beginLine = input_stream.getBeginLine();
3388: beginColumn = input_stream.getBeginColumn();
3389: endLine = input_stream.getEndLine();
3390: endColumn = input_stream.getEndColumn();
3391: t = Token.newToken(jjmatchedKind, tokenImage);
3392: t.offset = input_stream.offset();
3393: t.beginLine = beginLine;
3394: t.endLine = endLine;
3395: t.beginColumn = beginColumn;
3396: t.endColumn = endColumn;
3397:
3398: return t;
3399: }
3400:
3401: int curLexState = 0;
3402: int defaultLexState = 0;
3403: int jjnewStateCnt;
3404: int jjround;
3405: int jjmatchedPos;
3406: int jjmatchedKind;
3407:
3408: /** Get the next Token. */
3409: public Token getNextToken() {
3410: Token matchedToken;
3411: int curPos = 0;
3412:
3413: EOFLoop: for (;;) {
3414: try {
3415: curChar = input_stream.BeginToken();
3416: } catch (java.io.IOException e) {
3417: jjmatchedKind = 0;
3418: matchedToken = jjFillToken();
3419: return matchedToken;
3420: }
3421: image.setLength(0);
3422: jjimageLen = 0;
3423:
3424: for (;;) {
3425: switch (curLexState) {
3426: case 0:
3427: jjmatchedKind = 0x7fffffff;
3428: jjmatchedPos = 0;
3429: curPos = jjMoveStringLiteralDfa0_0();
3430: if (jjmatchedPos == 0 && jjmatchedKind > 77) {
3431: jjmatchedKind = 77;
3432: }
3433: break;
3434: case 1:
3435: jjmatchedKind = 0x7fffffff;
3436: jjmatchedPos = 0;
3437: curPos = jjMoveStringLiteralDfa0_1();
3438: if (jjmatchedPos == 0 && jjmatchedKind > 4) {
3439: jjmatchedKind = 4;
3440: }
3441: break;
3442: }
3443: if (jjmatchedKind != 0x7fffffff) {
3444: if (jjmatchedPos + 1 < curPos)
3445: input_stream.backup(curPos - jjmatchedPos - 1);
3446: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
3447: matchedToken = jjFillToken();
3448: TokenLexicalActions(matchedToken);
3449: if (jjnewLexState[jjmatchedKind] != -1)
3450: curLexState = jjnewLexState[jjmatchedKind];
3451: return matchedToken;
3452: } else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
3453: if (jjnewLexState[jjmatchedKind] != -1)
3454: curLexState = jjnewLexState[jjmatchedKind];
3455: continue EOFLoop;
3456: }
3457: jjimageLen += jjmatchedPos + 1;
3458: if (jjnewLexState[jjmatchedKind] != -1)
3459: curLexState = jjnewLexState[jjmatchedKind];
3460: curPos = 0;
3461: jjmatchedKind = 0x7fffffff;
3462: try {
3463: curChar = input_stream.readChar();
3464: continue;
3465: } catch (java.io.IOException e1) {
3466: }
3467: }
3468: int error_line = input_stream.getEndLine();
3469: int error_column = input_stream.getEndColumn();
3470: String error_after = null;
3471: boolean EOFSeen = false;
3472: try {
3473: input_stream.readChar();
3474: input_stream.backup(1);
3475: } catch (java.io.IOException e1) {
3476: EOFSeen = true;
3477: error_after = curPos <= 1 ? "" : input_stream
3478: .GetImage();
3479: if (curChar == '\n' || curChar == '\r') {
3480: error_line++;
3481: error_column = 0;
3482: } else
3483: error_column++;
3484: }
3485: if (!EOFSeen) {
3486: input_stream.backup(1);
3487: error_after = curPos <= 1 ? "" : input_stream
3488: .GetImage();
3489: }
3490: throw new TokenMgrError(EOFSeen, curLexState,
3491: error_line, error_column, error_after, curChar,
3492: TokenMgrError.LEXICAL_ERROR);
3493: }
3494: }
3495: }
3496:
3497: void TokenLexicalActions(Token matchedToken) {
3498: switch (jjmatchedKind) {
3499: case 77:
3500: image.append(input_stream.GetSuffix(jjimageLen
3501: + (lengthOfMatch = jjmatchedPos + 1)));
3502: System.err.println("Illegal character : "
3503: + image.toString());
3504: break;
3505: default:
3506: break;
3507: }
3508: }
3509:
3510: private void jjCheckNAdd(int state) {
3511: if (jjrounds[state] != jjround) {
3512: jjstateSet[jjnewStateCnt++] = state;
3513: jjrounds[state] = jjround;
3514: }
3515: }
3516:
3517: private void jjAddStates(int start, int end) {
3518: do {
3519: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
3520: } while (start++ != end);
3521: }
3522:
3523: private void jjCheckNAddTwoStates(int state1, int state2) {
3524: jjCheckNAdd(state1);
3525: jjCheckNAdd(state2);
3526: }
3527:
3528: private void jjCheckNAddStates(int start, int end) {
3529: do {
3530: jjCheckNAdd(jjnextStates[start]);
3531: } while (start++ != end);
3532: }
3533:
3534: }
|