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

#include "../Types.h"

#include "../TypeManager.h"

#include "../Strings.h"

#include "../Environments.h"

#include "../Structures.h"

#include "CompileContext.h"

#include "Scopes.h"

#include "../Spaces-inl.h"

#include "../Heap-inl.h"

using namespace ke;

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

  : pool_(pool),

    kind_(kind),

    enclosing_(enclosing)

{

}

bool

Scope::initialize()

{

    if (enclosing_ && !enclosing_->children_.append(this))

        return false;

    return true;

}

void

Scope::unlink()

{

    assert(empty());

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

    enclosing_->children_.pop();

    // OOM here is swallowed and checked after compilation.

    // :TODO: make the above true.

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

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

}

Scope *

Scope::unlinkIfEmpty()

{

    if (empty()) {

        unlink();

        return NULL;

    }

    return this;

}

Symbol *

Scope::localLookup(Handle<String> name)

{

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

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

            return names_[i];

    }

    return NULL;

}

Symbol  *

Scope::lookup(Handle<String> name)

{

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

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

            return bound;

    }

    return NULL;

}

#if 0

void

Scope::setUsesLifoHeap()

{

    // Only one lifo slot is needed per scope.

#if 0

    if (lifoSlot_)

        return;

#endif

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

    Local<String> name(ZONE());

#if 0

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

    lifoSlot_->setType(type);

#endif

}

#endif

bool

Scope::addSymbol(Symbol *sym)

{

    return names_.append(sym);

}

LocalScope::LocalScope(PoolAllocator &pool)

  : Scope(pool, Scope::BLOCK, NULL)

{

}

LocalScope *

LocalScope::New(PoolAllocator &pool)

{

    LocalScope *scope = new (pool) LocalScope(pool);

    if (!scope->initialize())

        return NULL;

    return scope;

}

ArgumentScope::ArgumentScope(PoolAllocator &pool)

  : Scope(pool, Scope::FUNCTION, NULL)

{

}

ArgumentScope *

ArgumentScope::New(PoolAllocator &pool)

{

    ArgumentScope *scope = new (pool) ArgumentScope(pool);

    if (!scope->initialize())

        return NULL;

    return scope;

}

GlobalScope::GlobalScope(PoolAllocator &pool, ImportScope *parent)

  : Scope(pool, Scope::GLOBAL, parent)

{

}

GlobalScope *

GlobalScope::New(PoolAllocator &pool, ImportScope *parent)

{

    GlobalScope *scope = new (pool) GlobalScope(pool, parent);

    if (!scope->initialize())

        return NULL;

    return scope;

}

bool

GlobalScope::addPublic(Symbol *sym)

{

    return publics_.append(sym);

}

Symbol *

GlobalScope::findPublic(Handle<String> name)

{

    for (size_t i = 0; i < publics_.length(); i++) {

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

            return publics_[i];

    }

    return NULL;

}

Struct *

GlobalScope::build(Zone *zone)

{

    Local<FixedArray> descriptors(zone, FixedArray::New(zone, names_.length(), Heap::Tenure_Old));

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

        Handle<String> name = names_[i]->name();

        Handle<Type> type = names_[i]->type();

        assert(type);

        Local<Descriptor> desc(zone, Descriptor::New(zone, name, type));

        if (!desc)

            return NULL;

        descriptors->set(zone, i, desc);

    }

    Local<StructType> type(zone, StructType::New(zone, Handle<String>::Null(), descriptors));

    if (!type)

        return NULL;

    Local<StructMap> map(zone, type->newMap());

    return Struct::New(zone, map, Heap::Tenure_Old);

}

ImportScope::ImportScope(PoolAllocator &pool)

  : Scope(pool, Scope::IMPORT, NULL)

{

}

ImportScope *

ImportScope::New(PoolAllocator &pool)

{

    ImportScope *scope = new (pool) ImportScope(pool);

    if (!scope->initialize())

        return NULL;

    return scope;

}