z80_monitor/monitor.c

#include <stdint.h>
#include "bios.h"

#define LINE_SIZE 80
#define MAX_ARGS 40
#define DEFAULT_DUMP_LENGTH 0x40
#define MAX_DUMP_LENGTH 0x100

static char hex_digit(uint8_t value)
{
    value &= 0x0f;
    return value < 10 ? (char)('0' + value) : (char)('A' + value - 10);
}

static void print_hex8(uint8_t value)
{
    bios_putc(hex_digit(value >> 4));
    bios_putc(hex_digit(value));
}

static void print_hex16(uint16_t value)
{
    print_hex8((uint8_t)(value >> 8));
    print_hex8((uint8_t)value);
}

static uint8_t hex_value(char c, uint8_t *value)
{
    if (c >= '0' && c <= '9') {
        *value = (uint8_t)(c - '0');
        return 1;
    }
    if (c >= 'a' && c <= 'f') {
        *value = (uint8_t)(c - 'a' + 10);
        return 1;
    }
    if (c >= 'A' && c <= 'F') {
        *value = (uint8_t)(c - 'A' + 10);
        return 1;
    }
    return 0;
}

static uint8_t parse_hex(const char *text, uint16_t *result)
{
    uint16_t value = 0;
    uint8_t digit;
    uint8_t digits = 0;

    if (text[0] == '0' && (text[1] == 'x' || text[1] == 'X')) text += 2;
    while (*text) {
        if (digits == 4 || !hex_value(*text++, &digit)) return 0;
        value = (uint16_t)((value << 4) | digit);
        ++digits;
    }
    if (digits == 0) return 0;
    *result = value;
    return 1;
}

static uint8_t strings_equal(const char *a, const char *b)
{
    char ca;
    char cb;

    do {
        ca = *a++;
        cb = *b++;
        if (ca >= 'A' && ca <= 'Z') ca += 'a' - 'A';
        if (cb >= 'A' && cb <= 'Z') cb += 'a' - 'A';
        if (ca != cb) return 0;
    } while (ca);
    return 1;
}

static uint8_t split_line(char *line, char **argv)
{
    uint8_t argc = 0;

    while (*line) {
        while (*line == ' ' || *line == '\t') ++line;
        if (!*line) break;
        if (argc == MAX_ARGS) return argc;
        argv[argc++] = line;
        while (*line && *line != ' ' && *line != '\t') ++line;
        if (*line) *line++ = 0;
    }
    return argc;
}

static void print_help(void)
{
    bios_puts(
        "Commands (hexadecimal numbers):\r\n"
        "  D|DUMP address [length]   Dump memory (default 0040, max 0100)\r\n"
        "  W|WRITE address byte ...  Write one or more memory bytes\r\n"
        "  I|IN port                 Read an I/O port\r\n"
        "  O|OUT port byte           Write an I/O port\r\n"
        "  G|GO address              Execute code; RET returns here\r\n"
        "  B|BASIC                   Start ROM Tiny BASIC at 1000\r\n"
        "  H|HELP|?                  Show this help\r\n");
}

static void command_dump(uint8_t argc, char **argv)
{
    uint16_t address;
    uint16_t length = DEFAULT_DUMP_LENGTH;
    uint16_t offset = 0;

    if (argc < 2 || argc > 3 || !parse_hex(argv[1], &address) ||
        (argc == 3 && !parse_hex(argv[2], &length))) {
        bios_puts("Usage: D address [length]\r\n");
        return;
    }
    if (length > MAX_DUMP_LENGTH) {
        bios_puts("Length must be 0100 or less\r\n");
        return;
    }
    while (offset < length) {
        uint8_t column;
        uint8_t row_length = (uint8_t)((length - offset) > 16 ? 16 : (length - offset));

        print_hex16((uint16_t)(address + offset));
        bios_puts(": ");
        for (column = 0; column < row_length; ++column) {
            print_hex8(*(volatile uint8_t *)(address + offset + column));
            bios_putc(' ');
        }
        bios_puts("\r\n");
        offset += row_length;
    }
}

