0001: /* Generated By:JavaCC: Do not edit this line. TurtleParserTokenManager.java */
0002: /*
0003: * (c) Copyright 2006 Hewlett-Packard Development Company, LP
0004: * All rights reserved.
0005: */
0006:
0007: package com.hp.hpl.jena.n3.turtle.parser;
0008:
0009: public class TurtleParserTokenManager implements TurtleParserConstants {
0010: public java.io.PrintStream debugStream = System.out;
0011:
0012: public void setDebugStream(java.io.PrintStream ds) {
0013: debugStream = ds;
0014: }
0015:
0016: private final int jjStopAtPos(int pos, int kind) {
0017: jjmatchedKind = kind;
0018: jjmatchedPos = pos;
0019: return pos + 1;
0020: }
0021:
0022: private final int jjMoveStringLiteralDfa0_0() {
0023: switch (curChar) {
0024: case 9:
0025: jjmatchedKind = 7;
0026: return jjMoveNfa_0(0, 0);
0027: case 10:
0028: jjmatchedKind = 8;
0029: return jjMoveNfa_0(0, 0);
0030: case 12:
0031: jjmatchedKind = 10;
0032: return jjMoveNfa_0(0, 0);
0033: case 13:
0034: jjmatchedKind = 9;
0035: return jjMoveNfa_0(0, 0);
0036: case 32:
0037: jjmatchedKind = 6;
0038: return jjMoveNfa_0(0, 0);
0039: case 33:
0040: jjmatchedKind = 1;
0041: return jjMoveNfa_0(0, 0);
0042: case 36:
0043: jjmatchedKind = 50;
0044: return jjMoveNfa_0(0, 0);
0045: case 40:
0046: jjmatchedKind = 37;
0047: return jjMoveNfa_0(0, 0);
0048: case 41:
0049: jjmatchedKind = 38;
0050: return jjMoveNfa_0(0, 0);
0051: case 42:
0052: jjmatchedKind = 54;
0053: return jjMoveNfa_0(0, 0);
0054: case 44:
0055: jjmatchedKind = 46;
0056: return jjMoveNfa_0(0, 0);
0057: case 45:
0058: return jjMoveStringLiteralDfa1_0(0x10L);
0059: case 46:
0060: jjmatchedKind = 47;
0061: return jjMoveNfa_0(0, 0);
0062: case 47:
0063: jjmatchedKind = 55;
0064: return jjMoveNfa_0(0, 0);
0065: case 58:
0066: jjmatchedKind = 53;
0067: return jjMoveNfa_0(0, 0);
0068: case 59:
0069: jjmatchedKind = 45;
0070: return jjMoveNfa_0(0, 0);
0071: case 60:
0072: return jjMoveStringLiteralDfa1_0(0x20L);
0073: case 61:
0074: jjmatchedKind = 48;
0075: return jjMoveStringLiteralDfa1_0(0x2000000000000L);
0076: case 63:
0077: jjmatchedKind = 51;
0078: return jjMoveNfa_0(0, 0);
0079: case 64:
0080: jjmatchedKind = 58;
0081: return jjMoveStringLiteralDfa1_0(0xc000L);
0082: case 91:
0083: jjmatchedKind = 42;
0084: return jjMoveNfa_0(0, 0);
0085: case 92:
0086: jjmatchedKind = 56;
0087: return jjMoveNfa_0(0, 0);
0088: case 93:
0089: jjmatchedKind = 43;
0090: return jjMoveNfa_0(0, 0);
0091: case 94:
0092: jjmatchedKind = 3;
0093: return jjMoveStringLiteralDfa1_0(0x200000000000000L);
0094: case 97:
0095: jjmatchedKind = 13;
0096: return jjMoveNfa_0(0, 0);
0097: case 123:
0098: jjmatchedKind = 40;
0099: return jjMoveNfa_0(0, 0);
0100: case 124:
0101: jjmatchedKind = 2;
0102: return jjMoveNfa_0(0, 0);
0103: case 125:
0104: jjmatchedKind = 41;
0105: return jjMoveNfa_0(0, 0);
0106: case 126:
0107: jjmatchedKind = 52;
0108: return jjMoveNfa_0(0, 0);
0109: default:
0110: return jjMoveNfa_0(0, 0);
0111: }
0112: }
0113:
0114: private final int jjMoveStringLiteralDfa1_0(long active0) {
0115: try {
0116: curChar = input_stream.readChar();
0117: } catch (java.io.IOException e) {
0118: return jjMoveNfa_0(0, 0);
0119: }
0120: switch (curChar) {
0121: case 45:
0122: if ((active0 & 0x20L) != 0L) {
0123: jjmatchedKind = 5;
0124: jjmatchedPos = 1;
0125: }
0126: break;
0127: case 62:
0128: if ((active0 & 0x10L) != 0L) {
0129: jjmatchedKind = 4;
0130: jjmatchedPos = 1;
0131: } else if ((active0 & 0x2000000000000L) != 0L) {
0132: jjmatchedKind = 49;
0133: jjmatchedPos = 1;
0134: }
0135: break;
0136: case 66:
0137: return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
0138: case 80:
0139: return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
0140: case 94:
0141: if ((active0 & 0x200000000000000L) != 0L) {
0142: jjmatchedKind = 57;
0143: jjmatchedPos = 1;
0144: }
0145: break;
0146: case 98:
0147: return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
0148: case 112:
0149: return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
0150: default:
0151: break;
0152: }
0153: return jjMoveNfa_0(0, 1);
0154: }
0155:
0156: private final int jjMoveStringLiteralDfa2_0(long old0, long active0) {
0157: if (((active0 &= old0)) == 0L)
0158: return jjMoveNfa_0(0, 1);
0159: try {
0160: curChar = input_stream.readChar();
0161: } catch (java.io.IOException e) {
0162: return jjMoveNfa_0(0, 1);
0163: }
0164: switch (curChar) {
0165: case 65:
0166: return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
0167: case 82:
0168: return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
0169: case 97:
0170: return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
0171: case 114:
0172: return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
0173: default:
0174: break;
0175: }
0176: return jjMoveNfa_0(0, 2);
0177: }
0178:
0179: private final int jjMoveStringLiteralDfa3_0(long old0, long active0) {
0180: if (((active0 &= old0)) == 0L)
0181: return jjMoveNfa_0(0, 2);
0182: try {
0183: curChar = input_stream.readChar();
0184: } catch (java.io.IOException e) {
0185: return jjMoveNfa_0(0, 2);
0186: }
0187: switch (curChar) {
0188: case 69:
0189: return jjMoveStringLiteralDfa4_0(active0, 0x4000L);
0190: case 83:
0191: return jjMoveStringLiteralDfa4_0(active0, 0x8000L);
0192: case 101:
0193: return jjMoveStringLiteralDfa4_0(active0, 0x4000L);
0194: case 115:
0195: return jjMoveStringLiteralDfa4_0(active0, 0x8000L);
0196: default:
0197: break;
0198: }
0199: return jjMoveNfa_0(0, 3);
0200: }
0201:
0202: private final int jjMoveStringLiteralDfa4_0(long old0, long active0) {
0203: if (((active0 &= old0)) == 0L)
0204: return jjMoveNfa_0(0, 3);
0205: try {
0206: curChar = input_stream.readChar();
0207: } catch (java.io.IOException e) {
0208: return jjMoveNfa_0(0, 3);
0209: }
0210: switch (curChar) {
0211: case 69:
0212: if ((active0 & 0x8000L) != 0L) {
0213: jjmatchedKind = 15;
0214: jjmatchedPos = 4;
0215: }
0216: break;
0217: case 70:
0218: return jjMoveStringLiteralDfa5_0(active0, 0x4000L);
0219: case 101:
0220: if ((active0 & 0x8000L) != 0L) {
0221: jjmatchedKind = 15;
0222: jjmatchedPos = 4;
0223: }
0224: break;
0225: case 102:
0226: return jjMoveStringLiteralDfa5_0(active0, 0x4000L);
0227: default:
0228: break;
0229: }
0230: return jjMoveNfa_0(0, 4);
0231: }
0232:
0233: private final int jjMoveStringLiteralDfa5_0(long old0, long active0) {
0234: if (((active0 &= old0)) == 0L)
0235: return jjMoveNfa_0(0, 4);
0236: try {
0237: curChar = input_stream.readChar();
0238: } catch (java.io.IOException e) {
0239: return jjMoveNfa_0(0, 4);
0240: }
0241: switch (curChar) {
0242: case 73:
0243: return jjMoveStringLiteralDfa6_0(active0, 0x4000L);
0244: case 105:
0245: return jjMoveStringLiteralDfa6_0(active0, 0x4000L);
0246: default:
0247: break;
0248: }
0249: return jjMoveNfa_0(0, 5);
0250: }
0251:
0252: private final int jjMoveStringLiteralDfa6_0(long old0, long active0) {
0253: if (((active0 &= old0)) == 0L)
0254: return jjMoveNfa_0(0, 5);
0255: try {
0256: curChar = input_stream.readChar();
0257: } catch (java.io.IOException e) {
0258: return jjMoveNfa_0(0, 5);
0259: }
0260: switch (curChar) {
0261: case 88:
0262: if ((active0 & 0x4000L) != 0L) {
0263: jjmatchedKind = 14;
0264: jjmatchedPos = 6;
0265: }
0266: break;
0267: case 120:
0268: if ((active0 & 0x4000L) != 0L) {
0269: jjmatchedKind = 14;
0270: jjmatchedPos = 6;
0271: }
0272: break;
0273: default:
0274: break;
0275: }
0276: return jjMoveNfa_0(0, 6);
0277: }
0278:
0279: private final void jjCheckNAdd(int state) {
0280: if (jjrounds[state] != jjround) {
0281: jjstateSet[jjnewStateCnt++] = state;
0282: jjrounds[state] = jjround;
0283: }
0284: }
0285:
0286: private final void jjAddStates(int start, int end) {
0287: do {
0288: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0289: } while (start++ != end);
0290: }
0291:
0292: private final void jjCheckNAddTwoStates(int state1, int state2) {
0293: jjCheckNAdd(state1);
0294: jjCheckNAdd(state2);
0295: }
0296:
0297: private final void jjCheckNAddStates(int start, int end) {
0298: do {
0299: jjCheckNAdd(jjnextStates[start]);
0300: } while (start++ != end);
0301: }
0302:
0303: private final void jjCheckNAddStates(int start) {
0304: jjCheckNAdd(jjnextStates[start]);
0305: jjCheckNAdd(jjnextStates[start + 1]);
0306: }
0307:
0308: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0309: 0xffffffffffffffffL, 0xffffffffffffffffL,
0310: 0xffffffffffffffffL };
0311: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0312: 0xffffffffffffffffL };
0313: static final long[] jjbitVec3 = { 0xfffe7000fffffff6L,
0314: 0xffffffffffffffffL, 0xffffffffffffffffL,
0315: 0x7e00000000ffffffL };
0316: static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L,
0317: 0xff7fffffff7fffffL };
0318: static final long[] jjbitVec5 = { 0x0L, 0xbfff000000000000L,
0319: 0xffffffffffffffffL, 0xffffffffffffffffL };
0320: static final long[] jjbitVec6 = { 0x3000L, 0xffff000000000000L,
0321: 0xffffffffffffffffL, 0xffffffffffffffffL };
0322: static final long[] jjbitVec7 = { 0xffffffffffffffffL,
0323: 0xffffffffffffffffL, 0xffffL, 0x0L };
0324: static final long[] jjbitVec8 = { 0xffffffffffffffffL,
0325: 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffL };
0326: static final long[] jjbitVec9 = { 0xffffffffffffffffL,
0327: 0xffffffffffffffffL, 0xffffffffffffffffL,
0328: 0x3fffffffffffffffL };
0329: static final long[] jjbitVec10 = { 0x0L, 0x0L, 0x80000000000000L,
0330: 0xff7fffffff7fffffL };
0331: static final long[] jjbitVec11 = { 0xffffffffffffffffL,
0332: 0xbfffffffffffffffL, 0xffffffffffffffffL,
0333: 0xffffffffffffffffL };
0334: static final long[] jjbitVec12 = { 0x8000000000003000L,
0335: 0xffff000000000001L, 0xffffffffffffffffL,
0336: 0xffffffffffffffffL };
0337:
0338: private final int jjMoveNfa_0(int startState, int curPos) {
0339: int strKind = jjmatchedKind;
0340: int strPos = jjmatchedPos;
0341: int seenUpto;
0342: input_stream.backup(seenUpto = curPos + 1);
0343: try {
0344: curChar = input_stream.readChar();
0345: } catch (java.io.IOException e) {
0346: throw new Error("Internal Error");
0347: }
0348: curPos = 0;
0349: int[] nextStates;
0350: int startsAt = 0;
0351: jjnewStateCnt = 110;
0352: int i = 1;
0353: jjstateSet[0] = startState;
0354: int j, kind = 0x7fffffff;
0355: for (;;) {
0356: if (++jjround == 0x7fffffff)
0357: ReInitRounds();
0358: if (curChar < 64) {
0359: long l = 1L << curChar;
0360: do {
0361: switch (jjstateSet[--i]) {
0362: case 0:
0363: if ((0x3ff000000000000L & l) != 0L) {
0364: if (kind > 16)
0365: kind = 16;
0366: jjCheckNAddStates(0, 7);
0367: } else if ((0x280000000000L & l) != 0L)
0368: jjCheckNAddStates(8, 12);
0369: else if (curChar == 58) {
0370: if (kind > 30)
0371: kind = 30;
0372: jjCheckNAdd(106);
0373: } else if (curChar == 46)
0374: jjCheckNAddTwoStates(79, 81);
0375: else if (curChar == 40)
0376: jjCheckNAddStates(13, 15);
0377: else if (curChar == 60)
0378: jjCheckNAddTwoStates(43, 44);
0379: else if (curChar == 34)
0380: jjstateSet[jjnewStateCnt++] = 39;
0381: else if (curChar == 39)
0382: jjstateSet[jjnewStateCnt++] = 27;
0383: else if (curChar == 35) {
0384: if (kind > 12)
0385: kind = 12;
0386: jjCheckNAddStates(16, 18);
0387: } else if (curChar == 63)
0388: jjstateSet[jjnewStateCnt++] = 51;
0389: if ((0x3ff000000000000L & l) != 0L) {
0390: if (kind > 28)
0391: kind = 28;
0392: } else if (curChar == 34)
0393: jjCheckNAddStates(19, 21);
0394: else if (curChar == 39)
0395: jjCheckNAddStates(22, 24);
0396: break;
0397: case 1:
0398: if ((0xffffffffffffdbffL & l) == 0L)
0399: break;
0400: if (kind > 12)
0401: kind = 12;
0402: jjCheckNAddStates(16, 18);
0403: break;
0404: case 2:
0405: if ((0x2400L & l) != 0L && kind > 12)
0406: kind = 12;
0407: break;
0408: case 3:
0409: if (curChar == 10 && kind > 12)
0410: kind = 12;
0411: break;
0412: case 4:
0413: if (curChar == 13)
0414: jjstateSet[jjnewStateCnt++] = 3;
0415: break;
0416: case 6:
0417: if ((0x8400000000L & l) != 0L && kind > 22)
0418: kind = 22;
0419: break;
0420: case 7:
0421: if (curChar == 39)
0422: jjCheckNAddStates(22, 24);
0423: break;
0424: case 8:
0425: if ((0xffffff7fffffdbffL & l) != 0L)
0426: jjCheckNAddStates(22, 24);
0427: break;
0428: case 10:
0429: if ((0x8400000000L & l) != 0L)
0430: jjCheckNAddStates(22, 24);
0431: break;
0432: case 11:
0433: if (curChar == 39 && kind > 23)
0434: kind = 23;
0435: break;
0436: case 12:
0437: if (curChar == 34)
0438: jjCheckNAddStates(19, 21);
0439: break;
0440: case 13:
0441: if ((0xfffffffbffffdbffL & l) != 0L)
0442: jjCheckNAddStates(19, 21);
0443: break;
0444: case 15:
0445: if ((0x8400000000L & l) != 0L)
0446: jjCheckNAddStates(19, 21);
0447: break;
0448: case 16:
0449: if (curChar == 34 && kind > 24)
0450: kind = 24;
0451: break;
0452: case 17:
0453: if (curChar == 39)
0454: jjCheckNAddStates(25, 28);
0455: break;
0456: case 18:
0457: case 22:
0458: if ((0xffffff7fffffffffL & l) != 0L)
0459: jjCheckNAddStates(25, 28);
0460: break;
0461: case 20:
0462: if ((0x8400000000L & l) != 0L)
0463: jjCheckNAddStates(25, 28);
0464: break;
0465: case 21:
0466: case 24:
0467: if (curChar == 39)
0468: jjCheckNAdd(22);
0469: break;
0470: case 23:
0471: if (curChar == 39)
0472: jjAddStates(29, 30);
0473: break;
0474: case 25:
0475: if (curChar == 39 && kind > 25)
0476: kind = 25;
0477: break;
0478: case 26:
0479: if (curChar == 39)
0480: jjstateSet[jjnewStateCnt++] = 25;
0481: break;
0482: case 27:
0483: if (curChar == 39)
0484: jjstateSet[jjnewStateCnt++] = 17;
0485: break;
0486: case 28:
0487: if (curChar == 39)
0488: jjstateSet[jjnewStateCnt++] = 27;
0489: break;
0490: case 29:
0491: if (curChar == 34)
0492: jjCheckNAddStates(31, 34);
0493: break;
0494: case 30:
0495: case 34:
0496: if ((0xfffffffbffffffffL & l) != 0L)
0497: jjCheckNAddStates(31, 34);
0498: break;
0499: case 32:
0500: if ((0x8400000000L & l) != 0L)
0501: jjCheckNAddStates(31, 34);
0502: break;
0503: case 33:
0504: case 36:
0505: if (curChar == 34)
0506: jjCheckNAdd(34);
0507: break;
0508: case 35:
0509: if (curChar == 34)
0510: jjAddStates(35, 36);
0511: break;
0512: case 37:
0513: if (curChar == 34 && kind > 26)
0514: kind = 26;
0515: break;
0516: case 38:
0517: if (curChar == 34)
0518: jjstateSet[jjnewStateCnt++] = 37;
0519: break;
0520: case 39:
0521: if (curChar == 34)
0522: jjstateSet[jjnewStateCnt++] = 29;
0523: break;
0524: case 40:
0525: if (curChar == 34)
0526: jjstateSet[jjnewStateCnt++] = 39;
0527: break;
0528: case 41:
0529: if ((0x3ff000000000000L & l) != 0L && kind > 28)
0530: kind = 28;
0531: break;
0532: case 42:
0533: if (curChar == 60)
0534: jjCheckNAddTwoStates(43, 44);
0535: break;
0536: case 43:
0537: if ((0xaffffffa00000000L & l) != 0L)
0538: jjCheckNAddTwoStates(43, 44);
0539: break;
0540: case 44:
0541: if (curChar == 62 && kind > 29)
0542: kind = 29;
0543: break;
0544: case 45:
0545: if (curChar == 58)
0546: jjstateSet[jjnewStateCnt++] = 46;
0547: break;
0548: case 46:
0549: if ((0x3ff000000000000L & l) == 0L)
0550: break;
0551: if (kind > 32)
0552: kind = 32;
0553: jjCheckNAddTwoStates(47, 48);
0554: break;
0555: case 47:
0556: if ((0x3ff600000000000L & l) != 0L)
0557: jjCheckNAddTwoStates(47, 48);
0558: break;
0559: case 48:
0560: if ((0x3ff200000000000L & l) != 0L && kind > 32)
0561: kind = 32;
0562: break;
0563: case 50:
0564: if (curChar == 63)
0565: jjstateSet[jjnewStateCnt++] = 51;
0566: break;
0567: case 51:
0568: case 52:
0569: if ((0x3ff000000000000L & l) == 0L)
0570: break;
0571: if (kind > 33)
0572: kind = 33;
0573: jjCheckNAdd(52);
0574: break;
0575: case 55:
0576: if (curChar == 45)
0577: jjCheckNAdd(56);
0578: break;
0579: case 56:
0580: if ((0x3ff000000000000L & l) == 0L)
0581: break;
0582: if (kind > 34)
0583: kind = 34;
0584: jjCheckNAddTwoStates(55, 56);
0585: break;
0586: case 57:
0587: if (curChar == 40)
0588: jjCheckNAddStates(13, 15);
0589: break;
0590: case 58:
0591: if (curChar == 35)
0592: jjCheckNAddStates(37, 42);
0593: break;
0594: case 59:
0595: if ((0xffffffffffffdbffL & l) != 0L)
0596: jjCheckNAddStates(37, 42);
0597: break;
0598: case 60:
0599: if ((0x2400L & l) != 0L)
0600: jjCheckNAddStates(13, 15);
0601: break;
0602: case 61:
0603: if ((0x100003600L & l) != 0L)
0604: jjCheckNAddStates(13, 15);
0605: break;
0606: case 62:
0607: if (curChar == 41 && kind > 39)
0608: kind = 39;
0609: break;
0610: case 63:
0611: if (curChar == 10)
0612: jjCheckNAddStates(13, 15);
0613: break;
0614: case 64:
0615: if (curChar == 13)
0616: jjstateSet[jjnewStateCnt++] = 63;
0617: break;
0618: case 66:
0619: if (curChar == 35)
0620: jjCheckNAddStates(43, 48);
0621: break;
0622: case 67:
0623: if ((0xffffffffffffdbffL & l) != 0L)
0624: jjCheckNAddStates(43, 48);
0625: break;
0626: case 68:
0627: if ((0x2400L & l) != 0L)
0628: jjCheckNAddStates(49, 51);
0629: break;
0630: case 69:
0631: if ((0x100003600L & l) != 0L)
0632: jjCheckNAddStates(49, 51);
0633: break;
0634: case 71:
0635: if (curChar == 10)
0636: jjCheckNAddStates(49, 51);
0637: break;
0638: case 72:
0639: if (curChar == 13)
0640: jjstateSet[jjnewStateCnt++] = 71;
0641: break;
0642: case 73:
0643: if ((0x280000000000L & l) != 0L)
0644: jjCheckNAddStates(8, 12);
0645: break;
0646: case 74:
0647: if ((0x3ff000000000000L & l) == 0L)
0648: break;
0649: if (kind > 16)
0650: kind = 16;
0651: jjCheckNAdd(74);
0652: break;
0653: case 75:
0654: if ((0x3ff000000000000L & l) != 0L)
0655: jjCheckNAddTwoStates(75, 76);
0656: break;
0657: case 76:
0658: if (curChar != 46)
0659: break;
0660: if (kind > 17)
0661: kind = 17;
0662: jjCheckNAdd(77);
0663: break;
0664: case 77:
0665: if ((0x3ff000000000000L & l) == 0L)
0666: break;
0667: if (kind > 17)
0668: kind = 17;
0669: jjCheckNAdd(77);
0670: break;
0671: case 78:
0672: if (curChar == 46)
0673: jjCheckNAdd(79);
0674: break;
0675: case 79:
0676: if ((0x3ff000000000000L & l) == 0L)
0677: break;
0678: if (kind > 17)
0679: kind = 17;
0680: jjCheckNAdd(79);
0681: break;
0682: case 80:
0683: if (curChar == 46)
0684: jjCheckNAdd(81);
0685: break;
0686: case 81:
0687: if ((0x3ff000000000000L & l) != 0L)
0688: jjCheckNAddTwoStates(81, 82);
0689: break;
0690: case 83:
0691: if ((0x280000000000L & l) != 0L)
0692: jjCheckNAdd(84);
0693: break;
0694: case 84:
0695: if ((0x3ff000000000000L & l) == 0L)
0696: break;
0697: if (kind > 18)
0698: kind = 18;
0699: jjCheckNAdd(84);
0700: break;
0701: case 85:
0702: if ((0x3ff000000000000L & l) != 0L)
0703: jjCheckNAddStates(52, 55);
0704: break;
0705: case 86:
0706: if ((0x3ff000000000000L & l) != 0L)
0707: jjCheckNAddTwoStates(86, 87);
0708: break;
0709: case 87:
0710: if (curChar == 46)
0711: jjCheckNAddTwoStates(88, 89);
0712: break;
0713: case 88:
0714: if ((0x3ff000000000000L & l) != 0L)
0715: jjCheckNAddTwoStates(88, 89);
0716: break;
0717: case 90:
0718: if ((0x280000000000L & l) != 0L)
0719: jjCheckNAdd(91);
0720: break;
0721: case 91:
0722: if ((0x3ff000000000000L & l) == 0L)
0723: break;
0724: if (kind > 18)
0725: kind = 18;
0726: jjCheckNAdd(91);
0727: break;
0728: case 92:
0729: if ((0x3ff000000000000L & l) != 0L)
0730: jjCheckNAddTwoStates(92, 93);
0731: break;
0732: case 94:
0733: if ((0x280000000000L & l) != 0L)
0734: jjCheckNAdd(95);
0735: break;
0736: case 95:
0737: if ((0x3ff000000000000L & l) == 0L)
0738: break;
0739: if (kind > 18)
0740: kind = 18;
0741: jjCheckNAdd(95);
0742: break;
0743: case 96:
0744: if ((0x3ff000000000000L & l) == 0L)
0745: break;
0746: if (kind > 16)
0747: kind = 16;
0748: jjCheckNAddStates(0, 7);
0749: break;
0750: case 97:
0751: if ((0x3ff000000000000L & l) == 0L)
0752: break;
0753: if (kind > 27)
0754: kind = 27;
0755: jjCheckNAdd(97);
0756: break;
0757: case 98:
0758: if (curChar == 46)
0759: jjCheckNAddTwoStates(79, 81);
0760: break;
0761: case 100:
0762: if ((0x3ff600000000000L & l) != 0L)
0763: jjAddStates(56, 57);
0764: break;
0765: case 101:
0766: if ((0x3ff200000000000L & l) != 0L)
0767: jjstateSet[jjnewStateCnt++] = 102;
0768: break;
0769: case 102:
0770: if (curChar == 58 && kind > 30)
0771: kind = 30;
0772: break;
0773: case 103:
0774: if ((0x3ff600000000000L & l) != 0L)
0775: jjAddStates(58, 59);
0776: break;
0777: case 104:
0778: if ((0x3ff200000000000L & l) != 0L)
0779: jjstateSet[jjnewStateCnt++] = 105;
0780: break;
0781: case 105:
0782: if (curChar == 58)
0783: jjCheckNAdd(106);
0784: break;
0785: case 106:
0786: if ((0x3ff000000000000L & l) == 0L)
0787: break;
0788: if (kind > 31)
0789: kind = 31;
0790: jjCheckNAddTwoStates(107, 108);
0791: break;
0792: case 107:
0793: if ((0x3ff600000000000L & l) != 0L)
0794: jjCheckNAddTwoStates(107, 108);
0795: break;
0796: case 108:
0797: if ((0x3ff200000000000L & l) != 0L && kind > 31)
0798: kind = 31;
0799: break;
0800: case 109:
0801: if (curChar != 58)
0802: break;
0803: if (kind > 30)
0804: kind = 30;
0805: jjCheckNAdd(106);
0806: break;
0807: default:
0808: break;
0809: }
0810: } while (i != startsAt);
0811: } else if (curChar < 128) {
0812: long l = 1L << (curChar & 077);
0813: do {
0814: switch (jjstateSet[--i]) {
0815: case 0:
0816: if ((0x7fffffe07fffffeL & l) != 0L)
0817: jjCheckNAddStates(60, 65);
0818: else if (curChar == 91)
0819: jjCheckNAddStates(49, 51);
0820: else if (curChar == 64)
0821: jjCheckNAdd(54);
0822: else if (curChar == 95)
0823: jjstateSet[jjnewStateCnt++] = 45;
0824: else if (curChar == 92)
0825: jjstateSet[jjnewStateCnt++] = 6;
0826: if ((0x7e0000007eL & l) != 0L) {
0827: if (kind > 28)
0828: kind = 28;
0829: }
0830: break;
0831: case 1:
0832: if (kind > 12)
0833: kind = 12;
0834: jjAddStates(16, 18);
0835: break;
0836: case 5:
0837: if (curChar == 92)
0838: jjstateSet[jjnewStateCnt++] = 6;
0839: break;
0840: case 6:
0841: if ((0x14404410000000L & l) != 0L && kind > 22)
0842: kind = 22;
0843: break;
0844: case 8:
0845: if ((0xffffffffefffffffL & l) != 0L)
0846: jjCheckNAddStates(22, 24);
0847: break;
0848: case 9:
0849: if (curChar == 92)
0850: jjstateSet[jjnewStateCnt++] = 10;
0851: break;
0852: case 10:
0853: if ((0x14404410000000L & l) != 0L)
0854: jjCheckNAddStates(22, 24);
0855: break;
0856: case 13:
0857: if ((0xffffffffefffffffL & l) != 0L)
0858: jjCheckNAddStates(19, 21);
0859: break;
0860: case 14:
0861: if (curChar == 92)
0862: jjstateSet[jjnewStateCnt++] = 15;
0863: break;
0864: case 15:
0865: if ((0x14404410000000L & l) != 0L)
0866: jjCheckNAddStates(19, 21);
0867: break;
0868: case 18:
0869: if ((0xffffffffefffffffL & l) != 0L)
0870: jjCheckNAddStates(25, 28);
0871: break;
0872: case 19:
0873: if (curChar == 92)
0874: jjstateSet[jjnewStateCnt++] = 20;
0875: break;
0876: case 20:
0877: if ((0x14404410000000L & l) != 0L)
0878: jjCheckNAddStates(25, 28);
0879: break;
0880: case 22:
0881: jjCheckNAddStates(25, 28);
0882: break;
0883: case 30:
0884: if ((0xffffffffefffffffL & l) != 0L)
0885: jjCheckNAddStates(31, 34);
0886: break;
0887: case 31:
0888: if (curChar == 92)
0889: jjstateSet[jjnewStateCnt++] = 32;
0890: break;
0891: case 32:
0892: if ((0x14404410000000L & l) != 0L)
0893: jjCheckNAddStates(31, 34);
0894: break;
0895: case 34:
0896: jjCheckNAddStates(31, 34);
0897: break;
0898: case 41:
0899: if ((0x7e0000007eL & l) != 0L && kind > 28)
0900: kind = 28;
0901: break;
0902: case 43:
0903: if ((0xc7fffffeafffffffL & l) != 0L)
0904: jjAddStates(66, 67);
0905: break;
0906: case 46:
0907: if ((0x7fffffe87fffffeL & l) == 0L)
0908: break;
0909: if (kind > 32)
0910: kind = 32;
0911: jjCheckNAddTwoStates(47, 48);
0912: break;
0913: case 47:
0914: if ((0x7fffffe87fffffeL & l) != 0L)
0915: jjCheckNAddTwoStates(47, 48);
0916: break;
0917: case 48:
0918: if ((0x7fffffe87fffffeL & l) != 0L && kind > 32)
0919: kind = 32;
0920: break;
0921: case 49:
0922: if (curChar == 95)
0923: jjstateSet[jjnewStateCnt++] = 45;
0924: break;
0925: case 51:
0926: case 52:
0927: if ((0x7fffffe87fffffeL & l) == 0L)
0928: break;
0929: if (kind > 33)
0930: kind = 33;
0931: jjCheckNAdd(52);
0932: break;
0933: case 53:
0934: if (curChar == 64)
0935: jjCheckNAdd(54);
0936: break;
0937: case 54:
0938: if ((0x7fffffe07fffffeL & l) == 0L)
0939: break;
0940: if (kind > 34)
0941: kind = 34;
0942: jjCheckNAddTwoStates(54, 55);
0943: break;
0944: case 56:
0945: if ((0x7fffffe07fffffeL & l) == 0L)
0946: break;
0947: if (kind > 34)
0948: kind = 34;
0949: jjCheckNAddTwoStates(55, 56);
0950: break;
0951: case 59:
0952: jjAddStates(37, 42);
0953: break;
0954: case 65:
0955: if (curChar == 91)
0956: jjCheckNAddStates(49, 51);
0957: break;
0958: case 67:
0959: jjCheckNAddStates(43, 48);
0960: break;
0961: case 70:
0962: if (curChar == 93 && kind > 44)
0963: kind = 44;
0964: break;
0965: case 82:
0966: if ((0x2000000020L & l) != 0L)
0967: jjAddStates(68, 69);
0968: break;
0969: case 89:
0970: if ((0x2000000020L & l) != 0L)
0971: jjAddStates(70, 71);
0972: break;
0973: case 93:
0974: if ((0x2000000020L & l) != 0L)
0975: jjAddStates(72, 73);
0976: break;
0977: case 99:
0978: if ((0x7fffffe07fffffeL & l) != 0L)
0979: jjCheckNAddStates(60, 65);
0980: break;
0981: case 100:
0982: if ((0x7fffffe87fffffeL & l) != 0L)
0983: jjCheckNAddTwoStates(100, 101);
0984: break;
0985: case 101:
0986: if ((0x7fffffe87fffffeL & l) != 0L)
0987: jjCheckNAdd(102);
0988: break;
0989: case 103:
0990: if ((0x7fffffe87fffffeL & l) != 0L)
0991: jjCheckNAddTwoStates(103, 104);
0992: break;
0993: case 104:
0994: if ((0x7fffffe87fffffeL & l) != 0L)
0995: jjCheckNAdd(105);
0996: break;
0997: case 106:
0998: if ((0x7fffffe87fffffeL & l) == 0L)
0999: break;
1000: if (kind > 31)
1001: kind = 31;
1002: jjCheckNAddTwoStates(107, 108);
1003: break;
1004: case 107:
1005: if ((0x7fffffe87fffffeL & l) != 0L)
1006: jjCheckNAddTwoStates(107, 108);
1007: break;
1008: case 108:
1009: if ((0x7fffffe87fffffeL & l) != 0L && kind > 31)
1010: kind = 31;
1011: break;
1012: default:
1013: break;
1014: }
1015: } while (i != startsAt);
1016: } else {
1017: int hiByte = (int) (curChar >> 8);
1018: int i1 = hiByte >> 6;
1019: long l1 = 1L << (hiByte & 077);
1020: int i2 = (curChar & 0xff) >> 6;
1021: long l2 = 1L << (curChar & 077);
1022: do {
1023: switch (jjstateSet[--i]) {
1024: case 0:
1025: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1026: jjCheckNAddStates(60, 65);
1027: break;
1028: case 1:
1029: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1030: break;
1031: if (kind > 12)
1032: kind = 12;
1033: jjAddStates(16, 18);
1034: break;
1035: case 8:
1036: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1037: jjAddStates(22, 24);
1038: break;
1039: case 13:
1040: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1041: jjAddStates(19, 21);
1042: break;
1043: case 18:
1044: case 22:
1045: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1046: jjCheckNAddStates(25, 28);
1047: break;
1048: case 30:
1049: case 34:
1050: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1051: jjCheckNAddStates(31, 34);
1052: break;
1053: case 43:
1054: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1055: jjAddStates(66, 67);
1056: break;
1057: case 46:
1058: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1059: break;
1060: if (kind > 32)
1061: kind = 32;
1062: jjCheckNAddTwoStates(47, 48);
1063: break;
1064: case 47:
1065: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1066: jjCheckNAddTwoStates(47, 48);
1067: break;
1068: case 48:
1069: if (jjCanMove_2(hiByte, i1, i2, l1, l2)
1070: && kind > 32)
1071: kind = 32;
1072: break;
1073: case 51:
1074: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1075: break;
1076: if (kind > 33)
1077: kind = 33;
1078: jjCheckNAdd(52);
1079: break;
1080: case 52:
1081: if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1082: break;
1083: if (kind > 33)
1084: kind = 33;
1085: jjCheckNAdd(52);
1086: break;
1087: case 59:
1088: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1089: jjAddStates(37, 42);
1090: break;
1091: case 67:
1092: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1093: jjAddStates(43, 48);
1094: break;
1095: case 100:
1096: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1097: jjCheckNAddTwoStates(100, 101);
1098: break;
1099: case 101:
1100: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1101: jjCheckNAdd(102);
1102: break;
1103: case 103:
1104: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1105: jjCheckNAddTwoStates(103, 104);
1106: break;
1107: case 104:
1108: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1109: jjCheckNAdd(105);
1110: break;
1111: case 106:
1112: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1113: break;
1114: if (kind > 31)
1115: kind = 31;
1116: jjCheckNAddTwoStates(107, 108);
1117: break;
1118: case 107:
1119: if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1120: jjCheckNAddTwoStates(107, 108);
1121: break;
1122: case 108:
1123: if (jjCanMove_2(hiByte, i1, i2, l1, l2)
1124: && kind > 31)
1125: kind = 31;
1126: break;
1127: default:
1128: break;
1129: }
1130: } while (i != startsAt);
1131: }
1132: if (kind != 0x7fffffff) {
1133: jjmatchedKind = kind;
1134: jjmatchedPos = curPos;
1135: kind = 0x7fffffff;
1136: }
1137: ++curPos;
1138: if ((i = jjnewStateCnt) == (startsAt = 110 - (jjnewStateCnt = startsAt)))
1139: break;
1140: try {
1141: curChar = input_stream.readChar();
1142: } catch (java.io.IOException e) {
1143: break;
1144: }
1145: }
1146: if (jjmatchedPos > strPos)
1147: return curPos;
1148:
1149: int toRet = Math.max(curPos, seenUpto);
1150:
1151: if (curPos < toRet)
1152: for (i = toRet - Math.min(curPos, seenUpto); i-- > 0;)
1153: try {
1154: curChar = input_stream.readChar();
1155: } catch (java.io.IOException e) {
1156: throw new Error(
1157: "Internal Error : Please send a bug report.");
1158: }
1159:
1160: if (jjmatchedPos < strPos) {
1161: jjmatchedKind = strKind;
1162: jjmatchedPos = strPos;
1163: } else if (jjmatchedPos == strPos && jjmatchedKind > strKind)
1164: jjmatchedKind = strKind;
1165:
1166: return toRet;
1167: }
1168:
1169: static final int[] jjnextStates = { 74, 75, 76, 86, 87, 92, 93, 97,
1170: 74, 75, 78, 80, 85, 58, 61, 62, 1, 2, 4, 13, 14, 16, 8, 9,
1171: 11, 18, 19, 21, 23, 24, 26, 30, 31, 33, 35, 36, 38, 58, 59,
1172: 60, 64, 61, 62, 66, 67, 68, 72, 69, 70, 66, 69, 70, 86, 87,
1173: 92, 93, 100, 101, 103, 104, 100, 101, 102, 103, 104, 105,
1174: 43, 44, 83, 84, 90, 91, 94, 95, };
1175:
1176: private static final boolean jjCanMove_0(int hiByte, int i1,
1177: int i2, long l1, long l2) {
1178: switch (hiByte) {
1179: case 0:
1180: return ((jjbitVec2[i2] & l2) != 0L);
1181: default:
1182: if ((jjbitVec0[i1] & l1) != 0L)
1183: return true;
1184: return false;
1185: }
1186: }
1187:
1188: private static final boolean jjCanMove_1(int hiByte, int i1,
1189: int i2, long l1, long l2) {
1190: switch (hiByte) {
1191: case 0:
1192: return ((jjbitVec4[i2] & l2) != 0L);
1193: case 3:
1194: return ((jjbitVec5[i2] & l2) != 0L);
1195: case 32:
1196: return ((jjbitVec6[i2] & l2) != 0L);
1197: case 33:
1198: return ((jjbitVec7[i2] & l2) != 0L);
1199: case 47:
1200: return ((jjbitVec8[i2] & l2) != 0L);
1201: case 48:
1202: return ((jjbitVec0[i2] & l2) != 0L);
1203: case 255:
1204: return ((jjbitVec9[i2] & l2) != 0L);
1205: default:
1206: if ((jjbitVec3[i1] & l1) != 0L)
1207: return true;
1208: return false;
1209: }
1210: }
1211:
1212: private static final boolean jjCanMove_2(int hiByte, int i1,
1213: int i2, long l1, long l2) {
1214: switch (hiByte) {
1215: case 0:
1216: return ((jjbitVec10[i2] & l2) != 0L);
1217: case 3:
1218: return ((jjbitVec11[i2] & l2) != 0L);
1219: case 32:
1220: return ((jjbitVec12[i2] & l2) != 0L);
1221: case 33:
1222: return ((jjbitVec7[i2] & l2) != 0L);
1223: case 47:
1224: return ((jjbitVec8[i2] & l2) != 0L);
1225: case 48:
1226: return ((jjbitVec0[i2] & l2) != 0L);
1227: case 255:
1228: return ((jjbitVec9[i2] & l2) != 0L);
1229: default:
1230: if ((jjbitVec3[i1] & l1) != 0L)
1231: return true;
1232: return false;
1233: }
1234: }
1235:
1236: public static final String[] jjstrLiteralImages = { "", "\41",
1237: "\174", "\136", "\55\76", "\74\55", null, null, null, null,
1238: null, null, null, "\141", null, null, null, null, null,
1239: null, null, null, null, null, null, null, null, null, null,
1240: null, null, null, null, null, null, null, null, "\50",
1241: "\51", null, "\173", "\175", "\133", "\135", null, "\73",
1242: "\54", "\56", "\75", "\75\76", "\44", "\77", "\176", "\72",
1243: "\52", "\57", "\134", "\136\136", "\100", null, null, null,
1244: null, null, null, null, };
1245: public static final String[] lexStateNames = { "DEFAULT", };
1246: static final long[] jjtoToken = { 0x7ffffe7ffc7e03fL, 0x0L, };
1247: static final long[] jjtoSkip = { 0x17c0L, 0x0L, };
1248: static final long[] jjtoSpecial = { 0x1000L, 0x0L, };
1249: protected JavaCharStream input_stream;
1250: private final int[] jjrounds = new int[110];
1251: private final int[] jjstateSet = new int[220];
1252: protected char curChar;
1253:
1254: public TurtleParserTokenManager(JavaCharStream stream) {
1255: if (JavaCharStream.staticFlag)
1256: throw new Error(
1257: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1258: input_stream = stream;
1259: }
1260:
1261: public TurtleParserTokenManager(JavaCharStream stream, int lexState) {
1262: this (stream);
1263: SwitchTo(lexState);
1264: }
1265:
1266: public void ReInit(JavaCharStream stream) {
1267: jjmatchedPos = jjnewStateCnt = 0;
1268: curLexState = defaultLexState;
1269: input_stream = stream;
1270: ReInitRounds();
1271: }
1272:
1273: private final void ReInitRounds() {
1274: int i;
1275: jjround = 0x80000001;
1276: for (i = 110; i-- > 0;)
1277: jjrounds[i] = 0x80000000;
1278: }
1279:
1280: public void ReInit(JavaCharStream stream, int lexState) {
1281: ReInit(stream);
1282: SwitchTo(lexState);
1283: }
1284:
1285: public void SwitchTo(int lexState) {
1286: if (lexState >= 1 || lexState < 0)
1287: throw new TokenMgrError(
1288: "Error: Ignoring invalid lexical state : "
1289: + lexState + ". State unchanged.",
1290: TokenMgrError.INVALID_LEXICAL_STATE);
1291: else
1292: curLexState = lexState;
1293: }
1294:
1295: protected Token jjFillToken() {
1296: Token t = Token.newToken(jjmatchedKind);
1297: t.kind = jjmatchedKind;
1298: String im = jjstrLiteralImages[jjmatchedKind];
1299: t.image = (im == null) ? input_stream.GetImage() : im;
1300: t.beginLine = input_stream.getBeginLine();
1301: t.beginColumn = input_stream.getBeginColumn();
1302: t.endLine = input_stream.getEndLine();
1303: t.endColumn = input_stream.getEndColumn();
1304: return t;
1305: }
1306:
1307: int curLexState = 0;
1308: int defaultLexState = 0;
1309: int jjnewStateCnt;
1310: int jjround;
1311: int jjmatchedPos;
1312: int jjmatchedKind;
1313:
1314: public Token getNextToken() {
1315: int kind;
1316: Token specialToken = null;
1317: Token matchedToken;
1318: int curPos = 0;
1319:
1320: EOFLoop: for (;;) {
1321: try {
1322: curChar = input_stream.BeginToken();
1323: } catch (java.io.IOException e) {
1324: jjmatchedKind = 0;
1325: matchedToken = jjFillToken();
1326: matchedToken.specialToken = specialToken;
1327: return matchedToken;
1328: }
1329:
1330: jjmatchedKind = 0x7fffffff;
1331: jjmatchedPos = 0;
1332: curPos = jjMoveStringLiteralDfa0_0();
1333: if (jjmatchedKind != 0x7fffffff) {
1334: if (jjmatchedPos + 1 < curPos)
1335: input_stream.backup(curPos - jjmatchedPos - 1);
1336: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1337: matchedToken = jjFillToken();
1338: matchedToken.specialToken = specialToken;
1339: return matchedToken;
1340: } else {
1341: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1342: matchedToken = jjFillToken();
1343: if (specialToken == null)
1344: specialToken = matchedToken;
1345: else {
1346: matchedToken.specialToken = specialToken;
1347: specialToken = (specialToken.next = matchedToken);
1348: }
1349: }
1350: continue EOFLoop;
1351: }
1352: }
1353: int error_line = input_stream.getEndLine();
1354: int error_column = input_stream.getEndColumn();
1355: String error_after = null;
1356: boolean EOFSeen = false;
1357: try {
1358: input_stream.readChar();
1359: input_stream.backup(1);
1360: } catch (java.io.IOException e1) {
1361: EOFSeen = true;
1362: error_after = curPos <= 1 ? "" : input_stream
1363: .GetImage();
1364: if (curChar == '\n' || curChar == '\r') {
1365: error_line++;
1366: error_column = 0;
1367: } else
1368: error_column++;
1369: }
1370: if (!EOFSeen) {
1371: input_stream.backup(1);
1372: error_after = curPos <= 1 ? "" : input_stream
1373: .GetImage();
1374: }
1375: throw new TokenMgrError(EOFSeen, curLexState, error_line,
1376: error_column, error_after, curChar,
1377: TokenMgrError.LEXICAL_ERROR);
1378: }
1379: }
1380:
1381: }
|