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