cground/src/interpreter.c

#include "interpreter.h"
#include "parser.h"
#include "types.h"
#include "include/uthash.h"
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#include <dlfcn.h>
#endif
#include <stdarg.h>
#include <unistd.h>

int currentInstruction = 0;

bool isMainScopeGlobal = true;

bool listDeprecationWarning = true;

char* getFileContents(const char* filename);

[[noreturn]] void customError(GroundArg type, GroundArg what, GroundInstruction* where, int whereLine, int exitCode) {
    printf("Ground runtime error:\n  ErrorType: ");
    printGroundArg(&type);
    printf("\n  ErrorContext: ");
    printGroundArg(&what);
    printf("\n");
    if (where != NULL) {
        printf("  ErrorInstruction: ");
        printGroundInstruction(where);
        printf("\n");
    }
    if (whereLine > -1) {
        printf("  ErrorLine: %d\n", whereLine + 1);
    }
    exit(exitCode);
}

[[noreturn]] void runtimeError(GroundRuntimeError error, char* what, GroundInstruction* where, int whereLine) {
    printf("Ground runtime error:\n  ErrorType: ");
    switch (error) {
        case ARG_TYPE_MISMATCH: {
            printf("ArgTypeMismatch");
            break;
        }
        case TOO_FEW_ARGS: {
            printf("TooFewArgs");
            break;
        }
        case TOO_MANY_ARGS: {
            printf("TooManyArgs");
            break;
        }
        case UNKNOWN_LABEL: {
            printf("UnknownLabel");
            break;
        }
        case UNKNOWN_VARIABLE: {
            printf("UnknownVariable");
            break;
        }
        case LIST_ERROR: {
            printf("ListError");
            break;
        }
        case STRING_ERROR: {
            printf("StringError");
            break;
        }
        case MATH_ERROR: {
            printf("MathError");
            break;
        }
        case RETURN_TYPE_MISMATCH: {
            printf("ReturnTypeMismatch");
            break;
        }
        case PREMATURE_EOF: {
            printf("PrematureEof");
            break;
        }
        case INVALID_INSTRUCTION: {
            printf("InvalidInstruction");
            break;
        }
        default:
        case FIXME: {
            printf("FIXME (please report issue to https://chsp.au/ground/cground)");
        }
    }
    printf("\n");
    if (what != NULL) {
        printf("  ErrorContext: %s\n", what);
    }
    if (where != NULL) {
        printf("  ErrorInstruction: ");
        printGroundInstruction(where);
        printf("\n");
    }
    if (whereLine > -1) {
        printf("  ErrorLine: %d\n", whereLine + 1);
    }
    exit(1);
}

[[noreturn]] void throwError(GroundError* error) {
    printf("Uncaught Ground runtime error:\n  ErrorType: %s\n", error->type);
    if (error->what != NULL) {
        printf("  ErrorContext: %s\n", error->what);
    }
    if (error->where != NULL) {
        printf("  ErrorInstruction: ");
        printGroundInstruction(error->where);
        printf("\n");
    }
    if (error->hasLine) {
        printf("  ErrorLine: %zu\n", error->line + 1);
    }
    exit(1);
}

GroundLabel* findLabel(GroundLabel* head, const char *id) {
    GroundLabel *item;
    HASH_FIND_STR(head, id, item);
    return item;
}

GroundCatch* findCatch(GroundCatch* head, const char *id) {
    GroundCatch *item;
    HASH_FIND_STR(head, id, item);
    return item;
}

void deleteLabel(GroundLabel** head, GroundLabel *item) {
    HASH_DEL(*head, item);
    free(item);
}

void addLabel(GroundLabel **head, const char *id, int data) {
    GroundLabel* label = findLabel(*head, id);
    if (label) {
        deleteLabel(head, label);
    }
    GroundLabel* item = malloc(sizeof(GroundLabel));
    snprintf(item->id, MAX_ID_LEN, "%s", id);
    item->lineNum = data;
    HASH_ADD_STR(*head, id, item);
}

GroundVariable* findVariable(GroundVariable* head, const char *id) {
    GroundVariable *item;
    HASH_FIND_STR(head, id, item);
    return item;
}

void deleteVariable(GroundVariable** head, GroundVariable *item) {
    if (item == NULL) {
        return;
    }
    if (strcmp(item->id, "self") == 0) {
        return;
    }
    if (item->freed) {
        return;
    }
    item->freed = true;
    if (item->value.type == CUSTOM) {
        GroundObjectField* destructor = findField(*item->value.data.customVal, "destructor");
        if (destructor != NULL) {
            if (destructor->value.type == FUNCTION) {
                GroundScope scope = {
                    .labels = NULL,
                    .variables = malloc(sizeof(GroundVariable*)),
                    .catches = malloc(sizeof(GroundCatch*)),
                    .isMainScope = false
                };
                if (scope.variables == NULL) {
                    runtimeError(FIXME, "Failed to allocate memory for scope variables", NULL, -1);
                }
                *scope.variables = NULL;
                addVariable(scope.variables, "self", item->value);
                GroundInstruction instruction = createGroundInstruction(CALLMETHOD);
                addArgToInstruction(&instruction, createRefGroundArg(DIRREF, "self"));
                addArgToInstruction(&instruction, createRefGroundArg(FNREF, "destructor"));
                addArgToInstruction(&instruction, createRefGroundArg(DIRREF, ""));
                interpretGroundInstruction(instruction, &scope);
            } else {
                runtimeError(ARG_TYPE_MISMATCH, "Custom type destructor must be a function", NULL, -1);
            }
        }
    }
    freeGroundValue(&item->value);
    HASH_DEL(*head, item);
    free(item);
}

void addVariable(GroundVariable **head, const char *id, GroundValue data) {
    GroundVariable* variable = findVariable(*head, id);
    if (variable) {
        deleteVariable(head, variable);
    }
    GroundVariable* item = malloc(sizeof(GroundVariable));
    snprintf(item->id, MAX_ID_LEN, "%s", id);
    item->value = copyGroundValue(&data);
    item->freed = false;
    HASH_ADD_STR(*head, id, item);
}

GroundFunction* createGroundFunction() {
    GroundFunction* gf = malloc(sizeof(GroundFunction));
    gf->argSize = 0;
    gf->args = malloc(sizeof(GroundFunctionArgs));
    gf->program = createGroundProgram();
    gf->isNative = false;
    gf->nativeFn = NULL;
    return gf;
}

void addArgsToGroundFunction(GroundFunction* function, GroundValueType type, char* name) {
    GroundFunctionArgs arg;
    arg.type = type;
    arg.name = name;
    function->argSize ++;
    GroundFunctionArgs* ptr = realloc(function->args, function->argSize * sizeof(GroundFunctionArgs));
    if (ptr == NULL) {
        printf("Failed to allocate memory for arg of GroundFunction");
        function->argSize --;
        return;
    }
    function->args = ptr;
    function->args[function->argSize - 1] = arg;
};

GroundValueType stringToValueType(char* in) {
    if (in == NULL) {
        return ANY;
    }
    if (strcmp(in, "int") == 0) {
        return INT;
    }
    if (strcmp(in, "double") == 0) {
        return DOUBLE;
    }
    if (strcmp(in, "bool") == 0) {
        return BOOL;
    }
    if (strcmp(in, "string") == 0) {
        return STRING;
    }
    if (strcmp(in, "char") == 0) {
        return CHAR;
    }
    if (strcmp(in, "list") == 0) {
        return LIST;
    }
    if (strcmp(in, "function") == 0) {
        return FUNCTION;
    }
    if (strcmp(in, "struct") == 0) {
        return STRUCTVAL;
    }
    if (strcmp(in, "any") == 0) {
        return ANY;
    }
    return CUSTOM;
}

GroundDebugInstruction parseDebugInstruction(char* in) {
    GroundDebugInstruction gdi;
    size_t insize = strlen(in);
    size_t spacepos = -1;

    for (size_t i = 0; i < insize; i++) {
        if (in[i] == ' ') {
            spacepos = i;
            break;
        }
    }

    if (spacepos == (size_t) -1) {
        spacepos = insize;
    }

    char* instruction = malloc(spacepos + 1);
    if (!instruction) {
        gdi.type = UNKNOWN;
        gdi.arg = NULL;
        return gdi;
    }
    strncpy(instruction, in, spacepos);
    instruction[spacepos] = '\0';

    if (strcmp(instruction, "dump") == 0) {
        gdi.type = DUMP;
    } else if (strcmp(instruction, "inspect") == 0) {
        gdi.type = INSPECT;
    } else if (strcmp(instruction, "eval") == 0) {
        gdi.type = EVAL;
    } else if (strcmp(instruction, "continue") == 0) {
        gdi.type = CONTINUE;
    } else if (strcmp(instruction, "exit") == 0) {
        gdi.type = EXIT;
    } else if (strcmp(instruction, "step") == 0) {
        gdi.type = STEP;
    } else if (strcmp(instruction, "view") == 0) {
        gdi.type = VIEW;
    } else if (strcmp(instruction, "help") == 0) {
        gdi.type = HELP;
    } else {
        gdi.type = UNKNOWN;
    }

    size_t arglen = insize - spacepos;
    gdi.arg = malloc(arglen + 1);
    if (gdi.arg) {
        strcpy(gdi.arg, in + spacepos + 1);
    }

    free(instruction);
    return gdi;
}   

