/*

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

 }