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

#include "Zone.h"

#include "RootScopes.h"

#include "CompileContext.h"

#include "Parser.h"

#include "Scopes.h"

#include "SemanticAnalysis.h"

#include "BytecodeCompiler.h"

#include "Modules.h"

#include "GlobalRoots.h"

using namespace ke;

bool

Ke::Keima::Initialize()

{

    SingleThreadedZone = new Zone();

    if (!SingleThreadedZone || !SingleThreadedZone->initialize())

        return false;

    return true;

}

void

Ke::Keima::Shutdown()

{

    delete SingleThreadedZone;

    SingleThreadedZone = NULL;

}

Ke::HandleScope::HandleScope()

  : zone_(ke::ZONE()),

    position_(zone_->rootScopes().position()),

    prev_(*zone_->rootScopes().scope())

{

    *zone_->rootScopes().scope() = this;

}

Ke::HandleScope::~HandleScope()

{

    zone_->rootScopes().unwind(position_);

    *zone_->rootScopes().scope() = prev_;

}

ke::Object **

Ke::HandleScope::CreateHandle(ke::Object *obj)

{

    if (!obj)

        return NULL;

    return ZONE()->rootScopes().make(obj);

}

template <typename From, typename To> static inline To *

Open(Ke::Handle<From> from)

{

    return *reinterpret_cast<To **>(*from);

}

template <typename From, typename To> static inline To *

Open(From *from)

{

    return *reinterpret_cast<To **>(from);

}

template <typename From, typename To> static inline Ke::Local<To>

ToLocal(From *from)

{

    return Ke::Local<To>(reinterpret_cast<To *>(Ke::HandleScope::CreateHandle(from)));

}

static ke::Module *

CompileFromSource(CompileContext &cc, const char *path, const char *stream, size_t length)

{

    Parser parser(ZONE(), cc, stream, length);

    ParseTree *tree = parser.parse();

    if (!tree)

        return NULL;

    tree->dump(stdout);

    if (!Scope::Bind(tree))

        return NULL;

    SemanticAnalysis semantics(ZONE(), cc, tree);

    if (!semantics.analyze())

        return NULL;

    Scope::Allocate(tree);

    BytecodeCompiler compiler(ZONE(), tree, NULL);

    return compiler.compile();

}

Ke::Local<Ke::Module>

Ke::Compile(const char *path)

{

    RootScope roots(ZONE());

    CompileContext cc(ZONE());

    char *bytes = NULL;

    size_t length;

    {

        FILE *fp = fopen(path, "rb");

        if (!fp) {

            cc.reportError(SourcePosition(), Message_CantOpenFile);

            return Ke::Local<Ke::Module>();

        }

        if (fseek(fp, 0, SEEK_END)) {

            cc.reportError(SourcePosition(), Message_ErrorSeekingFile);

            fclose(fp);

            return Ke::Local<Ke::Module>();;

        }

        long size = ftell(fp);

        if (size < 0) {

            cc.reportError(SourcePosition(), Message_ErrorSeekingFile);

            fclose(fp);

            return Ke::Local<Ke::Module>();;

        }

        rewind(fp);

        length = size_t(size);

        bytes = new char[length + 1];

        if (fread(bytes, 1, length, fp) != length) {

            cc.reportError(SourcePosition(), Message_ErrorReadingFile);

            fclose(fp);

            delete [] bytes;

            return Ke::Local<Ke::Module>();;

        }

        fclose(fp);

    }

    ke::Local<ke::Module> module(ZONE(),  CompileFromSource(cc, path, bytes, length));

    delete [] bytes;

    if (!module)

        return Ke::Local<Ke::Module>();

    return ToLocal<ke::Module, Ke::Module>(module);

}

static inline ke::HeapRoot *

FromAPI(ke::HeapRoot *from)

{

    ke::Address address = reinterpret_cast<ke::Address>(from);

    address -= offsetof(ke::HeapRoot, obj);

    return reinterpret_cast<ke::HeapRoot *>(address);

}

ke::HeapRoot *

Ke::Internals::NewHeapRoot(ke::Object **ptr)

{

    ke::Local<ke::Object> obj(ZONE(), *ptr);

    ke::HeapRoot *root = ke::ZONE()->globalRoots()->create(obj);

    if (!root)

        return NULL;

    // Compute an interior pointer, so it looks like a Handle to an object.

    return reinterpret_cast<ke::HeapRoot *>(&root->obj);

}

void

Ke::Internals::IncRef(ke::HeapRoot *root)

{

    ZONE()->globalRoots()->incref(FromAPI(root));

}

void

Ke::Internals::DecRef(ke::HeapRoot *root)

{

    ZONE()->globalRoots()->decref(FromAPI(root));

}

bool

Ke::Keima::IsInCallStack(Handle<Module> argModule)

{

    ke::Local<ke::Module> module(ke::ZONE(), Open<Ke::Module, ke::Module>(argModule));

    return ZONE()->stack().isInCallStack(module);

}

void

Ke::Keima::CollectGarbage()

{

    ke::ZONE()->heap().reclaim();

}

unsigned

Ke::Module::numPublics()

{

    ke::Local<ke::Module> module(ke::ZONE(), Open<Ke::Module, ke::Module>(this));

    return module->publics()->length();

}

Ke::Local<Ke::Function>

Ke::Module::getPublic(unsigned index)

{

    ke::Local<ke::Module> module(ke::ZONE(), Open<Ke::Module, ke::Module>(this));

    ke::Local<ke::Function> fun(ke::ZONE(), ke::Function::cast(module->publics()->at(index)));

    return ToLocal<ke::Function, Ke::Function>(fun);

}

unsigned

Ke::String::length()

{

    ke::Local<ke::String> obj(ke::ZONE(), Open<Ke::String, ke::String>(this));

    return obj->length();

}

const char *

Ke::String::chars()

{

    ke::Local<ke::String> obj(ke::ZONE(), Open<Ke::String, ke::String>(this));

    return obj->chars();

}

Ke::Local<Ke::String>

Ke::Function::name()

{

    ke::Local<ke::Function> fun(ke::ZONE(), Open<Ke::Function, ke::Function>(this));

    return ToLocal<ke::String, Ke::String>(fun->name());

}