#include "moar.h"

#include "nodes.h"

#include "compiler.h"

/* Takes a hash of types and produces a MASTNodeTypes structure. */

#define grab_type(name) do { \

    MVMString *key = MVM_string_utf8_decode(tc, tc->instance->VMString, #name, strlen(#name)); \

    result->name   = MVM_repr_at_key_o(tc, types, key); \

} while (0)

static MASTNodeTypes * node_types_struct(MVMThreadContext *tc, MVMObject *types) {

    MASTNodeTypes *result = MVM_malloc(sizeof(MASTNodeTypes));

    MVMROOT(tc, types, {

        grab_type(CompUnit);

        grab_type(Frame);

        grab_type(Op);

        grab_type(ExtOp);

        grab_type(SVal);

        grab_type(IVal);

        grab_type(NVal);

        grab_type(Label);

        grab_type(Local);

        grab_type(Lexical);

        grab_type(Call);

        grab_type(Annotated);

        grab_type(HandlerScope);

    });

    return result;

}

/* Compiles MAST down to bytecode, then loads it as a compilation unit,

 * running deserialize and load frames as appropriate. */

void MVM_mast_to_cu(MVMThreadContext *tc, MVMObject *mast, MVMObject *types,

        MVMRegister *res) {

    MVMCompUnit *loaded;

    MVMROOT(tc, mast, {

        /* Get node types into struct. */

        MASTNodeTypes *mnt = node_types_struct(tc, types);

        /* Turn the MAST tree into bytecode. Switch to gen2 GC allocation to be

         * sure nothing moves, though we'd really rather not have compiler

         * temporaries live longer. */

        unsigned int size;

        char *bytecode;

        MVM_gc_allocate_gen2_default_set(tc);

        bytecode = MVM_mast_compile(tc, mast, mnt, &size);

        MVM_free(mnt);

        MVM_gc_allocate_gen2_default_clear(tc);

        /* Load it as a compilation unit; it is a kind of MVMObject, so cast

         * it to that. */

        loaded = MVM_cu_from_bytes(tc, (MVMuint8 *)bytecode, (MVMuint32)size);

        loaded->body.deallocate = MVM_DEALLOCATE_FREE;

    });

    /* Stash loaded comp unit in result register. */

    res->o = (MVMObject *)loaded;

    /* If there's a deserialization frame, need to run that. */

    if (loaded->body.deserialize_frame) {

        /* Set up special return to delegate to running the load frame,

         * if any. */

        tc->cur_frame->return_value        = NULL;

        tc->cur_frame->return_type         = MVM_RETURN_VOID;

        /* Invoke the deserialization frame and return to the runloop. */

        MVM_frame_invoke(tc, loaded->body.deserialize_frame, MVM_callsite_get_common(tc, MVM_CALLSITE_ID_NULL_ARGS),

            NULL, NULL, NULL, -1);

    }

}

/* Compiles MAST down to bytecode, then writes it to disk. */

void MVM_mast_to_file(MVMThreadContext *tc, MVMObject *mast, MVMObject *types, MVMString *filename) {

    MVMROOT(tc, mast, {

        FILE *fh;

        char *c_filename;

        /* Get node types into struct. */

        MASTNodeTypes *mnt = node_types_struct(tc, types);

        /* Turn the MAST tree into bytecode. */

        unsigned int size;

        char *bytecode;

        MVM_gc_allocate_gen2_default_set(tc);

        bytecode = MVM_mast_compile(tc, mast, mnt, &size);

        MVM_free(mnt);

        MVM_gc_allocate_gen2_default_clear(tc);

        /* Write it out to a file. (Not using VM-level IO for this right now;

         * may want to do that in the future.) */

        c_filename = MVM_string_utf8_c8_encode_C_string(tc, filename);

        if ((fh = fopen(c_filename, "wb+"))) {

            fwrite(bytecode, 1, size, fh);

            fclose(fh);

            MVM_free(c_filename);

            MVM_free(bytecode);

        }

        else {

            char *waste[2];

            waste[0] = c_filename;

            waste[1] = NULL;

            MVM_free(bytecode);

            MVM_exception_throw_adhoc_free(tc, waste, "Unable to write bytecode to '%s'", c_filename);

        }

    });

}