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