/* vim: set ts=4 sw=4 tw=99 et:

  *

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

 #include "Zone.h"

 #include "Types.h"

 #include "TypeManager.h"

 using namespace jc;

 Scope::Scope(PoolAllocator &pool, Kind kind, Scope *enclosing)

   : pool_(pool),

     locals_(0),

     maxContainedLocals_(0),

     numFunctions_(0),

     lifoSlot_(NULL),

     kind_(kind),

     enclosing_(enclosing)

 {

 }

 bool

 Scope::initialize()

 {

     if (enclosing_)

         enclosing_->children_.push_back(this);

     return true;

 }

 void

 Scope::unlink()

 {

     assert(empty());

     assert(enclosing_->children_[enclosing_->children_.size() - 1] == this);

     enclosing_->children_.pop_back();

     for (size_t i = 0; i < children_.size(); i++)

         enclosing_->children_.push_back(children_[i]);

 }

 Scope *

 Scope::unlinkIfEmpty()

 {

     if (empty()) {

         unlink();

         return NULL;

     }

     return this;

 }

 BoundName *

 Scope::localLookup(Name *name)

 {

     for (size_t i = 0; i < names_.size(); i++) {

         if (names_[i]->name() == name)

             return names_[i];

     }

     return NULL;

 }

 BoundName *

 Scope::lookup(Name *name)

 {

     for (Scope *scope = this; scope; scope = scope->enclosing()) {

         if (BoundName *bound = scope->localLookup(name))

             return bound;

     }

     return NULL;

 }

 Variable *

 Scope::declareVariable(Name *name, const SourcePosition &pos)

 {

     assert(!localLookup(name));

     Variable *var = new (pool_) Variable(this, name, pos);

     names_.push_back(var);

     return var;

 }

 Variable *

 Scope::declareArgument(Name *name, const SourcePosition &pos)

 {

     assert(kind() == FUNCTION);

     Variable *var = declareVariable(name, pos);

     names_.push_back(var);

     parameters_.push_back(var);

     return var;

 }

 NamedFunction *

 Scope::declareFunction(Name *name, const SourcePosition &pos)

 {

     assert(!localLookup(name));

     assert(kind() == GLOBAL);

     NamedFunction *fun = new (pool_) NamedFunction(this, name, pos);

     names_.push_back(fun);

     return fun;

 }

 NamedEnum *

 Scope::declareEnum(Name *name, const SourcePosition &pos)

 {

     NamedEnum *e = new (pool_) NamedEnum(this, name, pos);

     names_.push_back(e);

     return e;

 }

 NamedConstant *

 Scope::declareConstant(Name *name, const SourcePosition &pos)

 {

     NamedConstant *constant = new (pool_) NamedConstant(this, name, pos);

     names_.push_back(constant);

     return constant;

 }

 void

 Scope::allocateGlobals()

 {

     assert(kind() == GLOBAL);

     for (size_t i = 0; i < children_.size(); i++) {

         assert(children_[i]->kind() == FUNCTION);

         children_[i]->allocate();

     }

     for (size_t i = 0; i < names_.size(); i++) {

         BoundName *name = names_[i];

         if (name->kind() == BoundName::FUNCTION) {

             NamedFunction *fun = name->toNamedFunction();

             fun->allocate(numFunctions_++);

         }

     }

 }

 void

 Scope::allocate(Variable *var)

 {

     if (!var->unallocated())

         return;

     var->allocate(Variable::STACK, maxContainedLocals_ + locals_);

     locals_++;

 }

 void

 Scope::allocate()

 {

     maxContainedLocals_ = 0;

     for (size_t i = 0; i < children_.size(); i++) {

         Scope *scope = children_[i];

         scope->allocate();

         if (scope->maxContainedLocals() > maxContainedLocals_)

             maxContainedLocals_ = scope->maxContainedLocals();

     }

     for (size_t i = 0; i < parameters_.size(); i++)

         parameters_[i]->allocate(Variable::PARAMETER, i);

     if (lifoSlot_)

         allocate(lifoSlot_);

     for (size_t i = 0; i < names_.size(); i++) {

         if (names_[i]->kind() != BoundName::VARIABLE)

             continue;

         allocate(names_[i]->toVariable());

     }

     maxContainedLocals_ += locals_;

 }

 bool

 Scope::Bind(ParseTree *tree)

 {

     for (size_t i = 0; i < tree->unbound()->size(); i++) {

         NameProxy *proxy = tree->unbound()->at(i);

         BoundName *name = tree->scope()->lookup(proxy->name());

         if (!name) {

             assert(false);

             return false;

         }

         proxy->bind(name);

     }

     return true;

 }

 void

 Scope::Allocate(ParseTree *tree)

 {

     tree->scope()->allocateGlobals();

 }

 void

 Scope::setUsesLifoHeap()

 {

     // Only one lifo slot is needed per scope.

     if (lifoSlot_)

         return;

     // If the parent of this scope is the function scope, then this is the

     // function's block scope, and the lifo slot is part of the Frame instead.

     // Note we can get a function scope here if we're making a temporary in a

     // function with no local variables.

     if (kind() == FUNCTION || enclosing()->kind() == FUNCTION)

         return;

     Local<Type> type(ZONE(), ZONE()->types()->getPrimitive(PrimitiveType_Native));

     if (!type)

         return;

     lifoSlot_ = new (pool_) Variable(this, NULL, SourcePosition());

     lifoSlot_->setType(type);

 }