void groundAddNativeFunction(GroundScope* scope, char* name, NativeGroundFunction fn, GroundValueType returnType, int argCount, ...) {
    GroundFunction* gf = createGroundFunction();
    gf->isNative = true;
    gf->nativeFn = fn;
    gf->returnType = returnType;
    
    va_list args;
    va_start(args, argCount);
    for(int i = 0; i < argCount; i++) {
        GroundValueType type = va_arg(args, GroundValueType);
        char* argName = va_arg(args, char*);
        addArgsToGroundFunction(gf, type, argName);
    }
    va_end(args);
    
    addVariable(scope->variables, name, createFunctionGroundValue(gf));
}

GroundFunction* parseFunction(GroundProgram* in, size_t errorOffset) {
    GroundFunction* function = createGroundFunction();
    for (size_t i = 0; i < in->size; i++) {
        if (in->instructions[i].args.length < 2) {
            function->returnType = NONE;
        } else {
            if (in->instructions[i].args.args[1].type != TYPEREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a TypeRef for arg 2", &in->instructions[i], errorOffset + i);
            }
            GroundArg* args = in->instructions[i].args.args;
            function->returnType = stringToValueType(args[1].value.refName);
            size_t length = in->instructions[i].args.length;
            for (size_t j = 2; j < length; j += 2) {
                if (args[j].type != TYPEREF) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting a TypeRef", &in->instructions[i], errorOffset + i);
                }
                if (j + 1 >= length) {
                    runtimeError(TOO_FEW_ARGS, "Expecting a DirectRef after a TypeRef", &in->instructions[i], errorOffset + i);
                }
                if (args[j + 1].type != DIRREF) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef after a TypeRef", &in->instructions[i], errorOffset + i);
                }
                addArgsToGroundFunction(function, stringToValueType(args[j].value.refName), args[j + 1].value.refName);
            }
        }
        i++;
        while (i < in->size) {
            addInstructionToProgram(&function->program, in->instructions[i]);
            i++;
        }
        break;
    }
    return function;
}

GroundStruct parseStruct(GroundProgram* in, GroundScope* scope, size_t errorOffset) {
    GroundStruct gstruct = createStruct();
    for (size_t i = 0; i < in->size; i++) {
        switch (in->instructions[i].type) {
            case SET: {
                if (in->instructions[i].args.length < 2) {
                    runtimeError(TOO_FEW_ARGS, "Expecting 2 args", &in->instructions[i], i + errorOffset);
                }
                if (in->instructions[i].args.length > 2) {
                    runtimeError(TOO_MANY_ARGS, "Expecting 2 args", &in->instructions[i], i + errorOffset);
                }
                if (in->instructions[i].args.args[0].type != DIRREF) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 1", &in->instructions[i], i + errorOffset);
                }
                if (in->instructions[i].args.args[1].type != VALUE) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", &in->instructions[i], i + errorOffset);
                }
                addFieldToStruct(&gstruct, in->instructions[i].args.args[0].value.refName, in->instructions[i].args.args[1].value.value);
                break;
            }
            case INIT: {
                if (in->instructions[i].args.length < 2) {
                    runtimeError(TOO_FEW_ARGS, "Expecting 2 args", &in->instructions[i], currentInstruction);
                }
                if (in->instructions[i].args.length > 2) {
                    runtimeError(TOO_MANY_ARGS, "Expecting 2 args", &in->instructions[i], currentInstruction);
                }
                if (in->instructions[i].args.args[0].type != DIRREF) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 1", &in->instructions[i], currentInstruction);
                }
                if (in->instructions[i].args.args[1].type != TYPEREF) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting a TypeRef for arg 2", &in->instructions[i], currentInstruction);
                }

                GroundValue gv;

                switch (stringToValueType(in->instructions[i].args.args[1].value.refName)) {
                    case INT: {
                        gv = createIntGroundValue(0);
                        break;
                    }
                    case DOUBLE: {
                        gv = createDoubleGroundValue(0);
                        break;
                    }
                    case STRING: {
                        gv = createStringGroundValue("");
                        break;
                    }
                    case CHAR: {
                        gv = createCharGroundValue('\0');
                        break;
                    }
                    case BOOL: {
                        gv = createBoolGroundValue(false);
                        break;
                    }
                    case LIST: {
                        gv = createListGroundValue(createList());
                        break;
                    }
                    case FUNCTION: {
                        gv = createFunctionGroundValue(createGroundFunction());
                        break;
                    }
                    case STRUCTVAL: {
                        gv.type = STRUCTVAL;
                        gv.data.structVal = malloc(sizeof(GroundStruct));
                        *gv.data.structVal = createStruct();
                        break;
                    }
                    case CUSTOM: {
                        GroundVariable* var = findVariable(*scope->variables, in->instructions[i].args.args[1].value.refName);
                        if (var == NULL) {
                            runtimeError(UNKNOWN_VARIABLE, "Couldn't find the specified type", &in->instructions[i], currentInstruction);
                        }
                        if (var->value.type != STRUCTVAL) {
                            runtimeError(ARG_TYPE_MISMATCH, "TypeRef does not reference a struct", &in->instructions[i], currentInstruction);
                        }
                        GroundStruct* gstruct = var->value.data.structVal;
                        gv.type = CUSTOM;
                        gv.data.customVal = malloc(sizeof(GroundObject));
                        *gv.data.customVal = createObject(*gstruct);
                        gv.customType = gstruct;
                        break;
                    }
                    case NONE: {
                        gv.type = NONE;
                        break;
                    }
                    default: {
                        runtimeError(FIXME, "Reached should-be-impossible state", &in->instructions[i], currentInstruction);
                        break;
                    }
                }
                addFieldToStruct(&gstruct, in->instructions[i].args.args[0].value.refName, gv);

                break;
            }
            case FUN: {
                if (in->instructions[i].args.length < 1) {
                    runtimeError(TOO_FEW_ARGS, "Expecting 1 or more args", &in->instructions[i], i);
                }
                if (in->instructions[i].args.args[0].type != FNREF) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting a FunctionRef for arg 1", &in->instructions[i], i);
                }
                char* name = malloc(strlen(in->instructions[i].args.args[0].value.refName) + 1);
                strcpy(name, in->instructions[i].args.args[0].value.refName);

                size_t counter = 1;
                GroundProgram gp = createGroundProgram();
                addInstructionToProgram(&gp, in->instructions[i]);
                size_t errorOffset = i;
                i++;
                while (counter > 0) {
                    if (i >= in->size) {
                        runtimeError(PREMATURE_EOF, "Reached end of scope before function definition ended", &in->instructions[i - 1], i - 1);
                    }
                    if (in->instructions[i].type == FUN) {
                        counter++;
                    }
                    if (in->instructions[i].type == ENDFUN) {
                        counter--;
                    }
                    addInstructionToProgram(&gp, in->instructions[i]);
                    i++;
                }
                i--;

                GroundFunction* function = parseFunction(&gp, errorOffset);
                function->startLine = i;
                function->closure = copyGroundScope(scope);
                GroundValue gv = createFunctionGroundValue(function);
                addFieldToStruct(&gstruct, name, gv);
                break;
            }
            case ENDSTRUCT: {
                break;
            }
            default: {
                runtimeError(INVALID_INSTRUCTION, "Unsupported instruction while inside struct", &in->instructions[i], errorOffset + i);
            }

        }
    }
    return gstruct;
}

