/*

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

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

}

static inline bool

IsPrimitiveType(Type *type, PrimitiveType primitive)

{

    if (!type)

        return false;

    if (!type->isPrimitive())

        return false;

    return primitive == type->primitive();

}

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

}