0001: /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParserTokenManager.java */
0002: package net.sourceforge.pmd.ast;
0003:
0004: import java.util.*;
0005: import net.sourceforge.pmd.PMD;
0006:
0007: /** Token Manager. */
0008: public class JavaParserTokenManager implements JavaParserConstants {
0009: private Map<Integer, String> excludeMap = new HashMap<Integer, String>();
0010: private String excludeMarker = PMD.EXCLUDE_MARKER;
0011:
0012: public void setExcludeMarker(String marker) {
0013: this .excludeMarker = marker;
0014: }
0015:
0016: public Map<Integer, String> getExcludeMap() {
0017: return excludeMap;
0018: }
0019:
0020: /** Debug output. */
0021: public java.io.PrintStream debugStream = System.out;
0022:
0023: /** Set debug output. */
0024: public void setDebugStream(java.io.PrintStream ds) {
0025: debugStream = ds;
0026: }
0027:
0028: private final int jjStopStringLiteralDfa_0(int pos, long active0,
0029: long active1) {
0030: switch (pos) {
0031: case 0:
0032: if ((active1 & 0x80000000080000L) != 0L)
0033: return 4;
0034: if ((active0 & 0x7ffffffffffff000L) != 0L) {
0035: jjmatchedKind = 72;
0036: return 28;
0037: }
0038: if ((active0 & 0x100L) != 0L
0039: || (active1 & 0x804000000000L) != 0L)
0040: return 45;
0041: return -1;
0042: case 1:
0043: if ((active0 & 0x201800000L) != 0L)
0044: return 28;
0045: if ((active0 & 0x7ffffffdfe7ff000L) != 0L) {
0046: if (jjmatchedPos != 1) {
0047: jjmatchedKind = 72;
0048: jjmatchedPos = 1;
0049: }
0050: return 28;
0051: }
0052: if ((active0 & 0x100L) != 0L)
0053: return 50;
0054: return -1;
0055: case 2:
0056: if ((active0 & 0x400026080000000L) != 0L)
0057: return 28;
0058: if ((active0 & 0x7bfffd9d7f7ff000L) != 0L) {
0059: if (jjmatchedPos != 2) {
0060: jjmatchedKind = 72;
0061: jjmatchedPos = 2;
0062: }
0063: return 28;
0064: }
0065: return -1;
0066: case 3:
0067: if ((active0 & 0x71dff95c7d7a7000L) != 0L) {
0068: jjmatchedKind = 72;
0069: jjmatchedPos = 3;
0070: return 28;
0071: }
0072: if ((active0 & 0xa20048102058000L) != 0L)
0073: return 28;
0074: return -1;
0075: case 4:
0076: if ((active0 & 0x20c50000781a4000L) != 0L)
0077: return 28;
0078: if ((active0 & 0x511af95c05603000L) != 0L) {
0079: if (jjmatchedPos != 4) {
0080: jjmatchedKind = 72;
0081: jjmatchedPos = 4;
0082: }
0083: return 28;
0084: }
0085: return -1;
0086: case 5:
0087: if ((active0 & 0x8ac10801000000L) != 0L)
0088: return 28;
0089: if ((active0 & 0x5110385424603000L) != 0L) {
0090: jjmatchedKind = 72;
0091: jjmatchedPos = 5;
0092: return 28;
0093: }
0094: return -1;
0095: case 6:
0096: if ((active0 & 0x5110205400201000L) != 0L) {
0097: jjmatchedKind = 72;
0098: jjmatchedPos = 6;
0099: return 28;
0100: }
0101: if ((active0 & 0x180024402000L) != 0L)
0102: return 28;
0103: return -1;
0104: case 7:
0105: if ((active0 & 0x5000000000201000L) != 0L)
0106: return 28;
0107: if ((active0 & 0x110205400000000L) != 0L) {
0108: jjmatchedKind = 72;
0109: jjmatchedPos = 7;
0110: return 28;
0111: }
0112: return -1;
0113: case 8:
0114: if ((active0 & 0x100204000000000L) != 0L)
0115: return 28;
0116: if ((active0 & 0x10001400000000L) != 0L) {
0117: jjmatchedKind = 72;
0118: jjmatchedPos = 8;
0119: return 28;
0120: }
0121: return -1;
0122: case 9:
0123: if ((active0 & 0x1400000000L) != 0L)
0124: return 28;
0125: if ((active0 & 0x10000000000000L) != 0L) {
0126: jjmatchedKind = 72;
0127: jjmatchedPos = 9;
0128: return 28;
0129: }
0130: return -1;
0131: case 10:
0132: if ((active0 & 0x10000000000000L) != 0L) {
0133: jjmatchedKind = 72;
0134: jjmatchedPos = 10;
0135: return 28;
0136: }
0137: return -1;
0138: default:
0139: return -1;
0140: }
0141: }
0142:
0143: private final int jjStartNfa_0(int pos, long active0, long active1) {
0144: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
0145: active1), pos + 1);
0146: }
0147:
0148: private int jjStopAtPos(int pos, int kind) {
0149: jjmatchedKind = kind;
0150: jjmatchedPos = pos;
0151: return pos + 1;
0152: }
0153:
0154: private int jjMoveStringLiteralDfa0_0() {
0155: switch (curChar) {
0156: case 9:
0157: return jjStopAtPos(0, 2);
0158: case 10:
0159: return jjStopAtPos(0, 3);
0160: case 12:
0161: return jjStopAtPos(0, 5);
0162: case 13:
0163: return jjStopAtPos(0, 4);
0164: case 26:
0165: return jjStopAtPos(0, 123);
0166: case 32:
0167: return jjStopAtPos(0, 1);
0168: case 33:
0169: jjmatchedKind = 87;
0170: return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L);
0171: case 37:
0172: jjmatchedKind = 106;
0173: return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L);
0174: case 38:
0175: jjmatchedKind = 103;
0176: return jjMoveStringLiteralDfa1_0(0x0L, 0x1000100000000L);
0177: case 40:
0178: return jjStopAtPos(0, 75);
0179: case 41:
0180: return jjStopAtPos(0, 76);
0181: case 42:
0182: jjmatchedKind = 101;
0183: return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000000L);
0184: case 43:
0185: jjmatchedKind = 99;
0186: return jjMoveStringLiteralDfa1_0(0x0L, 0x100200000000L);
0187: case 44:
0188: return jjStopAtPos(0, 82);
0189: case 45:
0190: jjmatchedKind = 100;
0191: return jjMoveStringLiteralDfa1_0(0x0L, 0x200400000000L);
0192: case 46:
0193: jjmatchedKind = 83;
0194: return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000000L);
0195: case 47:
0196: jjmatchedKind = 102;
0197: return jjMoveStringLiteralDfa1_0(0x100L, 0x800000000000L);
0198: case 58:
0199: return jjStopAtPos(0, 90);
0200: case 59:
0201: return jjStopAtPos(0, 81);
0202: case 60:
0203: jjmatchedKind = 86;
0204: return jjMoveStringLiteralDfa1_0(0x0L, 0x10080010000000L);
0205: case 61:
0206: jjmatchedKind = 85;
0207: return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L);
0208: case 62:
0209: jjmatchedKind = 122;
0210: return jjMoveStringLiteralDfa1_0(0x0L, 0x360000020000000L);
0211: case 63:
0212: return jjStopAtPos(0, 89);
0213: case 64:
0214: return jjStopAtPos(0, 84);
0215: case 91:
0216: return jjStopAtPos(0, 79);
0217: case 93:
0218: return jjStopAtPos(0, 80);
0219: case 94:
0220: jjmatchedKind = 105;
0221: return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000L);
0222: case 97:
0223: return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);
0224: case 98:
0225: return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L);
0226: case 99:
0227: return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L);
0228: case 100:
0229: return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L);
0230: case 101:
0231: return jjMoveStringLiteralDfa1_0(0x6000000L, 0x0L);
0232: case 102:
0233: return jjMoveStringLiteralDfa1_0(0xf8000000L, 0x0L);
0234: case 103:
0235: return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);
0236: case 105:
0237: return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L);
0238: case 108:
0239: return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
0240: case 110:
0241: return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L);
0242: case 112:
0243: return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L);
0244: case 114:
0245: return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L);
0246: case 115:
0247: return jjMoveStringLiteralDfa1_0(0x401f000000000000L, 0x0L);
0248: case 116:
0249: return jjMoveStringLiteralDfa1_0(0x7e0000000000000L, 0x0L);
0250: case 118:
0251: return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L);
0252: case 119:
0253: return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
0254: case 123:
0255: return jjStopAtPos(0, 77);
0256: case 124:
0257: jjmatchedKind = 104;
0258: return jjMoveStringLiteralDfa1_0(0x0L, 0x2000080000000L);
0259: case 125:
0260: return jjStopAtPos(0, 78);
0261: case 126:
0262: jjmatchedKind = 88;
0263: return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000000L);
0264: default:
0265: return jjMoveNfa_0(0, 0);
0266: }
0267: }
0268:
0269: private int jjMoveStringLiteralDfa1_0(long active0, long active1) {
0270: try {
0271: curChar = input_stream.readChar();
0272: } catch (java.io.IOException e) {
0273: jjStopStringLiteralDfa_0(0, active0, active1);
0274: return 1;
0275: }
0276: switch (curChar) {
0277: case 38:
0278: if ((active1 & 0x100000000L) != 0L)
0279: return jjStopAtPos(1, 96);
0280: break;
0281: case 42:
0282: if ((active0 & 0x100L) != 0L)
0283: return jjStartNfaWithStates_0(1, 8, 50);
0284: break;
0285: case 43:
0286: if ((active1 & 0x200000000L) != 0L)
0287: return jjStopAtPos(1, 97);
0288: break;
0289: case 45:
0290: if ((active1 & 0x400000000L) != 0L)
0291: return jjStopAtPos(1, 98);
0292: break;
0293: case 46:
0294: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0295: 0x80000000000000L);
0296: case 60:
0297: if ((active1 & 0x80000000000L) != 0L) {
0298: jjmatchedKind = 107;
0299: jjmatchedPos = 1;
0300: }
0301: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0302: 0x10000000000000L);
0303: case 61:
0304: if ((active1 & 0x8000000L) != 0L)
0305: return jjStopAtPos(1, 91);
0306: else if ((active1 & 0x10000000L) != 0L)
0307: return jjStopAtPos(1, 92);
0308: else if ((active1 & 0x20000000L) != 0L)
0309: return jjStopAtPos(1, 93);
0310: else if ((active1 & 0x40000000L) != 0L)
0311: return jjStopAtPos(1, 94);
0312: else if ((active1 & 0x100000000000L) != 0L)
0313: return jjStopAtPos(1, 108);
0314: else if ((active1 & 0x200000000000L) != 0L)
0315: return jjStopAtPos(1, 109);
0316: else if ((active1 & 0x400000000000L) != 0L)
0317: return jjStopAtPos(1, 110);
0318: else if ((active1 & 0x800000000000L) != 0L)
0319: return jjStopAtPos(1, 111);
0320: else if ((active1 & 0x1000000000000L) != 0L)
0321: return jjStopAtPos(1, 112);
0322: else if ((active1 & 0x2000000000000L) != 0L)
0323: return jjStopAtPos(1, 113);
0324: else if ((active1 & 0x4000000000000L) != 0L)
0325: return jjStopAtPos(1, 114);
0326: else if ((active1 & 0x8000000000000L) != 0L)
0327: return jjStopAtPos(1, 115);
0328: break;
0329: case 62:
0330: if ((active1 & 0x200000000000000L) != 0L) {
0331: jjmatchedKind = 121;
0332: jjmatchedPos = 1;
0333: }
0334: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0335: 0x160000000000000L);
0336: case 91:
0337: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
0338: 0x1000000000000000L);
0339: case 97:
0340: return jjMoveStringLiteralDfa2_0(active0, 0x90008030000L,
0341: active1, 0L);
0342: case 98:
0343: return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1,
0344: 0L);
0345: case 101:
0346: return jjMoveStringLiteralDfa2_0(active0, 0x820000400000L,
0347: active1, 0L);
0348: case 102:
0349: if ((active0 & 0x200000000L) != 0L)
0350: return jjStartNfaWithStates_0(1, 33, 28);
0351: break;
0352: case 104:
0353: return jjMoveStringLiteralDfa2_0(active0,
0354: 0x20e1000000040000L, active1, 0L);
0355: case 105:
0356: return jjMoveStringLiteralDfa2_0(active0, 0x30000000L,
0357: active1, 0L);
0358: case 108:
0359: return jjMoveStringLiteralDfa2_0(active0, 0x42080000L,
0360: active1, 0L);
0361: case 109:
0362: return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L,
0363: active1, 0L);
0364: case 110:
0365: return jjMoveStringLiteralDfa2_0(active0, 0x7000000000L,
0366: active1, 0L);
0367: case 111:
0368: if ((active0 & 0x800000L) != 0L) {
0369: jjmatchedKind = 23;
0370: jjmatchedPos = 1;
0371: }
0372: return jjMoveStringLiteralDfa2_0(active0,
0373: 0x1800008181302000L, active1, 0L);
0374: case 114:
0375: return jjMoveStringLiteralDfa2_0(active0,
0376: 0x700300000004000L, active1, 0L);
0377: case 116:
0378: return jjMoveStringLiteralDfa2_0(active0,
0379: 0x4002000000000000L, active1, 0L);
0380: case 117:
0381: return jjMoveStringLiteralDfa2_0(active0, 0x4440000000000L,
0382: active1, 0L);
0383: case 119:
0384: return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L,
0385: active1, 0L);
0386: case 120:
0387: return jjMoveStringLiteralDfa2_0(active0, 0x4000000L,
0388: active1, 0L);
0389: case 121:
0390: return jjMoveStringLiteralDfa2_0(active0,
0391: 0x10000000008000L, active1, 0L);
0392: case 124:
0393: if ((active1 & 0x80000000L) != 0L)
0394: return jjStopAtPos(1, 95);
0395: break;
0396: default:
0397: break;
0398: }
0399: return jjStartNfa_0(0, active0, active1);
0400: }
0401:
0402: private int jjMoveStringLiteralDfa2_0(long old0, long active0,
0403: long old1, long active1) {
0404: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0405: return jjStartNfa_0(0, old0, old1);
0406: try {
0407: curChar = input_stream.readChar();
0408: } catch (java.io.IOException e) {
0409: jjStopStringLiteralDfa_0(1, active0, active1);
0410: return 2;
0411: }
0412: switch (curChar) {
0413: case 46:
0414: if ((active1 & 0x80000000000000L) != 0L)
0415: return jjStopAtPos(2, 119);
0416: break;
0417: case 61:
0418: if ((active1 & 0x10000000000000L) != 0L)
0419: return jjStopAtPos(2, 116);
0420: else if ((active1 & 0x20000000000000L) != 0L)
0421: return jjStopAtPos(2, 117);
0422: break;
0423: case 62:
0424: if ((active1 & 0x100000000000000L) != 0L) {
0425: jjmatchedKind = 120;
0426: jjmatchedPos = 2;
0427: }
0428: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
0429: 0x40000000000000L);
0430: case 93:
0431: if ((active1 & 0x1000000000000000L) != 0L)
0432: return jjStopAtPos(2, 124);
0433: break;
0434: case 97:
0435: return jjMoveStringLiteralDfa3_0(active0,
0436: 0x1020000000c0000L, active1, 0L);
0437: case 98:
0438: return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L,
0439: active1, 0L);
0440: case 99:
0441: return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L,
0442: active1, 0L);
0443: case 101:
0444: return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1,
0445: 0L);
0446: case 102:
0447: return jjMoveStringLiteralDfa3_0(active0, 0x400000L,
0448: active1, 0L);
0449: case 105:
0450: return jjMoveStringLiteralDfa3_0(active0,
0451: 0x2828100000000000L, active1, 0L);
0452: case 108:
0453: return jjMoveStringLiteralDfa3_0(active0,
0454: 0x1000040008000000L, active1, 0L);
0455: case 110:
0456: return jjMoveStringLiteralDfa3_0(active0,
0457: 0x10008030300000L, active1, 0L);
0458: case 111:
0459: return jjMoveStringLiteralDfa3_0(active0, 0x1200040002000L,
0460: active1, 0L);
0461: case 112:
0462: return jjMoveStringLiteralDfa3_0(active0, 0x4000c00000000L,
0463: active1, 0L);
0464: case 114:
0465: if ((active0 & 0x80000000L) != 0L)
0466: return jjStartNfaWithStates_0(2, 31, 28);
0467: return jjMoveStringLiteralDfa3_0(active0,
0468: 0x40c0000000000000L, active1, 0L);
0469: case 115:
0470: return jjMoveStringLiteralDfa3_0(active0, 0x1002011000L,
0471: active1, 0L);
0472: case 116:
0473: if ((active0 & 0x2000000000L) != 0L) {
0474: jjmatchedKind = 37;
0475: jjmatchedPos = 2;
0476: }
0477: return jjMoveStringLiteralDfa3_0(active0, 0x814104028000L,
0478: active1, 0L);
0479: case 117:
0480: return jjMoveStringLiteralDfa3_0(active0,
0481: 0x200000001000000L, active1, 0L);
0482: case 119:
0483: if ((active0 & 0x20000000000L) != 0L)
0484: return jjStartNfaWithStates_0(2, 41, 28);
0485: break;
0486: case 121:
0487: if ((active0 & 0x400000000000000L) != 0L)
0488: return jjStartNfaWithStates_0(2, 58, 28);
0489: break;
0490: default:
0491: break;
0492: }
0493: return jjStartNfa_0(1, active0, active1);
0494: }
0495:
0496: private int jjMoveStringLiteralDfa3_0(long old0, long active0,
0497: long old1, long active1) {
0498: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0499: return jjStartNfa_0(1, old0, old1);
0500: try {
0501: curChar = input_stream.readChar();
0502: } catch (java.io.IOException e) {
0503: jjStopStringLiteralDfa_0(2, active0, active1);
0504: return 3;
0505: }
0506: switch (curChar) {
0507: case 61:
0508: if ((active1 & 0x40000000000000L) != 0L)
0509: return jjStopAtPos(3, 118);
0510: break;
0511: case 97:
0512: return jjMoveStringLiteralDfa4_0(active0,
0513: 0x1000000070404000L, active1, 0L);
0514: case 98:
0515: return jjMoveStringLiteralDfa4_0(active0, 0x1000000L,
0516: active1, 0L);
0517: case 99:
0518: return jjMoveStringLiteralDfa4_0(active0,
0519: 0x10000000020000L, active1, 0L);
0520: case 100:
0521: if ((active0 & 0x800000000000000L) != 0L)
0522: return jjStartNfaWithStates_0(3, 59, 28);
0523: break;
0524: case 101:
0525: if ((active0 & 0x8000L) != 0L)
0526: return jjStartNfaWithStates_0(3, 15, 28);
0527: else if ((active0 & 0x10000L) != 0L)
0528: return jjStartNfaWithStates_0(3, 16, 28);
0529: else if ((active0 & 0x2000000L) != 0L)
0530: return jjStartNfaWithStates_0(3, 25, 28);
0531: else if ((active0 & 0x200000000000000L) != 0L)
0532: return jjStartNfaWithStates_0(3, 57, 28);
0533: return jjMoveStringLiteralDfa4_0(active0, 0x4004004000000L,
0534: active1, 0L);
0535: case 103:
0536: if ((active0 & 0x8000000000L) != 0L)
0537: return jjStartNfaWithStates_0(3, 39, 28);
0538: break;
0539: case 105:
0540: return jjMoveStringLiteralDfa4_0(active0,
0541: 0x4000010000000000L, active1, 0L);
0542: case 107:
0543: return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L,
0544: active1, 0L);
0545: case 108:
0546: if ((active0 & 0x40000000000L) != 0L)
0547: return jjStartNfaWithStates_0(3, 42, 28);
0548: return jjMoveStringLiteralDfa4_0(active0,
0549: 0x2000400400002000L, active1, 0L);
0550: case 110:
0551: return jjMoveStringLiteralDfa4_0(active0,
0552: 0x100000000000000L, active1, 0L);
0553: case 111:
0554: if ((active0 & 0x100000000L) != 0L)
0555: return jjStartNfaWithStates_0(3, 32, 28);
0556: return jjMoveStringLiteralDfa4_0(active0,
0557: 0xc0000800000000L, active1, 0L);
0558: case 114:
0559: if ((active0 & 0x40000L) != 0L)
0560: return jjStartNfaWithStates_0(3, 18, 28);
0561: return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L,
0562: active1, 0L);
0563: case 115:
0564: if ((active0 & 0x20000000000000L) != 0L)
0565: return jjStartNfaWithStates_0(3, 53, 28);
0566: return jjMoveStringLiteralDfa4_0(active0, 0x8180000L,
0567: active1, 0L);
0568: case 116:
0569: return jjMoveStringLiteralDfa4_0(active0, 0xa201000201000L,
0570: active1, 0L);
0571: case 117:
0572: return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L,
0573: active1, 0L);
0574: case 118:
0575: return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L,
0576: active1, 0L);
0577: default:
0578: break;
0579: }
0580: return jjStartNfa_0(2, active0, active1);
0581: }
0582:
0583: private int jjMoveStringLiteralDfa4_0(long old0, long active0,
0584: long old1, long active1) {
0585: if (((active0 &= old0) | (active1 &= old1)) == 0L)
0586: return jjStartNfa_0(2, old0, old1);
0587: try {
0588: curChar = input_stream.readChar();
0589: } catch (java.io.IOException e) {
0590: jjStopStringLiteralDfa_0(3, active0, 0L);
0591: return 4;
0592: }
0593: switch (curChar) {
0594: case 97:
0595: return jjMoveStringLiteralDfa5_0(active0, 0x181000000000L);
0596: case 99:
0597: return jjMoveStringLiteralDfa5_0(active0,
0598: 0x4008000000000000L);
0599: case 101:
0600: if ((active0 & 0x8000000L) != 0L)
0601: return jjStartNfaWithStates_0(4, 27, 28);
0602: else if ((active0 & 0x2000000000000000L) != 0L)
0603: return jjStartNfaWithStates_0(4, 61, 28);
0604: return jjMoveStringLiteralDfa5_0(active0, 0x200400002000L);
0605: case 104:
0606: if ((active0 & 0x20000L) != 0L)
0607: return jjStartNfaWithStates_0(4, 17, 28);
0608: return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
0609: case 105:
0610: return jjMoveStringLiteralDfa5_0(active0, 0x2400000200000L);
0611: case 107:
0612: if ((active0 & 0x4000L) != 0L)
0613: return jjStartNfaWithStates_0(4, 14, 28);
0614: break;
0615: case 108:
0616: if ((active0 & 0x10000000L) != 0L) {
0617: jjmatchedKind = 28;
0618: jjmatchedPos = 4;
0619: }
0620: return jjMoveStringLiteralDfa5_0(active0, 0x21000000L);
0621: case 110:
0622: return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
0623: case 114:
0624: if ((active0 & 0x4000000000000L) != 0L)
0625: return jjStartNfaWithStates_0(4, 50, 28);
0626: return jjMoveStringLiteralDfa5_0(active0, 0x804800001000L);
0627: case 115:
0628: if ((active0 & 0x80000L) != 0L)
0629: return jjStartNfaWithStates_0(4, 19, 28);
0630: return jjMoveStringLiteralDfa5_0(active0,
0631: 0x100000000000000L);
0632: case 116:
0633: if ((active0 & 0x100000L) != 0L)
0634: return jjStartNfaWithStates_0(4, 20, 28);
0635: else if ((active0 & 0x40000000L) != 0L)
0636: return jjStartNfaWithStates_0(4, 30, 28);
0637: else if ((active0 & 0x1000000000000L) != 0L)
0638: return jjStartNfaWithStates_0(4, 48, 28);
0639: return jjMoveStringLiteralDfa5_0(active0,
0640: 0x1000000000000000L);
0641: case 117:
0642: return jjMoveStringLiteralDfa5_0(active0, 0x400000L);
0643: case 118:
0644: return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);
0645: case 119:
0646: if ((active0 & 0x40000000000000L) != 0L) {
0647: jjmatchedKind = 54;
0648: jjmatchedPos = 4;
0649: }
0650: return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);
0651: default:
0652: break;
0653: }
0654: return jjStartNfa_0(3, active0, 0L);
0655: }
0656:
0657: private int jjMoveStringLiteralDfa5_0(long old0, long active0) {
0658: if (((active0 &= old0)) == 0L)
0659: return jjStartNfa_0(3, old0, 0L);
0660: try {
0661: curChar = input_stream.readChar();
0662: } catch (java.io.IOException e) {
0663: jjStopStringLiteralDfa_0(4, active0, 0L);
0664: return 5;
0665: }
0666: switch (curChar) {
0667: case 97:
0668: return jjMoveStringLiteralDfa6_0(active0, 0x3000L);
0669: case 99:
0670: if ((active0 & 0x400000000000L) != 0L)
0671: return jjStartNfaWithStates_0(5, 46, 28);
0672: else if ((active0 & 0x2000000000000L) != 0L)
0673: return jjStartNfaWithStates_0(5, 49, 28);
0674: return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
0675: case 100:
0676: return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
0677: case 101:
0678: if ((active0 & 0x1000000L) != 0L)
0679: return jjStartNfaWithStates_0(5, 24, 28);
0680: else if ((active0 & 0x10000000000L) != 0L)
0681: return jjStartNfaWithStates_0(5, 40, 28);
0682: break;
0683: case 102:
0684: return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L);
0685: case 103:
0686: return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L);
0687: case 104:
0688: if ((active0 & 0x8000000000000L) != 0L)
0689: return jjStartNfaWithStates_0(5, 51, 28);
0690: break;
0691: case 105:
0692: return jjMoveStringLiteralDfa6_0(active0,
0693: 0x1100000000000000L);
0694: case 108:
0695: return jjMoveStringLiteralDfa6_0(active0, 0x20400000L);
0696: case 109:
0697: return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);
0698: case 110:
0699: if ((active0 & 0x800000000000L) != 0L)
0700: return jjStartNfaWithStates_0(5, 47, 28);
0701: return jjMoveStringLiteralDfa6_0(active0, 0x1000200000L);
0702: case 114:
0703: return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
0704: case 115:
0705: if ((active0 & 0x80000000000000L) != 0L)
0706: return jjStartNfaWithStates_0(5, 55, 28);
0707: break;
0708: case 116:
0709: if ((active0 & 0x800000000L) != 0L)
0710: return jjStartNfaWithStates_0(5, 35, 28);
0711: return jjMoveStringLiteralDfa6_0(active0,
0712: 0x4000100000000000L);
0713: default:
0714: break;
0715: }
0716: return jjStartNfa_0(4, active0, 0L);
0717: }
0718:
0719: private int jjMoveStringLiteralDfa6_0(long old0, long active0) {
0720: if (((active0 &= old0)) == 0L)
0721: return jjStartNfa_0(4, old0, 0L);
0722: try {
0723: curChar = input_stream.readChar();
0724: } catch (java.io.IOException e) {
0725: jjStopStringLiteralDfa_0(5, active0, 0L);
0726: return 6;
0727: }
0728: switch (curChar) {
0729: case 97:
0730: return jjMoveStringLiteralDfa7_0(active0, 0x4000000000L);
0731: case 99:
0732: return jjMoveStringLiteralDfa7_0(active0, 0x1000001000L);
0733: case 101:
0734: if ((active0 & 0x80000000000L) != 0L)
0735: return jjStartNfaWithStates_0(6, 43, 28);
0736: else if ((active0 & 0x100000000000L) != 0L)
0737: return jjStartNfaWithStates_0(6, 44, 28);
0738: return jjMoveStringLiteralDfa7_0(active0,
0739: 0x100000400000000L);
0740: case 102:
0741: return jjMoveStringLiteralDfa7_0(active0,
0742: 0x4000000000000000L);
0743: case 108:
0744: return jjMoveStringLiteralDfa7_0(active0,
0745: 0x1000000000000000L);
0746: case 110:
0747: if ((active0 & 0x2000L) != 0L)
0748: return jjStartNfaWithStates_0(6, 13, 28);
0749: break;
0750: case 111:
0751: return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
0752: case 115:
0753: if ((active0 & 0x4000000L) != 0L)
0754: return jjStartNfaWithStates_0(6, 26, 28);
0755: break;
0756: case 116:
0757: if ((active0 & 0x400000L) != 0L)
0758: return jjStartNfaWithStates_0(6, 22, 28);
0759: return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L);
0760: case 117:
0761: return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
0762: case 121:
0763: if ((active0 & 0x20000000L) != 0L)
0764: return jjStartNfaWithStates_0(6, 29, 28);
0765: break;
0766: default:
0767: break;
0768: }
0769: return jjStartNfa_0(5, active0, 0L);
0770: }
0771:
0772: private int jjMoveStringLiteralDfa7_0(long old0, long active0) {
0773: if (((active0 &= old0)) == 0L)
0774: return jjStartNfa_0(5, old0, 0L);
0775: try {
0776: curChar = input_stream.readChar();
0777: } catch (java.io.IOException e) {
0778: jjStopStringLiteralDfa_0(6, active0, 0L);
0779: return 7;
0780: }
0781: switch (curChar) {
0782: case 99:
0783: return jjMoveStringLiteralDfa8_0(active0, 0x4000000000L);
0784: case 101:
0785: if ((active0 & 0x200000L) != 0L)
0786: return jjStartNfaWithStates_0(7, 21, 28);
0787: else if ((active0 & 0x1000000000000000L) != 0L)
0788: return jjStartNfaWithStates_0(7, 60, 28);
0789: return jjMoveStringLiteralDfa8_0(active0, 0x201000000000L);
0790: case 110:
0791: return jjMoveStringLiteralDfa8_0(active0,
0792: 0x110000400000000L);
0793: case 112:
0794: if ((active0 & 0x4000000000000000L) != 0L)
0795: return jjStartNfaWithStates_0(7, 62, 28);
0796: break;
0797: case 116:
0798: if ((active0 & 0x1000L) != 0L)
0799: return jjStartNfaWithStates_0(7, 12, 28);
0800: break;
0801: default:
0802: break;
0803: }
0804: return jjStartNfa_0(6, active0, 0L);
0805: }
0806:
0807: private int jjMoveStringLiteralDfa8_0(long old0, long active0) {
0808: if (((active0 &= old0)) == 0L)
0809: return jjStartNfa_0(6, old0, 0L);
0810: try {
0811: curChar = input_stream.readChar();
0812: } catch (java.io.IOException e) {
0813: jjStopStringLiteralDfa_0(7, active0, 0L);
0814: return 8;
0815: }
0816: switch (curChar) {
0817: case 100:
0818: if ((active0 & 0x200000000000L) != 0L)
0819: return jjStartNfaWithStates_0(8, 45, 28);
0820: break;
0821: case 101:
0822: if ((active0 & 0x4000000000L) != 0L)
0823: return jjStartNfaWithStates_0(8, 38, 28);
0824: break;
0825: case 105:
0826: return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L);
0827: case 111:
0828: return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
0829: case 116:
0830: if ((active0 & 0x100000000000000L) != 0L)
0831: return jjStartNfaWithStates_0(8, 56, 28);
0832: return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
0833: default:
0834: break;
0835: }
0836: return jjStartNfa_0(7, active0, 0L);
0837: }
0838:
0839: private int jjMoveStringLiteralDfa9_0(long old0, long active0) {
0840: if (((active0 &= old0)) == 0L)
0841: return jjStartNfa_0(7, old0, 0L);
0842: try {
0843: curChar = input_stream.readChar();
0844: } catch (java.io.IOException e) {
0845: jjStopStringLiteralDfa_0(8, active0, 0L);
0846: return 9;
0847: }
0848: switch (curChar) {
0849: case 102:
0850: if ((active0 & 0x1000000000L) != 0L)
0851: return jjStartNfaWithStates_0(9, 36, 28);
0852: break;
0853: case 115:
0854: if ((active0 & 0x400000000L) != 0L)
0855: return jjStartNfaWithStates_0(9, 34, 28);
0856: break;
0857: case 122:
0858: return jjMoveStringLiteralDfa10_0(active0,
0859: 0x10000000000000L);
0860: default:
0861: break;
0862: }
0863: return jjStartNfa_0(8, active0, 0L);
0864: }
0865:
0866: private int jjMoveStringLiteralDfa10_0(long old0, long active0) {
0867: if (((active0 &= old0)) == 0L)
0868: return jjStartNfa_0(8, old0, 0L);
0869: try {
0870: curChar = input_stream.readChar();
0871: } catch (java.io.IOException e) {
0872: jjStopStringLiteralDfa_0(9, active0, 0L);
0873: return 10;
0874: }
0875: switch (curChar) {
0876: case 101:
0877: return jjMoveStringLiteralDfa11_0(active0,
0878: 0x10000000000000L);
0879: default:
0880: break;
0881: }
0882: return jjStartNfa_0(9, active0, 0L);
0883: }
0884:
0885: private int jjMoveStringLiteralDfa11_0(long old0, long active0) {
0886: if (((active0 &= old0)) == 0L)
0887: return jjStartNfa_0(9, old0, 0L);
0888: try {
0889: curChar = input_stream.readChar();
0890: } catch (java.io.IOException e) {
0891: jjStopStringLiteralDfa_0(10, active0, 0L);
0892: return 11;
0893: }
0894: switch (curChar) {
0895: case 100:
0896: if ((active0 & 0x10000000000000L) != 0L)
0897: return jjStartNfaWithStates_0(11, 52, 28);
0898: break;
0899: default:
0900: break;
0901: }
0902: return jjStartNfa_0(10, active0, 0L);
0903: }
0904:
0905: private int jjStartNfaWithStates_0(int pos, int kind, int state) {
0906: jjmatchedKind = kind;
0907: jjmatchedPos = pos;
0908: try {
0909: curChar = input_stream.readChar();
0910: } catch (java.io.IOException e) {
0911: return pos + 1;
0912: }
0913: return jjMoveNfa_0(state, pos + 1);
0914: }
0915:
0916: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0917: 0xffffffffffffffffL, 0xffffffffffffffffL,
0918: 0xffffffffffffffffL };
0919: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0920: 0xffffffffffffffffL };
0921: static final long[] jjbitVec3 = { 0xfff0000000200002L,
0922: 0xffffffffffffdfffL, 0xfffff00f7fffffffL,
0923: 0x12000000007fffffL };
0924: static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x420043c00000000L,
0925: 0xff7fffffff7fffffL };
0926: static final long[] jjbitVec5 = { 0xffffcffffffffL,
0927: 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L };
0928: static final long[] jjbitVec6 = { 0x0L, 0x400000000000000L,
0929: 0xfffffffbffffd740L, 0xffffffcff7fffL };
0930: static final long[] jjbitVec7 = { 0xffffffffffffffffL,
0931: 0xffffffffffffffffL, 0xfffffffffffff003L,
0932: 0x33fffffffff199fL };
0933: static final long[] jjbitVec8 = { 0xfffe000000000000L,
0934: 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L };
0935: static final long[] jjbitVec9 = { 0x7fffffe00000000L,
0936: 0xfffe0000000007ffL, 0xffffffffffffffffL,
0937: 0x1c000060002fffffL };
0938: static final long[] jjbitVec10 = { 0x1ffffffd0000L, 0x0L,
0939: 0x3fffffffffL, 0x0L };
0940: static final long[] jjbitVec11 = { 0x23ffffffffffffe0L,
0941: 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L };
0942: static final long[] jjbitVec12 = { 0x36dfdfffff987e0L,
0943: 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L };
0944: static final long[] jjbitVec13 = { 0x23cdfdfffff99fe0L,
0945: 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L };
0946: static final long[] jjbitVec14 = { 0x3effdfffffddfe0L,
0947: 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L };
0948: static final long[] jjbitVec15 = { 0x3fffdfffffddfe0L,
0949: 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL };
0950: static final long[] jjbitVec16 = { 0x800dfffffffffffeL, 0x7fL,
0951: 0x200decaefef02596L, 0x3000005fL };
0952: static final long[] jjbitVec17 = { 0x1L, 0x7fffffffeffL, 0xf00L,
0953: 0x0L };
0954: static final long[] jjbitVec18 = { 0x6fbffffffffL, 0x3f0000L,
0955: 0xffffffff00000000L, 0x7fffffffff003fL };
0956: static final long[] jjbitVec19 = { 0xffffffffffffffffL,
0957: 0xffffffff83ffffffL, 0xffffff07ffffffffL,
0958: 0x3ffffffffffffffL };
0959: static final long[] jjbitVec20 = { 0xffffffffffffff7fL,
0960: 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL,
0961: 0xffff7fffff7f7f3dL };
0962: static final long[] jjbitVec21 = { 0xffffffff7f3d7fffL, 0x7ffff7fL,
0963: 0xffffffff00000000L, 0x1fffffffffffffL };
0964: static final long[] jjbitVec22 = { 0xffffffffffffffffL,
0965: 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL };
0966: static final long[] jjbitVec23 = { 0x0L, 0x0L, 0xfffffffffffffL,
0967: 0x8000000L };
0968: static final long[] jjbitVec24 = { 0xffffffff00000000L,
0969: 0xffffffffffffffL, 0x1ffffffffffL, 0x0L };
0970: static final long[] jjbitVec25 = { 0xffffffffffffffffL,
0971: 0xffffffffffffffffL, 0xffffffff0fffffffL,
0972: 0x3ffffffffffffffL };
0973: static final long[] jjbitVec26 = { 0xffffffff3f3fffffL,
0974: 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL,
0975: 0x1fdc1fff0fcf1fdcL };
0976: static final long[] jjbitVec27 = { 0x8000000000000000L,
0977: 0x8000000000000001L, 0xffff00000000L, 0x0L };
0978: static final long[] jjbitVec28 = { 0x3fbbd503e2ffc84L,
0979: 0xffffffff00000000L, 0xfL, 0x0L };
0980: static final long[] jjbitVec29 = { 0x73e03fe000000e0L,
0981: 0xfffffffffffffffeL, 0xfffffffe601fffffL,
0982: 0x7fffffffffffffffL };
0983: static final long[] jjbitVec30 = { 0xfffe1fffffffffe0L,
0984: 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L };
0985: static final long[] jjbitVec31 = { 0xffffffffffffffffL,
0986: 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L };
0987: static final long[] jjbitVec32 = { 0xffffffffffffffffL,
0988: 0xffffffffffffffffL, 0x3fffffffffL, 0x0L };
0989: static final long[] jjbitVec33 = { 0xffffffffffffffffL,
0990: 0xffffffffffffffffL, 0x1fffL, 0x0L };
0991: static final long[] jjbitVec34 = { 0xffffffffffffffffL,
0992: 0xffffffffffffffffL, 0xfffffffffL, 0x0L };
0993: static final long[] jjbitVec35 = { 0x3fffffffffffL, 0x0L, 0x0L,
0994: 0x0L };
0995: static final long[] jjbitVec36 = { 0x5f7ffdffa0f8007fL,
0996: 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L };
0997: static final long[] jjbitVec37 = { 0x3fffffffffffffffL,
0998: 0xffffffffffff0000L, 0xfffffffffffcffffL,
0999: 0xfff0000000000ffL };
1000: static final long[] jjbitVec38 = { 0x18000000000000L,
1001: 0xffd702000000e000L, 0xffffffffffffffffL,
1002: 0x1fffffffffffffffL };
1003: static final long[] jjbitVec39 = { 0x87fffffe00000010L,
1004: 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL };
1005: static final long[] jjbitVec40 = { 0x0L, 0x0L, 0x420043cffffffffL,
1006: 0xff7fffffff7fffffL };
1007: static final long[] jjbitVec41 = { 0xffffffffffffffffL,
1008: 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL };
1009: static final long[] jjbitVec42 = { 0xffffffffffffffffL,
1010: 0xffffffffffffffffL, 0xfffffffffffff07bL,
1011: 0x33fffffffff199fL };
1012: static final long[] jjbitVec43 = { 0xfffe000000000000L,
1013: 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L };
1014: static final long[] jjbitVec44 = { 0x7fffffe00000000L,
1015: 0xffff03ff003fffffL, 0xffffffffffffffffL,
1016: 0x1fff3dff9fefffffL };
1017: static final long[] jjbitVec45 = { 0xffff1fffffff8000L, 0x7ffL,
1018: 0x1ffffffffffffL, 0x0L };
1019: static final long[] jjbitVec46 = { 0xf3ffffffffffffeeL,
1020: 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL };
1021: static final long[] jjbitVec47 = { 0xd36dfdfffff987e4L,
1022: 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL };
1023: static final long[] jjbitVec48 = { 0xf3cdfdfffff99feeL,
1024: 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L };
1025: static final long[] jjbitVec49 = { 0xc3effdfffffddfeeL,
1026: 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL };
1027: static final long[] jjbitVec50 = { 0xc3fffdfffffddfecL,
1028: 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL };
1029: static final long[] jjbitVec51 = { 0x87fffffffffffffeL, 0x3ff7fffL,
1030: 0x3bffecaefef02596L, 0x33ff3f5fL };
1031: static final long[] jjbitVec52 = { 0xc2a003ff03000001L,
1032: 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L };
1033: static final long[] jjbitVec53 = { 0x3c7f6fbffffffffL, 0x3ff03ffL,
1034: 0xffffffff00000000L, 0x7fffffffff003fL };
1035: static final long[] jjbitVec54 = { 0xffffffff7f3d7fffL,
1036: 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL };
1037: static final long[] jjbitVec55 = { 0x0L, 0x0L, 0xffffffffffffffffL,
1038: 0x3ff080fffffL };
1039: static final long[] jjbitVec56 = { 0xffffffff03ff7800L,
1040: 0xffffffffffffffL, 0x3ffffffffffL, 0x0L };
1041: static final long[] jjbitVec57 = { 0x80007c000000f000L,
1042: 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L };
1043: static final long[] jjbitVec58 = { 0x73efffe000000e0L,
1044: 0xfffffffffffffffeL, 0xfffffffe661fffffL,
1045: 0x7fffffffffffffffL };
1046: static final long[] jjbitVec59 = { 0x5f7ffdffe0f8007fL,
1047: 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L };
1048: static final long[] jjbitVec60 = { 0x18000f00000000L,
1049: 0xffd702000000e000L, 0xffffffffffffffffL,
1050: 0x9fffffffffffffffL };
1051: static final long[] jjbitVec61 = { 0x87fffffe03ff0010L,
1052: 0xffffffe007fffffeL, 0x7fffffffffffffffL,
1053: 0xe0000631cfcfcfcL };
1054:
1055: private int jjMoveNfa_0(int startState, int curPos) {
1056: int startsAt = 0;
1057: jjnewStateCnt = 68;
1058: int i = 1;
1059: jjstateSet[0] = startState;
1060: int kind = 0x7fffffff;
1061: for (;;) {
1062: if (++jjround == 0x7fffffff)
1063: ReInitRounds();
1064: if (curChar < 64) {
1065: long l = 1L << curChar;
1066: do {
1067: switch (jjstateSet[--i]) {
1068: case 45:
1069: if (curChar == 42)
1070: jjstateSet[jjnewStateCnt++] = 50;
1071: else if (curChar == 47) {
1072: if (kind > 6)
1073: kind = 6;
1074: jjCheckNAddStates(0, 2);
1075: }
1076: break;
1077: case 0:
1078: if ((0x3ff000000000000L & l) != 0L)
1079: jjCheckNAddStates(3, 9);
1080: else if (curChar == 47)
1081: jjAddStates(10, 11);
1082: else if (curChar == 36) {
1083: if (kind > 72)
1084: kind = 72;
1085: jjCheckNAdd(28);
1086: } else if (curChar == 34)
1087: jjCheckNAddStates(12, 14);
1088: else if (curChar == 39)
1089: jjAddStates(15, 16);
1090: else if (curChar == 46)
1091: jjCheckNAdd(4);
1092: if ((0x3fe000000000000L & l) != 0L) {
1093: if (kind > 63)
1094: kind = 63;
1095: jjCheckNAddTwoStates(1, 2);
1096: } else if (curChar == 48) {
1097: if (kind > 63)
1098: kind = 63;
1099: jjCheckNAddStates(17, 21);
1100: }
1101: break;
1102: case 1:
1103: if ((0x3ff000000000000L & l) == 0L)
1104: break;
1105: if (kind > 63)
1106: kind = 63;
1107: jjCheckNAddTwoStates(1, 2);
1108: break;
1109: case 3:
1110: if (curChar == 46)
1111: jjCheckNAdd(4);
1112: break;
1113: case 4:
1114: if ((0x3ff000000000000L & l) == 0L)
1115: break;
1116: if (kind > 67)
1117: kind = 67;
1118: jjCheckNAddStates(22, 24);
1119: break;
1120: case 6:
1121: if ((0x280000000000L & l) != 0L)
1122: jjCheckNAdd(7);
1123: break;
1124: case 7:
1125: if ((0x3ff000000000000L & l) == 0L)
1126: break;
1127: if (kind > 67)
1128: kind = 67;
1129: jjCheckNAddTwoStates(7, 8);
1130: break;
1131: case 9:
1132: if (curChar == 39)
1133: jjAddStates(15, 16);
1134: break;
1135: case 10:
1136: if ((0xffffff7fffffdbffL & l) != 0L)
1137: jjCheckNAdd(11);
1138: break;
1139: case 11:
1140: if (curChar == 39 && kind > 70)
1141: kind = 70;
1142: break;
1143: case 13:
1144: if ((0x8400000000L & l) != 0L)
1145: jjCheckNAdd(11);
1146: break;
1147: case 14:
1148: if ((0xff000000000000L & l) != 0L)
1149: jjCheckNAddTwoStates(15, 11);
1150: break;
1151: case 15:
1152: if ((0xff000000000000L & l) != 0L)
1153: jjCheckNAdd(11);
1154: break;
1155: case 16:
1156: if ((0xf000000000000L & l) != 0L)
1157: jjstateSet[jjnewStateCnt++] = 17;
1158: break;
1159: case 17:
1160: if ((0xff000000000000L & l) != 0L)
1161: jjCheckNAdd(15);
1162: break;
1163: case 18:
1164: if (curChar == 34)
1165: jjCheckNAddStates(12, 14);
1166: break;
1167: case 19:
1168: if ((0xfffffffbffffdbffL & l) != 0L)
1169: jjCheckNAddStates(12, 14);
1170: break;
1171: case 21:
1172: if ((0x8400000000L & l) != 0L)
1173: jjCheckNAddStates(12, 14);
1174: break;
1175: case 22:
1176: if (curChar == 34 && kind > 71)
1177: kind = 71;
1178: break;
1179: case 23:
1180: if ((0xff000000000000L & l) != 0L)
1181: jjCheckNAddStates(25, 28);
1182: break;
1183: case 24:
1184: if ((0xff000000000000L & l) != 0L)
1185: jjCheckNAddStates(12, 14);
1186: break;
1187: case 25:
1188: if ((0xf000000000000L & l) != 0L)
1189: jjstateSet[jjnewStateCnt++] = 26;
1190: break;
1191: case 26:
1192: if ((0xff000000000000L & l) != 0L)
1193: jjCheckNAdd(24);
1194: break;
1195: case 27:
1196: if (curChar != 36)
1197: break;
1198: if (kind > 72)
1199: kind = 72;
1200: jjCheckNAdd(28);
1201: break;
1202: case 28:
1203: if ((0x3ff00100fffc1ffL & l) == 0L)
1204: break;
1205: if (kind > 72)
1206: kind = 72;
1207: jjCheckNAdd(28);
1208: break;
1209: case 29:
1210: if ((0x3ff000000000000L & l) != 0L)
1211: jjCheckNAddStates(3, 9);
1212: break;
1213: case 30:
1214: if ((0x3ff000000000000L & l) != 0L)
1215: jjCheckNAddTwoStates(30, 31);
1216: break;
1217: case 31:
1218: if (curChar != 46)
1219: break;
1220: if (kind > 67)
1221: kind = 67;
1222: jjCheckNAddStates(29, 31);
1223: break;
1224: case 32:
1225: if ((0x3ff000000000000L & l) == 0L)
1226: break;
1227: if (kind > 67)
1228: kind = 67;
1229: jjCheckNAddStates(29, 31);
1230: break;
1231: case 34:
1232: if ((0x280000000000L & l) != 0L)
1233: jjCheckNAdd(35);
1234: break;
1235: case 35:
1236: if ((0x3ff000000000000L & l) == 0L)
1237: break;
1238: if (kind > 67)
1239: kind = 67;
1240: jjCheckNAddTwoStates(35, 8);
1241: break;
1242: case 36:
1243: if ((0x3ff000000000000L & l) != 0L)
1244: jjCheckNAddTwoStates(36, 37);
1245: break;
1246: case 38:
1247: if ((0x280000000000L & l) != 0L)
1248: jjCheckNAdd(39);
1249: break;
1250: case 39:
1251: if ((0x3ff000000000000L & l) == 0L)
1252: break;
1253: if (kind > 67)
1254: kind = 67;
1255: jjCheckNAddTwoStates(39, 8);
1256: break;
1257: case 40:
1258: if ((0x3ff000000000000L & l) != 0L)
1259: jjCheckNAddStates(32, 34);
1260: break;
1261: case 42:
1262: if ((0x280000000000L & l) != 0L)
1263: jjCheckNAdd(43);
1264: break;
1265: case 43:
1266: if ((0x3ff000000000000L & l) != 0L)
1267: jjCheckNAddTwoStates(43, 8);
1268: break;
1269: case 44:
1270: if (curChar == 47)
1271: jjAddStates(10, 11);
1272: break;
1273: case 46:
1274: if ((0xffffffffffffdbffL & l) == 0L)
1275: break;
1276: if (kind > 6)
1277: kind = 6;
1278: jjCheckNAddStates(0, 2);
1279: break;
1280: case 47:
1281: if ((0x2400L & l) != 0L && kind > 6)
1282: kind = 6;
1283: break;
1284: case 48:
1285: if (curChar == 10 && kind > 6)
1286: kind = 6;
1287: break;
1288: case 49:
1289: if (curChar == 13)
1290: jjstateSet[jjnewStateCnt++] = 48;
1291: break;
1292: case 50:
1293: if (curChar == 42)
1294: jjstateSet[jjnewStateCnt++] = 51;
1295: break;
1296: case 51:
1297: if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
1298: kind = 7;
1299: break;
1300: case 52:
1301: if (curChar == 42)
1302: jjstateSet[jjnewStateCnt++] = 50;
1303: break;
1304: case 53:
1305: if (curChar != 48)
1306: break;
1307: if (kind > 63)
1308: kind = 63;
1309: jjCheckNAddStates(17, 21);
1310: break;
1311: case 55:
1312: if ((0x3ff000000000000L & l) == 0L)
1313: break;
1314: if (kind > 63)
1315: kind = 63;
1316: jjCheckNAddTwoStates(55, 2);
1317: break;
1318: case 56:
1319: if ((0xff000000000000L & l) == 0L)
1320: break;
1321: if (kind > 63)
1322: kind = 63;
1323: jjCheckNAddTwoStates(56, 2);
1324: break;
1325: case 58:
1326: if ((0x3ff000000000000L & l) != 0L)
1327: jjCheckNAddStates(35, 37);
1328: break;
1329: case 59:
1330: if (curChar == 46)
1331: jjCheckNAdd(60);
1332: break;
1333: case 61:
1334: if ((0x280000000000L & l) != 0L)
1335: jjCheckNAdd(62);
1336: break;
1337: case 62:
1338: if ((0x3ff000000000000L & l) == 0L)
1339: break;
1340: if (kind > 68)
1341: kind = 68;
1342: jjCheckNAddTwoStates(62, 63);
1343: break;
1344: case 65:
1345: if ((0x3ff000000000000L & l) != 0L)
1346: jjAddStates(38, 39);
1347: break;
1348: case 66:
1349: if (curChar == 46)
1350: jjCheckNAdd(67);
1351: break;
1352: case 67:
1353: if ((0x3ff000000000000L & l) != 0L)
1354: jjCheckNAddTwoStates(67, 60);
1355: break;
1356: default:
1357: break;
1358: }
1359: } while (i != startsAt);
1360: } else if (curChar < 128) {
1361: long l = 1L << (curChar & 077);
1362: do {
1363: switch (jjstateSet[--i]) {
1364: case 0:
1365: if ((0x7fffffe87fffffeL & l) == 0L)
1366: break;
1367: if (kind > 72)
1368: kind = 72;
1369: jjCheckNAdd(28);
1370: break;
1371: case 2:
1372: if ((0x100000001000L & l) != 0L && kind > 63)
1373: kind = 63;
1374: break;
1375: case 5:
1376: if ((0x2000000020L & l) != 0L)
1377: jjAddStates(40, 41);
1378: break;
1379: case 8:
1380: if ((0x5000000050L & l) != 0L && kind > 67)
1381: kind = 67;
1382: break;
1383: case 10:
1384: if ((0xffffffffefffffffL & l) != 0L)
1385: jjCheckNAdd(11);
1386: break;
1387: case 12:
1388: if (curChar == 92)
1389: jjAddStates(42, 44);
1390: break;
1391: case 13:
1392: if ((0x14404410000000L & l) != 0L)
1393: jjCheckNAdd(11);
1394: break;
1395: case 19:
1396: if ((0xffffffffefffffffL & l) != 0L)
1397: jjCheckNAddStates(12, 14);
1398: break;
1399: case 20:
1400: if (curChar == 92)
1401: jjAddStates(45, 47);
1402: break;
1403: case 21:
1404: if ((0x14404410000000L & l) != 0L)
1405: jjCheckNAddStates(12, 14);
1406: break;
1407: case 28:
1408: if ((0x87fffffe87fffffeL & l) == 0L)
1409: break;
1410: if (kind > 72)
1411: kind = 72;
1412: jjCheckNAdd(28);
1413: break;
1414: case 33:
1415: if ((0x2000000020L & l) != 0L)
1416: jjAddStates(48, 49);
1417: break;
1418: case 37:
1419: if ((0x2000000020L & l) != 0L)
1420: jjAddStates(50, 51);
1421: break;
1422: case 41:
1423: if ((0x2000000020L & l) != 0L)
1424: jjAddStates(52, 53);
1425: break;
1426: case 46:
1427: if (kind > 6)
1428: kind = 6;
1429: jjAddStates(0, 2);
1430: break;
1431: case 51:
1432: if (kind > 7)
1433: kind = 7;
1434: break;
1435: case 54:
1436: if ((0x100000001000000L & l) != 0L)
1437: jjCheckNAdd(55);
1438: break;
1439: case 55:
1440: if ((0x7e0000007eL & l) == 0L)
1441: break;
1442: if (kind > 63)
1443: kind = 63;
1444: jjCheckNAddTwoStates(55, 2);
1445: break;
1446: case 57:
1447: if ((0x100000001000000L & l) != 0L)
1448: jjCheckNAdd(58);
1449: break;
1450: case 58:
1451: if ((0x7e0000007eL & l) != 0L)
1452: jjCheckNAddStates(35, 37);
1453: break;
1454: case 60:
1455: if ((0x1000000010000L & l) != 0L)
1456: jjAddStates(54, 55);
1457: break;
1458: case 63:
1459: if ((0x5000000050L & l) != 0L && kind > 68)
1460: kind = 68;
1461: break;
1462: case 64:
1463: if ((0x100000001000000L & l) != 0L)
1464: jjCheckNAddTwoStates(65, 66);
1465: break;
1466: case 65:
1467: if ((0x7e0000007eL & l) != 0L)
1468: jjCheckNAddTwoStates(65, 66);
1469: break;
1470: case 67:
1471: if ((0x7e0000007eL & l) != 0L)
1472: jjCheckNAddTwoStates(67, 60);
1473: break;
1474: default:
1475: break;
1476: }
1477: } while (i != startsAt);
1478: } else {
1479: int hiByte = (int) (curChar >> 8);
1480: int i1 = hiByte >> 6;
1481: long l1 = 1L << (hiByte & 077);
1482: int i2 = (curChar & 0xff) >> 6;
1483: long l2 = 1L << (curChar & 077);
1484: do {
1485: switch (jjstateSet[--i]) {
1486: case 0:
1487: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1488: break;
1489: if (kind > 72)
1490: kind = 72;
1491: jjCheckNAdd(28);
1492: break;
1493: case 10:
1494: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1495: jjstateSet[jjnewStateCnt++] = 11;
1496: break;
1497: case 19:
1498: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1499: jjAddStates(12, 14);
1500: break;
1501: case 28:
1502: if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1503: break;
1504: if (kind > 72)
1505: kind = 72;
1506: jjCheckNAdd(28);
1507: break;
1508: case 46:
1509: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1510: break;
1511: if (kind > 6)
1512: kind = 6;
1513: jjAddStates(0, 2);
1514: break;
1515: case 51:
1516: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1517: && kind > 7)
1518: kind = 7;
1519: break;
1520: default:
1521: break;
1522: }
1523: } while (i != startsAt);
1524: }
1525: if (kind != 0x7fffffff) {
1526: jjmatchedKind = kind;
1527: jjmatchedPos = curPos;
1528: kind = 0x7fffffff;
1529: }
1530: ++curPos;
1531: if ((i = jjnewStateCnt) == (startsAt = 68 - (jjnewStateCnt = startsAt)))
1532: return curPos;
1533: try {
1534: curChar = input_stream.readChar();
1535: } catch (java.io.IOException e) {
1536: return curPos;
1537: }
1538: }
1539: }
1540:
1541: private int jjMoveStringLiteralDfa0_2() {
1542: switch (curChar) {
1543: case 42:
1544: return jjMoveStringLiteralDfa1_2(0x400L);
1545: default:
1546: return 1;
1547: }
1548: }
1549:
1550: private int jjMoveStringLiteralDfa1_2(long active0) {
1551: try {
1552: curChar = input_stream.readChar();
1553: } catch (java.io.IOException e) {
1554: return 1;
1555: }
1556: switch (curChar) {
1557: case 47:
1558: if ((active0 & 0x400L) != 0L)
1559: return jjStopAtPos(1, 10);
1560: break;
1561: default:
1562: return 2;
1563: }
1564: return 2;
1565: }
1566:
1567: private int jjMoveStringLiteralDfa0_1() {
1568: switch (curChar) {
1569: case 42:
1570: return jjMoveStringLiteralDfa1_1(0x200L);
1571: default:
1572: return 1;
1573: }
1574: }
1575:
1576: private int jjMoveStringLiteralDfa1_1(long active0) {
1577: try {
1578: curChar = input_stream.readChar();
1579: } catch (java.io.IOException e) {
1580: return 1;
1581: }
1582: switch (curChar) {
1583: case 47:
1584: if ((active0 & 0x200L) != 0L)
1585: return jjStopAtPos(1, 9);
1586: break;
1587: default:
1588: return 2;
1589: }
1590: return 2;
1591: }
1592:
1593: static final int[] jjnextStates = { 46, 47, 49, 30, 31, 36, 37, 40,
1594: 41, 8, 45, 52, 19, 20, 22, 10, 12, 54, 56, 2, 57, 64, 4, 5,
1595: 8, 19, 20, 24, 22, 32, 33, 8, 40, 41, 8, 58, 59, 60, 65,
1596: 66, 6, 7, 13, 14, 16, 21, 23, 25, 34, 35, 38, 39, 42, 43,
1597: 61, 62, };
1598:
1599: private static final boolean jjCanMove_0(int hiByte, int i1,
1600: int i2, long l1, long l2) {
1601: switch (hiByte) {
1602: case 0:
1603: return ((jjbitVec2[i2] & l2) != 0L);
1604: default:
1605: if ((jjbitVec0[i1] & l1) != 0L)
1606: return true;
1607: return false;
1608: }
1609: }
1610:
1611: private static final boolean jjCanMove_1(int hiByte, int i1,
1612: int i2, long l1, long l2) {
1613: switch (hiByte) {
1614: case 0:
1615: return ((jjbitVec4[i2] & l2) != 0L);
1616: case 2:
1617: return ((jjbitVec5[i2] & l2) != 0L);
1618: case 3:
1619: return ((jjbitVec6[i2] & l2) != 0L);
1620: case 4:
1621: return ((jjbitVec7[i2] & l2) != 0L);
1622: case 5:
1623: return ((jjbitVec8[i2] & l2) != 0L);
1624: case 6:
1625: return ((jjbitVec9[i2] & l2) != 0L);
1626: case 7:
1627: return ((jjbitVec10[i2] & l2) != 0L);
1628: case 9:
1629: return ((jjbitVec11[i2] & l2) != 0L);
1630: case 10:
1631: return ((jjbitVec12[i2] & l2) != 0L);
1632: case 11:
1633: return ((jjbitVec13[i2] & l2) != 0L);
1634: case 12:
1635: return ((jjbitVec14[i2] & l2) != 0L);
1636: case 13:
1637: return ((jjbitVec15[i2] & l2) != 0L);
1638: case 14:
1639: return ((jjbitVec16[i2] & l2) != 0L);
1640: case 15:
1641: return ((jjbitVec17[i2] & l2) != 0L);
1642: case 16:
1643: return ((jjbitVec18[i2] & l2) != 0L);
1644: case 17:
1645: return ((jjbitVec19[i2] & l2) != 0L);
1646: case 18:
1647: return ((jjbitVec20[i2] & l2) != 0L);
1648: case 19:
1649: return ((jjbitVec21[i2] & l2) != 0L);
1650: case 20:
1651: return ((jjbitVec0[i2] & l2) != 0L);
1652: case 22:
1653: return ((jjbitVec22[i2] & l2) != 0L);
1654: case 23:
1655: return ((jjbitVec23[i2] & l2) != 0L);
1656: case 24:
1657: return ((jjbitVec24[i2] & l2) != 0L);
1658: case 30:
1659: return ((jjbitVec25[i2] & l2) != 0L);
1660: case 31:
1661: return ((jjbitVec26[i2] & l2) != 0L);
1662: case 32:
1663: return ((jjbitVec27[i2] & l2) != 0L);
1664: case 33:
1665: return ((jjbitVec28[i2] & l2) != 0L);
1666: case 48:
1667: return ((jjbitVec29[i2] & l2) != 0L);
1668: case 49:
1669: return ((jjbitVec30[i2] & l2) != 0L);
1670: case 77:
1671: return ((jjbitVec31[i2] & l2) != 0L);
1672: case 159:
1673: return ((jjbitVec32[i2] & l2) != 0L);
1674: case 164:
1675: return ((jjbitVec33[i2] & l2) != 0L);
1676: case 215:
1677: return ((jjbitVec34[i2] & l2) != 0L);
1678: case 250:
1679: return ((jjbitVec35[i2] & l2) != 0L);
1680: case 251:
1681: return ((jjbitVec36[i2] & l2) != 0L);
1682: case 253:
1683: return ((jjbitVec37[i2] & l2) != 0L);
1684: case 254:
1685: return ((jjbitVec38[i2] & l2) != 0L);
1686: case 255:
1687: return ((jjbitVec39[i2] & l2) != 0L);
1688: default:
1689: if ((jjbitVec3[i1] & l1) != 0L)
1690: return true;
1691: return false;
1692: }
1693: }
1694:
1695: private static final boolean jjCanMove_2(int hiByte, int i1,
1696: int i2, long l1, long l2) {
1697: switch (hiByte) {
1698: case 0:
1699: return ((jjbitVec40[i2] & l2) != 0L);
1700: case 2:
1701: return ((jjbitVec5[i2] & l2) != 0L);
1702: case 3:
1703: return ((jjbitVec41[i2] & l2) != 0L);
1704: case 4:
1705: return ((jjbitVec42[i2] & l2) != 0L);
1706: case 5:
1707: return ((jjbitVec43[i2] & l2) != 0L);
1708: case 6:
1709: return ((jjbitVec44[i2] & l2) != 0L);
1710: case 7:
1711: return ((jjbitVec45[i2] & l2) != 0L);
1712: case 9:
1713: return ((jjbitVec46[i2] & l2) != 0L);
1714: case 10:
1715: return ((jjbitVec47[i2] & l2) != 0L);
1716: case 11:
1717: return ((jjbitVec48[i2] & l2) != 0L);
1718: case 12:
1719: return ((jjbitVec49[i2] & l2) != 0L);
1720: case 13:
1721: return ((jjbitVec50[i2] & l2) != 0L);
1722: case 14:
1723: return ((jjbitVec51[i2] & l2) != 0L);
1724: case 15:
1725: return ((jjbitVec52[i2] & l2) != 0L);
1726: case 16:
1727: return ((jjbitVec53[i2] & l2) != 0L);
1728: case 17:
1729: return ((jjbitVec19[i2] & l2) != 0L);
1730: case 18:
1731: return ((jjbitVec20[i2] & l2) != 0L);
1732: case 19:
1733: return ((jjbitVec54[i2] & l2) != 0L);
1734: case 20:
1735: return ((jjbitVec0[i2] & l2) != 0L);
1736: case 22:
1737: return ((jjbitVec22[i2] & l2) != 0L);
1738: case 23:
1739: return ((jjbitVec55[i2] & l2) != 0L);
1740: case 24:
1741: return ((jjbitVec56[i2] & l2) != 0L);
1742: case 30:
1743: return ((jjbitVec25[i2] & l2) != 0L);
1744: case 31:
1745: return ((jjbitVec26[i2] & l2) != 0L);
1746: case 32:
1747: return ((jjbitVec57[i2] & l2) != 0L);
1748: case 33:
1749: return ((jjbitVec28[i2] & l2) != 0L);
1750: case 48:
1751: return ((jjbitVec58[i2] & l2) != 0L);
1752: case 49:
1753: return ((jjbitVec30[i2] & l2) != 0L);
1754: case 77:
1755: return ((jjbitVec31[i2] & l2) != 0L);
1756: case 159:
1757: return ((jjbitVec32[i2] & l2) != 0L);
1758: case 164:
1759: return ((jjbitVec33[i2] & l2) != 0L);
1760: case 215:
1761: return ((jjbitVec34[i2] & l2) != 0L);
1762: case 250:
1763: return ((jjbitVec35[i2] & l2) != 0L);
1764: case 251:
1765: return ((jjbitVec59[i2] & l2) != 0L);
1766: case 253:
1767: return ((jjbitVec37[i2] & l2) != 0L);
1768: case 254:
1769: return ((jjbitVec60[i2] & l2) != 0L);
1770: case 255:
1771: return ((jjbitVec61[i2] & l2) != 0L);
1772: default:
1773: if ((jjbitVec3[i1] & l1) != 0L)
1774: return true;
1775: return false;
1776: }
1777: }
1778:
1779: /** Token literal values. */
1780: public static final String[] jjstrLiteralImages = { "", null, null,
1781: null, null, null, null, null, null, null, null, null,
1782: "\141\142\163\164\162\141\143\164",
1783: "\142\157\157\154\145\141\156", "\142\162\145\141\153",
1784: "\142\171\164\145", "\143\141\163\145",
1785: "\143\141\164\143\150", "\143\150\141\162",
1786: "\143\154\141\163\163", "\143\157\156\163\164",
1787: "\143\157\156\164\151\156\165\145",
1788: "\144\145\146\141\165\154\164", "\144\157",
1789: "\144\157\165\142\154\145", "\145\154\163\145",
1790: "\145\170\164\145\156\144\163", "\146\141\154\163\145",
1791: "\146\151\156\141\154", "\146\151\156\141\154\154\171",
1792: "\146\154\157\141\164", "\146\157\162", "\147\157\164\157",
1793: "\151\146", "\151\155\160\154\145\155\145\156\164\163",
1794: "\151\155\160\157\162\164",
1795: "\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
1796: "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
1797: "\156\141\164\151\166\145", "\156\145\167",
1798: "\156\165\154\154", "\160\141\143\153\141\147\145",
1799: "\160\162\151\166\141\164\145",
1800: "\160\162\157\164\145\143\164\145\144",
1801: "\160\165\142\154\151\143", "\162\145\164\165\162\156",
1802: "\163\150\157\162\164", "\163\164\141\164\151\143",
1803: "\163\165\160\145\162", "\163\167\151\164\143\150",
1804: "\163\171\156\143\150\162\157\156\151\172\145\144",
1805: "\164\150\151\163", "\164\150\162\157\167",
1806: "\164\150\162\157\167\163",
1807: "\164\162\141\156\163\151\145\156\164", "\164\162\165\145",
1808: "\164\162\171", "\166\157\151\144",
1809: "\166\157\154\141\164\151\154\145", "\167\150\151\154\145",
1810: "\163\164\162\151\143\164\146\160", null, null, null, null,
1811: null, null, null, null, null, null, null, null, "\50",
1812: "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56",
1813: "\100", "\75", "\74", "\41", "\176", "\77", "\72",
1814: "\75\75", "\74\75", "\76\75", "\41\75", "\174\174",
1815: "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57",
1816: "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75",
1817: "\52\75", "\57\75", "\46\75", "\174\75", "\136\75",
1818: "\45\75", "\74\74\75", "\76\76\75", "\76\76\76\75",
1819: "\56\56\56", "\76\76\76", "\76\76", "\76", "\32",
1820: "\176\133\135", };
1821:
1822: /** Lexer state names. */
1823: public static final String[] lexStateNames = { "DEFAULT",
1824: "IN_FORMAL_COMMENT", "IN_MULTI_LINE_COMMENT", };
1825:
1826: /** Lex State array. */
1827: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
1828: -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1829: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1830: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1831: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1832: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1833: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1834: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1835: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, };
1836: static final long[] jjtoToken = { 0xfffffffffffff001L,
1837: 0x1ffffffffffff9d8L, };
1838: static final long[] jjtoSkip = { 0x67eL, 0x0L, };
1839: static final long[] jjtoSpecial = { 0x67eL, 0x0L, };
1840: static final long[] jjtoMore = { 0x980L, 0x0L, };
1841: protected CharStream input_stream;
1842: private final int[] jjrounds = new int[68];
1843: private final int[] jjstateSet = new int[136];
1844: private StringBuilder image = new StringBuilder();
1845: private int jjimageLen;
1846: private int lengthOfMatch;
1847: protected char curChar;
1848:
1849: /** Constructor. */
1850: public JavaParserTokenManager(CharStream stream) {
1851: input_stream = stream;
1852: }
1853:
1854: /** Constructor. */
1855: public JavaParserTokenManager(CharStream stream, int lexState) {
1856: this (stream);
1857: SwitchTo(lexState);
1858: }
1859:
1860: /** Reinitialise parser. */
1861: public void ReInit(CharStream stream) {
1862: jjmatchedPos = jjnewStateCnt = 0;
1863: curLexState = defaultLexState;
1864: input_stream = stream;
1865: ReInitRounds();
1866: }
1867:
1868: private void ReInitRounds() {
1869: int i;
1870: jjround = 0x80000001;
1871: for (i = 68; i-- > 0;)
1872: jjrounds[i] = 0x80000000;
1873: }
1874:
1875: /** Reinitialise parser. */
1876: public void ReInit(CharStream stream, int lexState) {
1877: ReInit(stream);
1878: SwitchTo(lexState);
1879: }
1880:
1881: /** Switch to specified lex state. */
1882: public void SwitchTo(int lexState) {
1883: if (lexState >= 3 || lexState < 0)
1884: throw new TokenMgrError(
1885: "Error: Ignoring invalid lexical state : "
1886: + lexState + ". State unchanged.",
1887: TokenMgrError.INVALID_LEXICAL_STATE);
1888: else
1889: curLexState = lexState;
1890: }
1891:
1892: protected Token jjFillToken() {
1893: final Token t;
1894: final String tokenImage;
1895: final int beginLine;
1896: final int endLine;
1897: final int beginColumn;
1898: final int endColumn;
1899: String im = jjstrLiteralImages[jjmatchedKind];
1900: tokenImage = (im == null) ? input_stream.GetImage() : im;
1901: beginLine = input_stream.getBeginLine();
1902: beginColumn = input_stream.getBeginColumn();
1903: endLine = input_stream.getEndLine();
1904: endColumn = input_stream.getEndColumn();
1905: t = Token.newToken(jjmatchedKind);
1906: t.kind = jjmatchedKind;
1907: t.image = tokenImage;
1908:
1909: t.beginLine = beginLine;
1910: t.endLine = endLine;
1911: t.beginColumn = beginColumn;
1912: t.endColumn = endColumn;
1913:
1914: return t;
1915: }
1916:
1917: int curLexState = 0;
1918: int defaultLexState = 0;
1919: int jjnewStateCnt;
1920: int jjround;
1921: int jjmatchedPos;
1922: int jjmatchedKind;
1923:
1924: /** Get the next Token. */
1925: public Token getNextToken() {
1926: Token specialToken = null;
1927: Token matchedToken;
1928: int curPos = 0;
1929:
1930: EOFLoop: for (;;) {
1931: try {
1932: curChar = input_stream.BeginToken();
1933: } catch (java.io.IOException e) {
1934: jjmatchedKind = 0;
1935: matchedToken = jjFillToken();
1936: matchedToken.specialToken = specialToken;
1937: return matchedToken;
1938: }
1939: image.setLength(0);
1940: jjimageLen = 0;
1941:
1942: for (;;) {
1943: switch (curLexState) {
1944: case 0:
1945: jjmatchedKind = 0x7fffffff;
1946: jjmatchedPos = 0;
1947: curPos = jjMoveStringLiteralDfa0_0();
1948: break;
1949: case 1:
1950: jjmatchedKind = 0x7fffffff;
1951: jjmatchedPos = 0;
1952: curPos = jjMoveStringLiteralDfa0_1();
1953: if (jjmatchedPos == 0 && jjmatchedKind > 11) {
1954: jjmatchedKind = 11;
1955: }
1956: break;
1957: case 2:
1958: jjmatchedKind = 0x7fffffff;
1959: jjmatchedPos = 0;
1960: curPos = jjMoveStringLiteralDfa0_2();
1961: if (jjmatchedPos == 0 && jjmatchedKind > 11) {
1962: jjmatchedKind = 11;
1963: }
1964: break;
1965: }
1966: if (jjmatchedKind != 0x7fffffff) {
1967: if (jjmatchedPos + 1 < curPos)
1968: input_stream.backup(curPos - jjmatchedPos - 1);
1969: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1970: matchedToken = jjFillToken();
1971: matchedToken.specialToken = specialToken;
1972: TokenLexicalActions(matchedToken);
1973: if (jjnewLexState[jjmatchedKind] != -1)
1974: curLexState = jjnewLexState[jjmatchedKind];
1975: return matchedToken;
1976: } else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1977: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1978: matchedToken = jjFillToken();
1979: if (specialToken == null)
1980: specialToken = matchedToken;
1981: else {
1982: matchedToken.specialToken = specialToken;
1983: specialToken = (specialToken.next = matchedToken);
1984: }
1985: SkipLexicalActions(matchedToken);
1986: } else
1987: SkipLexicalActions(null);
1988: if (jjnewLexState[jjmatchedKind] != -1)
1989: curLexState = jjnewLexState[jjmatchedKind];
1990: continue EOFLoop;
1991: }
1992: MoreLexicalActions();
1993: if (jjnewLexState[jjmatchedKind] != -1)
1994: curLexState = jjnewLexState[jjmatchedKind];
1995: curPos = 0;
1996: jjmatchedKind = 0x7fffffff;
1997: try {
1998: curChar = input_stream.readChar();
1999: continue;
2000: } catch (java.io.IOException e1) {
2001: }
2002: }
2003: int error_line = input_stream.getEndLine();
2004: int error_column = input_stream.getEndColumn();
2005: String error_after = null;
2006: boolean EOFSeen = false;
2007: try {
2008: input_stream.readChar();
2009: input_stream.backup(1);
2010: } catch (java.io.IOException e1) {
2011: EOFSeen = true;
2012: error_after = curPos <= 1 ? "" : input_stream
2013: .GetImage();
2014: if (curChar == '\n' || curChar == '\r') {
2015: error_line++;
2016: error_column = 0;
2017: } else
2018: error_column++;
2019: }
2020: if (!EOFSeen) {
2021: input_stream.backup(1);
2022: error_after = curPos <= 1 ? "" : input_stream
2023: .GetImage();
2024: }
2025: throw new TokenMgrError(EOFSeen, curLexState,
2026: error_line, error_column, error_after, curChar,
2027: TokenMgrError.LEXICAL_ERROR);
2028: }
2029: }
2030: }
2031:
2032: void SkipLexicalActions(Token matchedToken) {
2033: switch (jjmatchedKind) {
2034: case 6:
2035: image.append(input_stream.GetSuffix(jjimageLen
2036: + (lengthOfMatch = jjmatchedPos + 1)));
2037: int startOfNOPMD = matchedToken.image
2038: .indexOf(excludeMarker);
2039: if (startOfNOPMD != -1) {
2040: excludeMap.put(matchedToken.beginLine,
2041: matchedToken.image.substring(startOfNOPMD
2042: + excludeMarker.length()));
2043: }
2044: break;
2045: default:
2046: break;
2047: }
2048: }
2049:
2050: void MoreLexicalActions() {
2051: jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2052: switch (jjmatchedKind) {
2053: case 7:
2054: image.append(input_stream.GetSuffix(jjimageLen));
2055: jjimageLen = 0;
2056: input_stream.backup(1);
2057: break;
2058: default:
2059: break;
2060: }
2061: }
2062:
2063: void TokenLexicalActions(Token matchedToken) {
2064: switch (jjmatchedKind) {
2065: case 120:
2066: image.append(jjstrLiteralImages[120]);
2067: lengthOfMatch = jjstrLiteralImages[120].length();
2068: matchedToken.kind = GT;
2069: ((Token.GTToken) matchedToken).realKind = RUNSIGNEDSHIFT;
2070: input_stream.backup(2);
2071: matchedToken.image = ">";
2072: break;
2073: case 121:
2074: image.append(jjstrLiteralImages[121]);
2075: lengthOfMatch = jjstrLiteralImages[121].length();
2076: matchedToken.kind = GT;
2077: ((Token.GTToken) matchedToken).realKind = RSIGNEDSHIFT;
2078: input_stream.backup(1);
2079: matchedToken.image = ">";
2080: break;
2081: default:
2082: break;
2083: }
2084: }
2085:
2086: private void jjCheckNAdd(int state) {
2087: if (jjrounds[state] != jjround) {
2088: jjstateSet[jjnewStateCnt++] = state;
2089: jjrounds[state] = jjround;
2090: }
2091: }
2092:
2093: private void jjAddStates(int start, int end) {
2094: do {
2095: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
2096: } while (start++ != end);
2097: }
2098:
2099: private void jjCheckNAddTwoStates(int state1, int state2) {
2100: jjCheckNAdd(state1);
2101: jjCheckNAdd(state2);
2102: }
2103:
2104: private void jjCheckNAddStates(int start, int end) {
2105: do {
2106: jjCheckNAdd(jjnextStates[start]);
2107: } while (start++ != end);
2108: }
2109:
2110: }
|