/* vim: set ts=4 sw=4 tw=99 et:

  *

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of SourcePawn.

  *

  * SourcePawn 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.

  * 

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

  * SourcePawn. If not, see http://www.gnu.org/licenses/.

  */

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

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

 using namespace Ke;

 class MessageReporter : public IMessageReporter

 {

   public:

     void onOutOfMemory() {

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

     }

     void onUncaughtException(const char *message) {

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

         IStackFrameIterator *iter = Keima::NewStackFrameIterator();

         unsigned index = 0;

         while (!iter->done() && index < 10) {

             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;

 class MainCollector : public Ke::IPublicFunctionListener

 {

   public:

     MainCollector()

     {

     }

     void registerPublic(Handle<Function> fun) {

         Local<String> str = fun->name();

         if (str && strcmp(str->chars(), "main") == 0)

             fun_ = fun;

     }

     void unregisterPublic(Handle<Function> fun) {

         if (fun_ == fun)

             fun_ = Handle<Function>();

     }

     Handle<Function> fun() const {

         return fun_;

     }

   private:

     Root<Function> fun_;

 };

 intptr_t PrintFloat(void *blah, intptr_t *params)

 {

     fprintf(stdout, "%f", *reinterpret_cast<float *>(&params[1]));

     return 0;

 }

 intptr_t PrintNum(void *blah, intptr_t *params)

 {

     fprintf(stdout, "%i", *reinterpret_cast<int *>(&params[1]));

     return 0;

 }

 intptr_t PrintString(void *blah, intptr_t *params)

 {

     fprintf(stdout, "%s", *reinterpret_cast<const char **>(&params[1]));

     return 0;

 }

 int main(int argc, char **argv)

 {

     if (argc < 2) {

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

         return 1;

     }

     if (!Keima::Initialize())

         return 1;

     int rval = 0;

     Keima::InstallMessageReporter(&s_Reporter);

     {

         MainCollector entry;

         Keima::SetPublicFunctionListener(&entry);

         HandleScope scope;

         Compile(argv[1]);

         Keima::CollectGarbage();

         Keima::BindNative("PrintFloat", (void *)PrintFloat);

         Keima::BindNative("PrintNum", (void *)PrintNum);

         Keima::BindNative("PrintString", (void *)PrintString);

         Handle<Function> fun = entry.fun();

         if (!fun) {

             fprintf(stdout, "Not running; no public 'main'.\n");

         } else {

             if (!Keima::Invoke(fun, NULL, 0, true, &rval))

                 rval = 1;

         }

     }

     Keima::Shutdown();

     return rval;

 }

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