/*

 * 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"

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::kIntegerLiteralExpression:

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

        return true;

      default:

        return false;

    }

}

SemanticAnalysis::SemanticAnalysis(ParseTree *tree)

  : tree_(tree)

{

}

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

}

void

SemanticAnalysis::visit(Assignment *node)

{

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

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

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

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

    } else {

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

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

            fprintf(stderr, "error\n");

            return;

        }

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

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

    }

}

void

SemanticAnalysis::visit(BinaryExpression *node)

{

}

void

SemanticAnalysis::visit(ReturnStatement *node)

{

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

    // :TODO: type check

}

void

SemanticAnalysis::visit(ForStatement *node)

{

    if (node->declaration())

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

    if (node->condition())

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

    if (node->update())

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

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

}

void

SemanticAnalysis::visit(BlockStatement *node)

{

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

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

        statement->accept(this);

    }

}

void

SemanticAnalysis::visit(VariableDeclaration *node)

{

    Tag *tag = NULL;

    Type *type = Type::NewPrimitive(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);

            expr->accept(this);

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

                typeError(expr, "integer");

                return;

            }

            int size = -1;

            if (expr->isIntegerLiteralExpression()) {

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

                if (size <= 0) {

                    error();

                    return;

                }

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

                    error();

                    return;

                }

            }

            type = Type::NewUnsafeArray(type, size);

        }

    }

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

}

void

SemanticAnalysis::visit(IntegerLiteralExpression *node)

{

    Type *type = Type::NewPrimitive(NULL);

    node->setType(type);

}

void

SemanticAnalysis::visit(ExpressionStatement *node)

{

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

}

void

SemanticAnalysis::visit(FunctionStatement *node)

{

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

}

void

SemanticAnalysis::visit(CallExpression *node)

{

}

void

SemanticAnalysis::visit(IfStatement *node)

{

}

void

SemanticAnalysis::visit(IndexExpression *node)

{

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

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

    if (!node->right()->type(), PrimitiveType_Int32) {

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

        return;

    }

    if (!node->left()->type() || !node->left()->type()->isArray()) {

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

        return;

    }

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

}

void

SemanticAnalysis::visit(EnumStatement *node)

{

    Type *type = Type::NewPrimitive(NULL);

    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 expression\n");

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

            value = box.toInt();

        }

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

        value++;

    }

}