path: root/src/bytecode/compiler.h

#ifndef BDL_COMPILER_H
#define BDL_COMPILER_H

#include "chunk.h"
#include "lexer.h"

typedef struct Compiler {
    Token *tokens;
    size_t current;
} Compiler;

// Mimics the functionality in the Scanner functions, but for entire tokens.
Token next_token(Compiler *compiler);
Token peek_token(const Compiler *compiler);
bool has_next_token(const Compiler *compiler);

Chunk * compile(Token *tokens);

Token
peek_token(const Compiler *compiler) {
    return compiler->tokens[compiler->current];
}

Token
next_token(Compiler *compiler) {
    return compiler->tokens[compiler->current++];
}

bool
has_next_token(const Compiler *compiler) {
    return compiler->current < array_size(compiler->tokens);
}

void
emit_constant(Chunk *chunk, Token tok, Object obj) {
    size_t prev_size = array_size(chunk->constants);
    size_t num_idx = add_constant(chunk, obj);
    add_code(chunk, OP_CONSTANT, tok.line, tok.column);
    add_code(chunk, num_idx, tok.line, tok.column);

    // If the non value constant was already present we need to properly free
    // the memory from the object given to this function.
    if (prev_size == array_size(chunk->constants)) {
        object_free(obj);
    }
}

size_t
emit_jump(Chunk *chunk, Token tok, Ops op, ssize_t offset) {
    add_code(chunk, op, tok.line, tok.column);
    add_code(chunk, ((u16)offset >> 8) & 0xFF, tok.line, tok.column);
    add_code(chunk, ((u16)offset) & 0xFF, tok.line, tok.column);
    return array_size(chunk->code) - 2;
}

void
patch_jump(Chunk *chunk, ssize_t offset) {
  ssize_t jump = array_size(chunk->code) - offset - 2;
  assert((u16)jump <= UINT16_MAX && "error: jump is too long");
  chunk->code[offset] = ((u16)jump >> 8) & 0xFF;
  chunk->code[offset + 1] = ((u16)jump) & 0xFF;
}

void
parse_fixnum(Chunk *chunk, Token tok) {
    ssize_t num = 0;
    int sign = 1;
    for (size_t i = 0; i < tok.value.n; i++) {
        char c = tok.value.start[i];
        if (c == '-') {
            sign = -1;
            continue;
        }
        num = num * 10 + (c - '0');
    }
    emit_constant(chunk, tok, FIXNUM_VAL(num * sign));
}

void parse_tree(Chunk *chunk, Compiler *compiler);

void
compile_list_binary_op(Chunk *chunk, Compiler *compiler, Token start, Ops op) {
    size_t n = 0;
    while (has_next_token(compiler)) {
        Token tok = peek_token(compiler);
        if (tok.type == TOKEN_EOF) {
            error_push((Error){
                .type = ERR_TYPE_COMPILER,
                .value = ERR_UNBALANCED_PAREN,
                .line = start.line,
                .col = start.column,
            });
            return;
        }
        if (tok.type == TOKEN_RPAREN) {
            next_token(compiler);
            if (n <= 1) {
                error_push((Error){
                    .type = ERR_TYPE_COMPILER,
                    .value = ERR_NOT_ENOUGH_ARGS,
                    .line = start.line,
                    .col = start.column,
                });
                return;
            }
            break;
        }
        parse_tree(chunk, compiler);
        if (tok.type == TOKEN_SYMBOL) {
            add_code(chunk, OP_GET, tok.line, tok.column);
        }
        n++;
    }
    emit_constant(chunk, start, FIXNUM_VAL(n));
    add_code(chunk, op, start.line, start.column);
}

void
compile_list_unary_op(Chunk *chunk, Compiler *compiler, Token start, Ops op) {
    size_t n = 0;
    while (has_next_token(compiler)) {
        Token tok = peek_token(compiler);
        if (tok.type == TOKEN_EOF) {
            error_push((Error){
                .type = ERR_TYPE_COMPILER,
                .value = ERR_UNBALANCED_PAREN,
                .line = start.line,
                .col = start.column,
            });
            return;
        }
        if (tok.type == TOKEN_RPAREN) {
            next_token(compiler);
            if (n == 0) {
                error_push((Error){
                    .type = ERR_TYPE_COMPILER,
                    .value = ERR_NOT_ENOUGH_ARGS,
                    .line = start.line,
                    .col = start.column,
                });
            }
            return;
        }
        parse_tree(chunk, compiler);
        if (tok.type == TOKEN_SYMBOL) {
            add_code(chunk, OP_GET, tok.line, tok.column);
        }
        add_code(chunk, op, start.line, start.column);
        n++;
        if (n > 1) {
            error_push((Error){
                .type = ERR_TYPE_COMPILER,
                .value = ERR_TOO_MANY_ARGS,
                .line = start.line,
                .col = start.column,
            });
        }
    }
    error_push((Error){
        .type = ERR_TYPE_COMPILER,
        .value = ERR_UNBALANCED_PAREN,
        .line = start.line,
        .col = start.column,
    });
}

