/*

  * 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 <stdio.h>

 #include "Utility.h"

 #include "Scanner.h"

 #include "Parser.h"

 #include "SemanticAnalysis.h"

 #include "Zone.h"

 #include "BytecodeCompiler.h"

 #include "Code.h"

 #include "Interpreter.h"

 #include "Modules.h"

 #include "RootScopes.h"

 #include "../include/keima.h"

 #include "Spaces-inl.h"

 #include "Heap-inl.h"

 using namespace ke;

 class MessageReporter : public Ke::IMessageReporter

 {

   public:

     void onOutOfMemory() {

         fprintf(stderr, "Out of memory!\n");

     }

     void onUncaughtException(const char *message) {

         fprintf(stderr, "Uncaught exception: %s\n", message);

         Ke::IStackFrameIterator *iter = Ke::Keima::NewStackFrameIterator();

         unsigned index = 0;

         while (!iter->done()) {

             fprintf(stderr, "[%d] %s (%s line %d)\n",

                     index,

                     iter->function(),

                     iter->source(),

                     iter->lineNumber());

             iter->prev();

             index++;

         }

     }

     virtual void beginCompilationErrors(const char *file) {

         fprintf(stderr, "\nDisplaying compilation errors for \"%s\"\n", file);

     }

     virtual void reportCompilationError(const char *message, unsigned line, unsigned col) {

         fprintf(stderr, "  line %d, col %d: %s\n", line, col, message);

     }

     virtual void endCompilationErrors() {

     }

 } s_Reporter;

 #if 0

 static bool

 Compile(const char *stream, size_t length)

 {

     printf("\n ------------ \n\n");

     Disassemble(module->getFunction(1)->code(), stdout);

     //Disassemble(module->getFunction(1), stdout);

     printf("\n ------------ \n\n");

     Function *main = module->getFunction(1);

     Top top = ZONE()->stack().begin();

     LocalTop localTop(top);

     Frame *frame = ZONE()->stack().pushFrame(main);

     if (!frame)

         return false;

     LocalSlot result;

     if (!Interpret(ZONE(), frame, &result))

         return false;

     printf("Result: %d\n", result.i32);

     return true;

 }

 #endif

 intptr_t PrintToServer(void *blah, intptr_t *params)

 {

     assert(params[0] == 3);

     const char *fmt = reinterpret_cast<const char *>(params[1]);

     const char *str = reinterpret_cast<const char *>(params[2]);

     int *d = reinterpret_cast<int *>(params[3]);

     printf(fmt, str, *d);

     return 16;

 }

 int main(int argc, char **argv)

 {

     if (argc < 2) {

         fprintf(stderr, "Usage: <file>\n");

         return 1;

     }

     if (!Ke::Keima::Initialize())

         return 1;

     Ke::Keima::InstallMessageReporter(&s_Reporter);

     {

         Ke::HandleScope scope;

         Ke::Local<Ke::Module> module = Ke::Compile(argv[1]);

         if (!module)

             return 1;

         //Ke::Local<Ke::Native> native = module->getNative(0);

         //native->bind(reinterpret_cast<void *>(PrintToServer));

         //module->setNativeIdentity(reinterpret_cast<void *>(5));

         int result;

         Ke::Local<Ke::Function> fun = module->getPublic(0);

         if (Ke::Keima::Invoke(fun, NULL, 0, true, &result))

             printf("%d\n", result);

     }

     Ke::Keima::Shutdown();

 }

 /* Overload a few things to prevent libstdc++ linking */

 #if defined __linux__ || defined __APPLE__

 extern "C" void __cxa_pure_virtual(void)

 {

 }

 void *operator new(size_t size)

 {

 	return malloc(size);

 }

 void *operator new[](size_t size) 

 {

 	return malloc(size);

 }

 void operator delete(void *ptr) 

 {

 	free(ptr);

 }

 void operator delete[](void * ptr)

 {

 	free(ptr);

 }

 #endif