lonely-tiger/Compiler.c

#include <stdarg.h>
#include <stdio.h>

#include "Compiler.h"
#include "FunctionMap.h"
#include "Operation.h"
#include "StringIntMap.h"
#include "Tokenizer.h"

#define MAX_BYTES (1024 * 1024)
#define ERROR_LENGTH 256
#define VARS 256

static char error[ERROR_LENGTH] = {'\0'};

static ByteCode* code;

static int16 line = 1;

static int varIndex = 0;
static StringIntMap vars[2];
static FunctionMap functions;

static void cError(const char* format, ...) {
    va_list args;
    va_start(args, format);
    vsnprintf(error, ERROR_LENGTH, format, args);
    va_end(args);
}

static int cAddVar(const char* var) {
    int index = vars[varIndex].entries;
    simAdd(vars + varIndex, var, &index);
    return index;
}

static void cUnexpectedToken(Token t) {
    cError("unexpected token on line %d: %s", line, tGetTokenName(t));
}

static void cAddOperation(Operation token) {
    unsigned char c = token;
    bcAddBytes(code, &c, 1);
}

static int cReserveInt() {
    return bcReserveBytes(code, sizeof(int));
}

static void cSetInt(int p, int i) {
    bcSetBytes(code, p, &i, sizeof(int));
}

static void cAddInt(int i) {
    bcAddBytes(code, &i, sizeof(int));
}

static void cAddInt16(int16 i) {
    bcAddBytes(code, &i, sizeof(int16));
}

static void cAddFloat(float f) {
    bcAddBytes(code, &f, sizeof(float));
}

static Token cReadTokenAndLine() {
    Token t = tReadToken();
    if(tReadInt16(&line)) {
        return t;
    }
    return T_END;
}

static bool cConsumeToken(Token wanted) {
    Token t = cReadTokenAndLine();
    if(wanted == t) {
        return true;
    }
    cError("unexpected token on line %d: expected '%s' got '%s'", line, tGetTokenName(wanted), tGetTokenName(t));
    return false;
}

static bool cConsumeTokenIf(Token t) {
    if(tPeekToken() == t) {
        cReadTokenAndLine();
        return true;
    }
    return false;
}

static bool cExpression();

static bool cConstantInt() {
    int value;
    if(tReadInt(&value)) {
        cAddOperation(OP_PUSH_INT);
        cAddInt(value);
        return true;
    }
    return false;
}

static bool cConstantFloat() {
    float value;
    if(tReadFloat(&value)) {
        cAddOperation(OP_PUSH_FLOAT);
        cAddFloat(value);
        return true;
    }
    return false;
}

static bool cGetVar() {
    const char* literal = tReadString();
    if(literal == NULL) {
        cError("literal without string on line %d", line);
        return false;
    }
    cAddOperation(OP_GET);
    cAddInt(cAddVar(literal));
    return true;
}

static bool cPrimary() {
    Token t = cReadTokenAndLine();
    switch(t) {
        case T_INT: return cConstantInt();
        case T_FLOAT: return cConstantFloat();
        case T_NULL: cAddOperation(OP_PUSH_NULL); return true;
        case T_TRUE: cAddOperation(OP_PUSH_TRUE); return true;
        case T_FALSE: cAddOperation(OP_PUSH_FALSE); return true;
        case T_OPEN_BRACKET: return cExpression() && cConsumeToken(T_CLOSE_BRACKET);
        case T_LITERAL: return cGetVar();
        default: cUnexpectedToken(t); return false;
    }
}

static bool cMul() {
    if(!cPrimary()) {
        return false;
    }
    while(cConsumeTokenIf(T_MUL)) {
        if(!cPrimary()) {
            return false;
        }
        cAddOperation(OP_MUL);
    }
    return true;
}

static bool cAdd() {
    if(!cMul()) {
        return false;
    }
    while(cConsumeTokenIf(T_ADD)) {
        if(!cMul()) {
            return false;
        }
        cAddOperation(OP_ADD);
    }
    return true;
}

static bool cExpression() {
    return cAdd();
}

static bool cSetVar(const char* literal) {
    bool b = cExpression() && cConsumeToken(T_SEMICOLON);
    cAddOperation(OP_SET);
    cAddInt(cAddVar(literal));
    return b;
}

static int cCallFunctionArguments() {
    int arguments = 0;
    while(!cConsumeTokenIf(T_CLOSE_BRACKET)) {
        arguments++;
        if(!cExpression()) {
            return -1;
        } else if(cConsumeTokenIf(T_COMMA) && tPeekToken() == T_CLOSE_BRACKET) {
            cUnexpectedToken(tPeekToken());
            return -1;
        }
    }
    return arguments;
}

