/*

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

using namespace jc;

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

  : pool_(pool),

    kind_(kind),

    enclosing_(enclosing),

    locals_(0),

    maxContainedLocals_(0),

    numFunctions_(0)

{

}

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

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

    names_.push_back(fun);

    return fun;

}

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

        NamedFunction *fun = name->toNamedFunction();

        fun->allocate(numFunctions_++);

    }

}

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

    locals_ = 0;

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

        assert(names_[i]->kind() == BoundName::VARIABLE);

        Variable *var = names_[i]->toVariable();

        if (var->unallocated()) {

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

            locals_++;

        }

    }

    maxContainedLocals_ += locals_;

}

bool

Scope::BindAndAllocate(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)

            return false;

        proxy->bind(name);

    }

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

    return true;

}