void
compile_list_simple_op(Chunk *chunk, Compiler *compiler, Token start, Ops op) {
    if (has_next_token(compiler)) {
        Token tok = peek_token(compiler);
        if (tok.type == TOKEN_EOF) {
            error_push((Error){
                .type = ERR_TYPE_COMPILER,
                .value = ERR_UNBALANCED_PAREN,
                .line = start.line,
                .col = start.column,
            });
            return;
        }
        if (tok.type != TOKEN_RPAREN) {
            error_push((Error){
                .type = ERR_TYPE_COMPILER,
                .value = ERR_TOO_MANY_ARGS,
                .line = start.line,
                .col = start.column,
            });
            return;
        }
        next_token(compiler);
        add_code(chunk, op, start.line, start.column);
        return;
    }
    error_push((Error){
        .type = ERR_TYPE_COMPILER,
        .value = ERR_UNBALANCED_PAREN,
        .line = start.line,
        .col = start.column,
    });
}

void
compile_declare_op(Chunk *chunk, Compiler *compiler, Token start, Ops op) {
    Token name = peek_token(compiler);
    if (name.type != TOKEN_SYMBOL) {
        error_push((Error){
            .type = ERR_TYPE_COMPILER,
            .value = ERR_WRONG_ARG_TYPE,
            .line = start.line,
            .col = start.column,
        });
        return;
    }
    parse_tree(chunk, compiler);
    Token expr = peek_token(compiler);
    if (name.type == TOKEN_EOF || expr.type == TOKEN_EOF) {
        error_push((Error){
            .type = ERR_TYPE_COMPILER,
            .value = ERR_UNBALANCED_PAREN,
            .line = start.line,
            .col = start.column,
        });
        return;
    }
    if (name.type == TOKEN_RPAREN || expr.type == TOKEN_RPAREN) {
        error_push((Error){
            .type = ERR_TYPE_COMPILER,
            .value = ERR_NOT_ENOUGH_ARGS,
            .line = start.line,
            .col = start.column,
        });
        return;
    }
    parse_tree(chunk, compiler);
    if (expr.type == TOKEN_SYMBOL) {
        add_code(chunk, OP_GET, expr.line, expr.column);
    }
    if (peek_token(compiler).type != TOKEN_RPAREN) {
        error_push((Error){
            .type = ERR_TYPE_COMPILER,
            .value = ERR_TOO_MANY_ARGS,
            .line = start.line,
            .col = start.column,
        });
        return;
    }
    next_token(compiler);
    add_code(chunk, op, start.line, start.column);
}

void
compile_if_op(Chunk *chunk, Compiler *compiler, Token start) {
    Token tok = peek_token(compiler);
    if (tok.type == TOKEN_EOF) {
        error_push((Error){
            .type = ERR_TYPE_COMPILER,
            .value = ERR_UNBALANCED_PAREN,
            .line = start.line,
            .col = start.column,
        });
        return;
    }
    if (tok.type == TOKEN_RPAREN) {
        error_push((Error){
            .type = ERR_TYPE_COMPILER,
            .value = ERR_NOT_ENOUGH_ARGS,
            .line = start.line,
            .col = start.column,
        });
        return;
    }

    // Condition.
    parse_tree(chunk, compiler);
    size_t jmp_false = emit_jump(chunk, start, OP_JUMP_IF_FALSE, 0xFFFF);

    // True expression.
    parse_tree(chunk, compiler);

    // No second expression.
    if (peek_token(compiler).type == TOKEN_RPAREN) {
        patch_jump(chunk, jmp_false);
        next_token(compiler);
        return;
    }

    // False expression.
    size_t jmp_end = emit_jump(chunk, start, OP_JUMP, 0xFFFF);
    patch_jump(chunk, jmp_false);
    parse_tree(chunk, compiler);
    patch_jump(chunk, jmp_end);

    if (peek_token(compiler).type != TOKEN_RPAREN) {
        error_push((Error){
            .type = ERR_TYPE_COMPILER,
            .value = ERR_TOO_MANY_ARGS,
            .line = start.line,
            .col = start.column,
        });
        return;
    }
    next_token(compiler);
}

