0001: /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParserTokenManager.java */
0002: package net.sourceforge.pmd.ast;
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 ((active1 & 0x40000000040000L) != 0L)
0016: return 4;
0017: if ((active0 & 0x7ffffffffffff000L) != 0L) {
0018: jjmatchedKind = 71;
0019: return 28;
0020: }
0021: if ((active0 & 0x100L) != 0L
0022: || (active1 & 0x402000000000L) != 0L)
0023: return 49;
0024: return -1;
0025: case 1:
0026: if ((active0 & 0x201800000L) != 0L)
0027: return 28;
0028: if ((active0 & 0x7ffffffdfe7ff000L) != 0L) {
0029: if (jjmatchedPos != 1) {
0030: jjmatchedKind = 71;
0031: jjmatchedPos = 1;
0032: }
0033: return 28;
0034: }
0035: if ((active0 & 0x100L) != 0L)
0036: return 54;
0037: return -1;
0038: case 2:
0039: if ((active0 & 0x400026080000000L) != 0L)
0040: return 28;
0041: if ((active0 & 0x7bfffd9d7f7ff000L) != 0L) {
0042: if (jjmatchedPos != 2) {
0043: jjmatchedKind = 71;
0044: jjmatchedPos = 2;
0045: }
0046: return 28;
0047: }
0048: return -1;
0049: case 3:
0050: if ((active0 & 0xa20048102058000L) != 0L)
0051: return 28;
0052: if ((active0 & 0x71dff95c7d7a7000L) != 0L) {
0053: jjmatchedKind = 71;
0054: jjmatchedPos = 3;
0055: return 28;
0056: }
0057: return -1;
0058: case 4:
0059: if ((active0 & 0x20c50000781a4000L) != 0L)
0060: return 28;
0061: if ((active0 & 0x511af95c05603000L) != 0L) {
0062: if (jjmatchedPos != 4) {
0063: jjmatchedKind = 71;
0064: jjmatchedPos = 4;
0065: }
0066: return 28;
0067: }
0068: return -1;
0069: case 5:
0070: if ((active0 & 0x8ac10801000000L) != 0L)
0071: return 28;
0072: if ((active0 & 0x5110385424603000L) != 0L) {
0073: jjmatchedKind = 71;
0074: jjmatchedPos = 5;
0075: return 28;
0076: }
0077: return -1;
0078: case 6:
0079: if ((active0 & 0x5110205400201000L) != 0L) {
0080: jjmatchedKind = 71;
0081: jjmatchedPos = 6;
0082: return 28;
0083: }
0084: if ((active0 & 0x180024402000L) != 0L)
0085: return 28;
0086: return -1;
0087: case 7:
0088: if ((active0 & 0x5000000000201000L) != 0L)
0089: return 28;
0090: if ((active0 & 0x110205400000000L) != 0L) {
0091: jjmatchedKind = 71;
0092: jjmatchedPos = 7;
0093: return 28;
0094: }
0095: return -1;
0096: case 8:
0097: if ((active0 & 0x100204000000000L) != 0L)
0098: return 28;
0099: if ((active0 & 0x10001400000000L) != 0L) {
0100: jjmatchedKind = 71;
0101: jjmatchedPos = 8;
0102: return 28;
0103: }
0104: return -1;
0105: case 9:
0106: if ((active0 & 0x10000000000000L) != 0L) {
0107: jjmatchedKind = 71;
0108: jjmatchedPos = 9;
0109: return 28;
0110: }
0111: if ((active0 & 0x1400000000L) != 0L)
0112: return 28;
0113: return -1;
0114: case 10:
0115: if ((active0 & 0x10000000000000L) != 0L) {
0116: jjmatchedKind = 71;
0117: jjmatchedPos = 10;
0118: return 28;
0119: }
0120: return -1;
0121: default:
0122: return -1;
0123: }
0124: }
0125:
0126: private final int jjStartNfa_0(int pos, long active0, long active1) {
0127: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
0128: active1), pos + 1);
0129: }
0130:
0131: private final int jjStopAtPos(int pos, int kind) {
0132: jjmatchedKind = kind;
0133: jjmatchedPos = pos;
0134: return pos + 1;
0135: }
0136:
0137: private final int jjStartNfaWithStates_0(int pos, int kind,
0138: int state) {
0139: jjmatchedKind = kind;
0140: jjmatchedPos = pos;
0141: try {
0142: curChar = input_stream.readChar();
0143: } catch (java.io.IOException e) {
0144: return pos + 1;
0145: }
0146: return jjMoveNfa_0(state, pos + 1);
0147: }
0148:
0149: private final int jjMoveStringLiteralDfa0_0() {
0150: switch (curChar) {
0151: case 9:
0152: return jjStopAtPos(0, 2);
0153: case 10:
0154: return jjStopAtPos(0, 3);
0155: case 12:
0156: return jjStopAtPos(0, 5);
0157: case 13:
0158: return jjStopAtPos(0, 4);
0159: case 26:
0160: return jjStopAtPos(0, 122);
0161: case 32:
0162: return jjStopAtPos(0, 1);
0163: case 33:
0164: jjmatchedKind = 86;
0165: return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000L);
0166: case 37:
0167: jjmatchedKind = 105;
0168: return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000L);
0169: case 38:
0170: jjmatchedKind = 102;
0171: return jjMoveStringLiteralDfa1_0(0x0L, 0x800080000000L);
0172: case 40:
0173: return jjStopAtPos(0, 74);
0174: case 41:
0175: return jjStopAtPos(0, 75);
0176: case 42:
0177: jjmatchedKind = 100;
0178: return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000000L);
0179: case 43:
0180: jjmatchedKind = 98;
0181: return jjMoveStringLiteralDfa1_0(0x0L, 0x80100000000L);
0182: case 44:
0183: return jjStopAtPos(0, 81);
0184: case 45:
0185: jjmatchedKind = 99;
0186: return jjMoveStringLiteralDfa1_0(0x0L, 0x100200000000L);
0187: case 46:
0188: jjmatchedKind = 82;
0189: return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L);
0190: case 47:
0191: jjmatchedKind = 101;
0192: return jjMoveStringLiteralDfa1_0(0x100L, 0x400000000000L);
0193: case 58:
0194: return jjStopAtPos(0, 89);
0195: case 59:
0196: return jjStopAtPos(0, 80);
0197: case 60:
0198: jjmatchedKind = 85;
0199: return jjMoveStringLiteralDfa1_0(0x0L, 0x8040008000000L);
0200: case 61:
0201: jjmatchedKind = 84;
0202: return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L);
0203: case 62:
0204: jjmatchedKind = 121;
0205: return jjMoveStringLiteralDfa1_0(0x0L, 0x1b0000010000000L);
0206: case 63:
0207: return jjStopAtPos(0, 88);
0208: case 64:
0209: return jjStopAtPos(0, 83);
0210: case 91:
0211: return jjStopAtPos(0, 78);
0212: case 93:
0213: return jjStopAtPos(0, 79);
0214: case 94:
0215: jjmatchedKind = 104;
0216: return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L);
0217: case 97:
0218: return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);
0219: case 98:
0220: return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L);
0221: case 99:
0222: return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L);
0223: case 100:
0224: return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L);
0225: case 101:
0226: return jjMoveStringLiteralDfa1_0(0x6000000L, 0x0L);
0227: case 102:
0228: return jjMoveStringLiteralDfa1_0(0xf8000000L, 0x0L);
0229: case 103:
0230: return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);
0231: case 105:
0232: return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L);
0233: case 108:
0234: return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
0235: case 110:
0236: return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L);
0237: case 112:
0238: return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L);
0239: case 114:
0240: return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L);
0241: case 115:
0242: return jjMoveStringLiteralDfa1_0(0x401f000000000000L, 0x0L);
0243: case 116:
0244: return jjMoveStringLiteralDfa1_0(0x7e0000000000000L, 0x0L);
0245: case 118:
0246: return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L);
0247: case 119:
0248: return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
0249: case 123:
0250: return jjStopAtPos(0, 76);
0251: case 124:
0252: jjmatchedKind = 103;
0253: return jjMoveStringLiteralDfa1_0(0x0L, 0x1000040000000L);
0254: case 125:
0255: return jjStopAtPos(0, 77);
0256: case 126:
0257: jjmatchedKind = 87;
0258: return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000000L);
0259: default:
0260: return jjMoveNfa_0(0, 0);
0261: }
0262: }
0263:
0264: private final int jjMoveStringLiteralDfa1_0(long active0,
0265: long active1) {
0266: try {
0267: curChar = input_stream.readChar();
0268: } catch (java.io.IOException e) {
0269: jjStopStringLiteralDfa_0(0, active0, active1);
0270: return 1;
0271: }
0272: switch (curChar) {
0273: case 38:
0274: if ((active1 & 0x80000000L) != 0L)
0275: return jjStopAtPos(1, 95);
0276: break;
0277: case 42:
0278: if ((active0 & 0x100L) != 0L)
0279: return jjStartNfaWithStates_0(1, 8, 54);
0280: break;
0281: case 43:
0282: if ((active1 & 0x100000000L) != 0L)
0283: return jjStopAtPos(1, 96);
0284: break;
0285: case 45:
0286: if ((active1 & 0x200000000L) != 0L)
0287: return jjStopAtPos(1, 97);
0288: break;
0289: case 46:
0290: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0291: 0x40000000000000L);
0292: case 60:
0293: if ((active1 & 0x40000000000L) != 0L) {
0294: jjmatchedKind = 106;
0295: jjmatchedPos = 1;
0296: }
0297: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0298: 0x8000000000000L);
0299: case 61:
0300: if ((active1 & 0x4000000L) != 0L)
0301: return jjStopAtPos(1, 90);
0302: else if ((active1 & 0x8000000L) != 0L)
0303: return jjStopAtPos(1, 91);
0304: else if ((active1 & 0x10000000L) != 0L)
0305: return jjStopAtPos(1, 92);
0306: else if ((active1 & 0x20000000L) != 0L)
0307: return jjStopAtPos(1, 93);
0308: else if ((active1 & 0x80000000000L) != 0L)
0309: return jjStopAtPos(1, 107);
0310: else if ((active1 & 0x100000000000L) != 0L)
0311: return jjStopAtPos(1, 108);
0312: else if ((active1 & 0x200000000000L) != 0L)
0313: return jjStopAtPos(1, 109);
0314: else if ((active1 & 0x400000000000L) != 0L)
0315: return jjStopAtPos(1, 110);
0316: else if ((active1 & 0x800000000000L) != 0L)
0317: return jjStopAtPos(1, 111);
0318: else if ((active1 & 0x1000000000000L) != 0L)
0319: return jjStopAtPos(1, 112);
0320: else if ((active1 & 0x2000000000000L) != 0L)
0321: return jjStopAtPos(1, 113);
0322: else if ((active1 & 0x4000000000000L) != 0L)
0323: return jjStopAtPos(1, 114);
0324: break;
0325: case 62:
0326: if ((active1 & 0x100000000000000L) != 0L) {
0327: jjmatchedKind = 120;
0328: jjmatchedPos = 1;
0329: }
0330: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0331: 0xb0000000000000L);
0332: case 91:
0333: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0334: 0x800000000000000L);
0335: case 97:
0336: return jjMoveStringLiteralDfa2_0(active0, 0x90008030000L,
0337: active1, 0L);
0338: case 98:
0339: return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1,
0340: 0L);
0341: case 101:
0342: return jjMoveStringLiteralDfa2_0(active0, 0x820000400000L,
0343: active1, 0L);
0344: case 102:
0345: if ((active0 & 0x200000000L) != 0L)
0346: return jjStartNfaWithStates_0(1, 33, 28);
0347: break;
0348: case 104:
0349: return jjMoveStringLiteralDfa2_0(active0,
0350: 0x20e1000000040000L, active1, 0L);
0351: case 105:
0352: return jjMoveStringLiteralDfa2_0(active0, 0x30000000L,
0353: active1, 0L);
0354: case 108:
0355: return jjMoveStringLiteralDfa2_0(active0, 0x42080000L,
0356: active1, 0L);
0357: case 109:
0358: return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L,
0359: active1, 0L);
0360: case 110:
0361: return jjMoveStringLiteralDfa2_0(active0, 0x7000000000L,
0362: active1, 0L);
0363: case 111:
0364: if ((active0 & 0x800000L) != 0L) {
0365: jjmatchedKind = 23;
0366: jjmatchedPos = 1;
0367: }
0368: return jjMoveStringLiteralDfa2_0(active0,
0369: 0x1800008181302000L, active1, 0L);
0370: case 114:
0371: return jjMoveStringLiteralDfa2_0(active0,
0372: 0x700300000004000L, active1, 0L);
0373: case 116:
0374: return jjMoveStringLiteralDfa2_0(active0,
0375: 0x4002000000000000L, active1, 0L);
0376: case 117:
0377: return jjMoveStringLiteralDfa2_0(active0, 0x4440000000000L,
0378: active1, 0L);
0379: case 119:
0380: return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L,
0381: active1, 0L);
0382: case 120:
0383: return jjMoveStringLiteralDfa2_0(active0, 0x4000000L,
0384: active1, 0L);
0385: case 121:
0386: return jjMoveStringLiteralDfa2_0(active0,
0387: 0x10000000008000L, active1, 0L);
0388: case 124:
0389: if ((active1 & 0x40000000L) != 0L)
0390: return jjStopAtPos(1, 94);
0391: break;
0392: default:
0393: break;
0394: }
0395: return jjStartNfa_0(0, active0, active1);
0396: }
0397:
0398: private final int jjMoveStringLiteralDfa2_0(long old0,
0399: long active0, long old1, long active1) {
0400: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0401: return jjStartNfa_0(0, old0, old1);
0402: try {
0403: curChar = input_stream.readChar();
0404: } catch (java.io.IOException e) {
0405: jjStopStringLiteralDfa_0(1, active0, active1);
0406: return 2;
0407: }
0408: switch (curChar) {
0409: case 46:
0410: if ((active1 & 0x40000000000000L) != 0L)
0411: return jjStopAtPos(2, 118);
0412: break;
0413: case 61:
0414: if ((active1 & 0x8000000000000L) != 0L)
0415: return jjStopAtPos(2, 115);
0416: else if ((active1 & 0x10000000000000L) != 0L)
0417: return jjStopAtPos(2, 116);
0418: break;
0419: case 62:
0420: if ((active1 & 0x80000000000000L) != 0L) {
0421: jjmatchedKind = 119;
0422: jjmatchedPos = 2;
0423: }
0424: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
0425: 0x20000000000000L);
0426: case 93:
0427: if ((active1 & 0x800000000000000L) != 0L)
0428: return jjStopAtPos(2, 123);
0429: break;
0430: case 97:
0431: return jjMoveStringLiteralDfa3_0(active0,
0432: 0x1020000000c0000L, active1, 0L);
0433: case 98:
0434: return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L,
0435: active1, 0L);
0436: case 99:
0437: return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L,
0438: active1, 0L);
0439: case 101:
0440: return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1,
0441: 0L);
0442: case 102:
0443: return jjMoveStringLiteralDfa3_0(active0, 0x400000L,
0444: active1, 0L);
0445: case 105:
0446: return jjMoveStringLiteralDfa3_0(active0,
0447: 0x2828100000000000L, active1, 0L);
0448: case 108:
0449: return jjMoveStringLiteralDfa3_0(active0,
0450: 0x1000040008000000L, active1, 0L);
0451: case 110:
0452: return jjMoveStringLiteralDfa3_0(active0,
0453: 0x10008030300000L, active1, 0L);
0454: case 111:
0455: return jjMoveStringLiteralDfa3_0(active0, 0x1200040002000L,
0456: active1, 0L);
0457: case 112:
0458: return jjMoveStringLiteralDfa3_0(active0, 0x4000c00000000L,
0459: active1, 0L);
0460: case 114:
0461: if ((active0 & 0x80000000L) != 0L)
0462: return jjStartNfaWithStates_0(2, 31, 28);
0463: return jjMoveStringLiteralDfa3_0(active0,
0464: 0x40c0000000000000L, active1, 0L);
0465: case 115:
0466: return jjMoveStringLiteralDfa3_0(active0, 0x1002011000L,
0467: active1, 0L);
0468: case 116:
0469: if ((active0 & 0x2000000000L) != 0L) {
0470: jjmatchedKind = 37;
0471: jjmatchedPos = 2;
0472: }
0473: return jjMoveStringLiteralDfa3_0(active0, 0x814104028000L,
0474: active1, 0L);
0475: case 117:
0476: return jjMoveStringLiteralDfa3_0(active0,
0477: 0x200000001000000L, active1, 0L);
0478: case 119:
0479: if ((active0 & 0x20000000000L) != 0L)
0480: return jjStartNfaWithStates_0(2, 41, 28);
0481: break;
0482: case 121:
0483: if ((active0 & 0x400000000000000L) != 0L)
0484: return jjStartNfaWithStates_0(2, 58, 28);
0485: break;
0486: default:
0487: break;
0488: }
0489: return jjStartNfa_0(1, active0, active1);
0490: }
0491:
0492: private final int jjMoveStringLiteralDfa3_0(long old0,
0493: long active0, long old1, long active1) {
0494: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0495: return jjStartNfa_0(1, old0, old1);
0496: try {
0497: curChar = input_stream.readChar();
0498: } catch (java.io.IOException e) {
0499: jjStopStringLiteralDfa_0(2, active0, active1);
0500: return 3;
0501: }
0502: switch (curChar) {
0503: case 61:
0504: if ((active1 & 0x20000000000000L) != 0L)
0505: return jjStopAtPos(3, 117);
0506: break;
0507: case 97:
0508: return jjMoveStringLiteralDfa4_0(active0,
0509: 0x1000000070404000L, active1, 0L);
0510: case 98:
0511: return jjMoveStringLiteralDfa4_0(active0, 0x1000000L,
0512: active1, 0L);
0513: case 99:
0514: return jjMoveStringLiteralDfa4_0(active0,
0515: 0x10000000020000L, active1, 0L);
0516: case 100:
0517: if ((active0 & 0x800000000000000L) != 0L)
0518: return jjStartNfaWithStates_0(3, 59, 28);
0519: break;
0520: case 101:
0521: if ((active0 & 0x8000L) != 0L)
0522: return jjStartNfaWithStates_0(3, 15, 28);
0523: else if ((active0 & 0x10000L) != 0L)
0524: return jjStartNfaWithStates_0(3, 16, 28);
0525: else if ((active0 & 0x2000000L) != 0L)
0526: return jjStartNfaWithStates_0(3, 25, 28);
0527: else if ((active0 & 0x200000000000000L) != 0L)
0528: return jjStartNfaWithStates_0(3, 57, 28);
0529: return jjMoveStringLiteralDfa4_0(active0, 0x4004004000000L,
0530: active1, 0L);
0531: case 103:
0532: if ((active0 & 0x8000000000L) != 0L)
0533: return jjStartNfaWithStates_0(3, 39, 28);
0534: break;
0535: case 105:
0536: return jjMoveStringLiteralDfa4_0(active0,
0537: 0x4000010000000000L, active1, 0L);
0538: case 107:
0539: return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L,
0540: active1, 0L);
0541: case 108:
0542: if ((active0 & 0x40000000000L) != 0L)
0543: return jjStartNfaWithStates_0(3, 42, 28);
0544: return jjMoveStringLiteralDfa4_0(active0,
0545: 0x2000400400002000L, active1, 0L);
0546: case 110:
0547: return jjMoveStringLiteralDfa4_0(active0,
0548: 0x100000000000000L, active1, 0L);
0549: case 111:
0550: if ((active0 & 0x100000000L) != 0L)
0551: return jjStartNfaWithStates_0(3, 32, 28);
0552: return jjMoveStringLiteralDfa4_0(active0,
0553: 0xc0000800000000L, active1, 0L);
0554: case 114:
0555: if ((active0 & 0x40000L) != 0L)
0556: return jjStartNfaWithStates_0(3, 18, 28);
0557: return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L,
0558: active1, 0L);
0559: case 115:
0560: if ((active0 & 0x20000000000000L) != 0L)
0561: return jjStartNfaWithStates_0(3, 53, 28);
0562: return jjMoveStringLiteralDfa4_0(active0, 0x8180000L,
0563: active1, 0L);
0564: case 116:
0565: return jjMoveStringLiteralDfa4_0(active0, 0xa201000201000L,
0566: active1, 0L);
0567: case 117:
0568: return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L,
0569: active1, 0L);
0570: case 118:
0571: return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L,
0572: active1, 0L);
0573: default:
0574: break;
0575: }
0576: return jjStartNfa_0(2, active0, active1);
0577: }
0578:
0579: private final int jjMoveStringLiteralDfa4_0(long old0,
0580: long active0, long old1, long active1) {
0581: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0582: return jjStartNfa_0(2, old0, old1);
0583: try {
0584: curChar = input_stream.readChar();
0585: } catch (java.io.IOException e) {
0586: jjStopStringLiteralDfa_0(3, active0, 0L);
0587: return 4;
0588: }
0589: switch (curChar) {
0590: case 97:
0591: return jjMoveStringLiteralDfa5_0(active0, 0x181000000000L);
0592: case 99:
0593: return jjMoveStringLiteralDfa5_0(active0,
0594: 0x4008000000000000L);
0595: case 101:
0596: if ((active0 & 0x8000000L) != 0L)
0597: return jjStartNfaWithStates_0(4, 27, 28);
0598: else if ((active0 & 0x2000000000000000L) != 0L)
0599: return jjStartNfaWithStates_0(4, 61, 28);
0600: return jjMoveStringLiteralDfa5_0(active0, 0x200400002000L);
0601: case 104:
0602: if ((active0 & 0x20000L) != 0L)
0603: return jjStartNfaWithStates_0(4, 17, 28);
0604: return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
0605: case 105:
0606: return jjMoveStringLiteralDfa5_0(active0, 0x2400000200000L);
0607: case 107:
0608: if ((active0 & 0x4000L) != 0L)
0609: return jjStartNfaWithStates_0(4, 14, 28);
0610: break;
0611: case 108:
0612: if ((active0 & 0x10000000L) != 0L) {
0613: jjmatchedKind = 28;
0614: jjmatchedPos = 4;
0615: }
0616: return jjMoveStringLiteralDfa5_0(active0, 0x21000000L);
0617: case 110:
0618: return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
0619: case 114:
0620: if ((active0 & 0x4000000000000L) != 0L)
0621: return jjStartNfaWithStates_0(4, 50, 28);
0622: return jjMoveStringLiteralDfa5_0(active0, 0x804800001000L);
0623: case 115:
0624: if ((active0 & 0x80000L) != 0L)
0625: return jjStartNfaWithStates_0(4, 19, 28);
0626: return jjMoveStringLiteralDfa5_0(active0,
0627: 0x100000000000000L);
0628: case 116:
0629: if ((active0 & 0x100000L) != 0L)
0630: return jjStartNfaWithStates_0(4, 20, 28);
0631: else if ((active0 & 0x40000000L) != 0L)
0632: return jjStartNfaWithStates_0(4, 30, 28);
0633: else if ((active0 & 0x1000000000000L) != 0L)
0634: return jjStartNfaWithStates_0(4, 48, 28);
0635: return jjMoveStringLiteralDfa5_0(active0,
0636: 0x1000000000000000L);
0637: case 117:
0638: return jjMoveStringLiteralDfa5_0(active0, 0x400000L);
0639: case 118:
0640: return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);
0641: case 119:
0642: if ((active0 & 0x40000000000000L) != 0L) {
0643: jjmatchedKind = 54;
0644: jjmatchedPos = 4;
0645: }
0646: return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);
0647: default:
0648: break;
0649: }
0650: return jjStartNfa_0(3, active0, 0L);
0651: }
0652:
0653: private final int jjMoveStringLiteralDfa5_0(long old0, long active0) {
0654: if (((active0 &= old0)) == 0L)
0655: return jjStartNfa_0(3, old0, 0L);
0656: try {
0657: curChar = input_stream.readChar();
0658: } catch (java.io.IOException e) {
0659: jjStopStringLiteralDfa_0(4, active0, 0L);
0660: return 5;
0661: }
0662: switch (curChar) {
0663: case 97:
0664: return jjMoveStringLiteralDfa6_0(active0, 0x3000L);
0665: case 99:
0666: if ((active0 & 0x400000000000L) != 0L)
0667: return jjStartNfaWithStates_0(5, 46, 28);
0668: else if ((active0 & 0x2000000000000L) != 0L)
0669: return jjStartNfaWithStates_0(5, 49, 28);
0670: return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
0671: case 100:
0672: return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
0673: case 101:
0674: if ((active0 & 0x1000000L) != 0L)
0675: return jjStartNfaWithStates_0(5, 24, 28);
0676: else if ((active0 & 0x10000000000L) != 0L)
0677: return jjStartNfaWithStates_0(5, 40, 28);
0678: break;
0679: case 102:
0680: return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L);
0681: case 103:
0682: return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L);
0683: case 104:
0684: if ((active0 & 0x8000000000000L) != 0L)
0685: return jjStartNfaWithStates_0(5, 51, 28);
0686: break;
0687: case 105:
0688: return jjMoveStringLiteralDfa6_0(active0,
0689: 0x1100000000000000L);
0690: case 108:
0691: return jjMoveStringLiteralDfa6_0(active0, 0x20400000L);
0692: case 109:
0693: return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);
0694: case 110:
0695: if ((active0 & 0x800000000000L) != 0L)
0696: return jjStartNfaWithStates_0(5, 47, 28);
0697: return jjMoveStringLiteralDfa6_0(active0, 0x1000200000L);
0698: case 114:
0699: return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
0700: case 115:
0701: if ((active0 & 0x80000000000000L) != 0L)
0702: return jjStartNfaWithStates_0(5, 55, 28);
0703: break;
0704: case 116:
0705: if ((active0 & 0x800000000L) != 0L)
0706: return jjStartNfaWithStates_0(5, 35, 28);
0707: return jjMoveStringLiteralDfa6_0(active0,
0708: 0x4000100000000000L);
0709: default:
0710: break;
0711: }
0712: return jjStartNfa_0(4, active0, 0L);
0713: }
0714:
0715: private final int jjMoveStringLiteralDfa6_0(long old0, long active0) {
0716: if (((active0 &= old0)) == 0L)
0717: return jjStartNfa_0(4, old0, 0L);
0718: try {
0719: curChar = input_stream.readChar();
0720: } catch (java.io.IOException e) {
0721: jjStopStringLiteralDfa_0(5, active0, 0L);
0722: return 6;
0723: }
0724: switch (curChar) {
0725: case 97:
0726: return jjMoveStringLiteralDfa7_0(active0, 0x4000000000L);
0727: case 99:
0728: return jjMoveStringLiteralDfa7_0(active0, 0x1000001000L);
0729: case 101:
0730: if ((active0 & 0x80000000000L) != 0L)
0731: return jjStartNfaWithStates_0(6, 43, 28);
0732: else if ((active0 & 0x100000000000L) != 0L)
0733: return jjStartNfaWithStates_0(6, 44, 28);
0734: return jjMoveStringLiteralDfa7_0(active0,
0735: 0x100000400000000L);
0736: case 102:
0737: return jjMoveStringLiteralDfa7_0(active0,
0738: 0x4000000000000000L);
0739: case 108:
0740: return jjMoveStringLiteralDfa7_0(active0,
0741: 0x1000000000000000L);
0742: case 110:
0743: if ((active0 & 0x2000L) != 0L)
0744: return jjStartNfaWithStates_0(6, 13, 28);
0745: break;
0746: case 111:
0747: return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
0748: case 115:
0749: if ((active0 & 0x4000000L) != 0L)
0750: return jjStartNfaWithStates_0(6, 26, 28);
0751: break;
0752: case 116:
0753: if ((active0 & 0x400000L) != 0L)
0754: return jjStartNfaWithStates_0(6, 22, 28);
0755: return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L);
0756: case 117:
0757: return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
0758: case 121:
0759: if ((active0 & 0x20000000L) != 0L)
0760: return jjStartNfaWithStates_0(6, 29, 28);
0761: break;
0762: default:
0763: break;
0764: }
0765: return jjStartNfa_0(5, active0, 0L);
0766: }
0767:
0768: private final int jjMoveStringLiteralDfa7_0(long old0, long active0) {
0769: if (((active0 &= old0)) == 0L)
0770: return jjStartNfa_0(5, old0, 0L);
0771: try {
0772: curChar = input_stream.readChar();
0773: } catch (java.io.IOException e) {
0774: jjStopStringLiteralDfa_0(6, active0, 0L);
0775: return 7;
0776: }
0777: switch (curChar) {
0778: case 99:
0779: return jjMoveStringLiteralDfa8_0(active0, 0x4000000000L);
0780: case 101:
0781: if ((active0 & 0x200000L) != 0L)
0782: return jjStartNfaWithStates_0(7, 21, 28);
0783: else if ((active0 & 0x1000000000000000L) != 0L)
0784: return jjStartNfaWithStates_0(7, 60, 28);
0785: return jjMoveStringLiteralDfa8_0(active0, 0x201000000000L);
0786: case 110:
0787: return jjMoveStringLiteralDfa8_0(active0,
0788: 0x110000400000000L);
0789: case 112:
0790: if ((active0 & 0x4000000000000000L) != 0L)
0791: return jjStartNfaWithStates_0(7, 62, 28);
0792: break;
0793: case 116:
0794: if ((active0 & 0x1000L) != 0L)
0795: return jjStartNfaWithStates_0(7, 12, 28);
0796: break;
0797: default:
0798: break;
0799: }
0800: return jjStartNfa_0(6, active0, 0L);
0801: }
0802:
0803: private final int jjMoveStringLiteralDfa8_0(long old0, long active0) {
0804: if (((active0 &= old0)) == 0L)
0805: return jjStartNfa_0(6, old0, 0L);
0806: try {
0807: curChar = input_stream.readChar();
0808: } catch (java.io.IOException e) {
0809: jjStopStringLiteralDfa_0(7, active0, 0L);
0810: return 8;
0811: }
0812: switch (curChar) {
0813: case 100:
0814: if ((active0 & 0x200000000000L) != 0L)
0815: return jjStartNfaWithStates_0(8, 45, 28);
0816: break;
0817: case 101:
0818: if ((active0 & 0x4000000000L) != 0L)
0819: return jjStartNfaWithStates_0(8, 38, 28);
0820: break;
0821: case 105:
0822: return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L);
0823: case 111:
0824: return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
0825: case 116:
0826: if ((active0 & 0x100000000000000L) != 0L)
0827: return jjStartNfaWithStates_0(8, 56, 28);
0828: return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
0829: default:
0830: break;
0831: }
0832: return jjStartNfa_0(7, active0, 0L);
0833: }
0834:
0835: private final int jjMoveStringLiteralDfa9_0(long old0, long active0) {
0836: if (((active0 &= old0)) == 0L)
0837: return jjStartNfa_0(7, old0, 0L);
0838: try {
0839: curChar = input_stream.readChar();
0840: } catch (java.io.IOException e) {
0841: jjStopStringLiteralDfa_0(8, active0, 0L);
0842: return 9;
0843: }
0844: switch (curChar) {
0845: case 102:
0846: if ((active0 & 0x1000000000L) != 0L)
0847: return jjStartNfaWithStates_0(9, 36, 28);
0848: break;
0849: case 115:
0850: if ((active0 & 0x400000000L) != 0L)
0851: return jjStartNfaWithStates_0(9, 34, 28);
0852: break;
0853: case 122:
0854: return jjMoveStringLiteralDfa10_0(active0,
0855: 0x10000000000000L);
0856: default:
0857: break;
0858: }
0859: return jjStartNfa_0(8, active0, 0L);
0860: }
0861:
0862: private final int jjMoveStringLiteralDfa10_0(long old0, long active0) {
0863: if (((active0 &= old0)) == 0L)
0864: return jjStartNfa_0(8, old0, 0L);
0865: try {
0866: curChar = input_stream.readChar();
0867: } catch (java.io.IOException e) {
0868: jjStopStringLiteralDfa_0(9, active0, 0L);
0869: return 10;
0870: }
0871: switch (curChar) {
0872: case 101:
0873: return jjMoveStringLiteralDfa11_0(active0,
0874: 0x10000000000000L);
0875: default:
0876: break;
0877: }
0878: return jjStartNfa_0(9, active0, 0L);
0879: }
0880:
0881: private final int jjMoveStringLiteralDfa11_0(long old0, long active0) {
0882: if (((active0 &= old0)) == 0L)
0883: return jjStartNfa_0(9, old0, 0L);
0884: try {
0885: curChar = input_stream.readChar();
0886: } catch (java.io.IOException e) {
0887: jjStopStringLiteralDfa_0(10, active0, 0L);
0888: return 11;
0889: }
0890: switch (curChar) {
0891: case 100:
0892: if ((active0 & 0x10000000000000L) != 0L)
0893: return jjStartNfaWithStates_0(11, 52, 28);
0894: break;
0895: default:
0896: break;
0897: }
0898: return jjStartNfa_0(10, active0, 0L);
0899: }
0900:
0901: private final void jjCheckNAdd(int state) {
0902: if (jjrounds[state] != jjround) {
0903: jjstateSet[jjnewStateCnt++] = state;
0904: jjrounds[state] = jjround;
0905: }
0906: }
0907:
0908: private final void jjAddStates(int start, int end) {
0909: do {
0910: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0911: } while (start++ != end);
0912: }
0913:
0914: private final void jjCheckNAddTwoStates(int state1, int state2) {
0915: jjCheckNAdd(state1);
0916: jjCheckNAdd(state2);
0917: }
0918:
0919: private final void jjCheckNAddStates(int start, int end) {
0920: do {
0921: jjCheckNAdd(jjnextStates[start]);
0922: } while (start++ != end);
0923: }
0924:
0925: private final void jjCheckNAddStates(int start) {
0926: jjCheckNAdd(jjnextStates[start]);
0927: jjCheckNAdd(jjnextStates[start + 1]);
0928: }
0929:
0930: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0931: 0xffffffffffffffffL, 0xffffffffffffffffL,
0932: 0xffffffffffffffffL };
0933: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0934: 0xffffffffffffffffL };
0935: static final long[] jjbitVec3 = { 0xfff0000000200002L,
0936: 0xffffffffffffdfffL, 0xfffff00f7fffffffL,
0937: 0x12000000007fffffL };
0938: static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x420043c00000000L,
0939: 0xff7fffffff7fffffL };
0940: static final long[] jjbitVec5 = { 0xffffcffffffffL,
0941: 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L };
0942: static final long[] jjbitVec6 = { 0x0L, 0x400000000000000L,
0943: 0xfffffffbffffd740L, 0xffffffcff7fffL };
0944: static final long[] jjbitVec7 = { 0xffffffffffffffffL,
0945: 0xffffffffffffffffL, 0xfffffffffffff003L,
0946: 0x33fffffffff199fL };
0947: static final long[] jjbitVec8 = { 0xfffe000000000000L,
0948: 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L };
0949: static final long[] jjbitVec9 = { 0x7fffffe00000000L,
0950: 0xfffe0000000007ffL, 0xffffffffffffffffL,
0951: 0x1c000060002fffffL };
0952: static final long[] jjbitVec10 = { 0x1ffffffd0000L, 0x0L,
0953: 0x3fffffffffL, 0x0L };
0954: static final long[] jjbitVec11 = { 0x23ffffffffffffe0L,
0955: 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L };
0956: static final long[] jjbitVec12 = { 0x36dfdfffff987e0L,
0957: 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L };
0958: static final long[] jjbitVec13 = { 0x23cdfdfffff99fe0L,
0959: 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L };
0960: static final long[] jjbitVec14 = { 0x3effdfffffddfe0L,
0961: 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L };
0962: static final long[] jjbitVec15 = { 0x3fffdfffffddfe0L,
0963: 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL };
0964: static final long[] jjbitVec16 = { 0x800dfffffffffffeL, 0x7fL,
0965: 0x200decaefef02596L, 0x3000005fL };
0966: static final long[] jjbitVec17 = { 0x1L, 0x7fffffffeffL, 0xf00L,
0967: 0x0L };
0968: static final long[] jjbitVec18 = { 0x6fbffffffffL, 0x3f0000L,
0969: 0xffffffff00000000L, 0x7fffffffff003fL };
0970: static final long[] jjbitVec19 = { 0xffffffffffffffffL,
0971: 0xffffffff83ffffffL, 0xffffff07ffffffffL,
0972: 0x3ffffffffffffffL };
0973: static final long[] jjbitVec20 = { 0xffffffffffffff7fL,
0974: 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL,
0975: 0xffff7fffff7f7f3dL };
0976: static final long[] jjbitVec21 = { 0xffffffff7f3d7fffL, 0x7ffff7fL,
0977: 0xffffffff00000000L, 0x1fffffffffffffL };
0978: static final long[] jjbitVec22 = { 0xffffffffffffffffL,
0979: 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL };
0980: static final long[] jjbitVec23 = { 0x0L, 0x0L, 0xfffffffffffffL,
0981: 0x8000000L };
0982: static final long[] jjbitVec24 = { 0xffffffff00000000L,
0983: 0xffffffffffffffL, 0x1ffffffffffL, 0x0L };
0984: static final long[] jjbitVec25 = { 0xffffffffffffffffL,
0985: 0xffffffffffffffffL, 0xffffffff0fffffffL,
0986: 0x3ffffffffffffffL };
0987: static final long[] jjbitVec26 = { 0xffffffff3f3fffffL,
0988: 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL,
0989: 0x1fdc1fff0fcf1fdcL };
0990: static final long[] jjbitVec27 = { 0x8000000000000000L,
0991: 0x8000000000000001L, 0xffff00000000L, 0x0L };
0992: static final long[] jjbitVec28 = { 0x3fbbd503e2ffc84L,
0993: 0xffffffff00000000L, 0xfL, 0x0L };
0994: static final long[] jjbitVec29 = { 0x73e03fe000000e0L,
0995: 0xfffffffffffffffeL, 0xfffffffe601fffffL,
0996: 0x7fffffffffffffffL };
0997: static final long[] jjbitVec30 = { 0xfffe1fffffffffe0L,
0998: 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L };
0999: static final long[] jjbitVec31 = { 0xffffffffffffffffL,
1000: 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L };
1001: static final long[] jjbitVec32 = { 0xffffffffffffffffL,
1002: 0xffffffffffffffffL, 0x3fffffffffL, 0x0L };
1003: static final long[] jjbitVec33 = { 0xffffffffffffffffL,
1004: 0xffffffffffffffffL, 0x1fffL, 0x0L };
1005: static final long[] jjbitVec34 = { 0xffffffffffffffffL,
1006: 0xffffffffffffffffL, 0xfffffffffL, 0x0L };
1007: static final long[] jjbitVec35 = { 0x3fffffffffffL, 0x0L, 0x0L,
1008: 0x0L };
1009: static final long[] jjbitVec36 = { 0x5f7ffdffa0f8007fL,
1010: 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L };
1011: static final long[] jjbitVec37 = { 0x3fffffffffffffffL,
1012: 0xffffffffffff0000L, 0xfffffffffffcffffL,
1013: 0xfff0000000000ffL };
1014: static final long[] jjbitVec38 = { 0x18000000000000L,
1015: 0xffd702000000e000L, 0xffffffffffffffffL,
1016: 0x1fffffffffffffffL };
1017: static final long[] jjbitVec39 = { 0x87fffffe00000010L,
1018: 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL };
1019: static final long[] jjbitVec40 = { 0x0L, 0x0L, 0x420043cffffffffL,
1020: 0xff7fffffff7fffffL };
1021: static final long[] jjbitVec41 = { 0xffffffffffffffffL,
1022: 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL };
1023: static final long[] jjbitVec42 = { 0xffffffffffffffffL,
1024: 0xffffffffffffffffL, 0xfffffffffffff07bL,
1025: 0x33fffffffff199fL };
1026: static final long[] jjbitVec43 = { 0xfffe000000000000L,
1027: 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L };
1028: static final long[] jjbitVec44 = { 0x7fffffe00000000L,
1029: 0xffff03ff003fffffL, 0xffffffffffffffffL,
1030: 0x1fff3dff9fefffffL };
1031: static final long[] jjbitVec45 = { 0xffff1fffffff8000L, 0x7ffL,
1032: 0x1ffffffffffffL, 0x0L };
1033: static final long[] jjbitVec46 = { 0xf3ffffffffffffeeL,
1034: 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL };
1035: static final long[] jjbitVec47 = { 0xd36dfdfffff987e4L,
1036: 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL };
1037: static final long[] jjbitVec48 = { 0xf3cdfdfffff99feeL,
1038: 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L };
1039: static final long[] jjbitVec49 = { 0xc3effdfffffddfeeL,
1040: 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL };
1041: static final long[] jjbitVec50 = { 0xc3fffdfffffddfecL,
1042: 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL };
1043: static final long[] jjbitVec51 = { 0x87fffffffffffffeL, 0x3ff7fffL,
1044: 0x3bffecaefef02596L, 0x33ff3f5fL };
1045: static final long[] jjbitVec52 = { 0xc2a003ff03000001L,
1046: 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L };
1047: static final long[] jjbitVec53 = { 0x3c7f6fbffffffffL, 0x3ff03ffL,
1048: 0xffffffff00000000L, 0x7fffffffff003fL };
1049: static final long[] jjbitVec54 = { 0xffffffff7f3d7fffL,
1050: 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL };
1051: static final long[] jjbitVec55 = { 0x0L, 0x0L, 0xffffffffffffffffL,
1052: 0x3ff080fffffL };
1053: static final long[] jjbitVec56 = { 0xffffffff03ff7800L,
1054: 0xffffffffffffffL, 0x3ffffffffffL, 0x0L };
1055: static final long[] jjbitVec57 = { 0x80007c000000f000L,
1056: 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L };
1057: static final long[] jjbitVec58 = { 0x73efffe000000e0L,
1058: 0xfffffffffffffffeL, 0xfffffffe661fffffL,
1059: 0x7fffffffffffffffL };
1060: static final long[] jjbitVec59 = { 0x5f7ffdffe0f8007fL,
1061: 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L };
1062: static final long[] jjbitVec60 = { 0x18000f00000000L,
1063: 0xffd702000000e000L, 0xffffffffffffffffL,
1064: 0x9fffffffffffffffL };
1065: static final long[] jjbitVec61 = { 0x87fffffe03ff0010L,
1066: 0xffffffe007fffffeL, 0x7fffffffffffffffL,
1067: 0xe0000631cfcfcfcL };
1068:
1069: private final int jjMoveNfa_0(int startState, int curPos) {
1070: int[] nextStates;
1071: int startsAt = 0;
1072: jjnewStateCnt = 57;
1073: int i = 1;
1074: jjstateSet[0] = startState;
1075: int j, kind = 0x7fffffff;
1076: for (;;) {
1077: if (++jjround == 0x7fffffff)
1078: ReInitRounds();
1079: if (curChar < 64) {
1080: long l = 1L << curChar;
1081: MatchLoop: do {
1082: switch (jjstateSet[--i]) {
1083: case 49:
1084: if (curChar == 42)
1085: jjstateSet[jjnewStateCnt++] = 54;
1086: else if (curChar == 47) {
1087: if (kind > 6)
1088: kind = 6;
1089: jjCheckNAddStates(0, 2);
1090: }
1091: break;
1092: case 0:
1093: if ((0x3ff000000000000L & l) != 0L)
1094: jjCheckNAddStates(3, 9);
1095: else if (curChar == 47)
1096: jjAddStates(10, 11);
1097: else if (curChar == 36) {
1098: if (kind > 71)
1099: kind = 71;
1100: jjCheckNAdd(28);
1101: } else if (curChar == 34)
1102: jjCheckNAddStates(12, 14);
1103: else if (curChar == 39)
1104: jjAddStates(15, 16);
1105: else if (curChar == 46)
1106: jjCheckNAdd(4);
1107: if ((0x3fe000000000000L & l) != 0L) {
1108: if (kind > 63)
1109: kind = 63;
1110: jjCheckNAddTwoStates(1, 2);
1111: } else if (curChar == 48) {
1112: if (kind > 63)
1113: kind = 63;
1114: jjCheckNAddStates(17, 19);
1115: }
1116: break;
1117: case 1:
1118: if ((0x3ff000000000000L & l) == 0L)
1119: break;
1120: if (kind > 63)
1121: kind = 63;
1122: jjCheckNAddTwoStates(1, 2);
1123: break;
1124: case 3:
1125: if (curChar == 46)
1126: jjCheckNAdd(4);
1127: break;
1128: case 4:
1129: if ((0x3ff000000000000L & l) == 0L)
1130: break;
1131: if (kind > 67)
1132: kind = 67;
1133: jjCheckNAddStates(20, 22);
1134: break;
1135: case 6:
1136: if ((0x280000000000L & l) != 0L)
1137: jjCheckNAdd(7);
1138: break;
1139: case 7:
1140: if ((0x3ff000000000000L & l) == 0L)
1141: break;
1142: if (kind > 67)
1143: kind = 67;
1144: jjCheckNAddTwoStates(7, 8);
1145: break;
1146: case 9:
1147: if (curChar == 39)
1148: jjAddStates(15, 16);
1149: break;
1150: case 10:
1151: if ((0xffffff7fffffdbffL & l) != 0L)
1152: jjCheckNAdd(11);
1153: break;
1154: case 11:
1155: if (curChar == 39 && kind > 69)
1156: kind = 69;
1157: break;
1158: case 13:
1159: if ((0x8400000000L & l) != 0L)
1160: jjCheckNAdd(11);
1161: break;
1162: case 14:
1163: if ((0xff000000000000L & l) != 0L)
1164: jjCheckNAddTwoStates(15, 11);
1165: break;
1166: case 15:
1167: if ((0xff000000000000L & l) != 0L)
1168: jjCheckNAdd(11);
1169: break;
1170: case 16:
1171: if ((0xf000000000000L & l) != 0L)
1172: jjstateSet[jjnewStateCnt++] = 17;
1173: break;
1174: case 17:
1175: if ((0xff000000000000L & l) != 0L)
1176: jjCheckNAdd(15);
1177: break;
1178: case 18:
1179: if (curChar == 34)
1180: jjCheckNAddStates(12, 14);
1181: break;
1182: case 19:
1183: if ((0xfffffffbffffdbffL & l) != 0L)
1184: jjCheckNAddStates(12, 14);
1185: break;
1186: case 21:
1187: if ((0x8400000000L & l) != 0L)
1188: jjCheckNAddStates(12, 14);
1189: break;
1190: case 22:
1191: if (curChar == 34 && kind > 70)
1192: kind = 70;
1193: break;
1194: case 23:
1195: if ((0xff000000000000L & l) != 0L)
1196: jjCheckNAddStates(23, 26);
1197: break;
1198: case 24:
1199: if ((0xff000000000000L & l) != 0L)
1200: jjCheckNAddStates(12, 14);
1201: break;
1202: case 25:
1203: if ((0xf000000000000L & l) != 0L)
1204: jjstateSet[jjnewStateCnt++] = 26;
1205: break;
1206: case 26:
1207: if ((0xff000000000000L & l) != 0L)
1208: jjCheckNAdd(24);
1209: break;
1210: case 27:
1211: if (curChar != 36)
1212: break;
1213: if (kind > 71)
1214: kind = 71;
1215: jjCheckNAdd(28);
1216: break;
1217: case 28:
1218: if ((0x3ff00100fffc1ffL & l) == 0L)
1219: break;
1220: if (kind > 71)
1221: kind = 71;
1222: jjCheckNAdd(28);
1223: break;
1224: case 29:
1225: if ((0x3ff000000000000L & l) != 0L)
1226: jjCheckNAddStates(3, 9);
1227: break;
1228: case 30:
1229: if ((0x3ff000000000000L & l) != 0L)
1230: jjCheckNAddTwoStates(30, 31);
1231: break;
1232: case 31:
1233: if (curChar != 46)
1234: break;
1235: if (kind > 67)
1236: kind = 67;
1237: jjCheckNAddStates(27, 29);
1238: break;
1239: case 32:
1240: if ((0x3ff000000000000L & l) == 0L)
1241: break;
1242: if (kind > 67)
1243: kind = 67;
1244: jjCheckNAddStates(27, 29);
1245: break;
1246: case 34:
1247: if ((0x280000000000L & l) != 0L)
1248: jjCheckNAdd(35);
1249: break;
1250: case 35:
1251: if ((0x3ff000000000000L & l) == 0L)
1252: break;
1253: if (kind > 67)
1254: kind = 67;
1255: jjCheckNAddTwoStates(35, 8);
1256: break;
1257: case 36:
1258: if ((0x3ff000000000000L & l) != 0L)
1259: jjCheckNAddTwoStates(36, 37);
1260: break;
1261: case 38:
1262: if ((0x280000000000L & l) != 0L)
1263: jjCheckNAdd(39);
1264: break;
1265: case 39:
1266: if ((0x3ff000000000000L & l) == 0L)
1267: break;
1268: if (kind > 67)
1269: kind = 67;
1270: jjCheckNAddTwoStates(39, 8);
1271: break;
1272: case 40:
1273: if ((0x3ff000000000000L & l) != 0L)
1274: jjCheckNAddStates(30, 32);
1275: break;
1276: case 42:
1277: if ((0x280000000000L & l) != 0L)
1278: jjCheckNAdd(43);
1279: break;
1280: case 43:
1281: if ((0x3ff000000000000L & l) != 0L)
1282: jjCheckNAddTwoStates(43, 8);
1283: break;
1284: case 44:
1285: if (curChar != 48)
1286: break;
1287: if (kind > 63)
1288: kind = 63;
1289: jjCheckNAddStates(17, 19);
1290: break;
1291: case 46:
1292: if ((0x3ff000000000000L & l) == 0L)
1293: break;
1294: if (kind > 63)
1295: kind = 63;
1296: jjCheckNAddTwoStates(46, 2);
1297: break;
1298: case 47:
1299: if ((0xff000000000000L & l) == 0L)
1300: break;
1301: if (kind > 63)
1302: kind = 63;
1303: jjCheckNAddTwoStates(47, 2);
1304: break;
1305: case 48:
1306: if (curChar == 47)
1307: jjAddStates(10, 11);
1308: break;
1309: case 50:
1310: if ((0xffffffffffffdbffL & l) == 0L)
1311: break;
1312: if (kind > 6)
1313: kind = 6;
1314: jjCheckNAddStates(0, 2);
1315: break;
1316: case 51:
1317: if ((0x2400L & l) != 0L && kind > 6)
1318: kind = 6;
1319: break;
1320: case 52:
1321: if (curChar == 10 && kind > 6)
1322: kind = 6;
1323: break;
1324: case 53:
1325: if (curChar == 13)
1326: jjstateSet[jjnewStateCnt++] = 52;
1327: break;
1328: case 54:
1329: if (curChar == 42)
1330: jjstateSet[jjnewStateCnt++] = 55;
1331: break;
1332: case 55:
1333: if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
1334: kind = 7;
1335: break;
1336: case 56:
1337: if (curChar == 42)
1338: jjstateSet[jjnewStateCnt++] = 54;
1339: break;
1340: default:
1341: break;
1342: }
1343: } while (i != startsAt);
1344: } else if (curChar < 128) {
1345: long l = 1L << (curChar & 077);
1346: MatchLoop: do {
1347: switch (jjstateSet[--i]) {
1348: case 0:
1349: if ((0x7fffffe87fffffeL & l) == 0L)
1350: break;
1351: if (kind > 71)
1352: kind = 71;
1353: jjCheckNAdd(28);
1354: break;
1355: case 2:
1356: if ((0x100000001000L & l) != 0L && kind > 63)
1357: kind = 63;
1358: break;
1359: case 5:
1360: if ((0x2000000020L & l) != 0L)
1361: jjAddStates(33, 34);
1362: break;
1363: case 8:
1364: if ((0x5000000050L & l) != 0L && kind > 67)
1365: kind = 67;
1366: break;
1367: case 10:
1368: if ((0xffffffffefffffffL & l) != 0L)
1369: jjCheckNAdd(11);
1370: break;
1371: case 12:
1372: if (curChar == 92)
1373: jjAddStates(35, 37);
1374: break;
1375: case 13:
1376: if ((0x14404410000000L & l) != 0L)
1377: jjCheckNAdd(11);
1378: break;
1379: case 19:
1380: if ((0xffffffffefffffffL & l) != 0L)
1381: jjCheckNAddStates(12, 14);
1382: break;
1383: case 20:
1384: if (curChar == 92)
1385: jjAddStates(38, 40);
1386: break;
1387: case 21:
1388: if ((0x14404410000000L & l) != 0L)
1389: jjCheckNAddStates(12, 14);
1390: break;
1391: case 28:
1392: if ((0x87fffffe87fffffeL & l) == 0L)
1393: break;
1394: if (kind > 71)
1395: kind = 71;
1396: jjCheckNAdd(28);
1397: break;
1398: case 33:
1399: if ((0x2000000020L & l) != 0L)
1400: jjAddStates(41, 42);
1401: break;
1402: case 37:
1403: if ((0x2000000020L & l) != 0L)
1404: jjAddStates(43, 44);
1405: break;
1406: case 41:
1407: if ((0x2000000020L & l) != 0L)
1408: jjAddStates(45, 46);
1409: break;
1410: case 45:
1411: if ((0x100000001000000L & l) != 0L)
1412: jjCheckNAdd(46);
1413: break;
1414: case 46:
1415: if ((0x7e0000007eL & l) == 0L)
1416: break;
1417: if (kind > 63)
1418: kind = 63;
1419: jjCheckNAddTwoStates(46, 2);
1420: break;
1421: case 50:
1422: if (kind > 6)
1423: kind = 6;
1424: jjAddStates(0, 2);
1425: break;
1426: case 55:
1427: if (kind > 7)
1428: kind = 7;
1429: break;
1430: default:
1431: break;
1432: }
1433: } while (i != startsAt);
1434: } else {
1435: int hiByte = (int) (curChar >> 8);
1436: int i1 = hiByte >> 6;
1437: long l1 = 1L << (hiByte & 077);
1438: int i2 = (curChar & 0xff) >> 6;
1439: long l2 = 1L << (curChar & 077);
1440: MatchLoop: do {
1441: switch (jjstateSet[--i]) {
1442: case 0:
1443: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1444: break;
1445: if (kind > 71)
1446: kind = 71;
1447: jjCheckNAdd(28);
1448: break;
1449: case 10:
1450: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1451: jjstateSet[jjnewStateCnt++] = 11;
1452: break;
1453: case 19:
1454: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1455: jjAddStates(12, 14);
1456: break;
1457: case 28:
1458: if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1459: break;
1460: if (kind > 71)
1461: kind = 71;
1462: jjCheckNAdd(28);
1463: break;
1464: case 50:
1465: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1466: break;
1467: if (kind > 6)
1468: kind = 6;
1469: jjAddStates(0, 2);
1470: break;
1471: case 55:
1472: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1473: && kind > 7)
1474: kind = 7;
1475: break;
1476: default:
1477: break;
1478: }
1479: } while (i != startsAt);
1480: }
1481: if (kind != 0x7fffffff) {
1482: jjmatchedKind = kind;
1483: jjmatchedPos = curPos;
1484: kind = 0x7fffffff;
1485: }
1486: ++curPos;
1487: if ((i = jjnewStateCnt) == (startsAt = 57 - (jjnewStateCnt = startsAt)))
1488: return curPos;
1489: try {
1490: curChar = input_stream.readChar();
1491: } catch (java.io.IOException e) {
1492: return curPos;
1493: }
1494: }
1495: }
1496:
1497: private final int jjMoveStringLiteralDfa0_2() {
1498: switch (curChar) {
1499: case 42:
1500: return jjMoveStringLiteralDfa1_2(0x400L);
1501: default:
1502: return 1;
1503: }
1504: }
1505:
1506: private final int jjMoveStringLiteralDfa1_2(long active0) {
1507: try {
1508: curChar = input_stream.readChar();
1509: } catch (java.io.IOException e) {
1510: return 1;
1511: }
1512: switch (curChar) {
1513: case 47:
1514: if ((active0 & 0x400L) != 0L)
1515: return jjStopAtPos(1, 10);
1516: break;
1517: default:
1518: return 2;
1519: }
1520: return 2;
1521: }
1522:
1523: private final int jjMoveStringLiteralDfa0_1() {
1524: switch (curChar) {
1525: case 42:
1526: return jjMoveStringLiteralDfa1_1(0x200L);
1527: default:
1528: return 1;
1529: }
1530: }
1531:
1532: private final int jjMoveStringLiteralDfa1_1(long active0) {
1533: try {
1534: curChar = input_stream.readChar();
1535: } catch (java.io.IOException e) {
1536: return 1;
1537: }
1538: switch (curChar) {
1539: case 47:
1540: if ((active0 & 0x200L) != 0L)
1541: return jjStopAtPos(1, 9);
1542: break;
1543: default:
1544: return 2;
1545: }
1546: return 2;
1547: }
1548:
1549: static final int[] jjnextStates = { 50, 51, 53, 30, 31, 36, 37, 40,
1550: 41, 8, 49, 56, 19, 20, 22, 10, 12, 45, 47, 2, 4, 5, 8, 19,
1551: 20, 24, 22, 32, 33, 8, 40, 41, 8, 6, 7, 13, 14, 16, 21, 23,
1552: 25, 34, 35, 38, 39, 42, 43, };
1553:
1554: private static final boolean jjCanMove_0(int hiByte, int i1,
1555: int i2, long l1, long l2) {
1556: switch (hiByte) {
1557: case 0:
1558: return ((jjbitVec2[i2] & l2) != 0L);
1559: default:
1560: if ((jjbitVec0[i1] & l1) != 0L)
1561: return true;
1562: return false;
1563: }
1564: }
1565:
1566: private static final boolean jjCanMove_1(int hiByte, int i1,
1567: int i2, long l1, long l2) {
1568: switch (hiByte) {
1569: case 0:
1570: return ((jjbitVec4[i2] & l2) != 0L);
1571: case 2:
1572: return ((jjbitVec5[i2] & l2) != 0L);
1573: case 3:
1574: return ((jjbitVec6[i2] & l2) != 0L);
1575: case 4:
1576: return ((jjbitVec7[i2] & l2) != 0L);
1577: case 5:
1578: return ((jjbitVec8[i2] & l2) != 0L);
1579: case 6:
1580: return ((jjbitVec9[i2] & l2) != 0L);
1581: case 7:
1582: return ((jjbitVec10[i2] & l2) != 0L);
1583: case 9:
1584: return ((jjbitVec11[i2] & l2) != 0L);
1585: case 10:
1586: return ((jjbitVec12[i2] & l2) != 0L);
1587: case 11:
1588: return ((jjbitVec13[i2] & l2) != 0L);
1589: case 12:
1590: return ((jjbitVec14[i2] & l2) != 0L);
1591: case 13:
1592: return ((jjbitVec15[i2] & l2) != 0L);
1593: case 14:
1594: return ((jjbitVec16[i2] & l2) != 0L);
1595: case 15:
1596: return ((jjbitVec17[i2] & l2) != 0L);
1597: case 16:
1598: return ((jjbitVec18[i2] & l2) != 0L);
1599: case 17:
1600: return ((jjbitVec19[i2] & l2) != 0L);
1601: case 18:
1602: return ((jjbitVec20[i2] & l2) != 0L);
1603: case 19:
1604: return ((jjbitVec21[i2] & l2) != 0L);
1605: case 20:
1606: return ((jjbitVec0[i2] & l2) != 0L);
1607: case 22:
1608: return ((jjbitVec22[i2] & l2) != 0L);
1609: case 23:
1610: return ((jjbitVec23[i2] & l2) != 0L);
1611: case 24:
1612: return ((jjbitVec24[i2] & l2) != 0L);
1613: case 30:
1614: return ((jjbitVec25[i2] & l2) != 0L);
1615: case 31:
1616: return ((jjbitVec26[i2] & l2) != 0L);
1617: case 32:
1618: return ((jjbitVec27[i2] & l2) != 0L);
1619: case 33:
1620: return ((jjbitVec28[i2] & l2) != 0L);
1621: case 48:
1622: return ((jjbitVec29[i2] & l2) != 0L);
1623: case 49:
1624: return ((jjbitVec30[i2] & l2) != 0L);
1625: case 77:
1626: return ((jjbitVec31[i2] & l2) != 0L);
1627: case 159:
1628: return ((jjbitVec32[i2] & l2) != 0L);
1629: case 164:
1630: return ((jjbitVec33[i2] & l2) != 0L);
1631: case 215:
1632: return ((jjbitVec34[i2] & l2) != 0L);
1633: case 250:
1634: return ((jjbitVec35[i2] & l2) != 0L);
1635: case 251:
1636: return ((jjbitVec36[i2] & l2) != 0L);
1637: case 253:
1638: return ((jjbitVec37[i2] & l2) != 0L);
1639: case 254:
1640: return ((jjbitVec38[i2] & l2) != 0L);
1641: case 255:
1642: return ((jjbitVec39[i2] & l2) != 0L);
1643: default:
1644: if ((jjbitVec3[i1] & l1) != 0L)
1645: return true;
1646: return false;
1647: }
1648: }
1649:
1650: private static final boolean jjCanMove_2(int hiByte, int i1,
1651: int i2, long l1, long l2) {
1652: switch (hiByte) {
1653: case 0:
1654: return ((jjbitVec40[i2] & l2) != 0L);
1655: case 2:
1656: return ((jjbitVec5[i2] & l2) != 0L);
1657: case 3:
1658: return ((jjbitVec41[i2] & l2) != 0L);
1659: case 4:
1660: return ((jjbitVec42[i2] & l2) != 0L);
1661: case 5:
1662: return ((jjbitVec43[i2] & l2) != 0L);
1663: case 6:
1664: return ((jjbitVec44[i2] & l2) != 0L);
1665: case 7:
1666: return ((jjbitVec45[i2] & l2) != 0L);
1667: case 9:
1668: return ((jjbitVec46[i2] & l2) != 0L);
1669: case 10:
1670: return ((jjbitVec47[i2] & l2) != 0L);
1671: case 11:
1672: return ((jjbitVec48[i2] & l2) != 0L);
1673: case 12:
1674: return ((jjbitVec49[i2] & l2) != 0L);
1675: case 13:
1676: return ((jjbitVec50[i2] & l2) != 0L);
1677: case 14:
1678: return ((jjbitVec51[i2] & l2) != 0L);
1679: case 15:
1680: return ((jjbitVec52[i2] & l2) != 0L);
1681: case 16:
1682: return ((jjbitVec53[i2] & l2) != 0L);
1683: case 17:
1684: return ((jjbitVec19[i2] & l2) != 0L);
1685: case 18:
1686: return ((jjbitVec20[i2] & l2) != 0L);
1687: case 19:
1688: return ((jjbitVec54[i2] & l2) != 0L);
1689: case 20:
1690: return ((jjbitVec0[i2] & l2) != 0L);
1691: case 22:
1692: return ((jjbitVec22[i2] & l2) != 0L);
1693: case 23:
1694: return ((jjbitVec55[i2] & l2) != 0L);
1695: case 24:
1696: return ((jjbitVec56[i2] & l2) != 0L);
1697: case 30:
1698: return ((jjbitVec25[i2] & l2) != 0L);
1699: case 31:
1700: return ((jjbitVec26[i2] & l2) != 0L);
1701: case 32:
1702: return ((jjbitVec57[i2] & l2) != 0L);
1703: case 33:
1704: return ((jjbitVec28[i2] & l2) != 0L);
1705: case 48:
1706: return ((jjbitVec58[i2] & l2) != 0L);
1707: case 49:
1708: return ((jjbitVec30[i2] & l2) != 0L);
1709: case 77:
1710: return ((jjbitVec31[i2] & l2) != 0L);
1711: case 159:
1712: return ((jjbitVec32[i2] & l2) != 0L);
1713: case 164:
1714: return ((jjbitVec33[i2] & l2) != 0L);
1715: case 215:
1716: return ((jjbitVec34[i2] & l2) != 0L);
1717: case 250:
1718: return ((jjbitVec35[i2] & l2) != 0L);
1719: case 251:
1720: return ((jjbitVec59[i2] & l2) != 0L);
1721: case 253:
1722: return ((jjbitVec37[i2] & l2) != 0L);
1723: case 254:
1724: return ((jjbitVec60[i2] & l2) != 0L);
1725: case 255:
1726: return ((jjbitVec61[i2] & l2) != 0L);
1727: default:
1728: if ((jjbitVec3[i1] & l1) != 0L)
1729: return true;
1730: return false;
1731: }
1732: }
1733:
1734: public static final String[] jjstrLiteralImages = { "", null, null,
1735: null, null, null, null, null, null, null, null, null,
1736: "\141\142\163\164\162\141\143\164",
1737: "\142\157\157\154\145\141\156", "\142\162\145\141\153",
1738: "\142\171\164\145", "\143\141\163\145",
1739: "\143\141\164\143\150", "\143\150\141\162",
1740: "\143\154\141\163\163", "\143\157\156\163\164",
1741: "\143\157\156\164\151\156\165\145",
1742: "\144\145\146\141\165\154\164", "\144\157",
1743: "\144\157\165\142\154\145", "\145\154\163\145",
1744: "\145\170\164\145\156\144\163", "\146\141\154\163\145",
1745: "\146\151\156\141\154", "\146\151\156\141\154\154\171",
1746: "\146\154\157\141\164", "\146\157\162", "\147\157\164\157",
1747: "\151\146", "\151\155\160\154\145\155\145\156\164\163",
1748: "\151\155\160\157\162\164",
1749: "\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
1750: "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
1751: "\156\141\164\151\166\145", "\156\145\167",
1752: "\156\165\154\154", "\160\141\143\153\141\147\145",
1753: "\160\162\151\166\141\164\145",
1754: "\160\162\157\164\145\143\164\145\144",
1755: "\160\165\142\154\151\143", "\162\145\164\165\162\156",
1756: "\163\150\157\162\164", "\163\164\141\164\151\143",
1757: "\163\165\160\145\162", "\163\167\151\164\143\150",
1758: "\163\171\156\143\150\162\157\156\151\172\145\144",
1759: "\164\150\151\163", "\164\150\162\157\167",
1760: "\164\150\162\157\167\163",
1761: "\164\162\141\156\163\151\145\156\164", "\164\162\165\145",
1762: "\164\162\171", "\166\157\151\144",
1763: "\166\157\154\141\164\151\154\145", "\167\150\151\154\145",
1764: "\163\164\162\151\143\164\146\160", null, null, null, null,
1765: null, null, null, null, null, null, null, "\50", "\51",
1766: "\173", "\175", "\133", "\135", "\73", "\54", "\56",
1767: "\100", "\75", "\74", "\41", "\176", "\77", "\72",
1768: "\75\75", "\74\75", "\76\75", "\41\75", "\174\174",
1769: "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57",
1770: "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75",
1771: "\52\75", "\57\75", "\46\75", "\174\75", "\136\75",
1772: "\45\75", "\74\74\75", "\76\76\75", "\76\76\76\75",
1773: "\56\56\56", "\76\76\76", "\76\76", "\76", "\32",
1774: "\176\133\135", };
1775: public static final String[] lexStateNames = { "DEFAULT",
1776: "IN_FORMAL_COMMENT", "IN_MULTI_LINE_COMMENT", };
1777: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
1778: -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1779: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1780: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1781: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1782: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1783: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1784: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1785: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, };
1786: static final long[] jjtoToken = { 0xfffffffffffff001L,
1787: 0xffffffffffffce8L, };
1788: static final long[] jjtoSkip = { 0x67eL, 0x0L, };
1789: static final long[] jjtoSpecial = { 0x67eL, 0x0L, };
1790: static final long[] jjtoMore = { 0x980L, 0x0L, };
1791: protected CharStream input_stream;
1792: private final int[] jjrounds = new int[57];
1793: private final int[] jjstateSet = new int[114];
1794: StringBuffer image;
1795: int jjimageLen;
1796: int lengthOfMatch;
1797: protected char curChar;
1798:
1799: public JavaParserTokenManager(CharStream stream) {
1800: input_stream = stream;
1801: }
1802:
1803: public JavaParserTokenManager(CharStream stream, int lexState) {
1804: this (stream);
1805: SwitchTo(lexState);
1806: }
1807:
1808: public void ReInit(CharStream stream) {
1809: jjmatchedPos = jjnewStateCnt = 0;
1810: curLexState = defaultLexState;
1811: input_stream = stream;
1812: ReInitRounds();
1813: }
1814:
1815: private final void ReInitRounds() {
1816: int i;
1817: jjround = 0x80000001;
1818: for (i = 57; i-- > 0;)
1819: jjrounds[i] = 0x80000000;
1820: }
1821:
1822: public void ReInit(CharStream stream, int lexState) {
1823: ReInit(stream);
1824: SwitchTo(lexState);
1825: }
1826:
1827: public void SwitchTo(int lexState) {
1828: if (lexState >= 3 || lexState < 0)
1829: throw new TokenMgrError(
1830: "Error: Ignoring invalid lexical state : "
1831: + lexState + ". State unchanged.",
1832: TokenMgrError.INVALID_LEXICAL_STATE);
1833: else
1834: curLexState = lexState;
1835: }
1836:
1837: protected Token jjFillToken() {
1838: Token t = Token.newToken(jjmatchedKind);
1839: t.kind = jjmatchedKind;
1840: String im = jjstrLiteralImages[jjmatchedKind];
1841: t.image = (im == null) ? input_stream.GetImage() : im;
1842: t.beginLine = input_stream.getBeginLine();
1843: t.beginColumn = input_stream.getBeginColumn();
1844: t.endLine = input_stream.getEndLine();
1845: t.endColumn = input_stream.getEndColumn();
1846: return t;
1847: }
1848:
1849: int curLexState = 0;
1850: int defaultLexState = 0;
1851: int jjnewStateCnt;
1852: int jjround;
1853: int jjmatchedPos;
1854: int jjmatchedKind;
1855:
1856: public Token getNextToken() {
1857: int kind;
1858: Token specialToken = null;
1859: Token matchedToken;
1860: int curPos = 0;
1861:
1862: EOFLoop: for (;;) {
1863: try {
1864: curChar = input_stream.BeginToken();
1865: } catch (java.io.IOException e) {
1866: jjmatchedKind = 0;
1867: matchedToken = jjFillToken();
1868: matchedToken.specialToken = specialToken;
1869: return matchedToken;
1870: }
1871: image = null;
1872: jjimageLen = 0;
1873:
1874: for (;;) {
1875: switch (curLexState) {
1876: case 0:
1877: jjmatchedKind = 0x7fffffff;
1878: jjmatchedPos = 0;
1879: curPos = jjMoveStringLiteralDfa0_0();
1880: break;
1881: case 1:
1882: jjmatchedKind = 0x7fffffff;
1883: jjmatchedPos = 0;
1884: curPos = jjMoveStringLiteralDfa0_1();
1885: if (jjmatchedPos == 0 && jjmatchedKind > 11) {
1886: jjmatchedKind = 11;
1887: }
1888: break;
1889: case 2:
1890: jjmatchedKind = 0x7fffffff;
1891: jjmatchedPos = 0;
1892: curPos = jjMoveStringLiteralDfa0_2();
1893: if (jjmatchedPos == 0 && jjmatchedKind > 11) {
1894: jjmatchedKind = 11;
1895: }
1896: break;
1897: }
1898: if (jjmatchedKind != 0x7fffffff) {
1899: if (jjmatchedPos + 1 < curPos)
1900: input_stream.backup(curPos - jjmatchedPos - 1);
1901: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1902: matchedToken = jjFillToken();
1903: matchedToken.specialToken = specialToken;
1904: TokenLexicalActions(matchedToken);
1905: if (jjnewLexState[jjmatchedKind] != -1)
1906: curLexState = jjnewLexState[jjmatchedKind];
1907: return matchedToken;
1908: } else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1909: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1910: matchedToken = jjFillToken();
1911: if (specialToken == null)
1912: specialToken = matchedToken;
1913: else {
1914: matchedToken.specialToken = specialToken;
1915: specialToken = (specialToken.next = matchedToken);
1916: }
1917: SkipLexicalActions(matchedToken);
1918: } else
1919: SkipLexicalActions(null);
1920: if (jjnewLexState[jjmatchedKind] != -1)
1921: curLexState = jjnewLexState[jjmatchedKind];
1922: continue EOFLoop;
1923: }
1924: MoreLexicalActions();
1925: if (jjnewLexState[jjmatchedKind] != -1)
1926: curLexState = jjnewLexState[jjmatchedKind];
1927: curPos = 0;
1928: jjmatchedKind = 0x7fffffff;
1929: try {
1930: curChar = input_stream.readChar();
1931: continue;
1932: } catch (java.io.IOException e1) {
1933: }
1934: }
1935: int error_line = input_stream.getEndLine();
1936: int error_column = input_stream.getEndColumn();
1937: String error_after = null;
1938: boolean EOFSeen = false;
1939: try {
1940: input_stream.readChar();
1941: input_stream.backup(1);
1942: } catch (java.io.IOException e1) {
1943: EOFSeen = true;
1944: error_after = curPos <= 1 ? "" : input_stream
1945: .GetImage();
1946: if (curChar == '\n' || curChar == '\r') {
1947: error_line++;
1948: error_column = 0;
1949: } else
1950: error_column++;
1951: }
1952: if (!EOFSeen) {
1953: input_stream.backup(1);
1954: error_after = curPos <= 1 ? "" : input_stream
1955: .GetImage();
1956: }
1957: throw new TokenMgrError(EOFSeen, curLexState,
1958: error_line, error_column, error_after, curChar,
1959: TokenMgrError.LEXICAL_ERROR);
1960: }
1961: }
1962: }
1963:
1964: void SkipLexicalActions(Token matchedToken) {
1965: switch (jjmatchedKind) {
1966: default:
1967: break;
1968: }
1969: }
1970:
1971: void MoreLexicalActions() {
1972: jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1973: switch (jjmatchedKind) {
1974: case 7:
1975: if (image == null)
1976: image = new StringBuffer();
1977: image.append(input_stream.GetSuffix(jjimageLen));
1978: jjimageLen = 0;
1979: input_stream.backup(1);
1980: break;
1981: default:
1982: break;
1983: }
1984: }
1985:
1986: void TokenLexicalActions(Token matchedToken) {
1987: switch (jjmatchedKind) {
1988: case 119:
1989: if (image == null)
1990: image = new StringBuffer();
1991: image.append(jjstrLiteralImages[119]);
1992: matchedToken.kind = GT;
1993: ((Token.GTToken) matchedToken).realKind = RUNSIGNEDSHIFT;
1994: input_stream.backup(2);
1995: matchedToken.image = ">";
1996: break;
1997: case 120:
1998: if (image == null)
1999: image = new StringBuffer();
2000: image.append(jjstrLiteralImages[120]);
2001: matchedToken.kind = GT;
2002: ((Token.GTToken) matchedToken).realKind = RSIGNEDSHIFT;
2003: input_stream.backup(1);
2004: matchedToken.image = ">";
2005: break;
2006: default:
2007: break;
2008: }
2009: }
2010: }
|