static void command_write(uint8_t argc, char **argv)
{
    uint16_t address;
    uint16_t value;
    uint8_t i;

    if (argc < 3 || !parse_hex(argv[1], &address)) {
        bios_puts("Usage: W address byte [byte ...]\r\n");
        return;
    }
    for (i = 2; i < argc; ++i) {
        if (!parse_hex(argv[i], &value) || value > 0xff) {
            bios_puts("Bad byte: ");
            bios_puts(argv[i]);
            bios_puts("\r\n");
            return;
        }
        *(volatile uint8_t *)address++ = (uint8_t)value;
    }
    bios_puts("OK\r\n");
}

static void command_in(uint8_t argc, char **argv)
{
    uint16_t port;

    if (argc != 2 || !parse_hex(argv[1], &port) || port > 0xff) {
        bios_puts("Usage: I port\r\n");
        return;
    }
    print_hex8((uint8_t)port);
    bios_puts(": ");
    print_hex8(io_in((uint8_t)port));
    bios_puts("\r\n");
}

static void command_out(uint8_t argc, char **argv)
{
    uint16_t port;
    uint16_t value;

    if (argc != 3 || !parse_hex(argv[1], &port) || port > 0xff ||
        !parse_hex(argv[2], &value) || value > 0xff) {
        bios_puts("Usage: O port byte\r\n");
        return;
    }
    io_out((uint8_t)port, (uint8_t)value);
    bios_puts("OK\r\n");
}

static void execute_address(uint16_t address)
{
    bios_puts("Executing at ");
    print_hex16(address);
    bios_puts("...\r\n");
    bios_flush();
    jump_to(address);
    bios_puts("Returned to monitor\r\n");
}

static void command_go(uint8_t argc, char **argv)
{
    uint16_t address;

    if (argc != 2 || !parse_hex(argv[1], &address)) {
        bios_puts("Usage: G address\r\n");
        return;
    }
    execute_address(address);
}

static void command_basic(uint8_t argc)
{
    if (argc != 1) {
        bios_puts("Usage: B\r\n");
        return;
    }
    execute_address(0x1000);
}

static void execute_line(char *line)
{
    char *argv[MAX_ARGS];
    uint8_t argc = split_line(line, argv);

    if (!argc) return;
    if (strings_equal(argv[0], "h") || strings_equal(argv[0], "help") ||
        strings_equal(argv[0], "?")) {
        print_help();
    } else if (strings_equal(argv[0], "d") || strings_equal(argv[0], "dump")) {
        command_dump(argc, argv);
    } else if (strings_equal(argv[0], "w") || strings_equal(argv[0], "write")) {
        command_write(argc, argv);
    } else if (strings_equal(argv[0], "i") || strings_equal(argv[0], "in")) {
        command_in(argc, argv);
    } else if (strings_equal(argv[0], "o") || strings_equal(argv[0], "out")) {
        command_out(argc, argv);
    } else if (strings_equal(argv[0], "g") || strings_equal(argv[0], "go")) {
        command_go(argc, argv);
    } else if (strings_equal(argv[0], "b") || strings_equal(argv[0], "basic")) {
        command_basic(argc);
    } else {
        bios_puts("Unknown command; type HELP\r\n");
    }
}

void main(void)
{
    char line[LINE_SIZE];
    uint8_t length = 0;
    uint8_t ignore_lf = 0;

    bios_puts("\r\nZ80 monitor - v1\r\nType HELP for commands.\r\n> ");

    for (;;) {
        char c = bios_getc();

        if (c == '\n' && ignore_lf) {
            ignore_lf = 0;
            continue;
        }
        ignore_lf = 0;
        if (c == '\r' || c == '\n') {
            ignore_lf = (c == '\r');
            line[length] = 0;
            bios_puts("\r\n");
            execute_line(line);
            length = 0;
            bios_puts("> ");
        } else if (c == '\b' || c == 0x7f) {
            if (length) {
                --length;
                bios_puts("\b \b");
            }
        } else if (c == 0x15) {
            while (length) {
                --length;
                bios_puts("\b \b");
            }
        } else if (c >= ' ' && c <= '~' && length < LINE_SIZE - 1) {
            line[length++] = c;
            bios_putc(c);
        } else if (c >= ' ' && c <= '~') {
            bios_putc('\a');
        }
    }
}