javacc-7.0.1.test.cpp.gen.ParserTokenManager.cc Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javacc Show documentation
Show all versions of javacc Show documentation
JavaCC is a parser/scanner generator for Java.
/* ParserTokenManager.cc */
#include "ParserTokenManager.h"
#include "TokenMgrError.h"
namespace SPL {
static const int jjnextStates[] = {0
};
static JJChar jjstrLiteralChars_0[] = {0};
static JJChar jjstrLiteralChars_1[] = {0};
static JJChar jjstrLiteralChars_2[] = {0};
static JJChar jjstrLiteralChars_3[] = {0};
static JJChar jjstrLiteralChars_4[] = {0};
static JJChar jjstrLiteralChars_5[] = {0};
static JJChar jjstrLiteralChars_6[] = {0x69, 0x6e, 0x74, 0};
static JJChar jjstrLiteralChars_7[] = {0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0};
static JJChar jjstrLiteralChars_8[] = {0};
static JJChar jjstrLiteralChars_9[] = {0};
static JJChar jjstrLiteralChars_10[] = {0};
static JJChar jjstrLiteralChars_11[] = {0};
static const JJString jjstrLiteralImages[] = {
jjstrLiteralChars_0,
jjstrLiteralChars_1,
jjstrLiteralChars_2,
jjstrLiteralChars_3,
jjstrLiteralChars_4,
jjstrLiteralChars_5,
jjstrLiteralChars_6,
jjstrLiteralChars_7,
jjstrLiteralChars_8,
jjstrLiteralChars_9,
jjstrLiteralChars_10,
jjstrLiteralChars_11,
};
/** Lexer state names. */
static const JJChar lexStateNames_arr_0[] =
{0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0};
static const JJString lexStateNames[] = {
lexStateNames_arr_0,
};
static const unsigned long long jjtoToken[] = {
0x3c1ULL,
};
static const unsigned long long jjtoSkip[] = {
0x3eULL,
};
void ParserTokenManager::setDebugStream(FILE *ds){ debugStream = ds; }
int ParserTokenManager::jjStopStringLiteralDfa_0(int pos, unsigned long long active0){
switch (pos)
{
case 0:
if ((active0 & 0xc0ULL) != 0L)
{
jjmatchedKind = 9;
return 2;
}
return -1;
case 1:
if ((active0 & 0xc0ULL) != 0L)
{
jjmatchedKind = 9;
jjmatchedPos = 1;
return 2;
}
return -1;
case 2:
if ((active0 & 0x40ULL) != 0L)
return 2;
if ((active0 & 0x80ULL) != 0L)
{
jjmatchedKind = 9;
jjmatchedPos = 2;
return 2;
}
return -1;
case 3:
if ((active0 & 0x80ULL) != 0L)
{
jjmatchedKind = 9;
jjmatchedPos = 3;
return 2;
}
return -1;
case 4:
if ((active0 & 0x80ULL) != 0L)
{
jjmatchedKind = 9;
jjmatchedPos = 4;
return 2;
}
return -1;
case 5:
if ((active0 & 0x80ULL) != 0L)
{
jjmatchedKind = 9;
jjmatchedPos = 5;
return 2;
}
return -1;
default :
return -1;
}
}
int ParserTokenManager::jjStartNfa_0(int pos, unsigned long long active0){
return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
}
int ParserTokenManager::jjStopAtPos(int pos, int kind){
jjmatchedKind = kind;
jjmatchedPos = pos;
return pos + 1;
}
int ParserTokenManager::jjMoveStringLiteralDfa0_0(){
switch(curChar)
{
case 98:
return jjMoveStringLiteralDfa1_0(0x80ULL);
case 105:
return jjMoveStringLiteralDfa1_0(0x40ULL);
default :
return jjMoveNfa_0(1, 0);
}
}
int ParserTokenManager::jjMoveStringLiteralDfa1_0(unsigned long long active0){
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(0, active0);
return 1;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 110:
return jjMoveStringLiteralDfa2_0(active0, 0x40ULL);
case 111:
return jjMoveStringLiteralDfa2_0(active0, 0x80ULL);
default :
break;
}
return jjStartNfa_0(0, active0);
}
int ParserTokenManager::jjMoveStringLiteralDfa2_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(0, old0);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(1, active0);
return 2;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 111:
return jjMoveStringLiteralDfa3_0(active0, 0x80ULL);
case 116:
if ((active0 & 0x40ULL) != 0L)
return jjStartNfaWithStates_0(2, 6, 2);
break;
default :
break;
}
return jjStartNfa_0(1, active0);
}
int ParserTokenManager::jjMoveStringLiteralDfa3_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(1, old0);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(2, active0);
return 3;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 108:
return jjMoveStringLiteralDfa4_0(active0, 0x80ULL);
default :
break;
}
return jjStartNfa_0(2, active0);
}
int ParserTokenManager::jjMoveStringLiteralDfa4_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(2, old0);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(3, active0);
return 4;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 101:
return jjMoveStringLiteralDfa5_0(active0, 0x80ULL);
default :
break;
}
return jjStartNfa_0(3, active0);
}
int ParserTokenManager::jjMoveStringLiteralDfa5_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(3, old0);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(4, active0);
return 5;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 97:
return jjMoveStringLiteralDfa6_0(active0, 0x80ULL);
default :
break;
}
return jjStartNfa_0(4, active0);
}
int ParserTokenManager::jjMoveStringLiteralDfa6_0(unsigned long long old0, unsigned long long active0){
if (((active0 &= old0)) == 0L)
return jjStartNfa_0(4, old0);
if (input_stream->endOfInput()) {
jjStopStringLiteralDfa_0(5, active0);
return 6;
}
curChar = input_stream->readChar();
switch(curChar)
{
case 110:
if ((active0 & 0x80ULL) != 0L)
return jjStartNfaWithStates_0(6, 7, 2);
break;
default :
break;
}
return jjStartNfa_0(5, active0);
}
int ParserTokenManager::jjStartNfaWithStates_0(int pos, int kind, int state){
jjmatchedKind = kind;
jjmatchedPos = pos;
if (input_stream->endOfInput()) { return pos + 1; }
curChar = input_stream->readChar();
return jjMoveNfa_0(state, pos + 1);
}
int ParserTokenManager::jjMoveNfa_0(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)
{
unsigned long long l = 1ULL << curChar;
(void)l;
do
{
switch(jjstateSet[--i])
{
case 1:
case 0:
if ((0x3ff000000000000ULL & l) == 0L)
break;
if (kind > 8)
kind = 8;
{ jjCheckNAdd(0); }
break;
case 2:
if ((0x3ff000000000000ULL & l) == 0L)
break;
if (kind > 9)
kind = 9;
jjstateSet[jjnewStateCnt++] = 2;
break;
default : break;
}
} while(i != startsAt);
}
else if (curChar < 128)
{
unsigned long long l = 1ULL << (curChar & 077);
(void)l;
do
{
switch(jjstateSet[--i])
{
case 1:
case 2:
if ((0x7fffffe07fffffeULL & l) == 0L)
break;
if (kind > 9)
kind = 9;
{ jjCheckNAdd(2); }
break;
default : break;
}
} while(i != startsAt);
}
else
{
int i2 = (curChar & 0xff) >> 6;
unsigned long long l2 = 1ULL << (curChar & 077);
do
{
switch(jjstateSet[--i])
{
default : break;
}
} while(i != startsAt);
}
if (kind != 0x7fffffff)
{
jjmatchedKind = kind;
jjmatchedPos = curPos;
kind = 0x7fffffff;
}
++curPos;
if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 3 - startsAt)))
return curPos;
if (input_stream->endOfInput()) { return curPos; }
curChar = input_stream->readChar();
}
}
/** Token literal values. */
Token * ParserTokenManager::jjFillToken(){
Token *t;
JJString curTokenImage;
int beginLine = -1;
int endLine = -1;
int beginColumn = -1;
int endColumn = -1;
JJString im = jjstrLiteralImages[jjmatchedKind];
curTokenImage = (im.length() == 0) ? input_stream->GetImage() : im;
if (input_stream->getTrackLineColumn()) {
beginLine = input_stream->getBeginLine();
beginColumn = input_stream->getBeginColumn();
endLine = input_stream->getEndLine();
endColumn = input_stream->getEndColumn();
}
t = Token::newToken(jjmatchedKind);
t->kind = jjmatchedKind;
t->image = curTokenImage;
t->specialToken = nullptr;
t->next = nullptr;
if (input_stream->getTrackLineColumn()) {
t->beginLine = beginLine;
t->endLine = endLine;
t->beginColumn = beginColumn;
t->endColumn = endColumn;
}
return t;
}
const int defaultLexState = 0;
/** Get the next Token. */
Token * ParserTokenManager::getNextToken(){
Token *matchedToken = nullptr;
int curPos = 0;
for (;;)
{
EOFLoop:
if (input_stream->endOfInput())
{
jjmatchedKind = 0;
jjmatchedPos = -1;
matchedToken = jjFillToken();
return matchedToken;
}
curChar = input_stream->BeginToken();
{ input_stream->backup(0);
while (curChar <= 32 && (0x100003600ULL & (1ULL << curChar)) != 0L)
{
if (input_stream->endOfInput()) { goto EOFLoop; }
curChar = input_stream->BeginToken();
}
}
jjmatchedKind = 0x7fffffff;
jjmatchedPos = 0;
curPos = jjMoveStringLiteralDfa0_0();
if (jjmatchedKind != 0x7fffffff)
{
if (jjmatchedPos + 1 < curPos)
input_stream->backup(curPos - jjmatchedPos - 1);
if ((jjtoToken[jjmatchedKind >> 6] & (1ULL << (jjmatchedKind & 077))) != 0L)
{
matchedToken = jjFillToken();
return matchedToken;
}
else
{
goto EOFLoop;
}
}
int error_line = input_stream->getEndLine();
int error_column = input_stream->getEndColumn();
JJString error_after;
bool EOFSeen = false;
if (input_stream->endOfInput()) {
EOFSeen = true;
error_after = curPos <= 1 ? EMPTY : input_stream->GetImage();
if (curChar == '\n' || curChar == '\r') {
error_line++;
error_column = 0;
}
else
error_column++;
}
if (!EOFSeen) {
error_after = curPos <= 1 ? EMPTY : input_stream->GetImage();
}
errorHandler->lexicalError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, this);
}
}
/** Reinitialise parser. */
void ParserTokenManager::ReInit(JAVACC_CHARSTREAM *stream, int lexState) {
clear();
jjmatchedPos = jjnewStateCnt = 0;
curLexState = lexState;
input_stream = stream;
ReInitRounds();
debugStream = stdout; // init
SwitchTo(lexState);
errorHandler = new TokenManagerErrorHandler();
}
void ParserTokenManager::ReInitRounds() {
int i;
jjround = 0x80000001;
for (i = 3; i-- > 0;)
jjrounds[i] = 0x80000000;
}
/** Switch to specified lex state. */
void ParserTokenManager::SwitchTo(int lexState) {
if (lexState >= 1 || lexState < 0) {
JJString message;
#ifdef WIDE_CHAR
message += L"Error: Ignoring invalid lexical state : ";
message += lexState; message += L". State unchanged.";
#else
message += "Error: Ignoring invalid lexical state : ";
message += lexState; message += ". State unchanged.";
#endif
throw new TokenMgrError(message, INVALID_LEXICAL_STATE);
} else
curLexState = lexState;
}
/** Constructor. */
ParserTokenManager::ParserTokenManager (JAVACC_CHARSTREAM *stream, int lexState)
{
input_stream = nullptr;
ReInit(stream, lexState);
}
// Destructor
ParserTokenManager::~ParserTokenManager () {
clear();
}
// clear
void ParserTokenManager::clear() {
//Since input_stream was generated outside of TokenManager
//TokenManager should not take care of deleting it
//if (input_stream) delete input_stream;
if (errorHandler) delete errorHandler, errorHandler = nullptr;
}
}