nesemu/debugger/program_view.c

//
// Created by william on 10/01/24.
//

#include <stdlib.h>
#include <assert.h>
#include "program_view.h"
#include "../cpu/op.h"
#include "memory_view.h"

void decode_operands(ProgramView *view) {
    int pc = PROGRAM_VIEW_BASE_ADDR;
    while (pc < 0xfffa) {
        DebugOperand *operand = malloc(sizeof(DebugOperand));
        if (operand == NULL) {
            perror("Failed to allocate memory for debug operand");
            exit(EXIT_FAILURE);
        }

        byte op_code = view->ram[pc];
        operand->addr = pc;
        operand->op_code = op_code;
        operand->addr_mode = get_op_addr_mode(op_code);

        pc += 1;

        if (operand->addr_mode == ADDR_MODE_ACCUMULATOR || operand->addr_mode == ADDR_MODE_IMPLICIT) {
            operand->value = 0;
        } else if (operand->addr_mode == ADDR_MODE_RELATIVE || operand->addr_mode == ADDR_MODE_IMMEDIATE ||
                   operand->addr_mode == ADDR_MODE_ZERO_PAGE || operand->addr_mode == ADDR_MODE_ZERO_PAGE_INDEXED_X ||
                   operand->addr_mode == ADDR_MODE_ZERO_PAGE_INDEXED_Y) {
            operand->value = view->ram[pc];
            pc += 1;
        } else {
            operand->value = view->ram[pc];
            operand->value += view->ram[pc + 1] << 8;
            pc += 2;
        }

        linked_list_add(&view->operands, operand);
    }
}

char *get_addr_mode_format_str(AddressingMode addr_mode) {
    switch (addr_mode) {
        case ADDR_MODE_ABSOLUTE:
            return "$%04x";
        case ADDR_MODE_ABSOLUTE_INDEXED_X:
            return "$%04x,x";
        case ADDR_MODE_ABSOLUTE_INDEXED_Y:
            return "$%04x,y";
        case ADDR_MODE_ACCUMULATOR:
            return "A";
        case ADDR_MODE_IMMEDIATE:
            return "#$%02x";
        case ADDR_MODE_IMPLICIT:
            return "";
        case ADDR_MODE_INDIRECT_X:
            return "($%04x,x)";
        case ADDR_MODE_INDIRECT_JUMP:
            return "($%04x)";
        case ADDR_MODE_INDIRECT_Y:
            return "($%04x),y";
        case ADDR_MODE_RELATIVE:
            return "$%04x";
        case ADDR_MODE_ZERO_PAGE:
            return "$%02x,y";
        case ADDR_MODE_ZERO_PAGE_INDEXED_X:
            return "$%02x,x";
        case ADDR_MODE_ZERO_PAGE_INDEXED_Y:
            return "$%02x,y";
    }
}

void program_view_write_line(ProgramView *view, int line, DebugOperand *operand) {
    char *op_name = get_op_code_name(operand->op_code);

    window_inter_print(view->window, 0, line, "%04x:", operand->addr);
    window_inter_print(view->window, 6, line, "(%02x) %s", operand->op_code, op_name);

    char *format = get_addr_mode_format_str(operand->addr_mode);
    window_inter_print(view->window, 16, line, format, operand->value);
}

void program_view_print(ProgramView *view) {
    LinkedListNode *current_node = view->current_operand_node;
    int line = 0;
    while (line <= 0xf && current_node != NULL) {
        program_view_write_line(view, line, (DebugOperand *) current_node->data);
        current_node = current_node->next;
        line++;
    }
}

void program_view_cursor_init(ProgramView *view) {
    window_inter_cursor_init(view->window, 0, 0xf);
    view->window->cursor.width = PROGRAM_VIEW_WIDTH - 2;
}

void pv_scroll(ProgramView *view, int direction) {
    assert(direction == CURSOR_OFFSET_DOWN || direction == CURSOR_OFFSET_UP);

    if (direction == CURSOR_OFFSET_UP) {
        view->current_operand_node = view->current_operand_node->previous;
    } else {
        view->current_operand_node = view->current_operand_node->next;
    }

    program_view_print(view);
}

void pv_handle_cursor_move(InteractWindow *window, int horizontal, int vertical) {
    ProgramView *view = (ProgramView *) window->view;

    if (vertical == CURSOR_OFFSET_DOWN && view->window->cursor.pos_y == 0xf ||
        vertical == CURSOR_OFFSET_UP && view->window->cursor.pos_y == 0) {
        // Scroll the view
        pv_scroll(view, vertical);
    }

    cursor_move(&window->cursor, horizontal, vertical);
}

void program_view_handle_key_down(InteractWindow *window, int keycode) {

}

void pv_deinit(InteractWindow *window) {
    ProgramView *view = (ProgramView *) window->view;
    linked_list_uninit(&view->operands);
}

bool pv_predicate_operand_by_addr(void *data, void *userdata) {
    DebugOperand *operand = (DebugOperand *) data;
    address *addr = (address *) userdata;
    return operand->addr == *addr;
}

void program_view_init(InteractWindow *interact, System *system, int x, int y) {
    ProgramView *view = malloc(sizeof(ProgramView));
    view->window = interact;
    view->ram = system->ram;
    view->pc = &system->cpu.program_counter;
    view->operands = linked_list_init();

    interact->view = view;
    interact->handle_cursor_move = &pv_handle_cursor_move;
    interact->handle_key_down = &program_view_handle_key_down;
    interact->deinit = &pv_deinit;
    window_inter_init(interact, x, y, PROGRAM_VIEW_WIDTH, PROGRAM_VIEW_HEIGHT, "PROGRAM VIEW");

    decode_operands(view);
    view->current_operand_node = linked_list_get_if(&view->operands, &pv_predicate_operand_by_addr, view->pc);

    program_view_print(view);
    program_view_cursor_init(view);
}