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