1993 lines
61 KiB
Java
1993 lines
61 KiB
Java
/* Generated By:JJTree&JavaCC: Do not edit this line. FtScriptTokenManager.java */
|
|
package eu.dnetlib.data.collective.transformation.rulelanguage.parser;
|
|
import eu.dnetlib.data.collective.transformation.rulelanguage.Rules;
|
|
|
|
/** Token Manager. */
|
|
public class FtScriptTokenManager implements FtScriptConstants
|
|
{
|
|
|
|
/** Debug output. */
|
|
public java.io.PrintStream debugStream = System.out;
|
|
/** Set debug output. */
|
|
public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
|
|
private final int jjStopStringLiteralDfa_0(int pos, long active0)
|
|
{
|
|
switch (pos)
|
|
{
|
|
case 0:
|
|
if ((active0 & 0x7effffe00L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x20000000000L) != 0L)
|
|
return 76;
|
|
if ((active0 & 0x10000000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
return 19;
|
|
}
|
|
if ((active0 & 0x2L) != 0L)
|
|
return 44;
|
|
if ((active0 & 0x10000000000000L) != 0L)
|
|
return 95;
|
|
if ((active0 & 0x4000000000080L) != 0L)
|
|
return 28;
|
|
return -1;
|
|
case 1:
|
|
if ((active0 & 0x7effff600L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 1;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x10000000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 1;
|
|
return 18;
|
|
}
|
|
if ((active0 & 0x80L) != 0L)
|
|
return 96;
|
|
if ((active0 & 0x800L) != 0L)
|
|
return 95;
|
|
return -1;
|
|
case 2:
|
|
if ((active0 & 0x7eeffd600L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 2;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x10000000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 2;
|
|
return 17;
|
|
}
|
|
if ((active0 & 0x1002000L) != 0L)
|
|
return 95;
|
|
return -1;
|
|
case 3:
|
|
if ((active0 & 0x10000000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 3;
|
|
return 16;
|
|
}
|
|
if ((active0 & 0x7eef7c600L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 3;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x81000L) != 0L)
|
|
return 95;
|
|
return -1;
|
|
case 4:
|
|
if ((active0 & 0x78af7c200L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 4;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x10000000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 4;
|
|
return 12;
|
|
}
|
|
if ((active0 & 0x64000400L) != 0L)
|
|
return 95;
|
|
return -1;
|
|
case 5:
|
|
if ((active0 & 0x182f7c000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 5;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x10000000L) != 0L)
|
|
return 13;
|
|
if ((active0 & 0x608000200L) != 0L)
|
|
return 95;
|
|
return -1;
|
|
case 6:
|
|
if ((active0 & 0x182f48000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 6;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x34000L) != 0L)
|
|
return 95;
|
|
return -1;
|
|
case 7:
|
|
if ((active0 & 0x102f08000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 7;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x80040000L) != 0L)
|
|
return 95;
|
|
return -1;
|
|
case 8:
|
|
if ((active0 & 0x2f08000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 8;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x100000000L) != 0L)
|
|
return 95;
|
|
return -1;
|
|
case 9:
|
|
if ((active0 & 0x608000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 9;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x2900000L) != 0L)
|
|
return 95;
|
|
return -1;
|
|
case 10:
|
|
if ((active0 & 0x608000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 10;
|
|
return 95;
|
|
}
|
|
return -1;
|
|
case 11:
|
|
if ((active0 & 0x608000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 11;
|
|
return 95;
|
|
}
|
|
return -1;
|
|
case 12:
|
|
if ((active0 & 0x608000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 12;
|
|
return 95;
|
|
}
|
|
return -1;
|
|
case 13:
|
|
if ((active0 & 0x408000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 13;
|
|
return 95;
|
|
}
|
|
if ((active0 & 0x200000L) != 0L)
|
|
return 95;
|
|
return -1;
|
|
case 14:
|
|
if ((active0 & 0x408000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 14;
|
|
return 95;
|
|
}
|
|
return -1;
|
|
case 15:
|
|
if ((active0 & 0x408000L) != 0L)
|
|
{
|
|
jjmatchedKind = 65;
|
|
jjmatchedPos = 15;
|
|
return 95;
|
|
}
|
|
return -1;
|
|
default :
|
|
return -1;
|
|
}
|
|
}
|
|
private final int jjStartNfa_0(int pos, long active0)
|
|
{
|
|
return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
|
|
}
|
|
private int jjStopAtPos(int pos, int kind)
|
|
{
|
|
jjmatchedKind = kind;
|
|
jjmatchedPos = pos;
|
|
return pos + 1;
|
|
}
|
|
private int jjMoveStringLiteralDfa0_0()
|
|
{
|
|
switch(curChar)
|
|
{
|
|
case 32:
|
|
return jjStartNfaWithStates_0(0, 1, 44);
|
|
case 33:
|
|
return jjMoveStringLiteralDfa1_0(0x80000000000L);
|
|
case 39:
|
|
return jjStartNfaWithStates_0(0, 41, 76);
|
|
case 40:
|
|
return jjStopAtPos(0, 53);
|
|
case 41:
|
|
return jjStopAtPos(0, 40);
|
|
case 43:
|
|
return jjStopAtPos(0, 48);
|
|
case 44:
|
|
return jjStopAtPos(0, 39);
|
|
case 46:
|
|
return jjMoveStringLiteralDfa1_0(0x8000000000000L);
|
|
case 47:
|
|
jjmatchedKind = 50;
|
|
return jjMoveStringLiteralDfa1_0(0x80L);
|
|
case 59:
|
|
return jjStopAtPos(0, 35);
|
|
case 61:
|
|
return jjStopAtPos(0, 42);
|
|
case 64:
|
|
return jjStartNfaWithStates_0(0, 52, 95);
|
|
case 67:
|
|
return jjMoveStringLiteralDfa1_0(0x10000L);
|
|
case 69:
|
|
return jjMoveStringLiteralDfa1_0(0x4000L);
|
|
case 82:
|
|
return jjMoveStringLiteralDfa1_0(0x20000L);
|
|
case 91:
|
|
return jjStopAtPos(0, 54);
|
|
case 93:
|
|
return jjStopAtPos(0, 36);
|
|
case 97:
|
|
return jjMoveStringLiteralDfa1_0(0x20000000L);
|
|
case 98:
|
|
return jjMoveStringLiteralDfa1_0(0x100000000L);
|
|
case 99:
|
|
return jjMoveStringLiteralDfa1_0(0x400080000L);
|
|
case 100:
|
|
return jjMoveStringLiteralDfa1_0(0x80700000L);
|
|
case 101:
|
|
return jjMoveStringLiteralDfa1_0(0x40003000L);
|
|
case 103:
|
|
return jjMoveStringLiteralDfa1_0(0x40000L);
|
|
case 105:
|
|
return jjMoveStringLiteralDfa1_0(0x8a00L);
|
|
case 108:
|
|
return jjMoveStringLiteralDfa1_0(0x200000000L);
|
|
case 112:
|
|
return jjMoveStringLiteralDfa1_0(0x800000L);
|
|
case 115:
|
|
return jjMoveStringLiteralDfa1_0(0xf000000L);
|
|
case 116:
|
|
return jjMoveStringLiteralDfa1_0(0x400L);
|
|
case 120:
|
|
return jjMoveStringLiteralDfa1_0(0x10000000L);
|
|
case 123:
|
|
return jjStopAtPos(0, 37);
|
|
case 124:
|
|
return jjStopAtPos(0, 49);
|
|
case 125:
|
|
return jjStopAtPos(0, 38);
|
|
default :
|
|
return jjMoveNfa_0(0, 0);
|
|
}
|
|
}
|
|
private int jjMoveStringLiteralDfa1_0(long active0)
|
|
{
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(0, active0);
|
|
return 1;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 46:
|
|
if ((active0 & 0x8000000000000L) != 0L)
|
|
return jjStopAtPos(1, 51);
|
|
break;
|
|
case 47:
|
|
if ((active0 & 0x80L) != 0L)
|
|
return jjStartNfaWithStates_0(1, 7, 96);
|
|
break;
|
|
case 61:
|
|
if ((active0 & 0x80000000000L) != 0L)
|
|
return jjStopAtPos(1, 43);
|
|
break;
|
|
case 98:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x80000000L);
|
|
case 100:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x8000L);
|
|
case 101:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x1760000L);
|
|
case 102:
|
|
if ((active0 & 0x800L) != 0L)
|
|
return jjStartNfaWithStates_0(1, 11, 95);
|
|
break;
|
|
case 107:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x2000000L);
|
|
case 108:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x100001000L);
|
|
case 109:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x40000200L);
|
|
case 110:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x2000L);
|
|
case 111:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x600090000L);
|
|
case 112:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x34000000L);
|
|
case 114:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x800400L);
|
|
case 116:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x8000000L);
|
|
case 120:
|
|
return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(0, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa2_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(0, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(1, active0);
|
|
return 2;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 97:
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x118000400L);
|
|
case 99:
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x700000L);
|
|
case 100:
|
|
if ((active0 & 0x2000L) != 0L)
|
|
return jjStartNfaWithStates_0(2, 13, 95);
|
|
break;
|
|
case 101:
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x808000L);
|
|
case 103:
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x20000L);
|
|
case 105:
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x2000000L);
|
|
case 108:
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x84000000L);
|
|
case 110:
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x400010000L);
|
|
case 111:
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x200000000L);
|
|
case 112:
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x60080200L);
|
|
case 115:
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x1000L);
|
|
case 116:
|
|
if ((active0 & 0x1000000L) != 0L)
|
|
return jjStartNfaWithStates_0(2, 24, 95);
|
|
return jjMoveStringLiteralDfa3_0(active0, 0x44000L);
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(1, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa3_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(1, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(2, active0);
|
|
return 3;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 69:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
|
|
case 86:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x40000L);
|
|
case 99:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x500000000L);
|
|
case 101:
|
|
if ((active0 & 0x1000L) != 0L)
|
|
return jjStartNfaWithStates_0(3, 12, 95);
|
|
break;
|
|
case 105:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
|
|
case 107:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x200000000L);
|
|
case 108:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x20700000L);
|
|
case 110:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x8400L);
|
|
case 111:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x80000200L);
|
|
case 112:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x2800000L);
|
|
case 114:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x4000L);
|
|
case 116:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x58000000L);
|
|
case 118:
|
|
return jjMoveStringLiteralDfa4_0(active0, 0x10000L);
|
|
case 121:
|
|
if ((active0 & 0x80000L) != 0L)
|
|
return jjStartNfaWithStates_0(3, 19, 95);
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(2, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa4_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(2, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(3, active0);
|
|
return 4;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 82:
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x2000000L);
|
|
case 97:
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x400744000L);
|
|
case 101:
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
|
|
case 104:
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x10000000L);
|
|
case 105:
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
|
|
case 107:
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x100000000L);
|
|
case 111:
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x80000000L);
|
|
case 114:
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x800200L);
|
|
case 115:
|
|
if ((active0 & 0x400L) != 0L)
|
|
return jjStartNfaWithStates_0(4, 10, 95);
|
|
break;
|
|
case 116:
|
|
if ((active0 & 0x4000000L) != 0L)
|
|
return jjStartNfaWithStates_0(4, 26, 95);
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x8000L);
|
|
case 117:
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x200000000L);
|
|
case 120:
|
|
return jjMoveStringLiteralDfa5_0(active0, 0x20000L);
|
|
case 121:
|
|
if ((active0 & 0x20000000L) != 0L)
|
|
return jjStartNfaWithStates_0(4, 29, 95);
|
|
else if ((active0 & 0x40000000L) != 0L)
|
|
return jjStartNfaWithStates_0(4, 30, 95);
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(3, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa5_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(3, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(4, active0);
|
|
return 5;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 58:
|
|
if ((active0 & 0x10000000L) != 0L)
|
|
return jjStartNfaWithStates_0(5, 28, 13);
|
|
break;
|
|
case 99:
|
|
if ((active0 & 0x8000000L) != 0L)
|
|
return jjStartNfaWithStates_0(5, 27, 95);
|
|
return jjMoveStringLiteralDfa6_0(active0, 0x4000L);
|
|
case 101:
|
|
return jjMoveStringLiteralDfa6_0(active0, 0x2000000L);
|
|
case 105:
|
|
return jjMoveStringLiteralDfa6_0(active0, 0x8000L);
|
|
case 107:
|
|
return jjMoveStringLiteralDfa6_0(active0, 0x80000000L);
|
|
case 108:
|
|
return jjMoveStringLiteralDfa6_0(active0, 0x100040000L);
|
|
case 111:
|
|
return jjMoveStringLiteralDfa6_0(active0, 0x800000L);
|
|
case 112:
|
|
if ((active0 & 0x200000000L) != 0L)
|
|
return jjStartNfaWithStates_0(5, 33, 95);
|
|
return jjMoveStringLiteralDfa6_0(active0, 0x20000L);
|
|
case 114:
|
|
return jjMoveStringLiteralDfa6_0(active0, 0x710000L);
|
|
case 116:
|
|
if ((active0 & 0x200L) != 0L)
|
|
return jjStartNfaWithStates_0(5, 9, 95);
|
|
else if ((active0 & 0x400000000L) != 0L)
|
|
return jjStartNfaWithStates_0(5, 34, 95);
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(4, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa6_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(4, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(5, active0);
|
|
return 6;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 99:
|
|
return jjMoveStringLiteralDfa7_0(active0, 0x2800000L);
|
|
case 101:
|
|
return jjMoveStringLiteralDfa7_0(active0, 0x700000L);
|
|
case 102:
|
|
return jjMoveStringLiteralDfa7_0(active0, 0x8000L);
|
|
case 105:
|
|
return jjMoveStringLiteralDfa7_0(active0, 0x100000000L);
|
|
case 114:
|
|
if ((active0 & 0x20000L) != 0L)
|
|
return jjStartNfaWithStates_0(6, 17, 95);
|
|
break;
|
|
case 116:
|
|
if ((active0 & 0x4000L) != 0L)
|
|
return jjStartNfaWithStates_0(6, 14, 95);
|
|
else if ((active0 & 0x10000L) != 0L)
|
|
return jjStartNfaWithStates_0(6, 16, 95);
|
|
break;
|
|
case 117:
|
|
return jjMoveStringLiteralDfa7_0(active0, 0x80040000L);
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(5, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa7_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(5, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(6, active0);
|
|
return 7;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 95:
|
|
return jjMoveStringLiteralDfa8_0(active0, 0x700000L);
|
|
case 101:
|
|
if ((active0 & 0x40000L) != 0L)
|
|
return jjStartNfaWithStates_0(7, 18, 95);
|
|
return jjMoveStringLiteralDfa8_0(active0, 0x800000L);
|
|
case 105:
|
|
return jjMoveStringLiteralDfa8_0(active0, 0x8000L);
|
|
case 111:
|
|
return jjMoveStringLiteralDfa8_0(active0, 0x2000000L);
|
|
case 112:
|
|
if ((active0 & 0x80000000L) != 0L)
|
|
return jjStartNfaWithStates_0(7, 31, 95);
|
|
break;
|
|
case 115:
|
|
return jjMoveStringLiteralDfa8_0(active0, 0x100000000L);
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(6, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa8_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(6, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(7, active0);
|
|
return 8;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 101:
|
|
return jjMoveStringLiteralDfa9_0(active0, 0x8000L);
|
|
case 110:
|
|
return jjMoveStringLiteralDfa9_0(active0, 0x100000L);
|
|
case 114:
|
|
return jjMoveStringLiteralDfa9_0(active0, 0x2000000L);
|
|
case 115:
|
|
return jjMoveStringLiteralDfa9_0(active0, 0xe00000L);
|
|
case 116:
|
|
if ((active0 & 0x100000000L) != 0L)
|
|
return jjStartNfaWithStates_0(8, 32, 95);
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(7, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa9_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(7, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(8, active0);
|
|
return 9;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 99:
|
|
return jjMoveStringLiteralDfa10_0(active0, 0x200000L);
|
|
case 100:
|
|
if ((active0 & 0x2000000L) != 0L)
|
|
return jjStartNfaWithStates_0(9, 25, 95);
|
|
break;
|
|
case 114:
|
|
return jjMoveStringLiteralDfa10_0(active0, 0x8000L);
|
|
case 115:
|
|
if ((active0 & 0x100000L) != 0L)
|
|
return jjStartNfaWithStates_0(9, 20, 95);
|
|
else if ((active0 & 0x800000L) != 0L)
|
|
return jjStartNfaWithStates_0(9, 23, 95);
|
|
break;
|
|
case 117:
|
|
return jjMoveStringLiteralDfa10_0(active0, 0x400000L);
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(8, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa10_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(8, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(9, active0);
|
|
return 10;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 69:
|
|
return jjMoveStringLiteralDfa11_0(active0, 0x8000L);
|
|
case 98:
|
|
return jjMoveStringLiteralDfa11_0(active0, 0x400000L);
|
|
case 114:
|
|
return jjMoveStringLiteralDfa11_0(active0, 0x200000L);
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(9, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa11_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(9, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(10, active0);
|
|
return 11;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 105:
|
|
return jjMoveStringLiteralDfa12_0(active0, 0x200000L);
|
|
case 115:
|
|
return jjMoveStringLiteralDfa12_0(active0, 0x400000L);
|
|
case 120:
|
|
return jjMoveStringLiteralDfa12_0(active0, 0x8000L);
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(10, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa12_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(10, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(11, active0);
|
|
return 12;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 99:
|
|
return jjMoveStringLiteralDfa13_0(active0, 0x400000L);
|
|
case 112:
|
|
return jjMoveStringLiteralDfa13_0(active0, 0x200000L);
|
|
case 116:
|
|
return jjMoveStringLiteralDfa13_0(active0, 0x8000L);
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(11, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa13_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(11, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(12, active0);
|
|
return 13;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 114:
|
|
return jjMoveStringLiteralDfa14_0(active0, 0x408000L);
|
|
case 116:
|
|
if ((active0 & 0x200000L) != 0L)
|
|
return jjStartNfaWithStates_0(13, 21, 95);
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(12, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa14_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(12, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(13, active0);
|
|
return 14;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 97:
|
|
return jjMoveStringLiteralDfa15_0(active0, 0x8000L);
|
|
case 105:
|
|
return jjMoveStringLiteralDfa15_0(active0, 0x400000L);
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(13, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa15_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(13, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(14, active0);
|
|
return 15;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 99:
|
|
return jjMoveStringLiteralDfa16_0(active0, 0x8000L);
|
|
case 112:
|
|
return jjMoveStringLiteralDfa16_0(active0, 0x400000L);
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(14, active0);
|
|
}
|
|
private int jjMoveStringLiteralDfa16_0(long old0, long active0)
|
|
{
|
|
if (((active0 &= old0)) == 0L)
|
|
return jjStartNfa_0(14, old0);
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) {
|
|
jjStopStringLiteralDfa_0(15, active0);
|
|
return 16;
|
|
}
|
|
switch(curChar)
|
|
{
|
|
case 116:
|
|
if ((active0 & 0x8000L) != 0L)
|
|
return jjStartNfaWithStates_0(16, 15, 95);
|
|
else if ((active0 & 0x400000L) != 0L)
|
|
return jjStartNfaWithStates_0(16, 22, 95);
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
return jjStartNfa_0(15, active0);
|
|
}
|
|
private 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);
|
|
}
|
|
static final long[] jjbitVec0 = {
|
|
0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
|
|
};
|
|
private int jjMoveNfa_0(int startState, int curPos)
|
|
{
|
|
int startsAt = 0;
|
|
jjnewStateCnt = 95;
|
|
int i = 1;
|
|
jjstateSet[0] = startState;
|
|
int kind = 0x7fffffff;
|
|
for (;;)
|
|
{
|
|
if (++jjround == 0x7fffffff)
|
|
ReInitRounds();
|
|
if (curChar < 64)
|
|
{
|
|
long l = 1L << curChar;
|
|
do
|
|
{
|
|
switch(jjstateSet[--i])
|
|
{
|
|
case 13:
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
else if (curChar == 47)
|
|
jjstateSet[jjnewStateCnt++] = 86;
|
|
else if (curChar == 34)
|
|
jjCheckNAdd(14);
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 58)
|
|
jjstateSet[jjnewStateCnt++] = 92;
|
|
break;
|
|
case 17:
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 58)
|
|
jjstateSet[jjnewStateCnt++] = 92;
|
|
break;
|
|
case 16:
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 58)
|
|
jjstateSet[jjnewStateCnt++] = 92;
|
|
break;
|
|
case 28:
|
|
if (curChar == 42)
|
|
jjCheckNAddTwoStates(34, 35);
|
|
else if (curChar == 47)
|
|
jjCheckNAddStates(0, 2);
|
|
break;
|
|
case 18:
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 58)
|
|
jjstateSet[jjnewStateCnt++] = 92;
|
|
break;
|
|
case 44:
|
|
if (curChar == 38)
|
|
jjstateSet[jjnewStateCnt++] = 60;
|
|
if (curChar == 38)
|
|
jjstateSet[jjnewStateCnt++] = 54;
|
|
if (curChar == 38)
|
|
jjstateSet[jjnewStateCnt++] = 48;
|
|
if (curChar == 38)
|
|
jjstateSet[jjnewStateCnt++] = 43;
|
|
break;
|
|
case 12:
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 58)
|
|
jjstateSet[jjnewStateCnt++] = 92;
|
|
if (curChar == 58)
|
|
jjstateSet[jjnewStateCnt++] = 13;
|
|
break;
|
|
case 19:
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 58)
|
|
jjstateSet[jjnewStateCnt++] = 92;
|
|
break;
|
|
case 95:
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 58)
|
|
jjstateSet[jjnewStateCnt++] = 92;
|
|
break;
|
|
case 96:
|
|
if ((0xffffffffffffdbffL & l) != 0L)
|
|
jjCheckNAddStates(0, 2);
|
|
else if ((0x2400L & l) != 0L)
|
|
{
|
|
if (kind > 5)
|
|
kind = 5;
|
|
}
|
|
if (curChar == 13)
|
|
jjstateSet[jjnewStateCnt++] = 31;
|
|
break;
|
|
case 0:
|
|
if ((0x3ff000000000000L & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAddStates(3, 5);
|
|
}
|
|
else if (curChar == 39)
|
|
jjCheckNAddStates(6, 8);
|
|
else if (curChar == 34)
|
|
jjCheckNAddStates(9, 12);
|
|
else if (curChar == 32)
|
|
jjAddStates(13, 16);
|
|
else if (curChar == 47)
|
|
jjAddStates(17, 18);
|
|
else if (curChar == 36)
|
|
jjstateSet[jjnewStateCnt++] = 25;
|
|
else if (curChar == 37)
|
|
jjstateSet[jjnewStateCnt++] = 10;
|
|
else if (curChar == 60)
|
|
jjstateSet[jjnewStateCnt++] = 4;
|
|
else if (curChar == 62)
|
|
jjstateSet[jjnewStateCnt++] = 2;
|
|
if (curChar == 36)
|
|
jjstateSet[jjnewStateCnt++] = 7;
|
|
else if (curChar == 60)
|
|
{
|
|
if (kind > 45)
|
|
kind = 45;
|
|
}
|
|
else if (curChar == 62)
|
|
{
|
|
if (kind > 44)
|
|
kind = 44;
|
|
}
|
|
break;
|
|
case 76:
|
|
if ((0xffffff7fffffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(74, 75);
|
|
if ((0xffffff7fffffdbffL & l) != 0L)
|
|
jjCheckNAdd(77);
|
|
break;
|
|
case 1:
|
|
if (curChar == 60 && kind > 45)
|
|
kind = 45;
|
|
break;
|
|
case 2:
|
|
if (curChar == 61 && kind > 46)
|
|
kind = 46;
|
|
break;
|
|
case 3:
|
|
if (curChar == 62)
|
|
jjstateSet[jjnewStateCnt++] = 2;
|
|
break;
|
|
case 4:
|
|
if (curChar == 61 && kind > 47)
|
|
kind = 47;
|
|
break;
|
|
case 5:
|
|
if (curChar == 60)
|
|
jjstateSet[jjnewStateCnt++] = 4;
|
|
break;
|
|
case 6:
|
|
if (curChar == 36)
|
|
jjstateSet[jjnewStateCnt++] = 7;
|
|
break;
|
|
case 7:
|
|
if ((0x3ff000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 55)
|
|
kind = 55;
|
|
jjCheckNAdd(8);
|
|
break;
|
|
case 8:
|
|
if ((0x7ff600000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 55)
|
|
kind = 55;
|
|
jjCheckNAdd(8);
|
|
break;
|
|
case 9:
|
|
if (curChar == 37)
|
|
jjstateSet[jjnewStateCnt++] = 10;
|
|
break;
|
|
case 10:
|
|
if ((0x3ff000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 56)
|
|
kind = 56;
|
|
jjCheckNAdd(11);
|
|
break;
|
|
case 11:
|
|
if ((0x7ff600000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 56)
|
|
kind = 56;
|
|
jjCheckNAdd(11);
|
|
break;
|
|
case 14:
|
|
if ((0xfffffffbffffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(14, 15);
|
|
break;
|
|
case 15:
|
|
if (curChar == 34 && kind > 57)
|
|
kind = 57;
|
|
break;
|
|
case 21:
|
|
if (curChar == 46)
|
|
jjCheckNAdd(22);
|
|
break;
|
|
case 22:
|
|
if ((0x3ff000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 58)
|
|
kind = 58;
|
|
jjCheckNAdd(22);
|
|
break;
|
|
case 26:
|
|
if (curChar == 36)
|
|
jjstateSet[jjnewStateCnt++] = 25;
|
|
break;
|
|
case 27:
|
|
if (curChar == 47)
|
|
jjAddStates(17, 18);
|
|
break;
|
|
case 29:
|
|
if ((0xffffffffffffdbffL & l) != 0L)
|
|
jjCheckNAddStates(0, 2);
|
|
break;
|
|
case 30:
|
|
if ((0x2400L & l) != 0L && kind > 5)
|
|
kind = 5;
|
|
break;
|
|
case 31:
|
|
if (curChar == 10 && kind > 5)
|
|
kind = 5;
|
|
break;
|
|
case 32:
|
|
if (curChar == 13)
|
|
jjstateSet[jjnewStateCnt++] = 31;
|
|
break;
|
|
case 33:
|
|
if (curChar == 42)
|
|
jjCheckNAddTwoStates(34, 35);
|
|
break;
|
|
case 34:
|
|
if ((0xfffffbffffffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(34, 35);
|
|
break;
|
|
case 35:
|
|
if (curChar == 42)
|
|
jjAddStates(19, 20);
|
|
break;
|
|
case 36:
|
|
if ((0xffff7fffffffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(37, 35);
|
|
break;
|
|
case 37:
|
|
if ((0xfffffbffffffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(37, 35);
|
|
break;
|
|
case 38:
|
|
if (curChar == 47 && kind > 6)
|
|
kind = 6;
|
|
break;
|
|
case 39:
|
|
if (curChar == 32)
|
|
jjAddStates(13, 16);
|
|
break;
|
|
case 40:
|
|
if (curChar == 32 && kind > 44)
|
|
kind = 44;
|
|
break;
|
|
case 41:
|
|
if (curChar == 59)
|
|
jjstateSet[jjnewStateCnt++] = 40;
|
|
break;
|
|
case 45:
|
|
if (curChar == 32 && kind > 45)
|
|
kind = 45;
|
|
break;
|
|
case 46:
|
|
if (curChar == 59)
|
|
jjstateSet[jjnewStateCnt++] = 45;
|
|
break;
|
|
case 49:
|
|
if (curChar == 38)
|
|
jjstateSet[jjnewStateCnt++] = 48;
|
|
break;
|
|
case 50:
|
|
if (curChar == 32 && kind > 46)
|
|
kind = 46;
|
|
break;
|
|
case 51:
|
|
if (curChar == 61)
|
|
jjstateSet[jjnewStateCnt++] = 50;
|
|
break;
|
|
case 52:
|
|
if (curChar == 59)
|
|
jjstateSet[jjnewStateCnt++] = 51;
|
|
break;
|
|
case 55:
|
|
if (curChar == 38)
|
|
jjstateSet[jjnewStateCnt++] = 54;
|
|
break;
|
|
case 56:
|
|
if (curChar == 32 && kind > 47)
|
|
kind = 47;
|
|
break;
|
|
case 57:
|
|
if (curChar == 61)
|
|
jjstateSet[jjnewStateCnt++] = 56;
|
|
break;
|
|
case 58:
|
|
if (curChar == 59)
|
|
jjstateSet[jjnewStateCnt++] = 57;
|
|
break;
|
|
case 61:
|
|
if (curChar == 38)
|
|
jjstateSet[jjnewStateCnt++] = 60;
|
|
break;
|
|
case 62:
|
|
if (curChar == 34)
|
|
jjCheckNAddStates(9, 12);
|
|
break;
|
|
case 63:
|
|
if ((0xfffffffbffffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(63, 64);
|
|
break;
|
|
case 64:
|
|
if (curChar == 34 && kind > 60)
|
|
kind = 60;
|
|
break;
|
|
case 65:
|
|
if ((0xfffffffbffffdbffL & l) != 0L)
|
|
jjCheckNAddStates(21, 23);
|
|
break;
|
|
case 67:
|
|
if ((0x8400000000L & l) != 0L)
|
|
jjCheckNAddStates(21, 23);
|
|
break;
|
|
case 68:
|
|
if (curChar == 34 && kind > 63)
|
|
kind = 63;
|
|
break;
|
|
case 69:
|
|
if ((0xff000000000000L & l) != 0L)
|
|
jjCheckNAddStates(24, 27);
|
|
break;
|
|
case 70:
|
|
if ((0xff000000000000L & l) != 0L)
|
|
jjCheckNAddStates(21, 23);
|
|
break;
|
|
case 71:
|
|
if ((0xf000000000000L & l) != 0L)
|
|
jjstateSet[jjnewStateCnt++] = 72;
|
|
break;
|
|
case 72:
|
|
if ((0xff000000000000L & l) != 0L)
|
|
jjCheckNAdd(70);
|
|
break;
|
|
case 73:
|
|
if (curChar == 39)
|
|
jjCheckNAddStates(6, 8);
|
|
break;
|
|
case 74:
|
|
if ((0xffffff7fffffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(74, 75);
|
|
break;
|
|
case 75:
|
|
if (curChar == 39 && kind > 61)
|
|
kind = 61;
|
|
break;
|
|
case 77:
|
|
if (curChar == 39 && kind > 62)
|
|
kind = 62;
|
|
break;
|
|
case 79:
|
|
if ((0x8400000000L & l) != 0L)
|
|
jjCheckNAdd(77);
|
|
break;
|
|
case 80:
|
|
if ((0xff000000000000L & l) != 0L)
|
|
jjCheckNAddTwoStates(81, 77);
|
|
break;
|
|
case 81:
|
|
if ((0xff000000000000L & l) != 0L)
|
|
jjCheckNAdd(77);
|
|
break;
|
|
case 82:
|
|
if ((0xf000000000000L & l) != 0L)
|
|
jjstateSet[jjnewStateCnt++] = 83;
|
|
break;
|
|
case 83:
|
|
if ((0xff000000000000L & l) != 0L)
|
|
jjCheckNAdd(81);
|
|
break;
|
|
case 84:
|
|
if ((0x3ff000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAddStates(3, 5);
|
|
break;
|
|
case 85:
|
|
if ((0x7ff600000000000L & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
break;
|
|
case 86:
|
|
if (curChar == 47)
|
|
jjstateSet[jjnewStateCnt++] = 87;
|
|
break;
|
|
case 87:
|
|
if ((0x3ff000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 64)
|
|
kind = 64;
|
|
jjCheckNAddTwoStates(88, 89);
|
|
break;
|
|
case 88:
|
|
if ((0x7ff600000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 64)
|
|
kind = 64;
|
|
jjCheckNAddTwoStates(88, 89);
|
|
break;
|
|
case 89:
|
|
if (curChar != 47)
|
|
break;
|
|
if (kind > 64)
|
|
kind = 64;
|
|
jjstateSet[jjnewStateCnt++] = 90;
|
|
break;
|
|
case 90:
|
|
if ((0x3ff000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 64)
|
|
kind = 64;
|
|
jjCheckNAddTwoStates(91, 89);
|
|
break;
|
|
case 91:
|
|
if ((0x7ff600000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 64)
|
|
kind = 64;
|
|
jjCheckNAddTwoStates(91, 89);
|
|
break;
|
|
case 92:
|
|
if (curChar == 47)
|
|
jjstateSet[jjnewStateCnt++] = 86;
|
|
break;
|
|
case 93:
|
|
if (curChar == 58)
|
|
jjstateSet[jjnewStateCnt++] = 92;
|
|
break;
|
|
case 94:
|
|
if ((0x7ff600000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
break;
|
|
default : break;
|
|
}
|
|
} while(i != startsAt);
|
|
}
|
|
else if (curChar < 128)
|
|
{
|
|
long l = 1L << (curChar & 077);
|
|
do
|
|
{
|
|
switch(jjstateSet[--i])
|
|
{
|
|
case 13:
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
break;
|
|
case 17:
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 116)
|
|
jjstateSet[jjnewStateCnt++] = 16;
|
|
break;
|
|
case 16:
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 104)
|
|
jjstateSet[jjnewStateCnt++] = 12;
|
|
break;
|
|
case 18:
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 97)
|
|
jjstateSet[jjnewStateCnt++] = 17;
|
|
break;
|
|
case 12:
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
break;
|
|
case 19:
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
if (curChar == 112)
|
|
jjstateSet[jjnewStateCnt++] = 18;
|
|
break;
|
|
case 95:
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
}
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
break;
|
|
case 96:
|
|
case 29:
|
|
jjCheckNAddStates(0, 2);
|
|
break;
|
|
case 0:
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
{
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAddStates(3, 5);
|
|
}
|
|
if (curChar == 120)
|
|
jjstateSet[jjnewStateCnt++] = 19;
|
|
break;
|
|
case 76:
|
|
jjCheckNAddTwoStates(74, 75);
|
|
if ((0xffffffffefffffffL & l) != 0L)
|
|
jjCheckNAdd(77);
|
|
else if (curChar == 92)
|
|
jjAddStates(28, 30);
|
|
break;
|
|
case 7:
|
|
case 8:
|
|
if ((0x7fffffe87ffffffL & l) == 0L)
|
|
break;
|
|
if (kind > 55)
|
|
kind = 55;
|
|
jjCheckNAdd(8);
|
|
break;
|
|
case 10:
|
|
case 11:
|
|
if ((0x7fffffe87ffffffL & l) == 0L)
|
|
break;
|
|
if (kind > 56)
|
|
kind = 56;
|
|
jjCheckNAdd(11);
|
|
break;
|
|
case 14:
|
|
jjAddStates(31, 32);
|
|
break;
|
|
case 20:
|
|
if (curChar == 120)
|
|
jjstateSet[jjnewStateCnt++] = 19;
|
|
break;
|
|
case 22:
|
|
if ((0x7fffffe87fffffeL & l) == 0L)
|
|
break;
|
|
if (kind > 58)
|
|
kind = 58;
|
|
jjstateSet[jjnewStateCnt++] = 22;
|
|
break;
|
|
case 23:
|
|
if (curChar == 98)
|
|
jjstateSet[jjnewStateCnt++] = 21;
|
|
break;
|
|
case 24:
|
|
if (curChar == 111)
|
|
jjstateSet[jjnewStateCnt++] = 23;
|
|
break;
|
|
case 25:
|
|
if (curChar == 106)
|
|
jjstateSet[jjnewStateCnt++] = 24;
|
|
break;
|
|
case 34:
|
|
jjCheckNAddTwoStates(34, 35);
|
|
break;
|
|
case 36:
|
|
case 37:
|
|
jjCheckNAddTwoStates(37, 35);
|
|
break;
|
|
case 42:
|
|
if (curChar == 116)
|
|
jjstateSet[jjnewStateCnt++] = 41;
|
|
break;
|
|
case 43:
|
|
if (curChar == 103)
|
|
jjstateSet[jjnewStateCnt++] = 42;
|
|
break;
|
|
case 47:
|
|
if (curChar == 116)
|
|
jjstateSet[jjnewStateCnt++] = 46;
|
|
break;
|
|
case 48:
|
|
if (curChar == 108)
|
|
jjstateSet[jjnewStateCnt++] = 47;
|
|
break;
|
|
case 53:
|
|
if (curChar == 116)
|
|
jjstateSet[jjnewStateCnt++] = 52;
|
|
break;
|
|
case 54:
|
|
if (curChar == 103)
|
|
jjstateSet[jjnewStateCnt++] = 53;
|
|
break;
|
|
case 59:
|
|
if (curChar == 116)
|
|
jjstateSet[jjnewStateCnt++] = 58;
|
|
break;
|
|
case 60:
|
|
if (curChar == 108)
|
|
jjstateSet[jjnewStateCnt++] = 59;
|
|
break;
|
|
case 63:
|
|
jjAddStates(33, 34);
|
|
break;
|
|
case 65:
|
|
if ((0xffffffffefffffffL & l) != 0L)
|
|
jjCheckNAddStates(21, 23);
|
|
break;
|
|
case 66:
|
|
if (curChar == 92)
|
|
jjAddStates(35, 37);
|
|
break;
|
|
case 67:
|
|
if ((0x14404410000000L & l) != 0L)
|
|
jjCheckNAddStates(21, 23);
|
|
break;
|
|
case 74:
|
|
jjCheckNAddTwoStates(74, 75);
|
|
break;
|
|
case 78:
|
|
if (curChar == 92)
|
|
jjAddStates(28, 30);
|
|
break;
|
|
case 79:
|
|
if ((0x14404410000000L & l) != 0L)
|
|
jjCheckNAdd(77);
|
|
break;
|
|
case 84:
|
|
if ((0x7fffffe87ffffffL & l) == 0L)
|
|
break;
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAddStates(3, 5);
|
|
break;
|
|
case 85:
|
|
if ((0x7fffffe87ffffffL & l) != 0L)
|
|
jjCheckNAddTwoStates(85, 93);
|
|
break;
|
|
case 87:
|
|
case 88:
|
|
if ((0x7fffffe87ffffffL & l) == 0L)
|
|
break;
|
|
if (kind > 64)
|
|
kind = 64;
|
|
jjCheckNAddTwoStates(88, 89);
|
|
break;
|
|
case 90:
|
|
case 91:
|
|
if ((0x7fffffe87ffffffL & l) == 0L)
|
|
break;
|
|
if (kind > 64)
|
|
kind = 64;
|
|
jjCheckNAddTwoStates(91, 89);
|
|
break;
|
|
case 94:
|
|
if ((0x7fffffe87ffffffL & l) == 0L)
|
|
break;
|
|
if (kind > 65)
|
|
kind = 65;
|
|
jjCheckNAdd(94);
|
|
break;
|
|
default : break;
|
|
}
|
|
} while(i != startsAt);
|
|
}
|
|
else
|
|
{
|
|
int i2 = (curChar & 0xff) >> 6;
|
|
long l2 = 1L << (curChar & 077);
|
|
do
|
|
{
|
|
switch(jjstateSet[--i])
|
|
{
|
|
case 96:
|
|
case 29:
|
|
if ((jjbitVec0[i2] & l2) != 0L)
|
|
jjCheckNAddStates(0, 2);
|
|
break;
|
|
case 76:
|
|
if ((jjbitVec0[i2] & l2) != 0L)
|
|
jjCheckNAddTwoStates(74, 75);
|
|
if ((jjbitVec0[i2] & l2) != 0L)
|
|
jjstateSet[jjnewStateCnt++] = 77;
|
|
break;
|
|
case 14:
|
|
if ((jjbitVec0[i2] & l2) != 0L)
|
|
jjAddStates(31, 32);
|
|
break;
|
|
case 34:
|
|
if ((jjbitVec0[i2] & l2) != 0L)
|
|
jjCheckNAddTwoStates(34, 35);
|
|
break;
|
|
case 36:
|
|
case 37:
|
|
if ((jjbitVec0[i2] & l2) != 0L)
|
|
jjCheckNAddTwoStates(37, 35);
|
|
break;
|
|
case 63:
|
|
if ((jjbitVec0[i2] & l2) != 0L)
|
|
jjAddStates(33, 34);
|
|
break;
|
|
case 65:
|
|
if ((jjbitVec0[i2] & l2) != 0L)
|
|
jjAddStates(21, 23);
|
|
break;
|
|
case 74:
|
|
if ((jjbitVec0[i2] & l2) != 0L)
|
|
jjCheckNAddTwoStates(74, 75);
|
|
break;
|
|
default : break;
|
|
}
|
|
} while(i != startsAt);
|
|
}
|
|
if (kind != 0x7fffffff)
|
|
{
|
|
jjmatchedKind = kind;
|
|
jjmatchedPos = curPos;
|
|
kind = 0x7fffffff;
|
|
}
|
|
++curPos;
|
|
if ((i = jjnewStateCnt) == (startsAt = 95 - (jjnewStateCnt = startsAt)))
|
|
return curPos;
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) { return curPos; }
|
|
}
|
|
}
|
|
private int jjMoveStringLiteralDfa0_1()
|
|
{
|
|
return jjMoveNfa_1(0, 0);
|
|
}
|
|
private int jjMoveNfa_1(int startState, int curPos)
|
|
{
|
|
int startsAt = 0;
|
|
jjnewStateCnt = 3;
|
|
int i = 1;
|
|
jjstateSet[0] = startState;
|
|
int kind = 0x7fffffff;
|
|
for (;;)
|
|
{
|
|
if (++jjround == 0x7fffffff)
|
|
ReInitRounds();
|
|
if (curChar < 64)
|
|
{
|
|
long l = 1L << curChar;
|
|
do
|
|
{
|
|
switch(jjstateSet[--i])
|
|
{
|
|
case 0:
|
|
if ((0x2400L & l) != 0L)
|
|
{
|
|
if (kind > 8)
|
|
kind = 8;
|
|
}
|
|
if (curChar == 13)
|
|
jjstateSet[jjnewStateCnt++] = 1;
|
|
break;
|
|
case 1:
|
|
if (curChar == 10 && kind > 8)
|
|
kind = 8;
|
|
break;
|
|
case 2:
|
|
if (curChar == 13)
|
|
jjstateSet[jjnewStateCnt++] = 1;
|
|
break;
|
|
default : break;
|
|
}
|
|
} while(i != startsAt);
|
|
}
|
|
else if (curChar < 128)
|
|
{
|
|
long l = 1L << (curChar & 077);
|
|
do
|
|
{
|
|
switch(jjstateSet[--i])
|
|
{
|
|
default : break;
|
|
}
|
|
} while(i != startsAt);
|
|
}
|
|
else
|
|
{
|
|
int i2 = (curChar & 0xff) >> 6;
|
|
long l2 = 1L << (curChar & 077);
|
|
do
|
|
{
|
|
switch(jjstateSet[--i])
|
|
{
|
|
default : break;
|
|
}
|
|
} while(i != startsAt);
|
|
}
|
|
if (kind != 0x7fffffff)
|
|
{
|
|
jjmatchedKind = kind;
|
|
jjmatchedPos = curPos;
|
|
kind = 0x7fffffff;
|
|
}
|
|
++curPos;
|
|
if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
|
|
return curPos;
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) { return curPos; }
|
|
}
|
|
}
|
|
static final int[] jjnextStates = {
|
|
29, 30, 32, 85, 93, 94, 74, 76, 78, 63, 65, 66, 68, 44, 49, 55,
|
|
61, 28, 33, 36, 38, 65, 66, 68, 65, 66, 70, 68, 79, 80, 82, 14,
|
|
15, 63, 64, 67, 69, 71,
|
|
};
|
|
|
|
/** Token literal values. */
|
|
public static final String[] jjstrLiteralImages = {
|
|
"", null, null, null, null, null, null, null, null,
|
|
"\151\155\160\157\162\164", "\164\162\141\156\163", "\151\146", "\145\154\163\145", "\145\156\144",
|
|
"\105\170\164\162\141\143\164", "\151\144\145\156\164\151\146\151\145\162\105\170\164\162\141\143\164",
|
|
"\103\157\156\166\145\162\164", "\122\145\147\105\170\160\162", "\147\145\164\126\141\154\165\145",
|
|
"\143\157\160\171", "\144\145\143\154\141\162\145\137\156\163",
|
|
"\144\145\143\154\141\162\145\137\163\143\162\151\160\164", "\144\145\143\154\141\162\145\137\163\165\142\163\143\162\151\160\164",
|
|
"\160\162\145\160\162\157\143\145\163\163", "\163\145\164", "\163\153\151\160\122\145\143\157\162\144",
|
|
"\163\160\154\151\164", "\163\164\141\164\151\143", "\170\160\141\164\150\72", "\141\160\160\154\171",
|
|
"\145\155\160\164\171", "\144\142\154\157\157\153\165\160", "\142\154\141\143\153\154\151\163\164",
|
|
"\154\157\157\153\165\160", "\143\157\156\143\141\164", "\73", "\135", "\173", "\175", "\54", "\51",
|
|
"\47", "\75", "\41\75", null, null, null, null, "\53", "\174", "\57", "\56\56",
|
|
"\100", "\50", "\133", null, null, null, null, null, null, null, null, null, null,
|
|
null, null, null, null, null, };
|
|
|
|
/** Lexer state names. */
|
|
public static final String[] lexStateNames = {
|
|
"DEFAULT",
|
|
"IN_SINGLE_LINE_COMMENT",
|
|
};
|
|
|
|
/** Lex State array. */
|
|
public static final int[] jjnewLexState = {
|
|
-1, -1, -1, -1, -1, -1, -1, 1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
};
|
|
static final long[] jjtoToken = {
|
|
0xf7fffffffffffe01L, 0x3L,
|
|
};
|
|
static final long[] jjtoSkip = {
|
|
0x17eL, 0x0L,
|
|
};
|
|
static final long[] jjtoSpecial = {
|
|
0x100L, 0x0L,
|
|
};
|
|
static final long[] jjtoMore = {
|
|
0x80L, 0x0L,
|
|
};
|
|
protected SimpleCharStream input_stream;
|
|
private final int[] jjrounds = new int[95];
|
|
private final int[] jjstateSet = new int[190];
|
|
private final StringBuilder jjimage = new StringBuilder();
|
|
private StringBuilder image = jjimage;
|
|
private int jjimageLen;
|
|
private int lengthOfMatch;
|
|
protected char curChar;
|
|
/** Constructor. */
|
|
public FtScriptTokenManager(SimpleCharStream stream){
|
|
if (SimpleCharStream.staticFlag)
|
|
throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
|
|
input_stream = stream;
|
|
}
|
|
|
|
/** Constructor. */
|
|
public FtScriptTokenManager(SimpleCharStream stream, int lexState){
|
|
this(stream);
|
|
SwitchTo(lexState);
|
|
}
|
|
|
|
/** Reinitialise parser. */
|
|
public void ReInit(SimpleCharStream stream)
|
|
{
|
|
jjmatchedPos = jjnewStateCnt = 0;
|
|
curLexState = defaultLexState;
|
|
input_stream = stream;
|
|
ReInitRounds();
|
|
}
|
|
private void ReInitRounds()
|
|
{
|
|
int i;
|
|
jjround = 0x80000001;
|
|
for (i = 95; i-- > 0;)
|
|
jjrounds[i] = 0x80000000;
|
|
}
|
|
|
|
/** Reinitialise parser. */
|
|
public void ReInit(SimpleCharStream stream, int lexState)
|
|
{
|
|
ReInit(stream);
|
|
SwitchTo(lexState);
|
|
}
|
|
|
|
/** Switch to specified lex state. */
|
|
public void SwitchTo(int lexState)
|
|
{
|
|
if (lexState >= 2 || lexState < 0)
|
|
throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
|
|
else
|
|
curLexState = lexState;
|
|
}
|
|
|
|
protected Token jjFillToken()
|
|
{
|
|
final Token t;
|
|
final String curTokenImage;
|
|
final int beginLine;
|
|
final int endLine;
|
|
final int beginColumn;
|
|
final int endColumn;
|
|
String im = jjstrLiteralImages[jjmatchedKind];
|
|
curTokenImage = (im == null) ? input_stream.GetImage() : im;
|
|
beginLine = input_stream.getBeginLine();
|
|
beginColumn = input_stream.getBeginColumn();
|
|
endLine = input_stream.getEndLine();
|
|
endColumn = input_stream.getEndColumn();
|
|
t = Token.newToken(jjmatchedKind, curTokenImage);
|
|
|
|
t.beginLine = beginLine;
|
|
t.endLine = endLine;
|
|
t.beginColumn = beginColumn;
|
|
t.endColumn = endColumn;
|
|
|
|
return t;
|
|
}
|
|
|
|
int curLexState = 0;
|
|
int defaultLexState = 0;
|
|
int jjnewStateCnt;
|
|
int jjround;
|
|
int jjmatchedPos;
|
|
int jjmatchedKind;
|
|
|
|
/** Get the next Token. */
|
|
public Token getNextToken()
|
|
{
|
|
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 = jjimage;
|
|
image.setLength(0);
|
|
jjimageLen = 0;
|
|
|
|
for (;;)
|
|
{
|
|
switch(curLexState)
|
|
{
|
|
case 0:
|
|
try { input_stream.backup(0);
|
|
while (curChar <= 13 && (0x2600L & (1L << curChar)) != 0L)
|
|
curChar = input_stream.BeginToken();
|
|
}
|
|
catch (java.io.IOException e1) { continue EOFLoop; }
|
|
jjmatchedKind = 0x7fffffff;
|
|
jjmatchedPos = 0;
|
|
curPos = jjMoveStringLiteralDfa0_0();
|
|
break;
|
|
case 1:
|
|
jjmatchedKind = 0x7fffffff;
|
|
jjmatchedPos = 0;
|
|
curPos = jjMoveStringLiteralDfa0_1();
|
|
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;
|
|
if (jjnewLexState[jjmatchedKind] != -1)
|
|
curLexState = jjnewLexState[jjmatchedKind];
|
|
return matchedToken;
|
|
}
|
|
else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
|
|
{
|
|
if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
|
|
{
|
|
matchedToken = jjFillToken();
|
|
if (specialToken == null)
|
|
specialToken = matchedToken;
|
|
else
|
|
{
|
|
matchedToken.specialToken = specialToken;
|
|
specialToken = (specialToken.next = matchedToken);
|
|
}
|
|
SkipLexicalActions(matchedToken);
|
|
}
|
|
else
|
|
SkipLexicalActions(null);
|
|
if (jjnewLexState[jjmatchedKind] != -1)
|
|
curLexState = jjnewLexState[jjmatchedKind];
|
|
continue EOFLoop;
|
|
}
|
|
jjimageLen += jjmatchedPos + 1;
|
|
if (jjnewLexState[jjmatchedKind] != -1)
|
|
curLexState = jjnewLexState[jjmatchedKind];
|
|
curPos = 0;
|
|
jjmatchedKind = 0x7fffffff;
|
|
try {
|
|
curChar = input_stream.readChar();
|
|
continue;
|
|
}
|
|
catch (java.io.IOException e1) { }
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SkipLexicalActions(Token matchedToken)
|
|
{
|
|
switch(jjmatchedKind)
|
|
{
|
|
default :
|
|
break;
|
|
}
|
|
}
|
|
private void jjCheckNAdd(int state)
|
|
{
|
|
if (jjrounds[state] != jjround)
|
|
{
|
|
jjstateSet[jjnewStateCnt++] = state;
|
|
jjrounds[state] = jjround;
|
|
}
|
|
}
|
|
private void jjAddStates(int start, int end)
|
|
{
|
|
do {
|
|
jjstateSet[jjnewStateCnt++] = jjnextStates[start];
|
|
} while (start++ != end);
|
|
}
|
|
private void jjCheckNAddTwoStates(int state1, int state2)
|
|
{
|
|
jjCheckNAdd(state1);
|
|
jjCheckNAdd(state2);
|
|
}
|
|
|
|
private void jjCheckNAddStates(int start, int end)
|
|
{
|
|
do {
|
|
jjCheckNAdd(jjnextStates[start]);
|
|
} while (start++ != end);
|
|
}
|
|
|
|
}
|