#include "ttokenizer.h"
#include <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