GroundValue interpretGroundProgram(GroundProgram* in, GroundScope* inScope) {
    GroundLabel* labels = NULL;
    GroundVariable* variables = NULL;
    GroundCatch* catches = NULL;
    int instructionsToPause = -1;

    GroundScope scope;
    if (inScope != NULL) {
        scope = *inScope;
    } else {
        scope.labels = &labels;
        scope.variables = &variables;
        scope.catches = &catches;
    }
    scope.isMainScope = isMainScopeGlobal;
    isMainScopeGlobal = false;
    // Preprocess all labels, structs and functions
    for (size_t i = 0; i < in->size; i++) {
        if (in->instructions[i].type == CREATELABEL) {
            addLabel(scope.labels, in->instructions[i].args.args[0].value.refName, i);
        }
        if (in->instructions[i].type == STRUCT) {
            if (in->instructions[i].args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 arg", &in->instructions[i], i);
            }
            if (in->instructions[i].args.length > 1) {
                runtimeError(TOO_MANY_ARGS, "Expecting 1 arg", &in->instructions[i], i);
            }
            if (in->instructions[i].args.args[0].type != TYPEREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expected arg 1 to be a typeref", &in->instructions[i], i);
            }
            char* name = malloc(strlen(in->instructions[i].args.args[0].value.refName) + 1);
            strcpy(name, in->instructions[i].args.args[0].value.refName);
            i++;

            size_t counter = 1;
            GroundProgram gp = createGroundProgram();
            size_t errorOffset = i;
            while (counter > 0) {
                if (i >= in->size) {
                    runtimeError(PREMATURE_EOF, "Reached end of scope before struct definition ended", &in->instructions[i - 1], i - 1);
                }
                if (in->instructions[i].type == STRUCT) {
                    counter++;
                }
                if (in->instructions[i].type == ENDSTRUCT) {
                    counter--;
                }
                addInstructionToProgram(&gp, in->instructions[i]);
                i++;
            }
            i--;

            GroundValue gv = {
                .type = STRUCTVAL,
                .data.structVal = malloc(sizeof(GroundStruct))
            };
            *gv.data.structVal = parseStruct(&gp, &scope, errorOffset);

            addVariable(scope.variables, name, gv);
        }
    }
    for (size_t i = 0; i < in->size; i++) {
        if (in->instructions[i].type == FUN) {
            if (in->instructions[i].args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 or more args", &in->instructions[i], i);
            }
            if (in->instructions[i].args.args[0].type != FNREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a FunctionRef for arg 1", &in->instructions[i], i);
            }
            char* name = malloc(strlen(in->instructions[i].args.args[0].value.refName) + 1);
            strcpy(name, in->instructions[i].args.args[0].value.refName);

            size_t counter = 1;
            GroundProgram gp = createGroundProgram();
            addInstructionToProgram(&gp, in->instructions[i]);
            size_t errorOffset = i;
            i++;
            while (counter > 0) {
                if (i >= in->size) {
                    runtimeError(PREMATURE_EOF, "Reached end of scope before function definition ended", &in->instructions[i - 1], i - 1);
                }
                if (in->instructions[i].type == FUN) {
                    counter++;
                }
                if (in->instructions[i].type == ENDFUN) {
                    counter--;
                }
                addInstructionToProgram(&gp, in->instructions[i]);
                i++;
            }
            i--;

            GroundFunction* function = parseFunction(&gp, errorOffset);
            function->startLine = i;
            function->closure = copyGroundScope(inScope);
            GroundValue gv = createFunctionGroundValue(function);

            addVariable(scope.variables, name, gv);
        }
        /*
        if (in->instructions[i].type == FUN) {
            int count = 1;
            while (count > 0) {
                i++;
                if (i >= in->size) {
                    return createNoneGroundValue();
                }
                if (in->instructions[i].type == FUN) {
                    count++;
                }
                if (in->instructions[i].type == ENDFUN) {
                    count--;
                }
            }
        }
        */
        if (in->instructions[i].type == STRUCT) {
            int count = 1;
            while (count > 0) {
                i++;
                if (i >= in->size) {
                    return createNoneGroundValue();
                }
                if (in->instructions[i].type == STRUCT) {
                    count++;
                }
                if (in->instructions[i].type == ENDSTRUCT) {
                    count--;
                }
            }
        }
        if (in->instructions[i].type == PAUSE || instructionsToPause == 0) {
            printf("Paused execution\n");
            printf("Previous instruction: ");
            if (i > 0) {
                printGroundInstruction(&in->instructions[i - 1]);
            }
            while (true) {
                printf("\nprompt> ");
                char buffer[256];
                if (fgets(buffer, sizeof(buffer), stdin) != NULL) {
                    buffer[strcspn(buffer, "\n")] = '\0';
                } else {
                    runtimeError(FIXME, "Failed to read input from console with fgets", NULL, -1);
                }
                GroundDebugInstruction gdi = parseDebugInstruction(buffer);
                
                bool shouldBreak = false;
                switch (gdi.type) {
                    case CONTINUE: {
                        shouldBreak = true;
                        break;
                    }
                    case EXIT: {
                        exit(0);
                        break;
                    }

                    case DUMP: { 
                        if (scope.variables == NULL) {
                            printf("Can't access variables");
                            break;
                        }
                        if (*scope.variables == NULL) {
                            printf("Can't access variables");
                            break;
                        }
                        GroundVariable* entry;
                        GroundVariable* tmp;
                        GroundVariable* head = *scope.variables;
                        HASH_ITER(hh, head, entry, tmp) {
                            if (entry != NULL) {
                                printf("%s: ", entry->id);
                                printGroundValue(&entry->value);
                                printf("\n");
                            }
                        }
                        break;
                    }
                    case INSPECT: {
                        printf("%s: ", gdi.arg);
                        GroundVariable* var = findVariable(*scope.variables, gdi.arg);
                        if (var == NULL) {
                            printf("(nothing)");
                        } else {
                            printGroundValue(&var->value);
                        }
                        break;
                    }
                    case EVAL: {
                        GroundProgram program = parseFile(gdi.arg);
                        interpretGroundProgram(&program, &scope);
                        freeGroundProgram(&program);
                        break;
                    }
                    case STEP: {
                        if (gdi.arg != NULL && strlen(gdi.arg) > 0) {
                            instructionsToPause = atoi(gdi.arg);
                        } else {
                            instructionsToPause = 1;
                        }
                        instructionsToPause++;
                        shouldBreak = true;
                        break;
                    }
                    case VIEW: {
                        break;
                    }
                    case HELP: {
                        printf("Ground Debugger Help\n");
                        printf("Didn't mean to end up here? Type \"continue\" to escape this prompt.\n");
                        printf("Commands:\n");
                        printf("    continue: Continue execution of the program\n");
                        printf("    exit: Stop execution early\n");
                        printf("    dump: Shows all variables and their contents\n");
                        printf("    inspect (variable): Shows the contents of a variable\n");
                        printf("    eval (code): Runs Ground code in the current scope\n");
                        printf("    help: Shows this help message");
                        break;
                    }
                    case UNKNOWN: {
                        printf("Unknown instruction (type \"help\" for help)");
                        break;
                    }
                } 
                if (shouldBreak) {
                    break;
                }
            }
            if (in->instructions[i].type == PAUSE) {
                continue;
            }
        }
        instructionsToPause --;
        int ci = currentInstruction;
        GroundValue gv = interpretGroundInstruction(in->instructions[i], &scope);
        if (gv.type == ERROR) {
            GroundCatch* catch = findCatch(*scope.catches, gv.data.errorVal.type);
            if (catch != NULL) {
                currentInstruction = catch->label->lineNum;
            } else {
                if (scope.isMainScope) {
                    throwError(&gv.data.errorVal);
                } else {
                    return gv;
                }
            }
        } else if (gv.type != NONE) {
            return gv;
        }
        if (ci != currentInstruction) {
            i = currentInstruction;
        }
        currentInstruction++;
    }
    return createNoneGroundValue();
}

