0001: /* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */
0002: package de.gulden.util.javasource.jjt;
0003:
0004: import de.gulden.util.javasource.SourceParser;
0005: import java.io.*;
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) {
0016: switch (pos) {
0017: case 0:
0018: if ((active0 & 0x140L) != 0L
0019: || (active1 & 0x4008000000000L) != 0L)
0020: return 2;
0021: if ((active1 & 0x100000L) != 0L)
0022: return 8;
0023: if ((active0 & 0xffffffffffffe000L) != 0L
0024: || (active1 & 0x1L) != 0L) {
0025: jjmatchedKind = 73;
0026: return 32;
0027: }
0028: return -1;
0029: case 1:
0030: if ((active0 & 0x100L) != 0L)
0031: return 0;
0032: if ((active0 & 0xfffffff7f9ffe000L) != 0L
0033: || (active1 & 0x1L) != 0L) {
0034: if (jjmatchedPos != 1) {
0035: jjmatchedKind = 73;
0036: jjmatchedPos = 1;
0037: }
0038: return 32;
0039: }
0040: if ((active0 & 0x806000000L) != 0L)
0041: return 32;
0042: return -1;
0043: case 2:
0044: if ((active0 & 0xdffff675fdffe000L) != 0L
0045: || (active1 & 0x1L) != 0L) {
0046: if (jjmatchedPos != 2) {
0047: jjmatchedKind = 73;
0048: jjmatchedPos = 2;
0049: }
0050: return 32;
0051: }
0052: if ((active0 & 0x2000098200000000L) != 0L)
0053: return 32;
0054: return -1;
0055: case 3:
0056: if ((active0 & 0x8effe571f5e9e000L) != 0L
0057: || (active1 & 0x1L) != 0L) {
0058: jjmatchedKind = 73;
0059: jjmatchedPos = 3;
0060: return 32;
0061: }
0062: if ((active0 & 0x5100120408160000L) != 0L)
0063: return 32;
0064: return -1;
0065: case 4:
0066: if ((active0 & 0x88dbe5701580e000L) != 0L) {
0067: if (jjmatchedPos != 4) {
0068: jjmatchedKind = 73;
0069: jjmatchedPos = 4;
0070: }
0071: return 32;
0072: }
0073: if ((active0 & 0x6240001e0690000L) != 0L
0074: || (active1 & 0x1L) != 0L)
0075: return 32;
0076: return -1;
0077: case 5:
0078: if ((active0 & 0x8890e1509180a000L) != 0L) {
0079: jjmatchedKind = 73;
0080: jjmatchedPos = 5;
0081: return 32;
0082: }
0083: if ((active0 & 0x44b042004004000L) != 0L)
0084: return 32;
0085: return -1;
0086: case 6:
0087: if ((active0 & 0x8890815000802000L) != 0L) {
0088: jjmatchedKind = 73;
0089: jjmatchedPos = 6;
0090: return 32;
0091: }
0092: if ((active0 & 0x600091008000L) != 0L)
0093: return 32;
0094: return -1;
0095: case 7:
0096: if ((active0 & 0x880815000000000L) != 0L) {
0097: jjmatchedKind = 73;
0098: jjmatchedPos = 7;
0099: return 32;
0100: }
0101: if ((active0 & 0x8010000000802000L) != 0L)
0102: return 32;
0103: return -1;
0104: case 8:
0105: if ((active0 & 0x80005000000000L) != 0L) {
0106: jjmatchedKind = 73;
0107: jjmatchedPos = 8;
0108: return 32;
0109: }
0110: if ((active0 & 0x800810000000000L) != 0L)
0111: return 32;
0112: return -1;
0113: case 9:
0114: if ((active0 & 0x80000000000000L) != 0L) {
0115: jjmatchedKind = 73;
0116: jjmatchedPos = 9;
0117: return 32;
0118: }
0119: if ((active0 & 0x5000000000L) != 0L)
0120: return 32;
0121: return -1;
0122: case 10:
0123: if ((active0 & 0x80000000000000L) != 0L) {
0124: jjmatchedKind = 73;
0125: jjmatchedPos = 10;
0126: return 32;
0127: }
0128: return -1;
0129: default:
0130: return -1;
0131: }
0132: }
0133:
0134: private final int jjStartNfa_0(int pos, long active0, long active1) {
0135: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
0136: active1), 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 33:
0160: jjmatchedKind = 88;
0161: return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L);
0162: case 37:
0163: jjmatchedKind = 107;
0164: return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L);
0165: case 38:
0166: jjmatchedKind = 104;
0167: return jjMoveStringLiteralDfa1_0(0x0L, 0x8000200000000L);
0168: case 40:
0169: return jjStopAtPos(0, 76);
0170: case 41:
0171: return jjStopAtPos(0, 77);
0172: case 42:
0173: jjmatchedKind = 102;
0174: return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L);
0175: case 43:
0176: jjmatchedKind = 100;
0177: return jjMoveStringLiteralDfa1_0(0x0L, 0x800400000000L);
0178: case 44:
0179: return jjStopAtPos(0, 83);
0180: case 45:
0181: jjmatchedKind = 101;
0182: return jjMoveStringLiteralDfa1_0(0x0L, 0x1000800000000L);
0183: case 46:
0184: return jjStartNfaWithStates_0(0, 84, 8);
0185: case 47:
0186: jjmatchedKind = 103;
0187: return jjMoveStringLiteralDfa1_0(0x140L, 0x4000000000000L);
0188: case 58:
0189: return jjStopAtPos(0, 91);
0190: case 59:
0191: return jjStopAtPos(0, 82);
0192: case 60:
0193: jjmatchedKind = 87;
0194: return jjMoveStringLiteralDfa1_0(0x0L, 0x80100020000000L);
0195: case 61:
0196: jjmatchedKind = 85;
0197: return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
0198: case 62:
0199: jjmatchedKind = 86;
0200: return jjMoveStringLiteralDfa1_0(0x0L, 0x300600040000000L);
0201: case 63:
0202: return jjStopAtPos(0, 90);
0203: case 91:
0204: return jjStopAtPos(0, 80);
0205: case 93:
0206: return jjStopAtPos(0, 81);
0207: case 94:
0208: jjmatchedKind = 106;
0209: return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L);
0210: case 97:
0211: return jjMoveStringLiteralDfa1_0(0x6000L, 0x0L);
0212: case 98:
0213: return jjMoveStringLiteralDfa1_0(0x38000L, 0x0L);
0214: case 99:
0215: return jjMoveStringLiteralDfa1_0(0xfc0000L, 0x0L);
0216: case 100:
0217: return jjMoveStringLiteralDfa1_0(0x7000000L, 0x0L);
0218: case 101:
0219: return jjMoveStringLiteralDfa1_0(0x18000000L, 0x0L);
0220: case 102:
0221: return jjMoveStringLiteralDfa1_0(0x3e0000000L, 0x0L);
0222: case 103:
0223: return jjMoveStringLiteralDfa1_0(0x400000000L, 0x0L);
0224: case 105:
0225: return jjMoveStringLiteralDfa1_0(0x1f800000000L, 0x0L);
0226: case 108:
0227: return jjMoveStringLiteralDfa1_0(0x20000000000L, 0x0L);
0228: case 110:
0229: return jjMoveStringLiteralDfa1_0(0x1c0000000000L, 0x0L);
0230: case 112:
0231: return jjMoveStringLiteralDfa1_0(0x1e00000000000L, 0x0L);
0232: case 114:
0233: return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L);
0234: case 115:
0235: return jjMoveStringLiteralDfa1_0(0xfc000000000000L, 0x0L);
0236: case 116:
0237: return jjMoveStringLiteralDfa1_0(0x3f00000000000000L, 0x0L);
0238: case 118:
0239: return jjMoveStringLiteralDfa1_0(0xc000000000000000L, 0x0L);
0240: case 119:
0241: return jjMoveStringLiteralDfa1_0(0x0L, 0x1L);
0242: case 123:
0243: return jjStopAtPos(0, 78);
0244: case 124:
0245: jjmatchedKind = 105;
0246: return jjMoveStringLiteralDfa1_0(0x0L, 0x10000100000000L);
0247: case 125:
0248: return jjStopAtPos(0, 79);
0249: case 126:
0250: return jjStopAtPos(0, 89);
0251: default:
0252: return jjMoveNfa_0(3, 0);
0253: }
0254: }
0255:
0256: private final int jjMoveStringLiteralDfa1_0(long active0,
0257: long active1) {
0258: try {
0259: curChar = input_stream.readChar();
0260: } catch (java.io.IOException e) {
0261: jjStopStringLiteralDfa_0(0, active0, active1);
0262: return 1;
0263: }
0264: switch (curChar) {
0265: case 38:
0266: if ((active1 & 0x200000000L) != 0L)
0267: return jjStopAtPos(1, 97);
0268: break;
0269: case 42:
0270: if ((active0 & 0x100L) != 0L)
0271: return jjStartNfaWithStates_0(1, 8, 0);
0272: break;
0273: case 43:
0274: if ((active1 & 0x400000000L) != 0L)
0275: return jjStopAtPos(1, 98);
0276: break;
0277: case 45:
0278: if ((active1 & 0x800000000L) != 0L)
0279: return jjStopAtPos(1, 99);
0280: break;
0281: case 47:
0282: if ((active0 & 0x40L) != 0L)
0283: return jjStopAtPos(1, 6);
0284: break;
0285: case 60:
0286: if ((active1 & 0x100000000000L) != 0L) {
0287: jjmatchedKind = 108;
0288: jjmatchedPos = 1;
0289: }
0290: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0291: 0x80000000000000L);
0292: case 61:
0293: if ((active1 & 0x10000000L) != 0L)
0294: return jjStopAtPos(1, 92);
0295: else if ((active1 & 0x20000000L) != 0L)
0296: return jjStopAtPos(1, 93);
0297: else if ((active1 & 0x40000000L) != 0L)
0298: return jjStopAtPos(1, 94);
0299: else if ((active1 & 0x80000000L) != 0L)
0300: return jjStopAtPos(1, 95);
0301: else if ((active1 & 0x800000000000L) != 0L)
0302: return jjStopAtPos(1, 111);
0303: else if ((active1 & 0x1000000000000L) != 0L)
0304: return jjStopAtPos(1, 112);
0305: else if ((active1 & 0x2000000000000L) != 0L)
0306: return jjStopAtPos(1, 113);
0307: else if ((active1 & 0x4000000000000L) != 0L)
0308: return jjStopAtPos(1, 114);
0309: else if ((active1 & 0x8000000000000L) != 0L)
0310: return jjStopAtPos(1, 115);
0311: else if ((active1 & 0x10000000000000L) != 0L)
0312: return jjStopAtPos(1, 116);
0313: else if ((active1 & 0x20000000000000L) != 0L)
0314: return jjStopAtPos(1, 117);
0315: else if ((active1 & 0x40000000000000L) != 0L)
0316: return jjStopAtPos(1, 118);
0317: break;
0318: case 62:
0319: if ((active1 & 0x200000000000L) != 0L) {
0320: jjmatchedKind = 109;
0321: jjmatchedPos = 1;
0322: }
0323: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0324: 0x300400000000000L);
0325: case 97:
0326: return jjMoveStringLiteralDfa2_0(active0, 0x2400200c0000L,
0327: active1, 0L);
0328: case 98:
0329: return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1,
0330: 0L);
0331: case 101:
0332: return jjMoveStringLiteralDfa2_0(active0, 0x2080001000000L,
0333: active1, 0L);
0334: case 102:
0335: if ((active0 & 0x800000000L) != 0L)
0336: return jjStartNfaWithStates_0(1, 35, 32);
0337: break;
0338: case 104:
0339: return jjMoveStringLiteralDfa2_0(active0,
0340: 0x704000000100000L, active1, 0x1L);
0341: case 105:
0342: return jjMoveStringLiteralDfa2_0(active0, 0xc0000000L,
0343: active1, 0L);
0344: case 108:
0345: return jjMoveStringLiteralDfa2_0(active0, 0x108200000L,
0346: active1, 0L);
0347: case 109:
0348: return jjMoveStringLiteralDfa2_0(active0, 0x3000000000L,
0349: active1, 0L);
0350: case 110:
0351: return jjMoveStringLiteralDfa2_0(active0, 0x1c000000000L,
0352: active1, 0L);
0353: case 111:
0354: if ((active0 & 0x2000000L) != 0L) {
0355: jjmatchedKind = 25;
0356: jjmatchedPos = 1;
0357: }
0358: return jjMoveStringLiteralDfa2_0(active0,
0359: 0xc000020604c08000L, active1, 0L);
0360: case 114:
0361: return jjMoveStringLiteralDfa2_0(active0,
0362: 0x3800c00000010000L, active1, 0L);
0363: case 115:
0364: return jjMoveStringLiteralDfa2_0(active0, 0x4000L, active1,
0365: 0L);
0366: case 116:
0367: return jjMoveStringLiteralDfa2_0(active0,
0368: 0x18000000000000L, active1, 0L);
0369: case 117:
0370: return jjMoveStringLiteralDfa2_0(active0,
0371: 0x21100000000000L, active1, 0L);
0372: case 119:
0373: return jjMoveStringLiteralDfa2_0(active0,
0374: 0x40000000000000L, active1, 0L);
0375: case 120:
0376: return jjMoveStringLiteralDfa2_0(active0, 0x10000000L,
0377: active1, 0L);
0378: case 121:
0379: return jjMoveStringLiteralDfa2_0(active0,
0380: 0x80000000020000L, active1, 0L);
0381: case 124:
0382: if ((active1 & 0x100000000L) != 0L)
0383: return jjStopAtPos(1, 96);
0384: break;
0385: default:
0386: break;
0387: }
0388: return jjStartNfa_0(0, active0, active1);
0389: }
0390:
0391: private final int jjMoveStringLiteralDfa2_0(long old0,
0392: long active0, long old1, long active1) {
0393: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0394: return jjStartNfa_0(0, old0, old1);
0395: try {
0396: curChar = input_stream.readChar();
0397: } catch (java.io.IOException e) {
0398: jjStopStringLiteralDfa_0(1, active0, active1);
0399: return 2;
0400: }
0401: switch (curChar) {
0402: case 61:
0403: if ((active1 & 0x80000000000000L) != 0L)
0404: return jjStopAtPos(2, 119);
0405: else if ((active1 & 0x100000000000000L) != 0L)
0406: return jjStopAtPos(2, 120);
0407: break;
0408: case 62:
0409: if ((active1 & 0x400000000000L) != 0L) {
0410: jjmatchedKind = 110;
0411: jjmatchedPos = 2;
0412: }
0413: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
0414: 0x200000000000000L);
0415: case 97:
0416: return jjMoveStringLiteralDfa3_0(active0,
0417: 0x808000000300000L, active1, 0L);
0418: case 98:
0419: return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L,
0420: active1, 0L);
0421: case 99:
0422: return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L,
0423: active1, 0L);
0424: case 101:
0425: return jjMoveStringLiteralDfa3_0(active0, 0x10000L,
0426: active1, 0L);
0427: case 102:
0428: return jjMoveStringLiteralDfa3_0(active0, 0x1000000L,
0429: active1, 0L);
0430: case 105:
0431: return jjMoveStringLiteralDfa3_0(active0,
0432: 0x4140400000000000L, active1, 0x1L);
0433: case 108:
0434: return jjMoveStringLiteralDfa3_0(active0,
0435: 0x8000100020000000L, active1, 0L);
0436: case 110:
0437: return jjMoveStringLiteralDfa3_0(active0,
0438: 0x800200c0c00000L, active1, 0L);
0439: case 111:
0440: return jjMoveStringLiteralDfa3_0(active0, 0x4800100008000L,
0441: active1, 0L);
0442: case 112:
0443: return jjMoveStringLiteralDfa3_0(active0,
0444: 0x20003000000000L, active1, 0L);
0445: case 114:
0446: if ((active0 & 0x200000000L) != 0L)
0447: return jjStartNfaWithStates_0(2, 33, 32);
0448: return jjMoveStringLiteralDfa3_0(active0,
0449: 0x610000000000000L, active1, 0L);
0450: case 115:
0451: return jjMoveStringLiteralDfa3_0(active0, 0x4008046000L,
0452: active1, 0L);
0453: case 116:
0454: if ((active0 & 0x8000000000L) != 0L) {
0455: jjmatchedKind = 39;
0456: jjmatchedPos = 2;
0457: }
0458: return jjMoveStringLiteralDfa3_0(active0, 0x20504100a0000L,
0459: active1, 0L);
0460: case 117:
0461: return jjMoveStringLiteralDfa3_0(active0,
0462: 0x1000000004000000L, active1, 0L);
0463: case 119:
0464: if ((active0 & 0x80000000000L) != 0L)
0465: return jjStartNfaWithStates_0(2, 43, 32);
0466: break;
0467: case 121:
0468: if ((active0 & 0x2000000000000000L) != 0L)
0469: return jjStartNfaWithStates_0(2, 61, 32);
0470: break;
0471: default:
0472: break;
0473: }
0474: return jjStartNfa_0(1, active0, active1);
0475: }
0476:
0477: private final int jjMoveStringLiteralDfa3_0(long old0,
0478: long active0, long old1, long active1) {
0479: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0480: return jjStartNfa_0(1, old0, old1);
0481: try {
0482: curChar = input_stream.readChar();
0483: } catch (java.io.IOException e) {
0484: jjStopStringLiteralDfa_0(2, active0, active1);
0485: return 3;
0486: }
0487: switch (curChar) {
0488: case 61:
0489: if ((active1 & 0x200000000000000L) != 0L)
0490: return jjStopAtPos(3, 121);
0491: break;
0492: case 97:
0493: return jjMoveStringLiteralDfa4_0(active0,
0494: 0x80000001c1010000L, active1, 0L);
0495: case 98:
0496: return jjMoveStringLiteralDfa4_0(active0, 0x4000000L,
0497: active1, 0L);
0498: case 99:
0499: return jjMoveStringLiteralDfa4_0(active0,
0500: 0x80000000080000L, active1, 0L);
0501: case 100:
0502: if ((active0 & 0x4000000000000000L) != 0L)
0503: return jjStartNfaWithStates_0(3, 62, 32);
0504: break;
0505: case 101:
0506: if ((active0 & 0x20000L) != 0L)
0507: return jjStartNfaWithStates_0(3, 17, 32);
0508: else if ((active0 & 0x40000L) != 0L)
0509: return jjStartNfaWithStates_0(3, 18, 32);
0510: else if ((active0 & 0x8000000L) != 0L)
0511: return jjStartNfaWithStates_0(3, 27, 32);
0512: else if ((active0 & 0x1000000000000000L) != 0L)
0513: return jjStartNfaWithStates_0(3, 60, 32);
0514: return jjMoveStringLiteralDfa4_0(active0,
0515: 0x20010010004000L, active1, 0L);
0516: case 103:
0517: if ((active0 & 0x20000000000L) != 0L)
0518: return jjStartNfaWithStates_0(3, 41, 32);
0519: break;
0520: case 105:
0521: return jjMoveStringLiteralDfa4_0(active0,
0522: 0x10040000000000L, active1, 0L);
0523: case 107:
0524: return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L,
0525: active1, 0L);
0526: case 108:
0527: if ((active0 & 0x100000000000L) != 0L)
0528: return jjStartNfaWithStates_0(3, 44, 32);
0529: return jjMoveStringLiteralDfa4_0(active0, 0x1001000008000L,
0530: active1, 0x1L);
0531: case 110:
0532: return jjMoveStringLiteralDfa4_0(active0,
0533: 0x800000000000000L, active1, 0L);
0534: case 111:
0535: if ((active0 & 0x400000000L) != 0L)
0536: return jjStartNfaWithStates_0(3, 34, 32);
0537: return jjMoveStringLiteralDfa4_0(active0,
0538: 0x600002000000000L, active1, 0L);
0539: case 114:
0540: if ((active0 & 0x100000L) != 0L)
0541: return jjStartNfaWithStates_0(3, 20, 32);
0542: return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L,
0543: active1, 0L);
0544: case 115:
0545: if ((active0 & 0x100000000000000L) != 0L)
0546: return jjStartNfaWithStates_0(3, 56, 32);
0547: return jjMoveStringLiteralDfa4_0(active0, 0x20600000L,
0548: active1, 0L);
0549: case 116:
0550: return jjMoveStringLiteralDfa4_0(active0,
0551: 0x48804000802000L, active1, 0L);
0552: case 117:
0553: return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L,
0554: active1, 0L);
0555: case 118:
0556: return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L,
0557: active1, 0L);
0558: default:
0559: break;
0560: }
0561: return jjStartNfa_0(2, active0, active1);
0562: }
0563:
0564: private final int jjMoveStringLiteralDfa4_0(long old0,
0565: long active0, long old1, long active1) {
0566: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0567: return jjStartNfa_0(2, old0, old1);
0568: try {
0569: curChar = input_stream.readChar();
0570: } catch (java.io.IOException e) {
0571: jjStopStringLiteralDfa_0(3, active0, active1);
0572: return 4;
0573: }
0574: switch (curChar) {
0575: case 97:
0576: return jjMoveStringLiteralDfa5_0(active0, 0x604000000000L,
0577: active1, 0L);
0578: case 99:
0579: return jjMoveStringLiteralDfa5_0(active0,
0580: 0x50000000000000L, active1, 0L);
0581: case 101:
0582: if ((active0 & 0x20000000L) != 0L)
0583: return jjStartNfaWithStates_0(4, 29, 32);
0584: else if ((active1 & 0x1L) != 0L)
0585: return jjStartNfaWithStates_0(4, 64, 32);
0586: return jjMoveStringLiteralDfa5_0(active0, 0x801000008000L,
0587: active1, 0L);
0588: case 104:
0589: if ((active0 & 0x80000L) != 0L)
0590: return jjStartNfaWithStates_0(4, 19, 32);
0591: return jjMoveStringLiteralDfa5_0(active0,
0592: 0x80000000000000L, active1, 0L);
0593: case 105:
0594: return jjMoveStringLiteralDfa5_0(active0, 0x9000000800000L,
0595: active1, 0L);
0596: case 107:
0597: if ((active0 & 0x10000L) != 0L)
0598: return jjStartNfaWithStates_0(4, 16, 32);
0599: break;
0600: case 108:
0601: if ((active0 & 0x40000000L) != 0L) {
0602: jjmatchedKind = 30;
0603: jjmatchedPos = 4;
0604: }
0605: return jjMoveStringLiteralDfa5_0(active0, 0x84000000L,
0606: active1, 0L);
0607: case 110:
0608: return jjMoveStringLiteralDfa5_0(active0, 0x10000000L,
0609: active1, 0L);
0610: case 114:
0611: if ((active0 & 0x20000000000000L) != 0L)
0612: return jjStartNfaWithStates_0(4, 53, 32);
0613: return jjMoveStringLiteralDfa5_0(active0, 0x2012000006000L,
0614: active1, 0L);
0615: case 115:
0616: if ((active0 & 0x200000L) != 0L)
0617: return jjStartNfaWithStates_0(4, 21, 32);
0618: return jjMoveStringLiteralDfa5_0(active0,
0619: 0x800000000000000L, active1, 0L);
0620: case 116:
0621: if ((active0 & 0x400000L) != 0L)
0622: return jjStartNfaWithStates_0(4, 22, 32);
0623: else if ((active0 & 0x100000000L) != 0L)
0624: return jjStartNfaWithStates_0(4, 32, 32);
0625: else if ((active0 & 0x4000000000000L) != 0L)
0626: return jjStartNfaWithStates_0(4, 50, 32);
0627: return jjMoveStringLiteralDfa5_0(active0,
0628: 0x8000000000000000L, active1, 0L);
0629: case 117:
0630: return jjMoveStringLiteralDfa5_0(active0, 0x1000000L,
0631: active1, 0L);
0632: case 118:
0633: return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L,
0634: active1, 0L);
0635: case 119:
0636: if ((active0 & 0x200000000000000L) != 0L) {
0637: jjmatchedKind = 57;
0638: jjmatchedPos = 4;
0639: }
0640: return jjMoveStringLiteralDfa5_0(active0,
0641: 0x400000000000000L, active1, 0L);
0642: default:
0643: break;
0644: }
0645: return jjStartNfa_0(3, active0, active1);
0646: }
0647:
0648: private final int jjMoveStringLiteralDfa5_0(long old0,
0649: long active0, long old1, long active1) {
0650: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0651: return jjStartNfa_0(3, old0, old1);
0652: try {
0653: curChar = input_stream.readChar();
0654: } catch (java.io.IOException e) {
0655: jjStopStringLiteralDfa_0(4, active0, 0L);
0656: return 5;
0657: }
0658: switch (curChar) {
0659: case 97:
0660: return jjMoveStringLiteralDfa6_0(active0, 0xa000L);
0661: case 99:
0662: if ((active0 & 0x1000000000000L) != 0L)
0663: return jjStartNfaWithStates_0(5, 48, 32);
0664: else if ((active0 & 0x8000000000000L) != 0L)
0665: return jjStartNfaWithStates_0(5, 51, 32);
0666: return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L);
0667: case 100:
0668: return jjMoveStringLiteralDfa6_0(active0, 0x10000000L);
0669: case 101:
0670: if ((active0 & 0x4000000L) != 0L)
0671: return jjStartNfaWithStates_0(5, 26, 32);
0672: else if ((active0 & 0x40000000000L) != 0L)
0673: return jjStartNfaWithStates_0(5, 42, 32);
0674: break;
0675: case 102:
0676: return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L);
0677: case 103:
0678: return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
0679: case 104:
0680: if ((active0 & 0x40000000000000L) != 0L)
0681: return jjStartNfaWithStates_0(5, 54, 32);
0682: break;
0683: case 105:
0684: return jjMoveStringLiteralDfa6_0(active0,
0685: 0x8800000000000000L);
0686: case 108:
0687: return jjMoveStringLiteralDfa6_0(active0, 0x81000000L);
0688: case 109:
0689: return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L);
0690: case 110:
0691: if ((active0 & 0x2000000000000L) != 0L)
0692: return jjStartNfaWithStates_0(5, 49, 32);
0693: return jjMoveStringLiteralDfa6_0(active0, 0x4000800000L);
0694: case 114:
0695: return jjMoveStringLiteralDfa6_0(active0, 0x80000000000000L);
0696: case 115:
0697: if ((active0 & 0x400000000000000L) != 0L)
0698: return jjStartNfaWithStates_0(5, 58, 32);
0699: break;
0700: case 116:
0701: if ((active0 & 0x4000L) != 0L)
0702: return jjStartNfaWithStates_0(5, 14, 32);
0703: else if ((active0 & 0x2000000000L) != 0L)
0704: return jjStartNfaWithStates_0(5, 37, 32);
0705: return jjMoveStringLiteralDfa6_0(active0, 0x10400000000000L);
0706: default:
0707: break;
0708: }
0709: return jjStartNfa_0(4, active0, 0L);
0710: }
0711:
0712: private final int jjMoveStringLiteralDfa6_0(long old0, long active0) {
0713: if (((active0 &= old0)) == 0L)
0714: return jjStartNfa_0(4, old0, 0L);
0715: try {
0716: curChar = input_stream.readChar();
0717: } catch (java.io.IOException e) {
0718: jjStopStringLiteralDfa_0(5, active0, 0L);
0719: return 6;
0720: }
0721: switch (curChar) {
0722: case 97:
0723: return jjMoveStringLiteralDfa7_0(active0, 0x10000000000L);
0724: case 99:
0725: return jjMoveStringLiteralDfa7_0(active0, 0x4000002000L);
0726: case 101:
0727: if ((active0 & 0x200000000000L) != 0L)
0728: return jjStartNfaWithStates_0(6, 45, 32);
0729: else if ((active0 & 0x400000000000L) != 0L)
0730: return jjStartNfaWithStates_0(6, 46, 32);
0731: return jjMoveStringLiteralDfa7_0(active0,
0732: 0x800001000000000L);
0733: case 102:
0734: return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
0735: case 108:
0736: return jjMoveStringLiteralDfa7_0(active0,
0737: 0x8000000000000000L);
0738: case 110:
0739: if ((active0 & 0x8000L) != 0L)
0740: return jjStartNfaWithStates_0(6, 15, 32);
0741: break;
0742: case 111:
0743: return jjMoveStringLiteralDfa7_0(active0, 0x80000000000000L);
0744: case 115:
0745: if ((active0 & 0x10000000L) != 0L)
0746: return jjStartNfaWithStates_0(6, 28, 32);
0747: break;
0748: case 116:
0749: if ((active0 & 0x1000000L) != 0L)
0750: return jjStartNfaWithStates_0(6, 24, 32);
0751: return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L);
0752: case 117:
0753: return jjMoveStringLiteralDfa7_0(active0, 0x800000L);
0754: case 121:
0755: if ((active0 & 0x80000000L) != 0L)
0756: return jjStartNfaWithStates_0(6, 31, 32);
0757: break;
0758: default:
0759: break;
0760: }
0761: return jjStartNfa_0(5, active0, 0L);
0762: }
0763:
0764: private final int jjMoveStringLiteralDfa7_0(long old0, long active0) {
0765: if (((active0 &= old0)) == 0L)
0766: return jjStartNfa_0(5, old0, 0L);
0767: try {
0768: curChar = input_stream.readChar();
0769: } catch (java.io.IOException e) {
0770: jjStopStringLiteralDfa_0(6, active0, 0L);
0771: return 7;
0772: }
0773: switch (curChar) {
0774: case 99:
0775: return jjMoveStringLiteralDfa8_0(active0, 0x10000000000L);
0776: case 101:
0777: if ((active0 & 0x800000L) != 0L)
0778: return jjStartNfaWithStates_0(7, 23, 32);
0779: else if ((active0 & 0x8000000000000000L) != 0L)
0780: return jjStartNfaWithStates_0(7, 63, 32);
0781: return jjMoveStringLiteralDfa8_0(active0, 0x804000000000L);
0782: case 110:
0783: return jjMoveStringLiteralDfa8_0(active0,
0784: 0x880001000000000L);
0785: case 112:
0786: if ((active0 & 0x10000000000000L) != 0L)
0787: return jjStartNfaWithStates_0(7, 52, 32);
0788: break;
0789: case 116:
0790: if ((active0 & 0x2000L) != 0L)
0791: return jjStartNfaWithStates_0(7, 13, 32);
0792: break;
0793: default:
0794: break;
0795: }
0796: return jjStartNfa_0(6, active0, 0L);
0797: }
0798:
0799: private final int jjMoveStringLiteralDfa8_0(long old0, long active0) {
0800: if (((active0 &= old0)) == 0L)
0801: return jjStartNfa_0(6, old0, 0L);
0802: try {
0803: curChar = input_stream.readChar();
0804: } catch (java.io.IOException e) {
0805: jjStopStringLiteralDfa_0(7, active0, 0L);
0806: return 8;
0807: }
0808: switch (curChar) {
0809: case 100:
0810: if ((active0 & 0x800000000000L) != 0L)
0811: return jjStartNfaWithStates_0(8, 47, 32);
0812: break;
0813: case 101:
0814: if ((active0 & 0x10000000000L) != 0L)
0815: return jjStartNfaWithStates_0(8, 40, 32);
0816: break;
0817: case 105:
0818: return jjMoveStringLiteralDfa9_0(active0, 0x80000000000000L);
0819: case 111:
0820: return jjMoveStringLiteralDfa9_0(active0, 0x4000000000L);
0821: case 116:
0822: if ((active0 & 0x800000000000000L) != 0L)
0823: return jjStartNfaWithStates_0(8, 59, 32);
0824: return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
0825: default:
0826: break;
0827: }
0828: return jjStartNfa_0(7, active0, 0L);
0829: }
0830:
0831: private final int jjMoveStringLiteralDfa9_0(long old0, long active0) {
0832: if (((active0 &= old0)) == 0L)
0833: return jjStartNfa_0(7, old0, 0L);
0834: try {
0835: curChar = input_stream.readChar();
0836: } catch (java.io.IOException e) {
0837: jjStopStringLiteralDfa_0(8, active0, 0L);
0838: return 9;
0839: }
0840: switch (curChar) {
0841: case 102:
0842: if ((active0 & 0x4000000000L) != 0L)
0843: return jjStartNfaWithStates_0(9, 38, 32);
0844: break;
0845: case 115:
0846: if ((active0 & 0x1000000000L) != 0L)
0847: return jjStartNfaWithStates_0(9, 36, 32);
0848: break;
0849: case 122:
0850: return jjMoveStringLiteralDfa10_0(active0,
0851: 0x80000000000000L);
0852: default:
0853: break;
0854: }
0855: return jjStartNfa_0(8, active0, 0L);
0856: }
0857:
0858: private final int jjMoveStringLiteralDfa10_0(long old0, long active0) {
0859: if (((active0 &= old0)) == 0L)
0860: return jjStartNfa_0(8, old0, 0L);
0861: try {
0862: curChar = input_stream.readChar();
0863: } catch (java.io.IOException e) {
0864: jjStopStringLiteralDfa_0(9, active0, 0L);
0865: return 10;
0866: }
0867: switch (curChar) {
0868: case 101:
0869: return jjMoveStringLiteralDfa11_0(active0,
0870: 0x80000000000000L);
0871: default:
0872: break;
0873: }
0874: return jjStartNfa_0(9, active0, 0L);
0875: }
0876:
0877: private final int jjMoveStringLiteralDfa11_0(long old0, long active0) {
0878: if (((active0 &= old0)) == 0L)
0879: return jjStartNfa_0(9, old0, 0L);
0880: try {
0881: curChar = input_stream.readChar();
0882: } catch (java.io.IOException e) {
0883: jjStopStringLiteralDfa_0(10, active0, 0L);
0884: return 11;
0885: }
0886: switch (curChar) {
0887: case 100:
0888: if ((active0 & 0x80000000000000L) != 0L)
0889: return jjStartNfaWithStates_0(11, 55, 32);
0890: break;
0891: default:
0892: break;
0893: }
0894: return jjStartNfa_0(10, active0, 0L);
0895: }
0896:
0897: private final void jjCheckNAdd(int state) {
0898: if (jjrounds[state] != jjround) {
0899: jjstateSet[jjnewStateCnt++] = state;
0900: jjrounds[state] = jjround;
0901: }
0902: }
0903:
0904: private final void jjAddStates(int start, int end) {
0905: do {
0906: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0907: } while (start++ != end);
0908: }
0909:
0910: private final void jjCheckNAddTwoStates(int state1, int state2) {
0911: jjCheckNAdd(state1);
0912: jjCheckNAdd(state2);
0913: }
0914:
0915: private final void jjCheckNAddStates(int start, int end) {
0916: do {
0917: jjCheckNAdd(jjnextStates[start]);
0918: } while (start++ != end);
0919: }
0920:
0921: private final void jjCheckNAddStates(int start) {
0922: jjCheckNAdd(jjnextStates[start]);
0923: jjCheckNAdd(jjnextStates[start + 1]);
0924: }
0925:
0926: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0927: 0xffffffffffffffffL, 0xffffffffffffffffL,
0928: 0xffffffffffffffffL };
0929: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0930: 0xffffffffffffffffL };
0931: static final long[] jjbitVec3 = { 0x1ff00000fffffffeL,
0932: 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L };
0933: static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L,
0934: 0xff7fffffff7fffffL };
0935: static final long[] jjbitVec5 = { 0x0L, 0xffffffffffffffffL,
0936: 0xffffffffffffffffL, 0xffffffffffffffffL };
0937: static final long[] jjbitVec6 = { 0xffffffffffffffffL,
0938: 0xffffffffffffffffL, 0xffffL, 0x0L };
0939: static final long[] jjbitVec7 = { 0xffffffffffffffffL,
0940: 0xffffffffffffffffL, 0x0L, 0x0L };
0941: static final long[] jjbitVec8 = { 0x3fffffffffffL, 0x0L, 0x0L, 0x0L };
0942:
0943: private final int jjMoveNfa_0(int startState, int curPos) {
0944: int[] nextStates;
0945: int startsAt = 0;
0946: jjnewStateCnt = 52;
0947: int i = 1;
0948: jjstateSet[0] = startState;
0949: int j, kind = 0x7fffffff;
0950: for (;;) {
0951: if (++jjround == 0x7fffffff)
0952: ReInitRounds();
0953: if (curChar < 64) {
0954: long l = 1L << curChar;
0955: MatchLoop: do {
0956: switch (jjstateSet[--i]) {
0957: case 3:
0958: if ((0x3ff000000000000L & l) != 0L)
0959: jjCheckNAddStates(0, 6);
0960: else if (curChar == 36) {
0961: if (kind > 73)
0962: kind = 73;
0963: jjCheckNAdd(32);
0964: } else if (curChar == 34)
0965: jjCheckNAddStates(7, 9);
0966: else if (curChar == 39)
0967: jjAddStates(10, 11);
0968: else if (curChar == 46)
0969: jjCheckNAdd(8);
0970: else if (curChar == 47)
0971: jjstateSet[jjnewStateCnt++] = 2;
0972: if ((0x3fe000000000000L & l) != 0L) {
0973: if (kind > 65)
0974: kind = 65;
0975: jjCheckNAddTwoStates(5, 6);
0976: } else if (curChar == 48) {
0977: if (kind > 65)
0978: kind = 65;
0979: jjCheckNAddStates(12, 14);
0980: }
0981: break;
0982: case 0:
0983: if (curChar == 42)
0984: jjstateSet[jjnewStateCnt++] = 1;
0985: break;
0986: case 1:
0987: if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
0988: kind = 7;
0989: break;
0990: case 2:
0991: if (curChar == 42)
0992: jjstateSet[jjnewStateCnt++] = 0;
0993: break;
0994: case 4:
0995: if ((0x3fe000000000000L & l) == 0L)
0996: break;
0997: if (kind > 65)
0998: kind = 65;
0999: jjCheckNAddTwoStates(5, 6);
1000: break;
1001: case 5:
1002: if ((0x3ff000000000000L & l) == 0L)
1003: break;
1004: if (kind > 65)
1005: kind = 65;
1006: jjCheckNAddTwoStates(5, 6);
1007: break;
1008: case 7:
1009: if (curChar == 46)
1010: jjCheckNAdd(8);
1011: break;
1012: case 8:
1013: if ((0x3ff000000000000L & l) == 0L)
1014: break;
1015: if (kind > 69)
1016: kind = 69;
1017: jjCheckNAddStates(15, 17);
1018: break;
1019: case 10:
1020: if ((0x280000000000L & l) != 0L)
1021: jjCheckNAdd(11);
1022: break;
1023: case 11:
1024: if ((0x3ff000000000000L & l) == 0L)
1025: break;
1026: if (kind > 69)
1027: kind = 69;
1028: jjCheckNAddTwoStates(11, 12);
1029: break;
1030: case 13:
1031: if (curChar == 39)
1032: jjAddStates(10, 11);
1033: break;
1034: case 14:
1035: if ((0xffffff7fffffdbffL & l) != 0L)
1036: jjCheckNAdd(15);
1037: break;
1038: case 15:
1039: if (curChar == 39 && kind > 71)
1040: kind = 71;
1041: break;
1042: case 17:
1043: if ((0x8400000000L & l) != 0L)
1044: jjCheckNAdd(15);
1045: break;
1046: case 18:
1047: if ((0xff000000000000L & l) != 0L)
1048: jjCheckNAddTwoStates(19, 15);
1049: break;
1050: case 19:
1051: if ((0xff000000000000L & l) != 0L)
1052: jjCheckNAdd(15);
1053: break;
1054: case 20:
1055: if ((0xf000000000000L & l) != 0L)
1056: jjstateSet[jjnewStateCnt++] = 21;
1057: break;
1058: case 21:
1059: if ((0xff000000000000L & l) != 0L)
1060: jjCheckNAdd(19);
1061: break;
1062: case 22:
1063: if (curChar == 34)
1064: jjCheckNAddStates(7, 9);
1065: break;
1066: case 23:
1067: if ((0xfffffffbffffdbffL & l) != 0L)
1068: jjCheckNAddStates(7, 9);
1069: break;
1070: case 25:
1071: if ((0x8400000000L & l) != 0L)
1072: jjCheckNAddStates(7, 9);
1073: break;
1074: case 26:
1075: if (curChar == 34 && kind > 72)
1076: kind = 72;
1077: break;
1078: case 27:
1079: if ((0xff000000000000L & l) != 0L)
1080: jjCheckNAddStates(18, 21);
1081: break;
1082: case 28:
1083: if ((0xff000000000000L & l) != 0L)
1084: jjCheckNAddStates(7, 9);
1085: break;
1086: case 29:
1087: if ((0xf000000000000L & l) != 0L)
1088: jjstateSet[jjnewStateCnt++] = 30;
1089: break;
1090: case 30:
1091: if ((0xff000000000000L & l) != 0L)
1092: jjCheckNAdd(28);
1093: break;
1094: case 31:
1095: if (curChar != 36)
1096: break;
1097: if (kind > 73)
1098: kind = 73;
1099: jjCheckNAdd(32);
1100: break;
1101: case 32:
1102: if ((0x3ff001000000000L & l) == 0L)
1103: break;
1104: if (kind > 73)
1105: kind = 73;
1106: jjCheckNAdd(32);
1107: break;
1108: case 33:
1109: if ((0x3ff000000000000L & l) != 0L)
1110: jjCheckNAddStates(0, 6);
1111: break;
1112: case 34:
1113: if ((0x3ff000000000000L & l) != 0L)
1114: jjCheckNAddTwoStates(34, 35);
1115: break;
1116: case 35:
1117: if (curChar != 46)
1118: break;
1119: if (kind > 69)
1120: kind = 69;
1121: jjCheckNAddStates(22, 24);
1122: break;
1123: case 36:
1124: if ((0x3ff000000000000L & l) == 0L)
1125: break;
1126: if (kind > 69)
1127: kind = 69;
1128: jjCheckNAddStates(22, 24);
1129: break;
1130: case 38:
1131: if ((0x280000000000L & l) != 0L)
1132: jjCheckNAdd(39);
1133: break;
1134: case 39:
1135: if ((0x3ff000000000000L & l) == 0L)
1136: break;
1137: if (kind > 69)
1138: kind = 69;
1139: jjCheckNAddTwoStates(39, 12);
1140: break;
1141: case 40:
1142: if ((0x3ff000000000000L & l) != 0L)
1143: jjCheckNAddTwoStates(40, 41);
1144: break;
1145: case 42:
1146: if ((0x280000000000L & l) != 0L)
1147: jjCheckNAdd(43);
1148: break;
1149: case 43:
1150: if ((0x3ff000000000000L & l) == 0L)
1151: break;
1152: if (kind > 69)
1153: kind = 69;
1154: jjCheckNAddTwoStates(43, 12);
1155: break;
1156: case 44:
1157: if ((0x3ff000000000000L & l) != 0L)
1158: jjCheckNAddStates(25, 27);
1159: break;
1160: case 46:
1161: if ((0x280000000000L & l) != 0L)
1162: jjCheckNAdd(47);
1163: break;
1164: case 47:
1165: if ((0x3ff000000000000L & l) != 0L)
1166: jjCheckNAddTwoStates(47, 12);
1167: break;
1168: case 48:
1169: if (curChar != 48)
1170: break;
1171: if (kind > 65)
1172: kind = 65;
1173: jjCheckNAddStates(12, 14);
1174: break;
1175: case 50:
1176: if ((0x3ff000000000000L & l) == 0L)
1177: break;
1178: if (kind > 65)
1179: kind = 65;
1180: jjCheckNAddTwoStates(50, 6);
1181: break;
1182: case 51:
1183: if ((0xff000000000000L & l) == 0L)
1184: break;
1185: if (kind > 65)
1186: kind = 65;
1187: jjCheckNAddTwoStates(51, 6);
1188: break;
1189: default:
1190: break;
1191: }
1192: } while (i != startsAt);
1193: } else if (curChar < 128) {
1194: long l = 1L << (curChar & 077);
1195: MatchLoop: do {
1196: switch (jjstateSet[--i]) {
1197: case 3:
1198: case 32:
1199: if ((0x7fffffe87fffffeL & l) == 0L)
1200: break;
1201: if (kind > 73)
1202: kind = 73;
1203: jjCheckNAdd(32);
1204: break;
1205: case 1:
1206: if (kind > 7)
1207: kind = 7;
1208: break;
1209: case 6:
1210: if ((0x100000001000L & l) != 0L && kind > 65)
1211: kind = 65;
1212: break;
1213: case 9:
1214: if ((0x2000000020L & l) != 0L)
1215: jjAddStates(28, 29);
1216: break;
1217: case 12:
1218: if ((0x5000000050L & l) != 0L && kind > 69)
1219: kind = 69;
1220: break;
1221: case 14:
1222: if ((0xffffffffefffffffL & l) != 0L)
1223: jjCheckNAdd(15);
1224: break;
1225: case 16:
1226: if (curChar == 92)
1227: jjAddStates(30, 32);
1228: break;
1229: case 17:
1230: if ((0x14404410000000L & l) != 0L)
1231: jjCheckNAdd(15);
1232: break;
1233: case 23:
1234: if ((0xffffffffefffffffL & l) != 0L)
1235: jjCheckNAddStates(7, 9);
1236: break;
1237: case 24:
1238: if (curChar == 92)
1239: jjAddStates(33, 35);
1240: break;
1241: case 25:
1242: if ((0x14404410000000L & l) != 0L)
1243: jjCheckNAddStates(7, 9);
1244: break;
1245: case 37:
1246: if ((0x2000000020L & l) != 0L)
1247: jjAddStates(36, 37);
1248: break;
1249: case 41:
1250: if ((0x2000000020L & l) != 0L)
1251: jjAddStates(38, 39);
1252: break;
1253: case 45:
1254: if ((0x2000000020L & l) != 0L)
1255: jjAddStates(40, 41);
1256: break;
1257: case 49:
1258: if ((0x100000001000000L & l) != 0L)
1259: jjCheckNAdd(50);
1260: break;
1261: case 50:
1262: if ((0x7e0000007eL & l) == 0L)
1263: break;
1264: if (kind > 65)
1265: kind = 65;
1266: jjCheckNAddTwoStates(50, 6);
1267: break;
1268: default:
1269: break;
1270: }
1271: } while (i != startsAt);
1272: } else {
1273: int hiByte = (int) (curChar >> 8);
1274: int i1 = hiByte >> 6;
1275: long l1 = 1L << (hiByte & 077);
1276: int i2 = (curChar & 0xff) >> 6;
1277: long l2 = 1L << (curChar & 077);
1278: MatchLoop: do {
1279: switch (jjstateSet[--i]) {
1280: case 3:
1281: case 32:
1282: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1283: break;
1284: if (kind > 73)
1285: kind = 73;
1286: jjCheckNAdd(32);
1287: break;
1288: case 1:
1289: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1290: && kind > 7)
1291: kind = 7;
1292: break;
1293: case 14:
1294: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1295: jjstateSet[jjnewStateCnt++] = 15;
1296: break;
1297: case 23:
1298: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1299: jjAddStates(7, 9);
1300: break;
1301: default:
1302: break;
1303: }
1304: } while (i != startsAt);
1305: }
1306: if (kind != 0x7fffffff) {
1307: jjmatchedKind = kind;
1308: jjmatchedPos = curPos;
1309: kind = 0x7fffffff;
1310: }
1311: ++curPos;
1312: if ((i = jjnewStateCnt) == (startsAt = 52 - (jjnewStateCnt = startsAt)))
1313: return curPos;
1314: try {
1315: curChar = input_stream.readChar();
1316: } catch (java.io.IOException e) {
1317: return curPos;
1318: }
1319: }
1320: }
1321:
1322: private final int jjMoveStringLiteralDfa0_3() {
1323: switch (curChar) {
1324: case 42:
1325: return jjMoveStringLiteralDfa1_3(0x800L);
1326: default:
1327: return 1;
1328: }
1329: }
1330:
1331: private final int jjMoveStringLiteralDfa1_3(long active0) {
1332: try {
1333: curChar = input_stream.readChar();
1334: } catch (java.io.IOException e) {
1335: return 1;
1336: }
1337: switch (curChar) {
1338: case 47:
1339: if ((active0 & 0x800L) != 0L)
1340: return jjStopAtPos(1, 11);
1341: break;
1342: default:
1343: return 2;
1344: }
1345: return 2;
1346: }
1347:
1348: private final int jjMoveStringLiteralDfa0_1() {
1349: return jjMoveNfa_1(0, 0);
1350: }
1351:
1352: private final int jjMoveNfa_1(int startState, int curPos) {
1353: int[] nextStates;
1354: int startsAt = 0;
1355: jjnewStateCnt = 3;
1356: int i = 1;
1357: jjstateSet[0] = startState;
1358: int j, kind = 0x7fffffff;
1359: for (;;) {
1360: if (++jjround == 0x7fffffff)
1361: ReInitRounds();
1362: if (curChar < 64) {
1363: long l = 1L << curChar;
1364: MatchLoop: do {
1365: switch (jjstateSet[--i]) {
1366: case 0:
1367: if ((0x2400L & l) != 0L) {
1368: if (kind > 9)
1369: kind = 9;
1370: }
1371: if (curChar == 13)
1372: jjstateSet[jjnewStateCnt++] = 1;
1373: break;
1374: case 1:
1375: if (curChar == 10 && kind > 9)
1376: kind = 9;
1377: break;
1378: case 2:
1379: if (curChar == 13)
1380: jjstateSet[jjnewStateCnt++] = 1;
1381: break;
1382: default:
1383: break;
1384: }
1385: } while (i != startsAt);
1386: } else if (curChar < 128) {
1387: long l = 1L << (curChar & 077);
1388: MatchLoop: do {
1389: switch (jjstateSet[--i]) {
1390: default:
1391: break;
1392: }
1393: } while (i != startsAt);
1394: } else {
1395: int hiByte = (int) (curChar >> 8);
1396: int i1 = hiByte >> 6;
1397: long l1 = 1L << (hiByte & 077);
1398: int i2 = (curChar & 0xff) >> 6;
1399: long l2 = 1L << (curChar & 077);
1400: MatchLoop: do {
1401: switch (jjstateSet[--i]) {
1402: default:
1403: break;
1404: }
1405: } while (i != startsAt);
1406: }
1407: if (kind != 0x7fffffff) {
1408: jjmatchedKind = kind;
1409: jjmatchedPos = curPos;
1410: kind = 0x7fffffff;
1411: }
1412: ++curPos;
1413: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1414: return curPos;
1415: try {
1416: curChar = input_stream.readChar();
1417: } catch (java.io.IOException e) {
1418: return curPos;
1419: }
1420: }
1421: }
1422:
1423: private final int jjMoveStringLiteralDfa0_2() {
1424: switch (curChar) {
1425: case 42:
1426: return jjMoveStringLiteralDfa1_2(0x400L);
1427: default:
1428: return 1;
1429: }
1430: }
1431:
1432: private final int jjMoveStringLiteralDfa1_2(long active0) {
1433: try {
1434: curChar = input_stream.readChar();
1435: } catch (java.io.IOException e) {
1436: return 1;
1437: }
1438: switch (curChar) {
1439: case 47:
1440: if ((active0 & 0x400L) != 0L)
1441: return jjStopAtPos(1, 10);
1442: break;
1443: default:
1444: return 2;
1445: }
1446: return 2;
1447: }
1448:
1449: static final int[] jjnextStates = { 34, 35, 40, 41, 44, 45, 12, 23,
1450: 24, 26, 14, 16, 49, 51, 6, 8, 9, 12, 23, 24, 28, 26, 36,
1451: 37, 12, 44, 45, 12, 10, 11, 17, 18, 20, 25, 27, 29, 38, 39,
1452: 42, 43, 46, 47, };
1453:
1454: private static final boolean jjCanMove_0(int hiByte, int i1,
1455: int i2, long l1, long l2) {
1456: switch (hiByte) {
1457: case 0:
1458: return ((jjbitVec2[i2] & l2) != 0L);
1459: default:
1460: if ((jjbitVec0[i1] & l1) != 0L)
1461: return true;
1462: return false;
1463: }
1464: }
1465:
1466: private static final boolean jjCanMove_1(int hiByte, int i1,
1467: int i2, long l1, long l2) {
1468: switch (hiByte) {
1469: case 0:
1470: return ((jjbitVec4[i2] & l2) != 0L);
1471: case 48:
1472: return ((jjbitVec5[i2] & l2) != 0L);
1473: case 49:
1474: return ((jjbitVec6[i2] & l2) != 0L);
1475: case 51:
1476: return ((jjbitVec7[i2] & l2) != 0L);
1477: case 61:
1478: return ((jjbitVec8[i2] & l2) != 0L);
1479: default:
1480: if ((jjbitVec3[i1] & l1) != 0L)
1481: return true;
1482: return false;
1483: }
1484: }
1485:
1486: public static final String[] jjstrLiteralImages = { "", null, null,
1487: null, null, null, null, null, null, null, null, null, null,
1488: "\141\142\163\164\162\141\143\164",
1489: "\141\163\163\145\162\164", "\142\157\157\154\145\141\156",
1490: "\142\162\145\141\153", "\142\171\164\145",
1491: "\143\141\163\145", "\143\141\164\143\150",
1492: "\143\150\141\162", "\143\154\141\163\163",
1493: "\143\157\156\163\164", "\143\157\156\164\151\156\165\145",
1494: "\144\145\146\141\165\154\164", "\144\157",
1495: "\144\157\165\142\154\145", "\145\154\163\145",
1496: "\145\170\164\145\156\144\163", "\146\141\154\163\145",
1497: "\146\151\156\141\154", "\146\151\156\141\154\154\171",
1498: "\146\154\157\141\164", "\146\157\162", "\147\157\164\157",
1499: "\151\146", "\151\155\160\154\145\155\145\156\164\163",
1500: "\151\155\160\157\162\164",
1501: "\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
1502: "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
1503: "\156\141\164\151\166\145", "\156\145\167",
1504: "\156\165\154\154", "\160\141\143\153\141\147\145",
1505: "\160\162\151\166\141\164\145",
1506: "\160\162\157\164\145\143\164\145\144",
1507: "\160\165\142\154\151\143", "\162\145\164\165\162\156",
1508: "\163\150\157\162\164", "\163\164\141\164\151\143",
1509: "\163\164\162\151\143\164\146\160", "\163\165\160\145\162",
1510: "\163\167\151\164\143\150",
1511: "\163\171\156\143\150\162\157\156\151\172\145\144",
1512: "\164\150\151\163", "\164\150\162\157\167",
1513: "\164\150\162\157\167\163",
1514: "\164\162\141\156\163\151\145\156\164", "\164\162\165\145",
1515: "\164\162\171", "\166\157\151\144",
1516: "\166\157\154\141\164\151\154\145", "\167\150\151\154\145",
1517: null, null, null, null, null, null, null, null, null, null,
1518: null, "\50", "\51", "\173", "\175", "\133", "\135", "\73",
1519: "\54", "\56", "\75", "\76", "\74", "\41", "\176", "\77",
1520: "\72", "\75\75", "\74\75", "\76\75", "\41\75", "\174\174",
1521: "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57",
1522: "\46", "\174", "\136", "\45", "\74\74", "\76\76",
1523: "\76\76\76", "\53\75", "\55\75", "\52\75", "\57\75",
1524: "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75",
1525: "\76\76\75", "\76\76\76\75", };
1526: public static final String[] lexStateNames = { "DEFAULT",
1527: "IN_SINGLE_LINE_COMMENT", "IN_FORMAL_COMMENT",
1528: "IN_MULTI_LINE_COMMENT", };
1529: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
1530: 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1531: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1532: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1533: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1534: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1535: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1536: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1537: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, };
1538: static final long[] jjtoToken = { 0xffffffffffffe001L,
1539: 0x3fffffffffff3a3L, };
1540: static final long[] jjtoSkip = { 0xe3eL, 0x0L, };
1541: static final long[] jjtoSpecial = { 0xe00L, 0x0L, };
1542: static final long[] jjtoMore = { 0x11c0L, 0x0L, };
1543: protected JavaCharStream input_stream;
1544: private final int[] jjrounds = new int[52];
1545: private final int[] jjstateSet = new int[104];
1546: StringBuffer image;
1547: int jjimageLen;
1548: int lengthOfMatch;
1549: protected char curChar;
1550:
1551: public ParserTokenManager(JavaCharStream stream) {
1552: if (JavaCharStream.staticFlag)
1553: throw new Error(
1554: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1555: input_stream = stream;
1556: }
1557:
1558: public ParserTokenManager(JavaCharStream stream, int lexState) {
1559: this (stream);
1560: SwitchTo(lexState);
1561: }
1562:
1563: public void ReInit(JavaCharStream stream) {
1564: jjmatchedPos = jjnewStateCnt = 0;
1565: curLexState = defaultLexState;
1566: input_stream = stream;
1567: ReInitRounds();
1568: }
1569:
1570: private final void ReInitRounds() {
1571: int i;
1572: jjround = 0x80000001;
1573: for (i = 52; i-- > 0;)
1574: jjrounds[i] = 0x80000000;
1575: }
1576:
1577: public void ReInit(JavaCharStream stream, int lexState) {
1578: ReInit(stream);
1579: SwitchTo(lexState);
1580: }
1581:
1582: public void SwitchTo(int lexState) {
1583: if (lexState >= 4 || lexState < 0)
1584: throw new TokenMgrError(
1585: "Error: Ignoring invalid lexical state : "
1586: + lexState + ". State unchanged.",
1587: TokenMgrError.INVALID_LEXICAL_STATE);
1588: else
1589: curLexState = lexState;
1590: }
1591:
1592: protected Token jjFillToken() {
1593: Token t = Token.newToken(jjmatchedKind);
1594: t.kind = jjmatchedKind;
1595: String im = jjstrLiteralImages[jjmatchedKind];
1596: t.image = (im == null) ? input_stream.GetImage() : im;
1597: t.beginLine = input_stream.getBeginLine();
1598: t.beginColumn = input_stream.getBeginColumn();
1599: t.endLine = input_stream.getEndLine();
1600: t.endColumn = input_stream.getEndColumn();
1601: return t;
1602: }
1603:
1604: int curLexState = 0;
1605: int defaultLexState = 0;
1606: int jjnewStateCnt;
1607: int jjround;
1608: int jjmatchedPos;
1609: int jjmatchedKind;
1610:
1611: public Token getNextToken() {
1612: int kind;
1613: Token specialToken = null;
1614: Token matchedToken;
1615: int curPos = 0;
1616:
1617: EOFLoop: for (;;) {
1618: try {
1619: curChar = input_stream.BeginToken();
1620: } catch (java.io.IOException e) {
1621: jjmatchedKind = 0;
1622: matchedToken = jjFillToken();
1623: matchedToken.specialToken = specialToken;
1624: return matchedToken;
1625: }
1626: image = null;
1627: jjimageLen = 0;
1628:
1629: for (;;) {
1630: switch (curLexState) {
1631: case 0:
1632: try {
1633: input_stream.backup(0);
1634: while (curChar <= 32
1635: && (0x100003600L & (1L << curChar)) != 0L)
1636: curChar = input_stream.BeginToken();
1637: } catch (java.io.IOException e1) {
1638: continue EOFLoop;
1639: }
1640: jjmatchedKind = 0x7fffffff;
1641: jjmatchedPos = 0;
1642: curPos = jjMoveStringLiteralDfa0_0();
1643: break;
1644: case 1:
1645: jjmatchedKind = 0x7fffffff;
1646: jjmatchedPos = 0;
1647: curPos = jjMoveStringLiteralDfa0_1();
1648: if (jjmatchedPos == 0 && jjmatchedKind > 12) {
1649: jjmatchedKind = 12;
1650: }
1651: break;
1652: case 2:
1653: jjmatchedKind = 0x7fffffff;
1654: jjmatchedPos = 0;
1655: curPos = jjMoveStringLiteralDfa0_2();
1656: if (jjmatchedPos == 0 && jjmatchedKind > 12) {
1657: jjmatchedKind = 12;
1658: }
1659: break;
1660: case 3:
1661: jjmatchedKind = 0x7fffffff;
1662: jjmatchedPos = 0;
1663: curPos = jjMoveStringLiteralDfa0_3();
1664: if (jjmatchedPos == 0 && jjmatchedKind > 12) {
1665: jjmatchedKind = 12;
1666: }
1667: break;
1668: }
1669: if (jjmatchedKind != 0x7fffffff) {
1670: if (jjmatchedPos + 1 < curPos)
1671: input_stream.backup(curPos - jjmatchedPos - 1);
1672: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1673: matchedToken = jjFillToken();
1674: matchedToken.specialToken = specialToken;
1675: if (jjnewLexState[jjmatchedKind] != -1)
1676: curLexState = jjnewLexState[jjmatchedKind];
1677: return matchedToken;
1678: } else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1679: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1680: matchedToken = jjFillToken();
1681: if (specialToken == null)
1682: specialToken = matchedToken;
1683: else {
1684: matchedToken.specialToken = specialToken;
1685: specialToken = (specialToken.next = matchedToken);
1686: }
1687: SkipLexicalActions(matchedToken);
1688: } else
1689: SkipLexicalActions(null);
1690: if (jjnewLexState[jjmatchedKind] != -1)
1691: curLexState = jjnewLexState[jjmatchedKind];
1692: continue EOFLoop;
1693: }
1694: MoreLexicalActions();
1695: if (jjnewLexState[jjmatchedKind] != -1)
1696: curLexState = jjnewLexState[jjmatchedKind];
1697: curPos = 0;
1698: jjmatchedKind = 0x7fffffff;
1699: try {
1700: curChar = input_stream.readChar();
1701: continue;
1702: } catch (java.io.IOException e1) {
1703: }
1704: }
1705: int error_line = input_stream.getEndLine();
1706: int error_column = input_stream.getEndColumn();
1707: String error_after = null;
1708: boolean EOFSeen = false;
1709: try {
1710: input_stream.readChar();
1711: input_stream.backup(1);
1712: } catch (java.io.IOException e1) {
1713: EOFSeen = true;
1714: error_after = curPos <= 1 ? "" : input_stream
1715: .GetImage();
1716: if (curChar == '\n' || curChar == '\r') {
1717: error_line++;
1718: error_column = 0;
1719: } else
1720: error_column++;
1721: }
1722: if (!EOFSeen) {
1723: input_stream.backup(1);
1724: error_after = curPos <= 1 ? "" : input_stream
1725: .GetImage();
1726: }
1727: throw new TokenMgrError(EOFSeen, curLexState,
1728: error_line, error_column, error_after, curChar,
1729: TokenMgrError.LEXICAL_ERROR);
1730: }
1731: }
1732: }
1733:
1734: void SkipLexicalActions(Token matchedToken) {
1735: switch (jjmatchedKind) {
1736: default:
1737: break;
1738: }
1739: }
1740:
1741: void MoreLexicalActions() {
1742: jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1743: switch (jjmatchedKind) {
1744: case 7:
1745: if (image == null)
1746: image = new StringBuffer(new String(input_stream
1747: .GetSuffix(jjimageLen)));
1748: else
1749: image.append(input_stream.GetSuffix(jjimageLen));
1750: jjimageLen = 0;
1751: input_stream.backup(1);
1752: break;
1753: default:
1754: break;
1755: }
1756: }
1757: }
|