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