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