0001: /* Generated By:JavaCC: Do not edit this line. FMParserTokenManager.java */
0002: package freemarker.core;
0003:
0004: import freemarker.template.*;
0005: import freemarker.template.utility.StringUtil;
0006: import freemarker.template.utility.DeepUnwrap;
0007: import java.io.*;
0008: import java.util.*;
0009:
0010: class FMParserTokenManager implements FMParserConstants {
0011: /**
0012: The noparseTag is set when we enter
0013: a block of text that the parser more or less ignores.
0014: These are <noparse> and <comment>. This variable
0015: tells us what the closing tag should be, and when
0016: we hit that, we resume parsing. Note that with this
0017: scheme, <comment> and <noparse> tags cannot nest
0018: recursively, but it is not clear how important that is.
0019: */
0020: String noparseTag;
0021:
0022: /**
0023: Keeps track of how deeply nested
0024: we have the hash literals.
0025: This is necessary since we need to be
0026: able to distinguish the } used to close
0027: a hash literal and the one used to
0028: close a ${
0029: */
0030: private int hashLiteralNesting;
0031: private int parenthesisNesting;
0032: private int bracketNesting;
0033: private boolean inFTLHeader;
0034: boolean strictEscapeSyntax, onlyTextOutput, altDirectiveSyntax,
0035: autodetectTagSyntax, directiveSyntaxEstablished;
0036: String templateName;
0037:
0038: // This method checks if we are in a strict mode where all
0039: // FreeMarker directives must start with <#
0040:
0041: private void strictSyntaxCheck(Token tok, int newLexState) {
0042: if (onlyTextOutput) {
0043: tok.kind = PRINTABLE_CHARS;
0044: return;
0045: }
0046: char firstChar = tok.image.charAt(0);
0047: if (autodetectTagSyntax && !directiveSyntaxEstablished) {
0048: altDirectiveSyntax = (firstChar == '[');
0049: }
0050: if ((firstChar == '[' && !altDirectiveSyntax)
0051: || (firstChar == '<' && altDirectiveSyntax)) {
0052: tok.kind = PRINTABLE_CHARS;
0053: return;
0054: }
0055: if (!strictEscapeSyntax) {
0056: SwitchTo(newLexState);
0057: return;
0058: }
0059: if (!altDirectiveSyntax) {
0060: if (!tok.image.startsWith("<#")
0061: && !tok.image.startsWith("</#")) {
0062: tok.kind = PRINTABLE_CHARS;
0063: return;
0064: }
0065: }
0066: directiveSyntaxEstablished = true;
0067: SwitchTo(newLexState);
0068: }
0069:
0070: private void unifiedCall(Token tok) {
0071: char firstChar = tok.image.charAt(0);
0072: if (autodetectTagSyntax && !directiveSyntaxEstablished) {
0073: altDirectiveSyntax = (firstChar == '[');
0074: }
0075: if (altDirectiveSyntax && firstChar == '<') {
0076: tok.kind = PRINTABLE_CHARS;
0077: return;
0078: }
0079: if (!altDirectiveSyntax && firstChar == '[') {
0080: tok.kind = PRINTABLE_CHARS;
0081: return;
0082: }
0083: directiveSyntaxEstablished = true;
0084: SwitchTo(NO_SPACE_EXPRESSION);
0085: }
0086:
0087: private void unifiedCallEnd(Token tok) {
0088: char firstChar = tok.image.charAt(0);
0089: if (altDirectiveSyntax && firstChar == '<') {
0090: tok.kind = PRINTABLE_CHARS;
0091: return;
0092: }
0093: if (!altDirectiveSyntax && firstChar == '[') {
0094: tok.kind = PRINTABLE_CHARS;
0095: return;
0096: }
0097: }
0098:
0099: private void closeBracket(Token tok) {
0100: if (bracketNesting > 0) {
0101: --bracketNesting;
0102: } else {
0103: tok.kind = DIRECTIVE_END;
0104: if (inFTLHeader) {
0105: eatNewline();
0106: inFTLHeader = false;
0107: }
0108: SwitchTo(DEFAULT);
0109: }
0110: }
0111:
0112: private void eatNewline() {
0113: int charsRead = 0;
0114: try {
0115: while (true) {
0116: char c = input_stream.readChar();
0117: ++charsRead;
0118: if (!Character.isWhitespace(c)) {
0119: input_stream.backup(charsRead);
0120: return;
0121: } else if (c == '\r') {
0122: char next = input_stream.readChar();
0123: ++charsRead;
0124: if (next != '\n') {
0125: input_stream.backup(1);
0126: }
0127: return;
0128: } else if (c == '\n') {
0129: return;
0130: }
0131: }
0132: } catch (IOException ioe) {
0133: input_stream.backup(charsRead);
0134: }
0135: }
0136:
0137: private void ftlHeader(Token matchedToken) {
0138: if (!directiveSyntaxEstablished) {
0139: altDirectiveSyntax = matchedToken.image.charAt(0) == '[';
0140: directiveSyntaxEstablished = true;
0141: autodetectTagSyntax = false;
0142: }
0143: String img = matchedToken.image;
0144: char firstChar = img.charAt(0);
0145: char lastChar = img.charAt(img.length() - 1);
0146: if ((firstChar == '[' && !altDirectiveSyntax)
0147: || (firstChar == '<' && altDirectiveSyntax)) {
0148: matchedToken.kind = PRINTABLE_CHARS;
0149: }
0150: if (matchedToken.kind != PRINTABLE_CHARS) {
0151: if (lastChar != '>' && lastChar != ']') {
0152: SwitchTo(FM_EXPRESSION);
0153: inFTLHeader = true;
0154: } else {
0155: eatNewline();
0156: }
0157: }
0158: }
0159:
0160: public java.io.PrintStream debugStream = System.out;
0161:
0162: public void setDebugStream(java.io.PrintStream ds) {
0163: debugStream = ds;
0164: }
0165:
0166: private final int jjMoveStringLiteralDfa0_6() {
0167: return jjMoveNfa_6(0, 0);
0168: }
0169:
0170: private final void jjCheckNAdd(int state) {
0171: if (jjrounds[state] != jjround) {
0172: jjstateSet[jjnewStateCnt++] = state;
0173: jjrounds[state] = jjround;
0174: }
0175: }
0176:
0177: private final void jjAddStates(int start, int end) {
0178: do {
0179: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0180: } while (start++ != end);
0181: }
0182:
0183: private final void jjCheckNAddTwoStates(int state1, int state2) {
0184: jjCheckNAdd(state1);
0185: jjCheckNAdd(state2);
0186: }
0187:
0188: private final void jjCheckNAddStates(int start, int end) {
0189: do {
0190: jjCheckNAdd(jjnextStates[start]);
0191: } while (start++ != end);
0192: }
0193:
0194: private final void jjCheckNAddStates(int start) {
0195: jjCheckNAdd(jjnextStates[start]);
0196: jjCheckNAdd(jjnextStates[start + 1]);
0197: }
0198:
0199: static final long[] jjbitVec0 = { 0xfffffffffffffffeL,
0200: 0xffffffffffffffffL, 0xffffffffffffffffL,
0201: 0xffffffffffffffffL };
0202: static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
0203: 0xffffffffffffffffL };
0204:
0205: private final int jjMoveNfa_6(int startState, int curPos) {
0206: int[] nextStates;
0207: int startsAt = 0;
0208: jjnewStateCnt = 13;
0209: int i = 1;
0210: jjstateSet[0] = startState;
0211: int j, kind = 0x7fffffff;
0212: for (;;) {
0213: if (++jjround == 0x7fffffff)
0214: ReInitRounds();
0215: if (curChar < 64) {
0216: long l = 1L << curChar;
0217: MatchLoop: do {
0218: switch (jjstateSet[--i]) {
0219: case 0:
0220: if ((0xefffdfffffffffffL & l) != 0L) {
0221: if (kind > 130)
0222: kind = 130;
0223: jjCheckNAdd(6);
0224: } else if ((0x1000200000000000L & l) != 0L) {
0225: if (kind > 131)
0226: kind = 131;
0227: }
0228: if (curChar == 45)
0229: jjAddStates(0, 1);
0230: else if (curChar == 60)
0231: jjstateSet[jjnewStateCnt++] = 1;
0232: break;
0233: case 1:
0234: if (curChar == 47)
0235: jjCheckNAddTwoStates(2, 3);
0236: break;
0237: case 2:
0238: if (curChar == 35)
0239: jjCheckNAdd(3);
0240: break;
0241: case 4:
0242: if ((0x100002600L & l) != 0L)
0243: jjAddStates(2, 3);
0244: break;
0245: case 5:
0246: if (curChar == 62 && kind > 129)
0247: kind = 129;
0248: break;
0249: case 6:
0250: if ((0xefffdfffffffffffL & l) == 0L)
0251: break;
0252: if (kind > 130)
0253: kind = 130;
0254: jjCheckNAdd(6);
0255: break;
0256: case 7:
0257: if ((0x1000200000000000L & l) != 0L
0258: && kind > 131)
0259: kind = 131;
0260: break;
0261: case 8:
0262: if (curChar == 45)
0263: jjAddStates(0, 1);
0264: break;
0265: case 9:
0266: if (curChar == 62 && kind > 128)
0267: kind = 128;
0268: break;
0269: case 10:
0270: if (curChar == 45)
0271: jjstateSet[jjnewStateCnt++] = 9;
0272: break;
0273: case 12:
0274: if (curChar == 45)
0275: jjstateSet[jjnewStateCnt++] = 11;
0276: break;
0277: default:
0278: break;
0279: }
0280: } while (i != startsAt);
0281: } else if (curChar < 128) {
0282: long l = 1L << (curChar & 077);
0283: MatchLoop: do {
0284: switch (jjstateSet[--i]) {
0285: case 0:
0286: if ((0xfffffffff7ffffffL & l) != 0L) {
0287: if (kind > 130)
0288: kind = 130;
0289: jjCheckNAdd(6);
0290: } else if (curChar == 91) {
0291: if (kind > 131)
0292: kind = 131;
0293: }
0294: if (curChar == 91)
0295: jjstateSet[jjnewStateCnt++] = 1;
0296: break;
0297: case 3:
0298: if ((0x7fffffe07fffffeL & l) != 0L)
0299: jjAddStates(4, 6);
0300: break;
0301: case 5:
0302: if (curChar == 93 && kind > 129)
0303: kind = 129;
0304: break;
0305: case 6:
0306: if ((0xfffffffff7ffffffL & l) == 0L)
0307: break;
0308: if (kind > 130)
0309: kind = 130;
0310: jjCheckNAdd(6);
0311: break;
0312: case 7:
0313: if (curChar == 91 && kind > 131)
0314: kind = 131;
0315: break;
0316: case 11:
0317: if (curChar == 93 && kind > 128)
0318: kind = 128;
0319: break;
0320: default:
0321: break;
0322: }
0323: } while (i != startsAt);
0324: } else {
0325: int hiByte = (int) (curChar >> 8);
0326: int i1 = hiByte >> 6;
0327: long l1 = 1L << (hiByte & 077);
0328: int i2 = (curChar & 0xff) >> 6;
0329: long l2 = 1L << (curChar & 077);
0330: MatchLoop: do {
0331: switch (jjstateSet[--i]) {
0332: case 0:
0333: case 6:
0334: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
0335: break;
0336: if (kind > 130)
0337: kind = 130;
0338: jjCheckNAdd(6);
0339: break;
0340: default:
0341: break;
0342: }
0343: } while (i != startsAt);
0344: }
0345: if (kind != 0x7fffffff) {
0346: jjmatchedKind = kind;
0347: jjmatchedPos = curPos;
0348: kind = 0x7fffffff;
0349: }
0350: ++curPos;
0351: if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
0352: return curPos;
0353: try {
0354: curChar = input_stream.readChar();
0355: } catch (java.io.IOException e) {
0356: return curPos;
0357: }
0358: }
0359: }
0360:
0361: private final int jjStopStringLiteralDfa_1(int pos, long active0,
0362: long active1) {
0363: switch (pos) {
0364: case 0:
0365: if ((active1 & 0x180L) != 0L) {
0366: jjmatchedKind = 70;
0367: return -1;
0368: }
0369: return -1;
0370: default:
0371: return -1;
0372: }
0373: }
0374:
0375: private final int jjStartNfa_1(int pos, long active0, long active1) {
0376: return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0,
0377: active1), pos + 1);
0378: }
0379:
0380: private final int jjStopAtPos(int pos, int kind) {
0381: jjmatchedKind = kind;
0382: jjmatchedPos = pos;
0383: return pos + 1;
0384: }
0385:
0386: private final int jjStartNfaWithStates_1(int pos, int kind,
0387: int state) {
0388: jjmatchedKind = kind;
0389: jjmatchedPos = pos;
0390: try {
0391: curChar = input_stream.readChar();
0392: } catch (java.io.IOException e) {
0393: return pos + 1;
0394: }
0395: return jjMoveNfa_1(state, pos + 1);
0396: }
0397:
0398: private final int jjMoveStringLiteralDfa0_1() {
0399: switch (curChar) {
0400: case 35:
0401: return jjMoveStringLiteralDfa1_1(0x100L);
0402: case 36:
0403: return jjMoveStringLiteralDfa1_1(0x80L);
0404: default:
0405: return jjMoveNfa_1(2, 0);
0406: }
0407: }
0408:
0409: private final int jjMoveStringLiteralDfa1_1(long active1) {
0410: try {
0411: curChar = input_stream.readChar();
0412: } catch (java.io.IOException e) {
0413: jjStopStringLiteralDfa_1(0, 0L, active1);
0414: return 1;
0415: }
0416: switch (curChar) {
0417: case 123:
0418: if ((active1 & 0x80L) != 0L)
0419: return jjStopAtPos(1, 71);
0420: else if ((active1 & 0x100L) != 0L)
0421: return jjStopAtPos(1, 72);
0422: break;
0423: default:
0424: break;
0425: }
0426: return jjStartNfa_1(0, 0L, active1);
0427: }
0428:
0429: private final int jjMoveNfa_1(int startState, int curPos) {
0430: int[] nextStates;
0431: int startsAt = 0;
0432: jjnewStateCnt = 3;
0433: int i = 1;
0434: jjstateSet[0] = startState;
0435: int j, kind = 0x7fffffff;
0436: for (;;) {
0437: if (++jjround == 0x7fffffff)
0438: ReInitRounds();
0439: if (curChar < 64) {
0440: long l = 1L << curChar;
0441: MatchLoop: do {
0442: switch (jjstateSet[--i]) {
0443: case 2:
0444: if ((0xefffffe6ffffd9ffL & l) != 0L) {
0445: if (kind > 69)
0446: kind = 69;
0447: jjCheckNAdd(1);
0448: } else if ((0x100002600L & l) != 0L) {
0449: if (kind > 68)
0450: kind = 68;
0451: jjCheckNAdd(0);
0452: } else if ((0x1000001800000000L & l) != 0L) {
0453: if (kind > 70)
0454: kind = 70;
0455: }
0456: break;
0457: case 0:
0458: if ((0x100002600L & l) == 0L)
0459: break;
0460: kind = 68;
0461: jjCheckNAdd(0);
0462: break;
0463: case 1:
0464: if ((0xefffffe6ffffd9ffL & l) == 0L)
0465: break;
0466: kind = 69;
0467: jjCheckNAdd(1);
0468: break;
0469: default:
0470: break;
0471: }
0472: } while (i != startsAt);
0473: } else if (curChar < 128) {
0474: long l = 1L << (curChar & 077);
0475: MatchLoop: do {
0476: switch (jjstateSet[--i]) {
0477: case 2:
0478: if ((0xf7fffffff7ffffffL & l) != 0L) {
0479: if (kind > 69)
0480: kind = 69;
0481: jjCheckNAdd(1);
0482: } else if ((0x800000008000000L & l) != 0L) {
0483: if (kind > 70)
0484: kind = 70;
0485: }
0486: break;
0487: case 1:
0488: if ((0xf7fffffff7ffffffL & l) == 0L)
0489: break;
0490: kind = 69;
0491: jjCheckNAdd(1);
0492: break;
0493: default:
0494: break;
0495: }
0496: } while (i != startsAt);
0497: } else {
0498: int hiByte = (int) (curChar >> 8);
0499: int i1 = hiByte >> 6;
0500: long l1 = 1L << (hiByte & 077);
0501: int i2 = (curChar & 0xff) >> 6;
0502: long l2 = 1L << (curChar & 077);
0503: MatchLoop: do {
0504: switch (jjstateSet[--i]) {
0505: case 2:
0506: case 1:
0507: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
0508: break;
0509: if (kind > 69)
0510: kind = 69;
0511: jjCheckNAdd(1);
0512: break;
0513: default:
0514: break;
0515: }
0516: } while (i != startsAt);
0517: }
0518: if (kind != 0x7fffffff) {
0519: jjmatchedKind = kind;
0520: jjmatchedPos = curPos;
0521: kind = 0x7fffffff;
0522: }
0523: ++curPos;
0524: if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
0525: return curPos;
0526: try {
0527: curChar = input_stream.readChar();
0528: } catch (java.io.IOException e) {
0529: return curPos;
0530: }
0531: }
0532: }
0533:
0534: private final int jjStopStringLiteralDfa_0(int pos, long active0,
0535: long active1) {
0536: switch (pos) {
0537: case 0:
0538: if ((active1 & 0x180L) != 0L) {
0539: jjmatchedKind = 70;
0540: return -1;
0541: }
0542: return -1;
0543: default:
0544: return -1;
0545: }
0546: }
0547:
0548: private final int jjStartNfa_0(int pos, long active0, long active1) {
0549: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0,
0550: active1), pos + 1);
0551: }
0552:
0553: private final int jjStartNfaWithStates_0(int pos, int kind,
0554: int state) {
0555: jjmatchedKind = kind;
0556: jjmatchedPos = pos;
0557: try {
0558: curChar = input_stream.readChar();
0559: } catch (java.io.IOException e) {
0560: return pos + 1;
0561: }
0562: return jjMoveNfa_0(state, pos + 1);
0563: }
0564:
0565: private final int jjMoveStringLiteralDfa0_0() {
0566: switch (curChar) {
0567: case 35:
0568: return jjMoveStringLiteralDfa1_0(0x100L);
0569: case 36:
0570: return jjMoveStringLiteralDfa1_0(0x80L);
0571: default:
0572: return jjMoveNfa_0(2, 0);
0573: }
0574: }
0575:
0576: private final int jjMoveStringLiteralDfa1_0(long active1) {
0577: try {
0578: curChar = input_stream.readChar();
0579: } catch (java.io.IOException e) {
0580: jjStopStringLiteralDfa_0(0, 0L, active1);
0581: return 1;
0582: }
0583: switch (curChar) {
0584: case 123:
0585: if ((active1 & 0x80L) != 0L)
0586: return jjStopAtPos(1, 71);
0587: else if ((active1 & 0x100L) != 0L)
0588: return jjStopAtPos(1, 72);
0589: break;
0590: default:
0591: break;
0592: }
0593: return jjStartNfa_0(0, 0L, active1);
0594: }
0595:
0596: static final long[] jjbitVec3 = { 0x1ff00000fffffffeL,
0597: 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L };
0598: static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L,
0599: 0xff7fffffff7fffffL };
0600: static final long[] jjbitVec5 = { 0x0L, 0xffffffffffffffffL,
0601: 0xffffffffffffffffL, 0xffffffffffffffffL };
0602: static final long[] jjbitVec6 = { 0xffffffffffffffffL,
0603: 0xffffffffffffffffL, 0xffffL, 0x0L };
0604: static final long[] jjbitVec7 = { 0xffffffffffffffffL,
0605: 0xffffffffffffffffL, 0x0L, 0x0L };
0606: static final long[] jjbitVec8 = { 0x3fffffffffffL, 0x0L, 0x0L, 0x0L };
0607:
0608: private final int jjMoveNfa_0(int startState, int curPos) {
0609: int[] nextStates;
0610: int startsAt = 0;
0611: jjnewStateCnt = 567;
0612: int i = 1;
0613: jjstateSet[0] = startState;
0614: int j, kind = 0x7fffffff;
0615: for (;;) {
0616: if (++jjround == 0x7fffffff)
0617: ReInitRounds();
0618: if (curChar < 64) {
0619: long l = 1L << curChar;
0620: MatchLoop: do {
0621: switch (jjstateSet[--i]) {
0622: case 2:
0623: if ((0xefffffe6ffffd9ffL & l) != 0L) {
0624: if (kind > 69)
0625: kind = 69;
0626: jjCheckNAdd(1);
0627: } else if ((0x100002600L & l) != 0L) {
0628: if (kind > 68)
0629: kind = 68;
0630: jjCheckNAdd(0);
0631: } else if ((0x1000001800000000L & l) != 0L) {
0632: if (kind > 70)
0633: kind = 70;
0634: }
0635: if (curChar == 60)
0636: jjAddStates(7, 8);
0637: if (curChar == 60)
0638: jjCheckNAddStates(9, 84);
0639: if (curChar == 60)
0640: jjCheckNAddStates(85, 125);
0641: break;
0642: case 0:
0643: if ((0x100002600L & l) == 0L)
0644: break;
0645: if (kind > 68)
0646: kind = 68;
0647: jjCheckNAdd(0);
0648: break;
0649: case 1:
0650: if ((0xefffffe6ffffd9ffL & l) == 0L)
0651: break;
0652: if (kind > 69)
0653: kind = 69;
0654: jjCheckNAdd(1);
0655: break;
0656: case 3:
0657: if (curChar == 60)
0658: jjCheckNAddStates(85, 125);
0659: break;
0660: case 5:
0661: if ((0x100002600L & l) != 0L)
0662: jjAddStates(126, 127);
0663: break;
0664: case 6:
0665: if (curChar == 62 && kind > 6)
0666: kind = 6;
0667: break;
0668: case 14:
0669: if ((0x100002600L & l) != 0L)
0670: jjAddStates(128, 129);
0671: break;
0672: case 15:
0673: if (curChar == 62 && kind > 7)
0674: kind = 7;
0675: break;
0676: case 23:
0677: if ((0x100002600L & l) != 0L && kind > 8)
0678: kind = 8;
0679: break;
0680: case 26:
0681: if ((0x100002600L & l) != 0L && kind > 9)
0682: kind = 9;
0683: break;
0684: case 33:
0685: if ((0x100002600L & l) != 0L && kind > 10)
0686: kind = 10;
0687: break;
0688: case 38:
0689: if ((0x100002600L & l) != 0L && kind > 11)
0690: kind = 11;
0691: break;
0692: case 46:
0693: if ((0x100002600L & l) != 0L && kind > 12)
0694: kind = 12;
0695: break;
0696: case 53:
0697: if ((0x100002600L & l) != 0L && kind > 13)
0698: kind = 13;
0699: break;
0700: case 58:
0701: if ((0x100002600L & l) != 0L && kind > 14)
0702: kind = 14;
0703: break;
0704: case 65:
0705: if ((0x100002600L & l) != 0L && kind > 15)
0706: kind = 15;
0707: break;
0708: case 72:
0709: if ((0x100002600L & l) != 0L && kind > 16)
0710: kind = 16;
0711: break;
0712: case 78:
0713: if ((0x100002600L & l) != 0L && kind > 17)
0714: kind = 17;
0715: break;
0716: case 86:
0717: if ((0x100002600L & l) != 0L && kind > 18)
0718: kind = 18;
0719: break;
0720: case 93:
0721: if ((0x100002600L & l) != 0L && kind > 19)
0722: kind = 19;
0723: break;
0724: case 102:
0725: if ((0x100002600L & l) != 0L && kind > 20)
0726: kind = 20;
0727: break;
0728: case 108:
0729: if ((0x100002600L & l) != 0L && kind > 21)
0730: kind = 21;
0731: break;
0732: case 118:
0733: if ((0x100002600L & l) != 0L && kind > 22)
0734: kind = 22;
0735: break;
0736: case 124:
0737: if ((0x100002600L & l) != 0L && kind > 23)
0738: kind = 23;
0739: break;
0740: case 129:
0741: if ((0x100002600L & l) != 0L && kind > 24)
0742: kind = 24;
0743: break;
0744: case 136:
0745: if ((0x100002600L & l) != 0L && kind > 25)
0746: kind = 25;
0747: break;
0748: case 141:
0749: if ((0x100002600L & l) != 0L && kind > 26)
0750: kind = 26;
0751: break;
0752: case 149:
0753: if ((0x100002600L & l) != 0L)
0754: jjAddStates(130, 131);
0755: break;
0756: case 150:
0757: if (curChar == 62 && kind > 27)
0758: kind = 27;
0759: break;
0760: case 159:
0761: if ((0x100002600L & l) != 0L)
0762: jjAddStates(132, 133);
0763: break;
0764: case 160:
0765: if (curChar == 62 && kind > 28)
0766: kind = 28;
0767: break;
0768: case 168:
0769: if ((0x100002600L & l) != 0L)
0770: jjAddStates(134, 135);
0771: break;
0772: case 169:
0773: if (curChar == 62 && kind > 30)
0774: kind = 30;
0775: break;
0776: case 177:
0777: if ((0x100002600L & l) != 0L)
0778: jjCheckNAddStates(136, 138);
0779: break;
0780: case 178:
0781: if (curChar == 47)
0782: jjCheckNAdd(179);
0783: break;
0784: case 179:
0785: if (curChar == 62 && kind > 44)
0786: kind = 44;
0787: break;
0788: case 184:
0789: if ((0x100002600L & l) != 0L)
0790: jjCheckNAddStates(139, 141);
0791: break;
0792: case 185:
0793: if (curChar == 47)
0794: jjCheckNAdd(186);
0795: break;
0796: case 186:
0797: if (curChar == 62 && kind > 45)
0798: kind = 45;
0799: break;
0800: case 192:
0801: if ((0x100002600L & l) != 0L)
0802: jjCheckNAddStates(142, 144);
0803: break;
0804: case 193:
0805: if (curChar == 47)
0806: jjCheckNAdd(194);
0807: break;
0808: case 194:
0809: if (curChar == 62 && kind > 46)
0810: kind = 46;
0811: break;
0812: case 201:
0813: if ((0x100002600L & l) != 0L)
0814: jjCheckNAddStates(145, 147);
0815: break;
0816: case 202:
0817: if (curChar == 47)
0818: jjCheckNAdd(203);
0819: break;
0820: case 203:
0821: if (curChar == 62 && kind > 47)
0822: kind = 47;
0823: break;
0824: case 208:
0825: if ((0x100002600L & l) != 0L)
0826: jjCheckNAddStates(148, 150);
0827: break;
0828: case 209:
0829: if (curChar == 47)
0830: jjCheckNAdd(210);
0831: break;
0832: case 210:
0833: if (curChar == 62 && kind > 48)
0834: kind = 48;
0835: break;
0836: case 216:
0837: if ((0x100002600L & l) != 0L)
0838: jjCheckNAddStates(151, 153);
0839: break;
0840: case 217:
0841: if (curChar == 47)
0842: jjCheckNAdd(218);
0843: break;
0844: case 218:
0845: if (curChar == 62 && kind > 49)
0846: kind = 49;
0847: break;
0848: case 220:
0849: if ((0x100002600L & l) != 0L)
0850: jjCheckNAddStates(154, 156);
0851: break;
0852: case 221:
0853: if (curChar == 47)
0854: jjCheckNAdd(222);
0855: break;
0856: case 222:
0857: if (curChar == 62 && kind > 50)
0858: kind = 50;
0859: break;
0860: case 225:
0861: if ((0x100002600L & l) != 0L)
0862: jjCheckNAddStates(157, 159);
0863: break;
0864: case 226:
0865: if (curChar == 47)
0866: jjCheckNAdd(227);
0867: break;
0868: case 227:
0869: if (curChar == 62 && kind > 51)
0870: kind = 51;
0871: break;
0872: case 230:
0873: if ((0x100002600L & l) != 0L)
0874: jjCheckNAddStates(160, 162);
0875: break;
0876: case 231:
0877: if (curChar == 47)
0878: jjCheckNAdd(232);
0879: break;
0880: case 232:
0881: if (curChar == 62 && kind > 52)
0882: kind = 52;
0883: break;
0884: case 235:
0885: if ((0x100002600L & l) != 0L)
0886: jjAddStates(163, 164);
0887: break;
0888: case 236:
0889: if (curChar == 62 && kind > 53)
0890: kind = 53;
0891: break;
0892: case 244:
0893: if ((0x100002600L & l) != 0L)
0894: jjCheckNAddStates(165, 167);
0895: break;
0896: case 245:
0897: if (curChar == 47)
0898: jjCheckNAdd(246);
0899: break;
0900: case 246:
0901: if (curChar == 62 && kind > 54)
0902: kind = 54;
0903: break;
0904: case 253:
0905: if ((0x100002600L & l) != 0L && kind > 55)
0906: kind = 55;
0907: break;
0908: case 260:
0909: if ((0x100002600L & l) != 0L)
0910: jjCheckNAddStates(168, 170);
0911: break;
0912: case 261:
0913: if (curChar == 47)
0914: jjCheckNAdd(262);
0915: break;
0916: case 262:
0917: if (curChar == 62 && kind > 56)
0918: kind = 56;
0919: break;
0920: case 270:
0921: if ((0x100002600L & l) != 0L && kind > 57)
0922: kind = 57;
0923: break;
0924: case 278:
0925: if ((0x100002600L & l) != 0L)
0926: jjCheckNAddStates(171, 173);
0927: break;
0928: case 279:
0929: if (curChar == 47)
0930: jjCheckNAdd(280);
0931: break;
0932: case 280:
0933: if (curChar == 62 && kind > 58)
0934: kind = 58;
0935: break;
0936: case 289:
0937: if ((0x100002600L & l) != 0L && kind > 59)
0938: kind = 59;
0939: break;
0940: case 296:
0941: if ((0x100002600L & l) != 0L)
0942: jjAddStates(174, 175);
0943: break;
0944: case 297:
0945: if (curChar == 62 && kind > 61)
0946: kind = 61;
0947: break;
0948: case 305:
0949: if (curChar == 60)
0950: jjCheckNAddStates(9, 84);
0951: break;
0952: case 306:
0953: if (curChar == 35)
0954: jjCheckNAdd(12);
0955: break;
0956: case 307:
0957: if (curChar == 35)
0958: jjCheckNAdd(21);
0959: break;
0960: case 308:
0961: if (curChar == 35)
0962: jjCheckNAdd(24);
0963: break;
0964: case 309:
0965: if (curChar == 35)
0966: jjCheckNAdd(31);
0967: break;
0968: case 310:
0969: if (curChar == 35)
0970: jjCheckNAdd(36);
0971: break;
0972: case 311:
0973: if (curChar == 35)
0974: jjCheckNAdd(44);
0975: break;
0976: case 312:
0977: if (curChar == 35)
0978: jjCheckNAdd(51);
0979: break;
0980: case 313:
0981: if (curChar == 35)
0982: jjCheckNAdd(56);
0983: break;
0984: case 314:
0985: if (curChar == 35)
0986: jjCheckNAdd(63);
0987: break;
0988: case 315:
0989: if (curChar == 35)
0990: jjCheckNAdd(70);
0991: break;
0992: case 316:
0993: if (curChar == 35)
0994: jjCheckNAdd(76);
0995: break;
0996: case 317:
0997: if (curChar == 35)
0998: jjCheckNAdd(84);
0999: break;
1000: case 318:
1001: if (curChar == 35)
1002: jjCheckNAdd(91);
1003: break;
1004: case 319:
1005: if (curChar == 35)
1006: jjCheckNAdd(100);
1007: break;
1008: case 320:
1009: if (curChar == 35)
1010: jjCheckNAdd(106);
1011: break;
1012: case 321:
1013: if (curChar == 35)
1014: jjCheckNAdd(116);
1015: break;
1016: case 322:
1017: if (curChar == 35)
1018: jjCheckNAdd(122);
1019: break;
1020: case 323:
1021: if (curChar == 35)
1022: jjCheckNAdd(127);
1023: break;
1024: case 324:
1025: if (curChar == 35)
1026: jjCheckNAdd(134);
1027: break;
1028: case 325:
1029: if (curChar == 35)
1030: jjCheckNAdd(139);
1031: break;
1032: case 326:
1033: if (curChar == 35)
1034: jjCheckNAdd(147);
1035: break;
1036: case 327:
1037: if (curChar == 35)
1038: jjCheckNAdd(157);
1039: break;
1040: case 328:
1041: if (curChar == 35)
1042: jjCheckNAdd(166);
1043: break;
1044: case 329:
1045: if (curChar == 35)
1046: jjCheckNAdd(175);
1047: break;
1048: case 330:
1049: if (curChar == 47)
1050: jjCheckNAdd(334);
1051: break;
1052: case 332:
1053: if ((0x100002600L & l) != 0L)
1054: jjAddStates(176, 177);
1055: break;
1056: case 333:
1057: if (curChar == 62 && kind > 31)
1058: kind = 31;
1059: break;
1060: case 335:
1061: if (curChar == 35)
1062: jjCheckNAdd(334);
1063: break;
1064: case 336:
1065: case 532:
1066: if (curChar == 47)
1067: jjCheckNAdd(335);
1068: break;
1069: case 337:
1070: if (curChar == 47)
1071: jjCheckNAdd(343);
1072: break;
1073: case 339:
1074: if ((0x100002600L & l) != 0L)
1075: jjAddStates(178, 179);
1076: break;
1077: case 340:
1078: if (curChar == 62 && kind > 32)
1079: kind = 32;
1080: break;
1081: case 344:
1082: if (curChar == 35)
1083: jjCheckNAdd(343);
1084: break;
1085: case 345:
1086: case 533:
1087: if (curChar == 47)
1088: jjCheckNAdd(344);
1089: break;
1090: case 346:
1091: if (curChar == 47)
1092: jjCheckNAdd(355);
1093: break;
1094: case 348:
1095: if ((0x100002600L & l) != 0L)
1096: jjAddStates(180, 181);
1097: break;
1098: case 349:
1099: if (curChar == 62 && kind > 33)
1100: kind = 33;
1101: break;
1102: case 356:
1103: if (curChar == 35)
1104: jjCheckNAdd(355);
1105: break;
1106: case 357:
1107: case 534:
1108: if (curChar == 47)
1109: jjCheckNAdd(356);
1110: break;
1111: case 358:
1112: if (curChar == 47)
1113: jjCheckNAdd(367);
1114: break;
1115: case 360:
1116: if ((0x100002600L & l) != 0L)
1117: jjAddStates(182, 183);
1118: break;
1119: case 361:
1120: if (curChar == 62 && kind > 34)
1121: kind = 34;
1122: break;
1123: case 368:
1124: if (curChar == 35)
1125: jjCheckNAdd(367);
1126: break;
1127: case 369:
1128: case 535:
1129: if (curChar == 47)
1130: jjCheckNAdd(368);
1131: break;
1132: case 370:
1133: if (curChar == 47)
1134: jjCheckNAdd(379);
1135: break;
1136: case 372:
1137: if ((0x100002600L & l) != 0L)
1138: jjAddStates(184, 185);
1139: break;
1140: case 373:
1141: if (curChar == 62 && kind > 35)
1142: kind = 35;
1143: break;
1144: case 380:
1145: if (curChar == 35)
1146: jjCheckNAdd(379);
1147: break;
1148: case 381:
1149: case 536:
1150: if (curChar == 47)
1151: jjCheckNAdd(380);
1152: break;
1153: case 382:
1154: if (curChar == 47)
1155: jjCheckNAdd(389);
1156: break;
1157: case 384:
1158: if ((0x100002600L & l) != 0L)
1159: jjAddStates(186, 187);
1160: break;
1161: case 385:
1162: if (curChar == 62 && kind > 36)
1163: kind = 36;
1164: break;
1165: case 390:
1166: if (curChar == 35)
1167: jjCheckNAdd(389);
1168: break;
1169: case 391:
1170: case 537:
1171: if (curChar == 47)
1172: jjCheckNAdd(390);
1173: break;
1174: case 392:
1175: if (curChar == 47)
1176: jjCheckNAdd(400);
1177: break;
1178: case 394:
1179: if ((0x100002600L & l) != 0L)
1180: jjAddStates(188, 189);
1181: break;
1182: case 395:
1183: if (curChar == 62 && kind > 37)
1184: kind = 37;
1185: break;
1186: case 401:
1187: if (curChar == 35)
1188: jjCheckNAdd(400);
1189: break;
1190: case 402:
1191: case 538:
1192: if (curChar == 47)
1193: jjCheckNAdd(401);
1194: break;
1195: case 403:
1196: if (curChar == 47)
1197: jjCheckNAdd(411);
1198: break;
1199: case 405:
1200: if ((0x100002600L & l) != 0L)
1201: jjAddStates(190, 191);
1202: break;
1203: case 406:
1204: if (curChar == 62 && kind > 38)
1205: kind = 38;
1206: break;
1207: case 412:
1208: if (curChar == 35)
1209: jjCheckNAdd(411);
1210: break;
1211: case 413:
1212: case 539:
1213: if (curChar == 47)
1214: jjCheckNAdd(412);
1215: break;
1216: case 414:
1217: if (curChar == 47)
1218: jjCheckNAdd(424);
1219: break;
1220: case 416:
1221: if ((0x100002600L & l) != 0L)
1222: jjAddStates(192, 193);
1223: break;
1224: case 417:
1225: if (curChar == 62 && kind > 39)
1226: kind = 39;
1227: break;
1228: case 425:
1229: if (curChar == 35)
1230: jjCheckNAdd(424);
1231: break;
1232: case 426:
1233: case 540:
1234: if (curChar == 47)
1235: jjCheckNAdd(425);
1236: break;
1237: case 427:
1238: if (curChar == 47)
1239: jjCheckNAdd(434);
1240: break;
1241: case 429:
1242: if ((0x100002600L & l) != 0L)
1243: jjAddStates(194, 195);
1244: break;
1245: case 430:
1246: if (curChar == 62 && kind > 40)
1247: kind = 40;
1248: break;
1249: case 435:
1250: if (curChar == 35)
1251: jjCheckNAdd(434);
1252: break;
1253: case 436:
1254: case 541:
1255: if (curChar == 47)
1256: jjCheckNAdd(435);
1257: break;
1258: case 437:
1259: if (curChar == 47)
1260: jjCheckNAdd(447);
1261: break;
1262: case 439:
1263: if ((0x100002600L & l) != 0L)
1264: jjAddStates(196, 197);
1265: break;
1266: case 440:
1267: if (curChar == 62 && kind > 41)
1268: kind = 41;
1269: break;
1270: case 448:
1271: if (curChar == 35)
1272: jjCheckNAdd(447);
1273: break;
1274: case 449:
1275: case 542:
1276: if (curChar == 47)
1277: jjCheckNAdd(448);
1278: break;
1279: case 450:
1280: if (curChar == 47)
1281: jjCheckNAdd(461);
1282: break;
1283: case 452:
1284: if ((0x100002600L & l) != 0L)
1285: jjAddStates(198, 199);
1286: break;
1287: case 453:
1288: if (curChar == 62 && kind > 42)
1289: kind = 42;
1290: break;
1291: case 462:
1292: if (curChar == 35)
1293: jjCheckNAdd(461);
1294: break;
1295: case 463:
1296: case 543:
1297: if (curChar == 47)
1298: jjCheckNAdd(462);
1299: break;
1300: case 464:
1301: if (curChar == 47)
1302: jjCheckNAdd(472);
1303: break;
1304: case 466:
1305: if ((0x100002600L & l) != 0L)
1306: jjAddStates(200, 201);
1307: break;
1308: case 467:
1309: if (curChar == 62 && kind > 43)
1310: kind = 43;
1311: break;
1312: case 473:
1313: if (curChar == 35)
1314: jjCheckNAdd(472);
1315: break;
1316: case 474:
1317: case 544:
1318: if (curChar == 47)
1319: jjCheckNAdd(473);
1320: break;
1321: case 475:
1322: if (curChar == 35)
1323: jjCheckNAdd(182);
1324: break;
1325: case 476:
1326: if (curChar == 35)
1327: jjCheckNAdd(190);
1328: break;
1329: case 477:
1330: if (curChar == 35)
1331: jjCheckNAdd(199);
1332: break;
1333: case 478:
1334: if (curChar == 35)
1335: jjCheckNAdd(206);
1336: break;
1337: case 479:
1338: if (curChar == 35)
1339: jjCheckNAdd(214);
1340: break;
1341: case 480:
1342: if (curChar == 35)
1343: jjCheckNAdd(215);
1344: break;
1345: case 481:
1346: if (curChar == 35)
1347: jjCheckNAdd(223);
1348: break;
1349: case 482:
1350: if (curChar == 35)
1351: jjCheckNAdd(228);
1352: break;
1353: case 483:
1354: if (curChar == 35)
1355: jjCheckNAdd(233);
1356: break;
1357: case 484:
1358: if (curChar == 35)
1359: jjCheckNAdd(242);
1360: break;
1361: case 485:
1362: if (curChar == 35)
1363: jjCheckNAdd(251);
1364: break;
1365: case 486:
1366: if (curChar == 35)
1367: jjCheckNAdd(258);
1368: break;
1369: case 487:
1370: if (curChar == 35)
1371: jjCheckNAdd(268);
1372: break;
1373: case 488:
1374: if (curChar == 35)
1375: jjCheckNAdd(276);
1376: break;
1377: case 489:
1378: if (curChar == 35)
1379: jjCheckNAdd(287);
1380: break;
1381: case 490:
1382: if (curChar == 35)
1383: jjCheckNAdd(294);
1384: break;
1385: case 491:
1386: if (curChar == 47)
1387: jjCheckNAdd(499);
1388: break;
1389: case 493:
1390: if ((0x100002600L & l) != 0L)
1391: jjAddStates(202, 203);
1392: break;
1393: case 494:
1394: if (curChar == 62 && kind > 60)
1395: kind = 60;
1396: break;
1397: case 500:
1398: if (curChar == 35)
1399: jjCheckNAdd(499);
1400: break;
1401: case 501:
1402: case 545:
1403: if (curChar == 47)
1404: jjCheckNAdd(500);
1405: break;
1406: case 502:
1407: if (curChar == 35)
1408: jjCheckNAdd(304);
1409: break;
1410: case 503:
1411: if (curChar == 47)
1412: jjCheckNAdd(513);
1413: break;
1414: case 505:
1415: if ((0x100002600L & l) != 0L)
1416: jjAddStates(204, 205);
1417: break;
1418: case 506:
1419: if (curChar == 62 && kind > 62)
1420: kind = 62;
1421: break;
1422: case 514:
1423: if (curChar == 35)
1424: jjCheckNAdd(513);
1425: break;
1426: case 515:
1427: case 546:
1428: if (curChar == 47)
1429: jjCheckNAdd(514);
1430: break;
1431: case 518:
1432: if ((0x100002600L & l) != 0L && kind > 65)
1433: kind = 65;
1434: break;
1435: case 521:
1436: if (curChar == 35)
1437: jjstateSet[jjnewStateCnt++] = 520;
1438: break;
1439: case 523:
1440: if (curChar == 47)
1441: jjstateSet[jjnewStateCnt++] = 524;
1442: break;
1443: case 524:
1444: if (curChar == 62 && kind > 66)
1445: kind = 66;
1446: break;
1447: case 527:
1448: if (curChar == 35)
1449: jjstateSet[jjnewStateCnt++] = 526;
1450: break;
1451: case 528:
1452: if (curChar == 35)
1453: jjstateSet[jjnewStateCnt++] = 529;
1454: break;
1455: case 530:
1456: case 553:
1457: if (curChar == 47)
1458: jjCheckNAdd(528);
1459: break;
1460: case 549:
1461: if (curChar == 35)
1462: jjstateSet[jjnewStateCnt++] = 548;
1463: break;
1464: case 552:
1465: if (curChar == 35)
1466: jjstateSet[jjnewStateCnt++] = 551;
1467: break;
1468: case 554:
1469: if (curChar == 60)
1470: jjAddStates(7, 8);
1471: break;
1472: case 555:
1473: if (curChar == 45 && kind > 29)
1474: kind = 29;
1475: break;
1476: case 556:
1477: if (curChar == 45)
1478: jjstateSet[jjnewStateCnt++] = 555;
1479: break;
1480: case 557:
1481: if (curChar == 35)
1482: jjstateSet[jjnewStateCnt++] = 556;
1483: break;
1484: case 559:
1485: if (curChar == 36)
1486: jjCheckNAddStates(206, 209);
1487: break;
1488: case 560:
1489: if ((0x3ff001000000000L & l) != 0L)
1490: jjCheckNAddStates(206, 209);
1491: break;
1492: case 561:
1493: if (curChar == 46)
1494: jjstateSet[jjnewStateCnt++] = 562;
1495: break;
1496: case 562:
1497: if (curChar == 36)
1498: jjCheckNAddStates(210, 213);
1499: break;
1500: case 563:
1501: if ((0x3ff001000000000L & l) != 0L)
1502: jjCheckNAddStates(210, 213);
1503: break;
1504: case 564:
1505: if ((0x100002600L & l) != 0L)
1506: jjCheckNAddTwoStates(564, 565);
1507: break;
1508: case 565:
1509: if (curChar == 62 && kind > 64)
1510: kind = 64;
1511: break;
1512: case 566:
1513: if (curChar == 47)
1514: jjstateSet[jjnewStateCnt++] = 558;
1515: break;
1516: default:
1517: break;
1518: }
1519: } while (i != startsAt);
1520: } else if (curChar < 128) {
1521: long l = 1L << (curChar & 077);
1522: MatchLoop: do {
1523: switch (jjstateSet[--i]) {
1524: case 2:
1525: if ((0xf7fffffff7ffffffL & l) != 0L) {
1526: if (kind > 69)
1527: kind = 69;
1528: jjCheckNAdd(1);
1529: } else if ((0x800000008000000L & l) != 0L) {
1530: if (kind > 70)
1531: kind = 70;
1532: }
1533: if (curChar == 91)
1534: jjAddStates(7, 8);
1535: if (curChar == 91)
1536: jjAddStates(214, 274);
1537: break;
1538: case 1:
1539: if ((0xf7fffffff7ffffffL & l) == 0L)
1540: break;
1541: if (kind > 69)
1542: kind = 69;
1543: jjCheckNAdd(1);
1544: break;
1545: case 4:
1546: if (curChar == 116)
1547: jjAddStates(126, 127);
1548: break;
1549: case 6:
1550: if (curChar == 93 && kind > 6)
1551: kind = 6;
1552: break;
1553: case 7:
1554: if (curChar == 112)
1555: jjstateSet[jjnewStateCnt++] = 4;
1556: break;
1557: case 8:
1558: if (curChar == 109)
1559: jjstateSet[jjnewStateCnt++] = 7;
1560: break;
1561: case 9:
1562: if (curChar == 101)
1563: jjstateSet[jjnewStateCnt++] = 8;
1564: break;
1565: case 10:
1566: if (curChar == 116)
1567: jjstateSet[jjnewStateCnt++] = 9;
1568: break;
1569: case 11:
1570: if (curChar == 116)
1571: jjstateSet[jjnewStateCnt++] = 10;
1572: break;
1573: case 12:
1574: if (curChar == 97)
1575: jjstateSet[jjnewStateCnt++] = 11;
1576: break;
1577: case 13:
1578: if (curChar == 114)
1579: jjAddStates(128, 129);
1580: break;
1581: case 15:
1582: if (curChar == 93 && kind > 7)
1583: kind = 7;
1584: break;
1585: case 16:
1586: if (curChar == 101)
1587: jjstateSet[jjnewStateCnt++] = 13;
1588: break;
1589: case 17:
1590: if (curChar == 118)
1591: jjstateSet[jjnewStateCnt++] = 16;
1592: break;
1593: case 18:
1594: if (curChar == 111)
1595: jjstateSet[jjnewStateCnt++] = 17;
1596: break;
1597: case 19:
1598: if (curChar == 99)
1599: jjstateSet[jjnewStateCnt++] = 18;
1600: break;
1601: case 20:
1602: if (curChar == 101)
1603: jjstateSet[jjnewStateCnt++] = 19;
1604: break;
1605: case 21:
1606: if (curChar == 114)
1607: jjstateSet[jjnewStateCnt++] = 20;
1608: break;
1609: case 22:
1610: if (curChar == 102)
1611: jjstateSet[jjnewStateCnt++] = 23;
1612: break;
1613: case 24:
1614: if (curChar == 105)
1615: jjstateSet[jjnewStateCnt++] = 22;
1616: break;
1617: case 25:
1618: if (curChar == 102)
1619: jjstateSet[jjnewStateCnt++] = 26;
1620: break;
1621: case 27:
1622: if (curChar == 105)
1623: jjstateSet[jjnewStateCnt++] = 25;
1624: break;
1625: case 28:
1626: if (curChar == 101)
1627: jjstateSet[jjnewStateCnt++] = 27;
1628: break;
1629: case 29:
1630: if (curChar == 115)
1631: jjstateSet[jjnewStateCnt++] = 28;
1632: break;
1633: case 30:
1634: if (curChar == 108)
1635: jjstateSet[jjnewStateCnt++] = 29;
1636: break;
1637: case 31:
1638: if (curChar == 101)
1639: jjstateSet[jjnewStateCnt++] = 30;
1640: break;
1641: case 32:
1642: if (curChar == 116)
1643: jjstateSet[jjnewStateCnt++] = 33;
1644: break;
1645: case 34:
1646: if (curChar == 115)
1647: jjstateSet[jjnewStateCnt++] = 32;
1648: break;
1649: case 35:
1650: if (curChar == 105)
1651: jjstateSet[jjnewStateCnt++] = 34;
1652: break;
1653: case 36:
1654: if (curChar == 108)
1655: jjstateSet[jjnewStateCnt++] = 35;
1656: break;
1657: case 37:
1658: if (curChar == 104)
1659: jjstateSet[jjnewStateCnt++] = 38;
1660: break;
1661: case 39:
1662: if (curChar == 99)
1663: jjstateSet[jjnewStateCnt++] = 37;
1664: break;
1665: case 40:
1666: if (curChar == 97)
1667: jjstateSet[jjnewStateCnt++] = 39;
1668: break;
1669: case 41:
1670: if (curChar == 101)
1671: jjstateSet[jjnewStateCnt++] = 40;
1672: break;
1673: case 42:
1674: if (curChar == 114)
1675: jjstateSet[jjnewStateCnt++] = 41;
1676: break;
1677: case 43:
1678: if (curChar == 111)
1679: jjstateSet[jjnewStateCnt++] = 42;
1680: break;
1681: case 44:
1682: if (curChar == 102)
1683: jjstateSet[jjnewStateCnt++] = 43;
1684: break;
1685: case 45:
1686: if (curChar == 104)
1687: jjstateSet[jjnewStateCnt++] = 46;
1688: break;
1689: case 47:
1690: if (curChar == 99)
1691: jjstateSet[jjnewStateCnt++] = 45;
1692: break;
1693: case 48:
1694: if (curChar == 116)
1695: jjstateSet[jjnewStateCnt++] = 47;
1696: break;
1697: case 49:
1698: if (curChar == 105)
1699: jjstateSet[jjnewStateCnt++] = 48;
1700: break;
1701: case 50:
1702: if (curChar == 119)
1703: jjstateSet[jjnewStateCnt++] = 49;
1704: break;
1705: case 51:
1706: if (curChar == 115)
1707: jjstateSet[jjnewStateCnt++] = 50;
1708: break;
1709: case 52:
1710: if (curChar == 101)
1711: jjstateSet[jjnewStateCnt++] = 53;
1712: break;
1713: case 54:
1714: if (curChar == 115)
1715: jjstateSet[jjnewStateCnt++] = 52;
1716: break;
1717: case 55:
1718: if (curChar == 97)
1719: jjstateSet[jjnewStateCnt++] = 54;
1720: break;
1721: case 56:
1722: if (curChar == 99)
1723: jjstateSet[jjnewStateCnt++] = 55;
1724: break;
1725: case 57:
1726: if (curChar == 110)
1727: jjstateSet[jjnewStateCnt++] = 58;
1728: break;
1729: case 59:
1730: if (curChar == 103)
1731: jjstateSet[jjnewStateCnt++] = 57;
1732: break;
1733: case 60:
1734: if (curChar == 105)
1735: jjstateSet[jjnewStateCnt++] = 59;
1736: break;
1737: case 61:
1738: if (curChar == 115)
1739: jjstateSet[jjnewStateCnt++] = 60;
1740: break;
1741: case 62:
1742: if (curChar == 115)
1743: jjstateSet[jjnewStateCnt++] = 61;
1744: break;
1745: case 63:
1746: if (curChar == 97)
1747: jjstateSet[jjnewStateCnt++] = 62;
1748: break;
1749: case 64:
1750: if (curChar == 108)
1751: jjstateSet[jjnewStateCnt++] = 65;
1752: break;
1753: case 66:
1754: if (curChar == 97)
1755: jjstateSet[jjnewStateCnt++] = 64;
1756: break;
1757: case 67:
1758: if (curChar == 98)
1759: jjstateSet[jjnewStateCnt++] = 66;
1760: break;
1761: case 68:
1762: if (curChar == 111)
1763: jjstateSet[jjnewStateCnt++] = 67;
1764: break;
1765: case 69:
1766: if (curChar == 108)
1767: jjstateSet[jjnewStateCnt++] = 68;
1768: break;
1769: case 70:
1770: if (curChar == 103)
1771: jjstateSet[jjnewStateCnt++] = 69;
1772: break;
1773: case 71:
1774: if (curChar == 108)
1775: jjstateSet[jjnewStateCnt++] = 72;
1776: break;
1777: case 73:
1778: if (curChar == 97)
1779: jjstateSet[jjnewStateCnt++] = 71;
1780: break;
1781: case 74:
1782: if (curChar == 99)
1783: jjstateSet[jjnewStateCnt++] = 73;
1784: break;
1785: case 75:
1786: if (curChar == 111)
1787: jjstateSet[jjnewStateCnt++] = 74;
1788: break;
1789: case 76:
1790: if (curChar == 108)
1791: jjstateSet[jjnewStateCnt++] = 75;
1792: break;
1793: case 77:
1794: if (curChar == 101)
1795: jjstateSet[jjnewStateCnt++] = 78;
1796: break;
1797: case 79:
1798: if (curChar == 100)
1799: jjstateSet[jjnewStateCnt++] = 77;
1800: break;
1801: case 80:
1802: if (curChar == 117)
1803: jjstateSet[jjnewStateCnt++] = 79;
1804: break;
1805: case 81:
1806: if (curChar == 108)
1807: jjstateSet[jjnewStateCnt++] = 80;
1808: break;
1809: case 82:
1810: if (curChar == 99)
1811: jjstateSet[jjnewStateCnt++] = 81;
1812: break;
1813: case 83:
1814: if (curChar == 110)
1815: jjstateSet[jjnewStateCnt++] = 82;
1816: break;
1817: case 84:
1818: if (curChar == 105)
1819: jjstateSet[jjnewStateCnt++] = 83;
1820: break;
1821: case 85:
1822: if (curChar == 116)
1823: jjstateSet[jjnewStateCnt++] = 86;
1824: break;
1825: case 87:
1826: if (curChar == 114)
1827: jjstateSet[jjnewStateCnt++] = 85;
1828: break;
1829: case 88:
1830: if (curChar == 111)
1831: jjstateSet[jjnewStateCnt++] = 87;
1832: break;
1833: case 89:
1834: if (curChar == 112)
1835: jjstateSet[jjnewStateCnt++] = 88;
1836: break;
1837: case 90:
1838: if (curChar == 109)
1839: jjstateSet[jjnewStateCnt++] = 89;
1840: break;
1841: case 91:
1842: if (curChar == 105)
1843: jjstateSet[jjnewStateCnt++] = 90;
1844: break;
1845: case 92:
1846: if (curChar == 110)
1847: jjstateSet[jjnewStateCnt++] = 93;
1848: break;
1849: case 94:
1850: if (curChar == 111)
1851: jjstateSet[jjnewStateCnt++] = 92;
1852: break;
1853: case 95:
1854: if (curChar == 105)
1855: jjstateSet[jjnewStateCnt++] = 94;
1856: break;
1857: case 96:
1858: if (curChar == 116)
1859: jjstateSet[jjnewStateCnt++] = 95;
1860: break;
1861: case 97:
1862: if (curChar == 99)
1863: jjstateSet[jjnewStateCnt++] = 96;
1864: break;
1865: case 98:
1866: if (curChar == 110)
1867: jjstateSet[jjnewStateCnt++] = 97;
1868: break;
1869: case 99:
1870: if (curChar == 117)
1871: jjstateSet[jjnewStateCnt++] = 98;
1872: break;
1873: case 100:
1874: if (curChar == 102)
1875: jjstateSet[jjnewStateCnt++] = 99;
1876: break;
1877: case 101:
1878: if (curChar == 111)
1879: jjstateSet[jjnewStateCnt++] = 102;
1880: break;
1881: case 103:
1882: if (curChar == 114)
1883: jjstateSet[jjnewStateCnt++] = 101;
1884: break;
1885: case 104:
1886: if (curChar == 99)
1887: jjstateSet[jjnewStateCnt++] = 103;
1888: break;
1889: case 105:
1890: if (curChar == 97)
1891: jjstateSet[jjnewStateCnt++] = 104;
1892: break;
1893: case 106:
1894: if (curChar == 109)
1895: jjstateSet[jjnewStateCnt++] = 105;
1896: break;
1897: case 107:
1898: if (curChar == 109)
1899: jjstateSet[jjnewStateCnt++] = 108;
1900: break;
1901: case 109:
1902: if (curChar == 114)
1903: jjstateSet[jjnewStateCnt++] = 107;
1904: break;
1905: case 110:
1906: if (curChar == 111)
1907: jjstateSet[jjnewStateCnt++] = 109;
1908: break;
1909: case 111:
1910: if (curChar == 102)
1911: jjstateSet[jjnewStateCnt++] = 110;
1912: break;
1913: case 112:
1914: if (curChar == 115)
1915: jjstateSet[jjnewStateCnt++] = 111;
1916: break;
1917: case 113:
1918: if (curChar == 110)
1919: jjstateSet[jjnewStateCnt++] = 112;
1920: break;
1921: case 114:
1922: if (curChar == 97)
1923: jjstateSet[jjnewStateCnt++] = 113;
1924: break;
1925: case 115:
1926: if (curChar == 114)
1927: jjstateSet[jjnewStateCnt++] = 114;
1928: break;
1929: case 116:
1930: if (curChar == 116)
1931: jjstateSet[jjnewStateCnt++] = 115;
1932: break;
1933: case 117:
1934: if (curChar == 116)
1935: jjstateSet[jjnewStateCnt++] = 118;
1936: break;
1937: case 119:
1938: if (curChar == 105)
1939: jjstateSet[jjnewStateCnt++] = 117;
1940: break;
1941: case 120:
1942: if (curChar == 115)
1943: jjstateSet[jjnewStateCnt++] = 119;
1944: break;
1945: case 121:
1946: if (curChar == 105)
1947: jjstateSet[jjnewStateCnt++] = 120;
1948: break;
1949: case 122:
1950: if (curChar == 118)
1951: jjstateSet[jjnewStateCnt++] = 121;
1952: break;
1953: case 123:
1954: if (curChar == 112)
1955: jjstateSet[jjnewStateCnt++] = 124;
1956: break;
1957: case 125:
1958: if (curChar == 111)
1959: jjstateSet[jjnewStateCnt++] = 123;
1960: break;
1961: case 126:
1962: if (curChar == 116)
1963: jjstateSet[jjnewStateCnt++] = 125;
1964: break;
1965: case 127:
1966: if (curChar == 115)
1967: jjstateSet[jjnewStateCnt++] = 126;
1968: break;
1969: case 128:
1970: if (curChar == 110)
1971: jjstateSet[jjnewStateCnt++] = 129;
1972: break;
1973: case 130:
1974: if (curChar == 114)
1975: jjstateSet[jjnewStateCnt++] = 128;
1976: break;
1977: case 131:
1978: if (curChar == 117)
1979: jjstateSet[jjnewStateCnt++] = 130;
1980: break;
1981: case 132:
1982: if (curChar == 116)
1983: jjstateSet[jjnewStateCnt++] = 131;
1984: break;
1985: case 133:
1986: if (curChar == 101)
1987: jjstateSet[jjnewStateCnt++] = 132;
1988: break;
1989: case 134:
1990: if (curChar == 114)
1991: jjstateSet[jjnewStateCnt++] = 133;
1992: break;
1993: case 135:
1994: if (curChar == 108)
1995: jjstateSet[jjnewStateCnt++] = 136;
1996: break;
1997: case 137:
1998: if (curChar == 108)
1999: jjstateSet[jjnewStateCnt++] = 135;
2000: break;
2001: case 138:
2002: if (curChar == 97)
2003: jjstateSet[jjnewStateCnt++] = 137;
2004: break;
2005: case 139:
2006: if (curChar == 99)
2007: jjstateSet[jjnewStateCnt++] = 138;
2008: break;
2009: case 140:
2010: if (curChar == 103)
2011: jjstateSet[jjnewStateCnt++] = 141;
2012: break;
2013: case 142:
2014: if (curChar == 110)
2015: jjstateSet[jjnewStateCnt++] = 140;
2016: break;
2017: case 143:
2018: if (curChar == 105)
2019: jjstateSet[jjnewStateCnt++] = 142;
2020: break;
2021: case 144:
2022: if (curChar == 116)
2023: jjstateSet[jjnewStateCnt++] = 143;
2024: break;
2025: case 145:
2026: if (curChar == 116)
2027: jjstateSet[jjnewStateCnt++] = 144;
2028: break;
2029: case 146:
2030: if (curChar == 101)
2031: jjstateSet[jjnewStateCnt++] = 145;
2032: break;
2033: case 147:
2034: if (curChar == 115)
2035: jjstateSet[jjnewStateCnt++] = 146;
2036: break;
2037: case 148:
2038: if (curChar == 115)
2039: jjAddStates(130, 131);
2040: break;
2041: case 150:
2042: if (curChar == 93 && kind > 27)
2043: kind = 27;
2044: break;
2045: case 151:
2046: if (curChar == 115)
2047: jjstateSet[jjnewStateCnt++] = 148;
2048: break;
2049: case 152:
2050: if (curChar == 101)
2051: jjstateSet[jjnewStateCnt++] = 151;
2052: break;
2053: case 153:
2054: if (curChar == 114)
2055: jjstateSet[jjnewStateCnt++] = 152;
2056: break;
2057: case 154:
2058: if (curChar == 112)
2059: jjstateSet[jjnewStateCnt++] = 153;
2060: break;
2061: case 155:
2062: if (curChar == 109)
2063: jjstateSet[jjnewStateCnt++] = 154;
2064: break;
2065: case 156:
2066: if (curChar == 111)
2067: jjstateSet[jjnewStateCnt++] = 155;
2068: break;
2069: case 157:
2070: if (curChar == 99)
2071: jjstateSet[jjnewStateCnt++] = 156;
2072: break;
2073: case 158:
2074: if (curChar == 116)
2075: jjAddStates(132, 133);
2076: break;
2077: case 160:
2078: if (curChar == 93 && kind > 28)
2079: kind = 28;
2080: break;
2081: case 161:
2082: if (curChar == 110)
2083: jjstateSet[jjnewStateCnt++] = 158;
2084: break;
2085: case 162:
2086: if (curChar == 101)
2087: jjstateSet[jjnewStateCnt++] = 161;
2088: break;
2089: case 163:
2090: if (curChar == 109)
2091: jjstateSet[jjnewStateCnt++] = 162;
2092: break;
2093: case 164:
2094: if (curChar == 109)
2095: jjstateSet[jjnewStateCnt++] = 163;
2096: break;
2097: case 165:
2098: if (curChar == 111)
2099: jjstateSet[jjnewStateCnt++] = 164;
2100: break;
2101: case 166:
2102: if (curChar == 99)
2103: jjstateSet[jjnewStateCnt++] = 165;
2104: break;
2105: case 167:
2106: if (curChar == 101)
2107: jjAddStates(134, 135);
2108: break;
2109: case 169:
2110: if (curChar == 93 && kind > 30)
2111: kind = 30;
2112: break;
2113: case 170:
2114: if (curChar == 115)
2115: jjstateSet[jjnewStateCnt++] = 167;
2116: break;
2117: case 171:
2118: if (curChar == 114)
2119: jjstateSet[jjnewStateCnt++] = 170;
2120: break;
2121: case 172:
2122: if (curChar == 97)
2123: jjstateSet[jjnewStateCnt++] = 171;
2124: break;
2125: case 173:
2126: if (curChar == 112)
2127: jjstateSet[jjnewStateCnt++] = 172;
2128: break;
2129: case 174:
2130: if (curChar == 111)
2131: jjstateSet[jjnewStateCnt++] = 173;
2132: break;
2133: case 175:
2134: if (curChar == 110)
2135: jjstateSet[jjnewStateCnt++] = 174;
2136: break;
2137: case 176:
2138: if (curChar == 101)
2139: jjAddStates(136, 138);
2140: break;
2141: case 179:
2142: if (curChar == 93 && kind > 44)
2143: kind = 44;
2144: break;
2145: case 180:
2146: if (curChar == 115)
2147: jjstateSet[jjnewStateCnt++] = 176;
2148: break;
2149: case 181:
2150: if (curChar == 108)
2151: jjstateSet[jjnewStateCnt++] = 180;
2152: break;
2153: case 182:
2154: if (curChar == 101)
2155: jjstateSet[jjnewStateCnt++] = 181;
2156: break;
2157: case 183:
2158: if (curChar == 107)
2159: jjAddStates(139, 141);
2160: break;
2161: case 186:
2162: if (curChar == 93 && kind > 45)
2163: kind = 45;
2164: break;
2165: case 187:
2166: if (curChar == 97)
2167: jjstateSet[jjnewStateCnt++] = 183;
2168: break;
2169: case 188:
2170: if (curChar == 101)
2171: jjstateSet[jjnewStateCnt++] = 187;
2172: break;
2173: case 189:
2174: if (curChar == 114)
2175: jjstateSet[jjnewStateCnt++] = 188;
2176: break;
2177: case 190:
2178: if (curChar == 98)
2179: jjstateSet[jjnewStateCnt++] = 189;
2180: break;
2181: case 191:
2182: if (curChar == 110)
2183: jjAddStates(142, 144);
2184: break;
2185: case 194:
2186: if (curChar == 93 && kind > 46)
2187: kind = 46;
2188: break;
2189: case 195:
2190: if (curChar == 114)
2191: jjstateSet[jjnewStateCnt++] = 191;
2192: break;
2193: case 196:
2194: if (curChar == 117)
2195: jjstateSet[jjnewStateCnt++] = 195;
2196: break;
2197: case 197:
2198: if (curChar == 116)
2199: jjstateSet[jjnewStateCnt++] = 196;
2200: break;
2201: case 198:
2202: if (curChar == 101)
2203: jjstateSet[jjnewStateCnt++] = 197;
2204: break;
2205: case 199:
2206: if (curChar == 114)
2207: jjstateSet[jjnewStateCnt++] = 198;
2208: break;
2209: case 200:
2210: if (curChar == 112)
2211: jjAddStates(145, 147);
2212: break;
2213: case 203:
2214: if (curChar == 93 && kind > 47)
2215: kind = 47;
2216: break;
2217: case 204:
2218: if (curChar == 111)
2219: jjstateSet[jjnewStateCnt++] = 200;
2220: break;
2221: case 205:
2222: if (curChar == 116)
2223: jjstateSet[jjnewStateCnt++] = 204;
2224: break;
2225: case 206:
2226: if (curChar == 115)
2227: jjstateSet[jjnewStateCnt++] = 205;
2228: break;
2229: case 207:
2230: if (curChar == 104)
2231: jjAddStates(148, 150);
2232: break;
2233: case 210:
2234: if (curChar == 93 && kind > 48)
2235: kind = 48;
2236: break;
2237: case 211:
2238: if (curChar == 115)
2239: jjstateSet[jjnewStateCnt++] = 207;
2240: break;
2241: case 212:
2242: if (curChar == 117)
2243: jjstateSet[jjnewStateCnt++] = 211;
2244: break;
2245: case 213:
2246: if (curChar == 108)
2247: jjstateSet[jjnewStateCnt++] = 212;
2248: break;
2249: case 214:
2250: if (curChar == 102)
2251: jjstateSet[jjnewStateCnt++] = 213;
2252: break;
2253: case 215:
2254: if (curChar == 116)
2255: jjAddStates(151, 153);
2256: break;
2257: case 218:
2258: if (curChar == 93 && kind > 49)
2259: kind = 49;
2260: break;
2261: case 219:
2262: if (curChar == 116)
2263: jjAddStates(154, 156);
2264: break;
2265: case 222:
2266: if (curChar == 93 && kind > 50)
2267: kind = 50;
2268: break;
2269: case 223:
2270: if (curChar == 108)
2271: jjstateSet[jjnewStateCnt++] = 219;
2272: break;
2273: case 224:
2274: if (curChar == 116)
2275: jjAddStates(157, 159);
2276: break;
2277: case 227:
2278: if (curChar == 93 && kind > 51)
2279: kind = 51;
2280: break;
2281: case 228:
2282: if (curChar == 114)
2283: jjstateSet[jjnewStateCnt++] = 224;
2284: break;
2285: case 229:
2286: if (curChar == 116)
2287: jjAddStates(160, 162);
2288: break;
2289: case 232:
2290: if (curChar == 93 && kind > 52)
2291: kind = 52;
2292: break;
2293: case 233:
2294: if (curChar == 110)
2295: jjstateSet[jjnewStateCnt++] = 229;
2296: break;
2297: case 234:
2298: if (curChar == 116)
2299: jjAddStates(163, 164);
2300: break;
2301: case 236:
2302: if (curChar == 93 && kind > 53)
2303: kind = 53;
2304: break;
2305: case 237:
2306: if (curChar == 108)
2307: jjstateSet[jjnewStateCnt++] = 234;
2308: break;
2309: case 238:
2310: if (curChar == 117)
2311: jjstateSet[jjnewStateCnt++] = 237;
2312: break;
2313: case 239:
2314: if (curChar == 97)
2315: jjstateSet[jjnewStateCnt++] = 238;
2316: break;
2317: case 240:
2318: if (curChar == 102)
2319: jjstateSet[jjnewStateCnt++] = 239;
2320: break;
2321: case 241:
2322: if (curChar == 101)
2323: jjstateSet[jjnewStateCnt++] = 240;
2324: break;
2325: case 242:
2326: if (curChar == 100)
2327: jjstateSet[jjnewStateCnt++] = 241;
2328: break;
2329: case 243:
2330: if (curChar == 100)
2331: jjAddStates(165, 167);
2332: break;
2333: case 246:
2334: if (curChar == 93 && kind > 54)
2335: kind = 54;
2336: break;
2337: case 247:
2338: if (curChar == 101)
2339: jjstateSet[jjnewStateCnt++] = 243;
2340: break;
2341: case 248:
2342: if (curChar == 116)
2343: jjstateSet[jjnewStateCnt++] = 247;
2344: break;
2345: case 249:
2346: if (curChar == 115)
2347: jjstateSet[jjnewStateCnt++] = 248;
2348: break;
2349: case 250:
2350: if (curChar == 101)
2351: jjstateSet[jjnewStateCnt++] = 249;
2352: break;
2353: case 251:
2354: if (curChar == 110)
2355: jjstateSet[jjnewStateCnt++] = 250;
2356: break;
2357: case 252:
2358: if (curChar == 100)
2359: jjstateSet[jjnewStateCnt++] = 253;
2360: break;
2361: case 254:
2362: if (curChar == 101)
2363: jjstateSet[jjnewStateCnt++] = 252;
2364: break;
2365: case 255:
2366: if (curChar == 116)
2367: jjstateSet[jjnewStateCnt++] = 254;
2368: break;
2369: case 256:
2370: if (curChar == 115)
2371: jjstateSet[jjnewStateCnt++] = 255;
2372: break;
2373: case 257:
2374: if (curChar == 101)
2375: jjstateSet[jjnewStateCnt++] = 256;
2376: break;
2377: case 258:
2378: if (curChar == 110)
2379: jjstateSet[jjnewStateCnt++] = 257;
2380: break;
2381: case 259:
2382: if (curChar == 101)
2383: jjAddStates(168, 170);
2384: break;
2385: case 262:
2386: if (curChar == 93 && kind > 56)
2387: kind = 56;
2388: break;
2389: case 263:
2390: if (curChar == 115)
2391: jjstateSet[jjnewStateCnt++] = 259;
2392: break;
2393: case 264:
2394: if (curChar == 114)
2395: jjstateSet[jjnewStateCnt++] = 263;
2396: break;
2397: case 265:
2398: if (curChar == 117)
2399: jjstateSet[jjnewStateCnt++] = 264;
2400: break;
2401: case 266:
2402: if (curChar == 99)
2403: jjstateSet[jjnewStateCnt++] = 265;
2404: break;
2405: case 267:
2406: if (curChar == 101)
2407: jjstateSet[jjnewStateCnt++] = 266;
2408: break;
2409: case 268:
2410: if (curChar == 114)
2411: jjstateSet[jjnewStateCnt++] = 267;
2412: break;
2413: case 269:
2414: if (curChar == 101)
2415: jjstateSet[jjnewStateCnt++] = 270;
2416: break;
2417: case 271:
2418: if (curChar == 115)
2419: jjstateSet[jjnewStateCnt++] = 269;
2420: break;
2421: case 272:
2422: if (curChar == 114)
2423: jjstateSet[jjnewStateCnt++] = 271;
2424: break;
2425: case 273:
2426: if (curChar == 117)
2427: jjstateSet[jjnewStateCnt++] = 272;
2428: break;
2429: case 274:
2430: if (curChar == 99)
2431: jjstateSet[jjnewStateCnt++] = 273;
2432: break;
2433: case 275:
2434: if (curChar == 101)
2435: jjstateSet[jjnewStateCnt++] = 274;
2436: break;
2437: case 276:
2438: if (curChar == 114)
2439: jjstateSet[jjnewStateCnt++] = 275;
2440: break;
2441: case 277:
2442: if (curChar == 107)
2443: jjAddStates(171, 173);
2444: break;
2445: case 280:
2446: if (curChar == 93 && kind > 58)
2447: kind = 58;
2448: break;
2449: case 281:
2450: if (curChar == 99)
2451: jjstateSet[jjnewStateCnt++] = 277;
2452: break;
2453: case 282:
2454: if (curChar == 97)
2455: jjstateSet[jjnewStateCnt++] = 281;
2456: break;
2457: case 283:
2458: if (curChar == 98)
2459: jjstateSet[jjnewStateCnt++] = 282;
2460: break;
2461: case 284:
2462: if (curChar == 108)
2463: jjstateSet[jjnewStateCnt++] = 283;
2464: break;
2465: case 285:
2466: if (curChar == 108)
2467: jjstateSet[jjnewStateCnt++] = 284;
2468: break;
2469: case 286:
2470: if (curChar == 97)
2471: jjstateSet[jjnewStateCnt++] = 285;
2472: break;
2473: case 287:
2474: if (curChar == 102)
2475: jjstateSet[jjnewStateCnt++] = 286;
2476: break;
2477: case 288:
2478: if (curChar == 101)
2479: jjstateSet[jjnewStateCnt++] = 289;
2480: break;
2481: case 290:
2482: if (curChar == 112)
2483: jjstateSet[jjnewStateCnt++] = 288;
2484: break;
2485: case 291:
2486: if (curChar == 97)
2487: jjstateSet[jjnewStateCnt++] = 290;
2488: break;
2489: case 292:
2490: if (curChar == 99)
2491: jjstateSet[jjnewStateCnt++] = 291;
2492: break;
2493: case 293:
2494: if (curChar == 115)
2495: jjstateSet[jjnewStateCnt++] = 292;
2496: break;
2497: case 294:
2498: if (curChar == 101)
2499: jjstateSet[jjnewStateCnt++] = 293;
2500: break;
2501: case 295:
2502: if (curChar == 101)
2503: jjAddStates(174, 175);
2504: break;
2505: case 297:
2506: if (curChar == 93 && kind > 61)
2507: kind = 61;
2508: break;
2509: case 298:
2510: if (curChar == 112)
2511: jjstateSet[jjnewStateCnt++] = 295;
2512: break;
2513: case 299:
2514: if (curChar == 97)
2515: jjstateSet[jjnewStateCnt++] = 298;
2516: break;
2517: case 300:
2518: if (curChar == 99)
2519: jjstateSet[jjnewStateCnt++] = 299;
2520: break;
2521: case 301:
2522: if (curChar == 115)
2523: jjstateSet[jjnewStateCnt++] = 300;
2524: break;
2525: case 302:
2526: if (curChar == 101)
2527: jjstateSet[jjnewStateCnt++] = 301;
2528: break;
2529: case 303:
2530: if (curChar == 111)
2531: jjstateSet[jjnewStateCnt++] = 302;
2532: break;
2533: case 304:
2534: if (curChar == 110)
2535: jjstateSet[jjnewStateCnt++] = 303;
2536: break;
2537: case 331:
2538: if (curChar == 102)
2539: jjAddStates(176, 177);
2540: break;
2541: case 333:
2542: if (curChar == 93 && kind > 31)
2543: kind = 31;
2544: break;
2545: case 334:
2546: if (curChar == 105)
2547: jjstateSet[jjnewStateCnt++] = 331;
2548: break;
2549: case 338:
2550: if (curChar == 116)
2551: jjAddStates(178, 179);
2552: break;
2553: case 340:
2554: if (curChar == 93 && kind > 32)
2555: kind = 32;
2556: break;
2557: case 341:
2558: if (curChar == 115)
2559: jjstateSet[jjnewStateCnt++] = 338;
2560: break;
2561: case 342:
2562: if (curChar == 105)
2563: jjstateSet[jjnewStateCnt++] = 341;
2564: break;
2565: case 343:
2566: if (curChar == 108)
2567: jjstateSet[jjnewStateCnt++] = 342;
2568: break;
2569: case 347:
2570: if (curChar == 114)
2571: jjAddStates(180, 181);
2572: break;
2573: case 349:
2574: if (curChar == 93 && kind > 33)
2575: kind = 33;
2576: break;
2577: case 350:
2578: if (curChar == 101)
2579: jjstateSet[jjnewStateCnt++] = 347;
2580: break;
2581: case 351:
2582: if (curChar == 118)
2583: jjstateSet[jjnewStateCnt++] = 350;
2584: break;
2585: case 352:
2586: if (curChar == 111)
2587: jjstateSet[jjnewStateCnt++] = 351;
2588: break;
2589: case 353:
2590: if (curChar == 99)
2591: jjstateSet[jjnewStateCnt++] = 352;
2592: break;
2593: case 354:
2594: if (curChar == 101)
2595: jjstateSet[jjnewStateCnt++] = 353;
2596: break;
2597: case 355:
2598: if (curChar == 114)
2599: jjstateSet[jjnewStateCnt++] = 354;
2600: break;
2601: case 359:
2602: if (curChar == 116)
2603: jjAddStates(182, 183);
2604: break;
2605: case 361:
2606: if (curChar == 93 && kind > 34)
2607: kind = 34;
2608: break;
2609: case 362:
2610: if (curChar == 112)
2611: jjstateSet[jjnewStateCnt++] = 359;
2612: break;
2613: case 363:
2614: if (curChar == 109)
2615: jjstateSet[jjnewStateCnt++] = 362;
2616: break;
2617: case 364:
2618: if (curChar == 101)
2619: jjstateSet[jjnewStateCnt++] = 363;
2620: break;
2621: case 365:
2622: if (curChar == 116)
2623: jjstateSet[jjnewStateCnt++] = 364;
2624: break;
2625: case 366:
2626: if (curChar == 116)
2627: jjstateSet[jjnewStateCnt++] = 365;
2628: break;
2629: case 367:
2630: if (curChar == 97)
2631: jjstateSet[jjnewStateCnt++] = 366;
2632: break;
2633: case 371:
2634: if (curChar == 104)
2635: jjAddStates(184, 185);
2636: break;
2637: case 373:
2638: if (curChar == 93 && kind > 35)
2639: kind = 35;
2640: break;
2641: case 374:
2642: if (curChar == 99)
2643: jjstateSet[jjnewStateCnt++] = 371;
2644: break;
2645: case 375:
2646: if (curChar == 97)
2647: jjstateSet[jjnewStateCnt++] = 374;
2648: break;
2649: case 376:
2650: if (curChar == 101)
2651: jjstateSet[jjnewStateCnt++] = 375;
2652: break;
2653: case 377:
2654: if (curChar == 114)
2655: jjstateSet[jjnewStateCnt++] = 376;
2656: break;
2657: case 378:
2658: if (curChar == 111)
2659: jjstateSet[jjnewStateCnt++] = 377;
2660: break;
2661: case 379:
2662: if (curChar == 102)
2663: jjstateSet[jjnewStateCnt++] = 378;
2664: break;
2665: case 383:
2666: if (curChar == 108)
2667: jjAddStates(186, 187);
2668: break;
2669: case 385:
2670: if (curChar == 93 && kind > 36)
2671: kind = 36;
2672: break;
2673: case 386:
2674: if (curChar == 97)
2675: jjstateSet[jjnewStateCnt++] = 383;
2676: break;
2677: case 387:
2678: if (curChar == 99)
2679: jjstateSet[jjnewStateCnt++] = 386;
2680: break;
2681: case 388:
2682: if (curChar == 111)
2683: jjstateSet[jjnewStateCnt++] = 387;
2684: break;
2685: case 389:
2686: if (curChar == 108)
2687: jjstateSet[jjnewStateCnt++] = 388;
2688: break;
2689: case 393:
2690: if (curChar == 108)
2691: jjAddStates(188, 189);
2692: break;
2693: case 395:
2694: if (curChar == 93 && kind > 37)
2695: kind = 37;
2696: break;
2697: case 396:
2698: if (curChar == 97)
2699: jjstateSet[jjnewStateCnt++] = 393;
2700: break;
2701: case 397:
2702: if (curChar == 98)
2703: jjstateSet[jjnewStateCnt++] = 396;
2704: break;
2705: case 398:
2706: if (curChar == 111)
2707: jjstateSet[jjnewStateCnt++] = 397;
2708: break;
2709: case 399:
2710: if (curChar == 108)
2711: jjstateSet[jjnewStateCnt++] = 398;
2712: break;
2713: case 400:
2714: if (curChar == 103)
2715: jjstateSet[jjnewStateCnt++] = 399;
2716: break;
2717: case 404:
2718: if (curChar == 110)
2719: jjAddStates(190, 191);
2720: break;
2721: case 406:
2722: if (curChar == 93 && kind > 38)
2723: kind = 38;
2724: break;
2725: case 407:
2726: if (curChar == 103)
2727: jjstateSet[jjnewStateCnt++] = 404;
2728: break;
2729: case 408:
2730: if (curChar == 105)
2731: jjstateSet[jjnewStateCnt++] = 407;
2732: break;
2733: case 409:
2734: if (curChar == 115)
2735: jjstateSet[jjnewStateCnt++] = 408;
2736: break;
2737: case 410:
2738: if (curChar == 115)
2739: jjstateSet[jjnewStateCnt++] = 409;
2740: break;
2741: case 411:
2742: if (curChar == 97)
2743: jjstateSet[jjnewStateCnt++] = 410;
2744: break;
2745: case 415:
2746: if (curChar == 110)
2747: jjAddStates(192, 193);
2748: break;
2749: case 417:
2750: if (curChar == 93 && kind > 39)
2751: kind = 39;
2752: break;
2753: case 418:
2754: if (curChar == 111)
2755: jjstateSet[jjnewStateCnt++] = 415;
2756: break;
2757: case 419:
2758: if (curChar == 105)
2759: jjstateSet[jjnewStateCnt++] = 418;
2760: break;
2761: case 420:
2762: if (curChar == 116)
2763: jjstateSet[jjnewStateCnt++] = 419;
2764: break;
2765: case 421:
2766: if (curChar == 99)
2767: jjstateSet[jjnewStateCnt++] = 420;
2768: break;
2769: case 422:
2770: if (curChar == 110)
2771: jjstateSet[jjnewStateCnt++] = 421;
2772: break;
2773: case 423:
2774: if (curChar == 117)
2775: jjstateSet[jjnewStateCnt++] = 422;
2776: break;
2777: case 424:
2778: if (curChar == 102)
2779: jjstateSet[jjnewStateCnt++] = 423;
2780: break;
2781: case 428:
2782: if (curChar == 111)
2783: jjAddStates(194, 195);
2784: break;
2785: case 430:
2786: if (curChar == 93 && kind > 40)
2787: kind = 40;
2788: break;
2789: case 431:
2790: if (curChar == 114)
2791: jjstateSet[jjnewStateCnt++] = 428;
2792: break;
2793: case 432:
2794: if (curChar == 99)
2795: jjstateSet[jjnewStateCnt++] = 431;
2796: break;
2797: case 433:
2798: if (curChar == 97)
2799: jjstateSet[jjnewStateCnt++] = 432;
2800: break;
2801: case 434:
2802: if (curChar == 109)
2803: jjstateSet[jjnewStateCnt++] = 433;
2804: break;
2805: case 438:
2806: if (curChar == 115)
2807: jjAddStates(196, 197);
2808: break;
2809: case 440:
2810: if (curChar == 93 && kind > 41)
2811: kind = 41;
2812: break;
2813: case 441:
2814: if (curChar == 115)
2815: jjstateSet[jjnewStateCnt++] = 438;
2816: break;
2817: case 442:
2818: if (curChar == 101)
2819: jjstateSet[jjnewStateCnt++] = 441;
2820: break;
2821: case 443:
2822: if (curChar == 114)
2823: jjstateSet[jjnewStateCnt++] = 442;
2824: break;
2825: case 444:
2826: if (curChar == 112)
2827: jjstateSet[jjnewStateCnt++] = 443;
2828: break;
2829: case 445:
2830: if (curChar == 109)
2831: jjstateSet[jjnewStateCnt++] = 444;
2832: break;
2833: case 446:
2834: if (curChar == 111)
2835: jjstateSet[jjnewStateCnt++] = 445;
2836: break;
2837: case 447:
2838: if (curChar == 99)
2839: jjstateSet[jjnewStateCnt++] = 446;
2840: break;
2841: case 451:
2842: if (curChar == 109)
2843: jjAddStates(198, 199);
2844: break;
2845: case 453:
2846: if (curChar == 93 && kind > 42)
2847: kind = 42;
2848: break;
2849: case 454:
2850: if (curChar == 114)
2851: jjstateSet[jjnewStateCnt++] = 451;
2852: break;
2853: case 455:
2854: if (curChar == 111)
2855: jjstateSet[jjnewStateCnt++] = 454;
2856: break;
2857: case 456:
2858: if (curChar == 102)
2859: jjstateSet[jjnewStateCnt++] = 455;
2860: break;
2861: case 457:
2862: if (curChar == 115)
2863: jjstateSet[jjnewStateCnt++] = 456;
2864: break;
2865: case 458:
2866: if (curChar == 110)
2867: jjstateSet[jjnewStateCnt++] = 457;
2868: break;
2869: case 459:
2870: if (curChar == 97)
2871: jjstateSet[jjnewStateCnt++] = 458;
2872: break;
2873: case 460:
2874: if (curChar == 114)
2875: jjstateSet[jjnewStateCnt++] = 459;
2876: break;
2877: case 461:
2878: if (curChar == 116)
2879: jjstateSet[jjnewStateCnt++] = 460;
2880: break;
2881: case 465:
2882: if (curChar == 104)
2883: jjAddStates(200, 201);
2884: break;
2885: case 467:
2886: if (curChar == 93 && kind > 43)
2887: kind = 43;
2888: break;
2889: case 468:
2890: if (curChar == 99)
2891: jjstateSet[jjnewStateCnt++] = 465;
2892: break;
2893: case 469:
2894: if (curChar == 116)
2895: jjstateSet[jjnewStateCnt++] = 468;
2896: break;
2897: case 470:
2898: if (curChar == 105)
2899: jjstateSet[jjnewStateCnt++] = 469;
2900: break;
2901: case 471:
2902: if (curChar == 119)
2903: jjstateSet[jjnewStateCnt++] = 470;
2904: break;
2905: case 472:
2906: if (curChar == 115)
2907: jjstateSet[jjnewStateCnt++] = 471;
2908: break;
2909: case 492:
2910: if (curChar == 101)
2911: jjAddStates(202, 203);
2912: break;
2913: case 494:
2914: if (curChar == 93 && kind > 60)
2915: kind = 60;
2916: break;
2917: case 495:
2918: if (curChar == 112)
2919: jjstateSet[jjnewStateCnt++] = 492;
2920: break;
2921: case 496:
2922: if (curChar == 97)
2923: jjstateSet[jjnewStateCnt++] = 495;
2924: break;
2925: case 497:
2926: if (curChar == 99)
2927: jjstateSet[jjnewStateCnt++] = 496;
2928: break;
2929: case 498:
2930: if (curChar == 115)
2931: jjstateSet[jjnewStateCnt++] = 497;
2932: break;
2933: case 499:
2934: if (curChar == 101)
2935: jjstateSet[jjnewStateCnt++] = 498;
2936: break;
2937: case 504:
2938: if (curChar == 101)
2939: jjAddStates(204, 205);
2940: break;
2941: case 506:
2942: if (curChar == 93 && kind > 62)
2943: kind = 62;
2944: break;
2945: case 507:
2946: if (curChar == 112)
2947: jjstateSet[jjnewStateCnt++] = 504;
2948: break;
2949: case 508:
2950: if (curChar == 97)
2951: jjstateSet[jjnewStateCnt++] = 507;
2952: break;
2953: case 509:
2954: if (curChar == 99)
2955: jjstateSet[jjnewStateCnt++] = 508;
2956: break;
2957: case 510:
2958: if (curChar == 115)
2959: jjstateSet[jjnewStateCnt++] = 509;
2960: break;
2961: case 511:
2962: if (curChar == 101)
2963: jjstateSet[jjnewStateCnt++] = 510;
2964: break;
2965: case 512:
2966: if (curChar == 111)
2967: jjstateSet[jjnewStateCnt++] = 511;
2968: break;
2969: case 513:
2970: if (curChar == 110)
2971: jjstateSet[jjnewStateCnt++] = 512;
2972: break;
2973: case 516:
2974: if (curChar == 64 && kind > 63)
2975: kind = 63;
2976: break;
2977: case 517:
2978: if (curChar == 108)
2979: jjstateSet[jjnewStateCnt++] = 518;
2980: break;
2981: case 519:
2982: case 547:
2983: if (curChar == 116)
2984: jjCheckNAdd(517);
2985: break;
2986: case 520:
2987: if (curChar == 102)
2988: jjstateSet[jjnewStateCnt++] = 519;
2989: break;
2990: case 522:
2991: if (curChar == 108)
2992: jjAddStates(275, 276);
2993: break;
2994: case 524:
2995: if (curChar == 93 && kind > 66)
2996: kind = 66;
2997: break;
2998: case 525:
2999: case 550:
3000: if (curChar == 116)
3001: jjCheckNAdd(522);
3002: break;
3003: case 526:
3004: if (curChar == 102)
3005: jjstateSet[jjnewStateCnt++] = 525;
3006: break;
3007: case 529:
3008: if ((0x7fffffe87fffffeL & l) == 0L)
3009: break;
3010: if (kind > 67)
3011: kind = 67;
3012: jjstateSet[jjnewStateCnt++] = 529;
3013: break;
3014: case 531:
3015: if (curChar == 91)
3016: jjAddStates(214, 274);
3017: break;
3018: case 548:
3019: if (curChar == 102)
3020: jjstateSet[jjnewStateCnt++] = 547;
3021: break;
3022: case 551:
3023: if (curChar == 102)
3024: jjstateSet[jjnewStateCnt++] = 550;
3025: break;
3026: case 554:
3027: if (curChar == 91)
3028: jjAddStates(7, 8);
3029: break;
3030: case 558:
3031: if (curChar == 64)
3032: jjCheckNAddStates(277, 279);
3033: break;
3034: case 559:
3035: case 560:
3036: if ((0x7fffffe87ffffffL & l) != 0L)
3037: jjCheckNAddStates(206, 209);
3038: break;
3039: case 562:
3040: case 563:
3041: if ((0x7fffffe87ffffffL & l) != 0L)
3042: jjCheckNAddStates(210, 213);
3043: break;
3044: case 565:
3045: if (curChar == 93 && kind > 64)
3046: kind = 64;
3047: break;
3048: default:
3049: break;
3050: }
3051: } while (i != startsAt);
3052: } else {
3053: int hiByte = (int) (curChar >> 8);
3054: int i1 = hiByte >> 6;
3055: long l1 = 1L << (hiByte & 077);
3056: int i2 = (curChar & 0xff) >> 6;
3057: long l2 = 1L << (curChar & 077);
3058: MatchLoop: do {
3059: switch (jjstateSet[--i]) {
3060: case 2:
3061: case 1:
3062: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3063: break;
3064: if (kind > 69)
3065: kind = 69;
3066: jjCheckNAdd(1);
3067: break;
3068: case 559:
3069: case 560:
3070: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3071: jjCheckNAddStates(206, 209);
3072: break;
3073: case 562:
3074: case 563:
3075: if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3076: jjCheckNAddStates(210, 213);
3077: break;
3078: default:
3079: break;
3080: }
3081: } while (i != startsAt);
3082: }
3083: if (kind != 0x7fffffff) {
3084: jjmatchedKind = kind;
3085: jjmatchedPos = curPos;
3086: kind = 0x7fffffff;
3087: }
3088: ++curPos;
3089: if ((i = jjnewStateCnt) == (startsAt = 567 - (jjnewStateCnt = startsAt)))
3090: return curPos;
3091: try {
3092: curChar = input_stream.readChar();
3093: } catch (java.io.IOException e) {
3094: return curPos;
3095: }
3096: }
3097: }
3098:
3099: private final int jjStopStringLiteralDfa_2(int pos, long active0,
3100: long active1) {
3101: switch (pos) {
3102: case 0:
3103: if ((active1 & 0x800000000000L) != 0L)
3104: return 2;
3105: if ((active1 & 0xe0000000180000L) != 0L) {
3106: jjmatchedKind = 120;
3107: return 34;
3108: }
3109: if ((active1 & 0x8000000000L) != 0L)
3110: return 36;
3111: return -1;
3112: case 1:
3113: if ((active1 & 0x60000000000000L) != 0L)
3114: return 34;
3115: if ((active1 & 0x80000000180000L) != 0L) {
3116: if (jjmatchedPos != 1) {
3117: jjmatchedKind = 120;
3118: jjmatchedPos = 1;
3119: }
3120: return 34;
3121: }
3122: return -1;
3123: case 2:
3124: if ((active1 & 0x80000000180000L) != 0L) {
3125: jjmatchedKind = 120;
3126: jjmatchedPos = 2;
3127: return 34;
3128: }
3129: return -1;
3130: case 3:
3131: if ((active1 & 0x100000L) != 0L)
3132: return 34;
3133: if ((active1 & 0x80000000080000L) != 0L) {
3134: jjmatchedKind = 120;
3135: jjmatchedPos = 3;
3136: return 34;
3137: }
3138: return -1;
3139: default:
3140: return -1;
3141: }
3142: }
3143:
3144: private final int jjStartNfa_2(int pos, long active0, long active1) {
3145: return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0,
3146: active1), pos + 1);
3147: }
3148:
3149: private final int jjStartNfaWithStates_2(int pos, int kind,
3150: int state) {
3151: jjmatchedKind = kind;
3152: jjmatchedPos = pos;
3153: try {
3154: curChar = input_stream.readChar();
3155: } catch (java.io.IOException e) {
3156: return pos + 1;
3157: }
3158: return jjMoveNfa_2(state, pos + 1);
3159: }
3160:
3161: private final int jjMoveStringLiteralDfa0_2() {
3162: switch (curChar) {
3163: case 33:
3164: jjmatchedKind = 107;
3165: return jjMoveStringLiteralDfa1_2(0x20000000L);
3166: case 37:
3167: return jjStopAtPos(0, 104);
3168: case 40:
3169: return jjStopAtPos(0, 113);
3170: case 41:
3171: return jjStopAtPos(0, 114);
3172: case 42:
3173: jjmatchedKind = 100;
3174: return jjMoveStringLiteralDfa1_2(0x2000000000L);
3175: case 43:
3176: return jjStopAtPos(0, 98);
3177: case 44:
3178: return jjStopAtPos(0, 108);
3179: case 45:
3180: return jjStopAtPos(0, 99);
3181: case 46:
3182: jjmatchedKind = 87;
3183: return jjMoveStringLiteralDfa1_2(0x4001000000L);
3184: case 47:
3185: return jjStartNfaWithStates_2(0, 103, 36);
3186: case 58:
3187: return jjStopAtPos(0, 110);
3188: case 59:
3189: return jjStopAtPos(0, 109);
3190: case 61:
3191: jjmatchedKind = 91;
3192: return jjMoveStringLiteralDfa1_2(0x10000000L);
3193: case 62:
3194: return jjStopAtPos(0, 123);
3195: case 63:
3196: jjmatchedKind = 89;
3197: return jjMoveStringLiteralDfa1_2(0x4000000L);
3198: case 91:
3199: return jjStartNfaWithStates_2(0, 111, 2);
3200: case 93:
3201: return jjStopAtPos(0, 112);
3202: case 97:
3203: return jjMoveStringLiteralDfa1_2(0x40000000000000L);
3204: case 102:
3205: return jjMoveStringLiteralDfa1_2(0x80000L);
3206: case 105:
3207: return jjMoveStringLiteralDfa1_2(0x20000000000000L);
3208: case 116:
3209: return jjMoveStringLiteralDfa1_2(0x100000L);
3210: case 117:
3211: return jjMoveStringLiteralDfa1_2(0x80000000000000L);
3212: case 123:
3213: return jjStopAtPos(0, 115);
3214: case 125:
3215: return jjStopAtPos(0, 116);
3216: default:
3217: return jjMoveNfa_2(1, 0);
3218: }
3219: }
3220:
3221: private final int jjMoveStringLiteralDfa1_2(long active1) {
3222: try {
3223: curChar = input_stream.readChar();
3224: } catch (java.io.IOException e) {
3225: jjStopStringLiteralDfa_2(0, 0L, active1);
3226: return 1;
3227: }
3228: switch (curChar) {
3229: case 42:
3230: if ((active1 & 0x2000000000L) != 0L)
3231: return jjStopAtPos(1, 101);
3232: break;
3233: case 46:
3234: if ((active1 & 0x1000000L) != 0L) {
3235: jjmatchedKind = 88;
3236: jjmatchedPos = 1;
3237: }
3238: return jjMoveStringLiteralDfa2_2(active1, 0x4000000000L);
3239: case 61:
3240: if ((active1 & 0x10000000L) != 0L)
3241: return jjStopAtPos(1, 92);
3242: else if ((active1 & 0x20000000L) != 0L)
3243: return jjStopAtPos(1, 93);
3244: break;
3245: case 63:
3246: if ((active1 & 0x4000000L) != 0L)
3247: return jjStopAtPos(1, 90);
3248: break;
3249: case 97:
3250: return jjMoveStringLiteralDfa2_2(active1, 0x80000L);
3251: case 110:
3252: if ((active1 & 0x20000000000000L) != 0L)
3253: return jjStartNfaWithStates_2(1, 117, 34);
3254: break;
3255: case 114:
3256: return jjMoveStringLiteralDfa2_2(active1, 0x100000L);
3257: case 115:
3258: if ((active1 & 0x40000000000000L) != 0L)
3259: return jjStartNfaWithStates_2(1, 118, 34);
3260: return jjMoveStringLiteralDfa2_2(active1, 0x80000000000000L);
3261: default:
3262: break;
3263: }
3264: return jjStartNfa_2(0, 0L, active1);
3265: }
3266:
3267: private final int jjMoveStringLiteralDfa2_2(long old1, long active1) {
3268: if (((active1 &= old1)) == 0L)
3269: return jjStartNfa_2(0, 0L, old1);
3270: try {
3271: curChar = input_stream.readChar();
3272: } catch (java.io.IOException e) {
3273: jjStopStringLiteralDfa_2(1, 0L, active1);
3274: return 2;
3275: }
3276: switch (curChar) {
3277: case 46:
3278: if ((active1 & 0x4000000000L) != 0L)
3279: return jjStopAtPos(2, 102);
3280: break;
3281: case 105:
3282: return jjMoveStringLiteralDfa3_2(active1, 0x80000000000000L);
3283: case 108:
3284: return jjMoveStringLiteralDfa3_2(active1, 0x80000L);
3285: case 117:
3286: return jjMoveStringLiteralDfa3_2(active1, 0x100000L);
3287: default:
3288: break;
3289: }
3290: return jjStartNfa_2(1, 0L, active1);
3291: }
3292:
3293: private final int jjMoveStringLiteralDfa3_2(long old1, long active1) {
3294: if (((active1 &= old1)) == 0L)
3295: return jjStartNfa_2(1, 0L, old1);
3296: try {
3297: curChar = input_stream.readChar();
3298: } catch (java.io.IOException e) {
3299: jjStopStringLiteralDfa_2(2, 0L, active1);
3300: return 3;
3301: }
3302: switch (curChar) {
3303: case 101:
3304: if ((active1 & 0x100000L) != 0L)
3305: return jjStartNfaWithStates_2(3, 84, 34);
3306: break;
3307: case 110:
3308: return jjMoveStringLiteralDfa4_2(active1, 0x80000000000000L);
3309: case 115:
3310: return jjMoveStringLiteralDfa4_2(active1, 0x80000L);
3311: default:
3312: break;
3313: }
3314: return jjStartNfa_2(2, 0L, active1);
3315: }
3316:
3317: private final int jjMoveStringLiteralDfa4_2(long old1, long active1) {
3318: if (((active1 &= old1)) == 0L)
3319: return jjStartNfa_2(2, 0L, old1);
3320: try {
3321: curChar = input_stream.readChar();
3322: } catch (java.io.IOException e) {
3323: jjStopStringLiteralDfa_2(3, 0L, active1);
3324: return 4;
3325: }
3326: switch (curChar) {
3327: case 101:
3328: if ((active1 & 0x80000L) != 0L)
3329: return jjStartNfaWithStates_2(4, 83, 34);
3330: break;
3331: case 103:
3332: if ((active1 & 0x80000000000000L) != 0L)
3333: return jjStartNfaWithStates_2(4, 119, 34);
3334: break;
3335: default:
3336: break;
3337: }
3338: return jjStartNfa_2(3, 0L, active1);
3339: }
3340:
3341: private final int jjMoveNfa_2(int startState, int curPos) {
3342: int[] nextStates;
3343: int startsAt = 0;
3344: jjnewStateCnt = 73;
3345: int i = 1;
3346: jjstateSet[0] = startState;
3347: int j, kind = 0x7fffffff;
3348: for (;;) {
3349: if (++jjround == 0x7fffffff)
3350: ReInitRounds();
3351: if (curChar < 64) {
3352: long l = 1L << curChar;
3353: MatchLoop: do {
3354: switch (jjstateSet[--i]) {
3355: case 36:
3356: if (curChar == 62 && kind > 124)
3357: kind = 124;
3358: break;
3359: case 1:
3360: if ((0x3ff000000000000L & l) != 0L) {
3361: if (kind > 85)
3362: kind = 85;
3363: jjCheckNAddStates(280, 282);
3364: } else if ((0x100002600L & l) != 0L) {
3365: if (kind > 73)
3366: kind = 73;
3367: jjCheckNAdd(0);
3368: } else if (curChar == 38)
3369: jjAddStates(283, 287);
3370: else if (curChar == 47)
3371: jjAddStates(288, 289);
3372: else if (curChar == 36) {
3373: if (kind > 120)
3374: kind = 120;
3375: jjCheckNAdd(34);
3376: } else if (curChar == 60)
3377: jjCheckNAdd(27);
3378: else if (curChar == 39)
3379: jjCheckNAddStates(290, 292);
3380: else if (curChar == 34)
3381: jjCheckNAddStates(293, 295);
3382: if (curChar == 38) {
3383: if (kind > 105)
3384: kind = 105;
3385: } else if (curChar == 60) {
3386: if (kind > 94)
3387: kind = 94;
3388: }
3389: if (curChar == 60)
3390: jjstateSet[jjnewStateCnt++] = 2;
3391: break;
3392: case 0:
3393: if ((0x100002600L & l) == 0L)
3394: break;
3395: if (kind > 73)
3396: kind = 73;
3397: jjCheckNAdd(0);
3398: break;
3399: case 2:
3400: if ((0xa00000000L & l) != 0L)
3401: jjstateSet[jjnewStateCnt++] = 4;
3402: break;
3403: case 3:
3404: if (curChar == 45 && kind > 74)
3405: kind = 74;
3406: break;
3407: case 4:
3408: if (curChar == 45)
3409: jjstateSet[jjnewStateCnt++] = 3;
3410: break;
3411: case 5:
3412: if (curChar == 34)
3413: jjCheckNAddStates(293, 295);
3414: break;
3415: case 6:
3416: if ((0xfffffffbffffffffL & l) != 0L)
3417: jjCheckNAddStates(293, 295);
3418: break;
3419: case 8:
3420: if ((0x9400000000L & l) != 0L)
3421: jjCheckNAddStates(293, 295);
3422: break;
3423: case 9:
3424: if (curChar == 34 && kind > 81)
3425: kind = 81;
3426: break;
3427: case 11:
3428: if ((0x3ff000000000000L & l) != 0L)
3429: jjCheckNAddStates(293, 295);
3430: break;
3431: case 12:
3432: if (curChar == 39)
3433: jjCheckNAddStates(290, 292);
3434: break;
3435: case 13:
3436: if ((0xffffff7fffffffffL & l) != 0L)
3437: jjCheckNAddStates(290, 292);
3438: break;
3439: case 15:
3440: if ((0x9400000000L & l) != 0L)
3441: jjCheckNAddStates(290, 292);
3442: break;
3443: case 16:
3444: if (curChar == 39 && kind > 81)
3445: kind = 81;
3446: break;
3447: case 18:
3448: if ((0x3ff000000000000L & l) != 0L)
3449: jjCheckNAddStates(290, 292);
3450: break;
3451: case 20:
3452: if (curChar == 34)
3453: jjCheckNAddTwoStates(21, 22);
3454: break;
3455: case 21:
3456: if ((0xfffffffbffffffffL & l) != 0L)
3457: jjCheckNAddTwoStates(21, 22);
3458: break;
3459: case 22:
3460: if (curChar == 34 && kind > 82)
3461: kind = 82;
3462: break;
3463: case 23:
3464: if (curChar == 39)
3465: jjCheckNAddTwoStates(24, 25);
3466: break;
3467: case 24:
3468: if ((0xffffff7fffffffffL & l) != 0L)
3469: jjCheckNAddTwoStates(24, 25);
3470: break;
3471: case 25:
3472: if (curChar == 39 && kind > 82)
3473: kind = 82;
3474: break;
3475: case 26:
3476: if (curChar == 60 && kind > 94)
3477: kind = 94;
3478: break;
3479: case 27:
3480: if (curChar == 61 && kind > 95)
3481: kind = 95;
3482: break;
3483: case 28:
3484: if (curChar == 60)
3485: jjCheckNAdd(27);
3486: break;
3487: case 29:
3488: case 70:
3489: if (curChar == 38 && kind > 105)
3490: kind = 105;
3491: break;
3492: case 33:
3493: if (curChar != 36)
3494: break;
3495: if (kind > 120)
3496: kind = 120;
3497: jjCheckNAdd(34);
3498: break;
3499: case 34:
3500: if ((0x3ff001000000000L & l) == 0L)
3501: break;
3502: if (kind > 120)
3503: kind = 120;
3504: jjCheckNAdd(34);
3505: break;
3506: case 35:
3507: if (curChar == 47)
3508: jjAddStates(288, 289);
3509: break;
3510: case 38:
3511: if ((0x3ff000000000000L & l) == 0L)
3512: break;
3513: if (kind > 85)
3514: kind = 85;
3515: jjCheckNAddStates(280, 282);
3516: break;
3517: case 39:
3518: if ((0x3ff000000000000L & l) == 0L)
3519: break;
3520: if (kind > 85)
3521: kind = 85;
3522: jjCheckNAdd(39);
3523: break;
3524: case 40:
3525: if ((0x3ff000000000000L & l) != 0L)
3526: jjCheckNAddTwoStates(40, 41);
3527: break;
3528: case 41:
3529: if (curChar == 46)
3530: jjCheckNAdd(42);
3531: break;
3532: case 42:
3533: if ((0x3ff000000000000L & l) == 0L)
3534: break;
3535: if (kind > 86)
3536: kind = 86;
3537: jjCheckNAdd(42);
3538: break;
3539: case 56:
3540: if (curChar == 38)
3541: jjAddStates(283, 287);
3542: break;
3543: case 57:
3544: if (curChar == 59 && kind > 94)
3545: kind = 94;
3546: break;
3547: case 60:
3548: if (curChar == 59)
3549: jjCheckNAdd(27);
3550: break;
3551: case 63:
3552: if (curChar == 59 && kind > 96)
3553: kind = 96;
3554: break;
3555: case 66:
3556: if (curChar == 61 && kind > 97)
3557: kind = 97;
3558: break;
3559: case 67:
3560: if (curChar == 59)
3561: jjstateSet[jjnewStateCnt++] = 66;
3562: break;
3563: default:
3564: break;
3565: }
3566: } while (i != startsAt);
3567: } else if (curChar < 128) {
3568: long l = 1L << (curChar & 077);
3569: MatchLoop: do {
3570: switch (jjstateSet[--i]) {
3571: case 36:
3572: if (curChar == 93 && kind > 124)
3573: kind = 124;
3574: break;
3575: case 1:
3576: if ((0x7fffffe87ffffffL & l) != 0L) {
3577: if (kind > 120)
3578: kind = 120;
3579: jjCheckNAdd(34);
3580: } else if (curChar == 92)
3581: jjAddStates(296, 299);
3582: else if (curChar == 124)
3583: jjstateSet[jjnewStateCnt++] = 31;
3584: else if (curChar == 91)
3585: jjstateSet[jjnewStateCnt++] = 2;
3586: if (curChar == 103)
3587: jjCheckNAddTwoStates(51, 72);
3588: else if (curChar == 108)
3589: jjCheckNAddTwoStates(44, 46);
3590: else if (curChar == 124) {
3591: if (kind > 106)
3592: kind = 106;
3593: } else if (curChar == 114)
3594: jjAddStates(300, 301);
3595: break;
3596: case 6:
3597: if ((0xffffffffefffffffL & l) != 0L)
3598: jjCheckNAddStates(293, 295);
3599: break;
3600: case 7:
3601: if (curChar == 92)
3602: jjAddStates(302, 303);
3603: break;
3604: case 8:
3605: if ((0x1450c610000000L & l) != 0L)
3606: jjCheckNAddStates(293, 295);
3607: break;
3608: case 10:
3609: if (curChar == 120)
3610: jjstateSet[jjnewStateCnt++] = 11;
3611: break;
3612: case 11:
3613: if ((0x7e0000007eL & l) != 0L)
3614: jjCheckNAddStates(293, 295);
3615: break;
3616: case 13:
3617: if ((0xffffffffefffffffL & l) != 0L)
3618: jjCheckNAddStates(290, 292);
3619: break;
3620: case 14:
3621: if (curChar == 92)
3622: jjAddStates(304, 305);
3623: break;
3624: case 15:
3625: if ((0x1450c610000000L & l) != 0L)
3626: jjCheckNAddStates(290, 292);
3627: break;
3628: case 17:
3629: if (curChar == 120)
3630: jjstateSet[jjnewStateCnt++] = 18;
3631: break;
3632: case 18:
3633: if ((0x7e0000007eL & l) != 0L)
3634: jjCheckNAddStates(290, 292);
3635: break;
3636: case 19:
3637: if (curChar == 114)
3638: jjAddStates(300, 301);
3639: break;
3640: case 21:
3641: jjAddStates(306, 307);
3642: break;
3643: case 24:
3644: jjAddStates(308, 309);
3645: break;
3646: case 30:
3647: case 31:
3648: if (curChar == 124 && kind > 106)
3649: kind = 106;
3650: break;
3651: case 32:
3652: if (curChar == 124)
3653: jjstateSet[jjnewStateCnt++] = 31;
3654: break;
3655: case 33:
3656: case 34:
3657: if ((0x7fffffe87ffffffL & l) == 0L)
3658: break;
3659: if (kind > 120)
3660: kind = 120;
3661: jjCheckNAdd(34);
3662: break;
3663: case 43:
3664: if (curChar == 108)
3665: jjCheckNAddTwoStates(44, 46);
3666: break;
3667: case 44:
3668: if (curChar == 116 && kind > 94)
3669: kind = 94;
3670: break;
3671: case 45:
3672: if (curChar == 101 && kind > 95)
3673: kind = 95;
3674: break;
3675: case 46:
3676: case 49:
3677: if (curChar == 116)
3678: jjCheckNAdd(45);
3679: break;
3680: case 47:
3681: if (curChar == 92)
3682: jjAddStates(296, 299);
3683: break;
3684: case 48:
3685: if (curChar == 108)
3686: jjCheckNAdd(44);
3687: break;
3688: case 50:
3689: if (curChar == 108)
3690: jjstateSet[jjnewStateCnt++] = 49;
3691: break;
3692: case 51:
3693: if (curChar == 116 && kind > 96)
3694: kind = 96;
3695: break;
3696: case 52:
3697: if (curChar == 103)
3698: jjCheckNAdd(51);
3699: break;
3700: case 53:
3701: if (curChar == 101 && kind > 97)
3702: kind = 97;
3703: break;
3704: case 54:
3705: case 72:
3706: if (curChar == 116)
3707: jjCheckNAdd(53);
3708: break;
3709: case 55:
3710: if (curChar == 103)
3711: jjstateSet[jjnewStateCnt++] = 54;
3712: break;
3713: case 58:
3714: if (curChar == 116)
3715: jjstateSet[jjnewStateCnt++] = 57;
3716: break;
3717: case 59:
3718: if (curChar == 108)
3719: jjstateSet[jjnewStateCnt++] = 58;
3720: break;
3721: case 61:
3722: if (curChar == 116)
3723: jjstateSet[jjnewStateCnt++] = 60;
3724: break;
3725: case 62:
3726: if (curChar == 108)
3727: jjstateSet[jjnewStateCnt++] = 61;
3728: break;
3729: case 64:
3730: if (curChar == 116)
3731: jjstateSet[jjnewStateCnt++] = 63;
3732: break;
3733: case 65:
3734: if (curChar == 103)
3735: jjstateSet[jjnewStateCnt++] = 64;
3736: break;
3737: case 68:
3738: if (curChar == 116)
3739: jjstateSet[jjnewStateCnt++] = 67;
3740: break;
3741: case 69:
3742: if (curChar == 103)
3743: jjstateSet[jjnewStateCnt++] = 68;
3744: break;
3745: case 71:
3746: if (curChar == 103)
3747: jjCheckNAddTwoStates(51, 72);
3748: break;
3749: default:
3750: break;
3751: }
3752: } while (i != startsAt);
3753: } else {
3754: int hiByte = (int) (curChar >> 8);
3755: int i1 = hiByte >> 6;
3756: long l1 = 1L << (hiByte & 077);
3757: int i2 = (curChar & 0xff) >> 6;
3758: long l2 = 1L << (curChar & 077);
3759: MatchLoop: do {
3760: switch (jjstateSet[--i]) {
3761: case 1:
3762: case 34:
3763: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
3764: break;
3765: if (kind > 120)
3766: kind = 120;
3767: jjCheckNAdd(34);
3768: break;
3769: case 6:
3770: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3771: jjAddStates(293, 295);
3772: break;
3773: case 13:
3774: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3775: jjAddStates(290, 292);
3776: break;
3777: case 21:
3778: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3779: jjAddStates(306, 307);
3780: break;
3781: case 24:
3782: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3783: jjAddStates(308, 309);
3784: break;
3785: default:
3786: break;
3787: }
3788: } while (i != startsAt);
3789: }
3790: if (kind != 0x7fffffff) {
3791: jjmatchedKind = kind;
3792: jjmatchedPos = curPos;
3793: kind = 0x7fffffff;
3794: }
3795: ++curPos;
3796: if ((i = jjnewStateCnt) == (startsAt = 73 - (jjnewStateCnt = startsAt)))
3797: return curPos;
3798: try {
3799: curChar = input_stream.readChar();
3800: } catch (java.io.IOException e) {
3801: return curPos;
3802: }
3803: }
3804: }
3805:
3806: private final int jjStopStringLiteralDfa_3(int pos, long active0,
3807: long active1) {
3808: switch (pos) {
3809: case 0:
3810: if ((active1 & 0x800000000000L) != 0L)
3811: return 2;
3812: if ((active1 & 0xe0000000180000L) != 0L) {
3813: jjmatchedKind = 120;
3814: return 34;
3815: }
3816: return -1;
3817: case 1:
3818: if ((active1 & 0x60000000000000L) != 0L)
3819: return 34;
3820: if ((active1 & 0x80000000180000L) != 0L) {
3821: if (jjmatchedPos != 1) {
3822: jjmatchedKind = 120;
3823: jjmatchedPos = 1;
3824: }
3825: return 34;
3826: }
3827: return -1;
3828: case 2:
3829: if ((active1 & 0x80000000180000L) != 0L) {
3830: jjmatchedKind = 120;
3831: jjmatchedPos = 2;
3832: return 34;
3833: }
3834: return -1;
3835: case 3:
3836: if ((active1 & 0x100000L) != 0L)
3837: return 34;
3838: if ((active1 & 0x80000000080000L) != 0L) {
3839: jjmatchedKind = 120;
3840: jjmatchedPos = 3;
3841: return 34;
3842: }
3843: return -1;
3844: default:
3845: return -1;
3846: }
3847: }
3848:
3849: private final int jjStartNfa_3(int pos, long active0, long active1) {
3850: return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0,
3851: active1), pos + 1);
3852: }
3853:
3854: private final int jjStartNfaWithStates_3(int pos, int kind,
3855: int state) {
3856: jjmatchedKind = kind;
3857: jjmatchedPos = pos;
3858: try {
3859: curChar = input_stream.readChar();
3860: } catch (java.io.IOException e) {
3861: return pos + 1;
3862: }
3863: return jjMoveNfa_3(state, pos + 1);
3864: }
3865:
3866: private final int jjMoveStringLiteralDfa0_3() {
3867: switch (curChar) {
3868: case 33:
3869: jjmatchedKind = 107;
3870: return jjMoveStringLiteralDfa1_3(0x20000000L);
3871: case 37:
3872: return jjStopAtPos(0, 104);
3873: case 40:
3874: return jjStopAtPos(0, 113);
3875: case 41:
3876: return jjStopAtPos(0, 114);
3877: case 42:
3878: jjmatchedKind = 100;
3879: return jjMoveStringLiteralDfa1_3(0x2000000000L);
3880: case 43:
3881: return jjStopAtPos(0, 98);
3882: case 44:
3883: return jjStopAtPos(0, 108);
3884: case 45:
3885: return jjStopAtPos(0, 99);
3886: case 46:
3887: jjmatchedKind = 87;
3888: return jjMoveStringLiteralDfa1_3(0x4001000000L);
3889: case 47:
3890: return jjStopAtPos(0, 103);
3891: case 58:
3892: return jjStopAtPos(0, 110);
3893: case 59:
3894: return jjStopAtPos(0, 109);
3895: case 61:
3896: jjmatchedKind = 91;
3897: return jjMoveStringLiteralDfa1_3(0x10000000L);
3898: case 62:
3899: jjmatchedKind = 125;
3900: return jjMoveStringLiteralDfa1_3(0x4000000000000000L);
3901: case 63:
3902: jjmatchedKind = 89;
3903: return jjMoveStringLiteralDfa1_3(0x4000000L);
3904: case 91:
3905: return jjStartNfaWithStates_3(0, 111, 2);
3906: case 93:
3907: return jjStopAtPos(0, 112);
3908: case 97:
3909: return jjMoveStringLiteralDfa1_3(0x40000000000000L);
3910: case 102:
3911: return jjMoveStringLiteralDfa1_3(0x80000L);
3912: case 105:
3913: return jjMoveStringLiteralDfa1_3(0x20000000000000L);
3914: case 116:
3915: return jjMoveStringLiteralDfa1_3(0x100000L);
3916: case 117:
3917: return jjMoveStringLiteralDfa1_3(0x80000000000000L);
3918: case 123:
3919: return jjStopAtPos(0, 115);
3920: case 125:
3921: return jjStopAtPos(0, 116);
3922: default:
3923: return jjMoveNfa_3(1, 0);
3924: }
3925: }
3926:
3927: private final int jjMoveStringLiteralDfa1_3(long active1) {
3928: try {
3929: curChar = input_stream.readChar();
3930: } catch (java.io.IOException e) {
3931: jjStopStringLiteralDfa_3(0, 0L, active1);
3932: return 1;
3933: }
3934: switch (curChar) {
3935: case 42:
3936: if ((active1 & 0x2000000000L) != 0L)
3937: return jjStopAtPos(1, 101);
3938: break;
3939: case 46:
3940: if ((active1 & 0x1000000L) != 0L) {
3941: jjmatchedKind = 88;
3942: jjmatchedPos = 1;
3943: }
3944: return jjMoveStringLiteralDfa2_3(active1, 0x4000000000L);
3945: case 61:
3946: if ((active1 & 0x10000000L) != 0L)
3947: return jjStopAtPos(1, 92);
3948: else if ((active1 & 0x20000000L) != 0L)
3949: return jjStopAtPos(1, 93);
3950: else if ((active1 & 0x4000000000000000L) != 0L)
3951: return jjStopAtPos(1, 126);
3952: break;
3953: case 63:
3954: if ((active1 & 0x4000000L) != 0L)
3955: return jjStopAtPos(1, 90);
3956: break;
3957: case 97:
3958: return jjMoveStringLiteralDfa2_3(active1, 0x80000L);
3959: case 110:
3960: if ((active1 & 0x20000000000000L) != 0L)
3961: return jjStartNfaWithStates_3(1, 117, 34);
3962: break;
3963: case 114:
3964: return jjMoveStringLiteralDfa2_3(active1, 0x100000L);
3965: case 115:
3966: if ((active1 & 0x40000000000000L) != 0L)
3967: return jjStartNfaWithStates_3(1, 118, 34);
3968: return jjMoveStringLiteralDfa2_3(active1, 0x80000000000000L);
3969: default:
3970: break;
3971: }
3972: return jjStartNfa_3(0, 0L, active1);
3973: }
3974:
3975: private final int jjMoveStringLiteralDfa2_3(long old1, long active1) {
3976: if (((active1 &= old1)) == 0L)
3977: return jjStartNfa_3(0, 0L, old1);
3978: try {
3979: curChar = input_stream.readChar();
3980: } catch (java.io.IOException e) {
3981: jjStopStringLiteralDfa_3(1, 0L, active1);
3982: return 2;
3983: }
3984: switch (curChar) {
3985: case 46:
3986: if ((active1 & 0x4000000000L) != 0L)
3987: return jjStopAtPos(2, 102);
3988: break;
3989: case 105:
3990: return jjMoveStringLiteralDfa3_3(active1, 0x80000000000000L);
3991: case 108:
3992: return jjMoveStringLiteralDfa3_3(active1, 0x80000L);
3993: case 117:
3994: return jjMoveStringLiteralDfa3_3(active1, 0x100000L);
3995: default:
3996: break;
3997: }
3998: return jjStartNfa_3(1, 0L, active1);
3999: }
4000:
4001: private final int jjMoveStringLiteralDfa3_3(long old1, long active1) {
4002: if (((active1 &= old1)) == 0L)
4003: return jjStartNfa_3(1, 0L, old1);
4004: try {
4005: curChar = input_stream.readChar();
4006: } catch (java.io.IOException e) {
4007: jjStopStringLiteralDfa_3(2, 0L, active1);
4008: return 3;
4009: }
4010: switch (curChar) {
4011: case 101:
4012: if ((active1 & 0x100000L) != 0L)
4013: return jjStartNfaWithStates_3(3, 84, 34);
4014: break;
4015: case 110:
4016: return jjMoveStringLiteralDfa4_3(active1, 0x80000000000000L);
4017: case 115:
4018: return jjMoveStringLiteralDfa4_3(active1, 0x80000L);
4019: default:
4020: break;
4021: }
4022: return jjStartNfa_3(2, 0L, active1);
4023: }
4024:
4025: private final int jjMoveStringLiteralDfa4_3(long old1, long active1) {
4026: if (((active1 &= old1)) == 0L)
4027: return jjStartNfa_3(2, 0L, old1);
4028: try {
4029: curChar = input_stream.readChar();
4030: } catch (java.io.IOException e) {
4031: jjStopStringLiteralDfa_3(3, 0L, active1);
4032: return 4;
4033: }
4034: switch (curChar) {
4035: case 101:
4036: if ((active1 & 0x80000L) != 0L)
4037: return jjStartNfaWithStates_3(4, 83, 34);
4038: break;
4039: case 103:
4040: if ((active1 & 0x80000000000000L) != 0L)
4041: return jjStartNfaWithStates_3(4, 119, 34);
4042: break;
4043: default:
4044: break;
4045: }
4046: return jjStartNfa_3(3, 0L, active1);
4047: }
4048:
4049: private final int jjMoveNfa_3(int startState, int curPos) {
4050: int[] nextStates;
4051: int startsAt = 0;
4052: jjnewStateCnt = 70;
4053: int i = 1;
4054: jjstateSet[0] = startState;
4055: int j, kind = 0x7fffffff;
4056: for (;;) {
4057: if (++jjround == 0x7fffffff)
4058: ReInitRounds();
4059: if (curChar < 64) {
4060: long l = 1L << curChar;
4061: MatchLoop: do {
4062: switch (jjstateSet[--i]) {
4063: case 1:
4064: if ((0x3ff000000000000L & l) != 0L) {
4065: if (kind > 85)
4066: kind = 85;
4067: jjCheckNAddStates(310, 312);
4068: } else if ((0x100002600L & l) != 0L) {
4069: if (kind > 73)
4070: kind = 73;
4071: jjCheckNAdd(0);
4072: } else if (curChar == 38)
4073: jjAddStates(313, 317);
4074: else if (curChar == 36) {
4075: if (kind > 120)
4076: kind = 120;
4077: jjCheckNAdd(34);
4078: } else if (curChar == 60)
4079: jjCheckNAdd(27);
4080: else if (curChar == 39)
4081: jjCheckNAddStates(290, 292);
4082: else if (curChar == 34)
4083: jjCheckNAddStates(293, 295);
4084: if (curChar == 38) {
4085: if (kind > 105)
4086: kind = 105;
4087: } else if (curChar == 60) {
4088: if (kind > 94)
4089: kind = 94;
4090: }
4091: if (curChar == 60)
4092: jjstateSet[jjnewStateCnt++] = 2;
4093: break;
4094: case 0:
4095: if ((0x100002600L & l) == 0L)
4096: break;
4097: if (kind > 73)
4098: kind = 73;
4099: jjCheckNAdd(0);
4100: break;
4101: case 2:
4102: if ((0xa00000000L & l) != 0L)
4103: jjstateSet[jjnewStateCnt++] = 4;
4104: break;
4105: case 3:
4106: if (curChar == 45 && kind > 74)
4107: kind = 74;
4108: break;
4109: case 4:
4110: if (curChar == 45)
4111: jjstateSet[jjnewStateCnt++] = 3;
4112: break;
4113: case 5:
4114: if (curChar == 34)
4115: jjCheckNAddStates(293, 295);
4116: break;
4117: case 6:
4118: if ((0xfffffffbffffffffL & l) != 0L)
4119: jjCheckNAddStates(293, 295);
4120: break;
4121: case 8:
4122: if ((0x9400000000L & l) != 0L)
4123: jjCheckNAddStates(293, 295);
4124: break;
4125: case 9:
4126: if (curChar == 34 && kind > 81)
4127: kind = 81;
4128: break;
4129: case 11:
4130: if ((0x3ff000000000000L & l) != 0L)
4131: jjCheckNAddStates(293, 295);
4132: break;
4133: case 12:
4134: if (curChar == 39)
4135: jjCheckNAddStates(290, 292);
4136: break;
4137: case 13:
4138: if ((0xffffff7fffffffffL & l) != 0L)
4139: jjCheckNAddStates(290, 292);
4140: break;
4141: case 15:
4142: if ((0x9400000000L & l) != 0L)
4143: jjCheckNAddStates(290, 292);
4144: break;
4145: case 16:
4146: if (curChar == 39 && kind > 81)
4147: kind = 81;
4148: break;
4149: case 18:
4150: if ((0x3ff000000000000L & l) != 0L)
4151: jjCheckNAddStates(290, 292);
4152: break;
4153: case 20:
4154: if (curChar == 34)
4155: jjCheckNAddTwoStates(21, 22);
4156: break;
4157: case 21:
4158: if ((0xfffffffbffffffffL & l) != 0L)
4159: jjCheckNAddTwoStates(21, 22);
4160: break;
4161: case 22:
4162: if (curChar == 34 && kind > 82)
4163: kind = 82;
4164: break;
4165: case 23:
4166: if (curChar == 39)
4167: jjCheckNAddTwoStates(24, 25);
4168: break;
4169: case 24:
4170: if ((0xffffff7fffffffffL & l) != 0L)
4171: jjCheckNAddTwoStates(24, 25);
4172: break;
4173: case 25:
4174: if (curChar == 39 && kind > 82)
4175: kind = 82;
4176: break;
4177: case 26:
4178: if (curChar == 60 && kind > 94)
4179: kind = 94;
4180: break;
4181: case 27:
4182: if (curChar == 61 && kind > 95)
4183: kind = 95;
4184: break;
4185: case 28:
4186: if (curChar == 60)
4187: jjCheckNAdd(27);
4188: break;
4189: case 29:
4190: case 67:
4191: if (curChar == 38 && kind > 105)
4192: kind = 105;
4193: break;
4194: case 33:
4195: if (curChar != 36)
4196: break;
4197: if (kind > 120)
4198: kind = 120;
4199: jjCheckNAdd(34);
4200: break;
4201: case 34:
4202: if ((0x3ff001000000000L & l) == 0L)
4203: break;
4204: if (kind > 120)
4205: kind = 120;
4206: jjCheckNAdd(34);
4207: break;
4208: case 35:
4209: if ((0x3ff000000000000L & l) == 0L)
4210: break;
4211: if (kind > 85)
4212: kind = 85;
4213: jjCheckNAddStates(310, 312);
4214: break;
4215: case 36:
4216: if ((0x3ff000000000000L & l) == 0L)
4217: break;
4218: if (kind > 85)
4219: kind = 85;
4220: jjCheckNAdd(36);
4221: break;
4222: case 37:
4223: if ((0x3ff000000000000L & l) != 0L)
4224: jjCheckNAddTwoStates(37, 38);
4225: break;
4226: case 38:
4227: if (curChar == 46)
4228: jjCheckNAdd(39);
4229: break;
4230: case 39:
4231: if ((0x3ff000000000000L & l) == 0L)
4232: break;
4233: if (kind > 86)
4234: kind = 86;
4235: jjCheckNAdd(39);
4236: break;
4237: case 53:
4238: if (curChar == 38)
4239: jjAddStates(313, 317);
4240: break;
4241: case 54:
4242: if (curChar == 59 && kind > 94)
4243: kind = 94;
4244: break;
4245: case 57:
4246: if (curChar == 59)
4247: jjCheckNAdd(27);
4248: break;
4249: case 60:
4250: if (curChar == 59 && kind > 96)
4251: kind = 96;
4252: break;
4253: case 63:
4254: if (curChar == 61 && kind > 97)
4255: kind = 97;
4256: break;
4257: case 64:
4258: if (curChar == 59)
4259: jjstateSet[jjnewStateCnt++] = 63;
4260: break;
4261: default:
4262: break;
4263: }
4264: } while (i != startsAt);
4265: } else if (curChar < 128) {
4266: long l = 1L << (curChar & 077);
4267: MatchLoop: do {
4268: switch (jjstateSet[--i]) {
4269: case 1:
4270: if ((0x7fffffe87ffffffL & l) != 0L) {
4271: if (kind > 120)
4272: kind = 120;
4273: jjCheckNAdd(34);
4274: } else if (curChar == 92)
4275: jjAddStates(318, 321);
4276: else if (curChar == 124)
4277: jjstateSet[jjnewStateCnt++] = 31;
4278: else if (curChar == 91)
4279: jjstateSet[jjnewStateCnt++] = 2;
4280: if (curChar == 103)
4281: jjCheckNAddTwoStates(48, 69);
4282: else if (curChar == 108)
4283: jjCheckNAddTwoStates(41, 43);
4284: else if (curChar == 124) {
4285: if (kind > 106)
4286: kind = 106;
4287: } else if (curChar == 114)
4288: jjAddStates(300, 301);
4289: break;
4290: case 6:
4291: if ((0xffffffffefffffffL & l) != 0L)
4292: jjCheckNAddStates(293, 295);
4293: break;
4294: case 7:
4295: if (curChar == 92)
4296: jjAddStates(302, 303);
4297: break;
4298: case 8:
4299: if ((0x1450c610000000L & l) != 0L)
4300: jjCheckNAddStates(293, 295);
4301: break;
4302: case 10:
4303: if (curChar == 120)
4304: jjstateSet[jjnewStateCnt++] = 11;
4305: break;
4306: case 11:
4307: if ((0x7e0000007eL & l) != 0L)
4308: jjCheckNAddStates(293, 295);
4309: break;
4310: case 13:
4311: if ((0xffffffffefffffffL & l) != 0L)
4312: jjCheckNAddStates(290, 292);
4313: break;
4314: case 14:
4315: if (curChar == 92)
4316: jjAddStates(304, 305);
4317: break;
4318: case 15:
4319: if ((0x1450c610000000L & l) != 0L)
4320: jjCheckNAddStates(290, 292);
4321: break;
4322: case 17:
4323: if (curChar == 120)
4324: jjstateSet[jjnewStateCnt++] = 18;
4325: break;
4326: case 18:
4327: if ((0x7e0000007eL & l) != 0L)
4328: jjCheckNAddStates(290, 292);
4329: break;
4330: case 19:
4331: if (curChar == 114)
4332: jjAddStates(300, 301);
4333: break;
4334: case 21:
4335: jjAddStates(306, 307);
4336: break;
4337: case 24:
4338: jjAddStates(308, 309);
4339: break;
4340: case 30:
4341: case 31:
4342: if (curChar == 124 && kind > 106)
4343: kind = 106;
4344: break;
4345: case 32:
4346: if (curChar == 124)
4347: jjstateSet[jjnewStateCnt++] = 31;
4348: break;
4349: case 33:
4350: case 34:
4351: if ((0x7fffffe87ffffffL & l) == 0L)
4352: break;
4353: if (kind > 120)
4354: kind = 120;
4355: jjCheckNAdd(34);
4356: break;
4357: case 40:
4358: if (curChar == 108)
4359: jjCheckNAddTwoStates(41, 43);
4360: break;
4361: case 41:
4362: if (curChar == 116 && kind > 94)
4363: kind = 94;
4364: break;
4365: case 42:
4366: if (curChar == 101 && kind > 95)
4367: kind = 95;
4368: break;
4369: case 43:
4370: case 46:
4371: if (curChar == 116)
4372: jjCheckNAdd(42);
4373: break;
4374: case 44:
4375: if (curChar == 92)
4376: jjAddStates(318, 321);
4377: break;
4378: case 45:
4379: if (curChar == 108)
4380: jjCheckNAdd(41);
4381: break;
4382: case 47:
4383: if (curChar == 108)
4384: jjstateSet[jjnewStateCnt++] = 46;
4385: break;
4386: case 48:
4387: if (curChar == 116 && kind > 96)
4388: kind = 96;
4389: break;
4390: case 49:
4391: if (curChar == 103)
4392: jjCheckNAdd(48);
4393: break;
4394: case 50:
4395: if (curChar == 101 && kind > 97)
4396: kind = 97;
4397: break;
4398: case 51:
4399: case 69:
4400: if (curChar == 116)
4401: jjCheckNAdd(50);
4402: break;
4403: case 52:
4404: if (curChar == 103)
4405: jjstateSet[jjnewStateCnt++] = 51;
4406: break;
4407: case 55:
4408: if (curChar == 116)
4409: jjstateSet[jjnewStateCnt++] = 54;
4410: break;
4411: case 56:
4412: if (curChar == 108)
4413: jjstateSet[jjnewStateCnt++] = 55;
4414: break;
4415: case 58:
4416: if (curChar == 116)
4417: jjstateSet[jjnewStateCnt++] = 57;
4418: break;
4419: case 59:
4420: if (curChar == 108)
4421: jjstateSet[jjnewStateCnt++] = 58;
4422: break;
4423: case 61:
4424: if (curChar == 116)
4425: jjstateSet[jjnewStateCnt++] = 60;
4426: break;
4427: case 62:
4428: if (curChar == 103)
4429: jjstateSet[jjnewStateCnt++] = 61;
4430: break;
4431: case 65:
4432: if (curChar == 116)
4433: jjstateSet[jjnewStateCnt++] = 64;
4434: break;
4435: case 66:
4436: if (curChar == 103)
4437: jjstateSet[jjnewStateCnt++] = 65;
4438: break;
4439: case 68:
4440: if (curChar == 103)
4441: jjCheckNAddTwoStates(48, 69);
4442: break;
4443: default:
4444: break;
4445: }
4446: } while (i != startsAt);
4447: } else {
4448: int hiByte = (int) (curChar >> 8);
4449: int i1 = hiByte >> 6;
4450: long l1 = 1L << (hiByte & 077);
4451: int i2 = (curChar & 0xff) >> 6;
4452: long l2 = 1L << (curChar & 077);
4453: MatchLoop: do {
4454: switch (jjstateSet[--i]) {
4455: case 1:
4456: case 34:
4457: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
4458: break;
4459: if (kind > 120)
4460: kind = 120;
4461: jjCheckNAdd(34);
4462: break;
4463: case 6:
4464: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4465: jjAddStates(293, 295);
4466: break;
4467: case 13:
4468: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4469: jjAddStates(290, 292);
4470: break;
4471: case 21:
4472: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4473: jjAddStates(306, 307);
4474: break;
4475: case 24:
4476: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4477: jjAddStates(308, 309);
4478: break;
4479: default:
4480: break;
4481: }
4482: } while (i != startsAt);
4483: }
4484: if (kind != 0x7fffffff) {
4485: jjmatchedKind = kind;
4486: jjmatchedPos = curPos;
4487: kind = 0x7fffffff;
4488: }
4489: ++curPos;
4490: if ((i = jjnewStateCnt) == (startsAt = 70 - (jjnewStateCnt = startsAt)))
4491: return curPos;
4492: try {
4493: curChar = input_stream.readChar();
4494: } catch (java.io.IOException e) {
4495: return curPos;
4496: }
4497: }
4498: }
4499:
4500: private final int jjStopStringLiteralDfa_4(int pos, long active0,
4501: long active1) {
4502: switch (pos) {
4503: default:
4504: return -1;
4505: }
4506: }
4507:
4508: private final int jjStartNfa_4(int pos, long active0, long active1) {
4509: return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0,
4510: active1), pos + 1);
4511: }
4512:
4513: private final int jjStartNfaWithStates_4(int pos, int kind,
4514: int state) {
4515: jjmatchedKind = kind;
4516: jjmatchedPos = pos;
4517: try {
4518: curChar = input_stream.readChar();
4519: } catch (java.io.IOException e) {
4520: return pos + 1;
4521: }
4522: return jjMoveNfa_4(state, pos + 1);
4523: }
4524:
4525: private final int jjMoveStringLiteralDfa0_4() {
4526: switch (curChar) {
4527: case 45:
4528: return jjStartNfaWithStates_4(0, 78, 3);
4529: default:
4530: return jjMoveNfa_4(1, 0);
4531: }
4532: }
4533:
4534: private final int jjMoveNfa_4(int startState, int curPos) {
4535: int[] nextStates;
4536: int startsAt = 0;
4537: jjnewStateCnt = 6;
4538: int i = 1;
4539: jjstateSet[0] = startState;
4540: int j, kind = 0x7fffffff;
4541: for (;;) {
4542: if (++jjround == 0x7fffffff)
4543: ReInitRounds();
4544: if (curChar < 64) {
4545: long l = 1L << curChar;
4546: MatchLoop: do {
4547: switch (jjstateSet[--i]) {
4548: case 3:
4549: if (curChar == 45)
4550: jjstateSet[jjnewStateCnt++] = 4;
4551: if (curChar == 45)
4552: jjstateSet[jjnewStateCnt++] = 2;
4553: break;
4554: case 1:
4555: if ((0xbfffdfffffffffffL & l) != 0L) {
4556: if (kind > 75)
4557: kind = 75;
4558: jjCheckNAdd(0);
4559: } else if (curChar == 45)
4560: jjAddStates(322, 323);
4561: break;
4562: case 0:
4563: if ((0xbfffdfffffffffffL & l) == 0L)
4564: break;
4565: kind = 75;
4566: jjCheckNAdd(0);
4567: break;
4568: case 2:
4569: if (curChar == 62)
4570: kind = 79;
4571: break;
4572: case 5:
4573: if (curChar == 45)
4574: jjstateSet[jjnewStateCnt++] = 4;
4575: break;
4576: default:
4577: break;
4578: }
4579: } while (i != startsAt);
4580: } else if (curChar < 128) {
4581: long l = 1L << (curChar & 077);
4582: MatchLoop: do {
4583: switch (jjstateSet[--i]) {
4584: case 1:
4585: case 0:
4586: if ((0xffffffffdfffffffL & l) == 0L)
4587: break;
4588: kind = 75;
4589: jjCheckNAdd(0);
4590: break;
4591: case 4:
4592: if (curChar == 93)
4593: kind = 79;
4594: break;
4595: default:
4596: break;
4597: }
4598: } while (i != startsAt);
4599: } else {
4600: int hiByte = (int) (curChar >> 8);
4601: int i1 = hiByte >> 6;
4602: long l1 = 1L << (hiByte & 077);
4603: int i2 = (curChar & 0xff) >> 6;
4604: long l2 = 1L << (curChar & 077);
4605: MatchLoop: do {
4606: switch (jjstateSet[--i]) {
4607: case 1:
4608: case 0:
4609: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
4610: break;
4611: if (kind > 75)
4612: kind = 75;
4613: jjCheckNAdd(0);
4614: break;
4615: default:
4616: break;
4617: }
4618: } while (i != startsAt);
4619: }
4620: if (kind != 0x7fffffff) {
4621: jjmatchedKind = kind;
4622: jjmatchedPos = curPos;
4623: kind = 0x7fffffff;
4624: }
4625: ++curPos;
4626: if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
4627: return curPos;
4628: try {
4629: curChar = input_stream.readChar();
4630: } catch (java.io.IOException e) {
4631: return curPos;
4632: }
4633: }
4634: }
4635:
4636: private final int jjStopStringLiteralDfa_5(int pos, long active0,
4637: long active1) {
4638: switch (pos) {
4639: case 0:
4640: if ((active1 & 0x8000000000L) != 0L)
4641: return 32;
4642: if ((active1 & 0xe0000000180000L) != 0L) {
4643: jjmatchedKind = 120;
4644: return 29;
4645: }
4646: return -1;
4647: case 1:
4648: if ((active1 & 0x80000000180000L) != 0L) {
4649: if (jjmatchedPos != 1) {
4650: jjmatchedKind = 120;
4651: jjmatchedPos = 1;
4652: }
4653: return 29;
4654: }
4655: if ((active1 & 0x60000000000000L) != 0L)
4656: return 29;
4657: return -1;
4658: case 2:
4659: if ((active1 & 0x80000000180000L) != 0L) {
4660: jjmatchedKind = 120;
4661: jjmatchedPos = 2;
4662: return 29;
4663: }
4664: return -1;
4665: case 3:
4666: if ((active1 & 0x100000L) != 0L)
4667: return 29;
4668: if ((active1 & 0x80000000080000L) != 0L) {
4669: jjmatchedKind = 120;
4670: jjmatchedPos = 3;
4671: return 29;
4672: }
4673: return -1;
4674: default:
4675: return -1;
4676: }
4677: }
4678:
4679: private final int jjStartNfa_5(int pos, long active0, long active1) {
4680: return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0,
4681: active1), pos + 1);
4682: }
4683:
4684: private final int jjStartNfaWithStates_5(int pos, int kind,
4685: int state) {
4686: jjmatchedKind = kind;
4687: jjmatchedPos = pos;
4688: try {
4689: curChar = input_stream.readChar();
4690: } catch (java.io.IOException e) {
4691: return pos + 1;
4692: }
4693: return jjMoveNfa_5(state, pos + 1);
4694: }
4695:
4696: private final int jjMoveStringLiteralDfa0_5() {
4697: switch (curChar) {
4698: case 33:
4699: jjmatchedKind = 107;
4700: return jjMoveStringLiteralDfa1_5(0x20000000L);
4701: case 37:
4702: return jjStopAtPos(0, 104);
4703: case 40:
4704: return jjStopAtPos(0, 113);
4705: case 41:
4706: return jjStopAtPos(0, 114);
4707: case 42:
4708: jjmatchedKind = 100;
4709: return jjMoveStringLiteralDfa1_5(0x2000000000L);
4710: case 43:
4711: return jjStopAtPos(0, 98);
4712: case 44:
4713: return jjStopAtPos(0, 108);
4714: case 45:
4715: return jjStopAtPos(0, 99);
4716: case 46:
4717: jjmatchedKind = 87;
4718: return jjMoveStringLiteralDfa1_5(0x4001000000L);
4719: case 47:
4720: return jjStartNfaWithStates_5(0, 103, 32);
4721: case 58:
4722: return jjStopAtPos(0, 110);
4723: case 59:
4724: return jjStopAtPos(0, 109);
4725: case 61:
4726: jjmatchedKind = 91;
4727: return jjMoveStringLiteralDfa1_5(0x10000000L);
4728: case 62:
4729: return jjStopAtPos(0, 123);
4730: case 63:
4731: jjmatchedKind = 89;
4732: return jjMoveStringLiteralDfa1_5(0x4000000L);
4733: case 91:
4734: return jjStopAtPos(0, 111);
4735: case 93:
4736: return jjStopAtPos(0, 112);
4737: case 97:
4738: return jjMoveStringLiteralDfa1_5(0x40000000000000L);
4739: case 102:
4740: return jjMoveStringLiteralDfa1_5(0x80000L);
4741: case 105:
4742: return jjMoveStringLiteralDfa1_5(0x20000000000000L);
4743: case 116:
4744: return jjMoveStringLiteralDfa1_5(0x100000L);
4745: case 117:
4746: return jjMoveStringLiteralDfa1_5(0x80000000000000L);
4747: case 123:
4748: return jjStopAtPos(0, 115);
4749: case 125:
4750: return jjStopAtPos(0, 116);
4751: default:
4752: return jjMoveNfa_5(0, 0);
4753: }
4754: }
4755:
4756: private final int jjMoveStringLiteralDfa1_5(long active1) {
4757: try {
4758: curChar = input_stream.readChar();
4759: } catch (java.io.IOException e) {
4760: jjStopStringLiteralDfa_5(0, 0L, active1);
4761: return 1;
4762: }
4763: switch (curChar) {
4764: case 42:
4765: if ((active1 & 0x2000000000L) != 0L)
4766: return jjStopAtPos(1, 101);
4767: break;
4768: case 46:
4769: if ((active1 & 0x1000000L) != 0L) {
4770: jjmatchedKind = 88;
4771: jjmatchedPos = 1;
4772: }
4773: return jjMoveStringLiteralDfa2_5(active1, 0x4000000000L);
4774: case 61:
4775: if ((active1 & 0x10000000L) != 0L)
4776: return jjStopAtPos(1, 92);
4777: else if ((active1 & 0x20000000L) != 0L)
4778: return jjStopAtPos(1, 93);
4779: break;
4780: case 63:
4781: if ((active1 & 0x4000000L) != 0L)
4782: return jjStopAtPos(1, 90);
4783: break;
4784: case 97:
4785: return jjMoveStringLiteralDfa2_5(active1, 0x80000L);
4786: case 110:
4787: if ((active1 & 0x20000000000000L) != 0L)
4788: return jjStartNfaWithStates_5(1, 117, 29);
4789: break;
4790: case 114:
4791: return jjMoveStringLiteralDfa2_5(active1, 0x100000L);
4792: case 115:
4793: if ((active1 & 0x40000000000000L) != 0L)
4794: return jjStartNfaWithStates_5(1, 118, 29);
4795: return jjMoveStringLiteralDfa2_5(active1, 0x80000000000000L);
4796: default:
4797: break;
4798: }
4799: return jjStartNfa_5(0, 0L, active1);
4800: }
4801:
4802: private final int jjMoveStringLiteralDfa2_5(long old1, long active1) {
4803: if (((active1 &= old1)) == 0L)
4804: return jjStartNfa_5(0, 0L, old1);
4805: try {
4806: curChar = input_stream.readChar();
4807: } catch (java.io.IOException e) {
4808: jjStopStringLiteralDfa_5(1, 0L, active1);
4809: return 2;
4810: }
4811: switch (curChar) {
4812: case 46:
4813: if ((active1 & 0x4000000000L) != 0L)
4814: return jjStopAtPos(2, 102);
4815: break;
4816: case 105:
4817: return jjMoveStringLiteralDfa3_5(active1, 0x80000000000000L);
4818: case 108:
4819: return jjMoveStringLiteralDfa3_5(active1, 0x80000L);
4820: case 117:
4821: return jjMoveStringLiteralDfa3_5(active1, 0x100000L);
4822: default:
4823: break;
4824: }
4825: return jjStartNfa_5(1, 0L, active1);
4826: }
4827:
4828: private final int jjMoveStringLiteralDfa3_5(long old1, long active1) {
4829: if (((active1 &= old1)) == 0L)
4830: return jjStartNfa_5(1, 0L, old1);
4831: try {
4832: curChar = input_stream.readChar();
4833: } catch (java.io.IOException e) {
4834: jjStopStringLiteralDfa_5(2, 0L, active1);
4835: return 3;
4836: }
4837: switch (curChar) {
4838: case 101:
4839: if ((active1 & 0x100000L) != 0L)
4840: return jjStartNfaWithStates_5(3, 84, 29);
4841: break;
4842: case 110:
4843: return jjMoveStringLiteralDfa4_5(active1, 0x80000000000000L);
4844: case 115:
4845: return jjMoveStringLiteralDfa4_5(active1, 0x80000L);
4846: default:
4847: break;
4848: }
4849: return jjStartNfa_5(2, 0L, active1);
4850: }
4851:
4852: private final int jjMoveStringLiteralDfa4_5(long old1, long active1) {
4853: if (((active1 &= old1)) == 0L)
4854: return jjStartNfa_5(2, 0L, old1);
4855: try {
4856: curChar = input_stream.readChar();
4857: } catch (java.io.IOException e) {
4858: jjStopStringLiteralDfa_5(3, 0L, active1);
4859: return 4;
4860: }
4861: switch (curChar) {
4862: case 101:
4863: if ((active1 & 0x80000L) != 0L)
4864: return jjStartNfaWithStates_5(4, 83, 29);
4865: break;
4866: case 103:
4867: if ((active1 & 0x80000000000000L) != 0L)
4868: return jjStartNfaWithStates_5(4, 119, 29);
4869: break;
4870: default:
4871: break;
4872: }
4873: return jjStartNfa_5(3, 0L, active1);
4874: }
4875:
4876: private final int jjMoveNfa_5(int startState, int curPos) {
4877: int[] nextStates;
4878: int startsAt = 0;
4879: jjnewStateCnt = 69;
4880: int i = 1;
4881: jjstateSet[0] = startState;
4882: int j, kind = 0x7fffffff;
4883: for (;;) {
4884: if (++jjround == 0x7fffffff)
4885: ReInitRounds();
4886: if (curChar < 64) {
4887: long l = 1L << curChar;
4888: MatchLoop: do {
4889: switch (jjstateSet[--i]) {
4890: case 32:
4891: if (curChar == 62 && kind > 124)
4892: kind = 124;
4893: break;
4894: case 0:
4895: if ((0x3ff000000000000L & l) != 0L) {
4896: if (kind > 85)
4897: kind = 85;
4898: jjCheckNAddStates(324, 326);
4899: } else if ((0x100002600L & l) != 0L) {
4900: if (kind > 127)
4901: kind = 127;
4902: jjCheckNAdd(30);
4903: } else if (curChar == 38)
4904: jjAddStates(327, 331);
4905: else if (curChar == 47)
4906: jjAddStates(332, 333);
4907: else if (curChar == 36) {
4908: if (kind > 120)
4909: kind = 120;
4910: jjCheckNAdd(29);
4911: } else if (curChar == 60)
4912: jjCheckNAdd(22);
4913: else if (curChar == 39)
4914: jjCheckNAddStates(334, 336);
4915: else if (curChar == 34)
4916: jjCheckNAddStates(337, 339);
4917: if (curChar == 38) {
4918: if (kind > 105)
4919: kind = 105;
4920: } else if (curChar == 60) {
4921: if (kind > 94)
4922: kind = 94;
4923: }
4924: break;
4925: case 1:
4926: if ((0xfffffffbffffffffL & l) != 0L)
4927: jjCheckNAddStates(337, 339);
4928: break;
4929: case 3:
4930: if ((0x9400000000L & l) != 0L)
4931: jjCheckNAddStates(337, 339);
4932: break;
4933: case 4:
4934: if (curChar == 34 && kind > 81)
4935: kind = 81;
4936: break;
4937: case 6:
4938: if ((0x3ff000000000000L & l) != 0L)
4939: jjCheckNAddStates(337, 339);
4940: break;
4941: case 7:
4942: if (curChar == 39)
4943: jjCheckNAddStates(334, 336);
4944: break;
4945: case 8:
4946: if ((0xffffff7fffffffffL & l) != 0L)
4947: jjCheckNAddStates(334, 336);
4948: break;
4949: case 10:
4950: if ((0x9400000000L & l) != 0L)
4951: jjCheckNAddStates(334, 336);
4952: break;
4953: case 11:
4954: if (curChar == 39 && kind > 81)
4955: kind = 81;
4956: break;
4957: case 13:
4958: if ((0x3ff000000000000L & l) != 0L)
4959: jjCheckNAddStates(334, 336);
4960: break;
4961: case 15:
4962: if (curChar == 34)
4963: jjCheckNAddTwoStates(16, 17);
4964: break;
4965: case 16:
4966: if ((0xfffffffbffffffffL & l) != 0L)
4967: jjCheckNAddTwoStates(16, 17);
4968: break;
4969: case 17:
4970: if (curChar == 34 && kind > 82)
4971: kind = 82;
4972: break;
4973: case 18:
4974: if (curChar == 39)
4975: jjCheckNAddTwoStates(19, 20);
4976: break;
4977: case 19:
4978: if ((0xffffff7fffffffffL & l) != 0L)
4979: jjCheckNAddTwoStates(19, 20);
4980: break;
4981: case 20:
4982: if (curChar == 39 && kind > 82)
4983: kind = 82;
4984: break;
4985: case 21:
4986: if (curChar == 60 && kind > 94)
4987: kind = 94;
4988: break;
4989: case 22:
4990: if (curChar == 61 && kind > 95)
4991: kind = 95;
4992: break;
4993: case 23:
4994: if (curChar == 60)
4995: jjCheckNAdd(22);
4996: break;
4997: case 24:
4998: case 66:
4999: if (curChar == 38 && kind > 105)
5000: kind = 105;
5001: break;
5002: case 28:
5003: if (curChar != 36)
5004: break;
5005: if (kind > 120)
5006: kind = 120;
5007: jjCheckNAdd(29);
5008: break;
5009: case 29:
5010: if ((0x3ff001000000000L & l) == 0L)
5011: break;
5012: if (kind > 120)
5013: kind = 120;
5014: jjCheckNAdd(29);
5015: break;
5016: case 30:
5017: if ((0x100002600L & l) == 0L)
5018: break;
5019: if (kind > 127)
5020: kind = 127;
5021: jjCheckNAdd(30);
5022: break;
5023: case 31:
5024: if (curChar == 47)
5025: jjAddStates(332, 333);
5026: break;
5027: case 34:
5028: if ((0x3ff000000000000L & l) == 0L)
5029: break;
5030: if (kind > 85)
5031: kind = 85;
5032: jjCheckNAddStates(324, 326);
5033: break;
5034: case 35:
5035: if ((0x3ff000000000000L & l) == 0L)
5036: break;
5037: if (kind > 85)
5038: kind = 85;
5039: jjCheckNAdd(35);
5040: break;
5041: case 36:
5042: if ((0x3ff000000000000L & l) != 0L)
5043: jjCheckNAddTwoStates(36, 37);
5044: break;
5045: case 37:
5046: if (curChar == 46)
5047: jjCheckNAdd(38);
5048: break;
5049: case 38:
5050: if ((0x3ff000000000000L & l) == 0L)
5051: break;
5052: if (kind > 86)
5053: kind = 86;
5054: jjCheckNAdd(38);
5055: break;
5056: case 52:
5057: if (curChar == 38)
5058: jjAddStates(327, 331);
5059: break;
5060: case 53:
5061: if (curChar == 59 && kind > 94)
5062: kind = 94;
5063: break;
5064: case 56:
5065: if (curChar == 59)
5066: jjCheckNAdd(22);
5067: break;
5068: case 59:
5069: if (curChar == 59 && kind > 96)
5070: kind = 96;
5071: break;
5072: case 62:
5073: if (curChar == 61 && kind > 97)
5074: kind = 97;
5075: break;
5076: case 63:
5077: if (curChar == 59)
5078: jjstateSet[jjnewStateCnt++] = 62;
5079: break;
5080: default:
5081: break;
5082: }
5083: } while (i != startsAt);
5084: } else if (curChar < 128) {
5085: long l = 1L << (curChar & 077);
5086: MatchLoop: do {
5087: switch (jjstateSet[--i]) {
5088: case 32:
5089: if (curChar == 93 && kind > 124)
5090: kind = 124;
5091: break;
5092: case 0:
5093: if ((0x7fffffe87ffffffL & l) != 0L) {
5094: if (kind > 120)
5095: kind = 120;
5096: jjCheckNAdd(29);
5097: } else if (curChar == 92)
5098: jjAddStates(340, 343);
5099: else if (curChar == 124)
5100: jjstateSet[jjnewStateCnt++] = 26;
5101: if (curChar == 103)
5102: jjCheckNAddTwoStates(47, 68);
5103: else if (curChar == 108)
5104: jjCheckNAddTwoStates(40, 42);
5105: else if (curChar == 124) {
5106: if (kind > 106)
5107: kind = 106;
5108: } else if (curChar == 114)
5109: jjAddStates(344, 345);
5110: break;
5111: case 1:
5112: if ((0xffffffffefffffffL & l) != 0L)
5113: jjCheckNAddStates(337, 339);
5114: break;
5115: case 2:
5116: if (curChar == 92)
5117: jjAddStates(322, 323);
5118: break;
5119: case 3:
5120: if ((0x1450c610000000L & l) != 0L)
5121: jjCheckNAddStates(337, 339);
5122: break;
5123: case 5:
5124: if (curChar == 120)
5125: jjstateSet[jjnewStateCnt++] = 6;
5126: break;
5127: case 6:
5128: if ((0x7e0000007eL & l) != 0L)
5129: jjCheckNAddStates(337, 339);
5130: break;
5131: case 8:
5132: if ((0xffffffffefffffffL & l) != 0L)
5133: jjCheckNAddStates(334, 336);
5134: break;
5135: case 9:
5136: if (curChar == 92)
5137: jjAddStates(0, 1);
5138: break;
5139: case 10:
5140: if ((0x1450c610000000L & l) != 0L)
5141: jjCheckNAddStates(334, 336);
5142: break;
5143: case 12:
5144: if (curChar == 120)
5145: jjstateSet[jjnewStateCnt++] = 13;
5146: break;
5147: case 13:
5148: if ((0x7e0000007eL & l) != 0L)
5149: jjCheckNAddStates(334, 336);
5150: break;
5151: case 14:
5152: if (curChar == 114)
5153: jjAddStates(344, 345);
5154: break;
5155: case 16:
5156: jjAddStates(346, 347);
5157: break;
5158: case 19:
5159: jjAddStates(348, 349);
5160: break;
5161: case 25:
5162: case 26:
5163: if (curChar == 124 && kind > 106)
5164: kind = 106;
5165: break;
5166: case 27:
5167: if (curChar == 124)
5168: jjstateSet[jjnewStateCnt++] = 26;
5169: break;
5170: case 28:
5171: case 29:
5172: if ((0x7fffffe87ffffffL & l) == 0L)
5173: break;
5174: if (kind > 120)
5175: kind = 120;
5176: jjCheckNAdd(29);
5177: break;
5178: case 39:
5179: if (curChar == 108)
5180: jjCheckNAddTwoStates(40, 42);
5181: break;
5182: case 40:
5183: if (curChar == 116 && kind > 94)
5184: kind = 94;
5185: break;
5186: case 41:
5187: if (curChar == 101 && kind > 95)
5188: kind = 95;
5189: break;
5190: case 42:
5191: case 45:
5192: if (curChar == 116)
5193: jjCheckNAdd(41);
5194: break;
5195: case 43:
5196: if (curChar == 92)
5197: jjAddStates(340, 343);
5198: break;
5199: case 44:
5200: if (curChar == 108)
5201: jjCheckNAdd(40);
5202: break;
5203: case 46:
5204: if (curChar == 108)
5205: jjstateSet[jjnewStateCnt++] = 45;
5206: break;
5207: case 47:
5208: if (curChar == 116 && kind > 96)
5209: kind = 96;
5210: break;
5211: case 48:
5212: if (curChar == 103)
5213: jjCheckNAdd(47);
5214: break;
5215: case 49:
5216: if (curChar == 101 && kind > 97)
5217: kind = 97;
5218: break;
5219: case 50:
5220: case 68:
5221: if (curChar == 116)
5222: jjCheckNAdd(49);
5223: break;
5224: case 51:
5225: if (curChar == 103)
5226: jjstateSet[jjnewStateCnt++] = 50;
5227: break;
5228: case 54:
5229: if (curChar == 116)
5230: jjstateSet[jjnewStateCnt++] = 53;
5231: break;
5232: case 55:
5233: if (curChar == 108)
5234: jjstateSet[jjnewStateCnt++] = 54;
5235: break;
5236: case 57:
5237: if (curChar == 116)
5238: jjstateSet[jjnewStateCnt++] = 56;
5239: break;
5240: case 58:
5241: if (curChar == 108)
5242: jjstateSet[jjnewStateCnt++] = 57;
5243: break;
5244: case 60:
5245: if (curChar == 116)
5246: jjstateSet[jjnewStateCnt++] = 59;
5247: break;
5248: case 61:
5249: if (curChar == 103)
5250: jjstateSet[jjnewStateCnt++] = 60;
5251: break;
5252: case 64:
5253: if (curChar == 116)
5254: jjstateSet[jjnewStateCnt++] = 63;
5255: break;
5256: case 65:
5257: if (curChar == 103)
5258: jjstateSet[jjnewStateCnt++] = 64;
5259: break;
5260: case 67:
5261: if (curChar == 103)
5262: jjCheckNAddTwoStates(47, 68);
5263: break;
5264: default:
5265: break;
5266: }
5267: } while (i != startsAt);
5268: } else {
5269: int hiByte = (int) (curChar >> 8);
5270: int i1 = hiByte >> 6;
5271: long l1 = 1L << (hiByte & 077);
5272: int i2 = (curChar & 0xff) >> 6;
5273: long l2 = 1L << (curChar & 077);
5274: MatchLoop: do {
5275: switch (jjstateSet[--i]) {
5276: case 0:
5277: case 29:
5278: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
5279: break;
5280: if (kind > 120)
5281: kind = 120;
5282: jjCheckNAdd(29);
5283: break;
5284: case 1:
5285: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5286: jjAddStates(337, 339);
5287: break;
5288: case 8:
5289: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5290: jjAddStates(334, 336);
5291: break;
5292: case 16:
5293: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5294: jjAddStates(346, 347);
5295: break;
5296: case 19:
5297: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
5298: jjAddStates(348, 349);
5299: break;
5300: default:
5301: break;
5302: }
5303: } while (i != startsAt);
5304: }
5305: if (kind != 0x7fffffff) {
5306: jjmatchedKind = kind;
5307: jjmatchedPos = curPos;
5308: kind = 0x7fffffff;
5309: }
5310: ++curPos;
5311: if ((i = jjnewStateCnt) == (startsAt = 69 - (jjnewStateCnt = startsAt)))
5312: return curPos;
5313: try {
5314: curChar = input_stream.readChar();
5315: } catch (java.io.IOException e) {
5316: return curPos;
5317: }
5318: }
5319: }
5320:
5321: static final int[] jjnextStates = { 10, 12, 4, 5, 3, 4, 5, 557,
5322: 566, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316,
5323: 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328,
5324: 329, 330, 336, 337, 345, 346, 357, 358, 369, 370, 381, 382,
5325: 391, 392, 402, 403, 413, 414, 426, 427, 436, 437, 449, 450,
5326: 463, 464, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483,
5327: 484, 485, 486, 487, 488, 489, 490, 491, 501, 502, 503, 515,
5328: 516, 521, 527, 528, 530, 12, 21, 24, 31, 36, 44, 51, 56,
5329: 63, 70, 76, 84, 91, 100, 106, 116, 122, 127, 134, 139, 147,
5330: 157, 166, 175, 182, 190, 199, 206, 214, 215, 223, 228, 233,
5331: 242, 251, 258, 268, 276, 287, 294, 304, 5, 6, 14, 15, 149,
5332: 150, 159, 160, 168, 169, 177, 178, 179, 184, 185, 186, 192,
5333: 193, 194, 201, 202, 203, 208, 209, 210, 216, 217, 218, 220,
5334: 221, 222, 225, 226, 227, 230, 231, 232, 235, 236, 244, 245,
5335: 246, 260, 261, 262, 278, 279, 280, 296, 297, 332, 333, 339,
5336: 340, 348, 349, 360, 361, 372, 373, 384, 385, 394, 395, 405,
5337: 406, 416, 417, 429, 430, 439, 440, 452, 453, 466, 467, 493,
5338: 494, 505, 506, 560, 561, 564, 565, 561, 563, 564, 565, 306,
5339: 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318,
5340: 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 532,
5341: 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
5342: 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486,
5343: 487, 488, 489, 490, 545, 502, 546, 516, 549, 552, 528, 553,
5344: 523, 524, 559, 564, 565, 39, 40, 41, 59, 62, 65, 69, 70,
5345: 36, 37, 13, 14, 16, 6, 7, 9, 48, 50, 52, 55, 20, 23, 8, 10,
5346: 15, 17, 21, 22, 24, 25, 36, 37, 38, 56, 59, 62, 66, 67, 45,
5347: 47, 49, 52, 3, 5, 35, 36, 37, 55, 58, 61, 65, 66, 32, 33,
5348: 8, 9, 11, 1, 2, 4, 44, 46, 48, 51, 15, 18, 16, 17, 19, 20, };
5349:
5350: private static final boolean jjCanMove_0(int hiByte, int i1,
5351: int i2, long l1, long l2) {
5352: switch (hiByte) {
5353: case 0:
5354: return ((jjbitVec2[i2] & l2) != 0L);
5355: default:
5356: if ((jjbitVec0[i1] & l1) != 0L)
5357: return true;
5358: return false;
5359: }
5360: }
5361:
5362: private static final boolean jjCanMove_1(int hiByte, int i1,
5363: int i2, long l1, long l2) {
5364: switch (hiByte) {
5365: case 0:
5366: return ((jjbitVec4[i2] & l2) != 0L);
5367: case 48:
5368: return ((jjbitVec5[i2] & l2) != 0L);
5369: case 49:
5370: return ((jjbitVec6[i2] & l2) != 0L);
5371: case 51:
5372: return ((jjbitVec7[i2] & l2) != 0L);
5373: case 61:
5374: return ((jjbitVec8[i2] & l2) != 0L);
5375: default:
5376: if ((jjbitVec3[i1] & l1) != 0L)
5377: return true;
5378: return false;
5379: }
5380: }
5381:
5382: public static final String[] jjstrLiteralImages = { "", null, null,
5383: null, null, null, null, null, null, null, null, null, null,
5384: null, null, null, null, null, null, null, null, null, null,
5385: null, null, null, null, null, null, null, null, null, null,
5386: null, null, null, null, null, null, null, null, null, null,
5387: null, null, null, null, null, null, null, null, null, null,
5388: null, null, null, null, null, null, null, null, null, null,
5389: null, null, null, null, null, null, null, null, "\44\173",
5390: "\43\173", null, null, null, null, null, null, null, null,
5391: null, null, "\146\141\154\163\145", "\164\162\165\145",
5392: null, null, "\56", "\56\56", "\77", "\77\77", "\75",
5393: "\75\75", "\41\75", null, null, null, null, "\53", "\55",
5394: "\52", "\52\52", "\56\56\56", "\57", "\45", null, null,
5395: "\41", "\54", "\73", "\72", "\133", "\135", "\50", "\51",
5396: "\173", "\175", "\151\156", "\141\163",
5397: "\165\163\151\156\147", null, null, null, "\76", null,
5398: "\76", "\76\75", null, null, null, null, null, };
5399: public static final String[] lexStateNames = { "DEFAULT",
5400: "NODIRECTIVE", "FM_EXPRESSION", "IN_PAREN",
5401: "EXPRESSION_COMMENT", "NO_SPACE_EXPRESSION", "NO_PARSE", };
5402: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
5403: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5404: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5405: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5406: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5407: -1, -1, -1, -1, -1, 2, 2, -1, 4, -1, -1, -1, -1, -1, -1,
5408: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5409: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5410: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5411: -1, 2, -1, -1, -1, -1, };
5412: static final long[] jjtoToken = { 0xffffffffffffffc1L,
5413: 0xf9fffffffffe01ffL, 0xfL, };
5414: static final long[] jjtoSkip = { 0x0L, 0xfe00L, 0x0L, };
5415: private SimpleCharStream input_stream;
5416: private final int[] jjrounds = new int[567];
5417: private final int[] jjstateSet = new int[1134];
5418: StringBuffer image;
5419: int jjimageLen;
5420: int lengthOfMatch;
5421: protected char curChar;
5422:
5423: public FMParserTokenManager(SimpleCharStream stream) {
5424: if (SimpleCharStream.staticFlag)
5425: throw new Error(
5426: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
5427: input_stream = stream;
5428: }
5429:
5430: public FMParserTokenManager(SimpleCharStream stream, int lexState) {
5431: this (stream);
5432: SwitchTo(lexState);
5433: }
5434:
5435: public void ReInit(SimpleCharStream stream) {
5436: jjmatchedPos = jjnewStateCnt = 0;
5437: curLexState = defaultLexState;
5438: input_stream = stream;
5439: ReInitRounds();
5440: }
5441:
5442: private final void ReInitRounds() {
5443: int i;
5444: jjround = 0x80000001;
5445: for (i = 567; i-- > 0;)
5446: jjrounds[i] = 0x80000000;
5447: }
5448:
5449: public void ReInit(SimpleCharStream stream, int lexState) {
5450: ReInit(stream);
5451: SwitchTo(lexState);
5452: }
5453:
5454: public void SwitchTo(int lexState) {
5455: if (lexState >= 7 || lexState < 0)
5456: throw new TokenMgrError(
5457: "Error: Ignoring invalid lexical state : "
5458: + lexState + ". State unchanged.",
5459: TokenMgrError.INVALID_LEXICAL_STATE);
5460: else
5461: curLexState = lexState;
5462: }
5463:
5464: private final Token jjFillToken() {
5465: Token t = Token.newToken(jjmatchedKind);
5466: t.kind = jjmatchedKind;
5467: String im = jjstrLiteralImages[jjmatchedKind];
5468: t.image = (im == null) ? input_stream.GetImage() : im;
5469: t.beginLine = input_stream.getBeginLine();
5470: t.beginColumn = input_stream.getBeginColumn();
5471: t.endLine = input_stream.getEndLine();
5472: t.endColumn = input_stream.getEndColumn();
5473: return t;
5474: }
5475:
5476: int curLexState = 0;
5477: int defaultLexState = 0;
5478: int jjnewStateCnt;
5479: int jjround;
5480: int jjmatchedPos;
5481: int jjmatchedKind;
5482:
5483: public final Token getNextToken() {
5484: int kind;
5485: Token specialToken = null;
5486: Token matchedToken;
5487: int curPos = 0;
5488:
5489: EOFLoop: for (;;) {
5490: try {
5491: curChar = input_stream.BeginToken();
5492: } catch (java.io.IOException e) {
5493: jjmatchedKind = 0;
5494: matchedToken = jjFillToken();
5495: return matchedToken;
5496: }
5497: image = null;
5498: jjimageLen = 0;
5499:
5500: switch (curLexState) {
5501: case 0:
5502: jjmatchedKind = 0x7fffffff;
5503: jjmatchedPos = 0;
5504: curPos = jjMoveStringLiteralDfa0_0();
5505: break;
5506: case 1:
5507: jjmatchedKind = 0x7fffffff;
5508: jjmatchedPos = 0;
5509: curPos = jjMoveStringLiteralDfa0_1();
5510: break;
5511: case 2:
5512: jjmatchedKind = 0x7fffffff;
5513: jjmatchedPos = 0;
5514: curPos = jjMoveStringLiteralDfa0_2();
5515: break;
5516: case 3:
5517: jjmatchedKind = 0x7fffffff;
5518: jjmatchedPos = 0;
5519: curPos = jjMoveStringLiteralDfa0_3();
5520: break;
5521: case 4:
5522: try {
5523: input_stream.backup(0);
5524: while ((curChar < 64 && (0x4000000000000000L & (1L << curChar)) != 0L)
5525: || (curChar >> 6) == 1
5526: && (0x20000000L & (1L << (curChar & 077))) != 0L)
5527: curChar = input_stream.BeginToken();
5528: } catch (java.io.IOException e1) {
5529: continue EOFLoop;
5530: }
5531: jjmatchedKind = 0x7fffffff;
5532: jjmatchedPos = 0;
5533: curPos = jjMoveStringLiteralDfa0_4();
5534: break;
5535: case 5:
5536: jjmatchedKind = 0x7fffffff;
5537: jjmatchedPos = 0;
5538: curPos = jjMoveStringLiteralDfa0_5();
5539: break;
5540: case 6:
5541: jjmatchedKind = 0x7fffffff;
5542: jjmatchedPos = 0;
5543: curPos = jjMoveStringLiteralDfa0_6();
5544: break;
5545: }
5546: if (jjmatchedKind != 0x7fffffff) {
5547: if (jjmatchedPos + 1 < curPos)
5548: input_stream.backup(curPos - jjmatchedPos - 1);
5549: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
5550: matchedToken = jjFillToken();
5551: TokenLexicalActions(matchedToken);
5552: if (jjnewLexState[jjmatchedKind] != -1)
5553: curLexState = jjnewLexState[jjmatchedKind];
5554: return matchedToken;
5555: } else {
5556: SkipLexicalActions(null);
5557: if (jjnewLexState[jjmatchedKind] != -1)
5558: curLexState = jjnewLexState[jjmatchedKind];
5559: continue EOFLoop;
5560: }
5561: }
5562: int error_line = input_stream.getEndLine();
5563: int error_column = input_stream.getEndColumn();
5564: String error_after = null;
5565: boolean EOFSeen = false;
5566: try {
5567: input_stream.readChar();
5568: input_stream.backup(1);
5569: } catch (java.io.IOException e1) {
5570: EOFSeen = true;
5571: error_after = curPos <= 1 ? "" : input_stream
5572: .GetImage();
5573: if (curChar == '\n' || curChar == '\r') {
5574: error_line++;
5575: error_column = 0;
5576: } else
5577: error_column++;
5578: }
5579: if (!EOFSeen) {
5580: input_stream.backup(1);
5581: error_after = curPos <= 1 ? "" : input_stream
5582: .GetImage();
5583: }
5584: throw new TokenMgrError(EOFSeen, curLexState, error_line,
5585: error_column, error_after, curChar,
5586: TokenMgrError.LEXICAL_ERROR);
5587: }
5588: }
5589:
5590: final void SkipLexicalActions(Token matchedToken) {
5591: switch (jjmatchedKind) {
5592: case 79:
5593: if (image == null)
5594: image = new StringBuffer(new String(input_stream
5595: .GetSuffix(jjimageLen
5596: + (lengthOfMatch = jjmatchedPos + 1))));
5597: else
5598: image.append(new String(input_stream
5599: .GetSuffix(jjimageLen
5600: + (lengthOfMatch = jjmatchedPos + 1))));
5601: if (parenthesisNesting > 0)
5602: SwitchTo(IN_PAREN);
5603: else
5604: SwitchTo(FM_EXPRESSION);
5605: break;
5606: default:
5607: break;
5608: }
5609: }
5610:
5611: final void TokenLexicalActions(Token matchedToken) {
5612: switch (jjmatchedKind) {
5613: case 6:
5614: if (image == null)
5615: image = new StringBuffer(new String(input_stream
5616: .GetSuffix(jjimageLen
5617: + (lengthOfMatch = jjmatchedPos + 1))));
5618: else
5619: image.append(new String(input_stream
5620: .GetSuffix(jjimageLen
5621: + (lengthOfMatch = jjmatchedPos + 1))));
5622: strictSyntaxCheck(matchedToken, DEFAULT);
5623: break;
5624: case 7:
5625: if (image == null)
5626: image = new StringBuffer(new String(input_stream
5627: .GetSuffix(jjimageLen
5628: + (lengthOfMatch = jjmatchedPos + 1))));
5629: else
5630: image.append(new String(input_stream
5631: .GetSuffix(jjimageLen
5632: + (lengthOfMatch = jjmatchedPos + 1))));
5633: strictSyntaxCheck(matchedToken, DEFAULT);
5634: break;
5635: case 8:
5636: if (image == null)
5637: image = new StringBuffer(new String(input_stream
5638: .GetSuffix(jjimageLen
5639: + (lengthOfMatch = jjmatchedPos + 1))));
5640: else
5641: image.append(new String(input_stream
5642: .GetSuffix(jjimageLen
5643: + (lengthOfMatch = jjmatchedPos + 1))));
5644: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5645: break;
5646: case 9:
5647: if (image == null)
5648: image = new StringBuffer(new String(input_stream
5649: .GetSuffix(jjimageLen
5650: + (lengthOfMatch = jjmatchedPos + 1))));
5651: else
5652: image.append(new String(input_stream
5653: .GetSuffix(jjimageLen
5654: + (lengthOfMatch = jjmatchedPos + 1))));
5655: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5656: break;
5657: case 10:
5658: if (image == null)
5659: image = new StringBuffer(new String(input_stream
5660: .GetSuffix(jjimageLen
5661: + (lengthOfMatch = jjmatchedPos + 1))));
5662: else
5663: image.append(new String(input_stream
5664: .GetSuffix(jjimageLen
5665: + (lengthOfMatch = jjmatchedPos + 1))));
5666: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5667: break;
5668: case 11:
5669: if (image == null)
5670: image = new StringBuffer(new String(input_stream
5671: .GetSuffix(jjimageLen
5672: + (lengthOfMatch = jjmatchedPos + 1))));
5673: else
5674: image.append(new String(input_stream
5675: .GetSuffix(jjimageLen
5676: + (lengthOfMatch = jjmatchedPos + 1))));
5677: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5678: break;
5679: case 12:
5680: if (image == null)
5681: image = new StringBuffer(new String(input_stream
5682: .GetSuffix(jjimageLen
5683: + (lengthOfMatch = jjmatchedPos + 1))));
5684: else
5685: image.append(new String(input_stream
5686: .GetSuffix(jjimageLen
5687: + (lengthOfMatch = jjmatchedPos + 1))));
5688: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5689: break;
5690: case 13:
5691: if (image == null)
5692: image = new StringBuffer(new String(input_stream
5693: .GetSuffix(jjimageLen
5694: + (lengthOfMatch = jjmatchedPos + 1))));
5695: else
5696: image.append(new String(input_stream
5697: .GetSuffix(jjimageLen
5698: + (lengthOfMatch = jjmatchedPos + 1))));
5699: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5700: break;
5701: case 14:
5702: if (image == null)
5703: image = new StringBuffer(new String(input_stream
5704: .GetSuffix(jjimageLen
5705: + (lengthOfMatch = jjmatchedPos + 1))));
5706: else
5707: image.append(new String(input_stream
5708: .GetSuffix(jjimageLen
5709: + (lengthOfMatch = jjmatchedPos + 1))));
5710: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5711: break;
5712: case 15:
5713: if (image == null)
5714: image = new StringBuffer(new String(input_stream
5715: .GetSuffix(jjimageLen
5716: + (lengthOfMatch = jjmatchedPos + 1))));
5717: else
5718: image.append(new String(input_stream
5719: .GetSuffix(jjimageLen
5720: + (lengthOfMatch = jjmatchedPos + 1))));
5721: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5722: break;
5723: case 16:
5724: if (image == null)
5725: image = new StringBuffer(new String(input_stream
5726: .GetSuffix(jjimageLen
5727: + (lengthOfMatch = jjmatchedPos + 1))));
5728: else
5729: image.append(new String(input_stream
5730: .GetSuffix(jjimageLen
5731: + (lengthOfMatch = jjmatchedPos + 1))));
5732: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5733: break;
5734: case 17:
5735: if (image == null)
5736: image = new StringBuffer(new String(input_stream
5737: .GetSuffix(jjimageLen
5738: + (lengthOfMatch = jjmatchedPos + 1))));
5739: else
5740: image.append(new String(input_stream
5741: .GetSuffix(jjimageLen
5742: + (lengthOfMatch = jjmatchedPos + 1))));
5743: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5744: break;
5745: case 18:
5746: if (image == null)
5747: image = new StringBuffer(new String(input_stream
5748: .GetSuffix(jjimageLen
5749: + (lengthOfMatch = jjmatchedPos + 1))));
5750: else
5751: image.append(new String(input_stream
5752: .GetSuffix(jjimageLen
5753: + (lengthOfMatch = jjmatchedPos + 1))));
5754: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5755: break;
5756: case 19:
5757: if (image == null)
5758: image = new StringBuffer(new String(input_stream
5759: .GetSuffix(jjimageLen
5760: + (lengthOfMatch = jjmatchedPos + 1))));
5761: else
5762: image.append(new String(input_stream
5763: .GetSuffix(jjimageLen
5764: + (lengthOfMatch = jjmatchedPos + 1))));
5765: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5766: break;
5767: case 20:
5768: if (image == null)
5769: image = new StringBuffer(new String(input_stream
5770: .GetSuffix(jjimageLen
5771: + (lengthOfMatch = jjmatchedPos + 1))));
5772: else
5773: image.append(new String(input_stream
5774: .GetSuffix(jjimageLen
5775: + (lengthOfMatch = jjmatchedPos + 1))));
5776: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5777: break;
5778: case 21:
5779: if (image == null)
5780: image = new StringBuffer(new String(input_stream
5781: .GetSuffix(jjimageLen
5782: + (lengthOfMatch = jjmatchedPos + 1))));
5783: else
5784: image.append(new String(input_stream
5785: .GetSuffix(jjimageLen
5786: + (lengthOfMatch = jjmatchedPos + 1))));
5787: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5788: break;
5789: case 22:
5790: if (image == null)
5791: image = new StringBuffer(new String(input_stream
5792: .GetSuffix(jjimageLen
5793: + (lengthOfMatch = jjmatchedPos + 1))));
5794: else
5795: image.append(new String(input_stream
5796: .GetSuffix(jjimageLen
5797: + (lengthOfMatch = jjmatchedPos + 1))));
5798: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5799: break;
5800: case 23:
5801: if (image == null)
5802: image = new StringBuffer(new String(input_stream
5803: .GetSuffix(jjimageLen
5804: + (lengthOfMatch = jjmatchedPos + 1))));
5805: else
5806: image.append(new String(input_stream
5807: .GetSuffix(jjimageLen
5808: + (lengthOfMatch = jjmatchedPos + 1))));
5809: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5810: break;
5811: case 24:
5812: if (image == null)
5813: image = new StringBuffer(new String(input_stream
5814: .GetSuffix(jjimageLen
5815: + (lengthOfMatch = jjmatchedPos + 1))));
5816: else
5817: image.append(new String(input_stream
5818: .GetSuffix(jjimageLen
5819: + (lengthOfMatch = jjmatchedPos + 1))));
5820: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5821: break;
5822: case 25:
5823: if (image == null)
5824: image = new StringBuffer(new String(input_stream
5825: .GetSuffix(jjimageLen
5826: + (lengthOfMatch = jjmatchedPos + 1))));
5827: else
5828: image.append(new String(input_stream
5829: .GetSuffix(jjimageLen
5830: + (lengthOfMatch = jjmatchedPos + 1))));
5831: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5832: break;
5833: case 26:
5834: if (image == null)
5835: image = new StringBuffer(new String(input_stream
5836: .GetSuffix(jjimageLen
5837: + (lengthOfMatch = jjmatchedPos + 1))));
5838: else
5839: image.append(new String(input_stream
5840: .GetSuffix(jjimageLen
5841: + (lengthOfMatch = jjmatchedPos + 1))));
5842: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
5843: break;
5844: case 27:
5845: if (image == null)
5846: image = new StringBuffer(new String(input_stream
5847: .GetSuffix(jjimageLen
5848: + (lengthOfMatch = jjmatchedPos + 1))));
5849: else
5850: image.append(new String(input_stream
5851: .GetSuffix(jjimageLen
5852: + (lengthOfMatch = jjmatchedPos + 1))));
5853: strictSyntaxCheck(matchedToken, DEFAULT);
5854: break;
5855: case 28:
5856: if (image == null)
5857: image = new StringBuffer(new String(input_stream
5858: .GetSuffix(jjimageLen
5859: + (lengthOfMatch = jjmatchedPos + 1))));
5860: else
5861: image.append(new String(input_stream
5862: .GetSuffix(jjimageLen
5863: + (lengthOfMatch = jjmatchedPos + 1))));
5864: strictSyntaxCheck(matchedToken, NO_PARSE);
5865: noparseTag = "comment";
5866: break;
5867: case 29:
5868: if (image == null)
5869: image = new StringBuffer(new String(input_stream
5870: .GetSuffix(jjimageLen
5871: + (lengthOfMatch = jjmatchedPos + 1))));
5872: else
5873: image.append(new String(input_stream
5874: .GetSuffix(jjimageLen
5875: + (lengthOfMatch = jjmatchedPos + 1))));
5876: noparseTag = "-->";
5877: strictSyntaxCheck(matchedToken, NO_PARSE);
5878: break;
5879: case 30:
5880: if (image == null)
5881: image = new StringBuffer(new String(input_stream
5882: .GetSuffix(jjimageLen
5883: + (lengthOfMatch = jjmatchedPos + 1))));
5884: else
5885: image.append(new String(input_stream
5886: .GetSuffix(jjimageLen
5887: + (lengthOfMatch = jjmatchedPos + 1))));
5888: strictSyntaxCheck(matchedToken, NO_PARSE);
5889: noparseTag = "noparse";
5890: break;
5891: case 31:
5892: if (image == null)
5893: image = new StringBuffer(new String(input_stream
5894: .GetSuffix(jjimageLen
5895: + (lengthOfMatch = jjmatchedPos + 1))));
5896: else
5897: image.append(new String(input_stream
5898: .GetSuffix(jjimageLen
5899: + (lengthOfMatch = jjmatchedPos + 1))));
5900: strictSyntaxCheck(matchedToken, DEFAULT);
5901: break;
5902: case 32:
5903: if (image == null)
5904: image = new StringBuffer(new String(input_stream
5905: .GetSuffix(jjimageLen
5906: + (lengthOfMatch = jjmatchedPos + 1))));
5907: else
5908: image.append(new String(input_stream
5909: .GetSuffix(jjimageLen
5910: + (lengthOfMatch = jjmatchedPos + 1))));
5911: strictSyntaxCheck(matchedToken, DEFAULT);
5912: break;
5913: case 33:
5914: if (image == null)
5915: image = new StringBuffer(new String(input_stream
5916: .GetSuffix(jjimageLen
5917: + (lengthOfMatch = jjmatchedPos + 1))));
5918: else
5919: image.append(new String(input_stream
5920: .GetSuffix(jjimageLen
5921: + (lengthOfMatch = jjmatchedPos + 1))));
5922: strictSyntaxCheck(matchedToken, DEFAULT);
5923: break;
5924: case 34:
5925: if (image == null)
5926: image = new StringBuffer(new String(input_stream
5927: .GetSuffix(jjimageLen
5928: + (lengthOfMatch = jjmatchedPos + 1))));
5929: else
5930: image.append(new String(input_stream
5931: .GetSuffix(jjimageLen
5932: + (lengthOfMatch = jjmatchedPos + 1))));
5933: strictSyntaxCheck(matchedToken, DEFAULT);
5934: break;
5935: case 35:
5936: if (image == null)
5937: image = new StringBuffer(new String(input_stream
5938: .GetSuffix(jjimageLen
5939: + (lengthOfMatch = jjmatchedPos + 1))));
5940: else
5941: image.append(new String(input_stream
5942: .GetSuffix(jjimageLen
5943: + (lengthOfMatch = jjmatchedPos + 1))));
5944: strictSyntaxCheck(matchedToken, DEFAULT);
5945: break;
5946: case 36:
5947: if (image == null)
5948: image = new StringBuffer(new String(input_stream
5949: .GetSuffix(jjimageLen
5950: + (lengthOfMatch = jjmatchedPos + 1))));
5951: else
5952: image.append(new String(input_stream
5953: .GetSuffix(jjimageLen
5954: + (lengthOfMatch = jjmatchedPos + 1))));
5955: strictSyntaxCheck(matchedToken, DEFAULT);
5956: break;
5957: case 37:
5958: if (image == null)
5959: image = new StringBuffer(new String(input_stream
5960: .GetSuffix(jjimageLen
5961: + (lengthOfMatch = jjmatchedPos + 1))));
5962: else
5963: image.append(new String(input_stream
5964: .GetSuffix(jjimageLen
5965: + (lengthOfMatch = jjmatchedPos + 1))));
5966: strictSyntaxCheck(matchedToken, DEFAULT);
5967: break;
5968: case 38:
5969: if (image == null)
5970: image = new StringBuffer(new String(input_stream
5971: .GetSuffix(jjimageLen
5972: + (lengthOfMatch = jjmatchedPos + 1))));
5973: else
5974: image.append(new String(input_stream
5975: .GetSuffix(jjimageLen
5976: + (lengthOfMatch = jjmatchedPos + 1))));
5977: strictSyntaxCheck(matchedToken, DEFAULT);
5978: break;
5979: case 39:
5980: if (image == null)
5981: image = new StringBuffer(new String(input_stream
5982: .GetSuffix(jjimageLen
5983: + (lengthOfMatch = jjmatchedPos + 1))));
5984: else
5985: image.append(new String(input_stream
5986: .GetSuffix(jjimageLen
5987: + (lengthOfMatch = jjmatchedPos + 1))));
5988: strictSyntaxCheck(matchedToken, DEFAULT);
5989: break;
5990: case 40:
5991: if (image == null)
5992: image = new StringBuffer(new String(input_stream
5993: .GetSuffix(jjimageLen
5994: + (lengthOfMatch = jjmatchedPos + 1))));
5995: else
5996: image.append(new String(input_stream
5997: .GetSuffix(jjimageLen
5998: + (lengthOfMatch = jjmatchedPos + 1))));
5999: strictSyntaxCheck(matchedToken, DEFAULT);
6000: break;
6001: case 41:
6002: if (image == null)
6003: image = new StringBuffer(new String(input_stream
6004: .GetSuffix(jjimageLen
6005: + (lengthOfMatch = jjmatchedPos + 1))));
6006: else
6007: image.append(new String(input_stream
6008: .GetSuffix(jjimageLen
6009: + (lengthOfMatch = jjmatchedPos + 1))));
6010: strictSyntaxCheck(matchedToken, DEFAULT);
6011: break;
6012: case 42:
6013: if (image == null)
6014: image = new StringBuffer(new String(input_stream
6015: .GetSuffix(jjimageLen
6016: + (lengthOfMatch = jjmatchedPos + 1))));
6017: else
6018: image.append(new String(input_stream
6019: .GetSuffix(jjimageLen
6020: + (lengthOfMatch = jjmatchedPos + 1))));
6021: strictSyntaxCheck(matchedToken, DEFAULT);
6022: break;
6023: case 43:
6024: if (image == null)
6025: image = new StringBuffer(new String(input_stream
6026: .GetSuffix(jjimageLen
6027: + (lengthOfMatch = jjmatchedPos + 1))));
6028: else
6029: image.append(new String(input_stream
6030: .GetSuffix(jjimageLen
6031: + (lengthOfMatch = jjmatchedPos + 1))));
6032: strictSyntaxCheck(matchedToken, DEFAULT);
6033: break;
6034: case 44:
6035: if (image == null)
6036: image = new StringBuffer(new String(input_stream
6037: .GetSuffix(jjimageLen
6038: + (lengthOfMatch = jjmatchedPos + 1))));
6039: else
6040: image.append(new String(input_stream
6041: .GetSuffix(jjimageLen
6042: + (lengthOfMatch = jjmatchedPos + 1))));
6043: strictSyntaxCheck(matchedToken, DEFAULT);
6044: break;
6045: case 45:
6046: if (image == null)
6047: image = new StringBuffer(new String(input_stream
6048: .GetSuffix(jjimageLen
6049: + (lengthOfMatch = jjmatchedPos + 1))));
6050: else
6051: image.append(new String(input_stream
6052: .GetSuffix(jjimageLen
6053: + (lengthOfMatch = jjmatchedPos + 1))));
6054: strictSyntaxCheck(matchedToken, DEFAULT);
6055: break;
6056: case 46:
6057: if (image == null)
6058: image = new StringBuffer(new String(input_stream
6059: .GetSuffix(jjimageLen
6060: + (lengthOfMatch = jjmatchedPos + 1))));
6061: else
6062: image.append(new String(input_stream
6063: .GetSuffix(jjimageLen
6064: + (lengthOfMatch = jjmatchedPos + 1))));
6065: strictSyntaxCheck(matchedToken, DEFAULT);
6066: break;
6067: case 47:
6068: if (image == null)
6069: image = new StringBuffer(new String(input_stream
6070: .GetSuffix(jjimageLen
6071: + (lengthOfMatch = jjmatchedPos + 1))));
6072: else
6073: image.append(new String(input_stream
6074: .GetSuffix(jjimageLen
6075: + (lengthOfMatch = jjmatchedPos + 1))));
6076: strictSyntaxCheck(matchedToken, DEFAULT);
6077: break;
6078: case 48:
6079: if (image == null)
6080: image = new StringBuffer(new String(input_stream
6081: .GetSuffix(jjimageLen
6082: + (lengthOfMatch = jjmatchedPos + 1))));
6083: else
6084: image.append(new String(input_stream
6085: .GetSuffix(jjimageLen
6086: + (lengthOfMatch = jjmatchedPos + 1))));
6087: strictSyntaxCheck(matchedToken, DEFAULT);
6088: break;
6089: case 49:
6090: if (image == null)
6091: image = new StringBuffer(new String(input_stream
6092: .GetSuffix(jjimageLen
6093: + (lengthOfMatch = jjmatchedPos + 1))));
6094: else
6095: image.append(new String(input_stream
6096: .GetSuffix(jjimageLen
6097: + (lengthOfMatch = jjmatchedPos + 1))));
6098: strictSyntaxCheck(matchedToken, DEFAULT);
6099: break;
6100: case 50:
6101: if (image == null)
6102: image = new StringBuffer(new String(input_stream
6103: .GetSuffix(jjimageLen
6104: + (lengthOfMatch = jjmatchedPos + 1))));
6105: else
6106: image.append(new String(input_stream
6107: .GetSuffix(jjimageLen
6108: + (lengthOfMatch = jjmatchedPos + 1))));
6109: strictSyntaxCheck(matchedToken, DEFAULT);
6110: break;
6111: case 51:
6112: if (image == null)
6113: image = new StringBuffer(new String(input_stream
6114: .GetSuffix(jjimageLen
6115: + (lengthOfMatch = jjmatchedPos + 1))));
6116: else
6117: image.append(new String(input_stream
6118: .GetSuffix(jjimageLen
6119: + (lengthOfMatch = jjmatchedPos + 1))));
6120: strictSyntaxCheck(matchedToken, DEFAULT);
6121: break;
6122: case 52:
6123: if (image == null)
6124: image = new StringBuffer(new String(input_stream
6125: .GetSuffix(jjimageLen
6126: + (lengthOfMatch = jjmatchedPos + 1))));
6127: else
6128: image.append(new String(input_stream
6129: .GetSuffix(jjimageLen
6130: + (lengthOfMatch = jjmatchedPos + 1))));
6131: strictSyntaxCheck(matchedToken, DEFAULT);
6132: break;
6133: case 53:
6134: if (image == null)
6135: image = new StringBuffer(new String(input_stream
6136: .GetSuffix(jjimageLen
6137: + (lengthOfMatch = jjmatchedPos + 1))));
6138: else
6139: image.append(new String(input_stream
6140: .GetSuffix(jjimageLen
6141: + (lengthOfMatch = jjmatchedPos + 1))));
6142: strictSyntaxCheck(matchedToken, DEFAULT);
6143: break;
6144: case 54:
6145: if (image == null)
6146: image = new StringBuffer(new String(input_stream
6147: .GetSuffix(jjimageLen
6148: + (lengthOfMatch = jjmatchedPos + 1))));
6149: else
6150: image.append(new String(input_stream
6151: .GetSuffix(jjimageLen
6152: + (lengthOfMatch = jjmatchedPos + 1))));
6153: strictSyntaxCheck(matchedToken, DEFAULT);
6154: break;
6155: case 55:
6156: if (image == null)
6157: image = new StringBuffer(new String(input_stream
6158: .GetSuffix(jjimageLen
6159: + (lengthOfMatch = jjmatchedPos + 1))));
6160: else
6161: image.append(new String(input_stream
6162: .GetSuffix(jjimageLen
6163: + (lengthOfMatch = jjmatchedPos + 1))));
6164: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
6165: break;
6166: case 56:
6167: if (image == null)
6168: image = new StringBuffer(new String(input_stream
6169: .GetSuffix(jjimageLen
6170: + (lengthOfMatch = jjmatchedPos + 1))));
6171: else
6172: image.append(new String(input_stream
6173: .GetSuffix(jjimageLen
6174: + (lengthOfMatch = jjmatchedPos + 1))));
6175: strictSyntaxCheck(matchedToken, DEFAULT);
6176: break;
6177: case 57:
6178: if (image == null)
6179: image = new StringBuffer(new String(input_stream
6180: .GetSuffix(jjimageLen
6181: + (lengthOfMatch = jjmatchedPos + 1))));
6182: else
6183: image.append(new String(input_stream
6184: .GetSuffix(jjimageLen
6185: + (lengthOfMatch = jjmatchedPos + 1))));
6186: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
6187: break;
6188: case 58:
6189: if (image == null)
6190: image = new StringBuffer(new String(input_stream
6191: .GetSuffix(jjimageLen
6192: + (lengthOfMatch = jjmatchedPos + 1))));
6193: else
6194: image.append(new String(input_stream
6195: .GetSuffix(jjimageLen
6196: + (lengthOfMatch = jjmatchedPos + 1))));
6197: strictSyntaxCheck(matchedToken, DEFAULT);
6198: break;
6199: case 59:
6200: if (image == null)
6201: image = new StringBuffer(new String(input_stream
6202: .GetSuffix(jjimageLen
6203: + (lengthOfMatch = jjmatchedPos + 1))));
6204: else
6205: image.append(new String(input_stream
6206: .GetSuffix(jjimageLen
6207: + (lengthOfMatch = jjmatchedPos + 1))));
6208: strictSyntaxCheck(matchedToken, FM_EXPRESSION);
6209: break;
6210: case 60:
6211: if (image == null)
6212: image = new StringBuffer(new String(input_stream
6213: .GetSuffix(jjimageLen
6214: + (lengthOfMatch = jjmatchedPos + 1))));
6215: else
6216: image.append(new String(input_stream
6217: .GetSuffix(jjimageLen
6218: + (lengthOfMatch = jjmatchedPos + 1))));
6219: strictSyntaxCheck(matchedToken, DEFAULT);
6220: break;
6221: case 61:
6222: if (image == null)
6223: image = new StringBuffer(new String(input_stream
6224: .GetSuffix(jjimageLen
6225: + (lengthOfMatch = jjmatchedPos + 1))));
6226: else
6227: image.append(new String(input_stream
6228: .GetSuffix(jjimageLen
6229: + (lengthOfMatch = jjmatchedPos + 1))));
6230: strictSyntaxCheck(matchedToken, DEFAULT);
6231: break;
6232: case 62:
6233: if (image == null)
6234: image = new StringBuffer(new String(input_stream
6235: .GetSuffix(jjimageLen
6236: + (lengthOfMatch = jjmatchedPos + 1))));
6237: else
6238: image.append(new String(input_stream
6239: .GetSuffix(jjimageLen
6240: + (lengthOfMatch = jjmatchedPos + 1))));
6241: strictSyntaxCheck(matchedToken, DEFAULT);
6242: break;
6243: case 63:
6244: if (image == null)
6245: image = new StringBuffer(new String(input_stream
6246: .GetSuffix(jjimageLen
6247: + (lengthOfMatch = jjmatchedPos + 1))));
6248: else
6249: image.append(new String(input_stream
6250: .GetSuffix(jjimageLen
6251: + (lengthOfMatch = jjmatchedPos + 1))));
6252: unifiedCall(matchedToken);
6253: break;
6254: case 64:
6255: if (image == null)
6256: image = new StringBuffer(new String(input_stream
6257: .GetSuffix(jjimageLen
6258: + (lengthOfMatch = jjmatchedPos + 1))));
6259: else
6260: image.append(new String(input_stream
6261: .GetSuffix(jjimageLen
6262: + (lengthOfMatch = jjmatchedPos + 1))));
6263: unifiedCallEnd(matchedToken);
6264: break;
6265: case 65:
6266: if (image == null)
6267: image = new StringBuffer(new String(input_stream
6268: .GetSuffix(jjimageLen
6269: + (lengthOfMatch = jjmatchedPos + 1))));
6270: else
6271: image.append(new String(input_stream
6272: .GetSuffix(jjimageLen
6273: + (lengthOfMatch = jjmatchedPos + 1))));
6274: ftlHeader(matchedToken);
6275: break;
6276: case 66:
6277: if (image == null)
6278: image = new StringBuffer(new String(input_stream
6279: .GetSuffix(jjimageLen
6280: + (lengthOfMatch = jjmatchedPos + 1))));
6281: else
6282: image.append(new String(input_stream
6283: .GetSuffix(jjimageLen
6284: + (lengthOfMatch = jjmatchedPos + 1))));
6285: ftlHeader(matchedToken);
6286: break;
6287: case 67:
6288: if (image == null)
6289: image = new StringBuffer(new String(input_stream
6290: .GetSuffix(jjimageLen
6291: + (lengthOfMatch = jjmatchedPos + 1))));
6292: else
6293: image.append(new String(input_stream
6294: .GetSuffix(jjimageLen
6295: + (lengthOfMatch = jjmatchedPos + 1))));
6296: if (!directiveSyntaxEstablished) {
6297: matchedToken.kind = PRINTABLE_CHARS;
6298: } else {
6299: char firstChar = matchedToken.image.charAt(0);
6300: if (firstChar == '<' && altDirectiveSyntax) {
6301: matchedToken.kind = PRINTABLE_CHARS;
6302: } else if (firstChar == '[' && !altDirectiveSyntax) {
6303: matchedToken.kind = PRINTABLE_CHARS;
6304: } else if (strictEscapeSyntax) {
6305: String s = matchedToken.image;
6306: int index = s.indexOf('#');
6307: s = s.substring(index);
6308: String msg = "Unknown directive: " + s
6309: + " on line: " + matchedToken.beginLine
6310: + ", column: " + matchedToken.beginColumn
6311: + 1 + ", in template: " + templateName;
6312: throw new TokenMgrError(msg,
6313: TokenMgrError.LEXICAL_ERROR);
6314: }
6315: }
6316: break;
6317: case 111:
6318: if (image == null)
6319: image = new StringBuffer(jjstrLiteralImages[111]);
6320: else
6321: image.append(jjstrLiteralImages[111]);
6322: ++bracketNesting;
6323: break;
6324: case 112:
6325: if (image == null)
6326: image = new StringBuffer(jjstrLiteralImages[112]);
6327: else
6328: image.append(jjstrLiteralImages[112]);
6329: closeBracket(matchedToken);
6330: break;
6331: case 113:
6332: if (image == null)
6333: image = new StringBuffer(jjstrLiteralImages[113]);
6334: else
6335: image.append(jjstrLiteralImages[113]);
6336: ++parenthesisNesting;
6337: if (parenthesisNesting == 1)
6338: SwitchTo(IN_PAREN);
6339: break;
6340: case 114:
6341: if (image == null)
6342: image = new StringBuffer(jjstrLiteralImages[114]);
6343: else
6344: image.append(jjstrLiteralImages[114]);
6345: --parenthesisNesting;
6346: if (parenthesisNesting == 0)
6347: SwitchTo(FM_EXPRESSION);
6348: break;
6349: case 115:
6350: if (image == null)
6351: image = new StringBuffer(jjstrLiteralImages[115]);
6352: else
6353: image.append(jjstrLiteralImages[115]);
6354: ++hashLiteralNesting;
6355: break;
6356: case 116:
6357: if (image == null)
6358: image = new StringBuffer(jjstrLiteralImages[116]);
6359: else
6360: image.append(jjstrLiteralImages[116]);
6361: if (hashLiteralNesting == 0)
6362: SwitchTo(DEFAULT);
6363: else
6364: --hashLiteralNesting;
6365: break;
6366: case 123:
6367: if (image == null)
6368: image = new StringBuffer(jjstrLiteralImages[123]);
6369: else
6370: image.append(jjstrLiteralImages[123]);
6371: if (inFTLHeader)
6372: eatNewline();
6373: inFTLHeader = false;
6374: if (altDirectiveSyntax) {
6375: matchedToken.kind = NATURAL_GT;
6376: } else {
6377: SwitchTo(DEFAULT);
6378: }
6379: break;
6380: case 124:
6381: if (image == null)
6382: image = new StringBuffer(new String(input_stream
6383: .GetSuffix(jjimageLen
6384: + (lengthOfMatch = jjmatchedPos + 1))));
6385: else
6386: image.append(new String(input_stream
6387: .GetSuffix(jjimageLen
6388: + (lengthOfMatch = jjmatchedPos + 1))));
6389: if (inFTLHeader)
6390: eatNewline();
6391: inFTLHeader = false;
6392: SwitchTo(DEFAULT);
6393: break;
6394: case 128:
6395: if (image == null)
6396: image = new StringBuffer(new String(input_stream
6397: .GetSuffix(jjimageLen
6398: + (lengthOfMatch = jjmatchedPos + 1))));
6399: else
6400: image.append(new String(input_stream
6401: .GetSuffix(jjimageLen
6402: + (lengthOfMatch = jjmatchedPos + 1))));
6403: if (noparseTag.equals("-->")) {
6404: boolean squareBracket = matchedToken.image
6405: .endsWith("]");
6406: if ((altDirectiveSyntax && squareBracket)
6407: || (!altDirectiveSyntax && !squareBracket))
6408: SwitchTo(DEFAULT);
6409: }
6410: break;
6411: case 129:
6412: if (image == null)
6413: image = new StringBuffer(new String(input_stream
6414: .GetSuffix(jjimageLen
6415: + (lengthOfMatch = jjmatchedPos + 1))));
6416: else
6417: image.append(new String(input_stream
6418: .GetSuffix(jjimageLen
6419: + (lengthOfMatch = jjmatchedPos + 1))));
6420: StringTokenizer st = new StringTokenizer(image.toString(),
6421: " \t\n\r<>[]/#", false);
6422: if (st.nextToken().equals(noparseTag)) {
6423: SwitchTo(DEFAULT);
6424: }
6425: break;
6426: default:
6427: break;
6428: }
6429: }
6430: }
|