Lexer.cpp

#include "Lexer.h"

struct KeywordPair
{
	const char* keyword;
	Lexer::Token token;
};

KeywordPair Keywords[] = {
	{"var", Lexer::Keyword_var},
	{"true", Lexer::Keyword_true},
	{"false", Lexer::Keyword_false}
};

Lexer::Lexer(const QString &sourceText)
	: m_sourceText(sourceText), m_charIndex(0), m_lastChar(' '), m_currentLine(0), m_currentColumn(0)
{
	consumeWhitespace();
}

Lexer::Token Lexer::getNextToken()
{
	if(m_lastChar.isDigit())
	{
		QString numberLiteral;

		do
		{
			numberLiteral += m_lastChar;
			consumeChar();
		}
		while(m_lastChar.isDigit());

		Lexer::Token parsedToken;
		if(m_lastChar == '.')
		{
			do
			{
				numberLiteral += m_lastChar;
				consumeChar();
			}
			while(m_lastChar.isDigit());
			qDebug("FLOAT_LITERAL");
			parsedToken = Lexer::FloatLiteral;
		}
		else
		{
			qDebug("INTEGER_LITERAL");
			parsedToken = Lexer::IntegerLiteral;
		}
		m_lastValue = numberLiteral;

		consumeWhitespace();
		return parsedToken;
	}
	else if(m_lastChar == '"')
	{
		qDebug("STRING_LITERAL");

		consumeChar();

		QString stringLiteral;
		do
		{
			stringLiteral += m_lastChar;
			consumeChar();
		}
		while(m_lastChar != '"');
		consumeChar();

		m_lastValue = stringLiteral;
		consumeWhitespace();
		return Lexer::StringLiteral;
	}
	else if(m_lastChar.isLetter())
	{
		QString identifier;

		do
		{
			identifier += m_lastChar;

			Lexer::Token keyword = isKeyword(identifier);
			if(keyword != Lexer::Invalid)
			{
				consumeChar();
				consumeWhitespace();

				if(keyword == Keyword_true || keyword == Keyword_false)
				{
					qDebug("BOOL_LITERAL");
					m_lastValue = (keyword == Keyword_true ? true : false);
					return BoolLiteral;
				}

				qDebug("KEYWORD");
				return keyword;
			}

			consumeChar();
		}
		while(m_lastChar.isLetterOrNumber());

		qDebug("IDENTIFIER");
		m_lastValue = identifier;

		consumeWhitespace();
		return Lexer::Identifier;
	}
	else
	{
		if (m_charIndex == -1)
		{
			qDebug("EOF");
			return Lexer::EndOfFile;
		}

		Lexer::Token token;

		switch(m_lastChar.toLatin1())
		{
			case '(':
				qDebug("LEFT_PARENTHESIS");
				token = Lexer::LeftParenthesis;
				break;
			case ')':
				qDebug("RIGHT_PARENTHESIS");
				token = Lexer::RightParenthesis;
				break;
			case ',':
				qDebug("COMMA");
				token = Lexer::Comma;
				break;
			case '=':
				qDebug("EQUAL_SIGN");
				token = Lexer::EqualSign;
				break;
			case '+':
				qDebug("PLUS_SIGN");
				token = Lexer::PlusSign;
				break;
			case '-':
				qDebug("MINUS_SIGN");
				token = Lexer::MinusSign;
				break;
			case '*':
				qDebug("MUL_SIGN");
				token = Lexer::MulSign;
				break;
			case '/':
				qDebug("DIV_SIGN");
				token = Lexer::DivSign;
				break;
			case '%':
				qDebug("MODULO_SIGN");
				token = Lexer::ModuloSign;
				break;
			case '.':
				qDebug("SCOPE_OPERATOR");
				token = Lexer::ScopeOperator;
				break;
			default:
				qDebug("Invalid token found !");
				token = Lexer::Invalid;
				break;
		}

		consumeChar();
		consumeWhitespace();
		return token;
	}
}

Lexer::Token Lexer::lookAhead()
{
	QVariant tempLastValue = m_lastValue;
	quint32 tempCharIndex = m_charIndex;
	QChar tempLastChar = m_lastChar;
	int tempCurrentLine = m_currentLine;
	int tempCurrentColumn = m_currentColumn;

	Lexer::Token token = getNextToken();

	m_lastValue = tempLastValue;
	m_charIndex = tempCharIndex;
	m_lastChar = tempLastChar;
	m_currentLine = tempCurrentLine;
	m_currentColumn = tempCurrentColumn;

	return token;
}

void Lexer::consumeChar()
{
	if(m_charIndex == -1)
	{
		m_lastChar = QChar();
		return;
	}

	m_lastChar = m_sourceText[m_charIndex];
	m_charIndex++;
	m_currentColumn++;

	if( m_charIndex > m_sourceText.length() )
	{
		m_charIndex = -1;
		m_lastChar = QChar();
	}
}

void Lexer::consumeWhitespace()
{
	while(m_lastChar.isSpace())
	{
		if(m_lastChar == '\n')
		{
			m_currentLine++;
			m_currentColumn = 0;
		}
		consumeChar();
	}
}

Lexer::Token Lexer::isKeyword(const QString &value) const
{
	static int KeywordCount = sizeof(Keywords) / sizeof(KeywordPair);

	for(int i=0; i<KeywordCount; ++i)
	{
		if(value == QLatin1String(Keywords[i].keyword))
		{
			return Keywords[i].token;
		}
	}

	return Lexer::Invalid;
}