/* 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 Ke::Local<To>

 ToLocal(Handle<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();

 }