/*

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

#include "Types.h"

#include "Zone.h"

#include "TypeManager.h"

#include "Scopes.h"

using namespace jc;

static inline bool

IsPrimitiveType(Type *type, PrimitiveType primitive)

{

    if (!type)

        return false;

    if (!type->isPrimitive())

        return false;

    return primitive == type->primitive();

}

static inline bool

EvaluateBinaryOperation(TokenKind kind, const BoxedPrimitive &left, const BoxedPrimitive &right,

                        BoxedPrimitive *out)

{

    switch (kind) {

      case TOK_PLUS:

        *out = BoxedPrimitive::Int(left.toInt() + right.toInt());

        return true;

      case TOK_SHL:

        *out = BoxedPrimitive::Int(left.toInt() << right.toInt());

        return true;

    }

    return true;

}

static bool

EvaluateForConstant(Expression *expression, BoxedPrimitive *out)

{

    switch (expression->kind()) {

      case AstNode::kBinaryExpression:

      {

        BoxedPrimitive left;

        BoxedPrimitive right;

        BinaryExpression *b = expression->toBinaryExpression();

        if (!EvaluateForConstant(b->left(), &left) ||

            !EvaluateForConstant(b->right(), &right))

        {

            return false;

        }

        return EvaluateBinaryOperation(b->token(), left, right, out);

      }

      case AstNode::kNameProxy:

      {

        NameProxy *proxy = expression->toNameProxy();

        if (proxy->binding()->kind() != BoundName::CONSTANT)

            return false;

        NamedConstant *c = proxy->binding()->toNamedConstant();

        if (!IsPrimitiveType(c->type(), PrimitiveType_Int32))

            return false;

        *out = c->value();

        return true;

      }

      case AstNode::kIntegerLiteral:

        *out = BoxedPrimitive::Int(expression->toIntegerLiteral()->value());

        return true;

      default:

        return false;

    }

}

SemanticAnalysis::SemanticAnalysis(ParseTree *tree)

  : tree_(tree),

    loopDepth_(0),

    scope_(NULL)

{

}

bool

SemanticAnalysis::analyze()

{

    for (size_t i = 0; i < tree_->statements()->length(); i++) {

        Statement *statement = tree_->statements()->at(i);

        statement->accept(this);

    }

    return true;

}

void

SemanticAnalysis::visit(NameProxy *name)

{

    name->setType(name->binding()->type());

}

Type *

SemanticAnalysis::visitForLoad(Expression *expression)

{

    expression->accept(this);

    if (expression->type()) {

        // :TODO: use Local

        Type *type = expression->type();

        if (type->isArray() || type->isReference())

            expression->setType(type->contained());

    }

    return expression->type();

}

Type *

SemanticAnalysis::visitForRef(Expression *expression)

{

    expression->accept(this);

    return expression->type();

}

static inline bool

TypeCheck(Type *left, Type *right)

{

    if (!left || !right)

        return false;

    if (left->isPrimitive()) {

        if (!right->isPrimitive())

            return false;

        return left->primitive() == right->primitive();

    }

    return false;

}

void

SemanticAnalysis::visit(Assignment *node)

{

    visitForLoad(node->expression());

    if (node->lvalue()->isIndexExpression()) {

        node->lvalue()->accept(this);

        node->setType(node->lvalue()->type()->contained());

    } else {

        NameProxy *proxy = node->lvalue()->toNameProxy();

        if (!proxy->binding()->kind() == BoundName::VARIABLE) {

            fprintf(stderr, "error\n");

            return;

        }

        Variable *var = proxy->binding()->toVariable();

        if  (var->type()->isReference())

            node->setType(var->type()->contained());

        else

            node->setType(var->type());

    }

    assert(TypeCheck(node->type(), node->expression()->type()));

}

void

SemanticAnalysis::visit(BinaryExpression *node)

{

    Type *left = visitForLoad(node->left());

    Type *right = visitForLoad(node->right());

    if (node->token() >= TOK_PLUS && node->token() <= TOK_SLASH) {

        // Both sides must be primitive.

        if (!left || !right)

            return;

        // If either side is a float, the other side must be a float or int.

        if (left->isFloat() || right->isFloat()) {

            assert(left->isFloat() || left->isInt());

            assert(right->isFloat() || right->isInt());

            node->setType(left->isFloat() ? left : right);

            return;

        }

    }

    // For now, assert everything else is integer and untagged.

    assert(left->isInt() && right->isInt());

    assert(!left->tag() && !right->tag());

    node->setType(left);

}

void

SemanticAnalysis::visit(ReturnStatement *node)

{

    visitForLoad(node->expression());

    // :TODO: type check

}

void

SemanticAnalysis::visit(ForStatement *node)

{

    loopDepth_++;

    if (node->scope())

        scope_ = node->scope();

    if (node->declaration())

        node->declaration()->accept(this);

    if (node->condition())

        visitForLoad(node->condition());

    if (node->update())

        node->update()->accept(this);

    node->body()->accept(this);

    if (node->scope())

        scope_ = scope_->enclosing();

    loopDepth_--;

}

void 

SemanticAnalysis::visit(WhileStatement *node)

{

    loopDepth_++;

    node->condition()->accept(this);

    node->body()->accept(this);

    loopDepth_--;

}

void

SemanticAnalysis::visit(BlockStatement *node)

{

    if (node->scope())

        scope_ = node->scope();

    for (size_t i = 0; i < node->statements()->length(); i++) {

        Statement *statement = node->statements()->at(i);

        statement->accept(this);

    }

    if (node->scope())

        scope_ = scope_->enclosing();

}

void

SemanticAnalysis::visit(VariableDeclaration *node)

{

    // :TODO: use locals

    Type *type = ZONE()->types()->getPrimitiveForTag(node->tag());

    if (!type)

        return;

    if (node->postDimensions()) {

        if (node->postDimensions()->size() > Type::MAX_UNSAFE_ARRAY_DEPTH) {

            error();

            return;

        }

        for (size_t i = node->postDimensions()->size() - 1; i < node->postDimensions()->size(); i--) {

            Expression *expr = node->postDimensions()->at(i);

            visitForLoad(expr);

            if (!IsPrimitiveType(expr->type(), PrimitiveType_Int32)) {

                typeError(expr, "integer");

                return;

            }

            int size = -1;

            if (expr->isIntegerLiteral()) {

                size = expr->toIntegerLiteral()->value();

                if (size <= 0) {

                    error();

                    return;

                }

                if (size >= INT_MAX / sizeof(int)) {

                    error();

                    return;

                }

            }

            type = ZONE()->types()->unsafeArray(type, size);

        }

        // Right now, any array is allowed on the LIFO heap. In case the

        // runtime actually decides to use the LIFO heap, we must reserve

        // a slot so we can unwind the heap when the current scope leaves.

        scope_->setUsesLifoHeap();

    } else {

        if (node->initialization()) {

            Type *right = visitForLoad(node->initialization());

            assert(TypeCheck(type, right));

        }

    }

    node->variable()->setType(type);

}

void

SemanticAnalysis::visit(IntegerLiteral *node)

{

    node->setType(ZONE()->types()->getPrimitive(PrimitiveType_Int32));

}

void

SemanticAnalysis::visit(ExpressionStatement *node)

{

    node->expression()->accept(this);

}

bool

SemanticAnalysis::preanalyze(FunctionStatement *node)

{

    // :TODO: use Local

    FixedArray *args = FixedArray::New(ZONE(), node->parameters()->size(), Heap::Tenure_Old);

    if (!args)

        return false;

    // Apply types to arguments.

    for (size_t i = 0; i < node->parameters()->size(); i++) {

        Parameter *parameter = node->parameters()->at(i);

        Type *type = ZONE()->types()->getPrimitiveForTag(parameter->tag());

        if (!type)

            return false;

        if (parameter->reference()) {

            type = ZONE()->types()->getReference(type);

            if (!type)

                return false;

        }

        args->set(ZONE(), i, type);

        parameter->variable()->setType(type);

    }

    Type *returnType = ZONE()->types()->getPrimitive(PrimitiveType_Int32);

    if (!returnType)

        return false;

    Type *funtype = ZONE()->types()->newFunction(returnType, args);

    if (!funtype)

        return false;

    node->fun()->setType(funtype);

    return true;

}

void

SemanticAnalysis::visit(FunctionStatement *node)

{

    scope_ = node->scope();

    // :TODO: call this ahead of time.

    if (!preanalyze(node))

        return;

    node->body()->accept(this);

    scope_ = NULL;

}

// :TODO: use handles

static inline bool

TypeCheckParameter(Type *given, Type *actual)

{

    if (actual->isReference()) {

        if (given->isReference())

            given = given->contained();

        return TypeCheck(given, actual->contained());

    }

    return TypeCheck(given, actual);

}

void

SemanticAnalysis::visit(CallExpression *node)

{

    visitForLoad(node->callee());

    // :TODO: use locals

    Type *type = node->callee()->type();

    if (!type)

        return;

    assert(type->isFunction());

    assert(node->arguments()->size() == type->parameters()->length());

    for (unsigned i = 0; i < node->arguments()->size(); i++) {

        Expression *expression = node->arguments()->at(i);

        expression->accept(this);

        Type *given = expression->type();

        if (!given)

            return;

        Type *actual = Type::cast(type->parameters()->at(i));

        assert(TypeCheckParameter(given, actual));

        // If the actual is a reference, and the given is not, we'll need to

        // compute a reference, which may be allocated on the stack.

        if (actual->isReference() && !given->isReference())

            scope_->setUsesLifoHeap();

    }

}

void

SemanticAnalysis::visit(IfStatement *node)

{

    visitForLoad(node->condition());

    node->ifTrue()->accept(this);

    if (node->ifFalse())

        node->ifFalse()->accept(this);

}

void

SemanticAnalysis::visit(IndexExpression *node)

{

    // :TODO: use locals

    Type *left = visitForRef(node->left());

    Type *right = visitForLoad(node->right());

    if (!right || !right->isInt()) {

        typeError(node->right(), "integer");

        return;

    }

    if (!left || !left->isArray() || !left->contained()->isPrimitive()) {

        typeError(node->left(), "array");

        return;

    }

    node->setType(left);

}

void

SemanticAnalysis::visit(EnumStatement *node)

{

    // :TODO: test "enum Float { ..."

    Name *tag = node->name();

    Type *type = ZONE()->types()->getPrimitiveForTag(tag);

    if (!type)

        return;

    int value = 0;

    for (size_t i = 0; i < node->entries()->size(); i++) {

        EnumStatement::Entry &entry = node->entries()->at(i);

        BoxedPrimitive box = BoxedPrimitive::Int(value);

        if (entry.expr) {

            entry.expr->accept(this);

            if (!EvaluateForConstant(entry.expr, &box))

                fprintf(stderr, "expected constant integer expression\n");

            assert(box.type() == PrimitiveType_Int32);

            value = box.toInt();

        }

        entry.name->set(type, box);

        value++;

    }

}

void

SemanticAnalysis::visit(FloatLiteral *node)

{

    Type *type = ZONE()->types()->getPrimitive(PrimitiveType_Float);

    if (!type)

        return;

    node->setType(type);

}

void

SemanticAnalysis::visit(BreakStatement *node)

{

    assert(loopDepth_ > 0);

}

void

SemanticAnalysis::visit(ContinueStatement *node)

{

    assert(loopDepth_ > 0);

}