/*

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

using namespace jc;

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

  : pool_(ZONE()->pool()),

    strings_(pool_),

    scanner_(stream, length),

    scope_(NULL),

    unbound_(NULL)

{

    unbound_ = new std::vector<NameProxy *>();

}

bool

Parser::match(TokenKind kind)

{

    if (scanner_.peek() != kind)

        return false;

    scanner_.scan();

    return true;

}

bool

Parser::expect(TokenKind kind)

{

    TokenKind got = scanner_.scan();

    if (got == kind)

        return true;

    fprintf(stderr, "error: expected %s, got %s\n", 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(Name *name)

{

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

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

    if (!bound)

        unbound_->push_back(proxy);

    return proxy;

}

bool

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

{

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

    *name = NULL;

    if (!match(kind))

        return false;

    *name = strings_.add(scanner_.literal());

    return true;

}

Name *

Parser::expectName()

{

    if (!expect(TOK_NAME))

        return NULL;

    return strings_.add(scanner_.literal());

}

Expression *

Parser::primitive()

{

    switch (scanner_.peek()) {

      case TOK_NAME:

      {

        scanner_.scan();

        Name *name = strings_.add(scanner_.literal());

        return bind(name);

      }

      case TOK_FLOAT_LITERAL:

      {

        scanner_.scan();

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

        return new (pool_) FloatLiteral(value);

      }

      case TOK_INTEGER_LITERAL:

      {

        scanner_.scan();

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

        return new (pool_) IntegerLiteral(value);

      }

      case TOK_STRING_LITERAL:

      {

        // :TODO: Local

        scanner_.scan();

        ByteArray *array = ByteArray::New(ZONE(), scanner_.literal_length());

        if (!array)

            return NULL;

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

        return new (pool_) StringLiteral(array);

      }

      default:

      {

        fprintf(stderr, "error: expected expression!\n");

        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 ExpressionList();

    expect(TOK_LPAREN);

    if (!match(TOK_RPAREN)) {

        while (true) {

            Expression *expr = expression();

            if (!expr)

                return NULL;

            arguments->push_back(expr);

            if (!match(TOK_COMMA))

                break;

        }

        if (!expect(TOK_RPAREN))

            return NULL;

    }

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

}

Expression *

Parser::index(Expression *left)

{

    expect(TOK_LBRACKET);

    Expression *expr = expression();

    if (!expr)

        return NULL;

    if (!expect(TOK_RBRACKET))

        return NULL;

    return new (pool_) IndexExpression(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()

{

    return primary();

}

Expression *

Parser::multiplication()

{

    Expression *left = unary();

    do {

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

            break;

        TokenKind kind = scanner_.last();

        Expression *right = unary();

        if (!right)

            return NULL;

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

    } while (left);

    return left;

}

Expression *

Parser::addition()

{

    Expression *left = multiplication();

    while (left) {

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

            break;

        TokenKind kind = scanner_.last();

        Expression *right = multiplication();

        if (!right)

            return NULL;

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

    }

    return left;

}

Expression *

Parser::shift()

{

    Expression *left = addition();

    while (left) {

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

            break;

        TokenKind kind = scanner_.last();

        Expression *right = addition();

        if (!right)

            return NULL;

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

    }

    return left;

}

Expression *

Parser::bitand()

{

    Expression *left = shift();

    while (left) {

        if (!match(TOK_BITAND))

            break;

        Expression *right = shift();

        if (!right)

            return NULL;

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

    }

    return left;

}

Expression *

Parser::bitxor()

{

    Expression *left = bitand();

    while (left) {

        if (!match(TOK_BITXOR))

            break;

        Expression *right = shift();

        if (!right)

            return NULL;

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

    }

    return left;

}

Expression *

Parser::bitor()

{

    Expression *left = bitxor();

    while (left) {

        if (!match(TOK_BITOR))

            break;

        Expression *right = shift();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(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();

        Expression *right = shift();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(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();

        Expression *right = relational();

        if (!right)

            return NULL;

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

    }

    return left;

}

Expression *

Parser::assignment()

{

    Expression *left = equals();

    while (left) {

        TokenKind token = scanner_.peek();

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

            break;

        scanner_.scan();

        Expression *expr = equals();

        if (!expr)

            return NULL;

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

    }

    return left;

}

Expression *

Parser::expression()

{

    return assignment();

}

Statement *

Parser::while_()

{

    scanner_.scan();

    if (!expect(TOK_LPAREN))

        return NULL;

    Expression *condition = expression();

    if (!condition)

        return NULL;

    if (!expect(TOK_RPAREN))

        return NULL;

    Statement *body = localStatement();

    if (!body)

        return NULL;

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

}

Statement *

Parser::do_()

{

    scanner_.scan();

    Statement *body = block();

    if (!body)

        return NULL;

    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(TOK_DO, condition, body);

}

Statement *

Parser::forStatement()

{

    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)) {

        if ((condition = expression()) == NULL)

            return NULL;

        if (!expect(TOK_SEMICOLON))

            return NULL;

    }

    Statement *update = NULL;

    if (!match(TOK_RPAREN)) {

        if ((update = expressionStatement()) == NULL)

            return NULL;

        if (!expect(TOK_RPAREN))

            return NULL;

    }

    Statement *body = localStatement();

    if (!body)

        return NULL;

    Scope *blockScope = NULL;

    if (decl && decl->isVariableDeclaration()) {

        blockScope = scope_->unlinkIfEmpty();

        scope_ = scope_->enclosing();

    }

    return new (pool_) ForStatement(blockScope, decl, condition, update, body);

}

VariableDeclaration *

Parser::variableDeclaration()

{

    if (!expect(TOK_NEW))

        return NULL;

    Name *tag;

    if (matchName(&tag, TOK_LABEL) && !tag)

        return NULL;

    Name *name = expectName();

    if (!name)

        return NULL;

    ExpressionList *postDimensions = NULL;

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

        postDimensions = new ExpressionList();

        while (match(TOK_LBRACKET)) {

            Expression *dim = expression();

            if (!dim)

                return NULL;

            if (!expect(TOK_RBRACKET))

                return NULL;

            postDimensions->push_back(dim);

        }

    }

    Expression *expr = NULL;

    if (match(TOK_ASSIGN)) {

        if ((expr = expression()) == NULL)

            return NULL;

    }

    if (scope_->localLookup(name)) {

        redeclarationError();

        return NULL;

    }

    Variable *var = scope_->declareVariable(name);

    VariableDeclaration *decl = new (pool_) VariableDeclaration(var, tag, postDimensions, expr);

    return decl;

}

Statement *

Parser::returnStatement()

{

    if (!expect(TOK_RETURN))

        return NULL;

    Expression *expr = expression();

    if (!expr)

        return NULL;

    return new (pool_) ReturnStatement(expr);

}

Statement *

Parser::expressionStatement()

{

    Expression *left = assignment();

    if (!left)

        return NULL;

    return new (pool_) ExpressionStatement(left);

}

Statement *

Parser::block()

{

    if (!expect(TOK_LBRACE))

        return NULL;

    if (!enterScope(Scope::BLOCK))

        return NULL;

    StatementList *statements = new (pool_) StatementList();

    while (!match(TOK_RBRACE)) {

        Statement *statement = localStatement();

        if (statement == NULL)

            return NULL;

        statements->append(pool_, statement);

    }

    Scope *blockScope = scope_->unlinkIfEmpty();

    BlockStatement *block = new (pool_) BlockStatement(blockScope, statements);

    scope_ = scope_->enclosing();

    return block;

}

Statement *

Parser::if_()

{

    expect(TOK_IF);

    if (!expect(TOK_LPAREN))

        return NULL;

    Expression *cond = expression();

    if (!cond)

        return NULL;

    if (!expect(TOK_RPAREN))

        return NULL;

    Statement *ifTrue = localStatement();

    if (!ifTrue)

        return NULL;

    IfStatement *outer = new (pool_) IfStatement(cond, ifTrue);