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