/*

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of JITCraft.

 *

 * JITCraft is free software: you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or (at your option)

 * any later version.

 * 

 * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * JITCraft. If not, see http://www.gnu.org/licenses/.

 */

#include <assert.h>

#include <ctype.h>

#include "Scanner.h"

using namespace jc;

const char *jc::TokenNames[] =

{

#define _(name, str) str,

    TOKENMAP(_)

#undef _

    NULL

};

Scanner::Scanner(const char *stream, size_t length)

  : stream_(stream),

    length_(length),

    pushed_(false),

    saved_('\0'),

    pos_(stream_)

{

}

char

Scanner::getChar()

{

    if (saved_ != '\0') {

        char temp = saved_;

        saved_ = '\0';

        return temp;

    }

    if (pos_ >= stream_ + length_)

        return '\0';

    return *pos_++;

}

void

Scanner::putChar(char c)

{

    assert(saved_ == '\0');

    saved_ = c;

}

void

Scanner::eatSingleLine()

{

    char c;

    while ((c = getChar()) != '\0') {

        if (c == '\n' || c == '\r')

            break;

    }

}

bool

Scanner::eatComment()

{

    char c;

    while ((c = getChar()) != '\0') {

        while (c == '*') {

            c = getChar();

            if (c == '\0')

                return false;

            if (c == '/')

                return true;

        }

    }

    return false;

}

static inline bool

IsDigit(char c)

{

    return c >= '0' && c <= '9';

}

// Based off the logic in sc2.c's ftoi()...

double

Scanner::ParseDouble(const char *string)

{

    const char *ptr = string;

    double number = 0.0;

    while (IsDigit(*ptr)) {

        number = (number * 10) + (*ptr - '0');

        ptr++;

    }

    assert(*ptr == '.');

    ptr++;

    double fraction = 0.0;

    double multiplier = 1.0;

    while (IsDigit(*ptr)) {

        fraction = (fraction * 10) + (*ptr - '0');

        multiplier = multiplier / 10.0;

        ptr++;

    }

    number += fraction * multiplier;

    if (*ptr++ == 'e') {

        int sign = 1;

        if (*ptr == '-') {

            sign = -1;

            ptr++;

        }

        int exponent = 0;

        while (IsDigit(*ptr)) {

            exponent = (exponent * 10) + (*ptr - '0');

            ptr++;

        }

        multiplier = pow(10.0, exponent * sign);

        number *= multiplier;

    }

    return number;

}

TokenKind

Scanner::numberLiteral(char first)

{

    literal_ = first;

    char c;

    for (;;) {

        c = getChar();

        if (!IsDigit(c))

            break;

        literal_ += c;

    }

    if (c != '.') {

        putChar(c);

        return TOK_INTEGER_LITERAL;

    }

    literal_ += c;

    c = getChar();

    if (!IsDigit(c)) {

        assert(false);

        return TOK_ERROR;

    }

    literal_ += c;

    for (;;) {

        c = getChar();

        if (!IsDigit(c))

            break;

        literal_ += c;

    }

    if (c != 'e') {

        putChar(c);

    } else {

        literal_ += c;

        c = getChar();

        if (c == '-') {

            literal_ += c;

            c = getChar();

        }

        if (!IsDigit(c)) {

            assert(false);

            return TOK_ERROR;

        }

        literal_ += c;

        for (;;) {

            c = getChar();

            if (!IsDigit(c)) {

                putChar(c);

                break;

            }

            literal_ += c;

        }

    }

    return TOK_FLOAT_LITERAL;

}

TokenKind

Scanner::identifier(char first)

{

    literal_ = first;

    char c;

    for (;;) {

        c = getChar();

        if (!isascii(c) || (!isalnum(c) && c != '_')) {

            if (c != ':')

                putChar(c);

            break;

        }

        literal_ += c;

    }

    if (literal_ == "new")

        return TOK_NEW;

    if (literal_ == "for")

        return TOK_FOR;

    if (literal_ == "return")

        return TOK_RETURN;

    if (literal_ == "if")

        return TOK_IF;

    if (literal_ == "else")

        return TOK_ELSE;

    if (literal_ == "enum")

        return TOK_ENUM;

    if (literal_ == "while")

        return TOK_WHILE;

    if (literal_ == "do")

        return TOK_DO;

    if (literal_ == "break")

        return TOK_BREAK;

    if (literal_ == "continue")

        return TOK_CONTINUE;

    return (c == ':') ? TOK_LABEL : TOK_NAME;

}

TokenKind

Scanner::next()

{

    assert(!pushed_);

    for (;;) {

        char c = getChar();

        switch (c) {

          case '/':

          {

            c = getChar();

            if (c == '/') {

                eatSingleLine();

                break;

            }

            if (c == '*') {

                if (!eatComment())

                    return TOK_ERROR;

                break;

            }

            putChar(c);

            return TOK_SLASH;

          }

          case ';': return TOK_SEMICOLON;

          case '{': return TOK_LBRACE;

          case '}': return TOK_RBRACE;

          case '(': return TOK_LPAREN;

          case ')': return TOK_RPAREN;

          case '[': return TOK_LBRACKET;

          case ']': return TOK_RBRACKET;

          case '*':

            c = getChar();

            if (c == '=')

                return TOK_ASSIGN_MUL;

            putChar(c);

            return TOK_STAR;

          case '+':

            c = getChar();

            if (c == '=')

                return TOK_ASSIGN_ADD;

            putChar(c);

            return TOK_PLUS;

          case '&':

            return TOK_BITAND;

          case '|':

            return TOK_BITOR;

          case '^':

            return TOK_BITXOR;

          case '-': return TOK_MINUS;

          case ',': return TOK_COMMA;

          case '\0': return TOK_EOF;

          case '=':

            c = getChar();

            if (c == '=')

                return TOK_EQUALS;

            putChar(c);

            return TOK_ASSIGN;

          case '<':

            c = getChar();

            if (c == '=')

                return TOK_LE;

            if (c == '<') {

                c = getChar();

                if (c == '=')

                    return TOK_ASSIGN_SHL;

                return TOK_SHL;

            }

            putChar(c);

            return TOK_LT;

          case '>':

            c = getChar();

            if (c == '=')

                return TOK_GE;

            if (c == '>') {

                c = getChar();

                if (c == '>')

                    return TOK_USHR;

                return TOK_SHR;

            }

            putChar(c);

            return TOK_GT;

          case ' ':

          case '\t':

          case '\r':

          case '\f':

          case '\n':

            break;

          default:

            if (c >= '0' && c <= '9')

                return numberLiteral(c);

            if (c == '_' || (isascii(c) && isalpha(c)))

                return identifier(c);

            assert(false);

            return TOK_ERROR;

        }

    }

}

TokenKind

Scanner::scan()

{

    if (pushed_) {

        pushed_ = false;

        return lastToken_;

    }

    lastToken_ = next();

    return lastToken_;

}

TokenKind

Scanner::peek()

{

    if (pushed_)

        return lastToken_;

    scan();

    pushed_ = true;

    return lastToken_;

}