| /* Generated By:JJTree&JavaCC: Do not edit this line. XPathTokenManager.java */ |
| package org.apache.xpath.impl.parser; |
| import java.util.Stack; |
| |
| public class XPathTokenManager implements XPathConstants |
| { |
| private Stack stateStack = new Stack(); |
| static final int PARENMARKER = 2000; |
| |
| /** |
| * Push the current state onto the state stack. |
| */ |
| private void pushState() |
| { |
| stateStack.addElement(new Integer(curLexState)); |
| } |
| |
| /** |
| * Push the given state onto the state stack. |
| * @param state Must be a valid state. |
| */ |
| private void pushState(int state) |
| { |
| stateStack.push(new Integer(state)); |
| } |
| |
| /** |
| * Pop the state on the state stack, and switch to that state. |
| */ |
| private void popState() |
| { |
| if (stateStack.size() == 0) |
| { |
| printLinePos(); |
| } |
| |
| int nextState = ((Integer) stateStack.pop()).intValue(); |
| if(nextState == PARENMARKER) |
| printLinePos(); |
| SwitchTo(nextState); |
| } |
| |
| /** |
| * Push a parenthesis state. This pushes, in addition to the |
| * lexical state value, a special marker that lets |
| * resetParenStateOrSwitch(int state) |
| * know if it should pop and switch. Used for the comma operator. |
| */ |
| private void pushParenState(int commaState, int rparState) |
| { |
| stateStack.push(new Integer(rparState)); |
| stateStack.push(new Integer(commaState)); |
| stateStack.push(new Integer(PARENMARKER)); |
| SwitchTo(commaState); |
| } |
| |
| |
| // /** |
| // * Push a parenthesis state. This pushes, in addition to the |
| // * lexical state value, a special marker that lets |
| // * resetParenStateOrSwitch(int state) |
| // * know if it should pop and switch. Used for the comma operator. |
| // */ |
| // private void pushParenState() |
| // { |
| // stateStack.push(new Integer(curLexState)); |
| // stateStack.push(new Integer(PARENMARKER)); |
| // } |
| |
| /** |
| * If a PARENMARKER is on the stack, switch the state to |
| * the state underneath the marker. Leave the stack in |
| * the same state. If the stack is zero, do nothing. |
| * @param state The state to switch to if the PARENMARKER is not found. |
| */ |
| private void resetParenStateOrSwitch(int state) |
| { |
| if (stateStack.size() == 0) |
| { |
| SwitchTo(state); |
| return; |
| } |
| |
| int nextState = ((Integer) stateStack.peek()).intValue(); |
| if (PARENMARKER == nextState) |
| { |
| // Wait for right paren to do the pop! |
| Integer intObj = (Integer) stateStack.elementAt(stateStack.size() - 2); |
| nextState = intObj.intValue(); |
| SwitchTo(nextState); |
| } |
| else |
| SwitchTo(state); |
| } |
| |
| // /** |
| // * Pop the lexical state stack two elements. |
| // */ |
| // private void popParenState() |
| // { |
| // if (stateStack.size() == 0) |
| // return; |
| // |
| // int nextState = ((Integer) stateStack.peek()).intValue(); |
| // if (PARENMARKER == nextState) |
| // { |
| // stateStack.pop(); |
| // stateStack.pop(); |
| // } |
| // } |
| |
| /** |
| * Pop the lexical state stack two elements. |
| */ |
| private void popParenState() |
| { |
| if (stateStack.size() == 0) |
| return; |
| |
| int nextState = ((Integer) stateStack.peek()).intValue(); |
| if (PARENMARKER == nextState) |
| { |
| stateStack.pop(); |
| stateStack.pop(); |
| int rparState = ((Integer) stateStack.peek()).intValue(); |
| SwitchTo(rparState); |
| stateStack.pop(); |
| } |
| } |
| |
| /** |
| * Print the current line position. |
| */ |
| public void printLinePos() |
| { |
| System.err.println("Line: " + input_stream.getEndLine()); |
| } |
| private final int jjMoveStringLiteralDfa0_5() |
| { |
| return jjMoveNfa_5(8, 0); |
| } |
| private final void jjCheckNAdd(int state) |
| { |
| if (jjrounds[state] != jjround) |
| { |
| jjstateSet[jjnewStateCnt++] = state; |
| jjrounds[state] = jjround; |
| } |
| } |
| private final void jjAddStates(int start, int end) |
| { |
| do { |
| jjstateSet[jjnewStateCnt++] = jjnextStates[start]; |
| } while (start++ != end); |
| } |
| private final void jjCheckNAddTwoStates(int state1, int state2) |
| { |
| jjCheckNAdd(state1); |
| jjCheckNAdd(state2); |
| } |
| private final void jjCheckNAddStates(int start, int end) |
| { |
| do { |
| jjCheckNAdd(jjnextStates[start]); |
| } while (start++ != end); |
| } |
| private final void jjCheckNAddStates(int start) |
| { |
| jjCheckNAdd(jjnextStates[start]); |
| jjCheckNAdd(jjnextStates[start + 1]); |
| } |
| static final long[] jjbitVec0 = { |
| 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL |
| }; |
| private final int jjMoveNfa_5(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 15; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 8: |
| case 0: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddTwoStates(0, 5); |
| break; |
| case 1: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(2, 7); |
| break; |
| case 2: |
| jjCheckNAddTwoStates(2, 7); |
| break; |
| case 4: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 1; |
| break; |
| case 6: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 3; |
| break; |
| case 7: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 6; |
| break; |
| case 9: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(10, 13); |
| break; |
| case 10: |
| jjCheckNAddTwoStates(10, 13); |
| break; |
| case 12: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 11; |
| break; |
| case 13: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 12; |
| break; |
| case 14: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 9; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 8: |
| if (curChar == 123) |
| jjCheckNAddTwoStates(14, 4); |
| break; |
| case 2: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(0, 1); |
| break; |
| case 3: |
| if (curChar != 125) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjAddStates(2, 3); |
| break; |
| case 5: |
| if (curChar == 123) |
| jjCheckNAdd(4); |
| break; |
| case 10: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(4, 5); |
| break; |
| case 11: |
| if (curChar == 125 && kind > 5) |
| kind = 5; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 2: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(0, 1); |
| break; |
| case 10: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(4, 5); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjStopStringLiteralDfa_10(int pos, long active0, long active1) |
| { |
| switch (pos) |
| { |
| default : |
| return -1; |
| } |
| } |
| private final int jjStartNfa_10(int pos, long active0, long active1) |
| { |
| return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0, active1), pos + 1); |
| } |
| private final int jjStopAtPos(int pos, int kind) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = pos; |
| return pos + 1; |
| } |
| private final int jjStartNfaWithStates_10(int pos, int kind, int state) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = pos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return pos + 1; } |
| return jjMoveNfa_10(state, pos + 1); |
| } |
| private final int jjMoveStringLiteralDfa0_10() |
| { |
| switch(curChar) |
| { |
| case 123: |
| return jjStopAtPos(0, 118); |
| default : |
| return jjMoveNfa_10(0, 0); |
| } |
| } |
| private final int jjMoveNfa_10(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 1; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((0x100002600L & l) == 0L) |
| break; |
| kind = 8; |
| jjstateSet[jjnewStateCnt++] = 0; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjStopStringLiteralDfa_12(int pos, long active0, long active1) |
| { |
| switch (pos) |
| { |
| default : |
| return -1; |
| } |
| } |
| private final int jjStartNfa_12(int pos, long active0, long active1) |
| { |
| return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0, active1), pos + 1); |
| } |
| private final int jjStartNfaWithStates_12(int pos, int kind, int state) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = pos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return pos + 1; } |
| return jjMoveNfa_12(state, pos + 1); |
| } |
| private final int jjMoveStringLiteralDfa0_12() |
| { |
| switch(curChar) |
| { |
| case 123: |
| return jjStopAtPos(0, 118); |
| default : |
| return jjMoveNfa_12(0, 0); |
| } |
| } |
| static final long[] jjbitVec1 = { |
| 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x7fffffffffffffffL |
| }; |
| static final long[] jjbitVec3 = { |
| 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffffL |
| }; |
| private final int jjMoveNfa_12(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 1; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((0xffffffff00002600L & l) != 0L) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((jjbitVec0[i2] & l2) != 0L && kind > 121) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjMoveStringLiteralDfa0_4() |
| { |
| return jjMoveNfa_4(0, 0); |
| } |
| private final int jjMoveNfa_4(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 17; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(6, 8); |
| break; |
| case 1: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(2, 5); |
| break; |
| case 2: |
| jjCheckNAddTwoStates(2, 5); |
| break; |
| case 4: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 3; |
| break; |
| case 5: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 4; |
| break; |
| case 6: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 1; |
| break; |
| case 7: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(8, 14); |
| break; |
| case 8: |
| jjCheckNAddTwoStates(8, 14); |
| break; |
| case 10: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddTwoStates(10, 12); |
| break; |
| case 11: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 7; |
| break; |
| case 13: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 9; |
| break; |
| case 14: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 13; |
| break; |
| case 16: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 8) |
| kind = 8; |
| jjCheckNAdd(16); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if (curChar == 123) |
| jjCheckNAddTwoStates(6, 11); |
| break; |
| case 2: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(9, 10); |
| break; |
| case 3: |
| if (curChar == 125 && kind > 5) |
| kind = 5; |
| break; |
| case 8: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(11, 12); |
| break; |
| case 9: |
| if (curChar != 125) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjAddStates(13, 14); |
| break; |
| case 12: |
| if (curChar == 123) |
| jjCheckNAdd(11); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 2: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(9, 10); |
| break; |
| case 8: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(11, 12); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 17 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjStopStringLiteralDfa_6(int pos, long active0, long active1) |
| { |
| switch (pos) |
| { |
| case 0: |
| if ((active0 & 0x60030000000000L) != 0L || (active1 & 0x7600000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| return 65; |
| } |
| if ((active0 & 0x40000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| return 17; |
| } |
| if ((active1 & 0x80000000000000L) != 0L) |
| return 46; |
| return -1; |
| case 1: |
| if ((active0 & 0x40000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 1; |
| return 16; |
| } |
| if ((active0 & 0x60030000000000L) != 0L || (active1 & 0x7600000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 1; |
| return 65; |
| } |
| return -1; |
| case 2: |
| if ((active0 & 0x60070000000000L) != 0L || (active1 & 0x7600000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 2; |
| return 65; |
| } |
| return -1; |
| case 3: |
| if ((active0 & 0x20010000000000L) != 0L || (active1 & 0x1000000000L) != 0L) |
| return 65; |
| if ((active0 & 0x40060000000000L) != 0L || (active1 & 0x6600000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 3; |
| return 65; |
| } |
| return -1; |
| case 4: |
| if ((active0 & 0x40000000000000L) != 0L) |
| return 65; |
| if ((active0 & 0x60000000000L) != 0L || (active1 & 0x6600000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 4; |
| return 65; |
| } |
| return -1; |
| case 5: |
| if ((active0 & 0x60000000000L) != 0L || (active1 & 0x6600000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 5; |
| return 65; |
| } |
| return -1; |
| case 6: |
| if ((active0 & 0x20000000000L) != 0L || (active1 & 0x2200000000L) != 0L) |
| return 65; |
| if ((active0 & 0x40000000000L) != 0L || (active1 & 0x4400000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 6; |
| return 65; |
| } |
| return -1; |
| case 7: |
| if ((active1 & 0x400000000L) != 0L) |
| return 65; |
| if ((active0 & 0x40000000000L) != 0L || (active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 7; |
| return 65; |
| } |
| return -1; |
| case 8: |
| if ((active0 & 0x40000000000L) != 0L) |
| return 65; |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 8; |
| return 65; |
| } |
| return -1; |
| case 9: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 9; |
| return 65; |
| } |
| return -1; |
| case 10: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 10; |
| return 65; |
| } |
| return -1; |
| case 11: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 11; |
| return 65; |
| } |
| return -1; |
| case 12: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 12; |
| return 65; |
| } |
| return -1; |
| case 13: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 13; |
| return 65; |
| } |
| return -1; |
| case 14: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 14; |
| return 65; |
| } |
| return -1; |
| case 15: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 15; |
| return 65; |
| } |
| return -1; |
| case 16: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 16; |
| return 65; |
| } |
| return -1; |
| case 17: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 17; |
| return 65; |
| } |
| return -1; |
| case 18: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 18; |
| return 65; |
| } |
| return -1; |
| case 19: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 19; |
| return 65; |
| } |
| return -1; |
| case 20: |
| if ((active1 & 0x4000000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 20; |
| return 65; |
| } |
| return -1; |
| default : |
| return -1; |
| } |
| } |
| private final int jjStartNfa_6(int pos, long active0, long active1) |
| { |
| return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0, active1), pos + 1); |
| } |
| private final int jjStartNfaWithStates_6(int pos, int kind, int state) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = pos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return pos + 1; } |
| return jjMoveNfa_6(state, pos + 1); |
| } |
| private final int jjMoveStringLiteralDfa0_6() |
| { |
| switch(curChar) |
| { |
| case 36: |
| return jjStopAtPos(0, 114); |
| case 41: |
| return jjStopAtPos(0, 88); |
| case 46: |
| jjmatchedKind = 109; |
| return jjMoveStringLiteralDfa1_6(0x0L, 0x400000000000L); |
| case 97: |
| return jjMoveStringLiteralDfa1_6(0x40000000000L, 0x0L); |
| case 99: |
| return jjMoveStringLiteralDfa1_6(0x0L, 0x200000000L); |
| case 100: |
| return jjMoveStringLiteralDfa1_6(0x0L, 0x400000000L); |
| case 101: |
| return jjMoveStringLiteralDfa1_6(0x40020000000000L, 0x0L); |
| case 105: |
| return jjMoveStringLiteralDfa1_6(0x10000000000L, 0x0L); |
| case 110: |
| return jjMoveStringLiteralDfa1_6(0x20000000000000L, 0x0L); |
| case 112: |
| return jjMoveStringLiteralDfa1_6(0x0L, 0x4000000000L); |
| case 116: |
| return jjMoveStringLiteralDfa1_6(0x0L, 0x1000000000L); |
| case 117: |
| return jjMoveStringLiteralDfa1_6(0x0L, 0x2000000000L); |
| case 123: |
| return jjStartNfaWithStates_6(0, 119, 46); |
| default : |
| return jjMoveNfa_6(18, 0); |
| } |
| } |
| private final int jjMoveStringLiteralDfa1_6(long active0, long active1) |
| { |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(0, active0, active1); |
| return 1; |
| } |
| switch(curChar) |
| { |
| case 46: |
| if ((active1 & 0x400000000000L) != 0L) |
| return jjStopAtPos(1, 110); |
| break; |
| case 101: |
| return jjMoveStringLiteralDfa2_6(active0, 0L, active1, 0x1000000000L); |
| case 108: |
| return jjMoveStringLiteralDfa2_6(active0, 0x20000000000L, active1, 0L); |
| case 109: |
| return jjMoveStringLiteralDfa2_6(active0, 0x40000000000000L, active1, 0L); |
| case 110: |
| return jjMoveStringLiteralDfa2_6(active0, 0L, active1, 0x2000000000L); |
| case 111: |
| return jjMoveStringLiteralDfa2_6(active0, 0x20000000000000L, active1, 0x600000000L); |
| case 114: |
| return jjMoveStringLiteralDfa2_6(active0, 0L, active1, 0x4000000000L); |
| case 116: |
| return jjMoveStringLiteralDfa2_6(active0, 0x50000000000L, active1, 0L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(0, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa2_6(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_6(0, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(1, active0, active1); |
| return 2; |
| } |
| switch(curChar) |
| { |
| case 99: |
| return jjMoveStringLiteralDfa3_6(active0, 0L, active1, 0x400000000L); |
| case 100: |
| return jjMoveStringLiteralDfa3_6(active0, 0x20000000000000L, active1, 0L); |
| case 101: |
| return jjMoveStringLiteralDfa3_6(active0, 0x30000000000L, active1, 0L); |
| case 109: |
| return jjMoveStringLiteralDfa3_6(active0, 0L, active1, 0x200000000L); |
| case 111: |
| return jjMoveStringLiteralDfa3_6(active0, 0L, active1, 0x4000000000L); |
| case 112: |
| return jjMoveStringLiteralDfa3_6(active0, 0x40000000000000L, active1, 0L); |
| case 116: |
| return jjMoveStringLiteralDfa3_6(active0, 0x40000000000L, active1, 0x2000000000L); |
| case 120: |
| return jjMoveStringLiteralDfa3_6(active0, 0L, active1, 0x1000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(1, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa3_6(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_6(1, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(2, active0, active1); |
| return 3; |
| } |
| switch(curChar) |
| { |
| case 99: |
| return jjMoveStringLiteralDfa4_6(active0, 0L, active1, 0x4000000000L); |
| case 101: |
| if ((active0 & 0x20000000000000L) != 0L) |
| return jjStartNfaWithStates_6(3, 53, 65); |
| break; |
| case 109: |
| if ((active0 & 0x10000000000L) != 0L) |
| return jjStartNfaWithStates_6(3, 40, 65); |
| return jjMoveStringLiteralDfa4_6(active0, 0x20000000000L, active1, 0x200000000L); |
| case 114: |
| return jjMoveStringLiteralDfa4_6(active0, 0x40000000000L, active1, 0L); |
| case 116: |
| if ((active1 & 0x1000000000L) != 0L) |
| return jjStartNfaWithStates_6(3, 100, 65); |
| return jjMoveStringLiteralDfa4_6(active0, 0x40000000000000L, active1, 0L); |
| case 117: |
| return jjMoveStringLiteralDfa4_6(active0, 0L, active1, 0x400000000L); |
| case 121: |
| return jjMoveStringLiteralDfa4_6(active0, 0L, active1, 0x2000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(2, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa4_6(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_6(2, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(3, active0, active1); |
| return 4; |
| } |
| switch(curChar) |
| { |
| case 101: |
| return jjMoveStringLiteralDfa5_6(active0, 0x20000000000L, active1, 0x4200000000L); |
| case 105: |
| return jjMoveStringLiteralDfa5_6(active0, 0x40000000000L, active1, 0L); |
| case 109: |
| return jjMoveStringLiteralDfa5_6(active0, 0L, active1, 0x400000000L); |
| case 112: |
| return jjMoveStringLiteralDfa5_6(active0, 0L, active1, 0x2000000000L); |
| case 121: |
| if ((active0 & 0x40000000000000L) != 0L) |
| return jjStartNfaWithStates_6(4, 54, 65); |
| break; |
| default : |
| break; |
| } |
| return jjStartNfa_6(3, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa5_6(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_6(3, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(4, active0, active1); |
| return 5; |
| } |
| switch(curChar) |
| { |
| case 98: |
| return jjMoveStringLiteralDfa6_6(active0, 0x40000000000L, active1, 0L); |
| case 101: |
| return jjMoveStringLiteralDfa6_6(active0, 0L, active1, 0x2400000000L); |
| case 110: |
| return jjMoveStringLiteralDfa6_6(active0, 0x20000000000L, active1, 0x200000000L); |
| case 115: |
| return jjMoveStringLiteralDfa6_6(active0, 0L, active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(4, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa6_6(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_6(4, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(5, active0, active1); |
| return 6; |
| } |
| switch(curChar) |
| { |
| case 100: |
| if ((active1 & 0x2000000000L) != 0L) |
| return jjStartNfaWithStates_6(6, 101, 65); |
| break; |
| case 110: |
| return jjMoveStringLiteralDfa7_6(active0, 0L, active1, 0x400000000L); |
| case 115: |
| return jjMoveStringLiteralDfa7_6(active0, 0L, active1, 0x4000000000L); |
| case 116: |
| if ((active0 & 0x20000000000L) != 0L) |
| return jjStartNfaWithStates_6(6, 41, 65); |
| else if ((active1 & 0x200000000L) != 0L) |
| return jjStartNfaWithStates_6(6, 97, 65); |
| break; |
| case 117: |
| return jjMoveStringLiteralDfa7_6(active0, 0x40000000000L, active1, 0L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(5, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa7_6(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_6(5, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(6, active0, active1); |
| return 7; |
| } |
| switch(curChar) |
| { |
| case 105: |
| return jjMoveStringLiteralDfa8_6(active0, 0L, active1, 0x4000000000L); |
| case 116: |
| if ((active1 & 0x400000000L) != 0L) |
| return jjStartNfaWithStates_6(7, 98, 65); |
| return jjMoveStringLiteralDfa8_6(active0, 0x40000000000L, active1, 0L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(6, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa8_6(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_6(6, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(7, active0, active1); |
| return 8; |
| } |
| switch(curChar) |
| { |
| case 101: |
| if ((active0 & 0x40000000000L) != 0L) |
| return jjStartNfaWithStates_6(8, 42, 65); |
| break; |
| case 110: |
| return jjMoveStringLiteralDfa9_6(active0, 0L, active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(7, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa9_6(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_6(7, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(8, 0L, active1); |
| return 9; |
| } |
| switch(curChar) |
| { |
| case 103: |
| return jjMoveStringLiteralDfa10_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(8, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa10_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(8, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(9, 0L, active1); |
| return 10; |
| } |
| switch(curChar) |
| { |
| case 45: |
| return jjMoveStringLiteralDfa11_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(9, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa11_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(9, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(10, 0L, active1); |
| return 11; |
| } |
| switch(curChar) |
| { |
| case 105: |
| return jjMoveStringLiteralDfa12_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(10, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa12_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(10, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(11, 0L, active1); |
| return 12; |
| } |
| switch(curChar) |
| { |
| case 110: |
| return jjMoveStringLiteralDfa13_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(11, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa13_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(11, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(12, 0L, active1); |
| return 13; |
| } |
| switch(curChar) |
| { |
| case 115: |
| return jjMoveStringLiteralDfa14_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(12, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa14_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(12, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(13, 0L, active1); |
| return 14; |
| } |
| switch(curChar) |
| { |
| case 116: |
| return jjMoveStringLiteralDfa15_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(13, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa15_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(13, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(14, 0L, active1); |
| return 15; |
| } |
| switch(curChar) |
| { |
| case 114: |
| return jjMoveStringLiteralDfa16_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(14, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa16_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(14, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(15, 0L, active1); |
| return 16; |
| } |
| switch(curChar) |
| { |
| case 117: |
| return jjMoveStringLiteralDfa17_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(15, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa17_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(15, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(16, 0L, active1); |
| return 17; |
| } |
| switch(curChar) |
| { |
| case 99: |
| return jjMoveStringLiteralDfa18_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(16, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa18_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(16, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(17, 0L, active1); |
| return 18; |
| } |
| switch(curChar) |
| { |
| case 116: |
| return jjMoveStringLiteralDfa19_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(17, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa19_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(17, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(18, 0L, active1); |
| return 19; |
| } |
| switch(curChar) |
| { |
| case 105: |
| return jjMoveStringLiteralDfa20_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(18, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa20_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(18, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(19, 0L, active1); |
| return 20; |
| } |
| switch(curChar) |
| { |
| case 111: |
| return jjMoveStringLiteralDfa21_6(active1, 0x4000000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_6(19, 0L, active1); |
| } |
| private final int jjMoveStringLiteralDfa21_6(long old1, long active1) |
| { |
| if (((active1 &= old1)) == 0L) |
| return jjStartNfa_6(19, 0L, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_6(20, 0L, active1); |
| return 21; |
| } |
| switch(curChar) |
| { |
| case 110: |
| if ((active1 & 0x4000000000L) != 0L) |
| return jjStartNfaWithStates_6(21, 102, 65); |
| break; |
| default : |
| break; |
| } |
| return jjStartNfa_6(20, 0L, active1); |
| } |
| static final long[] jjbitVec4 = { |
| 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL |
| }; |
| static final long[] jjbitVec5 = { |
| 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL |
| }; |
| static final long[] jjbitVec6 = { |
| 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL |
| }; |
| static final long[] jjbitVec7 = { |
| 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L |
| }; |
| static final long[] jjbitVec8 = { |
| 0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL |
| }; |
| static final long[] jjbitVec9 = { |
| 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL |
| }; |
| static final long[] jjbitVec10 = { |
| 0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L |
| }; |
| static final long[] jjbitVec11 = { |
| 0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL |
| }; |
| static final long[] jjbitVec12 = { |
| 0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L |
| }; |
| static final long[] jjbitVec13 = { |
| 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L |
| }; |
| static final long[] jjbitVec14 = { |
| 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L |
| }; |
| static final long[] jjbitVec15 = { |
| 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L |
| }; |
| static final long[] jjbitVec16 = { |
| 0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L |
| }; |
| static final long[] jjbitVec17 = { |
| 0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL |
| }; |
| static final long[] jjbitVec18 = { |
| 0x0L, 0x3fffffffeffL, 0x0L, 0x0L |
| }; |
| static final long[] jjbitVec19 = { |
| 0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL |
| }; |
| static final long[] jjbitVec20 = { |
| 0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L |
| }; |
| static final long[] jjbitVec21 = { |
| 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL |
| }; |
| static final long[] jjbitVec22 = { |
| 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL |
| }; |
| static final long[] jjbitVec23 = { |
| 0x4c4000000000L, 0x0L, 0x7L, 0x0L |
| }; |
| static final long[] jjbitVec24 = { |
| 0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL |
| }; |
| static final long[] jjbitVec25 = { |
| 0x1fffffffffe0L, 0x0L, 0x0L, 0x0L |
| }; |
| static final long[] jjbitVec26 = { |
| 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L |
| }; |
| static final long[] jjbitVec27 = { |
| 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L |
| }; |
| static final long[] jjbitVec28 = { |
| 0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL |
| }; |
| static final long[] jjbitVec29 = { |
| 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L |
| }; |
| static final long[] jjbitVec30 = { |
| 0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL |
| }; |
| static final long[] jjbitVec31 = { |
| 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL |
| }; |
| static final long[] jjbitVec32 = { |
| 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L |
| }; |
| static final long[] jjbitVec33 = { |
| 0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL |
| }; |
| static final long[] jjbitVec34 = { |
| 0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL |
| }; |
| static final long[] jjbitVec35 = { |
| 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL |
| }; |
| static final long[] jjbitVec36 = { |
| 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L |
| }; |
| static final long[] jjbitVec37 = { |
| 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL |
| }; |
| static final long[] jjbitVec38 = { |
| 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L |
| }; |
| static final long[] jjbitVec39 = { |
| 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL |
| }; |
| static final long[] jjbitVec40 = { |
| 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L |
| }; |
| static final long[] jjbitVec41 = { |
| 0x0L, 0x0L, 0x0L, 0x21fff0000L |
| }; |
| static final long[] jjbitVec42 = { |
| 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL |
| }; |
| private final int jjMoveNfa_6(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 65; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 65: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 63; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 60; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| break; |
| case 17: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 63; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 60; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| break; |
| case 18: |
| if ((0x100002600L & l) != 0L) |
| { |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(15, 17); |
| } |
| else if (curChar == 42) |
| jjstateSet[jjnewStateCnt++] = 20; |
| break; |
| case 16: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 63; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 60; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| break; |
| case 46: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 47; |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 41; |
| break; |
| case 1: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(18, 20); |
| break; |
| case 2: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(3, 13); |
| break; |
| case 3: |
| jjCheckNAddTwoStates(3, 13); |
| break; |
| case 5: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 2; |
| break; |
| case 12: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 4; |
| break; |
| case 13: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 12; |
| break; |
| case 19: |
| if (curChar == 42) |
| jjstateSet[jjnewStateCnt++] = 20; |
| break; |
| case 20: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 21; |
| break; |
| case 22: |
| if ((0x3ff600000000000L & l) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjstateSet[jjnewStateCnt++] = 22; |
| break; |
| case 24: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(21, 23); |
| break; |
| case 25: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(26, 32); |
| break; |
| case 26: |
| jjCheckNAddTwoStates(26, 32); |
| break; |
| case 28: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 25; |
| break; |
| case 31: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 27; |
| break; |
| case 32: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 31; |
| break; |
| case 41: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(42, 45); |
| break; |
| case 42: |
| jjCheckNAddTwoStates(42, 45); |
| break; |
| case 44: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 43; |
| break; |
| case 45: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 44; |
| break; |
| case 47: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(48, 54); |
| break; |
| case 48: |
| jjCheckNAddTwoStates(48, 54); |
| break; |
| case 50: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddTwoStates(50, 52); |
| break; |
| case 51: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 47; |
| break; |
| case 53: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 49; |
| break; |
| case 54: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 53; |
| break; |
| case 55: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(15, 17); |
| break; |
| case 56: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 8) |
| kind = 8; |
| jjCheckNAdd(56); |
| break; |
| case 58: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| break; |
| case 59: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 60; |
| break; |
| case 60: |
| if (curChar == 42 && kind > 58) |
| kind = 58; |
| break; |
| case 61: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| break; |
| case 62: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 63; |
| break; |
| case 64: |
| if ((0x3ff600000000000L & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 65: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| break; |
| case 17: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 16; |
| break; |
| case 18: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(24, 28); |
| } |
| else if (curChar == 123) |
| jjCheckNAddTwoStates(46, 51); |
| if (curChar == 118) |
| jjstateSet[jjnewStateCnt++] = 38; |
| else if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 17; |
| break; |
| case 16: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 15; |
| break; |
| case 0: |
| if (curChar == 99) |
| jjCheckNAddTwoStates(1, 6); |
| break; |
| case 3: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(29, 30); |
| break; |
| case 4: |
| if (curChar == 125) |
| jjCheckNAddStates(18, 20); |
| break; |
| case 6: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 5; |
| break; |
| case 7: |
| if (curChar == 101 && kind > 51) |
| kind = 51; |
| break; |
| case 8: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 7; |
| break; |
| case 9: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 8; |
| break; |
| case 10: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 9; |
| break; |
| case 11: |
| if (curChar == 118) |
| jjstateSet[jjnewStateCnt++] = 10; |
| break; |
| case 14: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 0; |
| break; |
| case 15: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 14; |
| break; |
| case 21: |
| case 22: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(22); |
| break; |
| case 23: |
| if (curChar == 101) |
| jjCheckNAddStates(21, 23); |
| break; |
| case 26: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(31, 32); |
| break; |
| case 27: |
| if (curChar == 125) |
| jjCheckNAddStates(21, 23); |
| break; |
| case 29: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 28; |
| break; |
| case 30: |
| if (curChar == 123 && kind > 94) |
| kind = 94; |
| break; |
| case 33: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 23; |
| break; |
| case 34: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 33; |
| break; |
| case 35: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 34; |
| break; |
| case 36: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 35; |
| break; |
| case 37: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 36; |
| break; |
| case 38: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 37; |
| break; |
| case 39: |
| if (curChar == 118) |
| jjstateSet[jjnewStateCnt++] = 38; |
| break; |
| case 40: |
| if (curChar == 123) |
| jjCheckNAddTwoStates(46, 51); |
| break; |
| case 42: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(33, 34); |
| break; |
| case 43: |
| if (curChar == 125 && kind > 5) |
| kind = 5; |
| break; |
| case 48: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(35, 36); |
| break; |
| case 49: |
| if (curChar != 125) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjAddStates(37, 38); |
| break; |
| case 52: |
| if (curChar == 123) |
| jjCheckNAdd(51); |
| break; |
| case 57: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(24, 28); |
| break; |
| case 58: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| break; |
| case 61: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| break; |
| case 63: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| break; |
| case 64: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 65: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| } |
| break; |
| case 17: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| } |
| break; |
| case 18: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(24, 28); |
| break; |
| case 16: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| } |
| break; |
| case 3: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(29, 30); |
| break; |
| case 21: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(22); |
| break; |
| case 22: |
| if ((jjbitVec28[i2] & l2) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(22); |
| break; |
| case 26: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(31, 32); |
| break; |
| case 42: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(33, 34); |
| break; |
| case 48: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(35, 36); |
| break; |
| case 58: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(58, 59); |
| break; |
| case 61: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(61, 62); |
| break; |
| case 63: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| break; |
| case 64: |
| if ((jjbitVec28[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(64); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 65 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjMoveStringLiteralDfa0_7() |
| { |
| return jjMoveNfa_7(8, 0); |
| } |
| private final int jjMoveNfa_7(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 20; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 8: |
| case 0: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddTwoStates(0, 5); |
| break; |
| case 1: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(2, 7); |
| break; |
| case 2: |
| jjCheckNAddTwoStates(2, 7); |
| break; |
| case 4: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 1; |
| break; |
| case 6: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 3; |
| break; |
| case 7: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 6; |
| break; |
| case 9: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjAddStates(39, 40); |
| break; |
| case 10: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 11; |
| break; |
| case 12: |
| if ((0x3ff600000000000L & l) == 0L) |
| break; |
| if (kind > 115) |
| kind = 115; |
| jjstateSet[jjnewStateCnt++] = 12; |
| break; |
| case 14: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(15, 18); |
| break; |
| case 15: |
| jjCheckNAddTwoStates(15, 18); |
| break; |
| case 17: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 16; |
| break; |
| case 18: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 17; |
| break; |
| case 19: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 14; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 8: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 115) |
| kind = 115; |
| jjCheckNAddStates(41, 43); |
| } |
| else if (curChar == 123) |
| jjCheckNAddTwoStates(19, 4); |
| break; |
| case 2: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(0, 1); |
| break; |
| case 3: |
| if (curChar != 125) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjAddStates(2, 3); |
| break; |
| case 5: |
| if (curChar == 123) |
| jjCheckNAdd(4); |
| break; |
| case 9: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(9, 10); |
| break; |
| case 11: |
| case 12: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 115) |
| kind = 115; |
| jjCheckNAdd(12); |
| break; |
| case 13: |
| if (curChar == 123) |
| jjCheckNAddTwoStates(19, 4); |
| break; |
| case 15: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(44, 45); |
| break; |
| case 16: |
| if (curChar == 125 && kind > 5) |
| kind = 5; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 8: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 115) |
| kind = 115; |
| jjCheckNAddStates(41, 43); |
| break; |
| case 2: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(0, 1); |
| break; |
| case 9: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(9, 10); |
| break; |
| case 11: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 115) |
| kind = 115; |
| jjCheckNAdd(12); |
| break; |
| case 12: |
| if ((jjbitVec28[i2] & l2) == 0L) |
| break; |
| if (kind > 115) |
| kind = 115; |
| jjCheckNAdd(12); |
| break; |
| case 15: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(44, 45); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 20 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjMoveStringLiteralDfa0_15() |
| { |
| return jjMoveNfa_15(0, 0); |
| } |
| private final int jjMoveNfa_15(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 1; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((0xffffffff00002600L & l) != 0L) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((jjbitVec0[i2] & l2) != 0L && kind > 121) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) |
| { |
| switch (pos) |
| { |
| case 0: |
| if ((active1 & 0x80000000000000L) != 0L) |
| return 55; |
| if ((active0 & 0x200000000000000L) != 0L) |
| return 21; |
| if ((active1 & 0x600000000000L) != 0L) |
| return 718; |
| return -1; |
| default : |
| return -1; |
| } |
| } |
| private final int jjStartNfa_0(int pos, long active0, long active1) |
| { |
| return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1); |
| } |
| private final int jjStartNfaWithStates_0(int pos, int kind, int state) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = pos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return pos + 1; } |
| return jjMoveNfa_0(state, pos + 1); |
| } |
| private final int jjMoveStringLiteralDfa0_0() |
| { |
| switch(curChar) |
| { |
| case 36: |
| return jjStopAtPos(0, 114); |
| case 40: |
| return jjStopAtPos(0, 84); |
| case 41: |
| return jjStopAtPos(0, 88); |
| case 42: |
| return jjStartNfaWithStates_0(0, 57, 21); |
| case 43: |
| return jjStopAtPos(0, 81); |
| case 44: |
| return jjStopAtPos(0, 108); |
| case 45: |
| return jjStopAtPos(0, 80); |
| case 46: |
| jjmatchedKind = 109; |
| return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000000L); |
| case 47: |
| jjmatchedKind = 60; |
| return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L); |
| case 63: |
| return jjStopAtPos(0, 82); |
| case 64: |
| return jjStopAtPos(0, 85); |
| case 91: |
| return jjStopAtPos(0, 86); |
| case 93: |
| return jjStopAtPos(0, 87); |
| case 123: |
| return jjStartNfaWithStates_0(0, 119, 55); |
| case 125: |
| return jjStopAtPos(0, 120); |
| default : |
| return jjMoveNfa_0(19, 0); |
| } |
| } |
| private final int jjMoveStringLiteralDfa1_0(long active0, long active1) |
| { |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_0(0, active0, active1); |
| return 1; |
| } |
| switch(curChar) |
| { |
| case 46: |
| if ((active1 & 0x400000000000L) != 0L) |
| return jjStopAtPos(1, 110); |
| break; |
| case 47: |
| if ((active0 & 0x2000000000000000L) != 0L) |
| return jjStopAtPos(1, 61); |
| break; |
| default : |
| break; |
| } |
| return jjStartNfa_0(0, active0, active1); |
| } |
| private final int jjMoveNfa_0(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 718; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 55: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 56; |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 50; |
| break; |
| case 19: |
| if ((0x3ff000000000000L & l) != 0L) |
| { |
| if (kind > 1) |
| kind = 1; |
| jjCheckNAddStates(46, 51); |
| } |
| else if ((0x100002600L & l) != 0L) |
| { |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(52, 54); |
| } |
| else if (curChar == 46) |
| jjCheckNAddTwoStates(47, 48); |
| else if (curChar == 42) |
| jjstateSet[jjnewStateCnt++] = 21; |
| else if (curChar == 39) |
| jjCheckNAddTwoStates(4, 5); |
| else if (curChar == 34) |
| jjCheckNAddTwoStates(1, 2); |
| break; |
| case 718: |
| if ((0x3ff000000000000L & l) != 0L) |
| jjCheckNAddTwoStates(48, 43); |
| if ((0x3ff000000000000L & l) != 0L) |
| { |
| if (kind > 2) |
| kind = 2; |
| jjCheckNAdd(47); |
| } |
| break; |
| case 0: |
| if (curChar == 34) |
| jjCheckNAddTwoStates(1, 2); |
| break; |
| case 1: |
| if ((0xfffffffbffffffffL & l) != 0L) |
| jjCheckNAddTwoStates(1, 2); |
| break; |
| case 2: |
| if (curChar != 34) |
| break; |
| if (kind > 4) |
| kind = 4; |
| jjstateSet[jjnewStateCnt++] = 0; |
| break; |
| case 3: |
| if (curChar == 39) |
| jjCheckNAddTwoStates(4, 5); |
| break; |
| case 4: |
| if ((0xffffff7fffffffffL & l) != 0L) |
| jjCheckNAddTwoStates(4, 5); |
| break; |
| case 5: |
| if (curChar != 39) |
| break; |
| if (kind > 4) |
| kind = 4; |
| jjstateSet[jjnewStateCnt++] = 3; |
| break; |
| case 7: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(55, 57); |
| break; |
| case 8: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(9, 18); |
| break; |
| case 9: |
| jjCheckNAddTwoStates(9, 18); |
| break; |
| case 11: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 8; |
| break; |
| case 17: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 10; |
| break; |
| case 18: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 17; |
| break; |
| case 20: |
| if (curChar == 42) |
| jjstateSet[jjnewStateCnt++] = 21; |
| break; |
| case 21: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 22; |
| break; |
| case 23: |
| if ((0x3ff600000000000L & l) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjstateSet[jjnewStateCnt++] = 23; |
| break; |
| case 25: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(58, 60); |
| break; |
| case 26: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(27, 33); |
| break; |
| case 27: |
| jjCheckNAddTwoStates(27, 33); |
| break; |
| case 29: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 26; |
| break; |
| case 31: |
| if (curChar == 40 && kind > 107) |
| kind = 107; |
| break; |
| case 32: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 28; |
| break; |
| case 33: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 32; |
| break; |
| case 35: |
| if ((0x3ff000000000000L & l) == 0L) |
| break; |
| if (kind > 1) |
| kind = 1; |
| jjCheckNAddStates(46, 51); |
| break; |
| case 36: |
| if ((0x3ff000000000000L & l) == 0L) |
| break; |
| if (kind > 1) |
| kind = 1; |
| jjCheckNAdd(36); |
| break; |
| case 37: |
| if ((0x3ff000000000000L & l) != 0L) |
| jjCheckNAddTwoStates(37, 38); |
| break; |
| case 38: |
| if (curChar != 46) |
| break; |
| if (kind > 2) |
| kind = 2; |
| jjCheckNAdd(39); |
| break; |
| case 39: |
| if ((0x3ff000000000000L & l) == 0L) |
| break; |
| if (kind > 2) |
| kind = 2; |
| jjCheckNAdd(39); |
| break; |
| case 40: |
| if ((0x3ff000000000000L & l) != 0L) |
| jjCheckNAddStates(61, 63); |
| break; |
| case 41: |
| if (curChar == 46) |
| jjCheckNAddTwoStates(42, 43); |
| break; |
| case 42: |
| if ((0x3ff000000000000L & l) != 0L) |
| jjCheckNAddTwoStates(42, 43); |
| break; |
| case 44: |
| if ((0x280000000000L & l) != 0L) |
| jjCheckNAdd(45); |
| break; |
| case 45: |
| if ((0x3ff000000000000L & l) == 0L) |
| break; |
| if (kind > 3) |
| kind = 3; |
| jjCheckNAdd(45); |
| break; |
| case 46: |
| if (curChar == 46) |
| jjCheckNAddTwoStates(47, 48); |
| break; |
| case 47: |
| if ((0x3ff000000000000L & l) == 0L) |
| break; |
| if (kind > 2) |
| kind = 2; |
| jjCheckNAdd(47); |
| break; |
| case 48: |
| if ((0x3ff000000000000L & l) != 0L) |
| jjCheckNAddTwoStates(48, 43); |
| break; |
| case 50: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(51, 54); |
| break; |
| case 51: |
| jjCheckNAddTwoStates(51, 54); |
| break; |
| case 53: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 52; |
| break; |
| case 54: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 53; |
| break; |
| case 56: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(57, 63); |
| break; |
| case 57: |
| jjCheckNAddTwoStates(57, 63); |
| break; |
| case 59: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddTwoStates(59, 61); |
| break; |
| case 60: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 56; |
| break; |
| case 62: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 58; |
| break; |
| case 63: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 62; |
| break; |
| case 64: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(52, 54); |
| break; |
| case 65: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 8) |
| kind = 8; |
| jjCheckNAdd(65); |
| break; |
| case 68: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(64, 66); |
| break; |
| case 69: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(70, 77); |
| break; |
| case 70: |
| jjCheckNAddTwoStates(70, 77); |
| break; |
| case 72: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 69; |
| break; |
| case 74: |
| if (curChar == 58 && kind > 9) |
| kind = 9; |
| break; |
| case 75: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 74; |
| break; |
| case 76: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 71; |
| break; |
| case 77: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 76; |
| break; |
| case 82: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(67, 69); |
| break; |
| case 83: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(84, 91); |
| break; |
| case 84: |
| jjCheckNAddTwoStates(84, 91); |
| break; |
| case 86: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 83; |
| break; |
| case 90: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 85; |
| break; |
| case 91: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 90; |
| break; |
| case 95: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(70, 72); |
| break; |
| case 96: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(97, 103); |
| break; |
| case 97: |
| jjCheckNAddTwoStates(97, 103); |
| break; |
| case 99: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 96; |
| break; |
| case 101: |
| if (curChar == 40 && kind > 104) |
| kind = 104; |
| break; |
| case 102: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 98; |
| break; |
| case 103: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 102; |
| break; |
| case 111: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(73, 75); |
| break; |
| case 112: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(113, 120); |
| break; |
| case 113: |
| jjCheckNAddTwoStates(113, 120); |
| break; |
| case 115: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 112; |
| break; |
| case 117: |
| if (curChar == 58 && kind > 10) |
| kind = 10; |
| break; |
| case 118: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 117; |
| break; |
| case 119: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 114; |
| break; |
| case 120: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 119; |
| break; |
| case 130: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(76, 78); |
| break; |
| case 131: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(132, 139); |
| break; |
| case 132: |
| jjCheckNAddTwoStates(132, 139); |
| break; |
| case 134: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 131; |
| break; |
| case 136: |
| if (curChar == 58 && kind > 14) |
| kind = 14; |
| break; |
| case 137: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 136; |
| break; |
| case 138: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 133; |
| break; |
| case 139: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 138; |
| break; |
| case 143: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 142; |
| break; |
| case 146: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 145; |
| break; |
| case 157: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(79, 81); |
| break; |
| case 158: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(159, 182); |
| break; |
| case 159: |
| jjCheckNAddTwoStates(159, 182); |
| break; |
| case 161: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 158; |
| break; |
| case 164: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(82, 84); |
| break; |
| case 165: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(166, 172); |
| break; |
| case 166: |
| jjCheckNAddTwoStates(166, 172); |
| break; |
| case 168: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 165; |
| break; |
| case 170: |
| if (curChar == 61 && kind > 47) |
| kind = 47; |
| break; |
| case 171: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 167; |
| break; |
| case 172: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 171; |
| break; |
| case 181: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 160; |
| break; |
| case 182: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 181; |
| break; |
| case 189: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(85, 87); |
| break; |
| case 190: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(191, 203); |
| break; |
| case 191: |
| jjCheckNAddTwoStates(191, 203); |
| break; |
| case 193: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 190; |
| break; |
| case 202: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 192; |
| break; |
| case 203: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 202; |
| break; |
| case 210: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(88, 90); |
| break; |
| case 211: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(212, 225); |
| break; |
| case 212: |
| jjCheckNAddTwoStates(212, 225); |
| break; |
| case 214: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 211; |
| break; |
| case 224: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 213; |
| break; |
| case 225: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 224; |
| break; |
| case 232: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(91, 93); |
| break; |
| case 233: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(234, 240); |
| break; |
| case 234: |
| jjCheckNAddTwoStates(234, 240); |
| break; |
| case 236: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 233; |
| break; |
| case 239: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 235; |
| break; |
| case 240: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 239; |
| break; |
| case 249: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(94, 96); |
| break; |
| case 250: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(251, 258); |
| break; |
| case 251: |
| jjCheckNAddTwoStates(251, 258); |
| break; |
| case 253: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 250; |
| break; |
| case 255: |
| if (curChar == 58 && kind > 11) |
| kind = 11; |
| break; |
| case 256: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 255; |
| break; |
| case 257: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 252; |
| break; |
| case 258: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 257; |
| break; |
| case 264: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(97, 99); |
| break; |
| case 265: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(266, 273); |
| break; |
| case 266: |
| jjCheckNAddTwoStates(266, 273); |
| break; |
| case 268: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 265; |
| break; |
| case 270: |
| if (curChar == 58 && kind > 17) |
| kind = 17; |
| break; |
| case 271: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 270; |
| break; |
| case 272: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 267; |
| break; |
| case 273: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 272; |
| break; |
| case 280: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 279; |
| break; |
| case 290: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(100, 102); |
| break; |
| case 291: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(292, 299); |
| break; |
| case 292: |
| jjCheckNAddTwoStates(292, 299); |
| break; |
| case 294: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 291; |
| break; |
| case 296: |
| if (curChar == 58 && kind > 19) |
| kind = 19; |
| break; |
| case 297: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 296; |
| break; |
| case 298: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 293; |
| break; |
| case 299: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 298; |
| break; |
| case 308: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(103, 105); |
| break; |
| case 309: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(310, 316); |
| break; |
| case 310: |
| jjCheckNAddTwoStates(310, 316); |
| break; |
| case 312: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 309; |
| break; |
| case 314: |
| if (curChar == 40 && kind > 106) |
| kind = 106; |
| break; |
| case 315: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 311; |
| break; |
| case 316: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 315; |
| break; |
| case 327: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 326; |
| break; |
| case 339: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(106, 108); |
| break; |
| case 340: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(341, 348); |
| break; |
| case 341: |
| jjCheckNAddTwoStates(341, 348); |
| break; |
| case 343: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 340; |
| break; |
| case 345: |
| if (curChar == 58 && kind > 12) |
| kind = 12; |
| break; |
| case 346: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 345; |
| break; |
| case 347: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 342; |
| break; |
| case 348: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 347; |
| break; |
| case 357: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(109, 111); |
| break; |
| case 358: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(359, 366); |
| break; |
| case 359: |
| jjCheckNAddTwoStates(359, 366); |
| break; |
| case 361: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 358; |
| break; |
| case 363: |
| if (curChar == 58 && kind > 15) |
| kind = 15; |
| break; |
| case 364: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 363; |
| break; |
| case 365: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 360; |
| break; |
| case 366: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 365; |
| break; |
| case 374: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(112, 114); |
| break; |
| case 375: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(376, 383); |
| break; |
| case 376: |
| jjCheckNAddTwoStates(376, 383); |
| break; |
| case 378: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 375; |
| break; |
| case 380: |
| if (curChar == 58 && kind > 21) |
| kind = 21; |
| break; |
| case 381: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 380; |
| break; |
| case 382: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 377; |
| break; |
| case 383: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 382; |
| break; |
| case 387: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 386; |
| break; |
| case 390: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 389; |
| break; |
| case 399: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(115, 117); |
| break; |
| case 400: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(401, 420); |
| break; |
| case 401: |
| jjCheckNAddTwoStates(401, 420); |
| break; |
| case 403: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 400; |
| break; |
| case 406: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjAddStates(118, 119); |
| break; |
| case 407: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 408; |
| break; |
| case 409: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddStates(120, 123); |
| break; |
| case 410: |
| if ((0x100002600L & l) != 0L) |
| jjCheckNAddStates(124, 126); |
| break; |
| case 411: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(412, 418); |
| break; |
| case 412: |
| jjCheckNAddTwoStates(412, 418); |
| break; |
| case 414: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 411; |
| break; |
| case 417: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 413; |
| break; |
| case 418: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 417; |
| break; |
| case 419: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 402; |
| break; |
| case 420: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 419; |
| break; |
| case 429: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(127, 129); |
| break; |
| case 430: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(431, 437); |
| break; |
| case 431: |
| jjCheckNAddTwoStates(431, 437); |
| break; |
| case 433: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 430; |
| break; |
| case 436: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 432; |
| break; |
| case 437: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 436; |
| break; |
| case 447: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(130, 132); |
| break; |
| case 448: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(449, 456); |
| break; |
| case 449: |
| jjCheckNAddTwoStates(449, 456); |
| break; |
| case 451: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 448; |
| break; |
| case 453: |
| if (curChar == 58 && kind > 13) |
| kind = 13; |
| break; |
| case 454: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 453; |
| break; |
| case 455: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 450; |
| break; |
| case 456: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 455; |
| break; |
| case 460: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(133, 135); |
| break; |
| case 461: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(462, 468); |
| break; |
| case 462: |
| jjCheckNAddTwoStates(462, 468); |
| break; |
| case 464: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 461; |
| break; |
| case 466: |
| if (curChar == 36 && kind > 89) |
| kind = 89; |
| break; |
| case 467: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 463; |
| break; |
| case 468: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 467; |
| break; |
| case 473: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(136, 138); |
| break; |
| case 474: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(475, 482); |
| break; |
| case 475: |
| jjCheckNAddTwoStates(475, 482); |
| break; |
| case 477: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 474; |
| break; |
| case 479: |
| if (curChar == 58 && kind > 16) |
| kind = 16; |
| break; |
| case 480: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 479; |
| break; |
| case 481: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 476; |
| break; |
| case 482: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 481; |
| break; |
| case 489: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 488; |
| break; |
| case 499: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(139, 141); |
| break; |
| case 500: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(501, 508); |
| break; |
| case 501: |
| jjCheckNAddTwoStates(501, 508); |
| break; |
| case 503: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 500; |
| break; |
| case 505: |
| if (curChar == 58 && kind > 18) |
| kind = 18; |
| break; |
| case 506: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 505; |
| break; |
| case 507: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 502; |
| break; |
| case 508: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 507; |
| break; |
| case 517: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(142, 144); |
| break; |
| case 518: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(519, 525); |
| break; |
| case 519: |
| jjCheckNAddTwoStates(519, 525); |
| break; |
| case 521: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 518; |
| break; |
| case 523: |
| if (curChar == 36 && kind > 91) |
| kind = 91; |
| break; |
| case 524: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 520; |
| break; |
| case 525: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 524; |
| break; |
| case 529: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(145, 147); |
| break; |
| case 530: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(531, 538); |
| break; |
| case 531: |
| jjCheckNAddTwoStates(531, 538); |
| break; |
| case 533: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 530; |
| break; |
| case 535: |
| if (curChar == 58 && kind > 20) |
| kind = 20; |
| break; |
| case 536: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 535; |
| break; |
| case 537: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 532; |
| break; |
| case 538: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 537; |
| break; |
| case 547: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(148, 150); |
| break; |
| case 548: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(549, 555); |
| break; |
| case 549: |
| jjCheckNAddTwoStates(549, 555); |
| break; |
| case 551: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 548; |
| break; |
| case 553: |
| if (curChar == 40 && kind > 103) |
| kind = 103; |
| break; |
| case 554: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 550; |
| break; |
| case 555: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 554; |
| break; |
| case 560: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(151, 153); |
| break; |
| case 561: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(562, 581); |
| break; |
| case 562: |
| jjCheckNAddTwoStates(562, 581); |
| break; |
| case 564: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 561; |
| break; |
| case 567: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjAddStates(154, 155); |
| break; |
| case 568: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 569; |
| break; |
| case 570: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddStates(156, 159); |
| break; |
| case 571: |
| if ((0x100002600L & l) != 0L) |
| jjCheckNAddStates(160, 162); |
| break; |
| case 572: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(573, 579); |
| break; |
| case 573: |
| jjCheckNAddTwoStates(573, 579); |
| break; |
| case 575: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 572; |
| break; |
| case 578: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 574; |
| break; |
| case 579: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 578; |
| break; |
| case 580: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 563; |
| break; |
| case 581: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 580; |
| break; |
| case 588: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(163, 165); |
| break; |
| case 589: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(590, 596); |
| break; |
| case 590: |
| jjCheckNAddTwoStates(590, 596); |
| break; |
| case 592: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 589; |
| break; |
| case 595: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 591; |
| break; |
| case 596: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 595; |
| break; |
| case 603: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(166, 168); |
| break; |
| case 604: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(605, 611); |
| break; |
| case 605: |
| jjCheckNAddTwoStates(605, 611); |
| break; |
| case 607: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 604; |
| break; |
| case 609: |
| if (curChar == 36 && kind > 90) |
| kind = 90; |
| break; |
| case 610: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 606; |
| break; |
| case 611: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 610; |
| break; |
| case 617: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(169, 171); |
| break; |
| case 618: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(619, 629); |
| break; |
| case 619: |
| jjCheckNAddTwoStates(619, 629); |
| break; |
| case 621: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 618; |
| break; |
| case 624: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjAddStates(172, 173); |
| break; |
| case 625: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 626; |
| break; |
| case 627: |
| if ((0x3ff600000000000L & l) == 0L) |
| break; |
| if (kind > 52) |
| kind = 52; |
| jjstateSet[jjnewStateCnt++] = 627; |
| break; |
| case 628: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 620; |
| break; |
| case 629: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 628; |
| break; |
| case 633: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(174, 176); |
| break; |
| case 634: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(635, 642); |
| break; |
| case 635: |
| jjCheckNAddTwoStates(635, 642); |
| break; |
| case 637: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 634; |
| break; |
| case 641: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 636; |
| break; |
| case 642: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 641; |
| break; |
| case 647: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(177, 179); |
| break; |
| case 648: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(649, 655); |
| break; |
| case 649: |
| jjCheckNAddTwoStates(649, 655); |
| break; |
| case 651: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 648; |
| break; |
| case 653: |
| if (curChar == 40 && kind > 105) |
| kind = 105; |
| break; |
| case 654: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 650; |
| break; |
| case 655: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 654; |
| break; |
| case 659: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjAddStates(180, 181); |
| break; |
| case 660: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 661; |
| break; |
| case 661: |
| if (curChar == 42 && kind > 58) |
| kind = 58; |
| break; |
| case 662: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjAddStates(182, 183); |
| break; |
| case 663: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 664; |
| break; |
| case 665: |
| if ((0x3ff600000000000L & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjstateSet[jjnewStateCnt++] = 665; |
| break; |
| case 666: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjAddStates(184, 185); |
| break; |
| case 667: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 668; |
| break; |
| case 669: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddStates(186, 189); |
| break; |
| case 670: |
| if ((0x100002600L & l) != 0L) |
| jjCheckNAddStates(190, 192); |
| break; |
| case 671: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(672, 678); |
| break; |
| case 672: |
| jjCheckNAddTwoStates(672, 678); |
| break; |
| case 674: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 671; |
| break; |
| case 676: |
| if (curChar == 40 && kind > 117) |
| kind = 117; |
| break; |
| case 677: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 673; |
| break; |
| case 678: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 677; |
| break; |
| case 681: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(193, 195); |
| break; |
| case 682: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(683, 689); |
| break; |
| case 683: |
| jjCheckNAddTwoStates(683, 689); |
| break; |
| case 685: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 682; |
| break; |
| case 688: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 684; |
| break; |
| case 689: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 688; |
| break; |
| case 697: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(196, 198); |
| break; |
| case 698: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(699, 711); |
| break; |
| case 699: |
| jjCheckNAddTwoStates(699, 711); |
| break; |
| case 701: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 698; |
| break; |
| case 710: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 700; |
| break; |
| case 711: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 710; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 19: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(199, 209); |
| } |
| else if (curChar == 123) |
| jjCheckNAddTwoStates(55, 60); |
| if (curChar == 118) |
| jjAddStates(210, 211); |
| else if (curChar == 116) |
| jjAddStates(212, 214); |
| else if (curChar == 101) |
| jjAddStates(215, 217); |
| else if (curChar == 110) |
| jjAddStates(218, 219); |
| else if (curChar == 102) |
| jjAddStates(220, 222); |
| else if (curChar == 115) |
| jjAddStates(223, 224); |
| else if (curChar == 97) |
| jjAddStates(225, 229); |
| else if (curChar == 112) |
| jjAddStates(230, 233); |
| else if (curChar == 100) |
| jjAddStates(234, 239); |
| else if (curChar == 99) |
| jjAddStates(240, 242); |
| else if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 24; |
| else if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 6; |
| break; |
| case 1: |
| jjAddStates(243, 244); |
| break; |
| case 4: |
| jjAddStates(245, 246); |
| break; |
| case 6: |
| if (curChar == 102) |
| jjCheckNAddTwoStates(7, 12); |
| break; |
| case 9: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(247, 248); |
| break; |
| case 10: |
| if (curChar == 125) |
| jjCheckNAddStates(55, 57); |
| break; |
| case 12: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 11; |
| break; |
| case 13: |
| if (curChar == 101 && kind > 50) |
| kind = 50; |
| break; |
| case 14: |
| if (curChar == 112) |
| jjstateSet[jjnewStateCnt++] = 13; |
| break; |
| case 15: |
| if (curChar == 121) |
| jjstateSet[jjnewStateCnt++] = 14; |
| break; |
| case 16: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 15; |
| break; |
| case 22: |
| case 23: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(23); |
| break; |
| case 24: |
| if (curChar == 102) |
| jjCheckNAddStates(58, 60); |
| break; |
| case 27: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(249, 250); |
| break; |
| case 28: |
| if (curChar == 125) |
| jjCheckNAddStates(58, 60); |
| break; |
| case 30: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 29; |
| break; |
| case 34: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 24; |
| break; |
| case 43: |
| if ((0x2000000020L & l) != 0L) |
| jjAddStates(251, 252); |
| break; |
| case 49: |
| if (curChar == 123) |
| jjCheckNAddTwoStates(55, 60); |
| break; |
| case 51: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(253, 254); |
| break; |
| case 52: |
| if (curChar == 125 && kind > 5) |
| kind = 5; |
| break; |
| case 57: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(255, 256); |
| break; |
| case 58: |
| if (curChar != 125) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjAddStates(257, 258); |
| break; |
| case 61: |
| if (curChar == 123) |
| jjCheckNAdd(60); |
| break; |
| case 66: |
| if (curChar == 99) |
| jjAddStates(240, 242); |
| break; |
| case 67: |
| if (curChar == 100) |
| jjCheckNAddStates(64, 66); |
| break; |
| case 70: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(259, 260); |
| break; |
| case 71: |
| if (curChar == 125) |
| jjCheckNAddStates(64, 66); |
| break; |
| case 73: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 72; |
| break; |
| case 78: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 67; |
| break; |
| case 79: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 78; |
| break; |
| case 80: |
| if (curChar == 104) |
| jjstateSet[jjnewStateCnt++] = 79; |
| break; |
| case 81: |
| if (curChar == 116) |
| jjCheckNAddTwoStates(82, 87); |
| break; |
| case 84: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(261, 262); |
| break; |
| case 85: |
| if (curChar == 125) |
| jjCheckNAddStates(67, 69); |
| break; |
| case 87: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 86; |
| break; |
| case 88: |
| if (curChar == 115 && kind > 92) |
| kind = 92; |
| break; |
| case 89: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 88; |
| break; |
| case 92: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 81; |
| break; |
| case 93: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 92; |
| break; |
| case 94: |
| if (curChar == 116) |
| jjCheckNAddStates(70, 72); |
| break; |
| case 97: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(263, 264); |
| break; |
| case 98: |
| if (curChar == 125) |
| jjCheckNAddStates(70, 72); |
| break; |
| case 100: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 99; |
| break; |
| case 104: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 94; |
| break; |
| case 105: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 104; |
| break; |
| case 106: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 105; |
| break; |
| case 107: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 106; |
| break; |
| case 108: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 107; |
| break; |
| case 109: |
| if (curChar == 100) |
| jjAddStates(234, 239); |
| break; |
| case 110: |
| if (curChar == 116) |
| jjCheckNAddStates(73, 75); |
| break; |
| case 113: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(265, 266); |
| break; |
| case 114: |
| if (curChar == 125) |
| jjCheckNAddStates(73, 75); |
| break; |
| case 116: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 115; |
| break; |
| case 121: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 110; |
| break; |
| case 122: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 121; |
| break; |
| case 123: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 122; |
| break; |
| case 124: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 123; |
| break; |
| case 125: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 124; |
| break; |
| case 126: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 125; |
| break; |
| case 127: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 126; |
| break; |
| case 128: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 127; |
| break; |
| case 129: |
| if (curChar == 102) |
| jjCheckNAddStates(76, 78); |
| break; |
| case 132: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(267, 268); |
| break; |
| case 133: |
| if (curChar == 125) |
| jjCheckNAddStates(76, 78); |
| break; |
| case 135: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 134; |
| break; |
| case 140: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 129; |
| break; |
| case 141: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 140; |
| break; |
| case 142: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 141; |
| break; |
| case 144: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 143; |
| break; |
| case 145: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 144; |
| break; |
| case 147: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 146; |
| break; |
| case 148: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 147; |
| break; |
| case 149: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 148; |
| break; |
| case 150: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 149; |
| break; |
| case 151: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 150; |
| break; |
| case 152: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 151; |
| break; |
| case 153: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 152; |
| break; |
| case 154: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 153; |
| break; |
| case 155: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 154; |
| break; |
| case 156: |
| if (curChar == 116) |
| jjCheckNAddTwoStates(157, 162); |
| break; |
| case 159: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(269, 270); |
| break; |
| case 160: |
| if (curChar == 125) |
| jjCheckNAddStates(79, 81); |
| break; |
| case 162: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 161; |
| break; |
| case 163: |
| if (curChar == 110) |
| jjCheckNAddTwoStates(164, 169); |
| break; |
| case 166: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(271, 272); |
| break; |
| case 167: |
| if (curChar == 125) |
| jjCheckNAddStates(82, 84); |
| break; |
| case 169: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 168; |
| break; |
| case 173: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 163; |
| break; |
| case 174: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 173; |
| break; |
| case 175: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 174; |
| break; |
| case 176: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 175; |
| break; |
| case 177: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 176; |
| break; |
| case 178: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 177; |
| break; |
| case 179: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 178; |
| break; |
| case 180: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 179; |
| break; |
| case 183: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 156; |
| break; |
| case 184: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 183; |
| break; |
| case 185: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 184; |
| break; |
| case 186: |
| if (curChar == 102) |
| jjstateSet[jjnewStateCnt++] = 185; |
| break; |
| case 187: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 186; |
| break; |
| case 188: |
| if (curChar == 116) |
| jjCheckNAddTwoStates(189, 194); |
| break; |
| case 191: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(273, 274); |
| break; |
| case 192: |
| if (curChar == 125) |
| jjCheckNAddStates(85, 87); |
| break; |
| case 194: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 193; |
| break; |
| case 195: |
| if (curChar == 116 && kind > 48) |
| kind = 48; |
| break; |
| case 196: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 195; |
| break; |
| case 197: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 196; |
| break; |
| case 198: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 197; |
| break; |
| case 199: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 198; |
| break; |
| case 200: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 199; |
| break; |
| case 201: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 200; |
| break; |
| case 204: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 188; |
| break; |
| case 205: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 204; |
| break; |
| case 206: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 205; |
| break; |
| case 207: |
| if (curChar == 102) |
| jjstateSet[jjnewStateCnt++] = 206; |
| break; |
| case 208: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 207; |
| break; |
| case 209: |
| if (curChar == 116) |
| jjCheckNAddTwoStates(210, 215); |
| break; |
| case 212: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(275, 276); |
| break; |
| case 213: |
| if (curChar == 125) |
| jjCheckNAddStates(88, 90); |
| break; |
| case 215: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 214; |
| break; |
| case 216: |
| if (curChar == 110 && kind > 49) |
| kind = 49; |
| break; |
| case 217: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 216; |
| break; |
| case 218: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 217; |
| break; |
| case 219: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 218; |
| break; |
| case 220: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 219; |
| break; |
| case 221: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 220; |
| break; |
| case 222: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 221; |
| break; |
| case 223: |
| if (curChar == 102) |
| jjstateSet[jjnewStateCnt++] = 222; |
| break; |
| case 226: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 209; |
| break; |
| case 227: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 226; |
| break; |
| case 228: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 227; |
| break; |
| case 229: |
| if (curChar == 102) |
| jjstateSet[jjnewStateCnt++] = 228; |
| break; |
| case 230: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 229; |
| break; |
| case 231: |
| if (curChar == 116) |
| jjCheckNAddStates(91, 93); |
| break; |
| case 234: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(277, 278); |
| break; |
| case 235: |
| if (curChar == 125) |
| jjCheckNAddStates(91, 93); |
| break; |
| case 237: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 236; |
| break; |
| case 238: |
| if (curChar == 123 && kind > 99) |
| kind = 99; |
| break; |
| case 241: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 231; |
| break; |
| case 242: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 241; |
| break; |
| case 243: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 242; |
| break; |
| case 244: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 243; |
| break; |
| case 245: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 244; |
| break; |
| case 246: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 245; |
| break; |
| case 247: |
| if (curChar == 112) |
| jjAddStates(230, 233); |
| break; |
| case 248: |
| if (curChar == 116) |
| jjCheckNAddStates(94, 96); |
| break; |
| case 251: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(279, 280); |
| break; |
| case 252: |
| if (curChar == 125) |
| jjCheckNAddStates(94, 96); |
| break; |
| case 254: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 253; |
| break; |
| case 259: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 248; |
| break; |
| case 260: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 259; |
| break; |
| case 261: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 260; |
| break; |
| case 262: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 261; |
| break; |
| case 263: |
| if (curChar == 103) |
| jjCheckNAddStates(97, 99); |
| break; |
| case 266: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(281, 282); |
| break; |
| case 267: |
| if (curChar == 125) |
| jjCheckNAddStates(97, 99); |
| break; |
| case 269: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 268; |
| break; |
| case 274: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 263; |
| break; |
| case 275: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 274; |
| break; |
| case 276: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 275; |
| break; |
| case 277: |
| if (curChar == 98) |
| jjstateSet[jjnewStateCnt++] = 276; |
| break; |
| case 278: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 277; |
| break; |
| case 279: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 278; |
| break; |
| case 281: |
| if (curChar == 103) |
| jjstateSet[jjnewStateCnt++] = 280; |
| break; |
| case 282: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 281; |
| break; |
| case 283: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 282; |
| break; |
| case 284: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 283; |
| break; |
| case 285: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 284; |
| break; |
| case 286: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 285; |
| break; |
| case 287: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 286; |
| break; |
| case 288: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 287; |
| break; |
| case 289: |
| if (curChar == 103) |
| jjCheckNAddStates(100, 102); |
| break; |
| case 292: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(283, 284); |
| break; |
| case 293: |
| if (curChar == 125) |
| jjCheckNAddStates(100, 102); |
| break; |
| case 295: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 294; |
| break; |
| case 300: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 289; |
| break; |
| case 301: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 300; |
| break; |
| case 302: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 301; |
| break; |
| case 303: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 302; |
| break; |
| case 304: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 303; |
| break; |
| case 305: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 304; |
| break; |
| case 306: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 305; |
| break; |
| case 307: |
| if (curChar == 110) |
| jjCheckNAddStates(103, 105); |
| break; |
| case 310: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(285, 286); |
| break; |
| case 311: |
| if (curChar == 125) |
| jjCheckNAddStates(103, 105); |
| break; |
| case 313: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 312; |
| break; |
| case 317: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 307; |
| break; |
| case 318: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 317; |
| break; |
| case 319: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 318; |
| break; |
| case 320: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 319; |
| break; |
| case 321: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 320; |
| break; |
| case 322: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 321; |
| break; |
| case 323: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 322; |
| break; |
| case 324: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 323; |
| break; |
| case 325: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 324; |
| break; |
| case 326: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 325; |
| break; |
| case 328: |
| if (curChar == 103) |
| jjstateSet[jjnewStateCnt++] = 327; |
| break; |
| case 329: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 328; |
| break; |
| case 330: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 329; |
| break; |
| case 331: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 330; |
| break; |
| case 332: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 331; |
| break; |
| case 333: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 332; |
| break; |
| case 334: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 333; |
| break; |
| case 335: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 334; |
| break; |
| case 336: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 335; |
| break; |
| case 337: |
| if (curChar == 97) |
| jjAddStates(225, 229); |
| break; |
| case 338: |
| if (curChar == 101) |
| jjCheckNAddStates(106, 108); |
| break; |
| case 341: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(287, 288); |
| break; |
| case 342: |
| if (curChar == 125) |
| jjCheckNAddStates(106, 108); |
| break; |
| case 344: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 343; |
| break; |
| case 349: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 338; |
| break; |
| case 350: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 349; |
| break; |
| case 351: |
| if (curChar == 98) |
| jjstateSet[jjnewStateCnt++] = 350; |
| break; |
| case 352: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 351; |
| break; |
| case 353: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 352; |
| break; |
| case 354: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 353; |
| break; |
| case 355: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 354; |
| break; |
| case 356: |
| if (curChar == 114) |
| jjCheckNAddStates(109, 111); |
| break; |
| case 359: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(289, 290); |
| break; |
| case 360: |
| if (curChar == 125) |
| jjCheckNAddStates(109, 111); |
| break; |
| case 362: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 361; |
| break; |
| case 367: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 356; |
| break; |
| case 368: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 367; |
| break; |
| case 369: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 368; |
| break; |
| case 370: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 369; |
| break; |
| case 371: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 370; |
| break; |
| case 372: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 371; |
| break; |
| case 373: |
| if (curChar == 102) |
| jjCheckNAddStates(112, 114); |
| break; |
| case 376: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(291, 292); |
| break; |
| case 377: |
| if (curChar == 125) |
| jjCheckNAddStates(112, 114); |
| break; |
| case 379: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 378; |
| break; |
| case 384: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 373; |
| break; |
| case 385: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 384; |
| break; |
| case 386: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 385; |
| break; |
| case 388: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 387; |
| break; |
| case 389: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 388; |
| break; |
| case 391: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 390; |
| break; |
| case 392: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 391; |
| break; |
| case 393: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 392; |
| break; |
| case 394: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 393; |
| break; |
| case 395: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 394; |
| break; |
| case 396: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 395; |
| break; |
| case 397: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 396; |
| break; |
| case 398: |
| if (curChar == 101) |
| jjCheckNAddTwoStates(399, 404); |
| break; |
| case 401: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(293, 294); |
| break; |
| case 402: |
| if (curChar == 125) |
| jjCheckNAddStates(115, 117); |
| break; |
| case 404: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 403; |
| break; |
| case 405: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddStates(295, 300); |
| break; |
| case 406: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(406, 407); |
| break; |
| case 408: |
| case 409: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddStates(120, 123); |
| break; |
| case 412: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(301, 302); |
| break; |
| case 413: |
| if (curChar == 125) |
| jjCheckNAddStates(124, 126); |
| break; |
| case 415: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 414; |
| break; |
| case 416: |
| if (curChar == 123 && kind > 44) |
| kind = 44; |
| break; |
| case 421: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 398; |
| break; |
| case 422: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 421; |
| break; |
| case 423: |
| if (curChar == 98) |
| jjstateSet[jjnewStateCnt++] = 422; |
| break; |
| case 424: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 423; |
| break; |
| case 425: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 424; |
| break; |
| case 426: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 425; |
| break; |
| case 427: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 426; |
| break; |
| case 428: |
| if (curChar == 101) |
| jjCheckNAddStates(127, 129); |
| break; |
| case 431: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(303, 304); |
| break; |
| case 432: |
| if (curChar == 125) |
| jjCheckNAddStates(127, 129); |
| break; |
| case 434: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 433; |
| break; |
| case 435: |
| if (curChar == 123 && kind > 46) |
| kind = 46; |
| break; |
| case 438: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 428; |
| break; |
| case 439: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 438; |
| break; |
| case 440: |
| if (curChar == 98) |
| jjstateSet[jjnewStateCnt++] = 439; |
| break; |
| case 441: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 440; |
| break; |
| case 442: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 441; |
| break; |
| case 443: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 442; |
| break; |
| case 444: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 443; |
| break; |
| case 445: |
| if (curChar == 115) |
| jjAddStates(223, 224); |
| break; |
| case 446: |
| if (curChar == 102) |
| jjCheckNAddStates(130, 132); |
| break; |
| case 449: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(305, 306); |
| break; |
| case 450: |
| if (curChar == 125) |
| jjCheckNAddStates(130, 132); |
| break; |
| case 452: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 451; |
| break; |
| case 457: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 446; |
| break; |
| case 458: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 457; |
| break; |
| case 459: |
| if (curChar == 101) |
| jjCheckNAddStates(133, 135); |
| break; |
| case 462: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(307, 308); |
| break; |
| case 463: |
| if (curChar == 125) |
| jjCheckNAddStates(133, 135); |
| break; |
| case 465: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 464; |
| break; |
| case 469: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 459; |
| break; |
| case 470: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 469; |
| break; |
| case 471: |
| if (curChar == 102) |
| jjAddStates(220, 222); |
| break; |
| case 472: |
| if (curChar == 103) |
| jjCheckNAddStates(136, 138); |
| break; |
| case 475: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(309, 310); |
| break; |
| case 476: |
| if (curChar == 125) |
| jjCheckNAddStates(136, 138); |
| break; |
| case 478: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 477; |
| break; |
| case 483: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 472; |
| break; |
| case 484: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 483; |
| break; |
| case 485: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 484; |
| break; |
| case 486: |
| if (curChar == 98) |
| jjstateSet[jjnewStateCnt++] = 485; |
| break; |
| case 487: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 486; |
| break; |
| case 488: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 487; |
| break; |
| case 490: |
| if (curChar == 103) |
| jjstateSet[jjnewStateCnt++] = 489; |
| break; |
| case 491: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 490; |
| break; |
| case 492: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 491; |
| break; |
| case 493: |
| if (curChar == 119) |
| jjstateSet[jjnewStateCnt++] = 492; |
| break; |
| case 494: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 493; |
| break; |
| case 495: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 494; |
| break; |
| case 496: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 495; |
| break; |
| case 497: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 496; |
| break; |
| case 498: |
| if (curChar == 103) |
| jjCheckNAddStates(139, 141); |
| break; |
| case 501: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(311, 312); |
| break; |
| case 502: |
| if (curChar == 125) |
| jjCheckNAddStates(139, 141); |
| break; |
| case 504: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 503; |
| break; |
| case 509: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 498; |
| break; |
| case 510: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 509; |
| break; |
| case 511: |
| if (curChar == 119) |
| jjstateSet[jjnewStateCnt++] = 510; |
| break; |
| case 512: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 511; |
| break; |
| case 513: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 512; |
| break; |
| case 514: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 513; |
| break; |
| case 515: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 514; |
| break; |
| case 516: |
| if (curChar == 114) |
| jjCheckNAddStates(142, 144); |
| break; |
| case 519: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(313, 314); |
| break; |
| case 520: |
| if (curChar == 125) |
| jjCheckNAddStates(142, 144); |
| break; |
| case 522: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 521; |
| break; |
| case 526: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 516; |
| break; |
| case 527: |
| if (curChar == 110) |
| jjAddStates(218, 219); |
| break; |
| case 528: |
| if (curChar == 101) |
| jjCheckNAddStates(145, 147); |
| break; |
| case 531: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(315, 316); |
| break; |
| case 532: |
| if (curChar == 125) |
| jjCheckNAddStates(145, 147); |
| break; |
| case 534: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 533; |
| break; |
| case 539: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 528; |
| break; |
| case 540: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 539; |
| break; |
| case 541: |
| if (curChar == 112) |
| jjstateSet[jjnewStateCnt++] = 540; |
| break; |
| case 542: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 541; |
| break; |
| case 543: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 542; |
| break; |
| case 544: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 543; |
| break; |
| case 545: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 544; |
| break; |
| case 546: |
| if (curChar == 101) |
| jjCheckNAddStates(148, 150); |
| break; |
| case 549: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(317, 318); |
| break; |
| case 550: |
| if (curChar == 125) |
| jjCheckNAddStates(148, 150); |
| break; |
| case 552: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 551; |
| break; |
| case 556: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 546; |
| break; |
| case 557: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 556; |
| break; |
| case 558: |
| if (curChar == 101) |
| jjAddStates(215, 217); |
| break; |
| case 559: |
| if (curChar == 116) |
| jjCheckNAddTwoStates(560, 565); |
| break; |
| case 562: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(319, 320); |
| break; |
| case 563: |
| if (curChar == 125) |
| jjCheckNAddStates(151, 153); |
| break; |
| case 565: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 564; |
| break; |
| case 566: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddStates(321, 326); |
| break; |
| case 567: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(567, 568); |
| break; |
| case 569: |
| case 570: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddStates(156, 159); |
| break; |
| case 573: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(327, 328); |
| break; |
| case 574: |
| if (curChar == 125) |
| jjCheckNAddStates(160, 162); |
| break; |
| case 576: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 575; |
| break; |
| case 577: |
| if (curChar == 123 && kind > 43) |
| kind = 43; |
| break; |
| case 582: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 559; |
| break; |
| case 583: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 582; |
| break; |
| case 584: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 583; |
| break; |
| case 585: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 584; |
| break; |
| case 586: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 585; |
| break; |
| case 587: |
| if (curChar == 116) |
| jjCheckNAddStates(163, 165); |
| break; |
| case 590: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(329, 330); |
| break; |
| case 591: |
| if (curChar == 125) |
| jjCheckNAddStates(163, 165); |
| break; |
| case 593: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 592; |
| break; |
| case 594: |
| if (curChar == 123 && kind > 45) |
| kind = 45; |
| break; |
| case 597: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 587; |
| break; |
| case 598: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 597; |
| break; |
| case 599: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 598; |
| break; |
| case 600: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 599; |
| break; |
| case 601: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 600; |
| break; |
| case 602: |
| if (curChar == 121) |
| jjCheckNAddStates(166, 168); |
| break; |
| case 605: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(331, 332); |
| break; |
| case 606: |
| if (curChar == 125) |
| jjCheckNAddStates(166, 168); |
| break; |
| case 608: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 607; |
| break; |
| case 612: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 602; |
| break; |
| case 613: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 612; |
| break; |
| case 614: |
| if (curChar == 118) |
| jjstateSet[jjnewStateCnt++] = 613; |
| break; |
| case 615: |
| if (curChar == 116) |
| jjAddStates(212, 214); |
| break; |
| case 616: |
| if (curChar == 101) |
| jjCheckNAddTwoStates(617, 622); |
| break; |
| case 619: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(333, 334); |
| break; |
| case 620: |
| if (curChar == 125) |
| jjCheckNAddStates(169, 171); |
| break; |
| case 622: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 621; |
| break; |
| case 623: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 52) |
| kind = 52; |
| jjCheckNAddStates(335, 337); |
| break; |
| case 624: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(624, 625); |
| break; |
| case 626: |
| case 627: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 52) |
| kind = 52; |
| jjCheckNAdd(627); |
| break; |
| case 630: |
| if (curChar == 112) |
| jjstateSet[jjnewStateCnt++] = 616; |
| break; |
| case 631: |
| if (curChar == 121) |
| jjstateSet[jjnewStateCnt++] = 630; |
| break; |
| case 632: |
| if (curChar == 116) |
| jjCheckNAddTwoStates(633, 638); |
| break; |
| case 635: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(338, 339); |
| break; |
| case 636: |
| if (curChar == 125) |
| jjCheckNAddStates(174, 176); |
| break; |
| case 638: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 637; |
| break; |
| case 639: |
| if (curChar == 115 && kind > 93) |
| kind = 93; |
| break; |
| case 640: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 639; |
| break; |
| case 643: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 632; |
| break; |
| case 644: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 643; |
| break; |
| case 645: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 644; |
| break; |
| case 646: |
| if (curChar == 116) |
| jjCheckNAddStates(177, 179); |
| break; |
| case 649: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(340, 341); |
| break; |
| case 650: |
| if (curChar == 125) |
| jjCheckNAddStates(177, 179); |
| break; |
| case 652: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 651; |
| break; |
| case 656: |
| if (curChar == 120) |
| jjstateSet[jjnewStateCnt++] = 646; |
| break; |
| case 657: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 656; |
| break; |
| case 658: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(199, 209); |
| break; |
| case 659: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(659, 660); |
| break; |
| case 662: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(662, 663); |
| break; |
| case 664: |
| case 665: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(665); |
| break; |
| case 666: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(666, 667); |
| break; |
| case 668: |
| case 669: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddStates(186, 189); |
| break; |
| case 672: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(342, 343); |
| break; |
| case 673: |
| if (curChar == 125) |
| jjCheckNAddStates(190, 192); |
| break; |
| case 675: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 674; |
| break; |
| case 679: |
| if (curChar == 118) |
| jjAddStates(210, 211); |
| break; |
| case 680: |
| if (curChar == 101) |
| jjCheckNAddStates(193, 195); |
| break; |
| case 683: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(344, 345); |
| break; |
| case 684: |
| if (curChar == 125) |
| jjCheckNAddStates(193, 195); |
| break; |
| case 686: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 685; |
| break; |
| case 687: |
| if (curChar == 123 && kind > 94) |
| kind = 94; |
| break; |
| case 690: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 680; |
| break; |
| case 691: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 690; |
| break; |
| case 692: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 691; |
| break; |
| case 693: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 692; |
| break; |
| case 694: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 693; |
| break; |
| case 695: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 694; |
| break; |
| case 696: |
| if (curChar == 101) |
| jjCheckNAddTwoStates(697, 702); |
| break; |
| case 699: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(346, 347); |
| break; |
| case 700: |
| if (curChar == 125) |
| jjCheckNAddStates(196, 198); |
| break; |
| case 702: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 701; |
| break; |
| case 703: |
| if (curChar == 116 && kind > 95) |
| kind = 95; |
| break; |
| case 704: |
| if (curChar == 120) |
| jjstateSet[jjnewStateCnt++] = 703; |
| break; |
| case 705: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 704; |
| break; |
| case 706: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 705; |
| break; |
| case 707: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 706; |
| break; |
| case 708: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 707; |
| break; |
| case 709: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 708; |
| break; |
| case 712: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 696; |
| break; |
| case 713: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 712; |
| break; |
| case 714: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 713; |
| break; |
| case 715: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 714; |
| break; |
| case 716: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 715; |
| break; |
| case 717: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 716; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 19: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(199, 209); |
| break; |
| case 1: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(243, 244); |
| break; |
| case 4: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(245, 246); |
| break; |
| case 9: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(247, 248); |
| break; |
| case 22: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(23); |
| break; |
| case 23: |
| if ((jjbitVec28[i2] & l2) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(23); |
| break; |
| case 27: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(249, 250); |
| break; |
| case 51: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(253, 254); |
| break; |
| case 57: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(255, 256); |
| break; |
| case 70: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(259, 260); |
| break; |
| case 84: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(261, 262); |
| break; |
| case 97: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(263, 264); |
| break; |
| case 113: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(265, 266); |
| break; |
| case 132: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(267, 268); |
| break; |
| case 159: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(269, 270); |
| break; |
| case 166: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(271, 272); |
| break; |
| case 191: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(273, 274); |
| break; |
| case 212: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(275, 276); |
| break; |
| case 234: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(277, 278); |
| break; |
| case 251: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(279, 280); |
| break; |
| case 266: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(281, 282); |
| break; |
| case 292: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(283, 284); |
| break; |
| case 310: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(285, 286); |
| break; |
| case 341: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(287, 288); |
| break; |
| case 359: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(289, 290); |
| break; |
| case 376: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(291, 292); |
| break; |
| case 401: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(293, 294); |
| break; |
| case 405: |
| if ((jjbitVec5[i2] & l2) != 0L) |
| jjCheckNAddStates(295, 300); |
| break; |
| case 406: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(406, 407); |
| break; |
| case 408: |
| if ((jjbitVec5[i2] & l2) != 0L) |
| jjCheckNAddStates(120, 123); |
| break; |
| case 409: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddStates(120, 123); |
| break; |
| case 412: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(301, 302); |
| break; |
| case 431: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(303, 304); |
| break; |
| case 449: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(305, 306); |
| break; |
| case 462: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(307, 308); |
| break; |
| case 475: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(309, 310); |
| break; |
| case 501: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(311, 312); |
| break; |
| case 519: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(313, 314); |
| break; |
| case 531: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(315, 316); |
| break; |
| case 549: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(317, 318); |
| break; |
| case 562: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(319, 320); |
| break; |
| case 566: |
| if ((jjbitVec5[i2] & l2) != 0L) |
| jjCheckNAddStates(321, 326); |
| break; |
| case 567: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(567, 568); |
| break; |
| case 569: |
| if ((jjbitVec5[i2] & l2) != 0L) |
| jjCheckNAddStates(156, 159); |
| break; |
| case 570: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddStates(156, 159); |
| break; |
| case 573: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(327, 328); |
| break; |
| case 590: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(329, 330); |
| break; |
| case 605: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(331, 332); |
| break; |
| case 619: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(333, 334); |
| break; |
| case 623: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 52) |
| kind = 52; |
| jjCheckNAddStates(335, 337); |
| break; |
| case 624: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(624, 625); |
| break; |
| case 626: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 52) |
| kind = 52; |
| jjCheckNAdd(627); |
| break; |
| case 627: |
| if ((jjbitVec28[i2] & l2) == 0L) |
| break; |
| if (kind > 52) |
| kind = 52; |
| jjCheckNAdd(627); |
| break; |
| case 635: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(338, 339); |
| break; |
| case 649: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(340, 341); |
| break; |
| case 659: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(659, 660); |
| break; |
| case 662: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(662, 663); |
| break; |
| case 664: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(665); |
| break; |
| case 665: |
| if ((jjbitVec28[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(665); |
| break; |
| case 666: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(666, 667); |
| break; |
| case 668: |
| if ((jjbitVec5[i2] & l2) != 0L) |
| jjCheckNAddStates(186, 189); |
| break; |
| case 669: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddStates(186, 189); |
| break; |
| case 672: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(342, 343); |
| break; |
| case 683: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(344, 345); |
| break; |
| case 699: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(346, 347); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 718 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1) |
| { |
| switch (pos) |
| { |
| case 0: |
| if ((active0 & 0x400000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| return 42; |
| } |
| if ((active0 & 0x20000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| return 40; |
| } |
| if ((active0 & 0x40000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| return 71; |
| } |
| if ((active0 & 0x1584800000L) != 0L || (active1 & 0x3e00L) != 0L) |
| { |
| jjmatchedKind = 116; |
| return 231; |
| } |
| if ((active0 & 0x1000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| return 179; |
| } |
| if ((active1 & 0x600000000000L) != 0L) |
| return 232; |
| if ((active0 & 0x812000000L) != 0L || (active1 & 0xaL) != 0L) |
| { |
| jjmatchedKind = 116; |
| return 22; |
| } |
| if ((active0 & 0x8000000L) != 0L) |
| return 57; |
| if ((active1 & 0x80000000000000L) != 0L) |
| return 136; |
| if ((active0 & 0x2200000000L) != 0L || (active1 & 0x100L) != 0L) |
| { |
| jjmatchedKind = 116; |
| return 85; |
| } |
| return -1; |
| case 1: |
| if ((active0 & 0x33e7800000L) != 0L) |
| { |
| if (jjmatchedPos != 1) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 1; |
| } |
| return 231; |
| } |
| if ((active0 & 0x400400000L) != 0L || (active1 & 0x3f0aL) != 0L) |
| return 231; |
| if ((active0 & 0x810000000L) != 0L) |
| return 21; |
| return -1; |
| case 2: |
| if ((active0 & 0x3be2000000L) != 0L || (active1 & 0x8L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 2; |
| return 231; |
| } |
| if ((active0 & 0x5800000L) != 0L) |
| return 231; |
| return -1; |
| case 3: |
| if ((active0 & 0x38e0000000L) != 0L || (active1 & 0x8L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 3; |
| return 231; |
| } |
| if ((active0 & 0x302000000L) != 0L) |
| return 231; |
| return -1; |
| case 4: |
| if ((active0 & 0x28e0000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 4; |
| return 231; |
| } |
| if ((active0 & 0x1000000000L) != 0L || (active1 & 0x8L) != 0L) |
| return 231; |
| return -1; |
| case 5: |
| if ((active0 & 0x860000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 5; |
| return 231; |
| } |
| if ((active0 & 0x2080000000L) != 0L) |
| return 231; |
| return -1; |
| case 6: |
| if ((active0 & 0x20000000L) != 0L) |
| return 231; |
| if ((active0 & 0x840000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 6; |
| return 231; |
| } |
| return -1; |
| case 7: |
| if ((active0 & 0x840000000L) != 0L) |
| { |
| jjmatchedKind = 116; |
| jjmatchedPos = 7; |
| return 231; |
| } |
| return -1; |
| default : |
| return -1; |
| } |
| } |
| private final int jjStartNfa_1(int pos, long active0, long active1) |
| { |
| return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1); |
| } |
| private final int jjStartNfaWithStates_1(int pos, int kind, int state) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = pos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return pos + 1; } |
| return jjMoveNfa_1(state, pos + 1); |
| } |
| private final int jjMoveStringLiteralDfa0_1() |
| { |
| switch(curChar) |
| { |
| case 33: |
| return jjMoveStringLiteralDfa1_1(0x0L, 0x4L); |
| case 36: |
| return jjStopAtPos(0, 114); |
| case 40: |
| return jjStopAtPos(0, 84); |
| case 41: |
| return jjStopAtPos(0, 88); |
| case 42: |
| return jjStartNfaWithStates_1(0, 27, 57); |
| case 43: |
| return jjStopAtPos(0, 81); |
| case 44: |
| return jjStopAtPos(0, 108); |
| case 45: |
| return jjStopAtPos(0, 80); |
| case 46: |
| jjmatchedKind = 109; |
| return jjMoveStringLiteralDfa1_1(0x0L, 0x400000000000L); |
| case 47: |
| jjmatchedKind = 62; |
| return jjMoveStringLiteralDfa1_1(0x8000000000000000L, 0x0L); |
| case 60: |
| jjmatchedKind = 78; |
| return jjMoveStringLiteralDfa1_1(0x0L, 0x30L); |
| case 61: |
| return jjStopAtPos(0, 64); |
| case 62: |
| jjmatchedKind = 79; |
| return jjMoveStringLiteralDfa1_1(0x0L, 0xc0L); |
| case 63: |
| return jjStopAtPos(0, 82); |
| case 91: |
| return jjStopAtPos(0, 86); |
| case 93: |
| return jjStopAtPos(0, 87); |
| case 97: |
| return jjMoveStringLiteralDfa1_1(0x800000L, 0x0L); |
| case 99: |
| return jjMoveStringLiteralDfa1_1(0x20000000L, 0x0L); |
| case 100: |
| return jjMoveStringLiteralDfa1_1(0x1000000L, 0x0L); |
| case 101: |
| return jjMoveStringLiteralDfa1_1(0x2200000000L, 0x100L); |
| case 103: |
| return jjMoveStringLiteralDfa1_1(0x0L, 0xc00L); |
| case 105: |
| return jjMoveStringLiteralDfa1_1(0x812000000L, 0xaL); |
| case 108: |
| return jjMoveStringLiteralDfa1_1(0x0L, 0x3000L); |
| case 109: |
| return jjMoveStringLiteralDfa1_1(0x4000000L, 0x0L); |
| case 110: |
| return jjMoveStringLiteralDfa1_1(0x0L, 0x200L); |
| case 111: |
| return jjMoveStringLiteralDfa1_1(0x400000L, 0x0L); |
| case 114: |
| return jjMoveStringLiteralDfa1_1(0x80000000L, 0x0L); |
| case 115: |
| return jjMoveStringLiteralDfa1_1(0x40000000L, 0x0L); |
| case 116: |
| return jjMoveStringLiteralDfa1_1(0x500000000L, 0x0L); |
| case 117: |
| return jjMoveStringLiteralDfa1_1(0x1000000000L, 0x0L); |
| case 123: |
| return jjStartNfaWithStates_1(0, 119, 136); |
| case 124: |
| return jjStopAtPos(0, 83); |
| case 125: |
| return jjStopAtPos(0, 120); |
| default : |
| return jjMoveNfa_1(23, 0); |
| } |
| } |
| private final int jjMoveStringLiteralDfa1_1(long active0, long active1) |
| { |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_1(0, active0, active1); |
| return 1; |
| } |
| switch(curChar) |
| { |
| case 46: |
| if ((active1 & 0x400000000000L) != 0L) |
| return jjStopAtPos(1, 110); |
| break; |
| case 47: |
| if ((active0 & 0x8000000000000000L) != 0L) |
| return jjStopAtPos(1, 63); |
| break; |
| case 60: |
| if ((active1 & 0x20L) != 0L) |
| return jjStopAtPos(1, 69); |
| break; |
| case 61: |
| if ((active1 & 0x4L) != 0L) |
| return jjStopAtPos(1, 66); |
| else if ((active1 & 0x10L) != 0L) |
| return jjStopAtPos(1, 68); |
| else if ((active1 & 0x40L) != 0L) |
| return jjStopAtPos(1, 70); |
| break; |
| case 62: |
| if ((active1 & 0x80L) != 0L) |
| return jjStopAtPos(1, 71); |
| break; |
| case 97: |
| return jjMoveStringLiteralDfa2_1(active0, 0x40000000L, active1, 0L); |
| case 100: |
| return jjMoveStringLiteralDfa2_1(active0, 0x2000000L, active1, 0L); |
| case 101: |
| if ((active1 & 0x200L) != 0L) |
| return jjStartNfaWithStates_1(1, 73, 231); |
| else if ((active1 & 0x800L) != 0L) |
| return jjStartNfaWithStates_1(1, 75, 231); |
| else if ((active1 & 0x2000L) != 0L) |
| return jjStartNfaWithStates_1(1, 77, 231); |
| return jjMoveStringLiteralDfa2_1(active0, 0x80000000L, active1, 0L); |
| case 104: |
| return jjMoveStringLiteralDfa2_1(active0, 0x100000000L, active1, 0L); |
| case 105: |
| return jjMoveStringLiteralDfa2_1(active0, 0x1000000L, active1, 0L); |
| case 108: |
| return jjMoveStringLiteralDfa2_1(active0, 0x200000000L, active1, 0L); |
| case 110: |
| if ((active0 & 0x10000000L) != 0L) |
| { |
| jjmatchedKind = 28; |
| jjmatchedPos = 1; |
| } |
| return jjMoveStringLiteralDfa2_1(active0, 0x1800800000L, active1, 0L); |
| case 111: |
| if ((active0 & 0x400000000L) != 0L) |
| return jjStartNfaWithStates_1(1, 34, 231); |
| return jjMoveStringLiteralDfa2_1(active0, 0x24000000L, active1, 0L); |
| case 113: |
| if ((active1 & 0x100L) != 0L) |
| return jjStartNfaWithStates_1(1, 72, 231); |
| break; |
| case 114: |
| if ((active0 & 0x400000L) != 0L) |
| return jjStartNfaWithStates_1(1, 22, 231); |
| break; |
| case 115: |
| if ((active1 & 0x2L) != 0L) |
| { |
| jjmatchedKind = 65; |
| jjmatchedPos = 1; |
| } |
| return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0x8L); |
| case 116: |
| if ((active1 & 0x400L) != 0L) |
| return jjStartNfaWithStates_1(1, 74, 231); |
| else if ((active1 & 0x1000L) != 0L) |
| return jjStartNfaWithStates_1(1, 76, 231); |
| break; |
| case 120: |
| return jjMoveStringLiteralDfa2_1(active0, 0x2000000000L, active1, 0L); |
| default : |
| break; |
| } |
| return jjStartNfa_1(0, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa2_1(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_1(0, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_1(1, active0, active1); |
| return 2; |
| } |
| switch(curChar) |
| { |
| case 99: |
| return jjMoveStringLiteralDfa3_1(active0, 0x2000000000L, active1, 0L); |
| case 100: |
| if ((active0 & 0x800000L) != 0L) |
| return jjStartNfaWithStates_1(2, 23, 231); |
| else if ((active0 & 0x4000000L) != 0L) |
| return jjStartNfaWithStates_1(2, 26, 231); |
| break; |
| case 101: |
| return jjMoveStringLiteralDfa3_1(active0, 0x100000000L, active1, 0L); |
| case 105: |
| return jjMoveStringLiteralDfa3_1(active0, 0x1002000000L, active1, 0L); |
| case 110: |
| return jjMoveStringLiteralDfa3_1(active0, 0x20000000L, active1, 0x8L); |
| case 115: |
| return jjMoveStringLiteralDfa3_1(active0, 0x200000000L, active1, 0L); |
| case 116: |
| return jjMoveStringLiteralDfa3_1(active0, 0x8c0000000L, active1, 0L); |
| case 118: |
| if ((active0 & 0x1000000L) != 0L) |
| return jjStartNfaWithStates_1(2, 24, 231); |
| break; |
| default : |
| break; |
| } |
| return jjStartNfa_1(1, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa3_1(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_1(1, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_1(2, active0, active1); |
| return 3; |
| } |
| switch(curChar) |
| { |
| case 101: |
| if ((active0 & 0x200000000L) != 0L) |
| return jjStartNfaWithStates_1(3, 33, 231); |
| return jjMoveStringLiteralDfa4_1(active0, 0x2800000000L, active1, 0L); |
| case 105: |
| return jjMoveStringLiteralDfa4_1(active0, 0x40000000L, active1, 0L); |
| case 110: |
| if ((active0 & 0x100000000L) != 0L) |
| return jjStartNfaWithStates_1(3, 32, 231); |
| break; |
| case 111: |
| return jjMoveStringLiteralDfa4_1(active0, 0x1000000000L, active1, 0x8L); |
| case 116: |
| return jjMoveStringLiteralDfa4_1(active0, 0x20000000L, active1, 0L); |
| case 117: |
| return jjMoveStringLiteralDfa4_1(active0, 0x80000000L, active1, 0L); |
| case 118: |
| if ((active0 & 0x2000000L) != 0L) |
| return jjStartNfaWithStates_1(3, 25, 231); |
| break; |
| default : |
| break; |
| } |
| return jjStartNfa_1(2, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa4_1(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_1(2, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_1(3, active0, active1); |
| return 4; |
| } |
| switch(curChar) |
| { |
| case 101: |
| return jjMoveStringLiteralDfa5_1(active0, 0x20000000L, active1, 0L); |
| case 110: |
| if ((active0 & 0x1000000000L) != 0L) |
| return jjStartNfaWithStates_1(4, 36, 231); |
| break; |
| case 112: |
| return jjMoveStringLiteralDfa5_1(active0, 0x2000000000L, active1, 0L); |
| case 114: |
| return jjMoveStringLiteralDfa5_1(active0, 0x880000000L, active1, 0L); |
| case 115: |
| return jjMoveStringLiteralDfa5_1(active0, 0x40000000L, active1, 0L); |
| case 116: |
| if ((active1 & 0x8L) != 0L) |
| return jjStartNfaWithStates_1(4, 67, 231); |
| break; |
| default : |
| break; |
| } |
| return jjStartNfa_1(3, active0, active1); |
| } |
| private final int jjMoveStringLiteralDfa5_1(long old0, long active0, long old1, long active1) |
| { |
| if (((active0 &= old0) | (active1 &= old1)) == 0L) |
| return jjStartNfa_1(3, old0, old1); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_1(4, active0, 0L); |
| return 5; |
| } |
| switch(curChar) |
| { |
| case 102: |
| return jjMoveStringLiteralDfa6_1(active0, 0x40000000L); |
| case 110: |
| if ((active0 & 0x80000000L) != 0L) |
| return jjStartNfaWithStates_1(5, 31, 231); |
| break; |
| case 115: |
| return jjMoveStringLiteralDfa6_1(active0, 0x800000000L); |
| case 116: |
| if ((active0 & 0x2000000000L) != 0L) |
| return jjStartNfaWithStates_1(5, 37, 231); |
| break; |
| case 120: |
| return jjMoveStringLiteralDfa6_1(active0, 0x20000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_1(4, active0, 0L); |
| } |
| private final int jjMoveStringLiteralDfa6_1(long old0, long active0) |
| { |
| if (((active0 &= old0)) == 0L) |
| return jjStartNfa_1(4, old0, 0L); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_1(5, active0, 0L); |
| return 6; |
| } |
| switch(curChar) |
| { |
| case 101: |
| return jjMoveStringLiteralDfa7_1(active0, 0x800000000L); |
| case 105: |
| return jjMoveStringLiteralDfa7_1(active0, 0x40000000L); |
| case 116: |
| if ((active0 & 0x20000000L) != 0L) |
| return jjStartNfaWithStates_1(6, 29, 231); |
| break; |
| default : |
| break; |
| } |
| return jjStartNfa_1(5, active0, 0L); |
| } |
| private final int jjMoveStringLiteralDfa7_1(long old0, long active0) |
| { |
| if (((active0 &= old0)) == 0L) |
| return jjStartNfa_1(5, old0, 0L); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_1(6, active0, 0L); |
| return 7; |
| } |
| switch(curChar) |
| { |
| case 99: |
| return jjMoveStringLiteralDfa8_1(active0, 0x800000000L); |
| case 101: |
| return jjMoveStringLiteralDfa8_1(active0, 0x40000000L); |
| default : |
| break; |
| } |
| return jjStartNfa_1(6, active0, 0L); |
| } |
| private final int jjMoveStringLiteralDfa8_1(long old0, long active0) |
| { |
| if (((active0 &= old0)) == 0L) |
| return jjStartNfa_1(6, old0, 0L); |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_1(7, active0, 0L); |
| return 8; |
| } |
| switch(curChar) |
| { |
| case 115: |
| if ((active0 & 0x40000000L) != 0L) |
| return jjStartNfaWithStates_1(8, 30, 231); |
| break; |
| case 116: |
| if ((active0 & 0x800000000L) != 0L) |
| return jjStartNfaWithStates_1(8, 35, 231); |
| break; |
| default : |
| break; |
| } |
| return jjStartNfa_1(7, active0, 0L); |
| } |
| private final int jjMoveNfa_1(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 231; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 179: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 229; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 226; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 23: |
| if ((0x3ff000000000000L & l) != 0L) |
| { |
| if (kind > 1) |
| kind = 1; |
| jjCheckNAddStates(348, 353); |
| } |
| else if ((0x100002600L & l) != 0L) |
| { |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(354, 356); |
| } |
| else if (curChar == 46) |
| jjCheckNAddTwoStates(128, 129); |
| else if (curChar == 42) |
| jjstateSet[jjnewStateCnt++] = 57; |
| else if (curChar == 39) |
| jjCheckNAddTwoStates(4, 5); |
| else if (curChar == 34) |
| jjCheckNAddTwoStates(1, 2); |
| break; |
| case 231: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 229; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 226; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 21: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 229; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 226; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 71: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 229; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 226; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 85: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 229; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 226; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 232: |
| if ((0x3ff000000000000L & l) != 0L) |
| jjCheckNAddTwoStates(129, 124); |
| if ((0x3ff000000000000L & l) != 0L) |
| { |
| if (kind > 2) |
| kind = 2; |
| jjCheckNAdd(128); |
| } |
| break; |
| case 42: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 229; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 226; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 136: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 137; |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 131; |
| break; |
| case 40: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 229; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 226; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 22: |
| if ((0x3ff600000000000L & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 229; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| else if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 226; |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 0: |
| if (curChar == 34) |
| jjCheckNAddTwoStates(1, 2); |
| break; |
| case 1: |
| if ((0xfffffffbffffffffL & l) != 0L) |
| jjCheckNAddTwoStates(1, 2); |
| break; |
| case 2: |
| if (curChar != 34) |
| break; |
| if (kind > 4) |
| kind = 4; |
| jjstateSet[jjnewStateCnt++] = 0; |
| break; |
| case 3: |
| if (curChar == 39) |
| jjCheckNAddTwoStates(4, 5); |
| break; |
| case 4: |
| if ((0xffffff7fffffffffL & l) != 0L) |
| jjCheckNAddTwoStates(4, 5); |
| break; |
| case 5: |
| if (curChar != 39) |
| break; |
| if (kind > 4) |
| kind = 4; |
| jjstateSet[jjnewStateCnt++] = 3; |
| break; |
| case 7: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(357, 359); |
| break; |
| case 8: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(9, 16); |
| break; |
| case 9: |
| jjCheckNAddTwoStates(9, 16); |
| break; |
| case 11: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 8; |
| break; |
| case 15: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 10; |
| break; |
| case 16: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 15; |
| break; |
| case 25: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(360, 362); |
| break; |
| case 26: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(27, 34); |
| break; |
| case 27: |
| jjCheckNAddTwoStates(27, 34); |
| break; |
| case 29: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 26; |
| break; |
| case 33: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 28; |
| break; |
| case 34: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 33; |
| break; |
| case 43: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(363, 365); |
| break; |
| case 44: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(45, 54); |
| break; |
| case 45: |
| jjCheckNAddTwoStates(45, 54); |
| break; |
| case 47: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 44; |
| break; |
| case 53: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 46; |
| break; |
| case 54: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 53; |
| break; |
| case 56: |
| if (curChar == 42) |
| jjstateSet[jjnewStateCnt++] = 57; |
| break; |
| case 57: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 58; |
| break; |
| case 59: |
| if ((0x3ff600000000000L & l) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjstateSet[jjnewStateCnt++] = 59; |
| break; |
| case 61: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(366, 368); |
| break; |
| case 62: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(63, 69); |
| break; |
| case 63: |
| jjCheckNAddTwoStates(63, 69); |
| break; |
| case 65: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 62; |
| break; |
| case 67: |
| if (curChar == 36 && kind > 89) |
| kind = 89; |
| break; |
| case 68: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 64; |
| break; |
| case 69: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 68; |
| break; |
| case 74: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(369, 371); |
| break; |
| case 75: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(76, 82); |
| break; |
| case 76: |
| jjCheckNAddTwoStates(76, 82); |
| break; |
| case 78: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 75; |
| break; |
| case 80: |
| if (curChar == 36 && kind > 90) |
| kind = 90; |
| break; |
| case 81: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 77; |
| break; |
| case 82: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 81; |
| break; |
| case 88: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(372, 374); |
| break; |
| case 89: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(90, 96); |
| break; |
| case 90: |
| jjCheckNAddTwoStates(90, 96); |
| break; |
| case 92: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 89; |
| break; |
| case 94: |
| if (curChar == 36 && kind > 91) |
| kind = 91; |
| break; |
| case 95: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 91; |
| break; |
| case 96: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 95; |
| break; |
| case 100: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(375, 377); |
| break; |
| case 101: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(102, 108); |
| break; |
| case 102: |
| jjCheckNAddTwoStates(102, 108); |
| break; |
| case 104: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 101; |
| break; |
| case 107: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 103; |
| break; |
| case 108: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 107; |
| break; |
| case 116: |
| if ((0x3ff000000000000L & l) == 0L) |
| break; |
| if (kind > 1) |
| kind = 1; |
| jjCheckNAddStates(348, 353); |
| break; |
| case 117: |
| if ((0x3ff000000000000L & l) == 0L) |
| break; |
| if (kind > 1) |
| kind = 1; |
| jjCheckNAdd(117); |
| break; |
| case 118: |
| if ((0x3ff000000000000L & l) != 0L) |
| jjCheckNAddTwoStates(118, 119); |
| break; |
| case 119: |
| if (curChar != 46) |
| break; |
| if (kind > 2) |
| kind = 2; |
| jjCheckNAdd(120); |
| break; |
| case 120: |
| if ((0x3ff000000000000L & l) == 0L) |
| break; |
| if (kind > 2) |
| kind = 2; |
| jjCheckNAdd(120); |
| break; |
| case 121: |
| if ((0x3ff000000000000L & l) != 0L) |
| jjCheckNAddStates(378, 380); |
| break; |
| case 122: |
| if (curChar == 46) |
| jjCheckNAddTwoStates(123, 124); |
| break; |
| case 123: |
| if ((0x3ff000000000000L & l) != 0L) |
| jjCheckNAddTwoStates(123, 124); |
| break; |
| case 125: |
| if ((0x280000000000L & l) != 0L) |
| jjCheckNAdd(126); |
| break; |
| case 126: |
| if ((0x3ff000000000000L & l) == 0L) |
| break; |
| if (kind > 3) |
| kind = 3; |
| jjCheckNAdd(126); |
| break; |
| case 127: |
| if (curChar == 46) |
| jjCheckNAddTwoStates(128, 129); |
| break; |
| case 128: |
| if ((0x3ff000000000000L & l) == 0L) |
| break; |
| if (kind > 2) |
| kind = 2; |
| jjCheckNAdd(128); |
| break; |
| case 129: |
| if ((0x3ff000000000000L & l) != 0L) |
| jjCheckNAddTwoStates(129, 124); |
| break; |
| case 131: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(132, 135); |
| break; |
| case 132: |
| jjCheckNAddTwoStates(132, 135); |
| break; |
| case 134: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 133; |
| break; |
| case 135: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 134; |
| break; |
| case 137: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(138, 144); |
| break; |
| case 138: |
| jjCheckNAddTwoStates(138, 144); |
| break; |
| case 140: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddTwoStates(140, 142); |
| break; |
| case 141: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 137; |
| break; |
| case 143: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 139; |
| break; |
| case 144: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 143; |
| break; |
| case 145: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(354, 356); |
| break; |
| case 146: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 8) |
| kind = 8; |
| jjCheckNAdd(146); |
| break; |
| case 149: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(381, 383); |
| break; |
| case 150: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(151, 174); |
| break; |
| case 151: |
| jjCheckNAddTwoStates(151, 174); |
| break; |
| case 153: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 150; |
| break; |
| case 156: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(384, 386); |
| break; |
| case 157: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(158, 164); |
| break; |
| case 158: |
| jjCheckNAddTwoStates(158, 164); |
| break; |
| case 160: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 157; |
| break; |
| case 162: |
| if (curChar == 61 && kind > 47) |
| kind = 47; |
| break; |
| case 163: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 159; |
| break; |
| case 164: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 163; |
| break; |
| case 173: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 152; |
| break; |
| case 174: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 173; |
| break; |
| case 181: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(387, 389); |
| break; |
| case 182: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(183, 195); |
| break; |
| case 183: |
| jjCheckNAddTwoStates(183, 195); |
| break; |
| case 185: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 182; |
| break; |
| case 194: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 184; |
| break; |
| case 195: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 194; |
| break; |
| case 202: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(390, 392); |
| break; |
| case 203: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(204, 217); |
| break; |
| case 204: |
| jjCheckNAddTwoStates(204, 217); |
| break; |
| case 206: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 203; |
| break; |
| case 216: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 205; |
| break; |
| case 217: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 216; |
| break; |
| case 224: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 225: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 226; |
| break; |
| case 226: |
| if (curChar == 42 && kind > 58) |
| kind = 58; |
| break; |
| case 227: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| break; |
| case 228: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 229; |
| break; |
| case 230: |
| if ((0x3ff600000000000L & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 179: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 221; |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 199; |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 178; |
| break; |
| case 23: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(393, 397); |
| } |
| else if (curChar == 123) |
| jjCheckNAddTwoStates(136, 141); |
| if (curChar == 100) |
| jjAddStates(398, 400); |
| else if (curChar == 118) |
| jjstateSet[jjnewStateCnt++] = 114; |
| else if (curChar == 102) |
| jjstateSet[jjnewStateCnt++] = 97; |
| else if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 85; |
| else if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 71; |
| else if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 42; |
| else if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 40; |
| else if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 22; |
| break; |
| case 231: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 21: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 20; |
| break; |
| case 71: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 70; |
| break; |
| case 85: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if (curChar == 118) |
| jjstateSet[jjnewStateCnt++] = 84; |
| break; |
| case 42: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if (curChar == 102) |
| jjCheckNAddTwoStates(43, 48); |
| break; |
| case 40: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 39; |
| break; |
| case 22: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 21; |
| break; |
| case 1: |
| jjAddStates(243, 244); |
| break; |
| case 4: |
| jjAddStates(245, 246); |
| break; |
| case 6: |
| if (curChar == 101) |
| jjCheckNAddTwoStates(7, 12); |
| break; |
| case 9: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(401, 402); |
| break; |
| case 10: |
| if (curChar == 125) |
| jjCheckNAddStates(357, 359); |
| break; |
| case 12: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 11; |
| break; |
| case 13: |
| if (curChar == 102 && kind > 38) |
| kind = 38; |
| break; |
| case 14: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 13; |
| break; |
| case 17: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 6; |
| break; |
| case 18: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 17; |
| break; |
| case 19: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 18; |
| break; |
| case 20: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 19; |
| break; |
| case 24: |
| if (curChar == 101) |
| jjCheckNAddTwoStates(25, 30); |
| break; |
| case 27: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(403, 404); |
| break; |
| case 28: |
| if (curChar == 125) |
| jjCheckNAddStates(360, 362); |
| break; |
| case 30: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 29; |
| break; |
| case 31: |
| if (curChar == 115 && kind > 39) |
| kind = 39; |
| break; |
| case 32: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 31; |
| break; |
| case 35: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 24; |
| break; |
| case 36: |
| if (curChar == 98) |
| jjstateSet[jjnewStateCnt++] = 35; |
| break; |
| case 37: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 36; |
| break; |
| case 38: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 37; |
| break; |
| case 39: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 38; |
| break; |
| case 41: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 40; |
| break; |
| case 45: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(405, 406); |
| break; |
| case 46: |
| if (curChar == 125) |
| jjCheckNAddStates(363, 365); |
| break; |
| case 48: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 47; |
| break; |
| case 49: |
| if (curChar == 101 && kind > 50) |
| kind = 50; |
| break; |
| case 50: |
| if (curChar == 112) |
| jjstateSet[jjnewStateCnt++] = 49; |
| break; |
| case 51: |
| if (curChar == 121) |
| jjstateSet[jjnewStateCnt++] = 50; |
| break; |
| case 52: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 51; |
| break; |
| case 55: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 42; |
| break; |
| case 58: |
| case 59: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(59); |
| break; |
| case 60: |
| if (curChar == 101) |
| jjCheckNAddStates(366, 368); |
| break; |
| case 63: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(407, 408); |
| break; |
| case 64: |
| if (curChar == 125) |
| jjCheckNAddStates(366, 368); |
| break; |
| case 66: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 65; |
| break; |
| case 70: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 60; |
| break; |
| case 72: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 71; |
| break; |
| case 73: |
| if (curChar == 121) |
| jjCheckNAddStates(369, 371); |
| break; |
| case 76: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(409, 410); |
| break; |
| case 77: |
| if (curChar == 125) |
| jjCheckNAddStates(369, 371); |
| break; |
| case 79: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 78; |
| break; |
| case 83: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 73; |
| break; |
| case 84: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 83; |
| break; |
| case 86: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 85; |
| break; |
| case 87: |
| if (curChar == 114) |
| jjCheckNAddStates(372, 374); |
| break; |
| case 90: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(411, 412); |
| break; |
| case 91: |
| if (curChar == 125) |
| jjCheckNAddStates(372, 374); |
| break; |
| case 93: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 92; |
| break; |
| case 97: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 87; |
| break; |
| case 98: |
| if (curChar == 102) |
| jjstateSet[jjnewStateCnt++] = 97; |
| break; |
| case 99: |
| if (curChar == 101) |
| jjCheckNAddStates(375, 377); |
| break; |
| case 102: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(413, 414); |
| break; |
| case 103: |
| if (curChar == 125) |
| jjCheckNAddStates(375, 377); |
| break; |
| case 105: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 104; |
| break; |
| case 106: |
| if (curChar == 123 && kind > 94) |
| kind = 94; |
| break; |
| case 109: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 99; |
| break; |
| case 110: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 109; |
| break; |
| case 111: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 110; |
| break; |
| case 112: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 111; |
| break; |
| case 113: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 112; |
| break; |
| case 114: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 113; |
| break; |
| case 115: |
| if (curChar == 118) |
| jjstateSet[jjnewStateCnt++] = 114; |
| break; |
| case 124: |
| if ((0x2000000020L & l) != 0L) |
| jjAddStates(415, 416); |
| break; |
| case 130: |
| if (curChar == 123) |
| jjCheckNAddTwoStates(136, 141); |
| break; |
| case 132: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(417, 418); |
| break; |
| case 133: |
| if (curChar == 125 && kind > 5) |
| kind = 5; |
| break; |
| case 138: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(419, 420); |
| break; |
| case 139: |
| if (curChar != 125) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjAddStates(421, 422); |
| break; |
| case 142: |
| if (curChar == 123) |
| jjCheckNAdd(141); |
| break; |
| case 147: |
| if (curChar == 100) |
| jjAddStates(398, 400); |
| break; |
| case 148: |
| if (curChar == 116) |
| jjCheckNAddTwoStates(149, 154); |
| break; |
| case 151: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(423, 424); |
| break; |
| case 152: |
| if (curChar == 125) |
| jjCheckNAddStates(381, 383); |
| break; |
| case 154: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 153; |
| break; |
| case 155: |
| if (curChar == 110) |
| jjCheckNAddTwoStates(156, 161); |
| break; |
| case 158: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(425, 426); |
| break; |
| case 159: |
| if (curChar == 125) |
| jjCheckNAddStates(384, 386); |
| break; |
| case 161: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 160; |
| break; |
| case 165: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 155; |
| break; |
| case 166: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 165; |
| break; |
| case 167: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 166; |
| break; |
| case 168: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 167; |
| break; |
| case 169: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 168; |
| break; |
| case 170: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 169; |
| break; |
| case 171: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 170; |
| break; |
| case 172: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 171; |
| break; |
| case 175: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 148; |
| break; |
| case 176: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 175; |
| break; |
| case 177: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 176; |
| break; |
| case 178: |
| if (curChar == 102) |
| jjstateSet[jjnewStateCnt++] = 177; |
| break; |
| case 180: |
| if (curChar == 116) |
| jjCheckNAddTwoStates(181, 186); |
| break; |
| case 183: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(427, 428); |
| break; |
| case 184: |
| if (curChar == 125) |
| jjCheckNAddStates(387, 389); |
| break; |
| case 186: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 185; |
| break; |
| case 187: |
| if (curChar == 116 && kind > 48) |
| kind = 48; |
| break; |
| case 188: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 187; |
| break; |
| case 189: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 188; |
| break; |
| case 190: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 189; |
| break; |
| case 191: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 190; |
| break; |
| case 192: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 191; |
| break; |
| case 193: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 192; |
| break; |
| case 196: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 180; |
| break; |
| case 197: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 196; |
| break; |
| case 198: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 197; |
| break; |
| case 199: |
| if (curChar == 102) |
| jjstateSet[jjnewStateCnt++] = 198; |
| break; |
| case 200: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 199; |
| break; |
| case 201: |
| if (curChar == 116) |
| jjCheckNAddTwoStates(202, 207); |
| break; |
| case 204: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(429, 430); |
| break; |
| case 205: |
| if (curChar == 125) |
| jjCheckNAddStates(390, 392); |
| break; |
| case 207: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 206; |
| break; |
| case 208: |
| if (curChar == 110 && kind > 49) |
| kind = 49; |
| break; |
| case 209: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 208; |
| break; |
| case 210: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 209; |
| break; |
| case 211: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 210; |
| break; |
| case 212: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 211; |
| break; |
| case 213: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 212; |
| break; |
| case 214: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 213; |
| break; |
| case 215: |
| if (curChar == 102) |
| jjstateSet[jjnewStateCnt++] = 214; |
| break; |
| case 218: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 201; |
| break; |
| case 219: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 218; |
| break; |
| case 220: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 219; |
| break; |
| case 221: |
| if (curChar == 102) |
| jjstateSet[jjnewStateCnt++] = 220; |
| break; |
| case 222: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 221; |
| break; |
| case 223: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(393, 397); |
| break; |
| case 224: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 227: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| break; |
| case 229: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| break; |
| case 230: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 179: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| break; |
| case 23: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(393, 397); |
| break; |
| case 231: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| break; |
| case 21: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| break; |
| case 71: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| break; |
| case 85: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| break; |
| case 42: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| break; |
| case 40: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| break; |
| case 22: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| if ((jjbitVec28[i2] & l2) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| } |
| break; |
| case 1: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(243, 244); |
| break; |
| case 4: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(245, 246); |
| break; |
| case 9: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(401, 402); |
| break; |
| case 27: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(403, 404); |
| break; |
| case 45: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(405, 406); |
| break; |
| case 58: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(59); |
| break; |
| case 59: |
| if ((jjbitVec28[i2] & l2) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(59); |
| break; |
| case 63: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(407, 408); |
| break; |
| case 76: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(409, 410); |
| break; |
| case 90: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(411, 412); |
| break; |
| case 102: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(413, 414); |
| break; |
| case 132: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(417, 418); |
| break; |
| case 138: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(419, 420); |
| break; |
| case 151: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(423, 424); |
| break; |
| case 158: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(425, 426); |
| break; |
| case 183: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(427, 428); |
| break; |
| case 204: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(429, 430); |
| break; |
| case 224: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(224, 225); |
| break; |
| case 227: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(227, 228); |
| break; |
| case 229: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| break; |
| case 230: |
| if ((jjbitVec28[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(230); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 231 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjStopStringLiteralDfa_8(int pos, long active0, long active1) |
| { |
| switch (pos) |
| { |
| default : |
| return -1; |
| } |
| } |
| private final int jjStartNfa_8(int pos, long active0, long active1) |
| { |
| return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0, active1), pos + 1); |
| } |
| private final int jjStartNfaWithStates_8(int pos, int kind, int state) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = pos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return pos + 1; } |
| return jjMoveNfa_8(state, pos + 1); |
| } |
| private final int jjMoveStringLiteralDfa0_8() |
| { |
| switch(curChar) |
| { |
| case 123: |
| return jjStartNfaWithStates_8(0, 118, 5); |
| default : |
| return jjMoveNfa_8(6, 0); |
| } |
| } |
| private final int jjMoveNfa_8(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 8; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 6: |
| if ((0xffffffff00002600L & l) != 0L && kind > 121) |
| kind = 121; |
| break; |
| case 0: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(1, 4); |
| break; |
| case 1: |
| jjCheckNAddTwoStates(1, 4); |
| break; |
| case 3: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 2; |
| break; |
| case 4: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 3; |
| break; |
| case 5: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 0; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 6: |
| if (kind > 121) |
| kind = 121; |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 5; |
| break; |
| case 1: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(431, 432); |
| break; |
| case 2: |
| if (curChar == 125 && kind > 5) |
| kind = 5; |
| break; |
| case 7: |
| if (kind > 121) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 6: |
| if ((jjbitVec0[i2] & l2) != 0L && kind > 121) |
| kind = 121; |
| break; |
| case 1: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(431, 432); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjMoveStringLiteralDfa0_2() |
| { |
| return jjMoveNfa_2(6, 0); |
| } |
| private final int jjMoveNfa_2(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 23; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 6: |
| if ((0x100002600L & l) != 0L) |
| { |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(433, 435); |
| } |
| else if (curChar == 39) |
| jjCheckNAddTwoStates(4, 5); |
| else if (curChar == 34) |
| jjCheckNAddTwoStates(1, 2); |
| break; |
| case 0: |
| if (curChar == 34) |
| jjCheckNAddTwoStates(1, 2); |
| break; |
| case 1: |
| if ((0xfffffffbffffffffL & l) != 0L) |
| jjCheckNAddTwoStates(1, 2); |
| break; |
| case 2: |
| if (curChar != 34) |
| break; |
| if (kind > 4) |
| kind = 4; |
| jjstateSet[jjnewStateCnt++] = 0; |
| break; |
| case 3: |
| if (curChar == 39) |
| jjCheckNAddTwoStates(4, 5); |
| break; |
| case 4: |
| if ((0xffffff7fffffffffL & l) != 0L) |
| jjCheckNAddTwoStates(4, 5); |
| break; |
| case 5: |
| if (curChar != 39) |
| break; |
| if (kind > 4) |
| kind = 4; |
| jjstateSet[jjnewStateCnt++] = 3; |
| break; |
| case 7: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(8, 11); |
| break; |
| case 8: |
| jjCheckNAddTwoStates(8, 11); |
| break; |
| case 10: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 9; |
| break; |
| case 11: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 10; |
| break; |
| case 12: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 7; |
| break; |
| case 13: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(14, 20); |
| break; |
| case 14: |
| jjCheckNAddTwoStates(14, 20); |
| break; |
| case 16: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddTwoStates(16, 18); |
| break; |
| case 17: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 13; |
| break; |
| case 19: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 15; |
| break; |
| case 20: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 19; |
| break; |
| case 21: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(433, 435); |
| break; |
| case 22: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 8) |
| kind = 8; |
| jjCheckNAdd(22); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 6: |
| if (curChar == 123) |
| jjCheckNAddTwoStates(12, 17); |
| break; |
| case 1: |
| jjAddStates(243, 244); |
| break; |
| case 4: |
| jjAddStates(245, 246); |
| break; |
| case 8: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(436, 437); |
| break; |
| case 9: |
| if (curChar == 125 && kind > 5) |
| kind = 5; |
| break; |
| case 14: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(438, 439); |
| break; |
| case 15: |
| if (curChar != 125) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjAddStates(440, 441); |
| break; |
| case 18: |
| if (curChar == 123) |
| jjCheckNAdd(17); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 1: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(243, 244); |
| break; |
| case 4: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(245, 246); |
| break; |
| case 8: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(436, 437); |
| break; |
| case 14: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(438, 439); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjMoveStringLiteralDfa0_14() |
| { |
| return jjMoveNfa_14(0, 0); |
| } |
| private final int jjMoveNfa_14(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 1; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((0xffffffff00002600L & l) != 0L) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((jjbitVec0[i2] & l2) != 0L && kind > 121) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjStopStringLiteralDfa_11(int pos, long active0, long active1) |
| { |
| switch (pos) |
| { |
| default : |
| return -1; |
| } |
| } |
| private final int jjStartNfa_11(int pos, long active0, long active1) |
| { |
| return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0, active1), pos + 1); |
| } |
| private final int jjStartNfaWithStates_11(int pos, int kind, int state) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = pos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return pos + 1; } |
| return jjMoveNfa_11(state, pos + 1); |
| } |
| private final int jjMoveStringLiteralDfa0_11() |
| { |
| switch(curChar) |
| { |
| case 123: |
| return jjStopAtPos(0, 118); |
| case 125: |
| return jjStopAtPos(0, 120); |
| default : |
| return jjMoveNfa_11(0, 0); |
| } |
| } |
| private final int jjMoveNfa_11(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 1; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((0xffffffff00002600L & l) != 0L) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((jjbitVec0[i2] & l2) != 0L && kind > 121) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjMoveStringLiteralDfa0_16() |
| { |
| return jjMoveNfa_16(0, 0); |
| } |
| private final int jjMoveNfa_16(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 1; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((0xffffffff00002600L & l) != 0L) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((jjbitVec0[i2] & l2) != 0L && kind > 121) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjStopStringLiteralDfa_9(int pos, long active0, long active1) |
| { |
| switch (pos) |
| { |
| default : |
| return -1; |
| } |
| } |
| private final int jjStartNfa_9(int pos, long active0, long active1) |
| { |
| return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0, active1), pos + 1); |
| } |
| private final int jjStartNfaWithStates_9(int pos, int kind, int state) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = pos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return pos + 1; } |
| return jjMoveNfa_9(state, pos + 1); |
| } |
| private final int jjMoveStringLiteralDfa0_9() |
| { |
| switch(curChar) |
| { |
| case 123: |
| return jjStopAtPos(0, 118); |
| default : |
| return jjMoveNfa_9(0, 0); |
| } |
| } |
| private final int jjMoveNfa_9(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 1; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((0x100002600L & l) == 0L) |
| break; |
| kind = 8; |
| jjstateSet[jjnewStateCnt++] = 0; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjMoveStringLiteralDfa0_13() |
| { |
| return jjMoveNfa_13(0, 0); |
| } |
| private final int jjMoveNfa_13(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 1; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((0xffffffff00002600L & l) != 0L) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 0: |
| if ((jjbitVec0[i2] & l2) != 0L && kind > 121) |
| kind = 121; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1) |
| { |
| switch (pos) |
| { |
| case 0: |
| if ((active0 & 0x200000000000000L) != 0L) |
| return 15; |
| return -1; |
| default : |
| return -1; |
| } |
| } |
| private final int jjStartNfa_3(int pos, long active0, long active1) |
| { |
| return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1), pos + 1); |
| } |
| private final int jjStartNfaWithStates_3(int pos, int kind, int state) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = pos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return pos + 1; } |
| return jjMoveNfa_3(state, pos + 1); |
| } |
| private final int jjMoveStringLiteralDfa0_3() |
| { |
| switch(curChar) |
| { |
| case 36: |
| return jjStopAtPos(0, 114); |
| case 40: |
| return jjStopAtPos(0, 84); |
| case 41: |
| return jjStopAtPos(0, 88); |
| case 42: |
| return jjStartNfaWithStates_3(0, 57, 15); |
| case 44: |
| return jjStopAtPos(0, 108); |
| case 46: |
| jjmatchedKind = 109; |
| return jjMoveStringLiteralDfa1_3(0x0L, 0x400000000000L); |
| case 47: |
| jjmatchedKind = 60; |
| return jjMoveStringLiteralDfa1_3(0x2000000000000000L, 0x0L); |
| case 64: |
| return jjStopAtPos(0, 85); |
| default : |
| return jjMoveNfa_3(13, 0); |
| } |
| } |
| private final int jjMoveStringLiteralDfa1_3(long active0, long active1) |
| { |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { |
| jjStopStringLiteralDfa_3(0, active0, active1); |
| return 1; |
| } |
| switch(curChar) |
| { |
| case 46: |
| if ((active1 & 0x400000000000L) != 0L) |
| return jjStopAtPos(1, 110); |
| break; |
| case 47: |
| if ((active0 & 0x2000000000000000L) != 0L) |
| return jjStopAtPos(1, 61); |
| break; |
| default : |
| break; |
| } |
| return jjStartNfa_3(0, active0, active1); |
| } |
| private final int jjMoveNfa_3(int startState, int curPos) |
| { |
| int[] nextStates; |
| int startsAt = 0; |
| jjnewStateCnt = 360; |
| int i = 1; |
| jjstateSet[0] = startState; |
| int j, kind = 0x7fffffff; |
| for (;;) |
| { |
| if (++jjround == 0x7fffffff) |
| ReInitRounds(); |
| if (curChar < 64) |
| { |
| long l = 1L << curChar; |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 13: |
| if ((0x100002600L & l) != 0L) |
| { |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(442, 444); |
| } |
| else if (curChar == 42) |
| jjstateSet[jjnewStateCnt++] = 15; |
| break; |
| case 1: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(445, 447); |
| break; |
| case 2: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(3, 10); |
| break; |
| case 3: |
| jjCheckNAddTwoStates(3, 10); |
| break; |
| case 5: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 2; |
| break; |
| case 7: |
| if (curChar == 58 && kind > 13) |
| kind = 13; |
| break; |
| case 8: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 7; |
| break; |
| case 9: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 4; |
| break; |
| case 10: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 9; |
| break; |
| case 14: |
| if (curChar == 42) |
| jjstateSet[jjnewStateCnt++] = 15; |
| break; |
| case 15: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 16; |
| break; |
| case 17: |
| if ((0x3ff600000000000L & l) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjstateSet[jjnewStateCnt++] = 17; |
| break; |
| case 19: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(448, 450); |
| break; |
| case 20: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(21, 27); |
| break; |
| case 21: |
| jjCheckNAddTwoStates(21, 27); |
| break; |
| case 23: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 20; |
| break; |
| case 25: |
| if (curChar == 40 && kind > 105) |
| kind = 105; |
| break; |
| case 26: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 22; |
| break; |
| case 27: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 26; |
| break; |
| case 32: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(33, 36); |
| break; |
| case 33: |
| jjCheckNAddTwoStates(33, 36); |
| break; |
| case 35: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 34; |
| break; |
| case 36: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 35; |
| break; |
| case 37: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 32; |
| break; |
| case 38: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(39, 45); |
| break; |
| case 39: |
| jjCheckNAddTwoStates(39, 45); |
| break; |
| case 41: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddTwoStates(41, 43); |
| break; |
| case 42: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 38; |
| break; |
| case 44: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 40; |
| break; |
| case 45: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 44; |
| break; |
| case 46: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjCheckNAddStates(442, 444); |
| break; |
| case 47: |
| if ((0x100002600L & l) == 0L) |
| break; |
| if (kind > 8) |
| kind = 8; |
| jjCheckNAdd(47); |
| break; |
| case 50: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(451, 453); |
| break; |
| case 51: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(52, 59); |
| break; |
| case 52: |
| jjCheckNAddTwoStates(52, 59); |
| break; |
| case 54: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 51; |
| break; |
| case 56: |
| if (curChar == 58 && kind > 9) |
| kind = 9; |
| break; |
| case 57: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 56; |
| break; |
| case 58: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 53; |
| break; |
| case 59: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 58; |
| break; |
| case 64: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(454, 456); |
| break; |
| case 65: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(66, 72); |
| break; |
| case 66: |
| jjCheckNAddTwoStates(66, 72); |
| break; |
| case 68: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 65; |
| break; |
| case 70: |
| if (curChar == 40 && kind > 104) |
| kind = 104; |
| break; |
| case 71: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 67; |
| break; |
| case 72: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 71; |
| break; |
| case 80: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(457, 459); |
| break; |
| case 81: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(82, 89); |
| break; |
| case 82: |
| jjCheckNAddTwoStates(82, 89); |
| break; |
| case 84: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 81; |
| break; |
| case 86: |
| if (curChar == 58 && kind > 10) |
| kind = 10; |
| break; |
| case 87: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 86; |
| break; |
| case 88: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 83; |
| break; |
| case 89: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 88; |
| break; |
| case 99: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(460, 462); |
| break; |
| case 100: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(101, 108); |
| break; |
| case 101: |
| jjCheckNAddTwoStates(101, 108); |
| break; |
| case 103: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 100; |
| break; |
| case 105: |
| if (curChar == 58 && kind > 14) |
| kind = 14; |
| break; |
| case 106: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 105; |
| break; |
| case 107: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 102; |
| break; |
| case 108: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 107; |
| break; |
| case 112: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 111; |
| break; |
| case 115: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 114; |
| break; |
| case 127: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(463, 465); |
| break; |
| case 128: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(129, 136); |
| break; |
| case 129: |
| jjCheckNAddTwoStates(129, 136); |
| break; |
| case 131: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 128; |
| break; |
| case 133: |
| if (curChar == 58 && kind > 11) |
| kind = 11; |
| break; |
| case 134: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 133; |
| break; |
| case 135: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 130; |
| break; |
| case 136: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 135; |
| break; |
| case 142: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(466, 468); |
| break; |
| case 143: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(144, 151); |
| break; |
| case 144: |
| jjCheckNAddTwoStates(144, 151); |
| break; |
| case 146: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 143; |
| break; |
| case 148: |
| if (curChar == 58 && kind > 17) |
| kind = 17; |
| break; |
| case 149: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 148; |
| break; |
| case 150: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 145; |
| break; |
| case 151: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 150; |
| break; |
| case 158: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 157; |
| break; |
| case 168: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(469, 471); |
| break; |
| case 169: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(170, 177); |
| break; |
| case 170: |
| jjCheckNAddTwoStates(170, 177); |
| break; |
| case 172: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 169; |
| break; |
| case 174: |
| if (curChar == 58 && kind > 19) |
| kind = 19; |
| break; |
| case 175: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 174; |
| break; |
| case 176: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 171; |
| break; |
| case 177: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 176; |
| break; |
| case 186: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(472, 474); |
| break; |
| case 187: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(188, 194); |
| break; |
| case 188: |
| jjCheckNAddTwoStates(188, 194); |
| break; |
| case 190: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 187; |
| break; |
| case 192: |
| if (curChar == 40 && kind > 106) |
| kind = 106; |
| break; |
| case 193: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 189; |
| break; |
| case 194: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 193; |
| break; |
| case 205: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 204; |
| break; |
| case 217: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(475, 477); |
| break; |
| case 218: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(219, 226); |
| break; |
| case 219: |
| jjCheckNAddTwoStates(219, 226); |
| break; |
| case 221: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 218; |
| break; |
| case 223: |
| if (curChar == 58 && kind > 12) |
| kind = 12; |
| break; |
| case 224: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 223; |
| break; |
| case 225: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 220; |
| break; |
| case 226: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 225; |
| break; |
| case 235: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(478, 480); |
| break; |
| case 236: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(237, 244); |
| break; |
| case 237: |
| jjCheckNAddTwoStates(237, 244); |
| break; |
| case 239: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 236; |
| break; |
| case 241: |
| if (curChar == 58 && kind > 15) |
| kind = 15; |
| break; |
| case 242: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 241; |
| break; |
| case 243: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 238; |
| break; |
| case 244: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 243; |
| break; |
| case 252: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(481, 483); |
| break; |
| case 253: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(254, 261); |
| break; |
| case 254: |
| jjCheckNAddTwoStates(254, 261); |
| break; |
| case 256: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 253; |
| break; |
| case 258: |
| if (curChar == 58 && kind > 21) |
| kind = 21; |
| break; |
| case 259: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 258; |
| break; |
| case 260: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 255; |
| break; |
| case 261: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 260; |
| break; |
| case 265: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 264; |
| break; |
| case 268: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 267; |
| break; |
| case 278: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(484, 486); |
| break; |
| case 279: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(280, 287); |
| break; |
| case 280: |
| jjCheckNAddTwoStates(280, 287); |
| break; |
| case 282: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 279; |
| break; |
| case 284: |
| if (curChar == 58 && kind > 16) |
| kind = 16; |
| break; |
| case 285: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 284; |
| break; |
| case 286: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 281; |
| break; |
| case 287: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 286; |
| break; |
| case 294: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 293; |
| break; |
| case 304: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(487, 489); |
| break; |
| case 305: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(306, 313); |
| break; |
| case 306: |
| jjCheckNAddTwoStates(306, 313); |
| break; |
| case 308: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 305; |
| break; |
| case 310: |
| if (curChar == 58 && kind > 18) |
| kind = 18; |
| break; |
| case 311: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 310; |
| break; |
| case 312: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 307; |
| break; |
| case 313: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 312; |
| break; |
| case 323: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(490, 492); |
| break; |
| case 324: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(325, 332); |
| break; |
| case 325: |
| jjCheckNAddTwoStates(325, 332); |
| break; |
| case 327: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 324; |
| break; |
| case 329: |
| if (curChar == 58 && kind > 20) |
| kind = 20; |
| break; |
| case 330: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 329; |
| break; |
| case 331: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 326; |
| break; |
| case 332: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 331; |
| break; |
| case 341: |
| if ((0x100002600L & l) != 0L) |
| jjAddStates(493, 495); |
| break; |
| case 342: |
| if (curChar == 45) |
| jjCheckNAddTwoStates(343, 349); |
| break; |
| case 343: |
| jjCheckNAddTwoStates(343, 349); |
| break; |
| case 345: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 342; |
| break; |
| case 347: |
| if (curChar == 40 && kind > 103) |
| kind = 103; |
| break; |
| case 348: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 344; |
| break; |
| case 349: |
| if (curChar == 45) |
| jjstateSet[jjnewStateCnt++] = 348; |
| break; |
| case 353: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjAddStates(496, 497); |
| break; |
| case 354: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 355; |
| break; |
| case 355: |
| if (curChar == 42 && kind > 58) |
| kind = 58; |
| break; |
| case 356: |
| if ((0x3ff600000000000L & l) != 0L) |
| jjAddStates(498, 499); |
| break; |
| case 357: |
| if (curChar == 58) |
| jjstateSet[jjnewStateCnt++] = 358; |
| break; |
| case 359: |
| if ((0x3ff600000000000L & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjstateSet[jjnewStateCnt++] = 359; |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else if (curChar < 128) |
| { |
| long l = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 13: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| { |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(500, 504); |
| } |
| else if (curChar == 123) |
| jjCheckNAddTwoStates(37, 42); |
| if (curChar == 110) |
| jjAddStates(505, 506); |
| else if (curChar == 102) |
| jjAddStates(507, 508); |
| else if (curChar == 97) |
| jjAddStates(509, 511); |
| else if (curChar == 112) |
| jjAddStates(512, 515); |
| else if (curChar == 100) |
| jjAddStates(516, 517); |
| else if (curChar == 99) |
| jjAddStates(518, 519); |
| else if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 29; |
| else if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 12; |
| break; |
| case 0: |
| if (curChar == 102) |
| jjCheckNAddStates(445, 447); |
| break; |
| case 3: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(520, 521); |
| break; |
| case 4: |
| if (curChar == 125) |
| jjCheckNAddStates(445, 447); |
| break; |
| case 6: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 5; |
| break; |
| case 11: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 0; |
| break; |
| case 12: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 11; |
| break; |
| case 16: |
| case 17: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(17); |
| break; |
| case 18: |
| if (curChar == 116) |
| jjCheckNAddStates(448, 450); |
| break; |
| case 21: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(522, 523); |
| break; |
| case 22: |
| if (curChar == 125) |
| jjCheckNAddStates(448, 450); |
| break; |
| case 24: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 23; |
| break; |
| case 28: |
| if (curChar == 120) |
| jjstateSet[jjnewStateCnt++] = 18; |
| break; |
| case 29: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 28; |
| break; |
| case 30: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 29; |
| break; |
| case 31: |
| if (curChar == 123) |
| jjCheckNAddTwoStates(37, 42); |
| break; |
| case 33: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(524, 525); |
| break; |
| case 34: |
| if (curChar == 125 && kind > 5) |
| kind = 5; |
| break; |
| case 39: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(526, 527); |
| break; |
| case 40: |
| if (curChar != 125) |
| break; |
| if (kind > 6) |
| kind = 6; |
| jjAddStates(528, 529); |
| break; |
| case 43: |
| if (curChar == 123) |
| jjCheckNAdd(42); |
| break; |
| case 48: |
| if (curChar == 99) |
| jjAddStates(518, 519); |
| break; |
| case 49: |
| if (curChar == 100) |
| jjCheckNAddStates(451, 453); |
| break; |
| case 52: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(530, 531); |
| break; |
| case 53: |
| if (curChar == 125) |
| jjCheckNAddStates(451, 453); |
| break; |
| case 55: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 54; |
| break; |
| case 60: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 49; |
| break; |
| case 61: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 60; |
| break; |
| case 62: |
| if (curChar == 104) |
| jjstateSet[jjnewStateCnt++] = 61; |
| break; |
| case 63: |
| if (curChar == 116) |
| jjCheckNAddStates(454, 456); |
| break; |
| case 66: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(532, 533); |
| break; |
| case 67: |
| if (curChar == 125) |
| jjCheckNAddStates(454, 456); |
| break; |
| case 69: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 68; |
| break; |
| case 73: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 63; |
| break; |
| case 74: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 73; |
| break; |
| case 75: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 74; |
| break; |
| case 76: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 75; |
| break; |
| case 77: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 76; |
| break; |
| case 78: |
| if (curChar == 100) |
| jjAddStates(516, 517); |
| break; |
| case 79: |
| if (curChar == 116) |
| jjCheckNAddStates(457, 459); |
| break; |
| case 82: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(534, 535); |
| break; |
| case 83: |
| if (curChar == 125) |
| jjCheckNAddStates(457, 459); |
| break; |
| case 85: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 84; |
| break; |
| case 90: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 79; |
| break; |
| case 91: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 90; |
| break; |
| case 92: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 91; |
| break; |
| case 93: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 92; |
| break; |
| case 94: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 93; |
| break; |
| case 95: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 94; |
| break; |
| case 96: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 95; |
| break; |
| case 97: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 96; |
| break; |
| case 98: |
| if (curChar == 102) |
| jjCheckNAddStates(460, 462); |
| break; |
| case 101: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(536, 537); |
| break; |
| case 102: |
| if (curChar == 125) |
| jjCheckNAddStates(460, 462); |
| break; |
| case 104: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 103; |
| break; |
| case 109: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 98; |
| break; |
| case 110: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 109; |
| break; |
| case 111: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 110; |
| break; |
| case 113: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 112; |
| break; |
| case 114: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 113; |
| break; |
| case 116: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 115; |
| break; |
| case 117: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 116; |
| break; |
| case 118: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 117; |
| break; |
| case 119: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 118; |
| break; |
| case 120: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 119; |
| break; |
| case 121: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 120; |
| break; |
| case 122: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 121; |
| break; |
| case 123: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 122; |
| break; |
| case 124: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 123; |
| break; |
| case 125: |
| if (curChar == 112) |
| jjAddStates(512, 515); |
| break; |
| case 126: |
| if (curChar == 116) |
| jjCheckNAddStates(463, 465); |
| break; |
| case 129: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(538, 539); |
| break; |
| case 130: |
| if (curChar == 125) |
| jjCheckNAddStates(463, 465); |
| break; |
| case 132: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 131; |
| break; |
| case 137: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 126; |
| break; |
| case 138: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 137; |
| break; |
| case 139: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 138; |
| break; |
| case 140: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 139; |
| break; |
| case 141: |
| if (curChar == 103) |
| jjCheckNAddStates(466, 468); |
| break; |
| case 144: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(540, 541); |
| break; |
| case 145: |
| if (curChar == 125) |
| jjCheckNAddStates(466, 468); |
| break; |
| case 147: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 146; |
| break; |
| case 152: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 141; |
| break; |
| case 153: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 152; |
| break; |
| case 154: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 153; |
| break; |
| case 155: |
| if (curChar == 98) |
| jjstateSet[jjnewStateCnt++] = 154; |
| break; |
| case 156: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 155; |
| break; |
| case 157: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 156; |
| break; |
| case 159: |
| if (curChar == 103) |
| jjstateSet[jjnewStateCnt++] = 158; |
| break; |
| case 160: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 159; |
| break; |
| case 161: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 160; |
| break; |
| case 162: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 161; |
| break; |
| case 163: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 162; |
| break; |
| case 164: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 163; |
| break; |
| case 165: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 164; |
| break; |
| case 166: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 165; |
| break; |
| case 167: |
| if (curChar == 103) |
| jjCheckNAddStates(469, 471); |
| break; |
| case 170: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(542, 543); |
| break; |
| case 171: |
| if (curChar == 125) |
| jjCheckNAddStates(469, 471); |
| break; |
| case 173: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 172; |
| break; |
| case 178: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 167; |
| break; |
| case 179: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 178; |
| break; |
| case 180: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 179; |
| break; |
| case 181: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 180; |
| break; |
| case 182: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 181; |
| break; |
| case 183: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 182; |
| break; |
| case 184: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 183; |
| break; |
| case 185: |
| if (curChar == 110) |
| jjCheckNAddStates(472, 474); |
| break; |
| case 188: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(544, 545); |
| break; |
| case 189: |
| if (curChar == 125) |
| jjCheckNAddStates(472, 474); |
| break; |
| case 191: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 190; |
| break; |
| case 195: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 185; |
| break; |
| case 196: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 195; |
| break; |
| case 197: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 196; |
| break; |
| case 198: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 197; |
| break; |
| case 199: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 198; |
| break; |
| case 200: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 199; |
| break; |
| case 201: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 200; |
| break; |
| case 202: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 201; |
| break; |
| case 203: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 202; |
| break; |
| case 204: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 203; |
| break; |
| case 206: |
| if (curChar == 103) |
| jjstateSet[jjnewStateCnt++] = 205; |
| break; |
| case 207: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 206; |
| break; |
| case 208: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 207; |
| break; |
| case 209: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 208; |
| break; |
| case 210: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 209; |
| break; |
| case 211: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 210; |
| break; |
| case 212: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 211; |
| break; |
| case 213: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 212; |
| break; |
| case 214: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 213; |
| break; |
| case 215: |
| if (curChar == 97) |
| jjAddStates(509, 511); |
| break; |
| case 216: |
| if (curChar == 101) |
| jjCheckNAddStates(475, 477); |
| break; |
| case 219: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(546, 547); |
| break; |
| case 220: |
| if (curChar == 125) |
| jjCheckNAddStates(475, 477); |
| break; |
| case 222: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 221; |
| break; |
| case 227: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 216; |
| break; |
| case 228: |
| if (curChar == 117) |
| jjstateSet[jjnewStateCnt++] = 227; |
| break; |
| case 229: |
| if (curChar == 98) |
| jjstateSet[jjnewStateCnt++] = 228; |
| break; |
| case 230: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 229; |
| break; |
| case 231: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 230; |
| break; |
| case 232: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 231; |
| break; |
| case 233: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 232; |
| break; |
| case 234: |
| if (curChar == 114) |
| jjCheckNAddStates(478, 480); |
| break; |
| case 237: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(548, 549); |
| break; |
| case 238: |
| if (curChar == 125) |
| jjCheckNAddStates(478, 480); |
| break; |
| case 240: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 239; |
| break; |
| case 245: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 234; |
| break; |
| case 246: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 245; |
| break; |
| case 247: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 246; |
| break; |
| case 248: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 247; |
| break; |
| case 249: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 248; |
| break; |
| case 250: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 249; |
| break; |
| case 251: |
| if (curChar == 102) |
| jjCheckNAddStates(481, 483); |
| break; |
| case 254: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(550, 551); |
| break; |
| case 255: |
| if (curChar == 125) |
| jjCheckNAddStates(481, 483); |
| break; |
| case 257: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 256; |
| break; |
| case 262: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 251; |
| break; |
| case 263: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 262; |
| break; |
| case 264: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 263; |
| break; |
| case 266: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 265; |
| break; |
| case 267: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 266; |
| break; |
| case 269: |
| if (curChar == 114) |
| jjstateSet[jjnewStateCnt++] = 268; |
| break; |
| case 270: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 269; |
| break; |
| case 271: |
| if (curChar == 116) |
| jjstateSet[jjnewStateCnt++] = 270; |
| break; |
| case 272: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 271; |
| break; |
| case 273: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 272; |
| break; |
| case 274: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 273; |
| break; |
| case 275: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 274; |
| break; |
| case 276: |
| if (curChar == 102) |
| jjAddStates(507, 508); |
| break; |
| case 277: |
| if (curChar == 103) |
| jjCheckNAddStates(484, 486); |
| break; |
| case 280: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(552, 553); |
| break; |
| case 281: |
| if (curChar == 125) |
| jjCheckNAddStates(484, 486); |
| break; |
| case 283: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 282; |
| break; |
| case 288: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 277; |
| break; |
| case 289: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 288; |
| break; |
| case 290: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 289; |
| break; |
| case 291: |
| if (curChar == 98) |
| jjstateSet[jjnewStateCnt++] = 290; |
| break; |
| case 292: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 291; |
| break; |
| case 293: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 292; |
| break; |
| case 295: |
| if (curChar == 103) |
| jjstateSet[jjnewStateCnt++] = 294; |
| break; |
| case 296: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 295; |
| break; |
| case 297: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 296; |
| break; |
| case 298: |
| if (curChar == 119) |
| jjstateSet[jjnewStateCnt++] = 297; |
| break; |
| case 299: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 298; |
| break; |
| case 300: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 299; |
| break; |
| case 301: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 300; |
| break; |
| case 302: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 301; |
| break; |
| case 303: |
| if (curChar == 103) |
| jjCheckNAddStates(487, 489); |
| break; |
| case 306: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(554, 555); |
| break; |
| case 307: |
| if (curChar == 125) |
| jjCheckNAddStates(487, 489); |
| break; |
| case 309: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 308; |
| break; |
| case 314: |
| if (curChar == 110) |
| jjstateSet[jjnewStateCnt++] = 303; |
| break; |
| case 315: |
| if (curChar == 105) |
| jjstateSet[jjnewStateCnt++] = 314; |
| break; |
| case 316: |
| if (curChar == 119) |
| jjstateSet[jjnewStateCnt++] = 315; |
| break; |
| case 317: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 316; |
| break; |
| case 318: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 317; |
| break; |
| case 319: |
| if (curChar == 108) |
| jjstateSet[jjnewStateCnt++] = 318; |
| break; |
| case 320: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 319; |
| break; |
| case 321: |
| if (curChar == 110) |
| jjAddStates(505, 506); |
| break; |
| case 322: |
| if (curChar == 101) |
| jjCheckNAddStates(490, 492); |
| break; |
| case 325: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(556, 557); |
| break; |
| case 326: |
| if (curChar == 125) |
| jjCheckNAddStates(490, 492); |
| break; |
| case 328: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 327; |
| break; |
| case 333: |
| if (curChar == 99) |
| jjstateSet[jjnewStateCnt++] = 322; |
| break; |
| case 334: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 333; |
| break; |
| case 335: |
| if (curChar == 112) |
| jjstateSet[jjnewStateCnt++] = 334; |
| break; |
| case 336: |
| if (curChar == 115) |
| jjstateSet[jjnewStateCnt++] = 335; |
| break; |
| case 337: |
| if (curChar == 101) |
| jjstateSet[jjnewStateCnt++] = 336; |
| break; |
| case 338: |
| if (curChar == 109) |
| jjstateSet[jjnewStateCnt++] = 337; |
| break; |
| case 339: |
| if (curChar == 97) |
| jjstateSet[jjnewStateCnt++] = 338; |
| break; |
| case 340: |
| if (curChar == 101) |
| jjCheckNAddStates(493, 495); |
| break; |
| case 343: |
| if ((0xdfffffffffffffffL & l) != 0L) |
| jjAddStates(558, 559); |
| break; |
| case 344: |
| if (curChar == 125) |
| jjCheckNAddStates(493, 495); |
| break; |
| case 346: |
| if (curChar == 123) |
| jjstateSet[jjnewStateCnt++] = 345; |
| break; |
| case 350: |
| if (curChar == 100) |
| jjstateSet[jjnewStateCnt++] = 340; |
| break; |
| case 351: |
| if (curChar == 111) |
| jjstateSet[jjnewStateCnt++] = 350; |
| break; |
| case 352: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(500, 504); |
| break; |
| case 353: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(353, 354); |
| break; |
| case 356: |
| if ((0x7fffffe87fffffeL & l) != 0L) |
| jjCheckNAddTwoStates(356, 357); |
| break; |
| case 358: |
| case 359: |
| if ((0x7fffffe87fffffeL & l) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(359); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| else |
| { |
| int i2 = (curChar & 0xff) >> 6; |
| long l2 = 1L << (curChar & 077); |
| MatchLoop: do |
| { |
| switch(jjstateSet[--i]) |
| { |
| case 13: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAddStates(500, 504); |
| break; |
| case 3: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(520, 521); |
| break; |
| case 16: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(17); |
| break; |
| case 17: |
| if ((jjbitVec28[i2] & l2) == 0L) |
| break; |
| if (kind > 59) |
| kind = 59; |
| jjCheckNAdd(17); |
| break; |
| case 21: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(522, 523); |
| break; |
| case 33: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(524, 525); |
| break; |
| case 39: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(526, 527); |
| break; |
| case 52: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(530, 531); |
| break; |
| case 66: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(532, 533); |
| break; |
| case 82: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(534, 535); |
| break; |
| case 101: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(536, 537); |
| break; |
| case 129: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(538, 539); |
| break; |
| case 144: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(540, 541); |
| break; |
| case 170: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(542, 543); |
| break; |
| case 188: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(544, 545); |
| break; |
| case 219: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(546, 547); |
| break; |
| case 237: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(548, 549); |
| break; |
| case 254: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(550, 551); |
| break; |
| case 280: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(552, 553); |
| break; |
| case 306: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(554, 555); |
| break; |
| case 325: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(556, 557); |
| break; |
| case 343: |
| if ((jjbitVec0[i2] & l2) != 0L) |
| jjAddStates(558, 559); |
| break; |
| case 353: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(353, 354); |
| break; |
| case 356: |
| if ((jjbitVec28[i2] & l2) != 0L) |
| jjCheckNAddTwoStates(356, 357); |
| break; |
| case 358: |
| if ((jjbitVec5[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(359); |
| break; |
| case 359: |
| if ((jjbitVec28[i2] & l2) == 0L) |
| break; |
| if (kind > 116) |
| kind = 116; |
| jjCheckNAdd(359); |
| break; |
| default : break; |
| } |
| } while(i != startsAt); |
| } |
| if (kind != 0x7fffffff) |
| { |
| jjmatchedKind = kind; |
| jjmatchedPos = curPos; |
| kind = 0x7fffffff; |
| } |
| ++curPos; |
| if ((i = jjnewStateCnt) == (startsAt = 360 - (jjnewStateCnt = startsAt))) |
| return curPos; |
| try { curChar = input_stream.readChar(); } |
| catch(java.io.IOException e) { return curPos; } |
| } |
| } |
| static final int[] jjnextStates = { |
| 2, 7, 0, 5, 10, 13, 10, 12, 16, 2, 5, 8, 14, 10, 12, 50, |
| 52, 56, 1, 6, 11, 24, 29, 30, 58, 59, 61, 62, 64, 3, 13, 26, |
| 32, 42, 45, 48, 54, 50, 52, 9, 10, 9, 10, 12, 15, 18, 36, 37, |
| 38, 40, 41, 43, 59, 61, 65, 7, 12, 16, 25, 30, 31, 40, 41, 43, |
| 68, 73, 75, 82, 87, 89, 95, 100, 101, 111, 116, 118, 130, 135, 137, 157, |
| 162, 180, 164, 169, 170, 189, 194, 201, 210, 215, 223, 232, 237, 238, 249, 254, |
| 256, 264, 269, 271, 290, 295, 297, 308, 313, 314, 339, 344, 346, 357, 362, 364, |
| 374, 379, 381, 399, 404, 405, 406, 407, 409, 410, 415, 416, 410, 415, 416, 429, |
| 434, 435, 447, 452, 454, 460, 465, 466, 473, 478, 480, 499, 504, 506, 517, 522, |
| 523, 529, 534, 536, 547, 552, 553, 560, 565, 566, 567, 568, 570, 571, 576, 577, |
| 571, 576, 577, 588, 593, 594, 603, 608, 609, 617, 622, 623, 624, 625, 633, 638, |
| 640, 647, 652, 653, 659, 660, 662, 663, 666, 667, 669, 670, 675, 676, 670, 675, |
| 676, 681, 686, 687, 697, 702, 709, 659, 660, 662, 663, 665, 666, 667, 669, 670, |
| 675, 676, 695, 717, 631, 645, 657, 586, 601, 614, 545, 557, 497, 515, 526, 458, |
| 470, 355, 372, 397, 427, 444, 262, 288, 306, 336, 128, 155, 187, 208, 230, 246, |
| 80, 93, 108, 1, 2, 4, 5, 9, 18, 27, 33, 44, 45, 51, 54, 57, |
| 63, 59, 61, 70, 77, 84, 91, 97, 103, 113, 120, 132, 139, 159, 182, 166, |
| 172, 191, 203, 212, 225, 234, 240, 251, 258, 266, 273, 292, 299, 310, 316, 341, |
| 348, 359, 366, 376, 383, 401, 420, 406, 407, 409, 410, 415, 416, 412, 418, 431, |
| 437, 449, 456, 462, 468, 475, 482, 501, 508, 519, 525, 531, 538, 549, 555, 562, |
| 581, 567, 568, 570, 571, 576, 577, 573, 579, 590, 596, 605, 611, 619, 629, 624, |
| 625, 627, 635, 642, 649, 655, 672, 678, 683, 689, 699, 711, 117, 118, 119, 121, |
| 122, 124, 140, 142, 146, 7, 12, 14, 25, 30, 32, 43, 48, 52, 61, 66, |
| 67, 74, 79, 80, 88, 93, 94, 100, 105, 106, 121, 122, 124, 149, 154, 172, |
| 156, 161, 162, 181, 186, 193, 202, 207, 215, 224, 225, 227, 228, 230, 179, 200, |
| 222, 9, 16, 27, 34, 45, 54, 63, 69, 76, 82, 90, 96, 102, 108, 125, |
| 126, 132, 135, 138, 144, 140, 142, 151, 174, 158, 164, 183, 195, 204, 217, 1, |
| 4, 16, 18, 22, 8, 11, 14, 20, 16, 18, 41, 43, 47, 1, 6, 8, |
| 19, 24, 25, 50, 55, 57, 64, 69, 70, 80, 85, 87, 99, 104, 106, 127, |
| 132, 134, 142, 147, 149, 168, 173, 175, 186, 191, 192, 217, 222, 224, 235, 240, |
| 242, 252, 257, 259, 278, 283, 285, 304, 309, 311, 323, 328, 330, 341, 346, 347, |
| 353, 354, 356, 357, 353, 354, 356, 357, 359, 339, 351, 302, 320, 233, 250, 275, |
| 140, 166, 184, 214, 97, 124, 62, 77, 3, 10, 21, 27, 33, 36, 39, 45, |
| 41, 43, 52, 59, 66, 72, 82, 89, 101, 108, 129, 136, 144, 151, 170, 177, |
| 188, 194, 219, 226, 237, 244, 254, 261, 280, 287, 306, 313, 325, 332, 343, 349, |
| }; |
| public static final String[] jjstrLiteralImages = { |
| "", null, null, null, null, null, null, null, null, null, null, null, null, |
| null, null, null, null, null, null, null, null, null, "\157\162", "\141\156\144", |
| "\144\151\166", "\151\144\151\166", "\155\157\144", "\52", "\151\156", |
| "\143\157\156\164\145\170\164", "\163\141\164\151\163\146\151\145\163", "\162\145\164\165\162\156", |
| "\164\150\145\156", "\145\154\163\145", "\164\157", "\151\156\164\145\162\163\145\143\164", |
| "\165\156\151\157\156", "\145\170\143\145\160\164", null, null, "\151\164\145\155", |
| "\145\154\145\155\145\156\164", "\141\164\164\162\151\142\165\164\145", null, null, null, null, null, null, |
| null, null, null, null, "\156\157\144\145", "\145\155\160\164\171", null, null, |
| "\52", null, null, "\57", "\57\57", "\57", "\57\57", "\75", "\151\163", "\41\75", |
| "\151\163\156\157\164", "\74\75", "\74\74", "\76\75", "\76\76", "\145\161", "\156\145", "\147\164", |
| "\147\145", "\154\164", "\154\145", "\74", "\76", "\55", "\53", "\77", "\174", "\50", |
| "\100", "\133", "\135", "\51", null, null, null, null, null, null, null, null, |
| "\143\157\155\155\145\156\164", "\144\157\143\165\155\145\156\164", null, "\164\145\170\164", |
| "\165\156\164\171\160\145\144", |
| "\160\162\157\143\145\163\163\151\156\147\55\151\156\163\164\162\165\143\164\151\157\156", null, null, null, null, null, "\54", "\56", "\56\56", null, null, null, "\44", |
| null, null, null, "\173", "\173", "\175", null, null, null, null, null, null, null, |
| null, }; |
| public static final String[] lexStateNames = { |
| "DEFAULT", |
| "OPERATOR", |
| "NAMESPACEKEYWORD", |
| "QNAME", |
| "NAMESPACEDECL", |
| "XMLSPACE_DECL", |
| "ITEMTYPE", |
| "VARNAME", |
| "ELEMENT_CONTENT", |
| "START_TAG", |
| "END_TAG", |
| "QUOT_ATTRIBUTE_CONTENT", |
| "APOS_ATTRIBUTE_CONTENT", |
| "CDATA_SECTION", |
| "PROCESSING_INSTRUCTION_CONTENT", |
| "XML_COMMENT", |
| "XQUERY_COMMENT", |
| }; |
| public static final int[] jjnewLexState = { |
| -1, 1, 1, 1, 1, -1, -1, -1, -1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, -1, -1, -1, -1, 4, 2, 2, |
| 3, 0, 1, 0, 0, -1, -1, 1, 1, 1, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 1, 7, 7, 7, 6, 6, 0, -1, -1, 0, 0, -1, |
| 0, 0, 0, 0, 0, 0, 0, -1, -1, 1, 1, -1, -1, -1, 7, 1, 1, -1, 0, 0, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, |
| }; |
| static final long[] jjtoToken = { |
| 0xfe7fffffffffff1fL, 0x3fc7ffeffffffffL, 0x0L, |
| }; |
| static final long[] jjtoSkip = { |
| 0x60L, 0x0L, 0x0L, |
| }; |
| static final long[] jjtoSpecial = { |
| 0x20L, 0x0L, 0x0L, |
| }; |
| private ASCII_CharStream input_stream; |
| private final int[] jjrounds = new int[718]; |
| private final int[] jjstateSet = new int[1436]; |
| StringBuffer image; |
| int jjimageLen; |
| int lengthOfMatch; |
| protected char curChar; |
| public XPathTokenManager(ASCII_CharStream stream) |
| { |
| if (ASCII_CharStream.staticFlag) |
| throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); |
| input_stream = stream; |
| } |
| public XPathTokenManager(ASCII_CharStream stream, int lexState) |
| { |
| this(stream); |
| SwitchTo(lexState); |
| } |
| public void ReInit(ASCII_CharStream stream) |
| { |
| jjmatchedPos = jjnewStateCnt = 0; |
| curLexState = defaultLexState; |
| input_stream = stream; |
| ReInitRounds(); |
| } |
| private final void ReInitRounds() |
| { |
| int i; |
| jjround = 0x80000001; |
| for (i = 718; i-- > 0;) |
| jjrounds[i] = 0x80000000; |
| } |
| public void ReInit(ASCII_CharStream stream, int lexState) |
| { |
| ReInit(stream); |
| SwitchTo(lexState); |
| } |
| public void SwitchTo(int lexState) |
| { |
| if (lexState >= 17 || lexState < 0) |
| throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); |
| else |
| curLexState = lexState; |
| } |
| |
| private final Token jjFillToken() |
| { |
| Token t = Token.newToken(jjmatchedKind); |
| t.kind = jjmatchedKind; |
| String im = jjstrLiteralImages[jjmatchedKind]; |
| t.image = (im == null) ? input_stream.GetImage() : im; |
| t.beginLine = input_stream.getBeginLine(); |
| t.beginColumn = input_stream.getBeginColumn(); |
| t.endLine = input_stream.getEndLine(); |
| t.endColumn = input_stream.getEndColumn(); |
| return t; |
| } |
| |
| int curLexState = 0; |
| int defaultLexState = 0; |
| int jjnewStateCnt; |
| int jjround; |
| int jjmatchedPos; |
| int jjmatchedKind; |
| |
| public final Token getNextToken() |
| { |
| int kind; |
| Token specialToken = null; |
| Token matchedToken; |
| int curPos = 0; |
| |
| EOFLoop : |
| for (;;) |
| { |
| try |
| { |
| curChar = input_stream.BeginToken(); |
| } |
| catch(java.io.IOException e) |
| { |
| jjmatchedKind = 0; |
| matchedToken = jjFillToken(); |
| matchedToken.specialToken = specialToken; |
| return matchedToken; |
| } |
| image = null; |
| jjimageLen = 0; |
| |
| switch(curLexState) |
| { |
| case 0: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_0(); |
| break; |
| case 1: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_1(); |
| break; |
| case 2: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_2(); |
| break; |
| case 3: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_3(); |
| break; |
| case 4: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_4(); |
| break; |
| case 5: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_5(); |
| break; |
| case 6: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_6(); |
| break; |
| case 7: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_7(); |
| break; |
| case 8: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_8(); |
| break; |
| case 9: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_9(); |
| break; |
| case 10: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_10(); |
| break; |
| case 11: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_11(); |
| break; |
| case 12: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_12(); |
| break; |
| case 13: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_13(); |
| break; |
| case 14: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_14(); |
| break; |
| case 15: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_15(); |
| break; |
| case 16: |
| jjmatchedKind = 0x7fffffff; |
| jjmatchedPos = 0; |
| curPos = jjMoveStringLiteralDfa0_16(); |
| break; |
| } |
| if (jjmatchedKind != 0x7fffffff) |
| { |
| if (jjmatchedPos + 1 < curPos) |
| input_stream.backup(curPos - jjmatchedPos - 1); |
| if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) |
| { |
| matchedToken = jjFillToken(); |
| matchedToken.specialToken = specialToken; |
| TokenLexicalActions(matchedToken); |
| if (jjnewLexState[jjmatchedKind] != -1) |
| curLexState = jjnewLexState[jjmatchedKind]; |
| return matchedToken; |
| } |
| else |
| { |
| if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) |
| { |
| matchedToken = jjFillToken(); |
| if (specialToken == null) |
| specialToken = matchedToken; |
| else |
| { |
| matchedToken.specialToken = specialToken; |
| specialToken = (specialToken.next = matchedToken); |
| } |
| } |
| if (jjnewLexState[jjmatchedKind] != -1) |
| curLexState = jjnewLexState[jjmatchedKind]; |
| continue EOFLoop; |
| } |
| } |
| int error_line = input_stream.getEndLine(); |
| int error_column = input_stream.getEndColumn(); |
| String error_after = null; |
| boolean EOFSeen = false; |
| try { input_stream.readChar(); input_stream.backup(1); } |
| catch (java.io.IOException e1) { |
| EOFSeen = true; |
| error_after = curPos <= 1 ? "" : input_stream.GetImage(); |
| if (curChar == '\n' || curChar == '\r') { |
| error_line++; |
| error_column = 0; |
| } |
| else |
| error_column++; |
| } |
| if (!EOFSeen) { |
| input_stream.backup(1); |
| error_after = curPos <= 1 ? "" : input_stream.GetImage(); |
| } |
| throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); |
| } |
| } |
| |
| final void TokenLexicalActions(Token matchedToken) |
| { |
| switch(jjmatchedKind) |
| { |
| case 43 : |
| if (image == null) |
| image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| else |
| image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| pushState(DEFAULT); |
| break; |
| case 44 : |
| if (image == null) |
| image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| else |
| image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| pushState(DEFAULT); |
| break; |
| case 45 : |
| if (image == null) |
| image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| else |
| image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| pushState(DEFAULT); |
| break; |
| case 46 : |
| if (image == null) |
| image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| else |
| image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| pushState(DEFAULT); |
| break; |
| case 94 : |
| if (image == null) |
| image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| else |
| image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| pushState(DEFAULT); |
| break; |
| case 99 : |
| if (image == null) |
| image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| else |
| image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)))); |
| pushState(DEFAULT); |
| break; |
| case 108 : |
| if (image == null) |
| image = new StringBuffer(jjstrLiteralImages[108]); |
| else |
| image.append(jjstrLiteralImages[108]); |
| resetParenStateOrSwitch(DEFAULT); |
| break; |
| case 118 : |
| if (image == null) |
| image = new StringBuffer(jjstrLiteralImages[118]); |
| else |
| image.append(jjstrLiteralImages[118]); |
| pushState(); |
| break; |
| case 119 : |
| if (image == null) |
| image = new StringBuffer(jjstrLiteralImages[119]); |
| else |
| image.append(jjstrLiteralImages[119]); |
| pushState(DEFAULT); |
| break; |
| case 120 : |
| if (image == null) |
| image = new StringBuffer(jjstrLiteralImages[120]); |
| else |
| image.append(jjstrLiteralImages[120]); |
| popState(); |
| break; |
| default : |
| break; |
| } |
| } |
| } |