0001: /* Generated By:JJTree&JavaCC: Do not edit this line. CSSParserTokenManager.java */
0002: package jaxx.css;
0003:
0004: public class CSSParserTokenManager implements CSSParserConstants {
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: switch (pos) {
0013: default:
0014: return -1;
0015: }
0016: }
0017:
0018: private final int jjStartNfa_0(int pos, long active0) {
0019: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0),
0020: pos + 1);
0021: }
0022:
0023: private final int jjStopAtPos(int pos, int kind) {
0024: jjmatchedKind = kind;
0025: jjmatchedPos = pos;
0026: return pos + 1;
0027: }
0028:
0029: private final int jjStartNfaWithStates_0(int pos, int kind,
0030: int state) {
0031: jjmatchedKind = kind;
0032: jjmatchedPos = pos;
0033: try {
0034: curChar = input_stream.readChar();
0035: } catch (java.io.IOException e) {
0036: return pos + 1;
0037: }
0038: return jjMoveNfa_0(state, pos + 1);
0039: }
0040:
0041: private final int jjMoveStringLiteralDfa0_0() {
0042: switch (curChar) {
0043: case 35:
0044: return jjStopAtPos(0, 30);
0045: case 42:
0046: return jjStopAtPos(0, 29);
0047: case 44:
0048: return jjStopAtPos(0, 28);
0049: case 46:
0050: return jjStopAtPos(0, 31);
0051: case 58:
0052: return jjStopAtPos(0, 13);
0053: case 59:
0054: return jjStopAtPos(0, 15);
0055: case 61:
0056: return jjStopAtPos(0, 34);
0057: case 91:
0058: return jjStopAtPos(0, 32);
0059: case 93:
0060: return jjStopAtPos(0, 33);
0061: case 123:
0062: return jjStopAtPos(0, 16);
0063: default:
0064: return jjMoveNfa_0(3, 0);
0065: }
0066: }
0067:
0068: private final void jjCheckNAdd(int state) {
0069: if (jjrounds[state] != jjround) {
0070: jjstateSet[jjnewStateCnt++] = state;
0071: jjrounds[state] = jjround;
0072: }
0073: }
0074:
0075: private final void jjAddStates(int start, int end) {
0076: do {
0077: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0078: } while (start++ != end);
0079: }
0080:
0081: private final void jjCheckNAddTwoStates(int state1, int state2) {
0082: jjCheckNAdd(state1);
0083: jjCheckNAdd(state2);
0084: }
0085:
0086: private final void jjCheckNAddStates(int start, int end) {
0087: do {
0088: jjCheckNAdd(jjnextStates[start]);
0089: } while (start++ != end);
0090: }
0091:
0092: private final void jjCheckNAddStates(int start) {
0093: jjCheckNAdd(jjnextStates[start]);
0094: jjCheckNAdd(jjnextStates[start + 1]);
0095: }
0096:
0097: static final long[] jjbitVec0 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0098: 0xffffffffffffffffL };
0099:
0100: private final int jjMoveNfa_0(int startState, int curPos) {
0101: int[] nextStates;
0102: int startsAt = 0;
0103: jjnewStateCnt = 17;
0104: int i = 1;
0105: jjstateSet[0] = startState;
0106: int j, kind = 0x7fffffff;
0107: for (;;) {
0108: if (++jjround == 0x7fffffff)
0109: ReInitRounds();
0110: if (curChar < 64) {
0111: long l = 1L << curChar;
0112: MatchLoop: do {
0113: switch (jjstateSet[--i]) {
0114: case 3:
0115: if ((0x3ff000000000000L & l) != 0L) {
0116: if (kind > 7)
0117: kind = 7;
0118: jjCheckNAddTwoStates(0, 1);
0119: } else if (curChar == 47)
0120: jjAddStates(0, 1);
0121: else if (curChar == 45) {
0122: if (kind > 9)
0123: kind = 9;
0124: jjCheckNAdd(4);
0125: }
0126: break;
0127: case 0:
0128: if ((0x3ff000000000000L & l) == 0L)
0129: break;
0130: if (kind > 7)
0131: kind = 7;
0132: jjCheckNAddTwoStates(0, 1);
0133: break;
0134: case 1:
0135: if (curChar == 46)
0136: jjCheckNAdd(2);
0137: break;
0138: case 2:
0139: if ((0x3ff000000000000L & l) == 0L)
0140: break;
0141: if (kind > 7)
0142: kind = 7;
0143: jjCheckNAdd(2);
0144: break;
0145: case 4:
0146: if ((0x3ff200000000000L & l) == 0L)
0147: break;
0148: if (kind > 9)
0149: kind = 9;
0150: jjCheckNAdd(4);
0151: break;
0152: case 5:
0153: if (curChar == 47)
0154: jjAddStates(0, 1);
0155: break;
0156: case 6:
0157: if (curChar == 47)
0158: jjCheckNAddStates(2, 4);
0159: break;
0160: case 7:
0161: if ((0xffffffffffffdbffL & l) != 0L)
0162: jjCheckNAddStates(2, 4);
0163: break;
0164: case 8:
0165: if ((0x2400L & l) != 0L && kind > 5)
0166: kind = 5;
0167: break;
0168: case 9:
0169: if (curChar == 10 && kind > 5)
0170: kind = 5;
0171: break;
0172: case 10:
0173: if (curChar == 13)
0174: jjstateSet[jjnewStateCnt++] = 9;
0175: break;
0176: case 11:
0177: if (curChar == 42)
0178: jjCheckNAddTwoStates(12, 13);
0179: break;
0180: case 12:
0181: if ((0xfffffbffffffffffL & l) != 0L)
0182: jjCheckNAddTwoStates(12, 13);
0183: break;
0184: case 13:
0185: if (curChar == 42)
0186: jjAddStates(5, 6);
0187: break;
0188: case 14:
0189: if ((0xffff7fffffffffffL & l) != 0L)
0190: jjCheckNAddTwoStates(15, 13);
0191: break;
0192: case 15:
0193: if ((0xfffffbffffffffffL & l) != 0L)
0194: jjCheckNAddTwoStates(15, 13);
0195: break;
0196: case 16:
0197: if (curChar == 47 && kind > 6)
0198: kind = 6;
0199: break;
0200: default:
0201: break;
0202: }
0203: } while (i != startsAt);
0204: } else if (curChar < 128) {
0205: long l = 1L << (curChar & 077);
0206: MatchLoop: do {
0207: switch (jjstateSet[--i]) {
0208: case 3:
0209: case 4:
0210: if ((0x7fffffe87fffffeL & l) == 0L)
0211: break;
0212: if (kind > 9)
0213: kind = 9;
0214: jjCheckNAdd(4);
0215: break;
0216: case 7:
0217: jjAddStates(2, 4);
0218: break;
0219: case 12:
0220: jjCheckNAddTwoStates(12, 13);
0221: break;
0222: case 14:
0223: case 15:
0224: jjCheckNAddTwoStates(15, 13);
0225: break;
0226: default:
0227: break;
0228: }
0229: } while (i != startsAt);
0230: } else {
0231: int i2 = (curChar & 0xff) >> 6;
0232: long l2 = 1L << (curChar & 077);
0233: MatchLoop: do {
0234: switch (jjstateSet[--i]) {
0235: case 7:
0236: if ((jjbitVec0[i2] & l2) != 0L)
0237: jjAddStates(2, 4);
0238: break;
0239: case 12:
0240: if ((jjbitVec0[i2] & l2) != 0L)
0241: jjCheckNAddTwoStates(12, 13);
0242: break;
0243: case 14:
0244: case 15:
0245: if ((jjbitVec0[i2] & l2) != 0L)
0246: jjCheckNAddTwoStates(15, 13);
0247: break;
0248: default:
0249: break;
0250: }
0251: } while (i != startsAt);
0252: }
0253: if (kind != 0x7fffffff) {
0254: jjmatchedKind = kind;
0255: jjmatchedPos = curPos;
0256: kind = 0x7fffffff;
0257: }
0258: ++curPos;
0259: if ((i = jjnewStateCnt) == (startsAt = 17 - (jjnewStateCnt = startsAt)))
0260: return curPos;
0261: try {
0262: curChar = input_stream.readChar();
0263: } catch (java.io.IOException e) {
0264: return curPos;
0265: }
0266: }
0267: }
0268:
0269: private final int jjStopStringLiteralDfa_3(int pos, long active0) {
0270: switch (pos) {
0271: default:
0272: return -1;
0273: }
0274: }
0275:
0276: private final int jjStartNfa_3(int pos, long active0) {
0277: return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0),
0278: pos + 1);
0279: }
0280:
0281: private final int jjStartNfaWithStates_3(int pos, int kind,
0282: int state) {
0283: jjmatchedKind = kind;
0284: jjmatchedPos = pos;
0285: try {
0286: curChar = input_stream.readChar();
0287: } catch (java.io.IOException e) {
0288: return pos + 1;
0289: }
0290: return jjMoveNfa_3(state, pos + 1);
0291: }
0292:
0293: private final int jjMoveStringLiteralDfa0_3() {
0294: switch (curChar) {
0295: case 59:
0296: return jjStopAtPos(0, 15);
0297: default:
0298: return jjMoveNfa_3(3, 0);
0299: }
0300: }
0301:
0302: private final int jjMoveNfa_3(int startState, int curPos) {
0303: int[] nextStates;
0304: int startsAt = 0;
0305: jjnewStateCnt = 8;
0306: int i = 1;
0307: jjstateSet[0] = startState;
0308: int j, kind = 0x7fffffff;
0309: for (;;) {
0310: if (++jjround == 0x7fffffff)
0311: ReInitRounds();
0312: if (curChar < 64) {
0313: long l = 1L << curChar;
0314: MatchLoop: do {
0315: switch (jjstateSet[--i]) {
0316: case 3:
0317: if ((0x3ff000000000000L & l) != 0L) {
0318: if (kind > 7)
0319: kind = 7;
0320: jjCheckNAddTwoStates(0, 1);
0321: } else if (curChar == 45) {
0322: if (kind > 12)
0323: kind = 12;
0324: jjCheckNAdd(4);
0325: }
0326: break;
0327: case 0:
0328: if ((0x3ff000000000000L & l) == 0L)
0329: break;
0330: if (kind > 7)
0331: kind = 7;
0332: jjCheckNAddTwoStates(0, 1);
0333: break;
0334: case 1:
0335: if (curChar == 46)
0336: jjCheckNAdd(2);
0337: break;
0338: case 2:
0339: if ((0x3ff000000000000L & l) == 0L)
0340: break;
0341: if (kind > 7)
0342: kind = 7;
0343: jjCheckNAdd(2);
0344: break;
0345: case 4:
0346: if ((0x3ff200000000000L & l) == 0L)
0347: break;
0348: if (kind > 12)
0349: kind = 12;
0350: jjCheckNAdd(4);
0351: break;
0352: case 6:
0353: jjAddStates(7, 8);
0354: break;
0355: default:
0356: break;
0357: }
0358: } while (i != startsAt);
0359: } else if (curChar < 128) {
0360: long l = 1L << (curChar & 077);
0361: MatchLoop: do {
0362: switch (jjstateSet[--i]) {
0363: case 3:
0364: if ((0x7fffffe87fffffeL & l) != 0L) {
0365: if (kind > 12)
0366: kind = 12;
0367: jjCheckNAdd(4);
0368: } else if (curChar == 123)
0369: jjCheckNAdd(6);
0370: break;
0371: case 4:
0372: if ((0x7fffffe87fffffeL & l) == 0L)
0373: break;
0374: if (kind > 12)
0375: kind = 12;
0376: jjCheckNAdd(4);
0377: break;
0378: case 5:
0379: if (curChar == 123)
0380: jjCheckNAdd(6);
0381: break;
0382: case 6:
0383: if ((0xdfffffffffffffffL & l) != 0L)
0384: jjCheckNAddTwoStates(6, 7);
0385: break;
0386: case 7:
0387: if (curChar == 125)
0388: kind = 21;
0389: break;
0390: default:
0391: break;
0392: }
0393: } while (i != startsAt);
0394: } else {
0395: int i2 = (curChar & 0xff) >> 6;
0396: long l2 = 1L << (curChar & 077);
0397: MatchLoop: do {
0398: switch (jjstateSet[--i]) {
0399: case 6:
0400: if ((jjbitVec0[i2] & l2) != 0L)
0401: jjAddStates(7, 8);
0402: break;
0403: default:
0404: break;
0405: }
0406: } while (i != startsAt);
0407: }
0408: if (kind != 0x7fffffff) {
0409: jjmatchedKind = kind;
0410: jjmatchedPos = curPos;
0411: kind = 0x7fffffff;
0412: }
0413: ++curPos;
0414: if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
0415: return curPos;
0416: try {
0417: curChar = input_stream.readChar();
0418: } catch (java.io.IOException e) {
0419: return curPos;
0420: }
0421: }
0422: }
0423:
0424: private final int jjStopStringLiteralDfa_1(int pos, long active0) {
0425: switch (pos) {
0426: default:
0427: return -1;
0428: }
0429: }
0430:
0431: private final int jjStartNfa_1(int pos, long active0) {
0432: return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0),
0433: pos + 1);
0434: }
0435:
0436: private final int jjStartNfaWithStates_1(int pos, int kind,
0437: int state) {
0438: jjmatchedKind = kind;
0439: jjmatchedPos = pos;
0440: try {
0441: curChar = input_stream.readChar();
0442: } catch (java.io.IOException e) {
0443: return pos + 1;
0444: }
0445: return jjMoveNfa_1(state, pos + 1);
0446: }
0447:
0448: private final int jjMoveStringLiteralDfa0_1() {
0449: switch (curChar) {
0450: case 58:
0451: return jjStopAtPos(0, 14);
0452: case 59:
0453: return jjStopAtPos(0, 15);
0454: case 125:
0455: return jjStopAtPos(0, 17);
0456: default:
0457: return jjMoveNfa_1(0, 0);
0458: }
0459: }
0460:
0461: private final int jjMoveNfa_1(int startState, int curPos) {
0462: int[] nextStates;
0463: int startsAt = 0;
0464: jjnewStateCnt = 50;
0465: int i = 1;
0466: jjstateSet[0] = startState;
0467: int j, kind = 0x7fffffff;
0468: for (;;) {
0469: if (++jjround == 0x7fffffff)
0470: ReInitRounds();
0471: if (curChar < 64) {
0472: long l = 1L << curChar;
0473: MatchLoop: do {
0474: switch (jjstateSet[--i]) {
0475: case 0:
0476: if ((0x3ff000000000000L & l) != 0L) {
0477: if (kind > 7)
0478: kind = 7;
0479: jjCheckNAddStates(9, 22);
0480: } else if (curChar == 47)
0481: jjAddStates(23, 24);
0482: else if (curChar == 35)
0483: jjstateSet[jjnewStateCnt++] = 7;
0484: else if (curChar == 34)
0485: jjCheckNAddTwoStates(4, 5);
0486: else if (curChar == 45) {
0487: if (kind > 9)
0488: kind = 9;
0489: jjCheckNAdd(1);
0490: }
0491: break;
0492: case 1:
0493: if ((0x3ff200000000000L & l) == 0L)
0494: break;
0495: if (kind > 9)
0496: kind = 9;
0497: jjCheckNAdd(1);
0498: break;
0499: case 3:
0500: if (curChar == 34)
0501: jjCheckNAddTwoStates(4, 5);
0502: break;
0503: case 4:
0504: if ((0xfffffffbffffdbffL & l) != 0L)
0505: jjCheckNAddTwoStates(4, 5);
0506: break;
0507: case 5:
0508: if (curChar == 34 && kind > 22)
0509: kind = 22;
0510: break;
0511: case 6:
0512: if (curChar == 35)
0513: jjstateSet[jjnewStateCnt++] = 7;
0514: break;
0515: case 7:
0516: if ((0x3ff000000000000L & l) != 0L)
0517: jjstateSet[jjnewStateCnt++] = 8;
0518: break;
0519: case 8:
0520: if ((0x3ff000000000000L & l) != 0L)
0521: jjstateSet[jjnewStateCnt++] = 9;
0522: break;
0523: case 9:
0524: if ((0x3ff000000000000L & l) == 0L)
0525: break;
0526: if (kind > 23)
0527: kind = 23;
0528: jjstateSet[jjnewStateCnt++] = 10;
0529: break;
0530: case 10:
0531: if ((0x3ff000000000000L & l) != 0L)
0532: jjstateSet[jjnewStateCnt++] = 11;
0533: break;
0534: case 11:
0535: if ((0x3ff000000000000L & l) != 0L)
0536: jjstateSet[jjnewStateCnt++] = 12;
0537: break;
0538: case 12:
0539: if ((0x3ff000000000000L & l) != 0L && kind > 23)
0540: kind = 23;
0541: break;
0542: case 13:
0543: if (curChar == 47)
0544: jjAddStates(23, 24);
0545: break;
0546: case 14:
0547: if (curChar == 47)
0548: jjCheckNAddStates(25, 27);
0549: break;
0550: case 15:
0551: if ((0xffffffffffffdbffL & l) != 0L)
0552: jjCheckNAddStates(25, 27);
0553: break;
0554: case 16:
0555: if ((0x2400L & l) != 0L && kind > 5)
0556: kind = 5;
0557: break;
0558: case 17:
0559: if (curChar == 10 && kind > 5)
0560: kind = 5;
0561: break;
0562: case 18:
0563: if (curChar == 13)
0564: jjstateSet[jjnewStateCnt++] = 17;
0565: break;
0566: case 19:
0567: if (curChar == 42)
0568: jjCheckNAddTwoStates(20, 21);
0569: break;
0570: case 20:
0571: if ((0xfffffbffffffffffL & l) != 0L)
0572: jjCheckNAddTwoStates(20, 21);
0573: break;
0574: case 21:
0575: if (curChar == 42)
0576: jjAddStates(28, 29);
0577: break;
0578: case 22:
0579: if ((0xffff7fffffffffffL & l) != 0L)
0580: jjCheckNAddTwoStates(23, 21);
0581: break;
0582: case 23:
0583: if ((0xfffffbffffffffffL & l) != 0L)
0584: jjCheckNAddTwoStates(23, 21);
0585: break;
0586: case 24:
0587: if (curChar == 47 && kind > 6)
0588: kind = 6;
0589: break;
0590: case 25:
0591: if ((0x3ff000000000000L & l) == 0L)
0592: break;
0593: if (kind > 7)
0594: kind = 7;
0595: jjCheckNAddStates(9, 22);
0596: break;
0597: case 26:
0598: if ((0x3ff000000000000L & l) == 0L)
0599: break;
0600: if (kind > 7)
0601: kind = 7;
0602: jjCheckNAddTwoStates(26, 27);
0603: break;
0604: case 27:
0605: if (curChar == 46)
0606: jjCheckNAdd(28);
0607: break;
0608: case 28:
0609: if ((0x3ff000000000000L & l) == 0L)
0610: break;
0611: if (kind > 7)
0612: kind = 7;
0613: jjCheckNAdd(28);
0614: break;
0615: case 29:
0616: if ((0x3ff000000000000L & l) != 0L)
0617: jjCheckNAddStates(30, 32);
0618: break;
0619: case 30:
0620: if (curChar == 46)
0621: jjCheckNAdd(31);
0622: break;
0623: case 31:
0624: if ((0x3ff000000000000L & l) != 0L)
0625: jjCheckNAddTwoStates(31, 33);
0626: break;
0627: case 34:
0628: if ((0x3ff000000000000L & l) != 0L)
0629: jjCheckNAddStates(33, 35);
0630: break;
0631: case 35:
0632: if (curChar == 46)
0633: jjCheckNAdd(36);
0634: break;
0635: case 36:
0636: if ((0x3ff000000000000L & l) != 0L)
0637: jjCheckNAddTwoStates(36, 38);
0638: break;
0639: case 39:
0640: if ((0x3ff000000000000L & l) != 0L)
0641: jjCheckNAddStates(36, 41);
0642: break;
0643: case 40:
0644: if (curChar == 46)
0645: jjCheckNAdd(41);
0646: break;
0647: case 41:
0648: if ((0x3ff000000000000L & l) != 0L)
0649: jjCheckNAddStates(42, 46);
0650: break;
0651: default:
0652: break;
0653: }
0654: } while (i != startsAt);
0655: } else if (curChar < 128) {
0656: long l = 1L << (curChar & 077);
0657: MatchLoop: do {
0658: switch (jjstateSet[--i]) {
0659: case 0:
0660: if ((0x7fffffe87fffffeL & l) != 0L) {
0661: if (kind > 9)
0662: kind = 9;
0663: jjCheckNAdd(1);
0664: } else if (curChar == 123) {
0665: if (kind > 18)
0666: kind = 18;
0667: }
0668: break;
0669: case 1:
0670: if ((0x7fffffe87fffffeL & l) == 0L)
0671: break;
0672: if (kind > 9)
0673: kind = 9;
0674: jjCheckNAdd(1);
0675: break;
0676: case 2:
0677: if (curChar == 123 && kind > 18)
0678: kind = 18;
0679: break;
0680: case 4:
0681: if ((0xffffffffefffffffL & l) != 0L)
0682: jjAddStates(47, 48);
0683: break;
0684: case 7:
0685: if ((0x7e0000007eL & l) != 0L)
0686: jjstateSet[jjnewStateCnt++] = 8;
0687: break;
0688: case 8:
0689: if ((0x7e0000007eL & l) != 0L)
0690: jjstateSet[jjnewStateCnt++] = 9;
0691: break;
0692: case 9:
0693: if ((0x7e0000007eL & l) == 0L)
0694: break;
0695: if (kind > 23)
0696: kind = 23;
0697: jjstateSet[jjnewStateCnt++] = 10;
0698: break;
0699: case 10:
0700: if ((0x7e0000007eL & l) != 0L)
0701: jjstateSet[jjnewStateCnt++] = 11;
0702: break;
0703: case 11:
0704: if ((0x7e0000007eL & l) != 0L)
0705: jjstateSet[jjnewStateCnt++] = 12;
0706: break;
0707: case 12:
0708: if ((0x7e0000007eL & l) != 0L && kind > 23)
0709: kind = 23;
0710: break;
0711: case 15:
0712: jjAddStates(25, 27);
0713: break;
0714: case 20:
0715: jjCheckNAddTwoStates(20, 21);
0716: break;
0717: case 22:
0718: case 23:
0719: jjCheckNAddTwoStates(23, 21);
0720: break;
0721: case 32:
0722: if (curChar == 109 && kind > 25)
0723: kind = 25;
0724: break;
0725: case 33:
0726: if (curChar == 101)
0727: jjstateSet[jjnewStateCnt++] = 32;
0728: break;
0729: case 37:
0730: if (curChar == 120 && kind > 26)
0731: kind = 26;
0732: break;
0733: case 38:
0734: if (curChar == 101)
0735: jjstateSet[jjnewStateCnt++] = 37;
0736: break;
0737: case 42:
0738: if (curChar == 109 && kind > 27)
0739: kind = 27;
0740: break;
0741: case 43:
0742: if (curChar == 109)
0743: jjCheckNAdd(42);
0744: break;
0745: case 44:
0746: if (curChar == 99)
0747: jjCheckNAdd(42);
0748: break;
0749: case 45:
0750: if (curChar == 110 && kind > 27)
0751: kind = 27;
0752: break;
0753: case 46:
0754: if (curChar == 105)
0755: jjstateSet[jjnewStateCnt++] = 45;
0756: break;
0757: case 47:
0758: if (curChar == 112)
0759: jjAddStates(49, 50);
0760: break;
0761: case 48:
0762: if (curChar == 116 && kind > 27)
0763: kind = 27;
0764: break;
0765: case 49:
0766: if (curChar == 99 && kind > 27)
0767: kind = 27;
0768: break;
0769: default:
0770: break;
0771: }
0772: } while (i != startsAt);
0773: } else {
0774: int i2 = (curChar & 0xff) >> 6;
0775: long l2 = 1L << (curChar & 077);
0776: MatchLoop: do {
0777: switch (jjstateSet[--i]) {
0778: case 4:
0779: if ((jjbitVec0[i2] & l2) != 0L)
0780: jjAddStates(47, 48);
0781: break;
0782: case 15:
0783: if ((jjbitVec0[i2] & l2) != 0L)
0784: jjAddStates(25, 27);
0785: break;
0786: case 20:
0787: if ((jjbitVec0[i2] & l2) != 0L)
0788: jjCheckNAddTwoStates(20, 21);
0789: break;
0790: case 22:
0791: case 23:
0792: if ((jjbitVec0[i2] & l2) != 0L)
0793: jjCheckNAddTwoStates(23, 21);
0794: break;
0795: default:
0796: break;
0797: }
0798: } while (i != startsAt);
0799: }
0800: if (kind != 0x7fffffff) {
0801: jjmatchedKind = kind;
0802: jjmatchedPos = curPos;
0803: kind = 0x7fffffff;
0804: }
0805: ++curPos;
0806: if ((i = jjnewStateCnt) == (startsAt = 50 - (jjnewStateCnt = startsAt)))
0807: return curPos;
0808: try {
0809: curChar = input_stream.readChar();
0810: } catch (java.io.IOException e) {
0811: return curPos;
0812: }
0813: }
0814: }
0815:
0816: private final int jjStopStringLiteralDfa_2(int pos, long active0) {
0817: switch (pos) {
0818: default:
0819: return -1;
0820: }
0821: }
0822:
0823: private final int jjStartNfa_2(int pos, long active0) {
0824: return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0),
0825: pos + 1);
0826: }
0827:
0828: private final int jjStartNfaWithStates_2(int pos, int kind,
0829: int state) {
0830: jjmatchedKind = kind;
0831: jjmatchedPos = pos;
0832: try {
0833: curChar = input_stream.readChar();
0834: } catch (java.io.IOException e) {
0835: return pos + 1;
0836: }
0837: return jjMoveNfa_2(state, pos + 1);
0838: }
0839:
0840: private final int jjMoveStringLiteralDfa0_2() {
0841: switch (curChar) {
0842: case 59:
0843: return jjStartNfaWithStates_2(0, 15, 3);
0844: default:
0845: return jjMoveNfa_2(4, 0);
0846: }
0847: }
0848:
0849: private final int jjMoveNfa_2(int startState, int curPos) {
0850: int[] nextStates;
0851: int startsAt = 0;
0852: jjnewStateCnt = 5;
0853: int i = 1;
0854: jjstateSet[0] = startState;
0855: int j, kind = 0x7fffffff;
0856: for (;;) {
0857: if (++jjround == 0x7fffffff)
0858: ReInitRounds();
0859: if (curChar < 64) {
0860: long l = 1L << curChar;
0861: MatchLoop: do {
0862: switch (jjstateSet[--i]) {
0863: case 4:
0864: if (kind > 19)
0865: kind = 19;
0866: jjCheckNAdd(3);
0867: if ((0x3ff000000000000L & l) != 0L) {
0868: if (kind > 7)
0869: kind = 7;
0870: jjCheckNAddTwoStates(0, 1);
0871: }
0872: break;
0873: case 0:
0874: if ((0x3ff000000000000L & l) == 0L)
0875: break;
0876: if (kind > 7)
0877: kind = 7;
0878: jjCheckNAddTwoStates(0, 1);
0879: break;
0880: case 1:
0881: if (curChar == 46)
0882: jjCheckNAdd(2);
0883: break;
0884: case 2:
0885: if ((0x3ff000000000000L & l) == 0L)
0886: break;
0887: if (kind > 7)
0888: kind = 7;
0889: jjCheckNAdd(2);
0890: break;
0891: case 3:
0892: if (kind > 19)
0893: kind = 19;
0894: jjCheckNAdd(3);
0895: break;
0896: default:
0897: break;
0898: }
0899: } while (i != startsAt);
0900: } else if (curChar < 128) {
0901: long l = 1L << (curChar & 077);
0902: MatchLoop: do {
0903: switch (jjstateSet[--i]) {
0904: case 4:
0905: if ((0xdfffffffffffffffL & l) != 0L) {
0906: if (kind > 19)
0907: kind = 19;
0908: jjCheckNAdd(3);
0909: } else if (curChar == 125) {
0910: if (kind > 20)
0911: kind = 20;
0912: }
0913: break;
0914: case 3:
0915: if ((0xdfffffffffffffffL & l) == 0L)
0916: break;
0917: kind = 19;
0918: jjCheckNAdd(3);
0919: break;
0920: default:
0921: break;
0922: }
0923: } while (i != startsAt);
0924: } else {
0925: int i2 = (curChar & 0xff) >> 6;
0926: long l2 = 1L << (curChar & 077);
0927: MatchLoop: do {
0928: switch (jjstateSet[--i]) {
0929: case 4:
0930: case 3:
0931: if ((jjbitVec0[i2] & l2) == 0L)
0932: break;
0933: if (kind > 19)
0934: kind = 19;
0935: jjCheckNAdd(3);
0936: break;
0937: default:
0938: break;
0939: }
0940: } while (i != startsAt);
0941: }
0942: if (kind != 0x7fffffff) {
0943: jjmatchedKind = kind;
0944: jjmatchedPos = curPos;
0945: kind = 0x7fffffff;
0946: }
0947: ++curPos;
0948: if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
0949: return curPos;
0950: try {
0951: curChar = input_stream.readChar();
0952: } catch (java.io.IOException e) {
0953: return curPos;
0954: }
0955: }
0956: }
0957:
0958: static final int[] jjnextStates = { 6, 11, 7, 8, 10, 14, 16, 6, 7,
0959: 26, 27, 29, 30, 33, 34, 35, 38, 39, 40, 43, 44, 46, 47, 14,
0960: 19, 15, 16, 18, 22, 24, 29, 30, 33, 34, 35, 38, 39, 40, 43,
0961: 44, 46, 47, 41, 43, 44, 46, 47, 4, 5, 48, 49, };
0962: public static final String[] jjstrLiteralImages = { "", null, null,
0963: null, null, null, null, null, null, null, null, null, null,
0964: "\72", "\72", "\73", "\173", "\175", null, null, null,
0965: null, null, null, null, null, null, null, "\54", "\52",
0966: "\43", "\56", "\133", "\135", "\75", };
0967: public static final String[] lexStateNames = { "DEFAULT",
0968: "IN_RULE", "JAVA_CODE_RULE", "IN_PSEUDOCLASS", };
0969: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
0970: -1, -1, -1, -1, -1, -1, 0, 3, -1, -1, 1, 0, 2, -1, 1, 0,
0971: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, };
0972: static final long[] jjtoToken = { 0x7fefff281L, };
0973: static final long[] jjtoSkip = { 0x7eL, };
0974: protected SimpleCharStream input_stream;
0975: private final int[] jjrounds = new int[50];
0976: private final int[] jjstateSet = new int[100];
0977: protected char curChar;
0978:
0979: public CSSParserTokenManager(SimpleCharStream stream) {
0980: if (SimpleCharStream.staticFlag)
0981: throw new Error(
0982: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
0983: input_stream = stream;
0984: }
0985:
0986: public CSSParserTokenManager(SimpleCharStream stream, int lexState) {
0987: this (stream);
0988: SwitchTo(lexState);
0989: }
0990:
0991: public void ReInit(SimpleCharStream stream) {
0992: jjmatchedPos = jjnewStateCnt = 0;
0993: curLexState = defaultLexState;
0994: input_stream = stream;
0995: ReInitRounds();
0996: }
0997:
0998: private final void ReInitRounds() {
0999: int i;
1000: jjround = 0x80000001;
1001: for (i = 50; i-- > 0;)
1002: jjrounds[i] = 0x80000000;
1003: }
1004:
1005: public void ReInit(SimpleCharStream stream, int lexState) {
1006: ReInit(stream);
1007: SwitchTo(lexState);
1008: }
1009:
1010: public void SwitchTo(int lexState) {
1011: if (lexState >= 4 || lexState < 0)
1012: throw new TokenMgrError(
1013: "Error: Ignoring invalid lexical state : "
1014: + lexState + ". State unchanged.",
1015: TokenMgrError.INVALID_LEXICAL_STATE);
1016: else
1017: curLexState = lexState;
1018: }
1019:
1020: protected Token jjFillToken() {
1021: Token t = Token.newToken(jjmatchedKind);
1022: t.kind = jjmatchedKind;
1023: String im = jjstrLiteralImages[jjmatchedKind];
1024: t.image = (im == null) ? input_stream.GetImage() : im;
1025: t.beginLine = input_stream.getBeginLine();
1026: t.beginColumn = input_stream.getBeginColumn();
1027: t.endLine = input_stream.getEndLine();
1028: t.endColumn = input_stream.getEndColumn();
1029: return t;
1030: }
1031:
1032: int curLexState = 0;
1033: int defaultLexState = 0;
1034: int jjnewStateCnt;
1035: int jjround;
1036: int jjmatchedPos;
1037: int jjmatchedKind;
1038:
1039: public Token getNextToken() {
1040: int kind;
1041: Token specialToken = null;
1042: Token matchedToken;
1043: int curPos = 0;
1044:
1045: EOFLoop: for (;;) {
1046: try {
1047: curChar = input_stream.BeginToken();
1048: } catch (java.io.IOException e) {
1049: jjmatchedKind = 0;
1050: matchedToken = jjFillToken();
1051: return matchedToken;
1052: }
1053:
1054: switch (curLexState) {
1055: case 0:
1056: try {
1057: input_stream.backup(0);
1058: while (curChar <= 32
1059: && (0x100002600L & (1L << curChar)) != 0L)
1060: curChar = input_stream.BeginToken();
1061: } catch (java.io.IOException e1) {
1062: continue EOFLoop;
1063: }
1064: jjmatchedKind = 0x7fffffff;
1065: jjmatchedPos = 0;
1066: curPos = jjMoveStringLiteralDfa0_0();
1067: break;
1068: case 1:
1069: try {
1070: input_stream.backup(0);
1071: while (curChar <= 32
1072: && (0x100002600L & (1L << curChar)) != 0L)
1073: curChar = input_stream.BeginToken();
1074: } catch (java.io.IOException e1) {
1075: continue EOFLoop;
1076: }
1077: jjmatchedKind = 0x7fffffff;
1078: jjmatchedPos = 0;
1079: curPos = jjMoveStringLiteralDfa0_1();
1080: break;
1081: case 2:
1082: jjmatchedKind = 0x7fffffff;
1083: jjmatchedPos = 0;
1084: curPos = jjMoveStringLiteralDfa0_2();
1085: break;
1086: case 3:
1087: jjmatchedKind = 0x7fffffff;
1088: jjmatchedPos = 0;
1089: curPos = jjMoveStringLiteralDfa0_3();
1090: break;
1091: }
1092: if (jjmatchedKind != 0x7fffffff) {
1093: if (jjmatchedPos + 1 < curPos)
1094: input_stream.backup(curPos - jjmatchedPos - 1);
1095: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1096: matchedToken = jjFillToken();
1097: if (jjnewLexState[jjmatchedKind] != -1)
1098: curLexState = jjnewLexState[jjmatchedKind];
1099: return matchedToken;
1100: } else {
1101: if (jjnewLexState[jjmatchedKind] != -1)
1102: curLexState = jjnewLexState[jjmatchedKind];
1103: continue EOFLoop;
1104: }
1105: }
1106: int error_line = input_stream.getEndLine();
1107: int error_column = input_stream.getEndColumn();
1108: String error_after = null;
1109: boolean EOFSeen = false;
1110: try {
1111: input_stream.readChar();
1112: input_stream.backup(1);
1113: } catch (java.io.IOException e1) {
1114: EOFSeen = true;
1115: error_after = curPos <= 1 ? "" : input_stream
1116: .GetImage();
1117: if (curChar == '\n' || curChar == '\r') {
1118: error_line++;
1119: error_column = 0;
1120: } else
1121: error_column++;
1122: }
1123: if (!EOFSeen) {
1124: input_stream.backup(1);
1125: error_after = curPos <= 1 ? "" : input_stream
1126: .GetImage();
1127: }
1128: throw new TokenMgrError(EOFSeen, curLexState, error_line,
1129: error_column, error_after, curChar,
1130: TokenMgrError.LEXICAL_ERROR);
1131: }
1132: }
1133:
1134: }
|