#include "LexicalAnalyzer.h"

LexicalAnalyzer::LexicalAnalyzer(char* src)
{	
	infile.open(src, ios::in);
	assert( infile );
	NUM_OF_STATES = 19;
	transitionTable = new set<int>*[NUM_OF_STATES];
	for ( int i=0; i<NUM_OF_STATES; i++ )
	{
		transitionTable[i] = new set<int>[128];
	}
	isFinal = new bool[NUM_OF_STATES];
	for ( int i=0 ;i<NUM_OF_STATES; i++ )
		isFinal[i] = false;

	//head
	transEpsilon(0,1);
	transEpsilon(0,3);

	//id
	transLetter(1,2);
	transLetter(2,2);
	transDigit(2,2);

	//num
	transDigit(3,4);
	transDigit(4,4);
	transitionTable[4][int('.')].insert(5);
	transitionTable[4][int('e')].insert(8);
	transDigit(5,6);
	transDigit(6,6);
	transitionTable[6][int('e')].insert(8);
	transitionTable[8][int('+')].insert(9);
	transitionTable[8][int('-')].insert(9);
	transEpsilon(8,9);
	transDigit(9,10);
	transDigit(10,10);
	
	//=
	transitionTable[0][int('=')].insert(7);

	//+-*/
	transitionTable[0][int('+')].insert(12);
	transitionTable[0][int('-')].insert(12);
	transitionTable[0][int('*')].insert(12);
	transitionTable[0][int('/')].insert(12);

	//{
	transitionTable[0][int('{')].insert(13);

	//}
	transitionTable[0][int('}')].insert(14);

	//(
	transitionTable[0][int('(')].insert(15);

	//)
	transitionTable[0][int(')')].insert(16);

	//;
	transitionTable[0][int(';')].insert(17);

	//,
	transitionTable[0][int(',')].insert(18);

	isFinal[2] = true;
	isFinal[4] = true;
	isFinal[6] = true;
	isFinal[7] = true;
	isFinal[10] = true;
	isFinal[12] = true;
	isFinal[13] = true;
	isFinal[14] = true;
	isFinal[15] = true;
	isFinal[16] = true;
	isFinal[17] = true;
	isFinal[18] = true;
}

LexicalAnalyzer::~LexicalAnalyzer(void)
{
	for ( int i=0; i<NUM_OF_STATES; i++ )
	{
		delete []transitionTable[i];
	}
	delete []transitionTable;
}


//LexicalAnalyzer* LexicalAnalyzer::getInstance(string src)
//{
//	if ( instance == NULL )
//		instance = new LexicalAnalyzer(src);
//	return instance;
//}


string LexicalAnalyzer::getNextToken(string& token)
{
	int lastAccpState = -1;
	curLexLen = 0;
	char c;
	set<int> intiState;
	intiState.insert(0);
	set<int> S = getEpsilonClosure(intiState);
	c = getNextChar();
	if (c==-1)
	{
		token = "#";
		return "termination";
	}
	while (c!=-1 && !S.empty()) 
	{
		if (c==' '|| c=='\t'|| c=='\n')
		{
			break;
		}
		S = getEpsilonClosure(move(S, c));
		lastAccpState = currentFinalState;
		c = getNextChar();
	}

	token = "";
	while (curLexLen!=0)
	{
		token += innedSq.front();
		curLexLen--;
		innedSq.pop();
	}
	lastSq = innedSq;
	while (!innedSq.empty())
	{
		innedSq.pop();
	}

	switch(lastAccpState)
	{
	case -1:
		return "error";
	case 2:
		if (symbTbl.isKeyword(token))
			return "keyword";
		symbTbl.installId(currentToken);
		return "identifier";
	case 4:
	case 6:
	case 10:
		symbTbl.installNum(currentToken);
		return "number";
	case 7:
		return "assignOp";
	case 12:
		return "arithmeticOP";
	case 13:
		return "leftBrace";
	case 14:
		return "rightBrace";
	case 15:
		return "leftpPrentheses";
	case 16:
		return "rightPrentheses";
	case 17:
		return "semicolon";
	case 18:
		return "comma";
	default:
		assert(false);
	}
}


void LexicalAnalyzer::transLetter(int startState, int endState)
{
	for ( char c='a'; c<='z'; c++ )
		transitionTable[startState][int(c)].insert(endState);
	for ( char c='A'; c<='Z'; c++ )
		transitionTable[startState][int(c)].insert(endState);
}

void LexicalAnalyzer::transDigit(int startState, int endState)
{
	for ( char c='0'; c<='9'; c++ )
		transitionTable[startState][int(c)].insert(endState);
}

void LexicalAnalyzer::transEpsilon(int startState, int endState)
{
	transitionTable[startState][0].insert(endState);
}


set<int> LexicalAnalyzer::getEpsilonClosure(set<int> T)
{
	set<int> ET = T;
	stack<int> s;
	for( set<int>::iterator i = T.begin(); i!=T.end(); ++i)
	{
		s.push(*i);
	}

	while (!s.empty())
	{
		int t = s.top();
		s.pop();
		for ( set<int>::iterator u = transitionTable[t][0].begin(); u!=transitionTable[t][0].end(); ++u )
		{
			if (ET.find(*u)==ET.end())
			{
				ET.insert(*u);
				s.push(*u);
			}
		}
	}
	return ET;
}

set<int> LexicalAnalyzer::move(set<int> s, char a)
{
	set<int> rs;
	for ( set<int>::iterator i = s.begin(); i!=s.end(); ++i)
	{
		set<int> rsi = transitionTable[*i][int(a)];
		for (set<int>::iterator j = rsi.begin(); j!=rsi.end(); ++j)
		{
			if ( rs.find(*j)== rs.end() )
			{
				rs.insert(*j);
				if (isFinal[*j])
				{
					currentFinalState = *j;
					curLexLen = innedSq.size();
				}
			}
		}
	}
	return rs;
}

char LexicalAnalyzer::getNextChar()
{ 
	char c;
	if (!lastSq.empty())
	{
		c = lastSq.front();
		lastSq.pop();
	}
	else 
		c = infile.get();
	if (!(c==' '|| c=='\t'|| c=='\n'||c=='\#'))
		innedSq.push(c);
	return c;
}