void
parse_list(Chunk *chunk, Compiler *compiler, Token start) {
    if (!has_next_token(compiler)) {
        error_push((Error){
            .type = ERR_TYPE_COMPILER,
            .value = ERR_UNBALANCED_PAREN,
            .line = start.line,
            .col = start.column,
        });
        return;
    }
    Token tok = next_token(compiler);
    switch (tok.type) {
        case TOKEN_ADD: { compile_list_binary_op(chunk, compiler, start, OP_SUM); } break;
        case TOKEN_SUB: { compile_list_binary_op(chunk, compiler, start, OP_SUB); } break;
        case TOKEN_MUL: { compile_list_binary_op(chunk, compiler, start, OP_MUL); } break;
        case TOKEN_DIV: { compile_list_binary_op(chunk, compiler, start, OP_DIV); } break;
        case TOKEN_MOD: { compile_list_binary_op(chunk, compiler, start, OP_MOD); } break;
        case TOKEN_NOT: { compile_list_unary_op(chunk, compiler, start, OP_NOT); } break;
        case TOKEN_AND: { compile_list_binary_op(chunk, compiler, start, OP_AND); } break;
        case TOKEN_OR: { compile_list_binary_op(chunk, compiler, start, OP_OR); } break;
        case TOKEN_EQUAL: { compile_list_binary_op(chunk, compiler, start, OP_EQUAL); } break;
        case TOKEN_LESS: { compile_list_binary_op(chunk, compiler, start, OP_LESS); } break;
        case TOKEN_GREATER: { compile_list_binary_op(chunk, compiler, start, OP_GREATER); } break;
        case TOKEN_LESS_EQUAL: { compile_list_binary_op(chunk, compiler, start, OP_LESS_EQUAL); } break;
        case TOKEN_GREATER_EQUAL: { compile_list_binary_op(chunk, compiler, start, OP_GREATER_EQUAL); } break;
        case TOKEN_PRINT: { compile_list_unary_op(chunk, compiler, start, OP_PRINT); } break;
        case TOKEN_DISPLAY: { compile_list_unary_op(chunk, compiler, start, OP_DISPLAY); } break;
        case TOKEN_NEWLINE: { compile_list_simple_op(chunk, compiler, start, OP_NEWLINE); } break;
        case TOKEN_DEF: { compile_declare_op(chunk, compiler, start, OP_DEF); } break;
        case TOKEN_SET: { compile_declare_op(chunk, compiler, start, OP_SET); } break;
        case TOKEN_IF: { compile_if_op(chunk, compiler, start); } break;
        default: {
            error_push((Error){
                .type = ERR_TYPE_COMPILER,
                .value = ERR_OBJ_NOT_CALLABLE,
                .line = tok.line,
                .col = tok.column,
            });
        } break;
    }
}

void
parse_tree(Chunk *chunk, Compiler *compiler) {
    Token tok = next_token(compiler);
    if (errors_n != 0) {
        return;
    }
    switch (tok.type) {
        case TOKEN_FIXNUM: {
            parse_fixnum(chunk, tok);
            return ;
        } break;
        case TOKEN_TRUE: {
            emit_constant(chunk, tok, TRUE_VAL);
            return;
        } break;
        case TOKEN_FALSE: {
            emit_constant(chunk, tok, FALSE_VAL);
            return;
        } break;
        case TOKEN_RPAREN: {
            error_push((Error){
                .type = ERR_TYPE_COMPILER,
                .value = ERR_UNBALANCED_PAREN,
                .line = tok.line,
                .col = tok.column,
            });
            return;
        } break;
        case TOKEN_QUOTE: {
            // Object *base = make_pair(obj_quote, obj_nil);
            // base->cdr = make_pair(obj_nil, obj_nil);
            // push_root(base);
            // Object *next_obj = parse_tree(compiler);
            // if (next_obj == obj_err) {
            //     return obj_err;
            // }
            // base->cdr->car = next_obj;
            // return base;
            return;
        } break;
        case TOKEN_LPAREN: {
            parse_list(chunk, compiler, tok);
            return;
        } break;
        case TOKEN_STRING: {
            Object obj = make_string(tok.value);
            emit_constant(chunk, tok, obj);
            return;
        } break;
        case TOKEN_SYMBOL: {
            Object obj = make_symbol(tok.value);
            emit_constant(chunk, tok, obj);
            return;
        } break;
        case TOKEN_NIL: {
            emit_constant(chunk, tok, NIL_VAL);
            return;
        } break;
        default: {
            break;
        } break;
    }
    error_push((Error){
        .type = ERR_TYPE_COMPILER,
        .value = ERR_EOF_REACHED,
        .line = tok.line,
        .col = tok.column,
    });
    return;
}

Chunk *
compile(Token *tokens) {
    Chunk *chunk = NULL;
    chunk = chunk_init();
    Compiler compiler = (Compiler){
        .tokens = tokens,
        .current = 0,
    };
    Token start_tok = peek_token(&compiler);
    while (has_next_token(&compiler) && peek_token(&compiler).type != TOKEN_EOF) {
        parse_tree(chunk, &compiler);
    }
    add_code(chunk, OP_RETURN, start_tok.line, start_tok.column);
    return chunk;
}

#endif // BDL_COMPILER_H