/* vim: set ts=4 sw=4 tw=99 et:

 *

 * 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 "Zone.h"

#include "Parser.h"

#include "FixedArray.h"

#include "Heap.h"

#include "Strings.h"

#include "Heap-inl.h"

using namespace ke;

Parser::Parser(Zone *zone, CompileContext &cc, const char *stream, size_t length)

  : zone_(zone),

    cc_(cc),

    pool_(zone_->pool()),

    scanner_(cc, stream, length),

    scope_(NULL),

    unbound_(NULL)

{

    unbound_ = new (pool_) PoolList<NameProxy *>();

}

bool

Parser::match(TokenKind kind)

{

    if (scanner_.peek() != kind)

        return false;

    scanner_.scan();

    return true;

}

bool

Parser::matchSemicolon()

{

    return expect(TOK_SEMICOLON);

}

bool

Parser::expect(TokenKind kind)

{

    TokenKind got = scanner_.scan();

    if (got == kind)

        return true;

    cc_.reportError(scanner_.begin(), Message_WrongToken, TokenNames[kind], TokenNames[got]);

    return false;

}

Scope *

Parser::enterScope(Scope::Kind kind)

{

    scope_ = new (pool_) Scope(pool_, kind, scope_);

    if (!scope_->initialize())

        return NULL;

    return scope_;

}

NameProxy *

Parser::bind(Handle<String> name)

{

    BoundName *bound = scope_->lookup(name);

    NameProxy *proxy = new (pool_) NameProxy(scanner_.begin(), name, bound);

    if (!bound && !unbound_->append(proxy))

        return NULL;

    return proxy;

}

bool

Parser::matchName(String **name, TokenKind kind)

{

    assert(kind == TOK_NAME || kind == TOK_LABEL);

    *name = NULL;

    if (!match(kind))

        return false;

    *name = zone_->makeSymbol(scanner_.literal(), scanner_.literal_length());

    return true;

}

String *

Parser::expectName()

{

    if (!expect(TOK_NAME))

        return NULL;

    return zone_->makeSymbol(scanner_.literal(), scanner_.literal_length());

}

void

Parser::redeclarationError(BoundName *other)

{

    cc_.reportError(scanner_.begin(), Message_RedeclaredName, other->name()->chars(),

                    other->pos().line, other->pos().col);

}

Expression *

Parser::primitive()

{

    TokenKind kind = scanner_.peek();

    switch (kind) {

      case TOK_NAME:

      {

        Local<String> name(zone_, expectName());

        if (!name)

            return NULL;

        return bind(name);

      }

      case TOK_FLOAT_LITERAL:

      {

        scanner_.scan();

        double value = Scanner::ParseDouble(scanner_.literal());

        return new (pool_) FloatLiteral(scanner_.begin(), value);

      }

      case TOK_INTEGER_LITERAL:

      {

        scanner_.scan();

        int value = atoi(scanner_.literal());

        return new (pool_) IntegerLiteral(scanner_.begin(), value);

      }

      case TOK_STRING_LITERAL:

      {

        scanner_.scan();

        Local<ByteArray> array(zone_, ByteArray::New(zone_, scanner_.literal_length() + 1));

        if (!array)

            return NULL;

        memcpy(array->raw(), scanner_.literal(), scanner_.literal_length() + 1);

        return new (pool_) StringLiteral(scanner_.begin(), array);

      }

      default:

      {

        if (kind != TOK_ERROR)

            cc_.reportError(scanner_.begin(), Message_ExpectedExpression, TokenNames[kind]);

        return NULL;

      }

    }

}

Expression *

Parser::prefix()

{

    switch (scanner_.peek()) {

      case TOK_LPAREN:

      {

        scanner_.scan();

        Expression *expr = expression();

        if (!expr)

            return NULL;

        if (!expect(TOK_RPAREN))

            return NULL;

        return expr;

      }

      default:

        return primitive();

    }

}

Expression *

Parser::call(Expression *callee)

{

    ExpressionList *arguments = new (pool_) ExpressionList();

    SourcePosition pos = scanner_.begin();

    expect(TOK_LPAREN);

    if (!match(TOK_RPAREN)) {

        while (true) {

            Expression *expr = expression();

            if (!expr)

                return NULL;

            if (!arguments->append(expr))

                return NULL;

            if (!match(TOK_COMMA))

                break;

        }

        if (!expect(TOK_RPAREN))

            return NULL;

    }

    return new (pool_) CallExpression(pos, callee, arguments);

}

Expression *

Parser::index(Expression *left)

{

    expect(TOK_LBRACKET);

    SourcePosition pos = scanner_.begin();

    Expression *expr = expression();

    if (!expr)

        return NULL;

    if (!expect(TOK_RBRACKET))

        return NULL;

    return new (pool_) IndexExpression(pos, left, expr);

}

Expression *

Parser::primary()

{

    Expression *expr = prefix();

    if (!expr)

        return NULL;

    for (;;) {

        switch (scanner_.peek()) {

          case TOK_LPAREN:

            expr = call(expr);

            if (!expr)

                return NULL;

            break;

          case TOK_LBRACKET:

            expr = index(expr);

            if (!expr)

                return NULL;

            break;

          default:

            return expr;

        }

    }

}

Expression *

Parser::unary()

{

    TokenKind token = scanner_.peek();

    SourcePosition pos = scanner_.begin();

    switch (token) {

      case TOK_INCREMENT:

      case TOK_DECREMENT:

      {

        scanner_.scan();

        Expression *expr = expression();

        if (!expr)

            return NULL;

        return new (pool_) IncDecExpression(pos, token, expr, false);

      }

      case TOK_MINUS:

      case TOK_NOT:

      case TOK_TILDE:

      {

        scanner_.scan();

        Expression *expr = expression();

        if (!expr)

            return NULL;

        return new (pool_) UnaryExpression(pos, token, expr);

      }

      default:

        break;

    }

    Expression *expr = primary();

    token = scanner_.peek();

    if (token == TOK_INCREMENT || token == TOK_DECREMENT) {

        scanner_.scan();

        return new (pool_) IncDecExpression(pos, token, expr, true);

    }

    return expr;

}

Expression *

Parser::multiplication()

{

    Expression *left = unary();

    do {

        if (!match(TOK_SLASH) && !match(TOK_STAR))

            break;

        SourcePosition pos = scanner_.begin();

        TokenKind kind = scanner_.last();

        Expression *right = unary();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, kind, left, right);

    } while (left);

    return left;

}

Expression *

Parser::addition()

{

    Expression *left = multiplication();

    while (left) {

        if (!match(TOK_PLUS) && !match(TOK_MINUS))

            break;

        SourcePosition pos = scanner_.begin();

        TokenKind kind = scanner_.last();

        Expression *right = multiplication();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, kind, left, right);

    }

    return left;

}

Expression *

Parser::shift()

{

    Expression *left = addition();

    while (left) {

        if (!match(TOK_SHL) && !match(TOK_SHR) && !match(TOK_USHR))

            break;

        SourcePosition pos = scanner_.begin();

        TokenKind kind = scanner_.last();

        Expression *right = addition();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, kind, left, right);

    }

    return left;

}

Expression *

Parser::bitand_()

{

    Expression *left = shift();

    while (left) {

        if (!match(TOK_BITAND))

            break;

        SourcePosition pos = scanner_.begin();

        Expression *right = shift();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, TOK_BITAND, left, right);

    }

    return left;

}

Expression *

Parser::bitxor()

{

    Expression *left = bitand_();

    while (left) {

        if (!match(TOK_BITXOR))

            break;

        SourcePosition pos = scanner_.begin();

        Expression *right = shift();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, TOK_BITXOR, left, right);

    }

    return left;

}

Expression *

Parser::bitor_()

{

    Expression *left = bitxor();

    while (left) {

        if (!match(TOK_BITOR))

            break;

        SourcePosition pos = scanner_.begin();

        Expression *right = bitxor();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, TOK_BITOR, left, right);

    }

    return left;

}

Expression *

Parser::relational()

{

    Expression *left = bitor_();

    while (left) {

        TokenKind kind = scanner_.peek();

        if (kind < TOK_LT || kind > TOK_GE)

            break;

        scanner_.scan();

        SourcePosition pos = scanner_.begin();

        Expression *right = shift();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, kind, left, right);

    }

    return left;

}

Expression *

Parser::equals()

{

    Expression *left = relational();

    while (left) {

        if (!match(TOK_EQUALS) && !match(TOK_NOTEQUALS))

            break;

        TokenKind kind = scanner_.last();

        SourcePosition pos = scanner_.begin();

        Expression *right = relational();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, kind, left, right);

    }

    return left;

}

Expression *

Parser::and_()

{

    Expression *left = equals();

    while (left) {

        if (!match(TOK_AND))

            break;

        SourcePosition pos = scanner_.begin();

        Expression *right = equals();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, TOK_AND, left, right);

    }

    return left;

}

Expression *

Parser::or_()

{

    Expression *left = and_();

    while (left) {

        if (!match(TOK_OR))

            break;

        SourcePosition pos = scanner_.begin();

        Expression *right = and_();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, TOK_OR, left, right);

    }

    return left;

}

Expression *

Parser::assignment()

{

    Expression *left = or_();

    while (left) {

        TokenKind token = scanner_.peek();

        if (token != TOK_ASSIGN && (token < TOK_ASSIGN_ADD || token > TOK_ASSIGN_SHL))

            break;

        scanner_.scan();

        SourcePosition pos = scanner_.begin();

        Expression *expr = or_();

        if (!expr)

            return NULL;

        left = new (pool_) Assignment(pos, token, left, expr);

    }

    return left;

}

Expression *

Parser::expression()

{

    return assignment();

}

Statement *

Parser::while_()

{

    SourcePosition pos = scanner_.begin();

    scanner_.scan();

    if (!expect(TOK_LPAREN))

        return NULL;

    Expression *condition = expression();

    if (!condition)

        return NULL;

    if (!expect(TOK_RPAREN))

        return NULL;

    // Inside a loop, we force the creation of a scope object. Normally, we

    // will cull scopes if they have no variables. However inside a loop,

    // function calls that take references may compute a LIFO object, and to

    // avoid temporarily leaking many such objects, we ensure that a scope

    // is present so a LIFO slot can be allocated.

    if (!enterScope(Scope::BLOCK))

        return NULL;

    Statement *body;

    if (scanner_.peek() == TOK_LBRACE)

        body = block(scope_);

    else

        body = localStatement();

    if (!body)

        return NULL;

    scope_ = scope_->enclosing();

    return new (pool_) WhileStatement(pos, TOK_WHILE, condition, body);

}

Statement *

Parser::do_()

{

    SourcePosition pos = scanner_.begin();

    scanner_.scan();

    // See the comment in ::while_() as to why we force a scope.

    if (!enterScope(Scope::BLOCK))

        return NULL;

    Statement *body;

    if (scanner_.peek() == TOK_LBRACE)

        body = block(scope_);

    else

        body = localStatement();

    if (!body)

        return NULL;

    scope_ = scope_->enclosing();

    if (!expect(TOK_WHILE))

        return NULL;

    if (!expect(TOK_LPAREN))

        return NULL;

    Expression *condition = expression();

    if (!condition)

        return NULL;

    if (!expect(TOK_RPAREN))

        return NULL;

    return new (pool_) WhileStatement(pos, TOK_DO, condition, body);

}

Statement *

Parser::forStatement()

{

    SourcePosition pos = scanner_.begin();

    scanner_.scan();

    if (!expect(TOK_LPAREN))

        return NULL;

    Statement *decl = NULL;

    if (!match(TOK_SEMICOLON)) {

        if (scanner_.peek() == TOK_NEW) {

            if (!enterScope(Scope::BLOCK))

                return NULL;

            if ((decl = variableDeclaration()) == NULL)

                return NULL;

        } else {

            if ((decl = expressionStatement()) == NULL)

                return NULL;

        }

        if (!expect(TOK_SEMICOLON))

            return NULL;

    }

    Expression *condition = NULL;

    if (!match(TOK_SEMICOLON)) {