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