#include "ttokenizer.h"

#include <qstring></qstring>

namespace TSyntax

{

int Token::getIntValue() const

{

	return QString::fromStdString(getText()).toInt();

}

double Token::getDoubleValue() const

{

	return QString::fromStdString(getText()).toDouble();

}

//===================================================================

Tokenizer::Tokenizer()

	: m_buffer(), m_index(0)

{

}

//-------------------------------------------------------------------

Tokenizer::Tokenizer(std::string buffer)

	: m_buffer(), m_index(0)

{

	setBuffer(buffer);

}

//===================================================================

Tokenizer::~Tokenizer()

{

}

//-------------------------------------------------------------------

void Tokenizer::setBuffer(std::string buffer)

{

	m_buffer = buffer + '\0';

	m_index = 0;

	m_tokens.clear();

	bool stringBlock = false;

	int i = 0;

	const char *s = &m_buffer[0];

	for (;;) {

		while (isascii(s[i]) && isspace(s[i]))

			i++;

		int j = i;

		if (s[i] == '\0') {

			m_tokens.push_back(Token("", Token::Eos, j));

			break;

		}

		if (s[i] == '"') {

			stringBlock = !stringBlock;

			m_tokens.push_back(Token("\"", Token::Punct, j));

			++i;

			continue;

		}

		std::string token;

		if (stringBlock) {

			// string block - read mercilessly until either another '"' or EOS

			token = std::string(1, s[i++]);

			while (s[i] != '"' && s[i] != '\0')

				token.append(1, s[i++]);

			m_tokens.push_back(Token(token, Token::Ident, j));

		} else if (isascii(s[i]) && isalpha(s[i]) || s[i] == '_') {

			// ident

			token = std::string(1, s[i++]);

			while (isascii(s[i]) && (isalpha(s[i]) || s[i] == '_' || isdigit(s[i])))

				token.append(1, s[i++]);

			m_tokens.push_back(Token(token, Token::Ident, j));

		} else if (isascii(s[i]) && isdigit(s[i]) || s[i] == '.') {

			// number

			while (isascii(s[i]) && isdigit(s[i]))

				token.append(1, s[i++]);

			if (s[i] == '.') {

				token.append(1, s[i++]);

				while (isascii(s[i]) && isdigit(s[i]))

					token.append(1, s[i++]);

				if ((s[i] == 'e' || s[i] == 'E') &&

					(isascii(s[i + 1]) && isdigit(s[i + 1]) ||

					 (s[i + 1] == '-' || s[i + 1] == '+') &&

						 isascii(s[i + 2]) && isdigit(s[i + 2]))) {

					token.append(1, s[i++]);

					if (s[i] == '-' || s[i] == '+')

						token.append(1, s[i++]);

					while (isascii(s[i]) && isdigit(s[i]))

						token.append(1, s[i++]);

				}

			}

			m_tokens.push_back(Token(token, Token::Number, j));

		} else {

			// punct.

			if (s[i + 1] != '\0') {

				token = std::string(s + i, 2);

				const std::string ss[] = {

					"==", "!=", ">=", "<=", "||", "&&"};

				const int m = tArrayCount(ss);

				if (std::find(ss, ss + m, token) != ss + m)

					i += 2;

				else

					token = std::string(1, s[i++]);

			} else

				token = std::string(1, s[i++]);

			m_tokens.push_back(Token(token, Token::Punct, j));

		}

	}

}

//-------------------------------------------------------------------

int Tokenizer::getTokenCount() const

{

	return m_tokens.size();

}

//-------------------------------------------------------------------

const Token &Tokenizer::getToken(int index) const

{

	assert(0 <= index && index < getTokenCount());

	return m_tokens[index];

}

//-------------------------------------------------------------------

void Tokenizer::reset()

{

	m_index = 0;

}

//-------------------------------------------------------------------

const Token &Tokenizer::getToken()

{

	return getToken(m_index);

}

//-------------------------------------------------------------------

Token Tokenizer::nextToken()

{

	Token token = getToken();

	if (m_index + 1 < getTokenCount())

		m_index++;

	return token;

}

//-------------------------------------------------------------------

bool Tokenizer::eos() const

{

	return m_index + 1 == getTokenCount();

}

//-------------------------------------------------------------------

Token Tokenizer::getTokenFromPos(int pos) const

{

	int len = m_buffer.length();

	if (pos < 0 || pos >= len)

		return Token(pos);

	int x = 0;

	for (int i = 0; i < getTokenCount(); i++) {

		const Token &token = getToken(i);

		int y = token.getPos();

		if (pos < y) {

			assert(x < y);

			return Token(x, y - 1);

		}

		x = y + (int)token.getText().length();

		if (pos < x)

			return token;

	}

	assert(x < len);

	return Token(x, len - 1);

}

//===================================================================

} // TSyntax