0001: /* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */
0002: package org.gjt.sp.jedit.bsh;
0003:
0004: public class ParserTokenManager implements ParserConstants {
0005: public java.io.PrintStream debugStream = System.out;
0006:
0007: public void setDebugStream(java.io.PrintStream ds) {
0008: debugStream = ds;
0009: }
0010:
0011: private final int jjStopStringLiteralDfa_0(int pos, long active0,
0012: long active1, long active2) {
0013: switch (pos) {
0014: case 0:
0015: if ((active1 & 0x200020000000000L) != 0L)
0016: return 56;
0017: if ((active0 & 0x3eL) != 0L)
0018: return 0;
0019: if ((active1 & 0x10000L) != 0L)
0020: return 11;
0021: if ((active0 & 0xffffffffffffc00L) != 0L) {
0022: jjmatchedKind = 69;
0023: return 35;
0024: }
0025: return -1;
0026: case 1:
0027: if ((active0 & 0x100600000L) != 0L)
0028: return 35;
0029: if ((active0 & 0xffffffeff9ffc00L) != 0L) {
0030: if (jjmatchedPos != 1) {
0031: jjmatchedKind = 69;
0032: jjmatchedPos = 1;
0033: }
0034: return 35;
0035: }
0036: return -1;
0037: case 2:
0038: if ((active0 & 0xefffecebfdffc00L) != 0L) {
0039: if (jjmatchedPos != 2) {
0040: jjmatchedKind = 69;
0041: jjmatchedPos = 2;
0042: }
0043: return 35;
0044: }
0045: if ((active0 & 0x100013040000000L) != 0L)
0046: return 35;
0047: return -1;
0048: case 3:
0049: if ((active0 & 0xc7ffcae3e5d3c00L) != 0L) {
0050: if (jjmatchedPos != 3) {
0051: jjmatchedKind = 69;
0052: jjmatchedPos = 3;
0053: }
0054: return 35;
0055: }
0056: if ((active0 & 0x28002408182c000L) != 0L)
0057: return 35;
0058: return -1;
0059: case 4:
0060: if ((active0 & 0x86080003c053000L) != 0L)
0061: return 35;
0062: if ((active0 & 0x41f7cae02580c00L) != 0L) {
0063: if (jjmatchedPos != 4) {
0064: jjmatchedKind = 69;
0065: jjmatchedPos = 4;
0066: }
0067: return 35;
0068: }
0069: return -1;
0070: case 5:
0071: if ((active0 & 0x41a1c2a12180c00L) != 0L) {
0072: jjmatchedKind = 69;
0073: jjmatchedPos = 5;
0074: return 35;
0075: }
0076: if ((active0 & 0x45608400400000L) != 0L)
0077: return 35;
0078: return -1;
0079: case 6:
0080: if ((active0 & 0x41a102a00080400L) != 0L) {
0081: jjmatchedKind = 69;
0082: jjmatchedPos = 6;
0083: return 35;
0084: }
0085: if ((active0 & 0xc0012100800L) != 0L)
0086: return 35;
0087: return -1;
0088: case 7:
0089: if ((active0 & 0x402000000080400L) != 0L)
0090: return 35;
0091: if ((active0 & 0x18102a00000000L) != 0L) {
0092: jjmatchedKind = 69;
0093: jjmatchedPos = 7;
0094: return 35;
0095: }
0096: return -1;
0097: case 8:
0098: if ((active0 & 0x8000a00000000L) != 0L) {
0099: jjmatchedKind = 69;
0100: jjmatchedPos = 8;
0101: return 35;
0102: }
0103: if ((active0 & 0x10102000000000L) != 0L)
0104: return 35;
0105: return -1;
0106: case 9:
0107: if ((active0 & 0x8000000000000L) != 0L) {
0108: jjmatchedKind = 69;
0109: jjmatchedPos = 9;
0110: return 35;
0111: }
0112: if ((active0 & 0xa00000000L) != 0L)
0113: return 35;
0114: return -1;
0115: case 10:
0116: if ((active0 & 0x8000000000000L) != 0L) {
0117: if (jjmatchedPos != 10) {
0118: jjmatchedKind = 69;
0119: jjmatchedPos = 10;
0120: }
0121: return 35;
0122: }
0123: return -1;
0124: case 11:
0125: if ((active0 & 0x8000000000000L) != 0L)
0126: return 35;
0127: return -1;
0128: default:
0129: return -1;
0130: }
0131: }
0132:
0133: private final int jjStartNfa_0(int pos, long active0, long active1,
0134: long active2) {
0135: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
0136: active1, active2), pos + 1);
0137: }
0138:
0139: private final int jjStopAtPos(int pos, int kind) {
0140: jjmatchedKind = kind;
0141: jjmatchedPos = pos;
0142: return pos + 1;
0143: }
0144:
0145: private final int jjStartNfaWithStates_0(int pos, int kind,
0146: int state) {
0147: jjmatchedKind = kind;
0148: jjmatchedPos = pos;
0149: try {
0150: curChar = input_stream.readChar();
0151: } catch (java.io.IOException e) {
0152: return pos + 1;
0153: }
0154: return jjMoveNfa_0(state, pos + 1);
0155: }
0156:
0157: private final int jjMoveStringLiteralDfa0_0() {
0158: switch (curChar) {
0159: case 9:
0160: return jjStartNfaWithStates_0(0, 2, 0);
0161: case 10:
0162: return jjStartNfaWithStates_0(0, 5, 0);
0163: case 12:
0164: return jjStartNfaWithStates_0(0, 4, 0);
0165: case 13:
0166: return jjStartNfaWithStates_0(0, 3, 0);
0167: case 32:
0168: return jjStartNfaWithStates_0(0, 1, 0);
0169: case 33:
0170: jjmatchedKind = 86;
0171: return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L, 0x0L);
0172: case 37:
0173: jjmatchedKind = 111;
0174: return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000000L,
0175: 0x0L);
0176: case 38:
0177: jjmatchedKind = 106;
0178: return jjMoveStringLiteralDfa1_0(0x0L, 0x400000400000000L,
0179: 0x0L);
0180: case 40:
0181: return jjStopAtPos(0, 72);
0182: case 41:
0183: return jjStopAtPos(0, 73);
0184: case 42:
0185: jjmatchedKind = 104;
0186: return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000000L,
0187: 0x0L);
0188: case 43:
0189: jjmatchedKind = 102;
0190: return jjMoveStringLiteralDfa1_0(0x0L, 0x40001000000000L,
0191: 0x0L);
0192: case 44:
0193: return jjStopAtPos(0, 79);
0194: case 45:
0195: jjmatchedKind = 103;
0196: return jjMoveStringLiteralDfa1_0(0x0L, 0x80002000000000L,
0197: 0x0L);
0198: case 46:
0199: return jjStartNfaWithStates_0(0, 80, 11);
0200: case 47:
0201: jjmatchedKind = 105;
0202: return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000000000L,
0203: 0x0L);
0204: case 58:
0205: return jjStopAtPos(0, 89);
0206: case 59:
0207: return jjStopAtPos(0, 78);
0208: case 60:
0209: jjmatchedKind = 84;
0210: return jjMoveStringLiteralDfa1_0(0x0L, 0x1000008000000L,
0211: 0x1L);
0212: case 61:
0213: jjmatchedKind = 81;
0214: return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L, 0x0L);
0215: case 62:
0216: jjmatchedKind = 82;
0217: return jjMoveStringLiteralDfa1_0(0x0L, 0x14000020000000L,
0218: 0x14L);
0219: case 63:
0220: return jjStopAtPos(0, 88);
0221: case 64:
0222: return jjMoveStringLiteralDfa1_0(0x0L, 0x282a280a50280000L,
0223: 0x2aL);
0224: case 91:
0225: return jjStopAtPos(0, 76);
0226: case 93:
0227: return jjStopAtPos(0, 77);
0228: case 94:
0229: jjmatchedKind = 110;
0230: return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000000L,
0231: 0x0L);
0232: case 97:
0233: return jjMoveStringLiteralDfa1_0(0x400L, 0x0L, 0x0L);
0234: case 98:
0235: return jjMoveStringLiteralDfa1_0(0x5800L, 0x0L, 0x0L);
0236: case 99:
0237: return jjMoveStringLiteralDfa1_0(0xfa000L, 0x0L, 0x0L);
0238: case 100:
0239: return jjMoveStringLiteralDfa1_0(0x700000L, 0x0L, 0x0L);
0240: case 101:
0241: return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L, 0x0L);
0242: case 102:
0243: return jjMoveStringLiteralDfa1_0(0x7c000000L, 0x0L, 0x0L);
0244: case 103:
0245: return jjMoveStringLiteralDfa1_0(0x80000000L, 0x0L, 0x0L);
0246: case 105:
0247: return jjMoveStringLiteralDfa1_0(0x3f00000000L, 0x0L, 0x0L);
0248: case 108:
0249: return jjMoveStringLiteralDfa1_0(0x4000000000L, 0x0L, 0x0L);
0250: case 110:
0251: return jjMoveStringLiteralDfa1_0(0x38000000000L, 0x0L, 0x0L);
0252: case 112:
0253: return jjMoveStringLiteralDfa1_0(0x3c0000000000L, 0x0L,
0254: 0x0L);
0255: case 114:
0256: return jjMoveStringLiteralDfa1_0(0x400000000000L, 0x0L,
0257: 0x0L);
0258: case 115:
0259: return jjMoveStringLiteralDfa1_0(0xf800000000000L, 0x0L,
0260: 0x0L);
0261: case 116:
0262: return jjMoveStringLiteralDfa1_0(0x1f0000000000000L, 0x0L,
0263: 0x0L);
0264: case 118:
0265: return jjMoveStringLiteralDfa1_0(0x600000000000000L, 0x0L,
0266: 0x0L);
0267: case 119:
0268: return jjMoveStringLiteralDfa1_0(0x800000000000000L, 0x0L,
0269: 0x0L);
0270: case 123:
0271: return jjStopAtPos(0, 74);
0272: case 124:
0273: jjmatchedKind = 108;
0274: return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000100000000L,
0275: 0x0L);
0276: case 125:
0277: return jjStopAtPos(0, 75);
0278: case 126:
0279: return jjStopAtPos(0, 87);
0280: default:
0281: return jjMoveNfa_0(6, 0);
0282: }
0283: }
0284:
0285: private final int jjMoveStringLiteralDfa1_0(long active0,
0286: long active1, long active2) {
0287: try {
0288: curChar = input_stream.readChar();
0289: } catch (java.io.IOException e) {
0290: jjStopStringLiteralDfa_0(0, active0, active1, active2);
0291: return 1;
0292: }
0293: switch (curChar) {
0294: case 38:
0295: if ((active1 & 0x400000000L) != 0L)
0296: return jjStopAtPos(1, 98);
0297: break;
0298: case 43:
0299: if ((active1 & 0x1000000000L) != 0L)
0300: return jjStopAtPos(1, 100);
0301: break;
0302: case 45:
0303: if ((active1 & 0x2000000000L) != 0L)
0304: return jjStopAtPos(1, 101);
0305: break;
0306: case 60:
0307: if ((active1 & 0x1000000000000L) != 0L) {
0308: jjmatchedKind = 112;
0309: jjmatchedPos = 1;
0310: }
0311: return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L,
0312: active2, 0x1L);
0313: case 61:
0314: if ((active1 & 0x4000000L) != 0L)
0315: return jjStopAtPos(1, 90);
0316: else if ((active1 & 0x8000000L) != 0L)
0317: return jjStopAtPos(1, 91);
0318: else if ((active1 & 0x20000000L) != 0L)
0319: return jjStopAtPos(1, 93);
0320: else if ((active1 & 0x80000000L) != 0L)
0321: return jjStopAtPos(1, 95);
0322: else if ((active1 & 0x40000000000000L) != 0L)
0323: return jjStopAtPos(1, 118);
0324: else if ((active1 & 0x80000000000000L) != 0L)
0325: return jjStopAtPos(1, 119);
0326: else if ((active1 & 0x100000000000000L) != 0L)
0327: return jjStopAtPos(1, 120);
0328: else if ((active1 & 0x200000000000000L) != 0L)
0329: return jjStopAtPos(1, 121);
0330: else if ((active1 & 0x400000000000000L) != 0L)
0331: return jjStopAtPos(1, 122);
0332: else if ((active1 & 0x1000000000000000L) != 0L)
0333: return jjStopAtPos(1, 124);
0334: else if ((active1 & 0x4000000000000000L) != 0L)
0335: return jjStopAtPos(1, 126);
0336: else if ((active1 & 0x8000000000000000L) != 0L)
0337: return jjStopAtPos(1, 127);
0338: break;
0339: case 62:
0340: if ((active1 & 0x4000000000000L) != 0L) {
0341: jjmatchedKind = 114;
0342: jjmatchedPos = 1;
0343: }
0344: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0345: 0x10000000000000L, active2, 0x14L);
0346: case 97:
0347: return jjMoveStringLiteralDfa2_0(active0, 0x48004018000L,
0348: active1, 0x800000800000000L, active2, 0L);
0349: case 98:
0350: return jjMoveStringLiteralDfa2_0(active0, 0x400L, active1,
0351: 0x280000000000L, active2, 0L);
0352: case 101:
0353: return jjMoveStringLiteralDfa2_0(active0, 0x410000100000L,
0354: active1, 0L, active2, 0L);
0355: case 102:
0356: if ((active0 & 0x100000000L) != 0L)
0357: return jjStartNfaWithStates_0(1, 32, 35);
0358: break;
0359: case 103:
0360: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0361: 0x40080000L, active2, 0L);
0362: case 104:
0363: return jjMoveStringLiteralDfa2_0(active0,
0364: 0x860800000020000L, active1, 0L, active2, 0L);
0365: case 105:
0366: return jjMoveStringLiteralDfa2_0(active0, 0x18000000L,
0367: active1, 0L, active2, 0L);
0368: case 108:
0369: return jjMoveStringLiteralDfa2_0(active0, 0x20802000L,
0370: active1, 0x2000010200000L, active2, 0x2L);
0371: case 109:
0372: return jjMoveStringLiteralDfa2_0(active0, 0x600000000L,
0373: active1, 0L, active2, 0L);
0374: case 110:
0375: return jjMoveStringLiteralDfa2_0(active0, 0x3801000000L,
0376: active1, 0L, active2, 0L);
0377: case 111:
0378: if ((active0 & 0x200000L) != 0L) {
0379: jjmatchedKind = 21;
0380: jjmatchedPos = 1;
0381: }
0382: return jjMoveStringLiteralDfa2_0(active0,
0383: 0x6000040c04c0800L, active1, 0x2000000200000000L,
0384: active2, 0L);
0385: case 114:
0386: return jjMoveStringLiteralDfa2_0(active0,
0387: 0x190180000001000L, active1, 0x28000000000000L,
0388: active2, 0x28L);
0389: case 116:
0390: return jjMoveStringLiteralDfa2_0(active0, 0x3000000000000L,
0391: active1, 0L, active2, 0L);
0392: case 117:
0393: return jjMoveStringLiteralDfa2_0(active0, 0x220000000000L,
0394: active1, 0L, active2, 0L);
0395: case 119:
0396: return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000L,
0397: active1, 0L, active2, 0L);
0398: case 120:
0399: return jjMoveStringLiteralDfa2_0(active0, 0x2000000L,
0400: active1, 0L, active2, 0L);
0401: case 121:
0402: return jjMoveStringLiteralDfa2_0(active0, 0x8000000004000L,
0403: active1, 0L, active2, 0L);
0404: case 124:
0405: if ((active1 & 0x100000000L) != 0L)
0406: return jjStopAtPos(1, 96);
0407: break;
0408: default:
0409: break;
0410: }
0411: return jjStartNfa_0(0, active0, active1, active2);
0412: }
0413:
0414: private final int jjMoveStringLiteralDfa2_0(long old0,
0415: long active0, long old1, long active1, long old2,
0416: long active2) {
0417: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0418: return jjStartNfa_0(0, old0, old1, old2);
0419: try {
0420: curChar = input_stream.readChar();
0421: } catch (java.io.IOException e) {
0422: jjStopStringLiteralDfa_0(1, active0, active1, active2);
0423: return 2;
0424: }
0425: switch (curChar) {
0426: case 61:
0427: if ((active2 & 0x1L) != 0L)
0428: return jjStopAtPos(2, 128);
0429: else if ((active2 & 0x4L) != 0L)
0430: return jjStopAtPos(2, 130);
0431: break;
0432: case 62:
0433: if ((active1 & 0x10000000000000L) != 0L) {
0434: jjmatchedKind = 116;
0435: jjmatchedPos = 2;
0436: }
0437: return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L,
0438: active2, 0x10L);
0439: case 97:
0440: return jjMoveStringLiteralDfa3_0(active0,
0441: 0x11000000022000L, active1, 0L, active2, 0L);
0442: case 98:
0443: return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L,
0444: active1, 0L, active2, 0L);
0445: case 99:
0446: return jjMoveStringLiteralDfa3_0(active0, 0x40000000000L,
0447: active1, 0L, active2, 0L);
0448: case 101:
0449: return jjMoveStringLiteralDfa3_0(active0, 0x1000L, active1,
0450: 0x2000000000000L, active2, 0x2L);
0451: case 102:
0452: return jjMoveStringLiteralDfa3_0(active0, 0x100000L,
0453: active1, 0L, active2, 0L);
0454: case 105:
0455: return jjMoveStringLiteralDfa3_0(active0,
0456: 0xa04080000000000L, active1, 0x28280000000000L,
0457: active2, 0x28L);
0458: case 108:
0459: return jjMoveStringLiteralDfa3_0(active0,
0460: 0x400020004000000L, active1, 0L, active2, 0L);
0461: case 110:
0462: return jjMoveStringLiteralDfa3_0(active0, 0x80040180c0000L,
0463: active1, 0x800000800000000L, active2, 0L);
0464: case 111:
0465: return jjMoveStringLiteralDfa3_0(active0, 0x900020000800L,
0466: active1, 0L, active2, 0L);
0467: case 112:
0468: return jjMoveStringLiteralDfa3_0(active0, 0x600000000L,
0469: active1, 0L, active2, 0L);
0470: case 114:
0471: if ((active0 & 0x40000000L) != 0L)
0472: return jjStartNfaWithStates_0(2, 30, 35);
0473: else if ((active1 & 0x200000000L) != 0L) {
0474: jjmatchedKind = 97;
0475: jjmatchedPos = 2;
0476: }
0477: return jjMoveStringLiteralDfa3_0(active0,
0478: 0x62000000000000L, active1, 0x2000000000000000L,
0479: active2, 0L);
0480: case 115:
0481: return jjMoveStringLiteralDfa3_0(active0, 0x800808400L,
0482: active1, 0L, active2, 0L);
0483: case 116:
0484: if ((active0 & 0x1000000000L) != 0L) {
0485: jjmatchedKind = 36;
0486: jjmatchedPos = 2;
0487: } else if ((active1 & 0x80000L) != 0L) {
0488: jjmatchedKind = 83;
0489: jjmatchedPos = 2;
0490: } else if ((active1 & 0x200000L) != 0L) {
0491: jjmatchedKind = 85;
0492: jjmatchedPos = 2;
0493: }
0494: return jjMoveStringLiteralDfa3_0(active0, 0x40a082014000L,
0495: active1, 0x50000000L, active2, 0L);
0496: case 117:
0497: return jjMoveStringLiteralDfa3_0(active0,
0498: 0x80000001400000L, active1, 0L, active2, 0L);
0499: case 119:
0500: if ((active0 & 0x10000000000L) != 0L)
0501: return jjStartNfaWithStates_0(2, 40, 35);
0502: break;
0503: case 121:
0504: if ((active0 & 0x100000000000000L) != 0L)
0505: return jjStartNfaWithStates_0(2, 56, 35);
0506: break;
0507: default:
0508: break;
0509: }
0510: return jjStartNfa_0(1, active0, active1, active2);
0511: }
0512:
0513: private final int jjMoveStringLiteralDfa3_0(long old0,
0514: long active0, long old1, long active1, long old2,
0515: long active2) {
0516: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0517: return jjStartNfa_0(1, old0, old1, old2);
0518: try {
0519: curChar = input_stream.readChar();
0520: } catch (java.io.IOException e) {
0521: jjStopStringLiteralDfa_0(2, active0, active1, active2);
0522: return 3;
0523: }
0524: switch (curChar) {
0525: case 61:
0526: if ((active2 & 0x10L) != 0L)
0527: return jjStopAtPos(3, 132);
0528: break;
0529: case 95:
0530: return jjMoveStringLiteralDfa4_0(active0, 0L, active1,
0531: 0x2000000000000000L, active2, 0L);
0532: case 97:
0533: return jjMoveStringLiteralDfa4_0(active0,
0534: 0x400000038101000L, active1, 0L, active2, 0L);
0535: case 98:
0536: return jjMoveStringLiteralDfa4_0(active0, 0x400000L,
0537: active1, 0L, active2, 0L);
0538: case 99:
0539: return jjMoveStringLiteralDfa4_0(active0, 0x8000000010000L,
0540: active1, 0L, active2, 0L);
0541: case 100:
0542: if ((active0 & 0x200000000000000L) != 0L)
0543: return jjStartNfaWithStates_0(3, 57, 35);
0544: else if ((active1 & 0x800000000L) != 0L) {
0545: jjmatchedKind = 99;
0546: jjmatchedPos = 3;
0547: }
0548: return jjMoveStringLiteralDfa4_0(active0, 0L, active1,
0549: 0x800000000000000L, active2, 0L);
0550: case 101:
0551: if ((active0 & 0x4000L) != 0L)
0552: return jjStartNfaWithStates_0(3, 14, 35);
0553: else if ((active0 & 0x8000L) != 0L)
0554: return jjStartNfaWithStates_0(3, 15, 35);
0555: else if ((active0 & 0x800000L) != 0L)
0556: return jjStartNfaWithStates_0(3, 23, 35);
0557: else if ((active0 & 0x80000000000000L) != 0L)
0558: return jjStartNfaWithStates_0(3, 55, 35);
0559: return jjMoveStringLiteralDfa4_0(active0, 0x2002000000L,
0560: active1, 0x50000000L, active2, 0L);
0561: case 102:
0562: return jjMoveStringLiteralDfa4_0(active0, 0L, active1,
0563: 0x2000000000000L, active2, 0x2L);
0564: case 103:
0565: if ((active0 & 0x4000000000L) != 0L)
0566: return jjStartNfaWithStates_0(3, 38, 35);
0567: return jjMoveStringLiteralDfa4_0(active0, 0L, active1,
0568: 0x28000000000000L, active2, 0x28L);
0569: case 105:
0570: return jjMoveStringLiteralDfa4_0(active0, 0x2008000000000L,
0571: active1, 0L, active2, 0L);
0572: case 107:
0573: return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L,
0574: active1, 0L, active2, 0L);
0575: case 108:
0576: if ((active0 & 0x20000000000L) != 0L)
0577: return jjStartNfaWithStates_0(3, 41, 35);
0578: return jjMoveStringLiteralDfa4_0(active0,
0579: 0x800200200000800L, active1, 0L, active2, 0L);
0580: case 109:
0581: if ((active0 & 0x1000000L) != 0L)
0582: return jjStartNfaWithStates_0(3, 24, 35);
0583: break;
0584: case 110:
0585: return jjMoveStringLiteralDfa4_0(active0,
0586: 0x10000000000000L, active1, 0L, active2, 0L);
0587: case 111:
0588: if ((active0 & 0x80000000L) != 0L)
0589: return jjStartNfaWithStates_0(3, 31, 35);
0590: return jjMoveStringLiteralDfa4_0(active0,
0591: 0x60000400000000L, active1, 0L, active2, 0L);
0592: case 114:
0593: if ((active0 & 0x20000L) != 0L)
0594: return jjStartNfaWithStates_0(3, 17, 35);
0595: return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L,
0596: active1, 0L, active2, 0L);
0597: case 115:
0598: return jjMoveStringLiteralDfa4_0(active0, 0x4042000L,
0599: active1, 0L, active2, 0L);
0600: case 116:
0601: return jjMoveStringLiteralDfa4_0(active0, 0x5100800080400L,
0602: active1, 0x280000000000L, active2, 0L);
0603: case 117:
0604: return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L,
0605: active1, 0L, active2, 0L);
0606: case 118:
0607: return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L,
0608: active1, 0L, active2, 0L);
0609: default:
0610: break;
0611: }
0612: return jjStartNfa_0(2, active0, active1, active2);
0613: }
0614:
0615: private final int jjMoveStringLiteralDfa4_0(long old0,
0616: long active0, long old1, long active1, long old2,
0617: long active2) {
0618: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0619: return jjStartNfa_0(2, old0, old1, old2);
0620: try {
0621: curChar = input_stream.readChar();
0622: } catch (java.io.IOException e) {
0623: jjStopStringLiteralDfa_0(3, active0, active1, active2);
0624: return 4;
0625: }
0626: switch (curChar) {
0627: case 95:
0628: return jjMoveStringLiteralDfa5_0(active0, 0L, active1,
0629: 0x800000000000000L, active2, 0L);
0630: case 97:
0631: return jjMoveStringLiteralDfa5_0(active0, 0xc0800000000L,
0632: active1, 0x2000000000000000L, active2, 0L);
0633: case 99:
0634: return jjMoveStringLiteralDfa5_0(active0, 0x6000000000000L,
0635: active1, 0L, active2, 0L);
0636: case 101:
0637: if ((active0 & 0x4000000L) != 0L)
0638: return jjStartNfaWithStates_0(4, 26, 35);
0639: else if ((active0 & 0x800000000000000L) != 0L)
0640: return jjStartNfaWithStates_0(4, 59, 35);
0641: return jjMoveStringLiteralDfa5_0(active0, 0x100200000800L,
0642: active1, 0L, active2, 0L);
0643: case 104:
0644: if ((active0 & 0x10000L) != 0L)
0645: return jjStartNfaWithStates_0(4, 16, 35);
0646: return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000L,
0647: active1, 0x28000000000000L, active2, 0x28L);
0648: case 105:
0649: return jjMoveStringLiteralDfa5_0(active0, 0x1200000080000L,
0650: active1, 0L, active2, 0L);
0651: case 107:
0652: if ((active0 & 0x1000L) != 0L)
0653: return jjStartNfaWithStates_0(4, 12, 35);
0654: break;
0655: case 108:
0656: if ((active0 & 0x8000000L) != 0L) {
0657: jjmatchedKind = 27;
0658: jjmatchedPos = 4;
0659: }
0660: return jjMoveStringLiteralDfa5_0(active0, 0x10400000L,
0661: active1, 0L, active2, 0L);
0662: case 110:
0663: return jjMoveStringLiteralDfa5_0(active0, 0x2000000L,
0664: active1, 0L, active2, 0L);
0665: case 113:
0666: if ((active1 & 0x10000000L) != 0L)
0667: return jjStopAtPos(4, 92);
0668: else if ((active1 & 0x40000000L) != 0L)
0669: return jjStopAtPos(4, 94);
0670: break;
0671: case 114:
0672: return jjMoveStringLiteralDfa5_0(active0, 0x402400000400L,
0673: active1, 0L, active2, 0L);
0674: case 115:
0675: if ((active0 & 0x2000L) != 0L)
0676: return jjStartNfaWithStates_0(4, 13, 35);
0677: return jjMoveStringLiteralDfa5_0(active0,
0678: 0x10000000000000L, active1, 0L, active2, 0L);
0679: case 116:
0680: if ((active0 & 0x40000L) != 0L)
0681: return jjStartNfaWithStates_0(4, 18, 35);
0682: else if ((active0 & 0x20000000L) != 0L)
0683: return jjStartNfaWithStates_0(4, 29, 35);
0684: else if ((active0 & 0x800000000000L) != 0L)
0685: return jjStartNfaWithStates_0(4, 47, 35);
0686: return jjMoveStringLiteralDfa5_0(active0,
0687: 0x400000000000000L, active1, 0x2000000000000L,
0688: active2, 0x2L);
0689: case 117:
0690: return jjMoveStringLiteralDfa5_0(active0, 0x100000L,
0691: active1, 0L, active2, 0L);
0692: case 118:
0693: return jjMoveStringLiteralDfa5_0(active0, 0x8000000000L,
0694: active1, 0L, active2, 0L);
0695: case 119:
0696: if ((active0 & 0x20000000000000L) != 0L) {
0697: jjmatchedKind = 53;
0698: jjmatchedPos = 4;
0699: }
0700: return jjMoveStringLiteralDfa5_0(active0,
0701: 0x40000000000000L, active1, 0x280000000000L,
0702: active2, 0L);
0703: default:
0704: break;
0705: }
0706: return jjStartNfa_0(3, active0, active1, active2);
0707: }
0708:
0709: private final int jjMoveStringLiteralDfa5_0(long old0,
0710: long active0, long old1, long active1, long old2,
0711: long active2) {
0712: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0713: return jjStartNfa_0(3, old0, old1, old2);
0714: try {
0715: curChar = input_stream.readChar();
0716: } catch (java.io.IOException e) {
0717: jjStopStringLiteralDfa_0(4, active0, active1, active2);
0718: return 5;
0719: }
0720: switch (curChar) {
0721: case 95:
0722: return jjMoveStringLiteralDfa6_0(active0, 0L, active1,
0723: 0x2000000000000L, active2, 0x2L);
0724: case 97:
0725: return jjMoveStringLiteralDfa6_0(active0, 0xc00L, active1,
0726: 0x800000000000000L, active2, 0L);
0727: case 99:
0728: if ((active0 & 0x200000000000L) != 0L)
0729: return jjStartNfaWithStates_0(5, 45, 35);
0730: else if ((active0 & 0x1000000000000L) != 0L)
0731: return jjStartNfaWithStates_0(5, 48, 35);
0732: return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L,
0733: active1, 0L, active2, 0L);
0734: case 100:
0735: return jjMoveStringLiteralDfa6_0(active0, 0x2000000L,
0736: active1, 0L, active2, 0L);
0737: case 101:
0738: if ((active0 & 0x400000L) != 0L)
0739: return jjStartNfaWithStates_0(5, 22, 35);
0740: else if ((active0 & 0x8000000000L) != 0L)
0741: return jjStartNfaWithStates_0(5, 39, 35);
0742: break;
0743: case 102:
0744: return jjMoveStringLiteralDfa6_0(active0, 0x2000000000L,
0745: active1, 0L, active2, 0L);
0746: case 103:
0747: return jjMoveStringLiteralDfa6_0(active0, 0x40000000000L,
0748: active1, 0L, active2, 0L);
0749: case 104:
0750: if ((active0 & 0x4000000000000L) != 0L)
0751: return jjStartNfaWithStates_0(5, 50, 35);
0752: break;
0753: case 105:
0754: return jjMoveStringLiteralDfa6_0(active0,
0755: 0x410000000000000L, active1, 0x280000000000L,
0756: active2, 0L);
0757: case 108:
0758: return jjMoveStringLiteralDfa6_0(active0, 0x10100000L,
0759: active1, 0L, active2, 0L);
0760: case 109:
0761: return jjMoveStringLiteralDfa6_0(active0, 0x200000000L,
0762: active1, 0L, active2, 0L);
0763: case 110:
0764: if ((active0 & 0x400000000000L) != 0L)
0765: return jjStartNfaWithStates_0(5, 46, 35);
0766: return jjMoveStringLiteralDfa6_0(active0, 0x800080000L,
0767: active1, 0L, active2, 0L);
0768: case 114:
0769: return jjMoveStringLiteralDfa6_0(active0, 0x8000000000000L,
0770: active1, 0L, active2, 0L);
0771: case 115:
0772: if ((active0 & 0x40000000000000L) != 0L)
0773: return jjStartNfaWithStates_0(5, 54, 35);
0774: return jjMoveStringLiteralDfa6_0(active0, 0L, active1,
0775: 0x2000000000000000L, active2, 0L);
0776: case 116:
0777: if ((active0 & 0x400000000L) != 0L)
0778: return jjStartNfaWithStates_0(5, 34, 35);
0779: return jjMoveStringLiteralDfa6_0(active0, 0x2080000000000L,
0780: active1, 0x28000000000000L, active2, 0x28L);
0781: default:
0782: break;
0783: }
0784: return jjStartNfa_0(4, active0, active1, active2);
0785: }
0786:
0787: private final int jjMoveStringLiteralDfa6_0(long old0,
0788: long active0, long old1, long active1, long old2,
0789: long active2) {
0790: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0791: return jjStartNfa_0(4, old0, old1, old2);
0792: try {
0793: curChar = input_stream.readChar();
0794: } catch (java.io.IOException e) {
0795: jjStopStringLiteralDfa_0(5, active0, active1, active2);
0796: return 6;
0797: }
0798: switch (curChar) {
0799: case 95:
0800: return jjMoveStringLiteralDfa7_0(active0, 0L, active1,
0801: 0x28000000000000L, active2, 0x28L);
0802: case 97:
0803: return jjMoveStringLiteralDfa7_0(active0, 0x2000000000L,
0804: active1, 0L, active2, 0L);
0805: case 99:
0806: return jjMoveStringLiteralDfa7_0(active0, 0x800000400L,
0807: active1, 0L, active2, 0L);
0808: case 101:
0809: if ((active0 & 0x40000000000L) != 0L)
0810: return jjStartNfaWithStates_0(6, 42, 35);
0811: else if ((active0 & 0x80000000000L) != 0L)
0812: return jjStartNfaWithStates_0(6, 43, 35);
0813: return jjMoveStringLiteralDfa7_0(active0,
0814: 0x10000200000000L, active1, 0L, active2, 0L);
0815: case 102:
0816: return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000L,
0817: active1, 0L, active2, 0L);
0818: case 108:
0819: return jjMoveStringLiteralDfa7_0(active0,
0820: 0x400000000000000L, active1, 0L, active2, 0L);
0821: case 110:
0822: if ((active0 & 0x800L) != 0L)
0823: return jjStartNfaWithStates_0(6, 11, 35);
0824: break;
0825: case 111:
0826: return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L,
0827: active1, 0L, active2, 0L);
0828: case 115:
0829: if ((active0 & 0x2000000L) != 0L)
0830: return jjStartNfaWithStates_0(6, 25, 35);
0831: return jjMoveStringLiteralDfa7_0(active0, 0L, active1,
0832: 0x2802280000000000L, active2, 0x2L);
0833: case 116:
0834: if ((active0 & 0x100000L) != 0L)
0835: return jjStartNfaWithStates_0(6, 20, 35);
0836: return jjMoveStringLiteralDfa7_0(active0, 0x100000000000L,
0837: active1, 0L, active2, 0L);
0838: case 117:
0839: return jjMoveStringLiteralDfa7_0(active0, 0x80000L,
0840: active1, 0L, active2, 0L);
0841: case 121:
0842: if ((active0 & 0x10000000L) != 0L)
0843: return jjStartNfaWithStates_0(6, 28, 35);
0844: break;
0845: default:
0846: break;
0847: }
0848: return jjStartNfa_0(5, active0, active1, active2);
0849: }
0850:
0851: private final int jjMoveStringLiteralDfa7_0(long old0,
0852: long active0, long old1, long active1, long old2,
0853: long active2) {
0854: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0855: return jjStartNfa_0(5, old0, old1, old2);
0856: try {
0857: curChar = input_stream.readChar();
0858: } catch (java.io.IOException e) {
0859: jjStopStringLiteralDfa_0(6, active0, active1, active2);
0860: return 7;
0861: }
0862: switch (curChar) {
0863: case 99:
0864: return jjMoveStringLiteralDfa8_0(active0, 0x2000000000L,
0865: active1, 0L, active2, 0L);
0866: case 101:
0867: if ((active0 & 0x80000L) != 0L)
0868: return jjStartNfaWithStates_0(7, 19, 35);
0869: else if ((active0 & 0x400000000000000L) != 0L)
0870: return jjStartNfaWithStates_0(7, 58, 35);
0871: return jjMoveStringLiteralDfa8_0(active0, 0x100800000000L,
0872: active1, 0x280000000000L, active2, 0L);
0873: case 104:
0874: return jjMoveStringLiteralDfa8_0(active0, 0L, active1,
0875: 0x2000000000000L, active2, 0x2L);
0876: case 105:
0877: return jjMoveStringLiteralDfa8_0(active0, 0L, active1,
0878: 0x2000000000000000L, active2, 0L);
0879: case 110:
0880: return jjMoveStringLiteralDfa8_0(active0,
0881: 0x18000200000000L, active1, 0L, active2, 0L);
0882: case 112:
0883: if ((active0 & 0x2000000000000L) != 0L)
0884: return jjStartNfaWithStates_0(7, 49, 35);
0885: break;
0886: case 115:
0887: return jjMoveStringLiteralDfa8_0(active0, 0L, active1,
0888: 0x808000000000000L, active2, 0x8L);
0889: case 116:
0890: if ((active0 & 0x400L) != 0L)
0891: return jjStartNfaWithStates_0(7, 10, 35);
0892: break;
0893: case 117:
0894: return jjMoveStringLiteralDfa8_0(active0, 0L, active1,
0895: 0x20000000000000L, active2, 0x20L);
0896: default:
0897: break;
0898: }
0899: return jjStartNfa_0(6, active0, active1, active2);
0900: }
0901:
0902: private final int jjMoveStringLiteralDfa8_0(long old0,
0903: long active0, long old1, long active1, long old2,
0904: long active2) {
0905: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0906: return jjStartNfa_0(6, old0, old1, old2);
0907: try {
0908: curChar = input_stream.readChar();
0909: } catch (java.io.IOException e) {
0910: jjStopStringLiteralDfa_0(7, active0, active1, active2);
0911: return 8;
0912: }
0913: switch (curChar) {
0914: case 95:
0915: return jjMoveStringLiteralDfa9_0(active0, 0L, active1,
0916: 0x280000000000L, active2, 0L);
0917: case 100:
0918: if ((active0 & 0x100000000000L) != 0L)
0919: return jjStartNfaWithStates_0(8, 44, 35);
0920: break;
0921: case 101:
0922: if ((active0 & 0x2000000000L) != 0L)
0923: return jjStartNfaWithStates_0(8, 37, 35);
0924: break;
0925: case 103:
0926: return jjMoveStringLiteralDfa9_0(active0, 0L, active1,
0927: 0x2000000000000000L, active2, 0L);
0928: case 104:
0929: return jjMoveStringLiteralDfa9_0(active0, 0L, active1,
0930: 0x8000000000000L, active2, 0x8L);
0931: case 105:
0932: return jjMoveStringLiteralDfa9_0(active0, 0x8000000000000L,
0933: active1, 0x802000000000000L, active2, 0x2L);
0934: case 110:
0935: return jjMoveStringLiteralDfa9_0(active0, 0L, active1,
0936: 0x20000000000000L, active2, 0x20L);
0937: case 111:
0938: return jjMoveStringLiteralDfa9_0(active0, 0x800000000L,
0939: active1, 0L, active2, 0L);
0940: case 116:
0941: if ((active0 & 0x10000000000000L) != 0L)
0942: return jjStartNfaWithStates_0(8, 52, 35);
0943: return jjMoveStringLiteralDfa9_0(active0, 0x200000000L,
0944: active1, 0L, active2, 0L);
0945: default:
0946: break;
0947: }
0948: return jjStartNfa_0(7, active0, active1, active2);
0949: }
0950:
0951: private final int jjMoveStringLiteralDfa9_0(long old0,
0952: long active0, long old1, long active1, long old2,
0953: long active2) {
0954: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0955: return jjStartNfa_0(7, old0, old1, old2);
0956: try {
0957: curChar = input_stream.readChar();
0958: } catch (java.io.IOException e) {
0959: jjStopStringLiteralDfa_0(8, active0, active1, active2);
0960: return 9;
0961: }
0962: switch (curChar) {
0963: case 97:
0964: return jjMoveStringLiteralDfa10_0(active0, 0L, active1,
0965: 0x80000000000L, active2, 0L);
0966: case 102:
0967: if ((active0 & 0x800000000L) != 0L)
0968: return jjStartNfaWithStates_0(9, 35, 35);
0969: return jjMoveStringLiteralDfa10_0(active0, 0L, active1,
0970: 0x2000000000000L, active2, 0x2L);
0971: case 103:
0972: return jjMoveStringLiteralDfa10_0(active0, 0L, active1,
0973: 0x800000000000000L, active2, 0L);
0974: case 105:
0975: return jjMoveStringLiteralDfa10_0(active0, 0L, active1,
0976: 0x8000000000000L, active2, 0x8L);
0977: case 110:
0978: if ((active1 & 0x2000000000000000L) != 0L)
0979: return jjStopAtPos(9, 125);
0980: break;
0981: case 111:
0982: return jjMoveStringLiteralDfa10_0(active0, 0L, active1,
0983: 0x200000000000L, active2, 0L);
0984: case 115:
0985: if ((active0 & 0x200000000L) != 0L)
0986: return jjStartNfaWithStates_0(9, 33, 35);
0987: return jjMoveStringLiteralDfa10_0(active0, 0L, active1,
0988: 0x20000000000000L, active2, 0x20L);
0989: case 122:
0990: return jjMoveStringLiteralDfa10_0(active0,
0991: 0x8000000000000L, active1, 0L, active2, 0L);
0992: default:
0993: break;
0994: }
0995: return jjStartNfa_0(8, active0, active1, active2);
0996: }
0997:
0998: private final int jjMoveStringLiteralDfa10_0(long old0,
0999: long active0, long old1, long active1, long old2,
1000: long active2) {
1001: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
1002: return jjStartNfa_0(8, old0, old1, old2);
1003: try {
1004: curChar = input_stream.readChar();
1005: } catch (java.io.IOException e) {
1006: jjStopStringLiteralDfa_0(9, active0, active1, active2);
1007: return 10;
1008: }
1009: switch (curChar) {
1010: case 101:
1011: return jjMoveStringLiteralDfa11_0(active0,
1012: 0x8000000000000L, active1, 0L, active2, 0L);
1013: case 102:
1014: return jjMoveStringLiteralDfa11_0(active0, 0L, active1,
1015: 0x8000000000000L, active2, 0x8L);
1016: case 105:
1017: return jjMoveStringLiteralDfa11_0(active0, 0L, active1,
1018: 0x20000000000000L, active2, 0x20L);
1019: case 110:
1020: if ((active1 & 0x800000000000000L) != 0L)
1021: return jjStopAtPos(10, 123);
1022: return jjMoveStringLiteralDfa11_0(active0, 0L, active1,
1023: 0x80000000000L, active2, 0L);
1024: case 114:
1025: if ((active1 & 0x200000000000L) != 0L)
1026: return jjStopAtPos(10, 109);
1027: break;
1028: case 116:
1029: if ((active1 & 0x2000000000000L) != 0L) {
1030: jjmatchedKind = 113;
1031: jjmatchedPos = 10;
1032: }
1033: return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0L,
1034: active2, 0x2L);
1035: default:
1036: break;
1037: }
1038: return jjStartNfa_0(9, active0, active1, active2);
1039: }
1040:
1041: private final int jjMoveStringLiteralDfa11_0(long old0,
1042: long active0, long old1, long active1, long old2,
1043: long active2) {
1044: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
1045: return jjStartNfa_0(9, old0, old1, old2);
1046: try {
1047: curChar = input_stream.readChar();
1048: } catch (java.io.IOException e) {
1049: jjStopStringLiteralDfa_0(10, active0, active1, active2);
1050: return 11;
1051: }
1052: switch (curChar) {
1053: case 95:
1054: return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L,
1055: active2, 0x2L);
1056: case 100:
1057: if ((active0 & 0x8000000000000L) != 0L)
1058: return jjStartNfaWithStates_0(11, 51, 35);
1059: else if ((active1 & 0x80000000000L) != 0L)
1060: return jjStopAtPos(11, 107);
1061: break;
1062: case 103:
1063: return jjMoveStringLiteralDfa12_0(active0, 0L, active1,
1064: 0x20000000000000L, active2, 0x20L);
1065: case 116:
1066: if ((active1 & 0x8000000000000L) != 0L) {
1067: jjmatchedKind = 115;
1068: jjmatchedPos = 11;
1069: }
1070: return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0L,
1071: active2, 0x8L);
1072: default:
1073: break;
1074: }
1075: return jjStartNfa_0(10, active0, active1, active2);
1076: }
1077:
1078: private final int jjMoveStringLiteralDfa12_0(long old0,
1079: long active0, long old1, long active1, long old2,
1080: long active2) {
1081: if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
1082: return jjStartNfa_0(10, old0, old1, old2);
1083: try {
1084: curChar = input_stream.readChar();
1085: } catch (java.io.IOException e) {
1086: jjStopStringLiteralDfa_0(11, 0L, active1, active2);
1087: return 12;
1088: }
1089: switch (curChar) {
1090: case 95:
1091: return jjMoveStringLiteralDfa13_0(active1, 0L, active2,
1092: 0x8L);
1093: case 97:
1094: return jjMoveStringLiteralDfa13_0(active1, 0L, active2,
1095: 0x2L);
1096: case 110:
1097: return jjMoveStringLiteralDfa13_0(active1,
1098: 0x20000000000000L, active2, 0x20L);
1099: default:
1100: break;
1101: }
1102: return jjStartNfa_0(11, 0L, active1, active2);
1103: }
1104:
1105: private final int jjMoveStringLiteralDfa13_0(long old1,
1106: long active1, long old2, long active2) {
1107: if (((active1 &= old1) | (active2 &= old2)) == 0L)
1108: return jjStartNfa_0(11, 0L, old1, old2);
1109: try {
1110: curChar = input_stream.readChar();
1111: } catch (java.io.IOException e) {
1112: jjStopStringLiteralDfa_0(12, 0L, active1, active2);
1113: return 13;
1114: }
1115: switch (curChar) {
1116: case 97:
1117: return jjMoveStringLiteralDfa14_0(active1, 0L, active2,
1118: 0x8L);
1119: case 101:
1120: return jjMoveStringLiteralDfa14_0(active1,
1121: 0x20000000000000L, active2, 0x20L);
1122: case 115:
1123: return jjMoveStringLiteralDfa14_0(active1, 0L, active2,
1124: 0x2L);
1125: default:
1126: break;
1127: }
1128: return jjStartNfa_0(12, 0L, active1, active2);
1129: }
1130:
1131: private final int jjMoveStringLiteralDfa14_0(long old1,
1132: long active1, long old2, long active2) {
1133: if (((active1 &= old1) | (active2 &= old2)) == 0L)
1134: return jjStartNfa_0(12, 0L, old1, old2);
1135: try {
1136: curChar = input_stream.readChar();
1137: } catch (java.io.IOException e) {
1138: jjStopStringLiteralDfa_0(13, 0L, active1, active2);
1139: return 14;
1140: }
1141: switch (curChar) {
1142: case 100:
1143: return jjMoveStringLiteralDfa15_0(active1,
1144: 0x20000000000000L, active2, 0x20L);
1145: case 115:
1146: return jjMoveStringLiteralDfa15_0(active1, 0L, active2,
1147: 0xaL);
1148: default:
1149: break;
1150: }
1151: return jjStartNfa_0(13, 0L, active1, active2);
1152: }
1153:
1154: private final int jjMoveStringLiteralDfa15_0(long old1,
1155: long active1, long old2, long active2) {
1156: if (((active1 &= old1) | (active2 &= old2)) == 0L)
1157: return jjStartNfa_0(13, 0L, old1, old2);
1158: try {
1159: curChar = input_stream.readChar();
1160: } catch (java.io.IOException e) {
1161: jjStopStringLiteralDfa_0(14, 0L, active1, active2);
1162: return 15;
1163: }
1164: switch (curChar) {
1165: case 95:
1166: return jjMoveStringLiteralDfa16_0(active1,
1167: 0x20000000000000L, active2, 0x20L);
1168: case 105:
1169: return jjMoveStringLiteralDfa16_0(active1, 0L, active2,
1170: 0x2L);
1171: case 115:
1172: return jjMoveStringLiteralDfa16_0(active1, 0L, active2,
1173: 0x8L);
1174: default:
1175: break;
1176: }
1177: return jjStartNfa_0(14, 0L, active1, active2);
1178: }
1179:
1180: private final int jjMoveStringLiteralDfa16_0(long old1,
1181: long active1, long old2, long active2) {
1182: if (((active1 &= old1) | (active2 &= old2)) == 0L)
1183: return jjStartNfa_0(14, 0L, old1, old2);
1184: try {
1185: curChar = input_stream.readChar();
1186: } catch (java.io.IOException e) {
1187: jjStopStringLiteralDfa_0(15, 0L, active1, active2);
1188: return 16;
1189: }
1190: switch (curChar) {
1191: case 103:
1192: return jjMoveStringLiteralDfa17_0(active1, 0L, active2,
1193: 0x2L);
1194: case 105:
1195: return jjMoveStringLiteralDfa17_0(active1, 0L, active2,
1196: 0x8L);
1197: case 115:
1198: return jjMoveStringLiteralDfa17_0(active1,
1199: 0x20000000000000L, active2, 0x20L);
1200: default:
1201: break;
1202: }
1203: return jjStartNfa_0(15, 0L, active1, active2);
1204: }
1205:
1206: private final int jjMoveStringLiteralDfa17_0(long old1,
1207: long active1, long old2, long active2) {
1208: if (((active1 &= old1) | (active2 &= old2)) == 0L)
1209: return jjStartNfa_0(15, 0L, old1, old2);
1210: try {
1211: curChar = input_stream.readChar();
1212: } catch (java.io.IOException e) {
1213: jjStopStringLiteralDfa_0(16, 0L, active1, active2);
1214: return 17;
1215: }
1216: switch (curChar) {
1217: case 103:
1218: return jjMoveStringLiteralDfa18_0(active1, 0L, active2,
1219: 0x8L);
1220: case 104:
1221: return jjMoveStringLiteralDfa18_0(active1,
1222: 0x20000000000000L, active2, 0x20L);
1223: case 110:
1224: if ((active2 & 0x2L) != 0L)
1225: return jjStopAtPos(17, 129);
1226: break;
1227: default:
1228: break;
1229: }
1230: return jjStartNfa_0(16, 0L, active1, active2);
1231: }
1232:
1233: private final int jjMoveStringLiteralDfa18_0(long old1,
1234: long active1, long old2, long active2) {
1235: if (((active1 &= old1) | (active2 &= old2)) == 0L)
1236: return jjStartNfa_0(16, 0L, old1, old2);
1237: try {
1238: curChar = input_stream.readChar();
1239: } catch (java.io.IOException e) {
1240: jjStopStringLiteralDfa_0(17, 0L, active1, active2);
1241: return 18;
1242: }
1243: switch (curChar) {
1244: case 105:
1245: return jjMoveStringLiteralDfa19_0(active1,
1246: 0x20000000000000L, active2, 0x20L);
1247: case 110:
1248: if ((active2 & 0x8L) != 0L)
1249: return jjStopAtPos(18, 131);
1250: break;
1251: default:
1252: break;
1253: }
1254: return jjStartNfa_0(17, 0L, active1, active2);
1255: }
1256:
1257: private final int jjMoveStringLiteralDfa19_0(long old1,
1258: long active1, long old2, long active2) {
1259: if (((active1 &= old1) | (active2 &= old2)) == 0L)
1260: return jjStartNfa_0(17, 0L, old1, old2);
1261: try {
1262: curChar = input_stream.readChar();
1263: } catch (java.io.IOException e) {
1264: jjStopStringLiteralDfa_0(18, 0L, active1, active2);
1265: return 19;
1266: }
1267: switch (curChar) {
1268: case 102:
1269: return jjMoveStringLiteralDfa20_0(active1,
1270: 0x20000000000000L, active2, 0x20L);
1271: default:
1272: break;
1273: }
1274: return jjStartNfa_0(18, 0L, active1, active2);
1275: }
1276:
1277: private final int jjMoveStringLiteralDfa20_0(long old1,
1278: long active1, long old2, long active2) {
1279: if (((active1 &= old1) | (active2 &= old2)) == 0L)
1280: return jjStartNfa_0(18, 0L, old1, old2);
1281: try {
1282: curChar = input_stream.readChar();
1283: } catch (java.io.IOException e) {
1284: jjStopStringLiteralDfa_0(19, 0L, active1, active2);
1285: return 20;
1286: }
1287: switch (curChar) {
1288: case 116:
1289: if ((active1 & 0x20000000000000L) != 0L) {
1290: jjmatchedKind = 117;
1291: jjmatchedPos = 20;
1292: }
1293: return jjMoveStringLiteralDfa21_0(active1, 0L, active2,
1294: 0x20L);
1295: default:
1296: break;
1297: }
1298: return jjStartNfa_0(19, 0L, active1, active2);
1299: }
1300:
1301: private final int jjMoveStringLiteralDfa21_0(long old1,
1302: long active1, long old2, long active2) {
1303: if (((active1 &= old1) | (active2 &= old2)) == 0L)
1304: return jjStartNfa_0(19, 0L, old1, old2);
1305: try {
1306: curChar = input_stream.readChar();
1307: } catch (java.io.IOException e) {
1308: jjStopStringLiteralDfa_0(20, 0L, 0L, active2);
1309: return 21;
1310: }
1311: switch (curChar) {
1312: case 95:
1313: return jjMoveStringLiteralDfa22_0(active2, 0x20L);
1314: default:
1315: break;
1316: }
1317: return jjStartNfa_0(20, 0L, 0L, active2);
1318: }
1319:
1320: private final int jjMoveStringLiteralDfa22_0(long old2, long active2) {
1321: if (((active2 &= old2)) == 0L)
1322: return jjStartNfa_0(20, 0L, 0L, old2);
1323: try {
1324: curChar = input_stream.readChar();
1325: } catch (java.io.IOException e) {
1326: jjStopStringLiteralDfa_0(21, 0L, 0L, active2);
1327: return 22;
1328: }
1329: switch (curChar) {
1330: case 97:
1331: return jjMoveStringLiteralDfa23_0(active2, 0x20L);
1332: default:
1333: break;
1334: }
1335: return jjStartNfa_0(21, 0L, 0L, active2);
1336: }
1337:
1338: private final int jjMoveStringLiteralDfa23_0(long old2, long active2) {
1339: if (((active2 &= old2)) == 0L)
1340: return jjStartNfa_0(21, 0L, 0L, old2);
1341: try {
1342: curChar = input_stream.readChar();
1343: } catch (java.io.IOException e) {
1344: jjStopStringLiteralDfa_0(22, 0L, 0L, active2);
1345: return 23;
1346: }
1347: switch (curChar) {
1348: case 115:
1349: return jjMoveStringLiteralDfa24_0(active2, 0x20L);
1350: default:
1351: break;
1352: }
1353: return jjStartNfa_0(22, 0L, 0L, active2);
1354: }
1355:
1356: private final int jjMoveStringLiteralDfa24_0(long old2, long active2) {
1357: if (((active2 &= old2)) == 0L)
1358: return jjStartNfa_0(22, 0L, 0L, old2);
1359: try {
1360: curChar = input_stream.readChar();
1361: } catch (java.io.IOException e) {
1362: jjStopStringLiteralDfa_0(23, 0L, 0L, active2);
1363: return 24;
1364: }
1365: switch (curChar) {
1366: case 115:
1367: return jjMoveStringLiteralDfa25_0(active2, 0x20L);
1368: default:
1369: break;
1370: }
1371: return jjStartNfa_0(23, 0L, 0L, active2);
1372: }
1373:
1374: private final int jjMoveStringLiteralDfa25_0(long old2, long active2) {
1375: if (((active2 &= old2)) == 0L)
1376: return jjStartNfa_0(23, 0L, 0L, old2);
1377: try {
1378: curChar = input_stream.readChar();
1379: } catch (java.io.IOException e) {
1380: jjStopStringLiteralDfa_0(24, 0L, 0L, active2);
1381: return 25;
1382: }
1383: switch (curChar) {
1384: case 105:
1385: return jjMoveStringLiteralDfa26_0(active2, 0x20L);
1386: default:
1387: break;
1388: }
1389: return jjStartNfa_0(24, 0L, 0L, active2);
1390: }
1391:
1392: private final int jjMoveStringLiteralDfa26_0(long old2, long active2) {
1393: if (((active2 &= old2)) == 0L)
1394: return jjStartNfa_0(24, 0L, 0L, old2);
1395: try {
1396: curChar = input_stream.readChar();
1397: } catch (java.io.IOException e) {
1398: jjStopStringLiteralDfa_0(25, 0L, 0L, active2);
1399: return 26;
1400: }
1401: switch (curChar) {
1402: case 103:
1403: return jjMoveStringLiteralDfa27_0(active2, 0x20L);
1404: default:
1405: break;
1406: }
1407: return jjStartNfa_0(25, 0L, 0L, active2);
1408: }
1409:
1410: private final int jjMoveStringLiteralDfa27_0(long old2, long active2) {
1411: if (((active2 &= old2)) == 0L)
1412: return jjStartNfa_0(25, 0L, 0L, old2);
1413: try {
1414: curChar = input_stream.readChar();
1415: } catch (java.io.IOException e) {
1416: jjStopStringLiteralDfa_0(26, 0L, 0L, active2);
1417: return 27;
1418: }
1419: switch (curChar) {
1420: case 110:
1421: if ((active2 & 0x20L) != 0L)
1422: return jjStopAtPos(27, 133);
1423: break;
1424: default:
1425: break;
1426: }
1427: return jjStartNfa_0(26, 0L, 0L, active2);
1428: }
1429:
1430: private final void jjCheckNAdd(int state) {
1431: if (jjrounds[state] != jjround) {
1432: jjstateSet[jjnewStateCnt++] = state;
1433: jjrounds[state] = jjround;
1434: }
1435: }
1436:
1437: private final void jjAddStates(int start, int end) {
1438: do {
1439: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1440: } while (start++ != end);
1441: }
1442:
1443: private final void jjCheckNAddTwoStates(int state1, int state2) {
1444: jjCheckNAdd(state1);
1445: jjCheckNAdd(state2);
1446: }
1447:
1448: private final void jjCheckNAddStates(int start, int end) {
1449: do {
1450: jjCheckNAdd(jjnextStates[start]);
1451: } while (start++ != end);
1452: }
1453:
1454: private final void jjCheckNAddStates(int start) {
1455: jjCheckNAdd(jjnextStates[start]);
1456: jjCheckNAdd(jjnextStates[start + 1]);
1457: }
1458:
1459: static final long[] jjbitVec0 = { 0x0L, 0x0L, 0xffffffffffffffffL,
1460: 0xffffffffffffffffL };
1461: static final long[] jjbitVec1 = { 0xfffffffffffffffeL,
1462: 0xffffffffffffffffL, 0xffffffffffffffffL,
1463: 0xffffffffffffffffL };
1464: static final long[] jjbitVec3 = { 0x1ff00000fffffffeL,
1465: 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L };
1466: static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L,
1467: 0xff7fffffff7fffffL };
1468: static final long[] jjbitVec5 = { 0x0L, 0xffffffffffffffffL,
1469: 0xffffffffffffffffL, 0xffffffffffffffffL };
1470: static final long[] jjbitVec6 = { 0xffffffffffffffffL,
1471: 0xffffffffffffffffL, 0xffffL, 0x0L };
1472: static final long[] jjbitVec7 = { 0xffffffffffffffffL,
1473: 0xffffffffffffffffL, 0x0L, 0x0L };
1474: static final long[] jjbitVec8 = { 0x3fffffffffffL, 0x0L, 0x0L, 0x0L };
1475:
1476: private final int jjMoveNfa_0(int startState, int curPos) {
1477: int[] nextStates;
1478: int startsAt = 0;
1479: jjnewStateCnt = 74;
1480: int i = 1;
1481: jjstateSet[0] = startState;
1482: int j, kind = 0x7fffffff;
1483: for (;;) {
1484: if (++jjround == 0x7fffffff)
1485: ReInitRounds();
1486: if (curChar < 64) {
1487: long l = 1L << curChar;
1488: MatchLoop: do {
1489: switch (jjstateSet[--i]) {
1490: case 6:
1491: if ((0x1ffffffffL & l) != 0L) {
1492: if (kind > 6)
1493: kind = 6;
1494: jjCheckNAdd(0);
1495: } else if ((0x3ff000000000000L & l) != 0L)
1496: jjCheckNAddStates(0, 6);
1497: else if (curChar == 47)
1498: jjAddStates(7, 9);
1499: else if (curChar == 36) {
1500: if (kind > 69)
1501: kind = 69;
1502: jjCheckNAdd(35);
1503: } else if (curChar == 34)
1504: jjCheckNAddStates(10, 12);
1505: else if (curChar == 39)
1506: jjAddStates(13, 14);
1507: else if (curChar == 46)
1508: jjCheckNAdd(11);
1509: else if (curChar == 35)
1510: jjstateSet[jjnewStateCnt++] = 1;
1511: if ((0x3fe000000000000L & l) != 0L) {
1512: if (kind > 60)
1513: kind = 60;
1514: jjCheckNAddTwoStates(8, 9);
1515: } else if (curChar == 48) {
1516: if (kind > 60)
1517: kind = 60;
1518: jjCheckNAddStates(15, 17);
1519: }
1520: break;
1521: case 56:
1522: if (curChar == 42)
1523: jjstateSet[jjnewStateCnt++] = 67;
1524: else if (curChar == 47) {
1525: if (kind > 7)
1526: kind = 7;
1527: jjCheckNAddStates(18, 20);
1528: }
1529: if (curChar == 42)
1530: jjCheckNAdd(62);
1531: break;
1532: case 0:
1533: if ((0x1ffffffffL & l) == 0L)
1534: break;
1535: if (kind > 6)
1536: kind = 6;
1537: jjCheckNAdd(0);
1538: break;
1539: case 1:
1540: if (curChar == 33)
1541: jjCheckNAddStates(21, 23);
1542: break;
1543: case 2:
1544: if ((0xffffffffffffdbffL & l) != 0L)
1545: jjCheckNAddStates(21, 23);
1546: break;
1547: case 3:
1548: if ((0x2400L & l) != 0L && kind > 8)
1549: kind = 8;
1550: break;
1551: case 4:
1552: if (curChar == 10 && kind > 8)
1553: kind = 8;
1554: break;
1555: case 5:
1556: if (curChar == 13)
1557: jjstateSet[jjnewStateCnt++] = 4;
1558: break;
1559: case 7:
1560: if ((0x3fe000000000000L & l) == 0L)
1561: break;
1562: if (kind > 60)
1563: kind = 60;
1564: jjCheckNAddTwoStates(8, 9);
1565: break;
1566: case 8:
1567: if ((0x3ff000000000000L & l) == 0L)
1568: break;
1569: if (kind > 60)
1570: kind = 60;
1571: jjCheckNAddTwoStates(8, 9);
1572: break;
1573: case 10:
1574: if (curChar == 46)
1575: jjCheckNAdd(11);
1576: break;
1577: case 11:
1578: if ((0x3ff000000000000L & l) == 0L)
1579: break;
1580: if (kind > 64)
1581: kind = 64;
1582: jjCheckNAddStates(24, 26);
1583: break;
1584: case 13:
1585: if ((0x280000000000L & l) != 0L)
1586: jjCheckNAdd(14);
1587: break;
1588: case 14:
1589: if ((0x3ff000000000000L & l) == 0L)
1590: break;
1591: if (kind > 64)
1592: kind = 64;
1593: jjCheckNAddTwoStates(14, 15);
1594: break;
1595: case 16:
1596: if (curChar == 39)
1597: jjAddStates(13, 14);
1598: break;
1599: case 17:
1600: if ((0xffffff7fffffdbffL & l) != 0L)
1601: jjCheckNAdd(18);
1602: break;
1603: case 18:
1604: if (curChar == 39 && kind > 66)
1605: kind = 66;
1606: break;
1607: case 20:
1608: if ((0x8400000000L & l) != 0L)
1609: jjCheckNAdd(18);
1610: break;
1611: case 21:
1612: if ((0xff000000000000L & l) != 0L)
1613: jjCheckNAddTwoStates(22, 18);
1614: break;
1615: case 22:
1616: if ((0xff000000000000L & l) != 0L)
1617: jjCheckNAdd(18);
1618: break;
1619: case 23:
1620: if ((0xf000000000000L & l) != 0L)
1621: jjstateSet[jjnewStateCnt++] = 24;
1622: break;
1623: case 24:
1624: if ((0xff000000000000L & l) != 0L)
1625: jjCheckNAdd(22);
1626: break;
1627: case 25:
1628: if (curChar == 34)
1629: jjCheckNAddStates(10, 12);
1630: break;
1631: case 26:
1632: if ((0xfffffffbffffdbffL & l) != 0L)
1633: jjCheckNAddStates(10, 12);
1634: break;
1635: case 28:
1636: if ((0x8400000000L & l) != 0L)
1637: jjCheckNAddStates(10, 12);
1638: break;
1639: case 29:
1640: if (curChar == 34 && kind > 67)
1641: kind = 67;
1642: break;
1643: case 30:
1644: if ((0xff000000000000L & l) != 0L)
1645: jjCheckNAddStates(27, 30);
1646: break;
1647: case 31:
1648: if ((0xff000000000000L & l) != 0L)
1649: jjCheckNAddStates(10, 12);
1650: break;
1651: case 32:
1652: if ((0xf000000000000L & l) != 0L)
1653: jjstateSet[jjnewStateCnt++] = 33;
1654: break;
1655: case 33:
1656: if ((0xff000000000000L & l) != 0L)
1657: jjCheckNAdd(31);
1658: break;
1659: case 34:
1660: if (curChar != 36)
1661: break;
1662: if (kind > 69)
1663: kind = 69;
1664: jjCheckNAdd(35);
1665: break;
1666: case 35:
1667: if ((0x3ff001000000000L & l) == 0L)
1668: break;
1669: if (kind > 69)
1670: kind = 69;
1671: jjCheckNAdd(35);
1672: break;
1673: case 36:
1674: if ((0x3ff000000000000L & l) != 0L)
1675: jjCheckNAddStates(0, 6);
1676: break;
1677: case 37:
1678: if ((0x3ff000000000000L & l) != 0L)
1679: jjCheckNAddTwoStates(37, 38);
1680: break;
1681: case 38:
1682: if (curChar != 46)
1683: break;
1684: if (kind > 64)
1685: kind = 64;
1686: jjCheckNAddStates(31, 33);
1687: break;
1688: case 39:
1689: if ((0x3ff000000000000L & l) == 0L)
1690: break;
1691: if (kind > 64)
1692: kind = 64;
1693: jjCheckNAddStates(31, 33);
1694: break;
1695: case 41:
1696: if ((0x280000000000L & l) != 0L)
1697: jjCheckNAdd(42);
1698: break;
1699: case 42:
1700: if ((0x3ff000000000000L & l) == 0L)
1701: break;
1702: if (kind > 64)
1703: kind = 64;
1704: jjCheckNAddTwoStates(42, 15);
1705: break;
1706: case 43:
1707: if ((0x3ff000000000000L & l) != 0L)
1708: jjCheckNAddTwoStates(43, 44);
1709: break;
1710: case 45:
1711: if ((0x280000000000L & l) != 0L)
1712: jjCheckNAdd(46);
1713: break;
1714: case 46:
1715: if ((0x3ff000000000000L & l) == 0L)
1716: break;
1717: if (kind > 64)
1718: kind = 64;
1719: jjCheckNAddTwoStates(46, 15);
1720: break;
1721: case 47:
1722: if ((0x3ff000000000000L & l) != 0L)
1723: jjCheckNAddStates(34, 36);
1724: break;
1725: case 49:
1726: if ((0x280000000000L & l) != 0L)
1727: jjCheckNAdd(50);
1728: break;
1729: case 50:
1730: if ((0x3ff000000000000L & l) != 0L)
1731: jjCheckNAddTwoStates(50, 15);
1732: break;
1733: case 51:
1734: if (curChar != 48)
1735: break;
1736: if (kind > 60)
1737: kind = 60;
1738: jjCheckNAddStates(15, 17);
1739: break;
1740: case 53:
1741: if ((0x3ff000000000000L & l) == 0L)
1742: break;
1743: if (kind > 60)
1744: kind = 60;
1745: jjCheckNAddTwoStates(53, 9);
1746: break;
1747: case 54:
1748: if ((0xff000000000000L & l) == 0L)
1749: break;
1750: if (kind > 60)
1751: kind = 60;
1752: jjCheckNAddTwoStates(54, 9);
1753: break;
1754: case 55:
1755: if (curChar == 47)
1756: jjAddStates(7, 9);
1757: break;
1758: case 57:
1759: if ((0xffffffffffffdbffL & l) == 0L)
1760: break;
1761: if (kind > 7)
1762: kind = 7;
1763: jjCheckNAddStates(18, 20);
1764: break;
1765: case 58:
1766: if ((0x2400L & l) != 0L && kind > 7)
1767: kind = 7;
1768: break;
1769: case 59:
1770: if (curChar == 10 && kind > 7)
1771: kind = 7;
1772: break;
1773: case 60:
1774: if (curChar == 13)
1775: jjstateSet[jjnewStateCnt++] = 59;
1776: break;
1777: case 61:
1778: if (curChar == 42)
1779: jjCheckNAdd(62);
1780: break;
1781: case 62:
1782: if ((0xfffffbffffffffffL & l) != 0L)
1783: jjCheckNAddTwoStates(62, 63);
1784: break;
1785: case 63:
1786: if (curChar == 42)
1787: jjCheckNAddStates(37, 39);
1788: break;
1789: case 64:
1790: if ((0xffff7bffffffffffL & l) != 0L)
1791: jjCheckNAddTwoStates(65, 63);
1792: break;
1793: case 65:
1794: if ((0xfffffbffffffffffL & l) != 0L)
1795: jjCheckNAddTwoStates(65, 63);
1796: break;
1797: case 66:
1798: if (curChar == 47 && kind > 9)
1799: kind = 9;
1800: break;
1801: case 67:
1802: if (curChar == 42)
1803: jjCheckNAddTwoStates(68, 69);
1804: break;
1805: case 68:
1806: if ((0xfffffbffffffffffL & l) != 0L)
1807: jjCheckNAddTwoStates(68, 69);
1808: break;
1809: case 69:
1810: if (curChar == 42)
1811: jjCheckNAddStates(40, 42);
1812: break;
1813: case 70:
1814: if ((0xffff7bffffffffffL & l) != 0L)
1815: jjCheckNAddTwoStates(71, 69);
1816: break;
1817: case 71:
1818: if ((0xfffffbffffffffffL & l) != 0L)
1819: jjCheckNAddTwoStates(71, 69);
1820: break;
1821: case 72:
1822: if (curChar == 47 && kind > 68)
1823: kind = 68;
1824: break;
1825: case 73:
1826: if (curChar == 42)
1827: jjstateSet[jjnewStateCnt++] = 67;
1828: break;
1829: default:
1830: break;
1831: }
1832: } while (i != startsAt);
1833: } else if (curChar < 128) {
1834: long l = 1L << (curChar & 077);
1835: MatchLoop: do {
1836: switch (jjstateSet[--i]) {
1837: case 6:
1838: case 35:
1839: if ((0x7fffffe87fffffeL & l) == 0L)
1840: break;
1841: if (kind > 69)
1842: kind = 69;
1843: jjCheckNAdd(35);
1844: break;
1845: case 2:
1846: jjAddStates(21, 23);
1847: break;
1848: case 9:
1849: if ((0x100000001000L & l) != 0L && kind > 60)
1850: kind = 60;
1851: break;
1852: case 12:
1853: if ((0x2000000020L & l) != 0L)
1854: jjAddStates(43, 44);
1855: break;
1856: case 15:
1857: if ((0x5000000050L & l) != 0L && kind > 64)
1858: kind = 64;
1859: break;
1860: case 17:
1861: if ((0xffffffffefffffffL & l) != 0L)
1862: jjCheckNAdd(18);
1863: break;
1864: case 19:
1865: if (curChar == 92)
1866: jjAddStates(45, 47);
1867: break;
1868: case 20:
1869: if ((0x14404410000000L & l) != 0L)
1870: jjCheckNAdd(18);
1871: break;
1872: case 26:
1873: if ((0xffffffffefffffffL & l) != 0L)
1874: jjCheckNAddStates(10, 12);
1875: break;
1876: case 27:
1877: if (curChar == 92)
1878: jjAddStates(48, 50);
1879: break;
1880: case 28:
1881: if ((0x14404410000000L & l) != 0L)
1882: jjCheckNAddStates(10, 12);
1883: break;
1884: case 40:
1885: if ((0x2000000020L & l) != 0L)
1886: jjAddStates(51, 52);
1887: break;
1888: case 44:
1889: if ((0x2000000020L & l) != 0L)
1890: jjAddStates(53, 54);
1891: break;
1892: case 48:
1893: if ((0x2000000020L & l) != 0L)
1894: jjAddStates(55, 56);
1895: break;
1896: case 52:
1897: if ((0x100000001000000L & l) != 0L)
1898: jjCheckNAdd(53);
1899: break;
1900: case 53:
1901: if ((0x7e0000007eL & l) == 0L)
1902: break;
1903: if (kind > 60)
1904: kind = 60;
1905: jjCheckNAddTwoStates(53, 9);
1906: break;
1907: case 57:
1908: if (kind > 7)
1909: kind = 7;
1910: jjAddStates(18, 20);
1911: break;
1912: case 62:
1913: jjCheckNAddTwoStates(62, 63);
1914: break;
1915: case 64:
1916: case 65:
1917: jjCheckNAddTwoStates(65, 63);
1918: break;
1919: case 68:
1920: jjCheckNAddTwoStates(68, 69);
1921: break;
1922: case 70:
1923: case 71:
1924: jjCheckNAddTwoStates(71, 69);
1925: break;
1926: default:
1927: break;
1928: }
1929: } while (i != startsAt);
1930: } else {
1931: int hiByte = (int) (curChar >> 8);
1932: int i1 = hiByte >> 6;
1933: long l1 = 1L << (hiByte & 077);
1934: int i2 = (curChar & 0xff) >> 6;
1935: long l2 = 1L << (curChar & 077);
1936: MatchLoop: do {
1937: switch (jjstateSet[--i]) {
1938: case 6:
1939: if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
1940: if (kind > 6)
1941: kind = 6;
1942: jjCheckNAdd(0);
1943: }
1944: if (jjCanMove_2(hiByte, i1, i2, l1, l2)) {
1945: if (kind > 69)
1946: kind = 69;
1947: jjCheckNAdd(35);
1948: }
1949: break;
1950: case 0:
1951: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1952: break;
1953: if (kind > 6)
1954: kind = 6;
1955: jjCheckNAdd(0);
1956: break;
1957: case 2:
1958: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1959: jjAddStates(21, 23);
1960: break;
1961: case 17:
1962: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1963: jjstateSet[jjnewStateCnt++] = 18;
1964: break;
1965: case 26:
1966: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1967: jjAddStates(10, 12);
1968: break;
1969: case 34:
1970: case 35:
1971: if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1972: break;
1973: if (kind > 69)
1974: kind = 69;
1975: jjCheckNAdd(35);
1976: break;
1977: case 57:
1978: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1979: break;
1980: if (kind > 7)
1981: kind = 7;
1982: jjAddStates(18, 20);
1983: break;
1984: case 62:
1985: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1986: jjCheckNAddTwoStates(62, 63);
1987: break;
1988: case 64:
1989: case 65:
1990: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1991: jjCheckNAddTwoStates(65, 63);
1992: break;
1993: case 68:
1994: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1995: jjCheckNAddTwoStates(68, 69);
1996: break;
1997: case 70:
1998: case 71:
1999: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2000: jjCheckNAddTwoStates(71, 69);
2001: break;
2002: default:
2003: break;
2004: }
2005: } while (i != startsAt);
2006: }
2007: if (kind != 0x7fffffff) {
2008: jjmatchedKind = kind;
2009: jjmatchedPos = curPos;
2010: kind = 0x7fffffff;
2011: }
2012: ++curPos;
2013: if ((i = jjnewStateCnt) == (startsAt = 74 - (jjnewStateCnt = startsAt)))
2014: return curPos;
2015: try {
2016: curChar = input_stream.readChar();
2017: } catch (java.io.IOException e) {
2018: return curPos;
2019: }
2020: }
2021: }
2022:
2023: static final int[] jjnextStates = { 37, 38, 43, 44, 47, 48, 15, 56,
2024: 61, 73, 26, 27, 29, 17, 19, 52, 54, 9, 57, 58, 60, 2, 3, 5,
2025: 11, 12, 15, 26, 27, 31, 29, 39, 40, 15, 47, 48, 15, 63, 64,
2026: 66, 69, 70, 72, 13, 14, 20, 21, 23, 28, 30, 32, 41, 42, 45,
2027: 46, 49, 50, };
2028:
2029: private static final boolean jjCanMove_0(int hiByte, int i1,
2030: int i2, long l1, long l2) {
2031: switch (hiByte) {
2032: case 0:
2033: return ((jjbitVec0[i2] & l2) != 0L);
2034: default:
2035: return false;
2036: }
2037: }
2038:
2039: private static final boolean jjCanMove_1(int hiByte, int i1,
2040: int i2, long l1, long l2) {
2041: switch (hiByte) {
2042: case 0:
2043: return ((jjbitVec0[i2] & l2) != 0L);
2044: default:
2045: if ((jjbitVec1[i1] & l1) != 0L)
2046: return true;
2047: return false;
2048: }
2049: }
2050:
2051: private static final boolean jjCanMove_2(int hiByte, int i1,
2052: int i2, long l1, long l2) {
2053: switch (hiByte) {
2054: case 0:
2055: return ((jjbitVec4[i2] & l2) != 0L);
2056: case 48:
2057: return ((jjbitVec5[i2] & l2) != 0L);
2058: case 49:
2059: return ((jjbitVec6[i2] & l2) != 0L);
2060: case 51:
2061: return ((jjbitVec7[i2] & l2) != 0L);
2062: case 61:
2063: return ((jjbitVec8[i2] & l2) != 0L);
2064: default:
2065: if ((jjbitVec3[i1] & l1) != 0L)
2066: return true;
2067: return false;
2068: }
2069: }
2070:
2071: public static final String[] jjstrLiteralImages = {
2072: "",
2073: null,
2074: null,
2075: null,
2076: null,
2077: null,
2078: null,
2079: null,
2080: null,
2081: null,
2082: "\141\142\163\164\162\141\143\164",
2083: "\142\157\157\154\145\141\156",
2084: "\142\162\145\141\153",
2085: "\143\154\141\163\163",
2086: "\142\171\164\145",
2087: "\143\141\163\145",
2088: "\143\141\164\143\150",
2089: "\143\150\141\162",
2090: "\143\157\156\163\164",
2091: "\143\157\156\164\151\156\165\145",
2092: "\144\145\146\141\165\154\164",
2093: "\144\157",
2094: "\144\157\165\142\154\145",
2095: "\145\154\163\145",
2096: "\145\156\165\155",
2097: "\145\170\164\145\156\144\163",
2098: "\146\141\154\163\145",
2099: "\146\151\156\141\154",
2100: "\146\151\156\141\154\154\171",
2101: "\146\154\157\141\164",
2102: "\146\157\162",
2103: "\147\157\164\157",
2104: "\151\146",
2105: "\151\155\160\154\145\155\145\156\164\163",
2106: "\151\155\160\157\162\164",
2107: "\151\156\163\164\141\156\143\145\157\146",
2108: "\151\156\164",
2109: "\151\156\164\145\162\146\141\143\145",
2110: "\154\157\156\147",
2111: "\156\141\164\151\166\145",
2112: "\156\145\167",
2113: "\156\165\154\154",
2114: "\160\141\143\153\141\147\145",
2115: "\160\162\151\166\141\164\145",
2116: "\160\162\157\164\145\143\164\145\144",
2117: "\160\165\142\154\151\143",
2118: "\162\145\164\165\162\156",
2119: "\163\150\157\162\164",
2120: "\163\164\141\164\151\143",
2121: "\163\164\162\151\143\164\146\160",
2122: "\163\167\151\164\143\150",
2123: "\163\171\156\143\150\162\157\156\151\172\145\144",
2124: "\164\162\141\156\163\151\145\156\164",
2125: "\164\150\162\157\167",
2126: "\164\150\162\157\167\163",
2127: "\164\162\165\145",
2128: "\164\162\171",
2129: "\166\157\151\144",
2130: "\166\157\154\141\164\151\154\145",
2131: "\167\150\151\154\145",
2132: null,
2133: null,
2134: null,
2135: null,
2136: null,
2137: null,
2138: null,
2139: null,
2140: null,
2141: null,
2142: null,
2143: null,
2144: "\50",
2145: "\51",
2146: "\173",
2147: "\175",
2148: "\133",
2149: "\135",
2150: "\73",
2151: "\54",
2152: "\56",
2153: "\75",
2154: "\76",
2155: "\100\147\164",
2156: "\74",
2157: "\100\154\164",
2158: "\41",
2159: "\176",
2160: "\77",
2161: "\72",
2162: "\75\75",
2163: "\74\75",
2164: "\100\154\164\145\161",
2165: "\76\75",
2166: "\100\147\164\145\161",
2167: "\41\75",
2168: "\174\174",
2169: "\100\157\162",
2170: "\46\46",
2171: "\100\141\156\144",
2172: "\53\53",
2173: "\55\55",
2174: "\53",
2175: "\55",
2176: "\52",
2177: "\57",
2178: "\46",
2179: "\100\142\151\164\167\151\163\145\137\141\156\144",
2180: "\174",
2181: "\100\142\151\164\167\151\163\145\137\157\162",
2182: "\136",
2183: "\45",
2184: "\74\74",
2185: "\100\154\145\146\164\137\163\150\151\146\164",
2186: "\76\76",
2187: "\100\162\151\147\150\164\137\163\150\151\146\164",
2188: "\76\76\76",
2189: "\100\162\151\147\150\164\137\165\156\163\151\147\156\145\144\137\163\150\151\146\164",
2190: "\53\75",
2191: "\55\75",
2192: "\52\75",
2193: "\57\75",
2194: "\46\75",
2195: "\100\141\156\144\137\141\163\163\151\147\156",
2196: "\174\75",
2197: "\100\157\162\137\141\163\163\151\147\156",
2198: "\136\75",
2199: "\45\75",
2200: "\74\74\75",
2201: "\100\154\145\146\164\137\163\150\151\146\164\137\141\163\163\151\147\156",
2202: "\76\76\75",
2203: "\100\162\151\147\150\164\137\163\150\151\146\164\137\141\163\163\151\147\156",
2204: "\76\76\76\75",
2205: "\100\162\151\147\150\164\137\165\156\163\151\147\156\145\144\137\163\150\151\146\164\137\141\163\163\151\147\156", };
2206: public static final String[] lexStateNames = { "DEFAULT", };
2207: static final long[] jjtoToken = { 0x1ffffffffffffc01L,
2208: 0xffffffffffffff3dL, 0x3fL, };
2209: static final long[] jjtoSkip = { 0x3feL, 0x0L, 0x0L, };
2210: static final long[] jjtoSpecial = { 0x380L, 0x0L, 0x0L, };
2211: protected JavaCharStream input_stream;
2212: private final int[] jjrounds = new int[74];
2213: private final int[] jjstateSet = new int[148];
2214: protected char curChar;
2215:
2216: public ParserTokenManager(JavaCharStream stream) {
2217: if (JavaCharStream.staticFlag)
2218: throw new Error(
2219: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
2220: input_stream = stream;
2221: }
2222:
2223: public ParserTokenManager(JavaCharStream stream, int lexState) {
2224: this (stream);
2225: SwitchTo(lexState);
2226: }
2227:
2228: public void ReInit(JavaCharStream stream) {
2229: jjmatchedPos = jjnewStateCnt = 0;
2230: curLexState = defaultLexState;
2231: input_stream = stream;
2232: ReInitRounds();
2233: }
2234:
2235: private final void ReInitRounds() {
2236: int i;
2237: jjround = 0x80000001;
2238: for (i = 74; i-- > 0;)
2239: jjrounds[i] = 0x80000000;
2240: }
2241:
2242: public void ReInit(JavaCharStream stream, int lexState) {
2243: ReInit(stream);
2244: SwitchTo(lexState);
2245: }
2246:
2247: public void SwitchTo(int lexState) {
2248: if (lexState >= 1 || lexState < 0)
2249: throw new TokenMgrError(
2250: "Error: Ignoring invalid lexical state : "
2251: + lexState + ". State unchanged.",
2252: TokenMgrError.INVALID_LEXICAL_STATE);
2253: else
2254: curLexState = lexState;
2255: }
2256:
2257: protected Token jjFillToken() {
2258: Token t = Token.newToken(jjmatchedKind);
2259: t.kind = jjmatchedKind;
2260: String im = jjstrLiteralImages[jjmatchedKind];
2261: t.image = (im == null) ? input_stream.GetImage() : im;
2262: t.beginLine = input_stream.getBeginLine();
2263: t.beginColumn = input_stream.getBeginColumn();
2264: t.endLine = input_stream.getEndLine();
2265: t.endColumn = input_stream.getEndColumn();
2266: return t;
2267: }
2268:
2269: int curLexState = 0;
2270: int defaultLexState = 0;
2271: int jjnewStateCnt;
2272: int jjround;
2273: int jjmatchedPos;
2274: int jjmatchedKind;
2275:
2276: public Token getNextToken() {
2277: int kind;
2278: Token specialToken = null;
2279: Token matchedToken;
2280: int curPos = 0;
2281:
2282: EOFLoop: for (;;) {
2283: try {
2284: curChar = input_stream.BeginToken();
2285: } catch (java.io.IOException e) {
2286: jjmatchedKind = 0;
2287: matchedToken = jjFillToken();
2288: matchedToken.specialToken = specialToken;
2289: return matchedToken;
2290: }
2291:
2292: jjmatchedKind = 0x7fffffff;
2293: jjmatchedPos = 0;
2294: curPos = jjMoveStringLiteralDfa0_0();
2295: if (jjmatchedKind != 0x7fffffff) {
2296: if (jjmatchedPos + 1 < curPos)
2297: input_stream.backup(curPos - jjmatchedPos - 1);
2298: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
2299: matchedToken = jjFillToken();
2300: matchedToken.specialToken = specialToken;
2301: return matchedToken;
2302: } else {
2303: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
2304: matchedToken = jjFillToken();
2305: if (specialToken == null)
2306: specialToken = matchedToken;
2307: else {
2308: matchedToken.specialToken = specialToken;
2309: specialToken = (specialToken.next = matchedToken);
2310: }
2311: }
2312: continue EOFLoop;
2313: }
2314: }
2315: int error_line = input_stream.getEndLine();
2316: int error_column = input_stream.getEndColumn();
2317: String error_after = null;
2318: boolean EOFSeen = false;
2319: try {
2320: input_stream.readChar();
2321: input_stream.backup(1);
2322: } catch (java.io.IOException e1) {
2323: EOFSeen = true;
2324: error_after = curPos <= 1 ? "" : input_stream
2325: .GetImage();
2326: if (curChar == '\n' || curChar == '\r') {
2327: error_line++;
2328: error_column = 0;
2329: } else
2330: error_column++;
2331: }
2332: if (!EOFSeen) {
2333: input_stream.backup(1);
2334: error_after = curPos <= 1 ? "" : input_stream
2335: .GetImage();
2336: }
2337: throw new TokenMgrError(EOFSeen, curLexState, error_line,
2338: error_column, error_after, curChar,
2339: TokenMgrError.LEXICAL_ERROR);
2340: }
2341: }
2342:
2343: }
|