mirror of
https://github.com/pConst/basic_verilog.git
synced 2025-01-14 06:42:54 +08:00
577 lines
16 KiB
Java
577 lines
16 KiB
Java
/* Generated By:JavaCC: Do not edit this line. KCAsmTokenManager.java */
|
|
import java.util.Vector;
|
|
import java.util.Properties;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
|
|
public class KCAsmTokenManager implements KCAsmConstants
|
|
{
|
|
public java.io.PrintStream debugStream = System.out;
|
|
public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
|
|
private final int jjStopStringLiteralDfa_0(int pos, long active0)
|
|
{
|
|
switch (pos)
|
|
{
|
|
default :
|
|
return -1;
|
|
}
|
|
}
|
|
private final int jjStartNfa_0(int pos, long active0)
|
|
{
|
|
return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
|
|
}
|
|
private final int jjStopAtPos(int pos, int kind)
|
|
{
|
|
jjmatchedKind = kind;
|
|
jjmatchedPos = pos;
|
|
return 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 44:
|
|
return jjStopAtPos(0, 15);
|
|
case 59:
|
|
return jjStopAtPos(0, 13);
|
|
default :
|
|
return jjMoveNfa_0(0, 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_0(int startState, int curPos)
|
|
{
|
|
int[] nextStates;
|
|
int startsAt = 0;
|
|
jjnewStateCnt = 22;
|
|
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 ((0x3ff000000000000L & l) != 0L)
|
|
{
|
|
if (kind > 10)
|
|
kind = 10;
|
|
jjCheckNAdd(14);
|
|
}
|
|
else if ((0x2400L & l) != 0L)
|
|
{
|
|
if (kind > 4)
|
|
kind = 4;
|
|
}
|
|
else if (curChar == 39)
|
|
jjstateSet[jjnewStateCnt++] = 16;
|
|
else if (curChar == 36)
|
|
jjCheckNAdd(14);
|
|
else if (curChar == 38)
|
|
jjCheckNAdd(12);
|
|
else if (curChar == 37)
|
|
jjCheckNAdd(8);
|
|
else if (curChar == 40)
|
|
jjstateSet[jjnewStateCnt++] = 4;
|
|
if (curChar == 13)
|
|
jjstateSet[jjnewStateCnt++] = 1;
|
|
break;
|
|
case 1:
|
|
if (curChar == 10 && kind > 4)
|
|
kind = 4;
|
|
break;
|
|
case 2:
|
|
if (curChar == 13)
|
|
jjstateSet[jjnewStateCnt++] = 1;
|
|
break;
|
|
case 3:
|
|
if (curChar == 40)
|
|
jjstateSet[jjnewStateCnt++] = 4;
|
|
break;
|
|
case 5:
|
|
if ((0x3ff000000000000L & l) != 0L)
|
|
jjAddStates(0, 1);
|
|
break;
|
|
case 6:
|
|
if (curChar == 41 && kind > 6)
|
|
kind = 6;
|
|
break;
|
|
case 7:
|
|
if (curChar == 37)
|
|
jjCheckNAdd(8);
|
|
break;
|
|
case 8:
|
|
if ((0x3000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 7)
|
|
kind = 7;
|
|
jjCheckNAdd(8);
|
|
break;
|
|
case 10:
|
|
if ((0xff000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 8)
|
|
kind = 8;
|
|
jjstateSet[jjnewStateCnt++] = 10;
|
|
break;
|
|
case 11:
|
|
if (curChar == 38)
|
|
jjCheckNAdd(12);
|
|
break;
|
|
case 12:
|
|
if ((0x3ff000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 9)
|
|
kind = 9;
|
|
jjCheckNAdd(12);
|
|
break;
|
|
case 13:
|
|
if (curChar == 36)
|
|
jjCheckNAdd(14);
|
|
break;
|
|
case 14:
|
|
if ((0x3ff000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 10)
|
|
kind = 10;
|
|
jjCheckNAdd(14);
|
|
break;
|
|
case 15:
|
|
if (curChar == 39)
|
|
jjstateSet[jjnewStateCnt++] = 16;
|
|
break;
|
|
case 16:
|
|
jjstateSet[jjnewStateCnt++] = 17;
|
|
break;
|
|
case 17:
|
|
if (curChar == 39 && kind > 11)
|
|
kind = 11;
|
|
break;
|
|
case 19:
|
|
if ((0x3ff000000000000L & l) == 0L)
|
|
break;
|
|
if (kind > 5)
|
|
kind = 5;
|
|
jjstateSet[jjnewStateCnt++] = 19;
|
|
break;
|
|
case 20:
|
|
if ((0x3ff000000000000L & l) != 0L)
|
|
jjAddStates(2, 3);
|
|
break;
|
|
case 21:
|
|
if (curChar == 58 && kind > 12)
|
|
kind = 12;
|
|
break;
|
|
default : break;
|
|
}
|
|
} while(i != startsAt);
|
|
}
|
|
else if (curChar < 128)
|
|
{
|
|
long l = 1L << (curChar & 077);
|
|
MatchLoop: do
|
|
{
|
|
switch(jjstateSet[--i])
|
|
{
|
|
case 0:
|
|
if ((0x7fffffe87fffffeL & l) != 0L)
|
|
{
|
|
if (kind > 5)
|
|
kind = 5;
|
|
jjCheckNAddStates(4, 6);
|
|
}
|
|
else if (curChar == 64)
|
|
jjstateSet[jjnewStateCnt++] = 10;
|
|
if ((0x7e0000007eL & l) != 0L)
|
|
{
|
|
if (kind > 10)
|
|
kind = 10;
|
|
jjCheckNAdd(14);
|
|
}
|
|
break;
|
|
case 4:
|
|
case 5:
|
|
if ((0x7fffffe87fffffeL & l) != 0L)
|
|
jjCheckNAddTwoStates(5, 6);
|
|
break;
|
|
case 9:
|
|
if (curChar == 64)
|
|
jjstateSet[jjnewStateCnt++] = 10;
|
|
break;
|
|
case 14:
|
|
if ((0x7e0000007eL & l) == 0L)
|
|
break;
|
|
if (kind > 10)
|
|
kind = 10;
|
|
jjCheckNAdd(14);
|
|
break;
|
|
case 16:
|
|
jjstateSet[jjnewStateCnt++] = 17;
|
|
break;
|
|
case 18:
|
|
if ((0x7fffffe87fffffeL & l) == 0L)
|
|
break;
|
|
if (kind > 5)
|
|
kind = 5;
|
|
jjCheckNAddStates(4, 6);
|
|
break;
|
|
case 19:
|
|
if ((0x7fffffe87fffffeL & l) == 0L)
|
|
break;
|
|
if (kind > 5)
|
|
kind = 5;
|
|
jjCheckNAdd(19);
|
|
break;
|
|
case 20:
|
|
if ((0x7fffffe87fffffeL & l) != 0L)
|
|
jjCheckNAddTwoStates(20, 21);
|
|
break;
|
|
default : break;
|
|
}
|
|
} while(i != startsAt);
|
|
}
|
|
else
|
|
{
|
|
int i2 = (curChar & 0xff) >> 6;
|
|
long l2 = 1L << (curChar & 077);
|
|
MatchLoop: do
|
|
{
|
|
switch(jjstateSet[--i])
|
|
{
|
|
case 16:
|
|
if ((jjbitVec0[i2] & l2) != 0L)
|
|
jjstateSet[jjnewStateCnt++] = 17;
|
|
break;
|
|
default : break;
|
|
}
|
|
} while(i != startsAt);
|
|
}
|
|
if (kind != 0x7fffffff)
|
|
{
|
|
jjmatchedKind = kind;
|
|
jjmatchedPos = curPos;
|
|
kind = 0x7fffffff;
|
|
}
|
|
++curPos;
|
|
if ((i = jjnewStateCnt) == (startsAt = 22 - (jjnewStateCnt = startsAt)))
|
|
return curPos;
|
|
try { curChar = input_stream.readChar(); }
|
|
catch(java.io.IOException e) { return curPos; }
|
|
}
|
|
}
|
|
private final int jjMoveStringLiteralDfa0_1()
|
|
{
|
|
return jjMoveNfa_1(0, 0);
|
|
}
|
|
private final int jjMoveNfa_1(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 ((0xffffffffffffdbffL & l) == 0L)
|
|
break;
|
|
kind = 14;
|
|
jjstateSet[jjnewStateCnt++] = 0;
|
|
break;
|
|
default : break;
|
|
}
|
|
} while(i != startsAt);
|
|
}
|
|
else if (curChar < 128)
|
|
{
|
|
long l = 1L << (curChar & 077);
|
|
MatchLoop: do
|
|
{
|
|
switch(jjstateSet[--i])
|
|
{
|
|
case 0:
|
|
kind = 14;
|
|
jjstateSet[jjnewStateCnt++] = 0;
|
|
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)
|
|
break;
|
|
if (kind > 14)
|
|
kind = 14;
|
|
jjstateSet[jjnewStateCnt++] = 0;
|
|
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; }
|
|
}
|
|
}
|
|
static final int[] jjnextStates = {
|
|
5, 6, 20, 21, 19, 20, 21,
|
|
};
|
|
public static final String[] jjstrLiteralImages = {
|
|
"", null, null, null, null, null, null, null, null, null, null, null, null,
|
|
"\73", null, "\54", };
|
|
public static final String[] lexStateNames = {
|
|
"DEFAULT",
|
|
"IN_COMMENT",
|
|
};
|
|
public static final int[] jjnewLexState = {
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 0, -1,
|
|
};
|
|
static final long[] jjtoToken = {
|
|
0xfff1L,
|
|
};
|
|
static final long[] jjtoSkip = {
|
|
0x6L,
|
|
};
|
|
protected SimpleCharStream input_stream;
|
|
private final int[] jjrounds = new int[22];
|
|
private final int[] jjstateSet = new int[44];
|
|
StringBuffer image;
|
|
int jjimageLen;
|
|
int lengthOfMatch;
|
|
protected char curChar;
|
|
public KCAsmTokenManager(SimpleCharStream stream){
|
|
if (SimpleCharStream.staticFlag)
|
|
throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
|
|
input_stream = stream;
|
|
}
|
|
public KCAsmTokenManager(SimpleCharStream stream, int lexState){
|
|
this(stream);
|
|
SwitchTo(lexState);
|
|
}
|
|
public void ReInit(SimpleCharStream stream)
|
|
{
|
|
jjmatchedPos = jjnewStateCnt = 0;
|
|
curLexState = defaultLexState;
|
|
input_stream = stream;
|
|
ReInitRounds();
|
|
}
|
|
private final void ReInitRounds()
|
|
{
|
|
int i;
|
|
jjround = 0x80000001;
|
|
for (i = 22; i-- > 0;)
|
|
jjrounds[i] = 0x80000000;
|
|
}
|
|
public void ReInit(SimpleCharStream stream, int lexState)
|
|
{
|
|
ReInit(stream);
|
|
SwitchTo(lexState);
|
|
}
|
|
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()
|
|
{
|
|
Token t = Token.newToken(jjmatchedKind);
|
|
t.kind = jjmatchedKind;
|
|
if (jjmatchedPos < 0)
|
|
{
|
|
if (image == null)
|
|
t.image = "";
|
|
else
|
|
t.image = image.toString();
|
|
t.beginLine = t.endLine = input_stream.getBeginLine();
|
|
t.beginColumn = t.endColumn = input_stream.getBeginColumn();
|
|
}
|
|
else
|
|
{
|
|
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 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();
|
|
return matchedToken;
|
|
}
|
|
image = null;
|
|
jjimageLen = 0;
|
|
|
|
switch(curLexState)
|
|
{
|
|
case 0:
|
|
try { input_stream.backup(0);
|
|
while (curChar <= 32 && (0x100000200L & (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 = 14;
|
|
jjmatchedPos = -1;
|
|
curPos = 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();
|
|
TokenLexicalActions(matchedToken);
|
|
if (jjnewLexState[jjmatchedKind] != -1)
|
|
curLexState = jjnewLexState[jjmatchedKind];
|
|
return matchedToken;
|
|
}
|
|
else
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
void TokenLexicalActions(Token matchedToken)
|
|
{
|
|
switch(jjmatchedKind)
|
|
{
|
|
default :
|
|
break;
|
|
}
|
|
}
|
|
}
|