static bool cCallFunction(const char* literal) {
    cAddOperation(OP_PUSH_INT);
    cAddInt(0);
    int arguments = cCallFunctionArguments();
    if(arguments == -1) {
        return false;
    }
    int address = fmSearchAddress(&functions, literal, arguments);
    if(address == -1) {
        cError("unknown function on line %d", line);
        return false;
    }
    cAddOperation(OP_GOSUB);
    cAddInt(address);
    cAddInt(arguments);
    return cConsumeToken(T_SEMICOLON);
}

static bool cLiteral() {
    const char* literal = tReadString();
    if(literal == NULL) {
        cError("literal without string on line %d", line);
        return false;
    }
    Token t = cReadTokenAndLine();
    if(t == T_SET) {
        return cSetVar(literal);
    } else if(t == T_OPEN_BRACKET) {
        return cCallFunction(literal);
    }
    cUnexpectedToken(t);
    return false;
}

static int cFunctionArguments() {
    int arguments = 0;
    while(!cConsumeTokenIf(T_CLOSE_BRACKET)) {
        if(!cConsumeToken(T_LITERAL)) {
            return -1;
        }
        arguments++;
        const char* arg = tReadString();
        if(arg == NULL) {
            cError("function argument literal without string on line %d", line);
            return -1;
        }
        cAddVar(arg);
        if(cConsumeTokenIf(T_COMMA) && tPeekToken() != T_LITERAL) {
            cUnexpectedToken(tPeekToken());
            return -1;
        }
    }
    return arguments;
}

static bool cLine();

static bool cFunctionInnerBody(int arguments) {
    cAddOperation(OP_PUSH);
    int pushIndex = cReserveInt();
    cAddInt(arguments);

    int oldLine = line;
    while(!cConsumeTokenIf(T_CLOSE_CURVED_BRACKET)) {
        if(cConsumeTokenIf(T_END)) {
            cError("unexpected end of file: function not closed on line %d", oldLine);
            return false;
        } else if(!cLine()) {
            return false;
        }
    }

    cAddOperation(OP_POP);
    cAddInt(vars[1].entries);
    cSetInt(pushIndex, vars[1].entries);
    return true;
}

static bool cFunctionBody(const char* name, int arguments) {
    if(!cConsumeToken(T_OPEN_CURVED_BRACKET)) {
        return false;
    }
    cAddOperation(OP_GOTO);
    int gotoIndex = cReserveInt();

    if(!fmAdd(&functions, name, arguments, code->length)) {
        cError("function registered twice on line %d", line);
        return false;
    } else if(!cFunctionInnerBody(arguments)) {
        return false;
    }

    cAddOperation(OP_RETURN);
    cSetInt(gotoIndex, code->length);
    return true;
}

static bool cFunction() {
    if(varIndex == 1) {
        cError("function inside function on line %d", line);
        return false;
    } else if(!cConsumeToken(T_LITERAL)) {
        return false;
    }
    const char* name = tReadString();
    if(name == NULL) {
        cError("function literal without a function name on line %d", line);
        return false;
    } else if(!cConsumeToken(T_OPEN_BRACKET)) {
        return false;
    }

    varIndex = 1;
    vars[1].entries = 0;
    int arguments = cFunctionArguments();
    if(arguments == -1 || !cFunctionBody(name, arguments)) {
        return false;
    }
    varIndex = 0;
    return true;
}

static bool cPrint() {
    bool b = cExpression() && cConsumeToken(T_SEMICOLON);
    cAddOperation(OP_PRINT);
    return b;
}

static bool cLine() {
    Token t = cReadTokenAndLine();
    if(t == T_END) {
        return false;
    }
    cAddOperation(OP_LINE);
    cAddInt16(line);
    if(t == T_PRINT) {
        return cPrint();
    } else if(t == T_LITERAL) {
        return cLiteral();
    } else if(t == T_FUNCTION) {
        return cFunction();
    }
    cUnexpectedToken(t);
    return false;
}

static void cForEachLine() {
    cAddOperation(OP_PUSH);
    int globalVars = cReserveInt();
    cAddInt(0);
    while(cLine()) {
    }
    cAddOperation(OP_POP);
    cSetInt(globalVars, vars[varIndex].entries);
    cAddInt(vars[varIndex].entries);
}

static void cAllocAndCompile() {
    varIndex = 0;
    simInit(vars);
    simInit(vars + 1);
    fmInit(&functions);
    cForEachLine();
    fmDelete(&functions);
    simDelete(vars + 1);
    simDelete(vars);
}

ByteCode* cCompile() {
    error[0] = '\0';
    code = bcInit();
    cAllocAndCompile();
    if(error[0] != '\0') {
        bcDelete(code);
        return NULL;
    }
    return code;
}

const char* cGetError() {
    return error;
}