/*

 * 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),

    kind_(kind),

    enclosing_(enclosing),

    locals_(0),

    maxContainedLocals_(0),

    numFunctions_(0),

    lifoSlot_(NULL)

{

}

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)

{

    assert(!localLookup(name));

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

    names_.push_back(var);

    return var;

}

Variable *

Scope::declareArgument(Name *name)

{

    assert(kind() == FUNCTION);

    Variable *var = declareVariable(name);

    names_.push_back(var);

    parameters_.push_back(var);

    return var;

}

NamedFunction *

Scope::declareFunction(Name *name)

{

    assert(!localLookup(name));

    assert(kind() == GLOBAL);

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

    names_.push_back(fun);

    return fun;

}

NamedEnum *

Scope::declareEnum(Name *name)

{

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

    names_.push_back(e);

    return e;

}

NamedConstant *

Scope::declareConstant(Name *name)

{

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

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

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

    lifoSlot_->setType(ZONE()->types()->getPrimitive(PrimitiveType_Native));

}