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