/*

 * 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, &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