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