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

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

    {

        HandleScope scope;

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

        if (!module)

            return 1;

        Keima::CollectGarbage();

        // Look for a public named "main".

        Local<Function> fun;

        for (unsigned i = 0; i < module->numPublics(); i++) {

            if (strcmp(module->getPublic(i)->name()->chars(), "main") == 0) {

                fun = module->getPublic(i);

                break;

            }

        }

        for (unsigned i = 0; i < module->numNatives(); i++) {

            Local<Native> native = module->getNative(i);

            if (strcmp(native->name()->chars(), "PrintFloat") == 0)

                native->bind(reinterpret_cast<void *>(PrintFloat));

            else if (strcmp(native->name()->chars(), "PrintNum") == 0)

                native->bind(reinterpret_cast<void *>(PrintNum));

            else if (strcmp(native->name()->chars(), "PrintString") == 0)

                native->bind(reinterpret_cast<void *>(PrintString));

        }

        if (!fun) {

            fprintf(stdout, "Plugin compiles!\nNot 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