0001: /* Generated By:JJTree&JavaCC: Do not edit this line. PythonGrammarTokenManager.java */
0002: package org.python.parser;
0003:
0004: public class PythonGrammarTokenManager implements
0005: PythonGrammarConstants {
0006: int indentation[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0007: 0, 0, 0, 0, 0 };
0008: int level = 0;
0009: int dedents = 0;
0010: int parens = 0;
0011: int indent;
0012:
0013: boolean expect_indent = false;
0014:
0015: boolean compound = false;
0016:
0017: public boolean single_input = false;
0018:
0019: // parsing of partial sentence (interactive) mode
0020: public boolean partial = false;
0021: // control whether empty new lines on EOF force sentence closing NEWLINE even if indent
0022: // is expected,i.e. classic behavior at jython prompt (different from codeop behavior)
0023: public boolean stdprompt = false;
0024:
0025: public boolean generator_allowed = false;
0026:
0027: static Token addDedent(Token previous) {
0028: Token t = new Token();
0029: t.kind = DEDENT;
0030: t.beginLine = previous.beginLine;
0031: t.endLine = previous.endLine;
0032: t.beginColumn = previous.beginColumn;
0033: t.endColumn = previous.endColumn;
0034: t.image = "<DEDENT>";
0035: t.specialToken = null;
0036: t.next = null;
0037: previous.next = t;
0038: return t;
0039: }
0040:
0041: void CommonTokenAction(Token t) {
0042: /*
0043: if not partial: EOF is expanded to token sequences comprising
0044: if single_input: [NEWLINE] necessary DEDENT NEWLINE (afterward EOF)
0045: otherwise : [NEWLINE] necessary DEDENT EOF
0046: if partial: EOF expansion happens only if EOF preceded by empty line (etc),
0047: i.e. lexer is in MAYBE_FORCE_NEWLINE_IF_EOF state
0048: */
0049: if (t.kind == EOF) {
0050: // System.out.println("EOF: "+single_input+", "+curLexState+", "+level);
0051: if (!partial || curLexState == MAYBE_FORCE_NEWLINE_IF_EOF) {
0052: if (curLexState == DEFAULT) {
0053: t.kind = NEWLINE;
0054: } else {
0055: t.kind = DEDENT;
0056: if (level >= 0)
0057: level -= 1;
0058: }
0059: while (level >= 0) {
0060: level--;
0061: t = addDedent(t);
0062: }
0063: if (!single_input) {
0064: t.kind = EOF;
0065: t.image = "<EOF>";
0066: } else {
0067: t.kind = NEWLINE;
0068: t.image = "<FORCENL>";
0069: single_input = false;
0070: }
0071: }
0072: } else if (t.kind == YIELD) {
0073: if (!generator_allowed) {
0074: t.kind = NAME;
0075: }
0076: }
0077: }
0078:
0079: void indenting(int ind) {
0080: indent = ind;
0081: if (indent == indentation[level])
0082: SwitchTo(INDENTATION_UNCHANGED);
0083: else
0084: SwitchTo(INDENTING);
0085: }
0086:
0087: public java.io.PrintStream debugStream = System.out;
0088:
0089: public void setDebugStream(java.io.PrintStream ds) {
0090: debugStream = ds;
0091: }
0092:
0093: private final int jjStopStringLiteralDfa_4(int pos, long active0) {
0094: switch (pos) {
0095: default:
0096: return -1;
0097: }
0098: }
0099:
0100: private final int jjStartNfa_4(int pos, long active0) {
0101: return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0),
0102: pos + 1);
0103: }
0104:
0105: private final int jjStopAtPos(int pos, int kind) {
0106: jjmatchedKind = kind;
0107: jjmatchedPos = pos;
0108: return pos + 1;
0109: }
0110:
0111: private final int jjStartNfaWithStates_4(int pos, int kind,
0112: int state) {
0113: jjmatchedKind = kind;
0114: jjmatchedPos = pos;
0115: try {
0116: curChar = input_stream.readChar();
0117: } catch (java.io.IOException e) {
0118: return pos + 1;
0119: }
0120: return jjMoveNfa_4(state, pos + 1);
0121: }
0122:
0123: private final int jjMoveStringLiteralDfa0_4() {
0124: switch (curChar) {
0125: case 9:
0126: return jjStopAtPos(0, 9);
0127: case 12:
0128: return jjStopAtPos(0, 11);
0129: case 32:
0130: return jjStopAtPos(0, 10);
0131: default:
0132: return jjMoveNfa_4(1, 0);
0133: }
0134: }
0135:
0136: private final void jjCheckNAdd(int state) {
0137: if (jjrounds[state] != jjround) {
0138: jjstateSet[jjnewStateCnt++] = state;
0139: jjrounds[state] = jjround;
0140: }
0141: }
0142:
0143: private final void jjAddStates(int start, int end) {
0144: do {
0145: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0146: } while (start++ != end);
0147: }
0148:
0149: private final void jjCheckNAddTwoStates(int state1, int state2) {
0150: jjCheckNAdd(state1);
0151: jjCheckNAdd(state2);
0152: }
0153:
0154: private final void jjCheckNAddStates(int start, int end) {
0155: do {
0156: jjCheckNAdd(jjnextStates[start]);
0157: } while (start++ != end);
0158: }
0159:
0160: private final void jjCheckNAddStates(int start) {
0161: jjCheckNAdd(jjnextStates[start]);
0162: jjCheckNAdd(jjnextStates[start + 1]);
0163: }
0164:
0165: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0166: 0xffffffffffffffffL, 0xffffffffffffffffL,
0167: 0xffffffffffffffffL };
0168: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0169: 0xffffffffffffffffL };
0170:
0171: private final int jjMoveNfa_4(int startState, int curPos) {
0172: int[] nextStates;
0173: int startsAt = 0;
0174: jjnewStateCnt = 8;
0175: int i = 1;
0176: jjstateSet[0] = startState;
0177: int j, kind = 0x7fffffff;
0178: for (;;) {
0179: if (++jjround == 0x7fffffff)
0180: ReInitRounds();
0181: if (curChar < 64) {
0182: long l = 1L << curChar;
0183: MatchLoop: do {
0184: switch (jjstateSet[--i]) {
0185: case 1:
0186: if ((0x2400L & l) != 0L) {
0187: if (kind > 12)
0188: kind = 12;
0189: } else if (curChar == 35)
0190: jjCheckNAddStates(0, 2);
0191: if (curChar == 13)
0192: jjstateSet[jjnewStateCnt++] = 0;
0193: break;
0194: case 0:
0195: if (curChar == 10 && kind > 12)
0196: kind = 12;
0197: break;
0198: case 2:
0199: if ((0x2400L & l) != 0L && kind > 12)
0200: kind = 12;
0201: break;
0202: case 3:
0203: if (curChar == 35)
0204: jjCheckNAddStates(0, 2);
0205: break;
0206: case 4:
0207: if ((0xffffffffffffdbffL & l) != 0L)
0208: jjCheckNAddStates(0, 2);
0209: break;
0210: case 5:
0211: if (curChar == 10 && kind > 17)
0212: kind = 17;
0213: break;
0214: case 6:
0215: if (curChar == 13)
0216: jjstateSet[jjnewStateCnt++] = 5;
0217: break;
0218: case 7:
0219: if ((0x2400L & l) != 0L && kind > 17)
0220: kind = 17;
0221: break;
0222: default:
0223: break;
0224: }
0225: } while (i != startsAt);
0226: } else if (curChar < 128) {
0227: long l = 1L << (curChar & 077);
0228: MatchLoop: do {
0229: switch (jjstateSet[--i]) {
0230: case 4:
0231: jjAddStates(0, 2);
0232: break;
0233: default:
0234: break;
0235: }
0236: } while (i != startsAt);
0237: } else {
0238: int hiByte = (int) (curChar >> 8);
0239: int i1 = hiByte >> 6;
0240: long l1 = 1L << (hiByte & 077);
0241: int i2 = (curChar & 0xff) >> 6;
0242: long l2 = 1L << (curChar & 077);
0243: MatchLoop: do {
0244: switch (jjstateSet[--i]) {
0245: case 4:
0246: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
0247: jjAddStates(0, 2);
0248: break;
0249: default:
0250: break;
0251: }
0252: } while (i != startsAt);
0253: }
0254: if (kind != 0x7fffffff) {
0255: jjmatchedKind = kind;
0256: jjmatchedPos = curPos;
0257: kind = 0x7fffffff;
0258: }
0259: ++curPos;
0260: if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
0261: return curPos;
0262: try {
0263: curChar = input_stream.readChar();
0264: } catch (java.io.IOException e) {
0265: return curPos;
0266: }
0267: }
0268: }
0269:
0270: private final int jjMoveStringLiteralDfa0_15() {
0271: return 1;
0272: }
0273:
0274: private final int jjStopStringLiteralDfa_13(int pos, long active0,
0275: long active1, long active2) {
0276: switch (pos) {
0277: case 0:
0278: if ((active1 & 0x4000000000000L) != 0L) {
0279: jjmatchedKind = 133;
0280: return -1;
0281: }
0282: return -1;
0283: case 1:
0284: if ((active1 & 0x4000000000000L) != 0L) {
0285: if (jjmatchedPos == 0) {
0286: jjmatchedKind = 133;
0287: jjmatchedPos = 0;
0288: }
0289: return -1;
0290: }
0291: return -1;
0292: default:
0293: return -1;
0294: }
0295: }
0296:
0297: private final int jjStartNfa_13(int pos, long active0,
0298: long active1, long active2) {
0299: return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0,
0300: active1, active2), pos + 1);
0301: }
0302:
0303: private final int jjStartNfaWithStates_13(int pos, int kind,
0304: int state) {
0305: jjmatchedKind = kind;
0306: jjmatchedPos = pos;
0307: try {
0308: curChar = input_stream.readChar();
0309: } catch (java.io.IOException e) {
0310: return pos + 1;
0311: }
0312: return jjMoveNfa_13(state, pos + 1);
0313: }
0314:
0315: private final int jjMoveStringLiteralDfa0_13() {
0316: switch (curChar) {
0317: case 10:
0318: return jjStopAtPos(0, 131);
0319: case 13:
0320: jjmatchedKind = 132;
0321: return jjMoveStringLiteralDfa1_13(0x0L, 0x4L);
0322: case 39:
0323: return jjMoveStringLiteralDfa1_13(0x4000000000000L, 0x0L);
0324: default:
0325: return jjMoveNfa_13(0, 0);
0326: }
0327: }
0328:
0329: private final int jjMoveStringLiteralDfa1_13(long active1,
0330: long active2) {
0331: try {
0332: curChar = input_stream.readChar();
0333: } catch (java.io.IOException e) {
0334: jjStopStringLiteralDfa_13(0, 0L, active1, active2);
0335: return 1;
0336: }
0337: switch (curChar) {
0338: case 10:
0339: if ((active2 & 0x4L) != 0L)
0340: return jjStopAtPos(1, 130);
0341: break;
0342: case 39:
0343: return jjMoveStringLiteralDfa2_13(active1,
0344: 0x4000000000000L, active2, 0L);
0345: default:
0346: break;
0347: }
0348: return jjStartNfa_13(0, 0L, active1, active2);
0349: }
0350:
0351: private final int jjMoveStringLiteralDfa2_13(long old1,
0352: long active1, long old2, long active2) {
0353: if (((active1 &= old1) | (active2 &= old2)) == 0L)
0354: return jjStartNfa_13(0, 0L, old1, old2);
0355: try {
0356: curChar = input_stream.readChar();
0357: } catch (java.io.IOException e) {
0358: jjStopStringLiteralDfa_13(1, 0L, active1, 0L);
0359: return 2;
0360: }
0361: switch (curChar) {
0362: case 39:
0363: if ((active1 & 0x4000000000000L) != 0L)
0364: return jjStopAtPos(2, 114);
0365: break;
0366: default:
0367: break;
0368: }
0369: return jjStartNfa_13(1, 0L, active1, 0L);
0370: }
0371:
0372: private final int jjMoveNfa_13(int startState, int curPos) {
0373: int[] nextStates;
0374: int startsAt = 0;
0375: jjnewStateCnt = 3;
0376: int i = 1;
0377: jjstateSet[0] = startState;
0378: int j, kind = 0x7fffffff;
0379: for (;;) {
0380: if (++jjround == 0x7fffffff)
0381: ReInitRounds();
0382: if (curChar < 64) {
0383: long l = 1L << curChar;
0384: MatchLoop: do {
0385: switch (jjstateSet[--i]) {
0386: case 0:
0387: if ((0xffffffffffffdbffL & l) != 0L
0388: && kind > 133)
0389: kind = 133;
0390: break;
0391: case 2:
0392: if ((0xffffffffffffdbffL & l) != 0L
0393: && kind > 134)
0394: kind = 134;
0395: break;
0396: default:
0397: break;
0398: }
0399: } while (i != startsAt);
0400: } else if (curChar < 128) {
0401: long l = 1L << (curChar & 077);
0402: MatchLoop: do {
0403: switch (jjstateSet[--i]) {
0404: case 0:
0405: if (kind > 133)
0406: kind = 133;
0407: if (curChar == 92)
0408: jjstateSet[jjnewStateCnt++] = 2;
0409: break;
0410: case 1:
0411: if (curChar == 92)
0412: jjstateSet[jjnewStateCnt++] = 2;
0413: break;
0414: case 2:
0415: if (kind > 134)
0416: kind = 134;
0417: break;
0418: default:
0419: break;
0420: }
0421: } while (i != startsAt);
0422: } else {
0423: int hiByte = (int) (curChar >> 8);
0424: int i1 = hiByte >> 6;
0425: long l1 = 1L << (hiByte & 077);
0426: int i2 = (curChar & 0xff) >> 6;
0427: long l2 = 1L << (curChar & 077);
0428: MatchLoop: do {
0429: switch (jjstateSet[--i]) {
0430: case 0:
0431: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
0432: && kind > 133)
0433: kind = 133;
0434: break;
0435: case 2:
0436: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
0437: && kind > 134)
0438: kind = 134;
0439: break;
0440: default:
0441: break;
0442: }
0443: } while (i != startsAt);
0444: }
0445: if (kind != 0x7fffffff) {
0446: jjmatchedKind = kind;
0447: jjmatchedPos = curPos;
0448: kind = 0x7fffffff;
0449: }
0450: ++curPos;
0451: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
0452: return curPos;
0453: try {
0454: curChar = input_stream.readChar();
0455: } catch (java.io.IOException e) {
0456: return curPos;
0457: }
0458: }
0459: }
0460:
0461: private final int jjStopStringLiteralDfa_11(int pos, long active0,
0462: long active1) {
0463: switch (pos) {
0464: case 0:
0465: if ((active1 & 0x100000000000000L) != 0L) {
0466: jjmatchedKind = 128;
0467: return 2;
0468: }
0469: return -1;
0470: case 1:
0471: if ((active1 & 0x100000000000000L) != 0L) {
0472: jjmatchedKind = 121;
0473: jjmatchedPos = 1;
0474: return -1;
0475: }
0476: return -1;
0477: default:
0478: return -1;
0479: }
0480: }
0481:
0482: private final int jjStartNfa_11(int pos, long active0, long active1) {
0483: return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0,
0484: active1), pos + 1);
0485: }
0486:
0487: private final int jjStartNfaWithStates_11(int pos, int kind,
0488: int state) {
0489: jjmatchedKind = kind;
0490: jjmatchedPos = pos;
0491: try {
0492: curChar = input_stream.readChar();
0493: } catch (java.io.IOException e) {
0494: return pos + 1;
0495: }
0496: return jjMoveNfa_11(state, pos + 1);
0497: }
0498:
0499: private final int jjMoveStringLiteralDfa0_11() {
0500: switch (curChar) {
0501: case 39:
0502: return jjStopAtPos(0, 112);
0503: case 92:
0504: return jjMoveStringLiteralDfa1_11(0x100000000000000L);
0505: default:
0506: return jjMoveNfa_11(0, 0);
0507: }
0508: }
0509:
0510: private final int jjMoveStringLiteralDfa1_11(long active1) {
0511: try {
0512: curChar = input_stream.readChar();
0513: } catch (java.io.IOException e) {
0514: jjStopStringLiteralDfa_11(0, 0L, active1);
0515: return 1;
0516: }
0517: switch (curChar) {
0518: case 13:
0519: return jjMoveStringLiteralDfa2_11(active1,
0520: 0x100000000000000L);
0521: default:
0522: break;
0523: }
0524: return jjStartNfa_11(0, 0L, active1);
0525: }
0526:
0527: private final int jjMoveStringLiteralDfa2_11(long old1, long active1) {
0528: if (((active1 &= old1)) == 0L)
0529: return jjStartNfa_11(0, 0L, old1);
0530: try {
0531: curChar = input_stream.readChar();
0532: } catch (java.io.IOException e) {
0533: jjStopStringLiteralDfa_11(1, 0L, active1);
0534: return 2;
0535: }
0536: switch (curChar) {
0537: case 10:
0538: if ((active1 & 0x100000000000000L) != 0L)
0539: return jjStopAtPos(2, 120);
0540: break;
0541: default:
0542: break;
0543: }
0544: return jjStartNfa_11(1, 0L, active1);
0545: }
0546:
0547: private final int jjMoveNfa_11(int startState, int curPos) {
0548: int[] nextStates;
0549: int startsAt = 0;
0550: jjnewStateCnt = 4;
0551: int i = 1;
0552: jjstateSet[0] = startState;
0553: int j, kind = 0x7fffffff;
0554: for (;;) {
0555: if (++jjround == 0x7fffffff)
0556: ReInitRounds();
0557: if (curChar < 64) {
0558: long l = 1L << curChar;
0559: MatchLoop: do {
0560: switch (jjstateSet[--i]) {
0561: case 0:
0562: if ((0xffffffffffffdbffL & l) != 0L
0563: && kind > 128)
0564: kind = 128;
0565: break;
0566: case 2:
0567: if ((0x2400L & l) != 0L) {
0568: if (kind > 121)
0569: kind = 121;
0570: } else if (curChar == 39) {
0571: if (kind > 128)
0572: kind = 128;
0573: }
0574: break;
0575: case 3:
0576: if (curChar == 39 && kind > 128)
0577: kind = 128;
0578: break;
0579: default:
0580: break;
0581: }
0582: } while (i != startsAt);
0583: } else if (curChar < 128) {
0584: long l = 1L << (curChar & 077);
0585: MatchLoop: do {
0586: switch (jjstateSet[--i]) {
0587: case 0:
0588: if (kind > 128)
0589: kind = 128;
0590: if (curChar == 92)
0591: jjAddStates(3, 4);
0592: break;
0593: case 2:
0594: if (curChar == 92 && kind > 128)
0595: kind = 128;
0596: break;
0597: case 1:
0598: if (curChar == 92)
0599: jjAddStates(3, 4);
0600: break;
0601: default:
0602: break;
0603: }
0604: } while (i != startsAt);
0605: } else {
0606: int hiByte = (int) (curChar >> 8);
0607: int i1 = hiByte >> 6;
0608: long l1 = 1L << (hiByte & 077);
0609: int i2 = (curChar & 0xff) >> 6;
0610: long l2 = 1L << (curChar & 077);
0611: MatchLoop: do {
0612: switch (jjstateSet[--i]) {
0613: case 0:
0614: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
0615: && kind > 128)
0616: kind = 128;
0617: break;
0618: default:
0619: break;
0620: }
0621: } while (i != startsAt);
0622: }
0623: if (kind != 0x7fffffff) {
0624: jjmatchedKind = kind;
0625: jjmatchedPos = curPos;
0626: kind = 0x7fffffff;
0627: }
0628: ++curPos;
0629: if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
0630: return curPos;
0631: try {
0632: curChar = input_stream.readChar();
0633: } catch (java.io.IOException e) {
0634: return curPos;
0635: }
0636: }
0637: }
0638:
0639: private final int jjMoveStringLiteralDfa0_16() {
0640: return 1;
0641: }
0642:
0643: private final int jjStopStringLiteralDfa_10(int pos, long active0,
0644: long active1, long active2) {
0645: switch (pos) {
0646: case 0:
0647: if ((active1 & 0x800000000000L) != 0L) {
0648: jjmatchedKind = 133;
0649: return -1;
0650: }
0651: return -1;
0652: case 1:
0653: if ((active1 & 0x800000000000L) != 0L) {
0654: if (jjmatchedPos == 0) {
0655: jjmatchedKind = 133;
0656: jjmatchedPos = 0;
0657: }
0658: return -1;
0659: }
0660: return -1;
0661: default:
0662: return -1;
0663: }
0664: }
0665:
0666: private final int jjStartNfa_10(int pos, long active0,
0667: long active1, long active2) {
0668: return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0,
0669: active1, active2), pos + 1);
0670: }
0671:
0672: private final int jjStartNfaWithStates_10(int pos, int kind,
0673: int state) {
0674: jjmatchedKind = kind;
0675: jjmatchedPos = pos;
0676: try {
0677: curChar = input_stream.readChar();
0678: } catch (java.io.IOException e) {
0679: return pos + 1;
0680: }
0681: return jjMoveNfa_10(state, pos + 1);
0682: }
0683:
0684: private final int jjMoveStringLiteralDfa0_10() {
0685: switch (curChar) {
0686: case 10:
0687: return jjStopAtPos(0, 131);
0688: case 13:
0689: jjmatchedKind = 132;
0690: return jjMoveStringLiteralDfa1_10(0x0L, 0x4L);
0691: case 34:
0692: return jjMoveStringLiteralDfa1_10(0x800000000000L, 0x0L);
0693: default:
0694: return jjMoveNfa_10(0, 0);
0695: }
0696: }
0697:
0698: private final int jjMoveStringLiteralDfa1_10(long active1,
0699: long active2) {
0700: try {
0701: curChar = input_stream.readChar();
0702: } catch (java.io.IOException e) {
0703: jjStopStringLiteralDfa_10(0, 0L, active1, active2);
0704: return 1;
0705: }
0706: switch (curChar) {
0707: case 10:
0708: if ((active2 & 0x4L) != 0L)
0709: return jjStopAtPos(1, 130);
0710: break;
0711: case 34:
0712: return jjMoveStringLiteralDfa2_10(active1, 0x800000000000L,
0713: active2, 0L);
0714: default:
0715: break;
0716: }
0717: return jjStartNfa_10(0, 0L, active1, active2);
0718: }
0719:
0720: private final int jjMoveStringLiteralDfa2_10(long old1,
0721: long active1, long old2, long active2) {
0722: if (((active1 &= old1) | (active2 &= old2)) == 0L)
0723: return jjStartNfa_10(0, 0L, old1, old2);
0724: try {
0725: curChar = input_stream.readChar();
0726: } catch (java.io.IOException e) {
0727: jjStopStringLiteralDfa_10(1, 0L, active1, 0L);
0728: return 2;
0729: }
0730: switch (curChar) {
0731: case 34:
0732: if ((active1 & 0x800000000000L) != 0L)
0733: return jjStopAtPos(2, 111);
0734: break;
0735: default:
0736: break;
0737: }
0738: return jjStartNfa_10(1, 0L, active1, 0L);
0739: }
0740:
0741: private final int jjMoveNfa_10(int startState, int curPos) {
0742: int[] nextStates;
0743: int startsAt = 0;
0744: jjnewStateCnt = 3;
0745: int i = 1;
0746: jjstateSet[0] = startState;
0747: int j, kind = 0x7fffffff;
0748: for (;;) {
0749: if (++jjround == 0x7fffffff)
0750: ReInitRounds();
0751: if (curChar < 64) {
0752: long l = 1L << curChar;
0753: MatchLoop: do {
0754: switch (jjstateSet[--i]) {
0755: case 0:
0756: if ((0xffffffffffffdbffL & l) != 0L
0757: && kind > 133)
0758: kind = 133;
0759: break;
0760: case 2:
0761: if ((0xffffffffffffdbffL & l) != 0L
0762: && kind > 134)
0763: kind = 134;
0764: break;
0765: default:
0766: break;
0767: }
0768: } while (i != startsAt);
0769: } else if (curChar < 128) {
0770: long l = 1L << (curChar & 077);
0771: MatchLoop: do {
0772: switch (jjstateSet[--i]) {
0773: case 0:
0774: if (kind > 133)
0775: kind = 133;
0776: if (curChar == 92)
0777: jjstateSet[jjnewStateCnt++] = 2;
0778: break;
0779: case 1:
0780: if (curChar == 92)
0781: jjstateSet[jjnewStateCnt++] = 2;
0782: break;
0783: case 2:
0784: if (kind > 134)
0785: kind = 134;
0786: break;
0787: default:
0788: break;
0789: }
0790: } while (i != startsAt);
0791: } else {
0792: int hiByte = (int) (curChar >> 8);
0793: int i1 = hiByte >> 6;
0794: long l1 = 1L << (hiByte & 077);
0795: int i2 = (curChar & 0xff) >> 6;
0796: long l2 = 1L << (curChar & 077);
0797: MatchLoop: do {
0798: switch (jjstateSet[--i]) {
0799: case 0:
0800: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
0801: && kind > 133)
0802: kind = 133;
0803: break;
0804: case 2:
0805: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
0806: && kind > 134)
0807: kind = 134;
0808: break;
0809: default:
0810: break;
0811: }
0812: } while (i != startsAt);
0813: }
0814: if (kind != 0x7fffffff) {
0815: jjmatchedKind = kind;
0816: jjmatchedPos = curPos;
0817: kind = 0x7fffffff;
0818: }
0819: ++curPos;
0820: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
0821: return curPos;
0822: try {
0823: curChar = input_stream.readChar();
0824: } catch (java.io.IOException e) {
0825: return curPos;
0826: }
0827: }
0828: }
0829:
0830: private final int jjStopStringLiteralDfa_8(int pos, long active0,
0831: long active1) {
0832: switch (pos) {
0833: case 0:
0834: if ((active1 & 0x40000000000000L) != 0L) {
0835: jjmatchedKind = 129;
0836: return 2;
0837: }
0838: return -1;
0839: case 1:
0840: if ((active1 & 0x40000000000000L) != 0L) {
0841: jjmatchedKind = 119;
0842: jjmatchedPos = 1;
0843: return -1;
0844: }
0845: return -1;
0846: default:
0847: return -1;
0848: }
0849: }
0850:
0851: private final int jjStartNfa_8(int pos, long active0, long active1) {
0852: return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0,
0853: active1), pos + 1);
0854: }
0855:
0856: private final int jjStartNfaWithStates_8(int pos, int kind,
0857: int state) {
0858: jjmatchedKind = kind;
0859: jjmatchedPos = pos;
0860: try {
0861: curChar = input_stream.readChar();
0862: } catch (java.io.IOException e) {
0863: return pos + 1;
0864: }
0865: return jjMoveNfa_8(state, pos + 1);
0866: }
0867:
0868: private final int jjMoveStringLiteralDfa0_8() {
0869: switch (curChar) {
0870: case 34:
0871: return jjStopAtPos(0, 109);
0872: case 92:
0873: return jjMoveStringLiteralDfa1_8(0x40000000000000L);
0874: default:
0875: return jjMoveNfa_8(0, 0);
0876: }
0877: }
0878:
0879: private final int jjMoveStringLiteralDfa1_8(long active1) {
0880: try {
0881: curChar = input_stream.readChar();
0882: } catch (java.io.IOException e) {
0883: jjStopStringLiteralDfa_8(0, 0L, active1);
0884: return 1;
0885: }
0886: switch (curChar) {
0887: case 13:
0888: return jjMoveStringLiteralDfa2_8(active1, 0x40000000000000L);
0889: default:
0890: break;
0891: }
0892: return jjStartNfa_8(0, 0L, active1);
0893: }
0894:
0895: private final int jjMoveStringLiteralDfa2_8(long old1, long active1) {
0896: if (((active1 &= old1)) == 0L)
0897: return jjStartNfa_8(0, 0L, old1);
0898: try {
0899: curChar = input_stream.readChar();
0900: } catch (java.io.IOException e) {
0901: jjStopStringLiteralDfa_8(1, 0L, active1);
0902: return 2;
0903: }
0904: switch (curChar) {
0905: case 10:
0906: if ((active1 & 0x40000000000000L) != 0L)
0907: return jjStopAtPos(2, 118);
0908: break;
0909: default:
0910: break;
0911: }
0912: return jjStartNfa_8(1, 0L, active1);
0913: }
0914:
0915: private final int jjMoveNfa_8(int startState, int curPos) {
0916: int[] nextStates;
0917: int startsAt = 0;
0918: jjnewStateCnt = 4;
0919: int i = 1;
0920: jjstateSet[0] = startState;
0921: int j, kind = 0x7fffffff;
0922: for (;;) {
0923: if (++jjround == 0x7fffffff)
0924: ReInitRounds();
0925: if (curChar < 64) {
0926: long l = 1L << curChar;
0927: MatchLoop: do {
0928: switch (jjstateSet[--i]) {
0929: case 0:
0930: if ((0xffffffffffffdbffL & l) != 0L
0931: && kind > 129)
0932: kind = 129;
0933: break;
0934: case 2:
0935: if ((0x2400L & l) != 0L) {
0936: if (kind > 119)
0937: kind = 119;
0938: } else if (curChar == 34) {
0939: if (kind > 129)
0940: kind = 129;
0941: }
0942: break;
0943: case 3:
0944: if (curChar == 34 && kind > 129)
0945: kind = 129;
0946: break;
0947: default:
0948: break;
0949: }
0950: } while (i != startsAt);
0951: } else if (curChar < 128) {
0952: long l = 1L << (curChar & 077);
0953: MatchLoop: do {
0954: switch (jjstateSet[--i]) {
0955: case 0:
0956: if (kind > 129)
0957: kind = 129;
0958: if (curChar == 92)
0959: jjAddStates(3, 4);
0960: break;
0961: case 2:
0962: if (curChar == 92 && kind > 129)
0963: kind = 129;
0964: break;
0965: case 1:
0966: if (curChar == 92)
0967: jjAddStates(3, 4);
0968: break;
0969: default:
0970: break;
0971: }
0972: } while (i != startsAt);
0973: } else {
0974: int hiByte = (int) (curChar >> 8);
0975: int i1 = hiByte >> 6;
0976: long l1 = 1L << (hiByte & 077);
0977: int i2 = (curChar & 0xff) >> 6;
0978: long l2 = 1L << (curChar & 077);
0979: MatchLoop: do {
0980: switch (jjstateSet[--i]) {
0981: case 0:
0982: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
0983: && kind > 129)
0984: kind = 129;
0985: break;
0986: default:
0987: break;
0988: }
0989: } while (i != startsAt);
0990: }
0991: if (kind != 0x7fffffff) {
0992: jjmatchedKind = kind;
0993: jjmatchedPos = curPos;
0994: kind = 0x7fffffff;
0995: }
0996: ++curPos;
0997: if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
0998: return curPos;
0999: try {
1000: curChar = input_stream.readChar();
1001: } catch (java.io.IOException e) {
1002: return curPos;
1003: }
1004: }
1005: }
1006:
1007: private final int jjStopStringLiteralDfa_14(int pos, long active0,
1008: long active1, long active2) {
1009: switch (pos) {
1010: case 0:
1011: if ((active1 & 0x8000000000000L) != 0L) {
1012: jjmatchedKind = 133;
1013: return -1;
1014: }
1015: return -1;
1016: case 1:
1017: if ((active1 & 0x8000000000000L) != 0L) {
1018: if (jjmatchedPos == 0) {
1019: jjmatchedKind = 133;
1020: jjmatchedPos = 0;
1021: }
1022: return -1;
1023: }
1024: return -1;
1025: default:
1026: return -1;
1027: }
1028: }
1029:
1030: private final int jjStartNfa_14(int pos, long active0,
1031: long active1, long active2) {
1032: return jjMoveNfa_14(jjStopStringLiteralDfa_14(pos, active0,
1033: active1, active2), pos + 1);
1034: }
1035:
1036: private final int jjStartNfaWithStates_14(int pos, int kind,
1037: int state) {
1038: jjmatchedKind = kind;
1039: jjmatchedPos = pos;
1040: try {
1041: curChar = input_stream.readChar();
1042: } catch (java.io.IOException e) {
1043: return pos + 1;
1044: }
1045: return jjMoveNfa_14(state, pos + 1);
1046: }
1047:
1048: private final int jjMoveStringLiteralDfa0_14() {
1049: switch (curChar) {
1050: case 10:
1051: return jjStopAtPos(0, 131);
1052: case 13:
1053: jjmatchedKind = 132;
1054: return jjMoveStringLiteralDfa1_14(0x0L, 0x4L);
1055: case 34:
1056: return jjMoveStringLiteralDfa1_14(0x8000000000000L, 0x0L);
1057: default:
1058: return jjMoveNfa_14(0, 0);
1059: }
1060: }
1061:
1062: private final int jjMoveStringLiteralDfa1_14(long active1,
1063: long active2) {
1064: try {
1065: curChar = input_stream.readChar();
1066: } catch (java.io.IOException e) {
1067: jjStopStringLiteralDfa_14(0, 0L, active1, active2);
1068: return 1;
1069: }
1070: switch (curChar) {
1071: case 10:
1072: if ((active2 & 0x4L) != 0L)
1073: return jjStopAtPos(1, 130);
1074: break;
1075: case 34:
1076: return jjMoveStringLiteralDfa2_14(active1,
1077: 0x8000000000000L, active2, 0L);
1078: default:
1079: break;
1080: }
1081: return jjStartNfa_14(0, 0L, active1, active2);
1082: }
1083:
1084: private final int jjMoveStringLiteralDfa2_14(long old1,
1085: long active1, long old2, long active2) {
1086: if (((active1 &= old1) | (active2 &= old2)) == 0L)
1087: return jjStartNfa_14(0, 0L, old1, old2);
1088: try {
1089: curChar = input_stream.readChar();
1090: } catch (java.io.IOException e) {
1091: jjStopStringLiteralDfa_14(1, 0L, active1, 0L);
1092: return 2;
1093: }
1094: switch (curChar) {
1095: case 34:
1096: if ((active1 & 0x8000000000000L) != 0L)
1097: return jjStopAtPos(2, 115);
1098: break;
1099: default:
1100: break;
1101: }
1102: return jjStartNfa_14(1, 0L, active1, 0L);
1103: }
1104:
1105: private final int jjMoveNfa_14(int startState, int curPos) {
1106: int[] nextStates;
1107: int startsAt = 0;
1108: jjnewStateCnt = 3;
1109: int i = 1;
1110: jjstateSet[0] = startState;
1111: int j, kind = 0x7fffffff;
1112: for (;;) {
1113: if (++jjround == 0x7fffffff)
1114: ReInitRounds();
1115: if (curChar < 64) {
1116: long l = 1L << curChar;
1117: MatchLoop: do {
1118: switch (jjstateSet[--i]) {
1119: case 0:
1120: if ((0xffffffffffffdbffL & l) != 0L
1121: && kind > 133)
1122: kind = 133;
1123: break;
1124: case 2:
1125: if ((0xffffffffffffdbffL & l) != 0L
1126: && kind > 134)
1127: kind = 134;
1128: break;
1129: default:
1130: break;
1131: }
1132: } while (i != startsAt);
1133: } else if (curChar < 128) {
1134: long l = 1L << (curChar & 077);
1135: MatchLoop: do {
1136: switch (jjstateSet[--i]) {
1137: case 0:
1138: if (kind > 133)
1139: kind = 133;
1140: if (curChar == 92)
1141: jjstateSet[jjnewStateCnt++] = 2;
1142: break;
1143: case 1:
1144: if (curChar == 92)
1145: jjstateSet[jjnewStateCnt++] = 2;
1146: break;
1147: case 2:
1148: if (kind > 134)
1149: kind = 134;
1150: break;
1151: default:
1152: break;
1153: }
1154: } while (i != startsAt);
1155: } else {
1156: int hiByte = (int) (curChar >> 8);
1157: int i1 = hiByte >> 6;
1158: long l1 = 1L << (hiByte & 077);
1159: int i2 = (curChar & 0xff) >> 6;
1160: long l2 = 1L << (curChar & 077);
1161: MatchLoop: do {
1162: switch (jjstateSet[--i]) {
1163: case 0:
1164: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1165: && kind > 133)
1166: kind = 133;
1167: break;
1168: case 2:
1169: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1170: && kind > 134)
1171: kind = 134;
1172: break;
1173: default:
1174: break;
1175: }
1176: } while (i != startsAt);
1177: }
1178: if (kind != 0x7fffffff) {
1179: jjmatchedKind = kind;
1180: jjmatchedPos = curPos;
1181: kind = 0x7fffffff;
1182: }
1183: ++curPos;
1184: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1185: return curPos;
1186: try {
1187: curChar = input_stream.readChar();
1188: } catch (java.io.IOException e) {
1189: return curPos;
1190: }
1191: }
1192: }
1193:
1194: private final int jjStopStringLiteralDfa_12(int pos, long active0,
1195: long active1) {
1196: switch (pos) {
1197: case 0:
1198: if ((active1 & 0x400000000000000L) != 0L) {
1199: jjmatchedKind = 129;
1200: return 2;
1201: }
1202: return -1;
1203: case 1:
1204: if ((active1 & 0x400000000000000L) != 0L) {
1205: jjmatchedKind = 123;
1206: jjmatchedPos = 1;
1207: return -1;
1208: }
1209: return -1;
1210: default:
1211: return -1;
1212: }
1213: }
1214:
1215: private final int jjStartNfa_12(int pos, long active0, long active1) {
1216: return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0,
1217: active1), pos + 1);
1218: }
1219:
1220: private final int jjStartNfaWithStates_12(int pos, int kind,
1221: int state) {
1222: jjmatchedKind = kind;
1223: jjmatchedPos = pos;
1224: try {
1225: curChar = input_stream.readChar();
1226: } catch (java.io.IOException e) {
1227: return pos + 1;
1228: }
1229: return jjMoveNfa_12(state, pos + 1);
1230: }
1231:
1232: private final int jjMoveStringLiteralDfa0_12() {
1233: switch (curChar) {
1234: case 34:
1235: return jjStopAtPos(0, 113);
1236: case 92:
1237: return jjMoveStringLiteralDfa1_12(0x400000000000000L);
1238: default:
1239: return jjMoveNfa_12(0, 0);
1240: }
1241: }
1242:
1243: private final int jjMoveStringLiteralDfa1_12(long active1) {
1244: try {
1245: curChar = input_stream.readChar();
1246: } catch (java.io.IOException e) {
1247: jjStopStringLiteralDfa_12(0, 0L, active1);
1248: return 1;
1249: }
1250: switch (curChar) {
1251: case 13:
1252: return jjMoveStringLiteralDfa2_12(active1,
1253: 0x400000000000000L);
1254: default:
1255: break;
1256: }
1257: return jjStartNfa_12(0, 0L, active1);
1258: }
1259:
1260: private final int jjMoveStringLiteralDfa2_12(long old1, long active1) {
1261: if (((active1 &= old1)) == 0L)
1262: return jjStartNfa_12(0, 0L, old1);
1263: try {
1264: curChar = input_stream.readChar();
1265: } catch (java.io.IOException e) {
1266: jjStopStringLiteralDfa_12(1, 0L, active1);
1267: return 2;
1268: }
1269: switch (curChar) {
1270: case 10:
1271: if ((active1 & 0x400000000000000L) != 0L)
1272: return jjStopAtPos(2, 122);
1273: break;
1274: default:
1275: break;
1276: }
1277: return jjStartNfa_12(1, 0L, active1);
1278: }
1279:
1280: private final int jjMoveNfa_12(int startState, int curPos) {
1281: int[] nextStates;
1282: int startsAt = 0;
1283: jjnewStateCnt = 4;
1284: int i = 1;
1285: jjstateSet[0] = startState;
1286: int j, kind = 0x7fffffff;
1287: for (;;) {
1288: if (++jjround == 0x7fffffff)
1289: ReInitRounds();
1290: if (curChar < 64) {
1291: long l = 1L << curChar;
1292: MatchLoop: do {
1293: switch (jjstateSet[--i]) {
1294: case 0:
1295: if ((0xffffffffffffdbffL & l) != 0L
1296: && kind > 129)
1297: kind = 129;
1298: break;
1299: case 2:
1300: if ((0x2400L & l) != 0L) {
1301: if (kind > 123)
1302: kind = 123;
1303: } else if (curChar == 34) {
1304: if (kind > 129)
1305: kind = 129;
1306: }
1307: break;
1308: case 3:
1309: if (curChar == 34 && kind > 129)
1310: kind = 129;
1311: break;
1312: default:
1313: break;
1314: }
1315: } while (i != startsAt);
1316: } else if (curChar < 128) {
1317: long l = 1L << (curChar & 077);
1318: MatchLoop: do {
1319: switch (jjstateSet[--i]) {
1320: case 0:
1321: if (kind > 129)
1322: kind = 129;
1323: if (curChar == 92)
1324: jjAddStates(3, 4);
1325: break;
1326: case 2:
1327: if (curChar == 92 && kind > 129)
1328: kind = 129;
1329: break;
1330: case 1:
1331: if (curChar == 92)
1332: jjAddStates(3, 4);
1333: break;
1334: default:
1335: break;
1336: }
1337: } while (i != startsAt);
1338: } else {
1339: int hiByte = (int) (curChar >> 8);
1340: int i1 = hiByte >> 6;
1341: long l1 = 1L << (hiByte & 077);
1342: int i2 = (curChar & 0xff) >> 6;
1343: long l2 = 1L << (curChar & 077);
1344: MatchLoop: do {
1345: switch (jjstateSet[--i]) {
1346: case 0:
1347: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
1348: && kind > 129)
1349: kind = 129;
1350: break;
1351: default:
1352: break;
1353: }
1354: } while (i != startsAt);
1355: }
1356: if (kind != 0x7fffffff) {
1357: jjmatchedKind = kind;
1358: jjmatchedPos = curPos;
1359: kind = 0x7fffffff;
1360: }
1361: ++curPos;
1362: if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1363: return curPos;
1364: try {
1365: curChar = input_stream.readChar();
1366: } catch (java.io.IOException e) {
1367: return curPos;
1368: }
1369: }
1370: }
1371:
1372: private final int jjMoveStringLiteralDfa0_17() {
1373: return 1;
1374: }
1375:
1376: private final int jjStopStringLiteralDfa_5(int pos, long active0) {
1377: switch (pos) {
1378: default:
1379: return -1;
1380: }
1381: }
1382:
1383: private final int jjStartNfa_5(int pos, long active0) {
1384: return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0),
1385: pos + 1);
1386: }
1387:
1388: private final int jjStartNfaWithStates_5(int pos, int kind,
1389: int state) {
1390: jjmatchedKind = kind;
1391: jjmatchedPos = pos;
1392: try {
1393: curChar = input_stream.readChar();
1394: } catch (java.io.IOException e) {
1395: return pos + 1;
1396: }
1397: return jjMoveNfa_5(state, pos + 1);
1398: }
1399:
1400: private final int jjMoveStringLiteralDfa0_5() {
1401: switch (curChar) {
1402: case 9:
1403: return jjStopAtPos(0, 9);
1404: case 12:
1405: return jjStopAtPos(0, 11);
1406: case 32:
1407: return jjStopAtPos(0, 10);
1408: default:
1409: return jjMoveNfa_5(1, 0);
1410: }
1411: }
1412:
1413: private final int jjMoveNfa_5(int startState, int curPos) {
1414: int[] nextStates;
1415: int startsAt = 0;
1416: jjnewStateCnt = 8;
1417: int i = 1;
1418: jjstateSet[0] = startState;
1419: int j, kind = 0x7fffffff;
1420: for (;;) {
1421: if (++jjround == 0x7fffffff)
1422: ReInitRounds();
1423: if (curChar < 64) {
1424: long l = 1L << curChar;
1425: MatchLoop: do {
1426: switch (jjstateSet[--i]) {
1427: case 1:
1428: if ((0x2400L & l) != 0L) {
1429: if (kind > 12)
1430: kind = 12;
1431: } else if (curChar == 35)
1432: jjCheckNAddStates(0, 2);
1433: if (curChar == 13)
1434: jjstateSet[jjnewStateCnt++] = 0;
1435: break;
1436: case 0:
1437: if (curChar == 10 && kind > 12)
1438: kind = 12;
1439: break;
1440: case 2:
1441: if ((0x2400L & l) != 0L && kind > 12)
1442: kind = 12;
1443: break;
1444: case 3:
1445: if (curChar == 35)
1446: jjCheckNAddStates(0, 2);
1447: break;
1448: case 4:
1449: if ((0xffffffffffffdbffL & l) != 0L)
1450: jjCheckNAddStates(0, 2);
1451: break;
1452: case 5:
1453: if (curChar == 10 && kind > 17)
1454: kind = 17;
1455: break;
1456: case 6:
1457: if (curChar == 13)
1458: jjstateSet[jjnewStateCnt++] = 5;
1459: break;
1460: case 7:
1461: if ((0x2400L & l) != 0L && kind > 17)
1462: kind = 17;
1463: break;
1464: default:
1465: break;
1466: }
1467: } while (i != startsAt);
1468: } else if (curChar < 128) {
1469: long l = 1L << (curChar & 077);
1470: MatchLoop: do {
1471: switch (jjstateSet[--i]) {
1472: case 4:
1473: jjAddStates(0, 2);
1474: break;
1475: default:
1476: break;
1477: }
1478: } while (i != startsAt);
1479: } else {
1480: int hiByte = (int) (curChar >> 8);
1481: int i1 = hiByte >> 6;
1482: long l1 = 1L << (hiByte & 077);
1483: int i2 = (curChar & 0xff) >> 6;
1484: long l2 = 1L << (curChar & 077);
1485: MatchLoop: do {
1486: switch (jjstateSet[--i]) {
1487: case 4:
1488: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1489: jjAddStates(0, 2);
1490: break;
1491: default:
1492: break;
1493: }
1494: } while (i != startsAt);
1495: }
1496: if (kind != 0x7fffffff) {
1497: jjmatchedKind = kind;
1498: jjmatchedPos = curPos;
1499: kind = 0x7fffffff;
1500: }
1501: ++curPos;
1502: if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
1503: return curPos;
1504: try {
1505: curChar = input_stream.readChar();
1506: } catch (java.io.IOException e) {
1507: return curPos;
1508: }
1509: }
1510: }
1511:
1512: private final int jjMoveStringLiteralDfa0_6() {
1513: switch (curChar) {
1514: case 60:
1515: return jjMoveStringLiteralDfa1_6(0x8000L);
1516: default:
1517: return 1;
1518: }
1519: }
1520:
1521: private final int jjMoveStringLiteralDfa1_6(long active0) {
1522: try {
1523: curChar = input_stream.readChar();
1524: } catch (java.io.IOException e) {
1525: return 1;
1526: }
1527: switch (curChar) {
1528: case 73:
1529: return jjMoveStringLiteralDfa2_6(active0, 0x8000L);
1530: default:
1531: return 2;
1532: }
1533: }
1534:
1535: private final int jjMoveStringLiteralDfa2_6(long old0, long active0) {
1536: if (((active0 &= old0)) == 0L)
1537: return 2;
1538: try {
1539: curChar = input_stream.readChar();
1540: } catch (java.io.IOException e) {
1541: return 2;
1542: }
1543: switch (curChar) {
1544: case 78:
1545: return jjMoveStringLiteralDfa3_6(active0, 0x8000L);
1546: default:
1547: return 3;
1548: }
1549: }
1550:
1551: private final int jjMoveStringLiteralDfa3_6(long old0, long active0) {
1552: if (((active0 &= old0)) == 0L)
1553: return 3;
1554: try {
1555: curChar = input_stream.readChar();
1556: } catch (java.io.IOException e) {
1557: return 3;
1558: }
1559: switch (curChar) {
1560: case 68:
1561: return jjMoveStringLiteralDfa4_6(active0, 0x8000L);
1562: default:
1563: return 4;
1564: }
1565: }
1566:
1567: private final int jjMoveStringLiteralDfa4_6(long old0, long active0) {
1568: if (((active0 &= old0)) == 0L)
1569: return 4;
1570: try {
1571: curChar = input_stream.readChar();
1572: } catch (java.io.IOException e) {
1573: return 4;
1574: }
1575: switch (curChar) {
1576: case 69:
1577: return jjMoveStringLiteralDfa5_6(active0, 0x8000L);
1578: default:
1579: return 5;
1580: }
1581: }
1582:
1583: private final int jjMoveStringLiteralDfa5_6(long old0, long active0) {
1584: if (((active0 &= old0)) == 0L)
1585: return 5;
1586: try {
1587: curChar = input_stream.readChar();
1588: } catch (java.io.IOException e) {
1589: return 5;
1590: }
1591: switch (curChar) {
1592: case 78:
1593: return jjMoveStringLiteralDfa6_6(active0, 0x8000L);
1594: default:
1595: return 6;
1596: }
1597: }
1598:
1599: private final int jjMoveStringLiteralDfa6_6(long old0, long active0) {
1600: if (((active0 &= old0)) == 0L)
1601: return 6;
1602: try {
1603: curChar = input_stream.readChar();
1604: } catch (java.io.IOException e) {
1605: return 6;
1606: }
1607: switch (curChar) {
1608: case 84:
1609: return jjMoveStringLiteralDfa7_6(active0, 0x8000L);
1610: default:
1611: return 7;
1612: }
1613: }
1614:
1615: private final int jjMoveStringLiteralDfa7_6(long old0, long active0) {
1616: if (((active0 &= old0)) == 0L)
1617: return 7;
1618: try {
1619: curChar = input_stream.readChar();
1620: } catch (java.io.IOException e) {
1621: return 7;
1622: }
1623: switch (curChar) {
1624: case 62:
1625: if ((active0 & 0x8000L) != 0L)
1626: return jjStopAtPos(7, 15);
1627: break;
1628: default:
1629: return 8;
1630: }
1631: return 8;
1632: }
1633:
1634: private final int jjMoveStringLiteralDfa0_3() {
1635: return 1;
1636: }
1637:
1638: private final int jjMoveStringLiteralDfa0_18() {
1639: return 1;
1640: }
1641:
1642: private final int jjStopStringLiteralDfa_0(int pos, long active0,
1643: long active1, long active2) {
1644: switch (pos) {
1645: case 0:
1646: if ((active0 & 0xe000000000000000L) != 0L
1647: || (active1 & 0x7bdffffL) != 0L) {
1648: jjmatchedKind = 91;
1649: return 10;
1650: }
1651: if ((active0 & 0x4000000L) != 0L)
1652: return 78;
1653: if ((active1 & 0x420000L) != 0L) {
1654: jjmatchedKind = 91;
1655: return 79;
1656: }
1657: return -1;
1658: case 1:
1659: if ((active0 & 0x2000000000000000L) != 0L
1660: || (active1 & 0x600000bL) != 0L)
1661: return 10;
1662: if ((active0 & 0xc000000000000000L) != 0L
1663: || (active1 & 0x1fffff4L) != 0L) {
1664: if (jjmatchedPos != 1) {
1665: jjmatchedKind = 91;
1666: jjmatchedPos = 1;
1667: }
1668: return 10;
1669: }
1670: return -1;
1671: case 2:
1672: if ((active1 & 0x3dffa74L) != 0L) {
1673: jjmatchedKind = 91;
1674: jjmatchedPos = 2;
1675: return 10;
1676: }
1677: if ((active0 & 0xc000000000000000L) != 0L
1678: || (active1 & 0x200580L) != 0L)
1679: return 10;
1680: return -1;
1681: case 3:
1682: if ((active1 & 0x1104030L) != 0L)
1683: return 10;
1684: if ((active1 & 0x2cfba44L) != 0L) {
1685: jjmatchedKind = 91;
1686: jjmatchedPos = 3;
1687: return 10;
1688: }
1689: return -1;
1690: case 4:
1691: if ((active1 & 0x44a840L) != 0L)
1692: return 10;
1693: if ((active1 & 0x28b1204L) != 0L) {
1694: jjmatchedKind = 91;
1695: jjmatchedPos = 4;
1696: return 10;
1697: }
1698: return -1;
1699: case 5:
1700: if ((active1 & 0x28a0204L) != 0L)
1701: return 10;
1702: if ((active1 & 0x11000L) != 0L) {
1703: jjmatchedKind = 91;
1704: jjmatchedPos = 5;
1705: return 10;
1706: }
1707: return -1;
1708: case 6:
1709: if ((active1 & 0x1000L) != 0L)
1710: return 10;
1711: if ((active1 & 0x10000L) != 0L) {
1712: jjmatchedKind = 91;
1713: jjmatchedPos = 6;
1714: return 10;
1715: }
1716: return -1;
1717: default:
1718: return -1;
1719: }
1720: }
1721:
1722: private final int jjStartNfa_0(int pos, long active0, long active1,
1723: long active2) {
1724: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
1725: active1, active2), pos + 1);
1726: }
1727:
1728: private final int jjStartNfaWithStates_0(int pos, int kind,
1729: int state) {
1730: jjmatchedKind = kind;
1731: jjmatchedPos = pos;
1732: try {
1733: curChar = input_stream.readChar();
1734: } catch (java.io.IOException e) {
1735: return pos + 1;
1736: }
1737: return jjMoveNfa_0(state, pos + 1);
1738: }
1739:
1740: private final int jjMoveStringLiteralDfa0_0() {
1741: switch (curChar) {
1742: case 33:
1743: return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L);
1744: case 37:
1745: jjmatchedKind = 36;
1746: return jjMoveStringLiteralDfa1_0(0x40000000000000L, 0x0L);
1747: case 38:
1748: jjmatchedKind = 40;
1749: return jjMoveStringLiteralDfa1_0(0x80000000000000L, 0x0L);
1750: case 40:
1751: return jjStopAtPos(0, 18);
1752: case 41:
1753: return jjStopAtPos(0, 19);
1754: case 42:
1755: jjmatchedKind = 30;
1756: return jjMoveStringLiteralDfa1_0(0x1008000200000000L, 0x0L);
1757: case 43:
1758: jjmatchedKind = 28;
1759: return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L);
1760: case 44:
1761: return jjStopAtPos(0, 25);
1762: case 45:
1763: jjmatchedKind = 29;
1764: return jjMoveStringLiteralDfa1_0(0x4000000000000L, 0x0L);
1765: case 46:
1766: return jjStartNfaWithStates_0(0, 26, 78);
1767: case 47:
1768: jjmatchedKind = 31;
1769: return jjMoveStringLiteralDfa1_0(0x30000100000000L, 0x0L);
1770: case 58:
1771: return jjStopAtPos(0, 27);
1772: case 59:
1773: return jjStopAtPos(0, 24);
1774: case 60:
1775: jjmatchedKind = 43;
1776: return jjMoveStringLiteralDfa1_0(0x400a00400000000L, 0x0L);
1777: case 61:
1778: jjmatchedKind = 41;
1779: return jjMoveStringLiteralDfa1_0(0x100000000000L, 0x0L);
1780: case 62:
1781: jjmatchedKind = 42;
1782: return jjMoveStringLiteralDfa1_0(0x800400800000000L, 0x0L);
1783: case 91:
1784: return jjStopAtPos(0, 22);
1785: case 93:
1786: return jjStopAtPos(0, 23);
1787: case 94:
1788: jjmatchedKind = 38;
1789: return jjMoveStringLiteralDfa1_0(0x200000000000000L, 0x0L);
1790: case 96:
1791: return jjStopAtPos(0, 135);
1792: case 97:
1793: return jjMoveStringLiteralDfa1_0(0x4000000000000000L,
1794: 0x6000000L);
1795: case 98:
1796: return jjMoveStringLiteralDfa1_0(0x0L, 0x8000L);
1797: case 99:
1798: return jjMoveStringLiteralDfa1_0(0x0L, 0x10800L);
1799: case 100:
1800: return jjMoveStringLiteralDfa1_0(0x0L, 0x200400L);
1801: case 101:
1802: return jjMoveStringLiteralDfa1_0(0x0L, 0x1000230L);
1803: case 102:
1804: return jjMoveStringLiteralDfa1_0(0x0L, 0x101080L);
1805: case 103:
1806: return jjMoveStringLiteralDfa1_0(0x0L, 0x800000L);
1807: case 105:
1808: return jjMoveStringLiteralDfa1_0(0x0L, 0x8000bL);
1809: case 108:
1810: return jjMoveStringLiteralDfa1_0(0x0L, 0x4L);
1811: case 110:
1812: return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x0L);
1813: case 111:
1814: return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
1815: case 112:
1816: return jjMoveStringLiteralDfa1_0(0x0L, 0x6000L);
1817: case 114:
1818: return jjMoveStringLiteralDfa1_0(0x0L, 0x420000L);
1819: case 116:
1820: return jjMoveStringLiteralDfa1_0(0x0L, 0x100L);
1821: case 119:
1822: return jjMoveStringLiteralDfa1_0(0x0L, 0x40L);
1823: case 121:
1824: return jjMoveStringLiteralDfa1_0(0x0L, 0x40000L);
1825: case 123:
1826: return jjStopAtPos(0, 20);
1827: case 124:
1828: jjmatchedKind = 39;
1829: return jjMoveStringLiteralDfa1_0(0x100000000000000L, 0x0L);
1830: case 125:
1831: return jjStopAtPos(0, 21);
1832: case 126:
1833: return jjStopAtPos(0, 37);
1834: default:
1835: return jjMoveNfa_0(0, 0);
1836: }
1837: }
1838:
1839: private final int jjMoveStringLiteralDfa1_0(long active0,
1840: long active1) {
1841: try {
1842: curChar = input_stream.readChar();
1843: } catch (java.io.IOException e) {
1844: jjStopStringLiteralDfa_0(0, active0, active1, 0L);
1845: return 1;
1846: }
1847: switch (curChar) {
1848: case 42:
1849: if ((active0 & 0x200000000L) != 0L) {
1850: jjmatchedKind = 33;
1851: jjmatchedPos = 1;
1852: }
1853: return jjMoveStringLiteralDfa2_0(active0,
1854: 0x1000000000000000L, active1, 0L);
1855: case 47:
1856: if ((active0 & 0x100000000L) != 0L) {
1857: jjmatchedKind = 32;
1858: jjmatchedPos = 1;
1859: }
1860: return jjMoveStringLiteralDfa2_0(active0,
1861: 0x20000000000000L, active1, 0L);
1862: case 60:
1863: if ((active0 & 0x400000000L) != 0L) {
1864: jjmatchedKind = 34;
1865: jjmatchedPos = 1;
1866: }
1867: return jjMoveStringLiteralDfa2_0(active0,
1868: 0x400000000000000L, active1, 0L);
1869: case 61:
1870: if ((active0 & 0x100000000000L) != 0L)
1871: return jjStopAtPos(1, 44);
1872: else if ((active0 & 0x200000000000L) != 0L)
1873: return jjStopAtPos(1, 45);
1874: else if ((active0 & 0x400000000000L) != 0L)
1875: return jjStopAtPos(1, 46);
1876: else if ((active0 & 0x1000000000000L) != 0L)
1877: return jjStopAtPos(1, 48);
1878: else if ((active0 & 0x2000000000000L) != 0L)
1879: return jjStopAtPos(1, 49);
1880: else if ((active0 & 0x4000000000000L) != 0L)
1881: return jjStopAtPos(1, 50);
1882: else if ((active0 & 0x8000000000000L) != 0L)
1883: return jjStopAtPos(1, 51);
1884: else if ((active0 & 0x10000000000000L) != 0L)
1885: return jjStopAtPos(1, 52);
1886: else if ((active0 & 0x40000000000000L) != 0L)
1887: return jjStopAtPos(1, 54);
1888: else if ((active0 & 0x80000000000000L) != 0L)
1889: return jjStopAtPos(1, 55);
1890: else if ((active0 & 0x100000000000000L) != 0L)
1891: return jjStopAtPos(1, 56);
1892: else if ((active0 & 0x200000000000000L) != 0L)
1893: return jjStopAtPos(1, 57);
1894: break;
1895: case 62:
1896: if ((active0 & 0x800000000L) != 0L) {
1897: jjmatchedKind = 35;
1898: jjmatchedPos = 1;
1899: } else if ((active0 & 0x800000000000L) != 0L)
1900: return jjStopAtPos(1, 47);
1901: return jjMoveStringLiteralDfa2_0(active0,
1902: 0x800000000000000L, active1, 0L);
1903: case 97:
1904: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
1905: 0x404004L);
1906: case 101:
1907: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
1908: 0x220400L);
1909: case 102:
1910: if ((active1 & 0x8L) != 0L)
1911: return jjStartNfaWithStates_0(1, 67, 10);
1912: break;
1913: case 104:
1914: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
1915: 0x40L);
1916: case 105:
1917: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
1918: 0x41000L);
1919: case 108:
1920: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
1921: 0x800830L);
1922: case 109:
1923: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
1924: 0x80000L);
1925: case 110:
1926: if ((active1 & 0x2L) != 0L)
1927: return jjStartNfaWithStates_0(1, 65, 10);
1928: return jjMoveStringLiteralDfa2_0(active0,
1929: 0x4000000000000000L, active1, 0L);
1930: case 111:
1931: return jjMoveStringLiteralDfa2_0(active0,
1932: 0x8000000000000000L, active1, 0x10080L);
1933: case 114:
1934: if ((active0 & 0x2000000000000000L) != 0L)
1935: return jjStartNfaWithStates_0(1, 61, 10);
1936: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
1937: 0x10a100L);
1938: case 115:
1939: if ((active1 & 0x1L) != 0L)
1940: return jjStartNfaWithStates_0(1, 64, 10);
1941: else if ((active1 & 0x4000000L) != 0L) {
1942: jjmatchedKind = 90;
1943: jjmatchedPos = 1;
1944: }
1945: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
1946: 0x2000000L);
1947: case 120:
1948: return jjMoveStringLiteralDfa2_0(active0, 0L, active1,
1949: 0x1000200L);
1950: default:
1951: break;
1952: }
1953: return jjStartNfa_0(0, active0, active1, 0L);
1954: }
1955:
1956: private final int jjMoveStringLiteralDfa2_0(long old0,
1957: long active0, long old1, long active1) {
1958: if (((active0 &= old0) | (active1 &= old1)) == 0L)
1959: return jjStartNfa_0(0, old0, old1, 0L);
1960: try {
1961: curChar = input_stream.readChar();
1962: } catch (java.io.IOException e) {
1963: jjStopStringLiteralDfa_0(1, active0, active1, 0L);
1964: return 2;
1965: }
1966: switch (curChar) {
1967: case 61:
1968: if ((active0 & 0x20000000000000L) != 0L)
1969: return jjStopAtPos(2, 53);
1970: else if ((active0 & 0x400000000000000L) != 0L)
1971: return jjStopAtPos(2, 58);
1972: else if ((active0 & 0x800000000000000L) != 0L)
1973: return jjStopAtPos(2, 59);
1974: else if ((active0 & 0x1000000000000000L) != 0L)
1975: return jjStopAtPos(2, 60);
1976: break;
1977: case 97:
1978: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
1979: 0x800L);
1980: case 99:
1981: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
1982: 0x200L);
1983: case 100:
1984: if ((active0 & 0x4000000000000000L) != 0L)
1985: return jjStartNfaWithStates_0(2, 62, 10);
1986: break;
1987: case 101:
1988: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
1989: 0x1048000L);
1990: case 102:
1991: if ((active1 & 0x400L) != 0L)
1992: return jjStartNfaWithStates_0(2, 74, 10);
1993: break;
1994: case 105:
1995: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
1996: 0x402060L);
1997: case 108:
1998: if ((active1 & 0x200000L) != 0L)
1999: return jjStartNfaWithStates_0(2, 85, 10);
2000: break;
2001: case 109:
2002: return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x4L);
2003: case 110:
2004: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
2005: 0x11000L);
2006: case 111:
2007: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
2008: 0x900000L);
2009: case 112:
2010: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
2011: 0x80000L);
2012: case 114:
2013: if ((active1 & 0x80L) != 0L)
2014: return jjStartNfaWithStates_0(2, 71, 10);
2015: break;
2016: case 115:
2017: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
2018: 0x2004010L);
2019: case 116:
2020: if ((active0 & 0x8000000000000000L) != 0L)
2021: return jjStartNfaWithStates_0(2, 63, 10);
2022: return jjMoveStringLiteralDfa3_0(active0, 0L, active1,
2023: 0x20000L);
2024: case 121:
2025: if ((active1 & 0x100L) != 0L)
2026: return jjStartNfaWithStates_0(2, 72, 10);
2027: break;
2028: default:
2029: break;
2030: }
2031: return jjStartNfa_0(1, active0, active1, 0L);
2032: }
2033:
2034: private final int jjMoveStringLiteralDfa3_0(long old0,
2035: long active0, long old1, long active1) {
2036: if (((active0 &= old0) | (active1 &= old1)) == 0L)
2037: return jjStartNfa_0(1, old0, old1, 0L);
2038: try {
2039: curChar = input_stream.readChar();
2040: } catch (java.io.IOException e) {
2041: jjStopStringLiteralDfa_0(2, 0L, active1, 0L);
2042: return 3;
2043: }
2044: switch (curChar) {
2045: case 97:
2046: return jjMoveStringLiteralDfa4_0(active1, 0x9000L);
2047: case 98:
2048: return jjMoveStringLiteralDfa4_0(active1, 0x800004L);
2049: case 99:
2050: if ((active1 & 0x1000000L) != 0L)
2051: return jjStartNfaWithStates_0(3, 88, 10);
2052: break;
2053: case 101:
2054: if ((active1 & 0x10L) != 0L)
2055: return jjStartNfaWithStates_0(3, 68, 10);
2056: return jjMoveStringLiteralDfa4_0(active1, 0x2000200L);
2057: case 102:
2058: if ((active1 & 0x20L) != 0L)
2059: return jjStartNfaWithStates_0(3, 69, 10);
2060: break;
2061: case 108:
2062: return jjMoveStringLiteralDfa4_0(active1, 0x40040L);
2063: case 109:
2064: if ((active1 & 0x100000L) != 0L)
2065: return jjStartNfaWithStates_0(3, 84, 10);
2066: break;
2067: case 110:
2068: return jjMoveStringLiteralDfa4_0(active1, 0x2000L);
2069: case 111:
2070: return jjMoveStringLiteralDfa4_0(active1, 0x80000L);
2071: case 115:
2072: if ((active1 & 0x4000L) != 0L)
2073: return jjStartNfaWithStates_0(3, 78, 10);
2074: return jjMoveStringLiteralDfa4_0(active1, 0x400800L);
2075: case 116:
2076: return jjMoveStringLiteralDfa4_0(active1, 0x10000L);
2077: case 117:
2078: return jjMoveStringLiteralDfa4_0(active1, 0x20000L);
2079: default:
2080: break;
2081: }
2082: return jjStartNfa_0(2, 0L, active1, 0L);
2083: }
2084:
2085: private final int jjMoveStringLiteralDfa4_0(long old1, long active1) {
2086: if (((active1 &= old1)) == 0L)
2087: return jjStartNfa_0(2, 0L, old1, 0L);
2088: try {
2089: curChar = input_stream.readChar();
2090: } catch (java.io.IOException e) {
2091: jjStopStringLiteralDfa_0(3, 0L, active1, 0L);
2092: return 4;
2093: }
2094: switch (curChar) {
2095: case 97:
2096: return jjMoveStringLiteralDfa5_0(active1, 0x800000L);
2097: case 100:
2098: if ((active1 & 0x40000L) != 0L)
2099: return jjStartNfaWithStates_0(4, 82, 10);
2100: return jjMoveStringLiteralDfa5_0(active1, 0x4L);
2101: case 101:
2102: if ((active1 & 0x40L) != 0L)
2103: return jjStartNfaWithStates_0(4, 70, 10);
2104: else if ((active1 & 0x400000L) != 0L)
2105: return jjStartNfaWithStates_0(4, 86, 10);
2106: break;
2107: case 105:
2108: return jjMoveStringLiteralDfa5_0(active1, 0x10000L);
2109: case 107:
2110: if ((active1 & 0x8000L) != 0L)
2111: return jjStartNfaWithStates_0(4, 79, 10);
2112: break;
2113: case 108:
2114: return jjMoveStringLiteralDfa5_0(active1, 0x1000L);
2115: case 112:
2116: return jjMoveStringLiteralDfa5_0(active1, 0x200L);
2117: case 114:
2118: return jjMoveStringLiteralDfa5_0(active1, 0x20a0000L);
2119: case 115:
2120: if ((active1 & 0x800L) != 0L)
2121: return jjStartNfaWithStates_0(4, 75, 10);
2122: break;
2123: case 116:
2124: if ((active1 & 0x2000L) != 0L)
2125: return jjStartNfaWithStates_0(4, 77, 10);
2126: break;
2127: default:
2128: break;
2129: }
2130: return jjStartNfa_0(3, 0L, active1, 0L);
2131: }
2132:
2133: private final int jjMoveStringLiteralDfa5_0(long old1, long active1) {
2134: if (((active1 &= old1)) == 0L)
2135: return jjStartNfa_0(3, 0L, old1, 0L);
2136: try {
2137: curChar = input_stream.readChar();
2138: } catch (java.io.IOException e) {
2139: jjStopStringLiteralDfa_0(4, 0L, active1, 0L);
2140: return 5;
2141: }
2142: switch (curChar) {
2143: case 97:
2144: if ((active1 & 0x4L) != 0L)
2145: return jjStartNfaWithStates_0(5, 66, 10);
2146: break;
2147: case 108:
2148: if ((active1 & 0x800000L) != 0L)
2149: return jjStartNfaWithStates_0(5, 87, 10);
2150: return jjMoveStringLiteralDfa6_0(active1, 0x1000L);
2151: case 110:
2152: if ((active1 & 0x20000L) != 0L)
2153: return jjStartNfaWithStates_0(5, 81, 10);
2154: return jjMoveStringLiteralDfa6_0(active1, 0x10000L);
2155: case 116:
2156: if ((active1 & 0x200L) != 0L)
2157: return jjStartNfaWithStates_0(5, 73, 10);
2158: else if ((active1 & 0x80000L) != 0L)
2159: return jjStartNfaWithStates_0(5, 83, 10);
2160: else if ((active1 & 0x2000000L) != 0L)
2161: return jjStartNfaWithStates_0(5, 89, 10);
2162: break;
2163: default:
2164: break;
2165: }
2166: return jjStartNfa_0(4, 0L, active1, 0L);
2167: }
2168:
2169: private final int jjMoveStringLiteralDfa6_0(long old1, long active1) {
2170: if (((active1 &= old1)) == 0L)
2171: return jjStartNfa_0(4, 0L, old1, 0L);
2172: try {
2173: curChar = input_stream.readChar();
2174: } catch (java.io.IOException e) {
2175: jjStopStringLiteralDfa_0(5, 0L, active1, 0L);
2176: return 6;
2177: }
2178: switch (curChar) {
2179: case 117:
2180: return jjMoveStringLiteralDfa7_0(active1, 0x10000L);
2181: case 121:
2182: if ((active1 & 0x1000L) != 0L)
2183: return jjStartNfaWithStates_0(6, 76, 10);
2184: break;
2185: default:
2186: break;
2187: }
2188: return jjStartNfa_0(5, 0L, active1, 0L);
2189: }
2190:
2191: private final int jjMoveStringLiteralDfa7_0(long old1, long active1) {
2192: if (((active1 &= old1)) == 0L)
2193: return jjStartNfa_0(5, 0L, old1, 0L);
2194: try {
2195: curChar = input_stream.readChar();
2196: } catch (java.io.IOException e) {
2197: jjStopStringLiteralDfa_0(6, 0L, active1, 0L);
2198: return 7;
2199: }
2200: switch (curChar) {
2201: case 101:
2202: if ((active1 & 0x10000L) != 0L)
2203: return jjStartNfaWithStates_0(7, 80, 10);
2204: break;
2205: default:
2206: break;
2207: }
2208: return jjStartNfa_0(6, 0L, active1, 0L);
2209: }
2210:
2211: private final int jjMoveNfa_0(int startState, int curPos) {
2212: int[] nextStates;
2213: int startsAt = 0;
2214: jjnewStateCnt = 78;
2215: int i = 1;
2216: jjstateSet[0] = startState;
2217: int j, kind = 0x7fffffff;
2218: for (;;) {
2219: if (++jjround == 0x7fffffff)
2220: ReInitRounds();
2221: if (curChar < 64) {
2222: long l = 1L << curChar;
2223: MatchLoop: do {
2224: switch (jjstateSet[--i]) {
2225: case 78:
2226: if ((0x3ff000000000000L & l) != 0L)
2227: jjCheckNAddStates(5, 7);
2228: if ((0x3ff000000000000L & l) != 0L) {
2229: if (kind > 96)
2230: kind = 96;
2231: jjCheckNAddTwoStates(35, 36);
2232: }
2233: break;
2234: case 79:
2235: if ((0x3ff000000000000L & l) != 0L) {
2236: if (kind > 91)
2237: kind = 91;
2238: jjCheckNAdd(10);
2239: } else if (curChar == 34)
2240: jjstateSet[jjnewStateCnt++] = 17;
2241: else if (curChar == 39)
2242: jjstateSet[jjnewStateCnt++] = 14;
2243: if (curChar == 34) {
2244: if (kind > 105)
2245: kind = 105;
2246: } else if (curChar == 39) {
2247: if (kind > 104)
2248: kind = 104;
2249: }
2250: break;
2251: case 0:
2252: if ((0x3ff000000000000L & l) != 0L)
2253: jjCheckNAddStates(8, 15);
2254: else if ((0x2400L & l) != 0L) {
2255: if (kind > 5)
2256: kind = 5;
2257: } else if (curChar == 46)
2258: jjCheckNAddTwoStates(35, 39);
2259: else if (curChar == 34)
2260: jjstateSet[jjnewStateCnt++] = 17;
2261: else if (curChar == 39)
2262: jjstateSet[jjnewStateCnt++] = 14;
2263: else if (curChar == 35) {
2264: if (kind > 16)
2265: kind = 16;
2266: jjCheckNAdd(8);
2267: }
2268: if ((0x3fe000000000000L & l) != 0L) {
2269: if (kind > 93)
2270: kind = 93;
2271: jjCheckNAddStates(16, 20);
2272: } else if (curChar == 48) {
2273: if (kind > 93)
2274: kind = 93;
2275: jjCheckNAddStates(21, 26);
2276: } else if (curChar == 34) {
2277: if (kind > 105)
2278: kind = 105;
2279: } else if (curChar == 39) {
2280: if (kind > 104)
2281: kind = 104;
2282: } else if (curChar == 13)
2283: jjstateSet[jjnewStateCnt++] = 4;
2284: break;
2285: case 1:
2286: if (curChar == 10 && kind > 4)
2287: kind = 4;
2288: break;
2289: case 2:
2290: if (curChar == 13)
2291: jjstateSet[jjnewStateCnt++] = 1;
2292: break;
2293: case 3:
2294: if ((0x2400L & l) != 0L && kind > 4)
2295: kind = 4;
2296: break;
2297: case 4:
2298: if (curChar == 10 && kind > 5)
2299: kind = 5;
2300: break;
2301: case 5:
2302: if (curChar == 13)
2303: jjstateSet[jjnewStateCnt++] = 4;
2304: break;
2305: case 6:
2306: if ((0x2400L & l) != 0L && kind > 5)
2307: kind = 5;
2308: break;
2309: case 7:
2310: if (curChar != 35)
2311: break;
2312: if (kind > 16)
2313: kind = 16;
2314: jjCheckNAdd(8);
2315: break;
2316: case 8:
2317: if ((0xffffffffffffdbffL & l) == 0L)
2318: break;
2319: if (kind > 16)
2320: kind = 16;
2321: jjCheckNAdd(8);
2322: break;
2323: case 10:
2324: if ((0x3ff000000000000L & l) == 0L)
2325: break;
2326: if (kind > 91)
2327: kind = 91;
2328: jjCheckNAdd(10);
2329: break;
2330: case 11:
2331: if (curChar == 39 && kind > 104)
2332: kind = 104;
2333: break;
2334: case 12:
2335: if (curChar == 34 && kind > 105)
2336: kind = 105;
2337: break;
2338: case 13:
2339: if (curChar == 39 && kind > 106)
2340: kind = 106;
2341: break;
2342: case 14:
2343: if (curChar == 39)
2344: jjstateSet[jjnewStateCnt++] = 13;
2345: break;
2346: case 15:
2347: if (curChar == 39)
2348: jjstateSet[jjnewStateCnt++] = 14;
2349: break;
2350: case 16:
2351: if (curChar == 34 && kind > 107)
2352: kind = 107;
2353: break;
2354: case 17:
2355: if (curChar == 34)
2356: jjstateSet[jjnewStateCnt++] = 16;
2357: break;
2358: case 18:
2359: if (curChar == 34)
2360: jjstateSet[jjnewStateCnt++] = 17;
2361: break;
2362: case 19:
2363: if ((0x3fe000000000000L & l) == 0L)
2364: break;
2365: if (kind > 93)
2366: kind = 93;
2367: jjCheckNAddStates(16, 20);
2368: break;
2369: case 20:
2370: if ((0x3ff000000000000L & l) == 0L)
2371: break;
2372: if (kind > 93)
2373: kind = 93;
2374: jjCheckNAddTwoStates(20, 21);
2375: break;
2376: case 22:
2377: if ((0x3ff000000000000L & l) != 0L)
2378: jjCheckNAddStates(27, 29);
2379: break;
2380: case 25:
2381: if (curChar != 48)
2382: break;
2383: if (kind > 93)
2384: kind = 93;
2385: jjCheckNAddStates(21, 26);
2386: break;
2387: case 27:
2388: if ((0x3ff000000000000L & l) == 0L)
2389: break;
2390: if (kind > 94)
2391: kind = 94;
2392: jjAddStates(30, 31);
2393: break;
2394: case 29:
2395: if ((0xff000000000000L & l) == 0L)
2396: break;
2397: if (kind > 95)
2398: kind = 95;
2399: jjCheckNAddTwoStates(29, 30);
2400: break;
2401: case 31:
2402: if ((0x3fe000000000000L & l) != 0L)
2403: jjCheckNAddStates(32, 34);
2404: break;
2405: case 32:
2406: if ((0x3ff000000000000L & l) != 0L)
2407: jjCheckNAddStates(32, 34);
2408: break;
2409: case 33:
2410: if (curChar == 48)
2411: jjCheckNAdd(24);
2412: break;
2413: case 34:
2414: if (curChar == 46)
2415: jjCheckNAddTwoStates(35, 39);
2416: break;
2417: case 35:
2418: if ((0x3ff000000000000L & l) == 0L)
2419: break;
2420: if (kind > 96)
2421: kind = 96;
2422: jjCheckNAddTwoStates(35, 36);
2423: break;
2424: case 37:
2425: if ((0x280000000000L & l) != 0L)
2426: jjCheckNAdd(38);
2427: break;
2428: case 38:
2429: if ((0x3ff000000000000L & l) == 0L)
2430: break;
2431: if (kind > 96)
2432: kind = 96;
2433: jjCheckNAdd(38);
2434: break;
2435: case 39:
2436: if ((0x3ff000000000000L & l) != 0L)
2437: jjCheckNAddStates(5, 7);
2438: break;
2439: case 41:
2440: if ((0x280000000000L & l) != 0L)
2441: jjCheckNAdd(42);
2442: break;
2443: case 42:
2444: if ((0x3ff000000000000L & l) != 0L)
2445: jjCheckNAddTwoStates(42, 24);
2446: break;
2447: case 45:
2448: if (curChar == 39 && kind > 100)
2449: kind = 100;
2450: break;
2451: case 47:
2452: if (curChar == 34 && kind > 101)
2453: kind = 101;
2454: break;
2455: case 49:
2456: if (curChar == 39 && kind > 102)
2457: kind = 102;
2458: break;
2459: case 50:
2460: if (curChar == 39)
2461: jjstateSet[jjnewStateCnt++] = 49;
2462: break;
2463: case 51:
2464: if (curChar == 39)
2465: jjstateSet[jjnewStateCnt++] = 50;
2466: break;
2467: case 53:
2468: if (curChar == 34 && kind > 103)
2469: kind = 103;
2470: break;
2471: case 54:
2472: if (curChar == 34)
2473: jjstateSet[jjnewStateCnt++] = 53;
2474: break;
2475: case 55:
2476: if (curChar == 34)
2477: jjstateSet[jjnewStateCnt++] = 54;
2478: break;
2479: case 57:
2480: if ((0x3ff000000000000L & l) != 0L)
2481: jjCheckNAddStates(8, 15);
2482: break;
2483: case 58:
2484: if ((0x3ff000000000000L & l) != 0L)
2485: jjCheckNAddTwoStates(58, 59);
2486: break;
2487: case 59:
2488: if (curChar != 46)
2489: break;
2490: if (kind > 96)
2491: kind = 96;
2492: jjCheckNAddTwoStates(60, 61);
2493: break;
2494: case 60:
2495: if ((0x3ff000000000000L & l) == 0L)
2496: break;
2497: if (kind > 96)
2498: kind = 96;
2499: jjCheckNAddTwoStates(60, 61);
2500: break;
2501: case 62:
2502: if ((0x280000000000L & l) != 0L)
2503: jjCheckNAdd(63);
2504: break;
2505: case 63:
2506: if ((0x3ff000000000000L & l) == 0L)
2507: break;
2508: if (kind > 96)
2509: kind = 96;
2510: jjCheckNAdd(63);
2511: break;
2512: case 64:
2513: if ((0x3ff000000000000L & l) != 0L)
2514: jjCheckNAddTwoStates(64, 65);
2515: break;
2516: case 66:
2517: if ((0x280000000000L & l) != 0L)
2518: jjCheckNAdd(67);
2519: break;
2520: case 67:
2521: if ((0x3ff000000000000L & l) == 0L)
2522: break;
2523: if (kind > 96)
2524: kind = 96;
2525: jjCheckNAdd(67);
2526: break;
2527: case 68:
2528: if ((0x3ff000000000000L & l) != 0L)
2529: jjCheckNAddTwoStates(68, 69);
2530: break;
2531: case 70:
2532: if ((0x280000000000L & l) != 0L)
2533: jjCheckNAdd(71);
2534: break;
2535: case 71:
2536: if ((0x3ff000000000000L & l) != 0L)
2537: jjCheckNAddTwoStates(71, 24);
2538: break;
2539: case 72:
2540: if ((0x3ff000000000000L & l) != 0L)
2541: jjCheckNAddTwoStates(72, 73);
2542: break;
2543: case 73:
2544: if (curChar == 46)
2545: jjCheckNAddStates(35, 37);
2546: break;
2547: case 74:
2548: if ((0x3ff000000000000L & l) != 0L)
2549: jjCheckNAddStates(35, 37);
2550: break;
2551: case 76:
2552: if ((0x280000000000L & l) != 0L)
2553: jjCheckNAdd(77);
2554: break;
2555: case 77:
2556: if ((0x3ff000000000000L & l) != 0L)
2557: jjCheckNAddTwoStates(77, 24);
2558: break;
2559: default:
2560: break;
2561: }
2562: } while (i != startsAt);
2563: } else if (curChar < 128) {
2564: long l = 1L << (curChar & 077);
2565: MatchLoop: do {
2566: switch (jjstateSet[--i]) {
2567: case 79:
2568: case 10:
2569: if ((0x7fffffe87fffffeL & l) == 0L)
2570: break;
2571: if (kind > 91)
2572: kind = 91;
2573: jjCheckNAdd(10);
2574: break;
2575: case 0:
2576: if ((0x7fffffe87fffffeL & l) != 0L) {
2577: if (kind > 91)
2578: kind = 91;
2579: jjCheckNAdd(10);
2580: } else if (curChar == 92)
2581: jjAddStates(3, 4);
2582: if ((0x4000000040000L & l) != 0L)
2583: jjAddStates(38, 41);
2584: else if ((0x20000000200000L & l) != 0L)
2585: jjCheckNAddStates(42, 49);
2586: break;
2587: case 8:
2588: if (kind > 16)
2589: kind = 16;
2590: jjstateSet[jjnewStateCnt++] = 8;
2591: break;
2592: case 9:
2593: if ((0x7fffffe87fffffeL & l) == 0L)
2594: break;
2595: if (kind > 91)
2596: kind = 91;
2597: jjCheckNAdd(10);
2598: break;
2599: case 21:
2600: if ((0x100000001000L & l) != 0L && kind > 93)
2601: kind = 93;
2602: break;
2603: case 23:
2604: if ((0x100000001000L & l) != 0L)
2605: jjstateSet[jjnewStateCnt++] = 24;
2606: break;
2607: case 24:
2608: if ((0x40000000400L & l) != 0L && kind > 97)
2609: kind = 97;
2610: break;
2611: case 26:
2612: if ((0x100000001000000L & l) != 0L)
2613: jjCheckNAdd(27);
2614: break;
2615: case 27:
2616: if ((0x7e0000007eL & l) == 0L)
2617: break;
2618: if (kind > 94)
2619: kind = 94;
2620: jjCheckNAddTwoStates(27, 28);
2621: break;
2622: case 28:
2623: if ((0x100000001000L & l) != 0L && kind > 94)
2624: kind = 94;
2625: break;
2626: case 30:
2627: if ((0x100000001000L & l) != 0L && kind > 95)
2628: kind = 95;
2629: break;
2630: case 36:
2631: if ((0x2000000020L & l) != 0L)
2632: jjAddStates(50, 51);
2633: break;
2634: case 40:
2635: if ((0x2000000020L & l) != 0L)
2636: jjAddStates(52, 53);
2637: break;
2638: case 43:
2639: if ((0x20000000200000L & l) != 0L)
2640: jjCheckNAddStates(42, 49);
2641: break;
2642: case 44:
2643: if ((0x4000000040000L & l) != 0L)
2644: jjCheckNAdd(45);
2645: break;
2646: case 46:
2647: if ((0x4000000040000L & l) != 0L)
2648: jjCheckNAdd(47);
2649: break;
2650: case 48:
2651: if ((0x4000000040000L & l) != 0L)
2652: jjCheckNAdd(51);
2653: break;
2654: case 52:
2655: if ((0x4000000040000L & l) != 0L)
2656: jjCheckNAdd(55);
2657: break;
2658: case 56:
2659: if ((0x4000000040000L & l) != 0L)
2660: jjAddStates(38, 41);
2661: break;
2662: case 61:
2663: if ((0x2000000020L & l) != 0L)
2664: jjAddStates(54, 55);
2665: break;
2666: case 65:
2667: if ((0x2000000020L & l) != 0L)
2668: jjAddStates(56, 57);
2669: break;
2670: case 69:
2671: if ((0x2000000020L & l) != 0L)
2672: jjAddStates(58, 59);
2673: break;
2674: case 75:
2675: if ((0x2000000020L & l) != 0L)
2676: jjAddStates(60, 61);
2677: break;
2678: default:
2679: break;
2680: }
2681: } while (i != startsAt);
2682: } else {
2683: int hiByte = (int) (curChar >> 8);
2684: int i1 = hiByte >> 6;
2685: long l1 = 1L << (hiByte & 077);
2686: int i2 = (curChar & 0xff) >> 6;
2687: long l2 = 1L << (curChar & 077);
2688: MatchLoop: do {
2689: switch (jjstateSet[--i]) {
2690: case 8:
2691: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2692: break;
2693: if (kind > 16)
2694: kind = 16;
2695: jjstateSet[jjnewStateCnt++] = 8;
2696: break;
2697: default:
2698: break;
2699: }
2700: } while (i != startsAt);
2701: }
2702: if (kind != 0x7fffffff) {
2703: jjmatchedKind = kind;
2704: jjmatchedPos = curPos;
2705: kind = 0x7fffffff;
2706: }
2707: ++curPos;
2708: if ((i = jjnewStateCnt) == (startsAt = 78 - (jjnewStateCnt = startsAt)))
2709: return curPos;
2710: try {
2711: curChar = input_stream.readChar();
2712: } catch (java.io.IOException e) {
2713: return curPos;
2714: }
2715: }
2716: }
2717:
2718: private final int jjStopStringLiteralDfa_9(int pos, long active0,
2719: long active1, long active2) {
2720: switch (pos) {
2721: case 0:
2722: if ((active1 & 0x400000000000L) != 0L) {
2723: jjmatchedKind = 133;
2724: return -1;
2725: }
2726: return -1;
2727: case 1:
2728: if ((active1 & 0x400000000000L) != 0L) {
2729: if (jjmatchedPos == 0) {
2730: jjmatchedKind = 133;
2731: jjmatchedPos = 0;
2732: }
2733: return -1;
2734: }
2735: return -1;
2736: default:
2737: return -1;
2738: }
2739: }
2740:
2741: private final int jjStartNfa_9(int pos, long active0, long active1,
2742: long active2) {
2743: return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0,
2744: active1, active2), pos + 1);
2745: }
2746:
2747: private final int jjStartNfaWithStates_9(int pos, int kind,
2748: int state) {
2749: jjmatchedKind = kind;
2750: jjmatchedPos = pos;
2751: try {
2752: curChar = input_stream.readChar();
2753: } catch (java.io.IOException e) {
2754: return pos + 1;
2755: }
2756: return jjMoveNfa_9(state, pos + 1);
2757: }
2758:
2759: private final int jjMoveStringLiteralDfa0_9() {
2760: switch (curChar) {
2761: case 10:
2762: return jjStopAtPos(0, 131);
2763: case 13:
2764: jjmatchedKind = 132;
2765: return jjMoveStringLiteralDfa1_9(0x0L, 0x4L);
2766: case 39:
2767: return jjMoveStringLiteralDfa1_9(0x400000000000L, 0x0L);
2768: default:
2769: return jjMoveNfa_9(0, 0);
2770: }
2771: }
2772:
2773: private final int jjMoveStringLiteralDfa1_9(long active1,
2774: long active2) {
2775: try {
2776: curChar = input_stream.readChar();
2777: } catch (java.io.IOException e) {
2778: jjStopStringLiteralDfa_9(0, 0L, active1, active2);
2779: return 1;
2780: }
2781: switch (curChar) {
2782: case 10:
2783: if ((active2 & 0x4L) != 0L)
2784: return jjStopAtPos(1, 130);
2785: break;
2786: case 39:
2787: return jjMoveStringLiteralDfa2_9(active1, 0x400000000000L,
2788: active2, 0L);
2789: default:
2790: break;
2791: }
2792: return jjStartNfa_9(0, 0L, active1, active2);
2793: }
2794:
2795: private final int jjMoveStringLiteralDfa2_9(long old1,
2796: long active1, long old2, long active2) {
2797: if (((active1 &= old1) | (active2 &= old2)) == 0L)
2798: return jjStartNfa_9(0, 0L, old1, old2);
2799: try {
2800: curChar = input_stream.readChar();
2801: } catch (java.io.IOException e) {
2802: jjStopStringLiteralDfa_9(1, 0L, active1, 0L);
2803: return 2;
2804: }
2805: switch (curChar) {
2806: case 39:
2807: if ((active1 & 0x400000000000L) != 0L)
2808: return jjStopAtPos(2, 110);
2809: break;
2810: default:
2811: break;
2812: }
2813: return jjStartNfa_9(1, 0L, active1, 0L);
2814: }
2815:
2816: private final int jjMoveNfa_9(int startState, int curPos) {
2817: int[] nextStates;
2818: int startsAt = 0;
2819: jjnewStateCnt = 3;
2820: int i = 1;
2821: jjstateSet[0] = startState;
2822: int j, kind = 0x7fffffff;
2823: for (;;) {
2824: if (++jjround == 0x7fffffff)
2825: ReInitRounds();
2826: if (curChar < 64) {
2827: long l = 1L << curChar;
2828: MatchLoop: do {
2829: switch (jjstateSet[--i]) {
2830: case 0:
2831: if ((0xffffffffffffdbffL & l) != 0L
2832: && kind > 133)
2833: kind = 133;
2834: break;
2835: case 2:
2836: if ((0xffffffffffffdbffL & l) != 0L
2837: && kind > 134)
2838: kind = 134;
2839: break;
2840: default:
2841: break;
2842: }
2843: } while (i != startsAt);
2844: } else if (curChar < 128) {
2845: long l = 1L << (curChar & 077);
2846: MatchLoop: do {
2847: switch (jjstateSet[--i]) {
2848: case 0:
2849: if (kind > 133)
2850: kind = 133;
2851: if (curChar == 92)
2852: jjstateSet[jjnewStateCnt++] = 2;
2853: break;
2854: case 1:
2855: if (curChar == 92)
2856: jjstateSet[jjnewStateCnt++] = 2;
2857: break;
2858: case 2:
2859: if (kind > 134)
2860: kind = 134;
2861: break;
2862: default:
2863: break;
2864: }
2865: } while (i != startsAt);
2866: } else {
2867: int hiByte = (int) (curChar >> 8);
2868: int i1 = hiByte >> 6;
2869: long l1 = 1L << (hiByte & 077);
2870: int i2 = (curChar & 0xff) >> 6;
2871: long l2 = 1L << (curChar & 077);
2872: MatchLoop: do {
2873: switch (jjstateSet[--i]) {
2874: case 0:
2875: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
2876: && kind > 133)
2877: kind = 133;
2878: break;
2879: case 2:
2880: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
2881: && kind > 134)
2882: kind = 134;
2883: break;
2884: default:
2885: break;
2886: }
2887: } while (i != startsAt);
2888: }
2889: if (kind != 0x7fffffff) {
2890: jjmatchedKind = kind;
2891: jjmatchedPos = curPos;
2892: kind = 0x7fffffff;
2893: }
2894: ++curPos;
2895: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
2896: return curPos;
2897: try {
2898: curChar = input_stream.readChar();
2899: } catch (java.io.IOException e) {
2900: return curPos;
2901: }
2902: }
2903: }
2904:
2905: private final int jjMoveStringLiteralDfa0_2() {
2906: return jjMoveNfa_2(0, 0);
2907: }
2908:
2909: private final int jjMoveNfa_2(int startState, int curPos) {
2910: int[] nextStates;
2911: int startsAt = 0;
2912: jjnewStateCnt = 1;
2913: int i = 1;
2914: jjstateSet[0] = startState;
2915: int j, kind = 0x7fffffff;
2916: for (;;) {
2917: if (++jjround == 0x7fffffff)
2918: ReInitRounds();
2919: if (curChar < 64) {
2920: long l = 1L << curChar;
2921: MatchLoop: do {
2922: switch (jjstateSet[--i]) {
2923: case 0:
2924: if ((0x2400L & l) != 0L)
2925: kind = 7;
2926: break;
2927: default:
2928: break;
2929: }
2930: } while (i != startsAt);
2931: } else if (curChar < 128) {
2932: long l = 1L << (curChar & 077);
2933: MatchLoop: do {
2934: switch (jjstateSet[--i]) {
2935: default:
2936: break;
2937: }
2938: } while (i != startsAt);
2939: } else {
2940: int hiByte = (int) (curChar >> 8);
2941: int i1 = hiByte >> 6;
2942: long l1 = 1L << (hiByte & 077);
2943: int i2 = (curChar & 0xff) >> 6;
2944: long l2 = 1L << (curChar & 077);
2945: MatchLoop: do {
2946: switch (jjstateSet[--i]) {
2947: default:
2948: break;
2949: }
2950: } while (i != startsAt);
2951: }
2952: if (kind != 0x7fffffff) {
2953: jjmatchedKind = kind;
2954: jjmatchedPos = curPos;
2955: kind = 0x7fffffff;
2956: }
2957: ++curPos;
2958: if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
2959: return curPos;
2960: try {
2961: curChar = input_stream.readChar();
2962: } catch (java.io.IOException e) {
2963: return curPos;
2964: }
2965: }
2966: }
2967:
2968: private final int jjMoveStringLiteralDfa0_1() {
2969: return jjMoveNfa_1(0, 0);
2970: }
2971:
2972: private final int jjMoveNfa_1(int startState, int curPos) {
2973: int[] nextStates;
2974: int startsAt = 0;
2975: jjnewStateCnt = 1;
2976: int i = 1;
2977: jjstateSet[0] = startState;
2978: int j, kind = 0x7fffffff;
2979: for (;;) {
2980: if (++jjround == 0x7fffffff)
2981: ReInitRounds();
2982: if (curChar < 64) {
2983: long l = 1L << curChar;
2984: MatchLoop: do {
2985: switch (jjstateSet[--i]) {
2986: case 0:
2987: if ((0x2400L & l) != 0L)
2988: kind = 6;
2989: break;
2990: default:
2991: break;
2992: }
2993: } while (i != startsAt);
2994: } else if (curChar < 128) {
2995: long l = 1L << (curChar & 077);
2996: MatchLoop: do {
2997: switch (jjstateSet[--i]) {
2998: default:
2999: break;
3000: }
3001: } while (i != startsAt);
3002: } else {
3003: int hiByte = (int) (curChar >> 8);
3004: int i1 = hiByte >> 6;
3005: long l1 = 1L << (hiByte & 077);
3006: int i2 = (curChar & 0xff) >> 6;
3007: long l2 = 1L << (curChar & 077);
3008: MatchLoop: do {
3009: switch (jjstateSet[--i]) {
3010: default:
3011: break;
3012: }
3013: } while (i != startsAt);
3014: }
3015: if (kind != 0x7fffffff) {
3016: jjmatchedKind = kind;
3017: jjmatchedPos = curPos;
3018: kind = 0x7fffffff;
3019: }
3020: ++curPos;
3021: if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
3022: return curPos;
3023: try {
3024: curChar = input_stream.readChar();
3025: } catch (java.io.IOException e) {
3026: return curPos;
3027: }
3028: }
3029: }
3030:
3031: private final int jjStopStringLiteralDfa_7(int pos, long active0,
3032: long active1) {
3033: switch (pos) {
3034: case 0:
3035: if ((active1 & 0x10000000000000L) != 0L) {
3036: jjmatchedKind = 128;
3037: return 2;
3038: }
3039: return -1;
3040: case 1:
3041: if ((active1 & 0x10000000000000L) != 0L) {
3042: jjmatchedKind = 117;
3043: jjmatchedPos = 1;
3044: return -1;
3045: }
3046: return -1;
3047: default:
3048: return -1;
3049: }
3050: }
3051:
3052: private final int jjStartNfa_7(int pos, long active0, long active1) {
3053: return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0,
3054: active1), pos + 1);
3055: }
3056:
3057: private final int jjStartNfaWithStates_7(int pos, int kind,
3058: int state) {
3059: jjmatchedKind = kind;
3060: jjmatchedPos = pos;
3061: try {
3062: curChar = input_stream.readChar();
3063: } catch (java.io.IOException e) {
3064: return pos + 1;
3065: }
3066: return jjMoveNfa_7(state, pos + 1);
3067: }
3068:
3069: private final int jjMoveStringLiteralDfa0_7() {
3070: switch (curChar) {
3071: case 39:
3072: return jjStopAtPos(0, 108);
3073: case 92:
3074: return jjMoveStringLiteralDfa1_7(0x10000000000000L);
3075: default:
3076: return jjMoveNfa_7(0, 0);
3077: }
3078: }
3079:
3080: private final int jjMoveStringLiteralDfa1_7(long active1) {
3081: try {
3082: curChar = input_stream.readChar();
3083: } catch (java.io.IOException e) {
3084: jjStopStringLiteralDfa_7(0, 0L, active1);
3085: return 1;
3086: }
3087: switch (curChar) {
3088: case 13:
3089: return jjMoveStringLiteralDfa2_7(active1, 0x10000000000000L);
3090: default:
3091: break;
3092: }
3093: return jjStartNfa_7(0, 0L, active1);
3094: }
3095:
3096: private final int jjMoveStringLiteralDfa2_7(long old1, long active1) {
3097: if (((active1 &= old1)) == 0L)
3098: return jjStartNfa_7(0, 0L, old1);
3099: try {
3100: curChar = input_stream.readChar();
3101: } catch (java.io.IOException e) {
3102: jjStopStringLiteralDfa_7(1, 0L, active1);
3103: return 2;
3104: }
3105: switch (curChar) {
3106: case 10:
3107: if ((active1 & 0x10000000000000L) != 0L)
3108: return jjStopAtPos(2, 116);
3109: break;
3110: default:
3111: break;
3112: }
3113: return jjStartNfa_7(1, 0L, active1);
3114: }
3115:
3116: private final int jjMoveNfa_7(int startState, int curPos) {
3117: int[] nextStates;
3118: int startsAt = 0;
3119: jjnewStateCnt = 4;
3120: int i = 1;
3121: jjstateSet[0] = startState;
3122: int j, kind = 0x7fffffff;
3123: for (;;) {
3124: if (++jjround == 0x7fffffff)
3125: ReInitRounds();
3126: if (curChar < 64) {
3127: long l = 1L << curChar;
3128: MatchLoop: do {
3129: switch (jjstateSet[--i]) {
3130: case 0:
3131: if ((0xffffffffffffdbffL & l) != 0L
3132: && kind > 128)
3133: kind = 128;
3134: break;
3135: case 2:
3136: if ((0x2400L & l) != 0L) {
3137: if (kind > 117)
3138: kind = 117;
3139: } else if (curChar == 39) {
3140: if (kind > 128)
3141: kind = 128;
3142: }
3143: break;
3144: case 3:
3145: if (curChar == 39 && kind > 128)
3146: kind = 128;
3147: break;
3148: default:
3149: break;
3150: }
3151: } while (i != startsAt);
3152: } else if (curChar < 128) {
3153: long l = 1L << (curChar & 077);
3154: MatchLoop: do {
3155: switch (jjstateSet[--i]) {
3156: case 0:
3157: if (kind > 128)
3158: kind = 128;
3159: if (curChar == 92)
3160: jjAddStates(3, 4);
3161: break;
3162: case 2:
3163: if (curChar == 92 && kind > 128)
3164: kind = 128;
3165: break;
3166: case 1:
3167: if (curChar == 92)
3168: jjAddStates(3, 4);
3169: break;
3170: default:
3171: break;
3172: }
3173: } while (i != startsAt);
3174: } else {
3175: int hiByte = (int) (curChar >> 8);
3176: int i1 = hiByte >> 6;
3177: long l1 = 1L << (hiByte & 077);
3178: int i2 = (curChar & 0xff) >> 6;
3179: long l2 = 1L << (curChar & 077);
3180: MatchLoop: do {
3181: switch (jjstateSet[--i]) {
3182: case 0:
3183: if (jjCanMove_0(hiByte, i1, i2, l1, l2)
3184: && kind > 128)
3185: kind = 128;
3186: break;
3187: default:
3188: break;
3189: }
3190: } while (i != startsAt);
3191: }
3192: if (kind != 0x7fffffff) {
3193: jjmatchedKind = kind;
3194: jjmatchedPos = curPos;
3195: kind = 0x7fffffff;
3196: }
3197: ++curPos;
3198: if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
3199: return curPos;
3200: try {
3201: curChar = input_stream.readChar();
3202: } catch (java.io.IOException e) {
3203: return curPos;
3204: }
3205: }
3206: }
3207:
3208: static final int[] jjnextStates = { 4, 6, 7, 2, 3, 39, 40, 24, 58,
3209: 59, 64, 65, 68, 69, 72, 73, 20, 21, 22, 23, 24, 26, 29, 30,
3210: 31, 33, 24, 22, 23, 24, 27, 28, 32, 23, 24, 74, 75, 24, 11,
3211: 12, 15, 18, 44, 45, 46, 47, 48, 51, 52, 55, 37, 38, 41, 42,
3212: 62, 63, 66, 67, 70, 71, 76, 77, };
3213:
3214: private static final boolean jjCanMove_0(int hiByte, int i1,
3215: int i2, long l1, long l2) {
3216: switch (hiByte) {
3217: case 0:
3218: return ((jjbitVec2[i2] & l2) != 0L);
3219: default:
3220: if ((jjbitVec0[i1] & l1) != 0L)
3221: return true;
3222: return false;
3223: }
3224: }
3225:
3226: public static final String[] jjstrLiteralImages = { "", null, null,
3227: null, null, null, null, null, null, null, null, null, null,
3228: null, null, "\74\111\116\104\105\116\124\76", null, null,
3229: "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54",
3230: "\56", "\72", "\53", "\55", "\52", "\57", "\57\57",
3231: "\52\52", "\74\74", "\76\76", "\45", "\176", "\136",
3232: "\174", "\46", "\75", "\76", "\74", "\75\75", "\74\75",
3233: "\76\75", "\74\76", "\41\75", "\53\75", "\55\75", "\52\75",
3234: "\57\75", "\57\57\75", "\45\75", "\46\75", "\174\75",
3235: "\136\75", "\74\74\75", "\76\76\75", "\52\52\75",
3236: "\157\162", "\141\156\144", "\156\157\164", "\151\163",
3237: "\151\156", "\154\141\155\142\144\141", "\151\146",
3238: "\145\154\163\145", "\145\154\151\146",
3239: "\167\150\151\154\145", "\146\157\162", "\164\162\171",
3240: "\145\170\143\145\160\164", "\144\145\146",
3241: "\143\154\141\163\163", "\146\151\156\141\154\154\171",
3242: "\160\162\151\156\164", "\160\141\163\163",
3243: "\142\162\145\141\153", "\143\157\156\164\151\156\165\145",
3244: "\162\145\164\165\162\156", "\171\151\145\154\144",
3245: "\151\155\160\157\162\164", "\146\162\157\155",
3246: "\144\145\154", "\162\141\151\163\145",
3247: "\147\154\157\142\141\154", "\145\170\145\143",
3248: "\141\163\163\145\162\164", "\141\163", null, null, null,
3249: null, null, null, null, null, null, null, null, null, null,
3250: null, null, null, null, null, null, null, null, null, null,
3251: null, null, null, null, null, null, null, null, null, null,
3252: null, null, null, null, null, null, null, null, null, null,
3253: null, "\140", };
3254: public static final String[] lexStateNames = { "DEFAULT",
3255: "FORCE_NEWLINE1", "FORCE_NEWLINE2",
3256: "MAYBE_FORCE_NEWLINE_IF_EOF", "INDENTING",
3257: "INDENTATION_UNCHANGED", "UNREACHABLE", "IN_STRING11",
3258: "IN_STRING21", "IN_STRING13", "IN_STRING23",
3259: "IN_USTRING11", "IN_USTRING21", "IN_USTRING13",
3260: "IN_USTRING23", "IN_STRING1NLC", "IN_STRING2NLC",
3261: "IN_USTRING1NLC", "IN_USTRING2NLC", };
3262: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
3263: 5, 4, -1, -1, -1, -1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1,
3264: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3265: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3266: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3267: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3268: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3269: -1, -1, -1, 11, 12, 13, 14, 7, 8, 9, 10, 0, 0, 0, 0, 0, 0,
3270: 0, 0, 15, 15, 16, 16, 17, 17, 18, 18, 7, 8, 11, 12, -1, -1,
3271: -1, -1, -1, -1, -1, -1, };
3272: static final long[] jjtoToken = { 0xfffffffffffcc0c1L,
3273: 0xff003efffffffL, 0x80L, };
3274: static final long[] jjtoSkip = { 0x33f3eL, 0x0L, 0x0L, };
3275: static final long[] jjtoSpecial = { 0x30000L, 0x0L, 0x0L, };
3276: static final long[] jjtoMore = { 0x0L, 0xfff00ff000000000L, 0x7fL, };
3277: protected CharStream input_stream;
3278: private final int[] jjrounds = new int[78];
3279: private final int[] jjstateSet = new int[156];
3280: StringBuffer image;
3281: int jjimageLen;
3282: int lengthOfMatch;
3283: protected char curChar;
3284:
3285: public PythonGrammarTokenManager(CharStream stream) {
3286: input_stream = stream;
3287: }
3288:
3289: public PythonGrammarTokenManager(CharStream stream, int lexState) {
3290: this (stream);
3291: SwitchTo(lexState);
3292: }
3293:
3294: public void ReInit(CharStream stream) {
3295: jjmatchedPos = jjnewStateCnt = 0;
3296: curLexState = defaultLexState;
3297: input_stream = stream;
3298: ReInitRounds();
3299: }
3300:
3301: private final void ReInitRounds() {
3302: int i;
3303: jjround = 0x80000001;
3304: for (i = 78; i-- > 0;)
3305: jjrounds[i] = 0x80000000;
3306: }
3307:
3308: public void ReInit(CharStream stream, int lexState) {
3309: ReInit(stream);
3310: SwitchTo(lexState);
3311: }
3312:
3313: public void SwitchTo(int lexState) {
3314: if (lexState >= 19 || lexState < 0)
3315: throw new TokenMgrError(
3316: "Error: Ignoring invalid lexical state : "
3317: + lexState + ". State unchanged.",
3318: TokenMgrError.INVALID_LEXICAL_STATE);
3319: else
3320: curLexState = lexState;
3321: }
3322:
3323: protected Token jjFillToken() {
3324: Token t = Token.newToken(jjmatchedKind);
3325: t.kind = jjmatchedKind;
3326: if (jjmatchedPos < 0) {
3327: if (image == null)
3328: t.image = "";
3329: else
3330: t.image = image.toString();
3331: t.beginLine = t.endLine = input_stream.getBeginLine();
3332: t.beginColumn = t.endColumn = input_stream.getBeginColumn();
3333: } else {
3334: String im = jjstrLiteralImages[jjmatchedKind];
3335: t.image = (im == null) ? input_stream.GetImage() : im;
3336: t.beginLine = input_stream.getBeginLine();
3337: t.beginColumn = input_stream.getBeginColumn();
3338: t.endLine = input_stream.getEndLine();
3339: t.endColumn = input_stream.getEndColumn();
3340: }
3341: return t;
3342: }
3343:
3344: int curLexState = 0;
3345: int defaultLexState = 0;
3346: int jjnewStateCnt;
3347: int jjround;
3348: int jjmatchedPos;
3349: int jjmatchedKind;
3350:
3351: public Token getNextToken() {
3352: int kind;
3353: Token specialToken = null;
3354: Token matchedToken;
3355: int curPos = 0;
3356:
3357: EOFLoop: for (;;) {
3358: try {
3359: curChar = input_stream.BeginToken();
3360: } catch (java.io.IOException e) {
3361: jjmatchedKind = 0;
3362: matchedToken = jjFillToken();
3363: matchedToken.specialToken = specialToken;
3364: CommonTokenAction(matchedToken);
3365: return matchedToken;
3366: }
3367: image = null;
3368: jjimageLen = 0;
3369:
3370: for (;;) {
3371: switch (curLexState) {
3372: case 0:
3373: try {
3374: input_stream.backup(0);
3375: while (curChar <= 32
3376: && (0x100001200L & (1L << curChar)) != 0L)
3377: curChar = input_stream.BeginToken();
3378: } catch (java.io.IOException e1) {
3379: continue EOFLoop;
3380: }
3381: jjmatchedKind = 0x7fffffff;
3382: jjmatchedPos = 0;
3383: curPos = jjMoveStringLiteralDfa0_0();
3384: break;
3385: case 1:
3386: jjmatchedKind = 0x7fffffff;
3387: jjmatchedPos = 0;
3388: curPos = jjMoveStringLiteralDfa0_1();
3389: break;
3390: case 2:
3391: jjmatchedKind = 0x7fffffff;
3392: jjmatchedPos = 0;
3393: curPos = jjMoveStringLiteralDfa0_2();
3394: break;
3395: case 3:
3396: jjmatchedKind = 8;
3397: jjmatchedPos = -1;
3398: curPos = 0;
3399: curPos = jjMoveStringLiteralDfa0_3();
3400: break;
3401: case 4:
3402: jjmatchedKind = 14;
3403: jjmatchedPos = -1;
3404: curPos = 0;
3405: curPos = jjMoveStringLiteralDfa0_4();
3406: break;
3407: case 5:
3408: jjmatchedKind = 13;
3409: jjmatchedPos = -1;
3410: curPos = 0;
3411: curPos = jjMoveStringLiteralDfa0_5();
3412: break;
3413: case 6:
3414: jjmatchedKind = 0x7fffffff;
3415: jjmatchedPos = 0;
3416: curPos = jjMoveStringLiteralDfa0_6();
3417: break;
3418: case 7:
3419: jjmatchedKind = 0x7fffffff;
3420: jjmatchedPos = 0;
3421: curPos = jjMoveStringLiteralDfa0_7();
3422: break;
3423: case 8:
3424: jjmatchedKind = 0x7fffffff;
3425: jjmatchedPos = 0;
3426: curPos = jjMoveStringLiteralDfa0_8();
3427: break;
3428: case 9:
3429: jjmatchedKind = 0x7fffffff;
3430: jjmatchedPos = 0;
3431: curPos = jjMoveStringLiteralDfa0_9();
3432: break;
3433: case 10:
3434: jjmatchedKind = 0x7fffffff;
3435: jjmatchedPos = 0;
3436: curPos = jjMoveStringLiteralDfa0_10();
3437: break;
3438: case 11:
3439: jjmatchedKind = 0x7fffffff;
3440: jjmatchedPos = 0;
3441: curPos = jjMoveStringLiteralDfa0_11();
3442: break;
3443: case 12:
3444: jjmatchedKind = 0x7fffffff;
3445: jjmatchedPos = 0;
3446: curPos = jjMoveStringLiteralDfa0_12();
3447: break;
3448: case 13:
3449: jjmatchedKind = 0x7fffffff;
3450: jjmatchedPos = 0;
3451: curPos = jjMoveStringLiteralDfa0_13();
3452: break;
3453: case 14:
3454: jjmatchedKind = 0x7fffffff;
3455: jjmatchedPos = 0;
3456: curPos = jjMoveStringLiteralDfa0_14();
3457: break;
3458: case 15:
3459: jjmatchedKind = 124;
3460: jjmatchedPos = -1;
3461: curPos = 0;
3462: curPos = jjMoveStringLiteralDfa0_15();
3463: break;
3464: case 16:
3465: jjmatchedKind = 125;
3466: jjmatchedPos = -1;
3467: curPos = 0;
3468: curPos = jjMoveStringLiteralDfa0_16();
3469: break;
3470: case 17:
3471: jjmatchedKind = 126;
3472: jjmatchedPos = -1;
3473: curPos = 0;
3474: curPos = jjMoveStringLiteralDfa0_17();
3475: break;
3476: case 18:
3477: jjmatchedKind = 127;
3478: jjmatchedPos = -1;
3479: curPos = 0;
3480: curPos = jjMoveStringLiteralDfa0_18();
3481: break;
3482: }
3483: if (jjmatchedKind != 0x7fffffff) {
3484: if (jjmatchedPos + 1 < curPos)
3485: input_stream.backup(curPos - jjmatchedPos - 1);
3486: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
3487: matchedToken = jjFillToken();
3488: matchedToken.specialToken = specialToken;
3489: TokenLexicalActions(matchedToken);
3490: if (jjnewLexState[jjmatchedKind] != -1)
3491: curLexState = jjnewLexState[jjmatchedKind];
3492: CommonTokenAction(matchedToken);
3493: return matchedToken;
3494: } else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
3495: if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
3496: matchedToken = jjFillToken();
3497: if (specialToken == null)
3498: specialToken = matchedToken;
3499: else {
3500: matchedToken.specialToken = specialToken;
3501: specialToken = (specialToken.next = matchedToken);
3502: }
3503: SkipLexicalActions(matchedToken);
3504: } else
3505: SkipLexicalActions(null);
3506: if (jjnewLexState[jjmatchedKind] != -1)
3507: curLexState = jjnewLexState[jjmatchedKind];
3508: continue EOFLoop;
3509: }
3510: MoreLexicalActions();
3511: if (jjnewLexState[jjmatchedKind] != -1)
3512: curLexState = jjnewLexState[jjmatchedKind];
3513: curPos = 0;
3514: jjmatchedKind = 0x7fffffff;
3515: try {
3516: curChar = input_stream.readChar();
3517: continue;
3518: } catch (java.io.IOException e1) {
3519: }
3520: }
3521: int error_line = input_stream.getEndLine();
3522: int error_column = input_stream.getEndColumn();
3523: String error_after = null;
3524: boolean EOFSeen = false;
3525: try {
3526: input_stream.readChar();
3527: input_stream.backup(1);
3528: } catch (java.io.IOException e1) {
3529: EOFSeen = true;
3530: error_after = curPos <= 1 ? "" : input_stream
3531: .GetImage();
3532: if (curChar == '\n' || curChar == '\r') {
3533: error_line++;
3534: error_column = 0;
3535: } else
3536: error_column++;
3537: }
3538: if (!EOFSeen) {
3539: input_stream.backup(1);
3540: error_after = curPos <= 1 ? "" : input_stream
3541: .GetImage();
3542: }
3543: throw new TokenMgrError(EOFSeen, curLexState,
3544: error_line, error_column, error_after, curChar,
3545: TokenMgrError.LEXICAL_ERROR);
3546: }
3547: }
3548: }
3549:
3550: int[] jjemptyLineNo = new int[19];
3551: int[] jjemptyColNo = new int[19];
3552: boolean[] jjbeenHere = new boolean[19];
3553:
3554: void SkipLexicalActions(Token matchedToken) {
3555: switch (jjmatchedKind) {
3556: case 5:
3557: if (image == null)
3558: image = new StringBuffer(new String(input_stream
3559: .GetSuffix(jjimageLen
3560: + (lengthOfMatch = jjmatchedPos + 1))));
3561: else
3562: image.append(input_stream.GetSuffix(jjimageLen
3563: + (lengthOfMatch = jjmatchedPos + 1)));
3564: if (parens == 0) {
3565: indent = 0;
3566: input_stream.backup(1);
3567: if (level == 0)
3568: SwitchTo(FORCE_NEWLINE1);
3569: else
3570: SwitchTo(FORCE_NEWLINE2);
3571: }
3572: break;
3573: case 8:
3574: if (jjmatchedPos == -1) {
3575: if (jjbeenHere[3]
3576: && jjemptyLineNo[3] == input_stream
3577: .getBeginLine()
3578: && jjemptyColNo[3] == input_stream
3579: .getBeginColumn())
3580: throw new TokenMgrError(
3581: ("Error: Bailing out of infinite loop caused by repeated empty string matches at line "
3582: + input_stream.getBeginLine()
3583: + ", column "
3584: + input_stream.getBeginColumn() + "."),
3585: TokenMgrError.LOOP_DETECTED);
3586: jjemptyLineNo[3] = input_stream.getBeginLine();
3587: jjemptyColNo[3] = input_stream.getBeginColumn();
3588: jjbeenHere[3] = true;
3589: }
3590: if (image == null)
3591: image = new StringBuffer(new String(input_stream
3592: .GetSuffix(jjimageLen
3593: + (lengthOfMatch = jjmatchedPos + 1))));
3594: else
3595: image.append(input_stream.GetSuffix(jjimageLen
3596: + (lengthOfMatch = jjmatchedPos + 1)));
3597: indenting(0);
3598: break;
3599: case 9:
3600: if (image == null)
3601: image = new StringBuffer(new String(input_stream
3602: .GetSuffix(jjimageLen
3603: + (lengthOfMatch = jjmatchedPos + 1))));
3604: else
3605: image.append(input_stream.GetSuffix(jjimageLen
3606: + (lengthOfMatch = jjmatchedPos + 1)));
3607: indenting((indent / 8 + 1) * 8);
3608: break;
3609: case 10:
3610: if (image == null)
3611: image = new StringBuffer(new String(input_stream
3612: .GetSuffix(jjimageLen
3613: + (lengthOfMatch = jjmatchedPos + 1))));
3614: else
3615: image.append(input_stream.GetSuffix(jjimageLen
3616: + (lengthOfMatch = jjmatchedPos + 1)));
3617: indenting(indent + 1);
3618: break;
3619: case 11:
3620: if (image == null)
3621: image = new StringBuffer(new String(input_stream
3622: .GetSuffix(jjimageLen
3623: + (lengthOfMatch = jjmatchedPos + 1))));
3624: else
3625: image.append(input_stream.GetSuffix(jjimageLen
3626: + (lengthOfMatch = jjmatchedPos + 1)));
3627: indenting(0);
3628: break;
3629: case 12:
3630: if (image == null)
3631: image = new StringBuffer(new String(input_stream
3632: .GetSuffix(jjimageLen
3633: + (lengthOfMatch = jjmatchedPos + 1))));
3634: else
3635: image.append(input_stream.GetSuffix(jjimageLen
3636: + (lengthOfMatch = jjmatchedPos + 1)));
3637: //System.out.println("empty line");
3638: // if partial single_input (interactive) mode,
3639: // empty line (indent==0), and no parens open
3640: // or indentetion expected (if stdprompt == true, ovveride last cond)
3641: // consider forcing sentence closing NEWLINE if EOF
3642: if (partial && single_input && indent == 0 && parens == 0
3643: && (stdprompt || !expect_indent)) {
3644: //System.out.println("force newline");
3645: //backup a character!
3646: // - input_stream.backup(1); -
3647: SwitchTo(MAYBE_FORCE_NEWLINE_IF_EOF);
3648: } else
3649: indenting(0);
3650: break;
3651: case 17:
3652: if (image == null)
3653: image = new StringBuffer(new String(input_stream
3654: .GetSuffix(jjimageLen
3655: + (lengthOfMatch = jjmatchedPos + 1))));
3656: else
3657: image.append(input_stream.GetSuffix(jjimageLen
3658: + (lengthOfMatch = jjmatchedPos + 1)));
3659: indenting(0);
3660: break;
3661: default:
3662: break;
3663: }
3664: }
3665:
3666: void MoreLexicalActions() {
3667: jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
3668: switch (jjmatchedKind) {
3669: case 116:
3670: if (image == null)
3671: image = new StringBuffer(new String(input_stream
3672: .GetSuffix(jjimageLen)));
3673: else
3674: image.append(input_stream.GetSuffix(jjimageLen));
3675: jjimageLen = 0;
3676: image.setLength(image.length() - 3);
3677: break;
3678: case 117:
3679: if (image == null)
3680: image = new StringBuffer(new String(input_stream
3681: .GetSuffix(jjimageLen)));
3682: else
3683: image.append(input_stream.GetSuffix(jjimageLen));
3684: jjimageLen = 0;
3685: image.setLength(image.length() - 2);
3686: break;
3687: case 118:
3688: if (image == null)
3689: image = new StringBuffer(new String(input_stream
3690: .GetSuffix(jjimageLen)));
3691: else
3692: image.append(input_stream.GetSuffix(jjimageLen));
3693: jjimageLen = 0;
3694: image.setLength(image.length() - 3);
3695: break;
3696: case 119:
3697: if (image == null)
3698: image = new StringBuffer(new String(input_stream
3699: .GetSuffix(jjimageLen)));
3700: else
3701: image.append(input_stream.GetSuffix(jjimageLen));
3702: jjimageLen = 0;
3703: image.setLength(image.length() - 2);
3704: break;
3705: case 120:
3706: if (image == null)
3707: image = new StringBuffer(new String(input_stream
3708: .GetSuffix(jjimageLen)));
3709: else
3710: image.append(input_stream.GetSuffix(jjimageLen));
3711: jjimageLen = 0;
3712: image.setLength(image.length() - 3);
3713: break;
3714: case 121:
3715: if (image == null)
3716: image = new StringBuffer(new String(input_stream
3717: .GetSuffix(jjimageLen)));
3718: else
3719: image.append(input_stream.GetSuffix(jjimageLen));
3720: jjimageLen = 0;
3721: image.setLength(image.length() - 2);
3722: break;
3723: case 122:
3724: if (image == null)
3725: image = new StringBuffer(new String(input_stream
3726: .GetSuffix(jjimageLen)));
3727: else
3728: image.append(input_stream.GetSuffix(jjimageLen));
3729: jjimageLen = 0;
3730: image.setLength(image.length() - 3);
3731: break;
3732: case 123:
3733: if (image == null)
3734: image = new StringBuffer(new String(input_stream
3735: .GetSuffix(jjimageLen)));
3736: else
3737: image.append(input_stream.GetSuffix(jjimageLen));
3738: jjimageLen = 0;
3739: image.setLength(image.length() - 2);
3740: break;
3741: case 130:
3742: if (image == null)
3743: image = new StringBuffer(new String(input_stream
3744: .GetSuffix(jjimageLen)));
3745: else
3746: image.append(input_stream.GetSuffix(jjimageLen));
3747: jjimageLen = 0;
3748: int l = image.length();
3749: image.setLength(l - 1);
3750: image.setCharAt(l - 2, '\n');
3751: break;
3752: case 132:
3753: if (image == null)
3754: image = new StringBuffer(new String(input_stream
3755: .GetSuffix(jjimageLen)));
3756: else
3757: image.append(input_stream.GetSuffix(jjimageLen));
3758: jjimageLen = 0;
3759: image.setCharAt(image.length() - 1, '\n');
3760: break;
3761: default:
3762: break;
3763: }
3764: }
3765:
3766: void TokenLexicalActions(Token matchedToken) {
3767: switch (jjmatchedKind) {
3768: case 7:
3769: if (image == null)
3770: image = new StringBuffer(new String(input_stream
3771: .GetSuffix(jjimageLen
3772: + (lengthOfMatch = jjmatchedPos + 1))));
3773: else
3774: image.append(input_stream.GetSuffix(jjimageLen
3775: + (lengthOfMatch = jjmatchedPos + 1)));
3776: matchedToken.kind = NEWLINE;
3777: break;
3778: case 14:
3779: if (image == null)
3780: image = new StringBuffer(new String(input_stream
3781: .GetSuffix(jjimageLen
3782: + (lengthOfMatch = jjmatchedPos + 1))));
3783: else
3784: image.append(input_stream.GetSuffix(jjimageLen
3785: + (lengthOfMatch = jjmatchedPos + 1)));
3786: if (indent > indentation[level]) {
3787: level++;
3788: indentation[level] = indent;
3789: matchedToken.kind = INDENT;
3790: matchedToken.image = "<INDENT>";
3791: } else if (level > 0) {
3792: Token t = matchedToken;
3793: level -= 1;
3794: while (level > 0 && indent < indentation[level]) {
3795: level--;
3796: t = addDedent(t);
3797: }
3798: if (indent != indentation[level]) {
3799: throw new TokenMgrError("inconsistent dedent",
3800: t.endLine, t.endColumn);
3801: }
3802: t.next = null;
3803: }
3804: break;
3805: case 18:
3806: if (image == null)
3807: image = new StringBuffer(jjstrLiteralImages[18]);
3808: else
3809: image.append(jjstrLiteralImages[18]);
3810: parens++;
3811: break;
3812: case 19:
3813: if (image == null)
3814: image = new StringBuffer(jjstrLiteralImages[19]);
3815: else
3816: image.append(jjstrLiteralImages[19]);
3817: parens--;
3818: break;
3819: case 20:
3820: if (image == null)
3821: image = new StringBuffer(jjstrLiteralImages[20]);
3822: else
3823: image.append(jjstrLiteralImages[20]);
3824: parens++;
3825: break;
3826: case 21:
3827: if (image == null)
3828: image = new StringBuffer(jjstrLiteralImages[21]);
3829: else
3830: image.append(jjstrLiteralImages[21]);
3831: parens--;
3832: break;
3833: case 22:
3834: if (image == null)
3835: image = new StringBuffer(jjstrLiteralImages[22]);
3836: else
3837: image.append(jjstrLiteralImages[22]);
3838: parens++;
3839: break;
3840: case 23:
3841: if (image == null)
3842: image = new StringBuffer(jjstrLiteralImages[23]);
3843: else
3844: image.append(jjstrLiteralImages[23]);
3845: parens--;
3846: break;
3847: case 108:
3848: if (image == null)
3849: image = new StringBuffer(new String(input_stream
3850: .GetSuffix(jjimageLen
3851: + (lengthOfMatch = jjmatchedPos + 1))));
3852: else
3853: image.append(input_stream.GetSuffix(jjimageLen
3854: + (lengthOfMatch = jjmatchedPos + 1)));
3855: matchedToken.image = image.toString();
3856: break;
3857: case 109:
3858: if (image == null)
3859: image = new StringBuffer(new String(input_stream
3860: .GetSuffix(jjimageLen
3861: + (lengthOfMatch = jjmatchedPos + 1))));
3862: else
3863: image.append(input_stream.GetSuffix(jjimageLen
3864: + (lengthOfMatch = jjmatchedPos + 1)));
3865: matchedToken.image = image.toString();
3866: break;
3867: case 110:
3868: if (image == null)
3869: image = new StringBuffer(new String(input_stream
3870: .GetSuffix(jjimageLen
3871: + (lengthOfMatch = jjmatchedPos + 1))));
3872: else
3873: image.append(input_stream.GetSuffix(jjimageLen
3874: + (lengthOfMatch = jjmatchedPos + 1)));
3875: matchedToken.image = image.toString();
3876: break;
3877: case 111:
3878: if (image == null)
3879: image = new StringBuffer(new String(input_stream
3880: .GetSuffix(jjimageLen
3881: + (lengthOfMatch = jjmatchedPos + 1))));
3882: else
3883: image.append(input_stream.GetSuffix(jjimageLen
3884: + (lengthOfMatch = jjmatchedPos + 1)));
3885: matchedToken.image = image.toString();
3886: break;
3887: case 112:
3888: if (image == null)
3889: image = new StringBuffer(new String(input_stream
3890: .GetSuffix(jjimageLen
3891: + (lengthOfMatch = jjmatchedPos + 1))));
3892: else
3893: image.append(input_stream.GetSuffix(jjimageLen
3894: + (lengthOfMatch = jjmatchedPos + 1)));
3895: matchedToken.image = image.toString();
3896: break;
3897: case 113:
3898: if (image == null)
3899: image = new StringBuffer(new String(input_stream
3900: .GetSuffix(jjimageLen
3901: + (lengthOfMatch = jjmatchedPos + 1))));
3902: else
3903: image.append(input_stream.GetSuffix(jjimageLen
3904: + (lengthOfMatch = jjmatchedPos + 1)));
3905: matchedToken.image = image.toString();
3906: break;
3907: case 114:
3908: if (image == null)
3909: image = new StringBuffer(new String(input_stream
3910: .GetSuffix(jjimageLen
3911: + (lengthOfMatch = jjmatchedPos + 1))));
3912: else
3913: image.append(input_stream.GetSuffix(jjimageLen
3914: + (lengthOfMatch = jjmatchedPos + 1)));
3915: matchedToken.image = image.toString();
3916: break;
3917: case 115:
3918: if (image == null)
3919: image = new StringBuffer(new String(input_stream
3920: .GetSuffix(jjimageLen
3921: + (lengthOfMatch = jjmatchedPos + 1))));
3922: else
3923: image.append(input_stream.GetSuffix(jjimageLen
3924: + (lengthOfMatch = jjmatchedPos + 1)));
3925: matchedToken.image = image.toString();
3926: break;
3927: default:
3928: break;
3929: }
3930: }
3931: }
|