GroundValue interpretGroundInstruction(GroundInstruction inst, GroundScope* scope) {
    GroundInstruction copied_inst = copyGroundInstruction(&inst);
    GroundInstruction* in = &copied_inst;

    // Insert variables prefixed with $
    for (size_t i = 0; i < in->args.length; i++) {
        if (in->args.args[i].type == VALREF) {
            GroundVariable* variable = findVariable(*scope->variables, in->args.args[i].value.refName);
            if (variable) {
                // If there is a duplicator, call it (except when returning and getting fields)
                if (variable->value.type == CUSTOM && in->type != RETURN && in->type != GETFIELD) {
                    GroundObject* obj = variable->value.data.customVal;
                    GroundObjectField* duplicator = findField(*obj, "duplicator");
                    if (duplicator != NULL) {
                        if (duplicator->value.type != FUNCTION) {
                            runtimeError(ARG_TYPE_MISMATCH, "duplicator is not a function", in, currentInstruction);
                        }
                        GroundInstruction gi = createGroundInstruction(CALLMETHOD);
                        addArgToInstruction(&gi, createRefGroundArg(DIRREF, in->args.args[i].value.refName));
                        addArgToInstruction(&gi, createRefGroundArg(FNREF, "duplicator"));
                        addArgToInstruction(&gi, createValueGroundArg(variable->value));
                        addArgToInstruction(&gi, createRefGroundArg(DIRREF, "__ground_tmp_duplicate"));
                        GroundValue gv = interpretGroundInstruction(gi, scope);
                        if (gv.type == ERROR) {
                            return gv;
                        }
                        GroundVariable* tmp = findVariable(*scope->variables, "__ground_tmp_duplicate");
                        if (tmp == NULL) {
                            runtimeError(FIXME, "Couldn't find temporary variable (this should never happen)", in, currentInstruction);
                        }
                        in->args.args[i].value.value = copyGroundValue(&tmp->value);
                        in->args.args[i].type = VALUE;
                        deleteVariable(scope->variables, tmp);
                        continue;
                    }
                }
                free(in->args.args[i].value.refName); // Free the strdup'd refName
                in->args.args[i].value.value = copyGroundValue(&variable->value);
                in->args.args[i].type = VALUE;
            } else {
                runtimeError(UNKNOWN_VARIABLE, NULL, in, currentInstruction);
            }
        }
    }
    switch (in->type) {
        // We can safely ignore these instructions, as they have been preprocessed
        case FUN:
        case ENDFUN:
        case STRUCT:
        case ENDSTRUCT:
        case CREATELABEL: {
            break;
        }

        /*
         * CONTROL FLOW
         * These instructions are for controlling how the program is executed.
         * Instructions:
         *    if, jump, end
         */ 
        case IF: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 arguments", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 arguments", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE || in->args.args[0].value.value.type != BOOL) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a bool for arg 0", in, currentInstruction);
            }
            if (in->args.args[1].type != LINEREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a LineRef for arg 1", in, currentInstruction);
            }

            if (in->args.args[0].value.value.data.boolVal) {
                GroundLabel* label = findLabel(*scope->labels, in->args.args[1].value.refName);
                if (label) {
                    currentInstruction = label->lineNum;
                } else {
                    runtimeError(UNKNOWN_LABEL, NULL, in, currentInstruction);
                }
            }
            break;
        }
        case JUMP: {
            if (in->args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 argument", in, currentInstruction);
            }
            if (in->args.length > 1) {
                runtimeError(TOO_MANY_ARGS, "Expecting 1 argument", in, currentInstruction);
            }
            if (in->args.args[0].type != LINEREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a LineRef for arg 1", in, currentInstruction);
            }

            GroundLabel* label = findLabel(*scope->labels, in->args.args[0].value.refName);
            if (label) {
                currentInstruction = label->lineNum;
            } else {
                runtimeError(UNKNOWN_LABEL, NULL, in, currentInstruction);
            }
            break;
        }
        case END: {
            if (in->args.length < 1 || in->args.args[0].type != VALUE || in->args.args[0].value.value.type != INT) {
                exit(0);
            } else {
                exit(in->args.args[0].value.value.data.intVal);
            }
            break;
        }

        /*
         * I/O
         * These instructions take information from the user, and print it out.
         * Instructions:
         *    print, println, input
         */ 
        case PRINT: {
            if (in->args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 or more args", in, currentInstruction);
            }
            for (size_t i = 0; i < in->args.length; i++) {
                if (i != 0) printf(" ");
                printGroundArg(&in->args.args[i]);
            }
            break;
        }
        case PRINTLN: {
            if (in->args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 or more args", in, currentInstruction);
            }
            for (size_t i = 0; i < in->args.length; i++) {
                if (i != 0) printf(" ");
                printGroundArg(&in->args.args[i]);
            }
            printf("\n");
            break;
        }
        case INPUT: {
            if (in->args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 arg", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 1", in, currentInstruction);
            }
            char buffer[256];
            if (fgets(buffer, sizeof(buffer), stdin) != NULL) {
                buffer[strcspn(buffer, "\n")] = '\0';
                addVariable(scope->variables, in->args.args[0].value.refName, createStringGroundValue(buffer));
            } else {
                runtimeError(FIXME, "Failed to read input from console with fgets", in, currentInstruction);
            }
            break;
        }
        case ERRORCMD: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            } else if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[2].value.value.type != INT ) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an int for arg 2", in, currentInstruction);
            }
            
            customError(in->args.args[0], in->args.args[1], in, currentInstruction, in->args.args[2].value.value.data.intVal);
            break;
        }
        /*
         * VARIABLES AND LISTS
         * These instructions are for initializing variables and lists.
         * Instructions:
         *    set, gettype, exists, setlist, setlistat, getlistat, getlistsize, listappend
         */
        case SET: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", in, currentInstruction);
            }

            addVariable(scope->variables, in->args.args[0].value.refName, in->args.args[1].value.value);
            break;
        }
        case GETTYPE: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }

            switch (in->args.args[0].value.value.type) {
                case INT: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("int"));
                    break;
                }
                case DOUBLE: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("double"));
                    break;
                }
                case STRING: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("string"));
                    break;
                }
                case CHAR: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("char"));
                    break;
                }
                case BOOL: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("bool"));
                    break;
                }
                case LIST: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("list"));
                    break;
                }
                case CUSTOM: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("custom"));
                    break;
                }
                case FUNCTION: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("function"));
                    break;
                }
                case STRUCTVAL: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("struct"));
                    break;
                }
                case ANY: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("any"));
                    break;
                }
                case NONE: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("none"));
                    break;
                }
                case ERROR: {
                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("error"));
                    break;
                }
            }

            break;
        } 
        case EXISTS: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 1", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }

            if (findVariable(*scope->variables, in->args.args[0].value.refName)) {
                addVariable(scope->variables, in->args.args[1].value.refName, createBoolGroundValue(true));
            } else {
                addVariable(scope->variables, in->args.args[1].value.refName, createBoolGroundValue(false));
            }
            break;
        }
        case SETLIST: {
            if (listDeprecationWarning) {
                printf("Lists are deprecated, please migrate to using the \"collections\" library soon.\n");
                listDeprecationWarning = false;
            }
            if (in->args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 arg", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 1", in, currentInstruction);
            }
            List newList = createList();
            for (size_t i = 1; i < in->args.length; i++) {
                if (in->args.args[i].type != VALUE) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for all args after arg 1", in, currentInstruction);
                }
                appendToList(&newList, in->args.args[i].value.value);
            }
            addVariable(scope->variables, in->args.args[0].value.refName, createListGroundValue(newList));
            break;
        }
        case SETLISTAT: {
            if (listDeprecationWarning) {
                printf("Lists are deprecated, please migrate to using the \"collections\" library soon.\n");
                listDeprecationWarning = false;
            }
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to a List for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE && in->args.args[1].value.value.type != INT) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int value for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 3", in, currentInstruction);
            }
            GroundVariable* var = findVariable(*scope->variables, in->args.args[0].value.refName);
            if (var == NULL) {
                runtimeError(UNKNOWN_VARIABLE, NULL, in, currentInstruction);
            }
            GroundValue* value = &var->value;
            if (value == NULL) {
                runtimeError(FIXME, NULL, in, currentInstruction);
            }
            if (value->type != LIST) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to a List for arg 1", in, currentInstruction);
            }
            ListAccessStatus status = setListAt(&value->data.listVal, in->args.args[1].value.value.data.intVal, in->args.args[2].value.value);
            switch (status) {
                case LIST_OKAY:
                    break;
                case LIST_OUT_OF_BOUNDS:
                    runtimeError(LIST_ERROR, "Out of bounds index", in, currentInstruction);
                case LIST_FIXME:
                default:
                    runtimeError(FIXME, "List related error", in, currentInstruction);
            }
            break;
        }
        case GETLISTAT: {
            if (listDeprecationWarning) {
                printf("Lists are deprecated, please migrate to using the \"collections\" library soon.\n");
                listDeprecationWarning = false;
            }
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to a List for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE && in->args.args[1].value.value.type != INT) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an integer value for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to a List for arg 3", in, currentInstruction);
            }
            GroundVariable* var = findVariable(*scope->variables, in->args.args[0].value.refName);
            if (var == NULL) {
                runtimeError(UNKNOWN_VARIABLE, NULL, in, currentInstruction);
            }
            GroundValue* value = &var->value;
            if (value == NULL) {
                runtimeError(FIXME, NULL, in, currentInstruction);
            }
            if (value->type != LIST) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to a List for arg 1", in, currentInstruction);
            }
            ListAccess status = getListAt(&value->data.listVal, in->args.args[1].value.value.data.intVal);
            switch (status.status) {
                case LIST_OKAY: {
                    addVariable(scope->variables, in->args.args[2].value.refName, *status.value);
                    break;
                }
                case LIST_OUT_OF_BOUNDS:
                    runtimeError(LIST_ERROR, "Out of bounds index", in, currentInstruction);
                case LIST_FIXME:
                default:
                    runtimeError(FIXME, "List related error", in, currentInstruction);
            }
            break;
        }
        case GETLISTSIZE: {
            if (listDeprecationWarning) {
                printf("Lists are deprecated, please migrate to using the \"collections\" library soon.\n");
                listDeprecationWarning = false;
            }
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to a List for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }
            GroundVariable* var = findVariable(*scope->variables, in->args.args[0].value.refName);
            if (var == NULL) {
                runtimeError(UNKNOWN_VARIABLE, NULL, in, currentInstruction);
            }
            GroundValue* value = &var->value;
            if (value == NULL) {
                runtimeError(FIXME, NULL, in, currentInstruction);
            }
            if (value->type != LIST) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to a List for arg 1", in, currentInstruction);
            }
            addVariable(scope->variables, in->args.args[1].value.refName, createIntGroundValue(value->data.listVal.size));
            break;
        }
        case LISTAPPEND: {
            if (listDeprecationWarning) {
                printf("Lists are deprecated, please migrate to using the \"collections\" library soon.\n");
                listDeprecationWarning = false;
            }
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to a List for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", in, currentInstruction);
            }
            GroundVariable* var = findVariable(*scope->variables, in->args.args[0].value.refName);
            if (var == NULL) {
                runtimeError(UNKNOWN_VARIABLE, NULL, in, currentInstruction);
            }
            GroundValue* value = &var->value;
            if (value == NULL) {
                runtimeError(FIXME, NULL, in, currentInstruction);
            }
            if (value->type != LIST) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to a List for arg 1", in, currentInstruction);
            }
            appendToList(&value->data.listVal, in->args.args[1].value.value);
            break;
        }

        case STOI: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE || in->args.args[0].value.value.type != STRING) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a String for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }
            addVariable(scope->variables, in->args.args[1].value.refName, createIntGroundValue(atoll(in->args.args[0].value.value.data.stringVal)));
            break;
        }
        case STOD: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE || in->args.args[0].value.value.type != STRING) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a String for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }
            addVariable(scope->variables, in->args.args[1].value.refName, createDoubleGroundValue(atof(in->args.args[0].value.value.data.stringVal)));
            break;
        }
        case ITOC: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE || in->args.args[0].value.value.type != INT) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }
            addVariable(scope->variables, in->args.args[1].value.refName, createCharGroundValue((char)in->args.args[0].value.value.data.intVal));
            break;
        }
        case CTOI: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE || in->args.args[0].value.value.type != CHAR) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Char for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }
            addVariable(scope->variables, in->args.args[1].value.refName, createIntGroundValue((int)in->args.args[0].value.value.data.charVal));
            break;
        }
        case TOSTRING: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }
            GroundValue* value = &in->args.args[0].value.value;
            char buf[256];
            switch (value->type) {
                case INT: {
                    snprintf(buf, sizeof(buf), "%" PRId64, value->data.intVal);
                    break;
                }
                case DOUBLE: {
                    snprintf(buf, sizeof(buf), "%f", value->data.doubleVal);
                    break;
                }
                case STRING: {
                    snprintf(buf, sizeof(buf), "%s", value->data.stringVal);
                    break;
                }
                case CHAR: {
                    buf[0] = value->data.charVal;
                    buf[1] = '\0';
                    break;
                }
                case BOOL: {
                    if (value->data.boolVal) {
                        snprintf(buf, sizeof(buf), "true");
                    } else {
                        snprintf(buf, sizeof(buf), "false");
                    }
                    break;
                }
                case LIST: {
                    snprintf(buf, sizeof(buf), "<list>");
                    break;
                }
                case FUNCTION: {
                    snprintf(buf, sizeof(buf), "<function>");
                    break;
                }
                case CUSTOM: {
                    snprintf(buf, sizeof(buf), "<custom>");
                    break;
                }
                case NONE:
                default: {
                    snprintf(buf, sizeof(buf), "<default>");
                    break;

                }
            }
            addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue(buf));

            break;
        }

        /*
         * MATHS
         * These instructions allow running mathematical operations on values.
         * Instructions:
         *    add, subtract, multiply, divide
         */ 
        case ADD: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", in, currentInstruction);
            }

            GroundValue* left = &in->args.args[0].value.value;
            GroundValue* right = &in->args.args[1].value.value;

            if (left->type == STRING) {
                if (right->type != STRING) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting a String for arg 2", in, currentInstruction);
                }
                char* newString = malloc(strlen(left->data.stringVal) + strlen(right->data.stringVal));
                strcpy(newString, left->data.stringVal);
                strcat(newString, right->data.stringVal);

                addVariable(scope->variables, in->args.args[2].value.refName, createStringGroundValue(newString));
            }
            else if (left->type == INT || left->type == DOUBLE) {
                if (right->type != INT && right->type != DOUBLE) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 2", in, currentInstruction);
                }

                if (left->type == DOUBLE || right->type == DOUBLE) {
                    double result = 0;
                    
                    if (left->type == INT) {
                        result += left->data.intVal;
                    } else if (left->type == DOUBLE) {
                        result += left->data.doubleVal;
                    }
    
                    if (right->type == INT) {
                        result += right->data.intVal;
                    } else if (right->type == DOUBLE) {
                        result += right->data.doubleVal;
                    }

                    addVariable(scope->variables, in->args.args[2].value.refName, createDoubleGroundValue(result));
                } else {
                    int64_t result = left->data.intVal + right->data.intVal;
                    addVariable(scope->variables, in->args.args[2].value.refName, createIntGroundValue(result));
                }
            } else {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int, Double, or String for arg 1", in, currentInstruction);
            }
            break;
        }
        case SUBTRACT: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", in, currentInstruction);
            }

            GroundValue* left = &in->args.args[0].value.value;
            GroundValue* right = &in->args.args[1].value.value;

            if (left->type == INT || left->type == DOUBLE) {
                if (right->type != INT && right->type != DOUBLE) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 2", in, currentInstruction);
                }

                if (left->type == DOUBLE || right->type == DOUBLE) {
                    double result = 0;
                    
                    if (left->type == INT) {
                        result = left->data.intVal;
                    } else if (left->type == DOUBLE) {
                        result = left->data.doubleVal;
                    }
    
                    if (right->type == INT) {
                        result += right->data.intVal;
                    } else if (right->type == DOUBLE) {
                        result += right->data.doubleVal;
                    }

                    addVariable(scope->variables, in->args.args[2].value.refName, createDoubleGroundValue(result));
                } else {
                    int64_t result = left->data.intVal - right->data.intVal;
                    addVariable(scope->variables, in->args.args[2].value.refName, createIntGroundValue(result));
                }
            } else {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 1", in, currentInstruction);
            }
            break;
        }
        case MULTIPLY: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", in, currentInstruction);
            }

            GroundValue* left = &in->args.args[0].value.value;
            GroundValue* right = &in->args.args[1].value.value;

            if (left->type == INT || left->type == DOUBLE) {
                if (right->type != INT && right->type != DOUBLE) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 2", in, currentInstruction);
                }

                if (left->type == DOUBLE || right->type == DOUBLE) {
                    double result = 1.0;
                    
                    if (left->type == INT) {
                        result *= left->data.intVal;
                    } else if (left->type == DOUBLE) {
                        result += left->data.doubleVal;
                    }
    
                    if (right->type == INT) {
                        result *= right->data.intVal;
                    } else if (right->type == DOUBLE) {
                        result += right->data.doubleVal;
                    }

                    addVariable(scope->variables, in->args.args[2].value.refName, createDoubleGroundValue(result));
                } else {
                    int64_t result = left->data.intVal * right->data.intVal;
                    addVariable(scope->variables, in->args.args[2].value.refName, createIntGroundValue(result));
                }
            } else {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 1", in, currentInstruction);
            }
            break;
        }
        case DIVIDE: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", in, currentInstruction);
            }

            GroundValue* left = &in->args.args[0].value.value;
            GroundValue* right = &in->args.args[1].value.value;

            if (left->type == INT || left->type == DOUBLE) {
                if (right->type != INT && right->type != DOUBLE) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 2", in, currentInstruction);
                }
                
                if (right->type == INT && right->data.intVal == 0) {
                    runtimeError(MATH_ERROR, "Division by zero", in, currentInstruction);
                }

                if (left->type == DOUBLE || right->type == DOUBLE) {
                    double result = 0;
                    
                    if (left->type == INT) {
                        result = left->data.intVal;
                    } else if (left->type == DOUBLE) {
                        result = left->data.doubleVal;
                    }
    
                    if (right->type == INT) {
                        result /= right->data.intVal;
                    } else if (right->type == DOUBLE) {
                        result /= right->data.doubleVal;
                    }

                    addVariable(scope->variables, in->args.args[2].value.refName, createDoubleGroundValue(result));
                } else {
                    int64_t result = left->data.intVal / right->data.intVal;
                    addVariable(scope->variables, in->args.args[2].value.refName, createIntGroundValue(result));
                }
            } else {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 1", in, currentInstruction);
            }
            break;
        }
        case OR: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting at least 2 args", in, currentInstruction);
            }
            for (size_t i = 0; i < in->args.length - 1; i++) {
                if (in->args.args[i].type != VALUE) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting a value for all args except last", in, currentInstruction);
                }
                if (in->args.args[i].value.value.type != INT) {
                    runtimeError(ARG_TYPE_MISMATCH, "Expecting an int for all args except last", in, currentInstruction);
                }
            }
            if (in->args.args[in->args.length-1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a direct reference for last argument", in, currentInstruction);
            }
            
            int64_t result = 0;
            for (size_t i = 0; i < in->args.length - 1; i++) {
                result |= in->args.args[i].value.value.data.intVal;
            }
            addVariable(scope->variables, in->args.args[in->args.length-1].value.refName, createIntGroundValue(result));
            break;
        }
        
        /*
         * STRING OPERATIONS 
         * Allows easier manipulation of strings.
         * Instructions: 
         *    getstrcharat, getstrsize
        */
        case GETSTRCHARAT: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE && in->args.args[0].value.value.type != STRING) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a String for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE && in->args.args[1].value.value.type != INT) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", in, currentInstruction);
            }
            char* str = in->args.args[0].value.value.data.stringVal;
            size_t idx = in->args.args[1].value.value.data.intVal;
            if (idx < strlen(str)) {
                addVariable(scope->variables, in->args.args[2].value.refName, createCharGroundValue(str[idx]));
            } else {
                runtimeError(STRING_ERROR, "Out of bounds index", in, currentInstruction);
            }
            break;
        }
        case GETSTRSIZE: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE && in->args.args[0].value.value.type != STRING) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a String for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }
            addVariable(scope->variables, in->args.args[1].value.refName, createIntGroundValue(strlen(in->args.args[0].value.value.data.stringVal)));
            break;
        }

        /*
         * COMPARISONS
         * Allows comparing values.
         * Instructions:
         *    equal, inequal, not, greater, lesser
         */
        case EQUAL: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", in, currentInstruction);
            }

            GroundValue* left = &in->args.args[0].value.value;
            GroundValue* right = &in->args.args[1].value.value;

            if (left->type != right->type) {
                if (left->type == INT && right->type == DOUBLE) {
                    bool cond = (left->data.intVal == right->data.doubleVal);
                    addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                } else if (left->type == DOUBLE && right->type == INT) {
                    bool cond = (left->data.doubleVal == right->data.intVal);
                    addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                } else {
                    addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(false));
                }
            } else {
                switch (left->type) {
                    case INT: {
                        bool cond = (left->data.intVal == right->data.intVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    case DOUBLE: {
                        bool cond = (left->data.doubleVal == right->data.doubleVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    case STRING: {
                        bool cond = (strcmp(left->data.stringVal, right->data.stringVal) == 0);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    case CHAR: {
                        bool cond = (left->data.charVal == right->data.charVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    case BOOL: {
                        bool cond = (left->data.boolVal == right->data.boolVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    default: {
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(false));
                        break;
                    }
                }
            }
            break;
        }
        case INEQUAL: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", in, currentInstruction);
            }

            GroundValue* left = &in->args.args[0].value.value;
            GroundValue* right = &in->args.args[1].value.value;

            if (left->type != right->type) {
                if (left->type == INT && right->type == DOUBLE) {
                    bool cond = (left->data.intVal != right->data.doubleVal);
                    addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                } else if (left->type == DOUBLE && right->type == INT) {
                    bool cond = (left->data.doubleVal != right->data.intVal);
                    addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                } else {
                    addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(false));
                }
            } else {
                switch (left->type) {
                    case INT: {
                        bool cond = (left->data.intVal != right->data.intVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    case DOUBLE: {
                        bool cond = (left->data.doubleVal != right->data.doubleVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    case STRING: {
                        bool cond = (strcmp(left->data.stringVal, right->data.stringVal) != 0);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    case CHAR: {
                        bool cond = (left->data.charVal != right->data.charVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    case BOOL: {
                        bool cond = (left->data.boolVal != right->data.boolVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    default: {
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(true));
                        break;
                    }
                }
            }
            break;
        }
        case NOT: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE && in->args.args[0].value.value.type != BOOL) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Bool for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }

            bool condition = !in->args.args[0].value.value.data.boolVal;

            addVariable(scope->variables, in->args.args[1].value.refName, createBoolGroundValue(condition));
            break;
        }
        case GREATER: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", in, currentInstruction);
            }

            GroundValue* left = &in->args.args[0].value.value;
            GroundValue* right = &in->args.args[1].value.value;

            if (left->type != INT && left->type != DOUBLE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 1", in, currentInstruction);
            } else if (right->type != INT && right->type != DOUBLE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 2", in, currentInstruction);
            }

            if (left->type != right->type) {
                if (left->type == INT && right->type == DOUBLE) {
                    bool cond = (left->data.intVal > right->data.doubleVal);
                    addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                } else if (left->type == DOUBLE && right->type == INT) {
                    bool cond = (left->data.doubleVal > right->data.intVal);
                    addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                } else {
                    runtimeError(FIXME, "Uncaught invalid type", in, currentInstruction);
                }
            } else {
                switch (left->type) {
                    case INT: {
                        bool cond = (left->data.intVal > right->data.intVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    case DOUBLE: {
                        bool cond = (left->data.doubleVal > right->data.doubleVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    default: {
                        runtimeError(FIXME, "Uncaught invalid type", in, currentInstruction);
                        break;
                    }
                }
            }
            break;
        }
        case LESSER: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", in, currentInstruction);
            }

            GroundValue* left = &in->args.args[0].value.value;
            GroundValue* right = &in->args.args[1].value.value;

            if (left->type != INT && left->type != DOUBLE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 1", in, currentInstruction);
            } else if (right->type != INT && right->type != DOUBLE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int or Double for arg 2", in, currentInstruction);
            }

            if (left->type != right->type) {
                if (left->type == INT && right->type == DOUBLE) {
                    bool cond = (left->data.intVal < right->data.doubleVal);
                    addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                } else if (left->type == DOUBLE && right->type == INT) {
                    bool cond = (left->data.doubleVal < right->data.intVal);
                    addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                } else {
                    runtimeError(FIXME, "Uncaught invalid type", in, currentInstruction);
                }
            } else {
                switch (left->type) {
                    case INT: {
                        bool cond = (left->data.intVal < right->data.intVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    case DOUBLE: {
                        bool cond = (left->data.doubleVal < right->data.doubleVal);
                        addVariable(scope->variables, in->args.args[2].value.refName, createBoolGroundValue(cond));
                        break;
                    }
                    default: {
                        runtimeError(FIXME, "Uncaught invalid type", in, currentInstruction);
                        break;
                    }
                }
            }
            break;
        }
        /*
        * FUNCTIONS
        * Allows execution of functions in Ground.
        * Instructions:
        *     fun, return, endfun, pusharg, call
        */
        case RETURN: {
            if (in->args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 arg", in, currentInstruction);
            }
            if (in->args.length > 1) {
                runtimeError(TOO_MANY_ARGS, "Expecting 1 arg", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 1", in, currentInstruction);
            }
            return in->args.args[0].value.value;
        }
        case CALL: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 or more args", in, currentInstruction);
            }
            if (in->args.args[0].type != FNREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a FunctionRef for arg 1", in, currentInstruction);
            }
            if (in->args.args[in->args.length - 1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef as the last arg", in, currentInstruction);
            }
            GroundVariable* var = findVariable(*scope->variables, in->args.args[0].value.refName);
            if (var == NULL) {
                runtimeError(UNKNOWN_VARIABLE, "Function not found", in, currentInstruction);
            }
            GroundValue* value = &var->value;
            if (value->type != FUNCTION) {
                runtimeError(UNKNOWN_VARIABLE, "Provided reference does not reference a function", in, currentInstruction);
            }
            GroundFunction* function = value->data.fnVal;
            if (function->argSize < in->args.length - 2) {
                runtimeError(TOO_FEW_ARGS, "Incorrect amount of arguments provided for function", in, currentInstruction);
            }
            if (function->argSize > in->args.length - 2) {
                runtimeError(TOO_MANY_ARGS, "Incorrect amount of arguments provided for function", in, currentInstruction);
            }
            
            if (function->isNative) {
                List argsList = createList();
                for (size_t i = 0; i < function->argSize; i++) {
                    if (in->args.args[i + 1].type != VALUE) {
                        runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value", in, currentInstruction);
                    }
                    if (function->nativeFn) {
                        if (function->args[i].type != ANY && in->args.args[i + 1].value.value.type != function->args[i].type) {
                            runtimeError(ARG_TYPE_MISMATCH, "Mismatched function argument types", in, currentInstruction);
                        }
                    } else {
                        if (function->args[i].type != ANY && !checkFnTypes(&in->args.args[i + 1].value.value, &function->args[i])) {
                            runtimeError(ARG_TYPE_MISMATCH, "Mismatched function argument types", in, currentInstruction);
                        }
                    }
                    appendToList(&argsList, in->args.args[i + 1].value.value);
                }
                
                if (function->nativeFn) {
                    GroundValue returnValue = function->nativeFn(scope, argsList);
                    if (returnValue.type == ERROR) {
                        returnValue.data.errorVal.line = currentInstruction;
                        returnValue.data.errorVal.hasLine = true;
                        returnValue.data.errorVal.where = in;
                        return returnValue;
                    }
                    if (returnValue.type != ANY && returnValue.type != function->returnType) {
                         runtimeError(RETURN_TYPE_MISMATCH, "Unexpected return value type from native function", in, currentInstruction);
                    }
                    addVariable(scope->variables, in->args.args[in->args.length - 1].value.refName, returnValue);
                }
                free(argsList.values); 
            } else {
                GroundScope newScope = copyGroundScope(&function->closure);
                for (size_t i = 0; i < function->argSize; i++) {
                    if (in->args.args[i + 1].type != VALUE) {
                        runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value", in, currentInstruction);
                    }
                    if (function->args[i].type != ANY && !checkFnTypes(&in->args.args[i + 1].value.value, &function->args[i])) {
                        runtimeError(ARG_TYPE_MISMATCH, "Mismatched function argument types", in, currentInstruction);
                    }
                    addVariable(newScope.variables, function->args[i].name, in->args.args[i + 1].value.value);
                }
                size_t currentCurrentInstruction = currentInstruction;
                currentInstruction = function->startLine;
                GroundValue returnValue = interpretGroundProgram(&function->program, &newScope);
                if (returnValue.type == ERROR) {
                    return returnValue;
                }
                if (function->returnType != ANY && returnValue.type != function->returnType) {
                    runtimeError(RETURN_TYPE_MISMATCH, "Unexpected return value type from function", in, currentInstruction);
                }

                GroundVariable* var, *tmp;

                HASH_ITER(hh, *newScope.variables, var, tmp) {
                    deleteVariable(newScope.variables, var);
                }

                addVariable(scope->variables, in->args.args[in->args.length - 1].value.refName, returnValue);
                currentInstruction = currentCurrentInstruction;
            }
            break;
        }
        case CALLMETHOD: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 or more args", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to an object for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != FNREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a FunctionRef for arg 2", in, currentInstruction);
            }
            if (in->args.args[in->args.length - 1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef as the last arg", in, currentInstruction);
            }

            GroundVariable* objvar = findVariable(*scope->variables, in->args.args[0].value.refName);
            if (objvar == NULL) {
                runtimeError(UNKNOWN_VARIABLE, "Object not found", in, currentInstruction);
            }
            GroundValue* obj = &objvar->value;
            if (obj->type != CUSTOM) {
                runtimeError(UNKNOWN_VARIABLE, "Provided reference does not reference an object", in, currentInstruction);
            }

            GroundObjectField* fnvar = findField(*obj->data.customVal, in->args.args[1].value.refName);
            if (fnvar == NULL) {
                runtimeError(UNKNOWN_VARIABLE, "Method not found inside specified object", in, currentInstruction);
            }
            if (fnvar->value.type != FUNCTION) {
                runtimeError(UNKNOWN_VARIABLE, "Provided reference does not reference a method", in, currentInstruction);
            }
            GroundFunction* function = fnvar->value.data.fnVal;
            if (function->argSize < in->args.length - 3) {
                runtimeError(TOO_FEW_ARGS, "Incorrect amount of arguments provided for function", in, currentInstruction);
            }
            if (function->argSize > in->args.length - 3) {
                runtimeError(TOO_MANY_ARGS, "Incorrect amount of arguments provided for function", in, currentInstruction);
            }
            if (function->isNative) {
                List argsList = createList();
                for (size_t i = 0; i < function->argSize; i++) {
                    if (in->args.args[i + 2].type != VALUE) {
                        runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value", in, currentInstruction);
                    }
                    if (function->nativeFn) {
                        if (function->args[i].type != ANY && in->args.args[i + 2].value.value.type != function->args[i].type) {
                            runtimeError(ARG_TYPE_MISMATCH, "Mismatched function argument types", in, currentInstruction);
                        }
                    } else {
                        if (function->args[i].type != ANY && !checkFnTypes(&in->args.args[i + 2].value.value, &function->args[i])) {
                            runtimeError(ARG_TYPE_MISMATCH, "Mismatched function argument types", in, currentInstruction);
                        }
                    }
                    appendToList(&argsList, in->args.args[i + 2].value.value);
                }

                GroundScope newscope = {
                    .labels = NULL,
                    .variables = malloc(sizeof(GroundVariable*)),
                    .isMainScope = false
                };

                if (newscope.variables == NULL) {
                    runtimeError(FIXME, "Failed to allocate memory", in, currentInstruction);
                }

                *newscope.variables = NULL;

                GroundObjectField* tmp;
                GroundObjectField* el;

                HASH_ITER(hh, obj->data.customVal->fields, el, tmp) {
                    addVariable(newscope.variables, el->id, el->value);
                }

                if (function->nativeFn) {
                    GroundValue returnValue = function->nativeFn(&newscope, argsList);
                    if (returnValue.type == ERROR) {
                        returnValue.data.errorVal.line = currentInstruction;
                        returnValue.data.errorVal.hasLine = true;
                        returnValue.data.errorVal.where = in;
                        if (scope->isMainScope) {
                            throwError(&returnValue.data.errorVal);
                        }
                        return returnValue;
                    }
                    if (function->returnType != ANY && returnValue.type != function->returnType) {
                         runtimeError(RETURN_TYPE_MISMATCH, "Unexpected return value type from native function", in, currentInstruction);
                    }
                    addVariable(scope->variables, in->args.args[in->args.length - 1].value.refName, returnValue);

                    // Copy back modified variables
                    HASH_ITER(hh, obj->data.customVal->fields, el, tmp) {
                        el->value = findVariable(*newscope.variables, el->id)->value;
                    }
                }
                free(argsList.values);
            } else {
                GroundScope newScope = copyGroundScope(&function->closure);
                for (size_t i = 0; i < function->argSize; i++) {
                    if (in->args.args[i + 2].type != VALUE) {
                        runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value", in, currentInstruction);
                    }
                    //if (in->args.args[i + 1].value.value.type != function->args[i].type) {
                    if (function->args[i].type != ANY && !checkFnTypes(&in->args.args[i + 2].value.value, &function->args[i])) {
                        runtimeError(ARG_TYPE_MISMATCH, "Mismatched function argument types", in, currentInstruction);
                    }
                    addVariable(newScope.variables, function->args[i].name, in->args.args[i + 2].value.value);
                }
                // Add the object to the scope
                addVariable(newScope.variables, "self", *obj);
                size_t currentCurrentInstruction = currentInstruction;
                currentInstruction = function->startLine;
                GroundValue returnValue = interpretGroundProgram(&function->program, &newScope);
                if (returnValue.type == ERROR) {
                    return returnValue;
                }
                if (function->returnType != ANY && returnValue.type != function->returnType) {
                    runtimeError(RETURN_TYPE_MISMATCH, "Unexpected return value type from function", in, currentInstruction);
                }
                addVariable(scope->variables, in->args.args[in->args.length - 1].value.refName, returnValue);
                currentInstruction = currentCurrentInstruction;

                // Copy out the object
                GroundVariable* objvar = findVariable(*newScope.variables, "self");
                if (objvar == NULL) {
                    runtimeError(UNKNOWN_VARIABLE, "self not found in scope, did you drop the object?", in, currentInstruction);
                }
                addVariable(scope->variables, in->args.args[0].value.refName, objvar->value);
            }

            break;

        }

        case USE: {
            if (in->args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 arg", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE || in->args.args[0].value.value.type != STRING) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a String for arg 1", in, currentInstruction);
            }
            
            char* libName = in->args.args[0].value.value.data.stringVal;
            char path[1024];
            int found = 0;
            
            char* envPath = getenv("GROUND_LIBS");
            
            if (envPath) {
                snprintf(path, sizeof(path), "%s/%s.grnd", envPath, libName);
                if (access(path, F_OK) == 0) found = 1;
            }
            
            if (!found) {
                snprintf(path, sizeof(path), "/usr/lib/ground/%s.grnd", libName);
                if (access(path, F_OK) == 0) found = 1;
            }
            
            if (!found) {
                snprintf(path, sizeof(path), "%s.grnd", libName);
                 if (access(path, F_OK) == 0) found = 1;
            }

            if (!found) {
                char errorMsg[1100];
                snprintf(errorMsg, sizeof(errorMsg), "Could not find library: %s", libName);
                runtimeError(FIXME, errorMsg, in, currentInstruction);
            }

            char* fileContents = getFileContents(path);

            GroundProgram program = parseFile(fileContents);
            free(fileContents);

            GroundScope newScope = {
                    .variables = scope->variables,
            .labels = malloc(sizeof(GroundLabel*)),
            .isMainScope = false
            };

            *newScope.labels = NULL;

            int ci = currentInstruction;
            
            interpretGroundProgram(&program, &newScope);

            currentInstruction = ci;

            break;
        }

        case EXTERN: {
	    #ifdef _WIN32
	    runtimeError(FIXME, "No Windows support for extern, sucker", in, currentInstruction);
	    #endif
	    #ifndef _WIN32
            if (in->args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 arg", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE || in->args.args[0].value.value.type != STRING) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a String for arg 1", in, currentInstruction);
            }
            
            char* libName = in->args.args[0].value.value.data.stringVal;
            char path[1024];
            int found = 0;

            // care about mac and windows later
            char* extension = "so";
            
            char* envPath = getenv("GROUND_LIBS");
            
            if (envPath) {
                snprintf(path, sizeof(path), "%s/%s.%s", envPath, libName, extension);
                if (access(path, F_OK) == 0) found = 1;
            }
            
            if (!found) {
                snprintf(path, sizeof(path), "/usr/lib/ground/%s.%s", libName, extension);
                if (access(path, F_OK) == 0) found = 1;
            }
             if (!found) {
                snprintf(path, sizeof(path), "./%s.%s", libName, extension);
                 if (access(path, F_OK) == 0) found = 1;
            }

            if (!found) {
                char errorMsg[1100];
                snprintf(errorMsg, sizeof(errorMsg), "Could not find external library: %s, in path: %s", libName, path);
                runtimeError(FIXME, errorMsg, in, currentInstruction);
            }

            void* handle = dlopen(path, RTLD_LAZY);
            if (!handle) {
                runtimeError(FIXME, dlerror(), in, currentInstruction);
            }
            
            typedef void (*GroundInitFn)(GroundScope*);
            GroundInitFn initFn = (GroundInitFn)dlsym(handle, "ground_init");
            
            if (!initFn) {
                 runtimeError(FIXME, "Could not find 'ground_init' symbol in library", in, currentInstruction);
            }
            
            initFn(scope);
	    #endif
            break;
        }

        case INIT: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != TYPEREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a TypeRef for arg 2", in, currentInstruction);
            }

            GroundValue gv;

            switch (stringToValueType(in->args.args[1].value.refName)) {
                case INT: {
                    gv = createIntGroundValue(0);
                    break;
                }
                case DOUBLE: {
                    gv = createDoubleGroundValue(0);
                    break;
                }
                case STRING: {
                    gv = createStringGroundValue("");
                    break;
                }
                case CHAR: {
                    gv = createCharGroundValue('\0');
                    break;
                }
                case BOOL: {
                    gv = createBoolGroundValue(false);
                    break;
                }
                case LIST: {
                    gv = createListGroundValue(createList());
                    break;
                }
                case FUNCTION: {
                    GroundFunction* gf = createGroundFunction();
                    gf->returnType = NONE;
                    gv = createFunctionGroundValue(gf);
                    break;
                }
                case STRUCTVAL: {
                    gv.type = STRUCTVAL;
                    gv.data.structVal = malloc(sizeof(GroundStruct));
                    *gv.data.structVal = createStruct();
                    break;
                }
                case CUSTOM: {
                    GroundVariable* var = findVariable(*scope->variables, in->args.args[1].value.refName);
                    if (var == NULL) {
                        runtimeError(UNKNOWN_VARIABLE, "Couldn't find the specified type", in, currentInstruction);
                    }
                    if (var->value.type != STRUCTVAL) {
                        runtimeError(ARG_TYPE_MISMATCH, "TypeRef does not reference a struct", in, currentInstruction);
                    }
                    GroundStruct* gstruct = var->value.data.structVal;
                    gv.type = CUSTOM;
                    gv.data.customVal = malloc(sizeof(GroundObject));
                    *gv.data.customVal = createObject(*gstruct);
                    gv.customType = gstruct;
                    break;
                }
                case NONE: {
                    gv.type = NONE;
                    break;
                }
                default: {
                    runtimeError(FIXME, "Reached should-be-impossible state", in, currentInstruction);
                    break;
                }
            }
            addVariable(scope->variables, in->args.args[0].value.refName, gv);

            break;
        }

        /*
         * OBJECTS
         * Allows manipulation of Ground objects.
         */
        // getfield $obj &field &result
        case GETFIELD: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Object for arg 1", in, currentInstruction);
            }
            if (in->args.args[0].value.value.type != CUSTOM) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting an Object for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", in, currentInstruction);
            }

            GroundObjectField* field = findField(*in->args.args[0].value.value.data.customVal, in->args.args[1].value.refName);
            if (field == NULL) {
                runtimeError(UNKNOWN_VARIABLE, "Struct does not contain that field", in, currentInstruction);
            }
            addVariable(scope->variables, in->args.args[2].value.refName, field->value);
            
            break;
        }
        // setfield &obj &field $value
        case SETFIELD: {
            if (in->args.length < 3) {
                runtimeError(TOO_FEW_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.length > 3) {
                runtimeError(TOO_MANY_ARGS, "Expecting 3 args", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to an Object for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
            }
            if (in->args.args[2].type != VALUE) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 3", in, currentInstruction);
            }

            GroundVariable* var = findVariable(*scope->variables, in->args.args[0].value.refName);
            if (var == NULL) {
                runtimeError(UNKNOWN_VARIABLE, "Could not find that object", in, currentInstruction);
            }
            if (var->value.type != CUSTOM) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef to an Object for arg 1", in, currentInstruction);
            }

            GroundObjectField* field = findField(*var->value.data.customVal, in->args.args[1].value.refName);
            if (field == NULL) {
                runtimeError(UNKNOWN_VARIABLE, "Struct does not contain that field", in, currentInstruction);
            }
            if (field->value.type != in->args.args[2].value.value.type) {
                runtimeError(ARG_TYPE_MISMATCH, "Field type and provided type do not match", in, currentInstruction);
            }

            field->value = copyGroundValue(&in->args.args[2].value.value);
            break;
        }

        case DROP: {
            if (in->args.length < 1) {
                runtimeError(TOO_FEW_ARGS, "Expecting 1 arg", in, currentInstruction);
            }
            if (in->args.length > 1) {
                runtimeError(TOO_MANY_ARGS, "Expecting 1 arg", in, currentInstruction);
            }
            if (in->args.args[0].type != DIRREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 1", in, currentInstruction);
            }
            GroundVariable* var = findVariable(*scope->variables, in->args.args[0].value.refName);
            if (!var) {
                runtimeError(UNKNOWN_VARIABLE, NULL, in, currentInstruction);
            }
            deleteVariable(scope->variables, var);
            break;
        }


        case THROW: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE || in->args.args[0].value.value.type != STRING) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a String value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != VALUE || in->args.args[1].value.value.type != STRING) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a String value for arg 2", in, currentInstruction);
            }

            return createErrorGroundValue(
                createGroundError(
                    in->args.args[1].value.value.data.stringVal,
                    in->args.args[0].value.value.data.stringVal,
                    in,
                    (size_t*)&currentInstruction
                )
            );
        }
        case CATCH: {
            if (in->args.length < 2) {
                runtimeError(TOO_FEW_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.length > 2) {
                runtimeError(TOO_MANY_ARGS, "Expecting 2 args", in, currentInstruction);
            }
            if (in->args.args[0].type != VALUE || in->args.args[0].value.value.type != STRING) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a String value for arg 1", in, currentInstruction);
            }
            if (in->args.args[1].type != LINEREF) {
                runtimeError(ARG_TYPE_MISMATCH, "Expecting a LineRef for arg 2", in, currentInstruction);
            }

            GroundLabel* label = findLabel(*scope->labels, in->args.args[1].value.refName);
            if (label == NULL) {
                runtimeError(UNKNOWN_LABEL, NULL, in, currentInstruction);
            }

            GroundCatch catch = {
                .label = label,
            };
            snprintf(catch.id, sizeof(catch.id), "%s", in->args.args[0].value.value.data.stringVal);

            HASH_ADD_STR(*scope->catches, id, &catch);
            break;
        }

        /*
         * License for REPL
         */
        
        case LICENSE: {
            printf("                    GNU GENERAL PUBLIC LICENSE\n                       Version 3, 29 June 2007\n\n Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n                            Preamble\n\n  The GNU General Public License is a free, copyleft license for\nsoftware and other kinds of works.\n\n  The licenses for most software and other practical works are designed\nto take away your freedom to share and change the works.  By contrast,\nthe GNU General Public License is intended to guarantee your freedom to\nshare and change all versions of a program--to make sure it remains free\nsoftware for all its users.  We, the Free Software Foundation, use the\nGNU General Public License for most of our software; it applies also to\nany other work released this way by its authors.  You can apply it to\nyour programs, too.\n\n  When we speak of free software, we are referring to freedom, not\nprice.  Our General Public Licenses are designed to make sure that you\nhave the freedom to distribute copies of free software (and charge for\nthem if you wish), that you receive source code or can get it if you\nwant it, that you can change the software or use pieces of it in new\nfree programs, and that you know you can do these things.\n\n  To protect your rights, we need to prevent others from denying you\nthese rights or asking you to surrender the rights.  Therefore, you have\ncertain responsibilities if you distribute copies of the software, or if\nyou modify it: responsibilities to respect the freedom of others.\n\n  For example, if you distribute copies of such a program, whether\ngratis or for a fee, you must pass on to the recipients the same\nfreedoms that you received.  You must make sure that they, too, receive\nor can get the source code.  And you must show them these terms so they\nknow their rights.\n\n  Developers that use the GNU GPL protect your rights with two steps:\n(1) assert copyright on the software, and (2) offer you this License\ngiving you legal permission to copy, distribute and/or modify it.\n\n  For the developers' and authors' protection, the GPL clearly explains\nthat there is no warranty for this free software.  For both users' and\nauthors' sake, the GPL requires that modified versions be marked as\nchanged, so that their problems will not be attributed erroneously to\nauthors of previous versions.\n\n  Some devices are designed to deny users access to install or run\nmodified versions of the software inside them, although the manufacturer\ncan do so.  This is fundamentally incompatible with the aim of\nprotecting users' freedom to change the software.  The systematic\npattern of such abuse occurs in the area of products for individuals to\nuse, which is precisely where it is most unacceptable.  Therefore, we\nhave designed this version of the GPL to prohibit the practice for those\nproducts.  If such problems arise substantially in other domains, we\nstand ready to extend this provision to those domains in future versions\nof the GPL, as needed to protect the freedom of users.\n\n  Finally, every program is threatened constantly by software patents.\nStates should not allow patents to restrict development and use of\nsoftware on general-purpose computers, but in those that do, we wish to\navoid the special danger that patents applied to a free program could\nmake it effectively proprietary.  To prevent this, the GPL assures that\npatents cannot be used to render the program non-free.\n\n  The precise terms and conditions for copying, distribution and\nmodification follow.\n\n                       TERMS AND CONDITIONS\n\n  0. Definitions.\n\n  \"This License\" refers to version 3 of the GNU General Public License.\n\n  \"Copyright\" also means copyright-like laws that apply to other kinds of\nworks, such as semiconductor masks.\n\n  \"The Program\" refers to any copyrightable work licensed under this\nLicense.  Each licensee is addressed as \"you
            break;
        }

        
        default: {
            runtimeError(FIXME, "Currently unimplemented instruction", in, currentInstruction);
        }
    }

    freeGroundInstruction(in);
    return createNoneGroundValue();
}