fibonacci.c

/* ===== Generated by Board Code Generator ===== */
/* Board: TinyFib */
/* Chips: cpu, output */

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>

/* --- cpu chip --- */
typedef struct {
    uint16_t PC;  /* Program counter */
    uint16_t SP;  /* Stack pointer */
    uint64_t cycle_count;  /* Total cycles executed */
    bool halted;  /* CPU halted flag */
    bool ime;  /* Interrupt master enable */
    uint8_t A;
    uint8_t X;
    uint8_t F;
    uint8_t ram[256];  /* Zero-page RAM */
    uint8_t rom[32768];  /* Program ROM */
    uint8_t memory[65536];  /* flat address space */
} cpu_t;

/* --- output chip --- */
typedef struct {
    uint8_t last_value;  /* Last value written */
} output_t;

/* --- Board: TinyFib --- */
typedef struct {
    cpu_t cpu;
    output_t output;
} tinyfib_t;

/* --- Forward declarations --- */
static void tinyfib_init(tinyfib_t* sys);
static void cpu_step(tinyfib_t* sys);
static uint8_t main_read(tinyfib_t* sys, uint16_t addr);
static void main_write(tinyfib_t* sys, uint16_t addr, uint8_t val);
static uint8_t mem_read(tinyfib_t* sys, uint16_t addr);
static void mem_write(tinyfib_t* sys, uint16_t addr, uint8_t val);
static uint8_t read_imm8(tinyfib_t* sys);
static uint16_t read_imm16(tinyfib_t* sys);
static void push8(tinyfib_t* sys, uint8_t val);
static void push16(tinyfib_t* sys, uint16_t val);
static uint8_t pop8(tinyfib_t* sys);
static uint16_t pop16(tinyfib_t* sys);
static uint8_t output_io_read(tinyfib_t* sys, uint8_t index);
static void output_io_write(tinyfib_t* sys, uint8_t index, uint8_t val);

/* --- cpu flag helpers --- */
static inline bool cpu_get_Z(tinyfib_t* sys) { return (sys->cpu.F >> 7) & 1; }
static inline void cpu_set_Z(tinyfib_t* sys, bool val) { if (val) sys->cpu.F |= 0x80; else sys->cpu.F &= ~0x80; }
static inline bool cpu_get_N(tinyfib_t* sys) { return (sys->cpu.F >> 6) & 1; }
static inline void cpu_set_N(tinyfib_t* sys, bool val) { if (val) sys->cpu.F |= 0x40; else sys->cpu.F &= ~0x40; }
static inline bool cpu_get_C(tinyfib_t* sys) { return (sys->cpu.F >> 0) & 1; }
static inline void cpu_set_C(tinyfib_t* sys, bool val) { if (val) sys->cpu.F |= 0x01; else sys->cpu.F &= ~0x01; }

static uint8_t main_read(tinyfib_t* sys, uint16_t addr) {
    /* Zero-page RAM */
    if (addr >= 0x0000 && addr <= 0x00FF) {
        return sys->cpu.ram[addr - 0x0000 + 0];
    }
    /* Serial output port */
    if (addr >= 0x2000 && addr <= 0x2000) {
        return output_io_read(sys, addr - 0x2000);
    }
    /* Program ROM */
    if (addr >= 0x8000 && addr <= 0xFFFF) {
        return sys->cpu.rom[addr - 0x8000 + 0];
    }
    return 0xFF;  /* unmapped */
}

static void main_write(tinyfib_t* sys, uint16_t addr, uint8_t val) {
    /* Zero-page RAM */
    if (addr >= 0x0000 && addr <= 0x00FF) {
        sys->cpu.ram[addr - 0x0000 + 0] = val;
        return;
    }
    /* Serial output port */
    if (addr >= 0x2000 && addr <= 0x2000) {
        output_io_write(sys, addr - 0x2000, val);
        return;
        return;
    }
    /* Program ROM */
    if (addr >= 0x8000 && addr <= 0xFFFF) {
        /* read-only: ignore */
        return;
    }
    /* unmapped write */
}

/* --- Memory convenience functions --- */
static uint8_t mem_read(tinyfib_t* sys, uint16_t addr) {
    return main_read(sys, addr);
}
static void mem_write(tinyfib_t* sys, uint16_t addr, uint8_t val) {
    main_write(sys, addr, val);
}
static uint8_t read_imm8(tinyfib_t* sys) {
    return mem_read(sys, sys->cpu.PC++);
}
static uint16_t read_imm16(tinyfib_t* sys) {
    uint8_t lo = read_imm8(sys);
    uint8_t hi = read_imm8(sys);
    return ((uint16_t)hi << 8) | lo;
}
static void push8(tinyfib_t* sys, uint8_t val) {
    sys->cpu.SP--;
    mem_write(sys, sys->cpu.SP, val);
}
static void push16(tinyfib_t* sys, uint16_t val) {
    push8(sys, (val >> 8) & 0xFF);
    push8(sys, val & 0xFF);
}
static uint8_t pop8(tinyfib_t* sys) {
    return mem_read(sys, sys->cpu.SP++);
}
static uint16_t pop16(tinyfib_t* sys) {
    uint8_t lo = pop8(sys);
    uint8_t hi = pop8(sys);
    return ((uint16_t)hi << 8) | lo;
}

static uint8_t output_io_read(tinyfib_t* sys, uint8_t index) {
    switch (index) {
        case 0: /* Write prints value */
            return sys->output.last_value;
        default: return 0xFF;
    }
}

static void output_io_write(tinyfib_t* sys, uint8_t index, uint8_t val) {
    switch (index) {
        case 0: /* Write prints value */
            sys->output.last_value = val; printf("  %d\n", val); return;
            break;
    }
}

static void cpu_step(tinyfib_t* sys) {
    if (sys->cpu.halted) return;
    uint8_t opcode = mem_read(sys, sys->cpu.PC++);
    switch (opcode) {
        case 0x00: /* NOP */ {
            sys->cpu.cycle_count += 1;
            break;
        }
        case 0x01: /* LDA #imm8 */ {
            sys->cpu.A = read_imm8(sys);
            sys->cpu.cycle_count += 2;
            break;
        }
        case 0x02: /* LDX #imm8 */ {
            sys->cpu.X = read_imm8(sys);
            sys->cpu.cycle_count += 2;
            break;
        }
        case 0x03: /* STA abs16 */ {
            uint16_t addr = read_imm16(sys);
            mem_write(sys, addr, sys->cpu.A);
            sys->cpu.cycle_count += 4;
            break;
        }
        case 0x04: /* LDA abs16 */ {
            sys->cpu.A = mem_read(sys, read_imm16(sys));
            sys->cpu.cycle_count += 4;
            break;
        }
        case 0x05: /* STX abs16 */ {
            uint16_t addr = read_imm16(sys);
            mem_write(sys, addr, sys->cpu.X);
            sys->cpu.cycle_count += 4;
            break;
        }
        case 0x06: /* LDX abs16 */ {
            sys->cpu.X = mem_read(sys, read_imm16(sys));
            sys->cpu.cycle_count += 4;
            break;
        }
        case 0x07: /* TAX */ {
            sys->cpu.X = sys->cpu.A;
            sys->cpu.cycle_count += 1;
            break;
        }
        case 0x08: /* TXA */ {
            sys->cpu.A = sys->cpu.X;
            sys->cpu.cycle_count += 1;
            break;
        }
        case 0x09: /* ADD abs16 */ {
            uint16_t addr = read_imm16(sys);
            uint16_t result = (sys->cpu.A + mem_read(sys, addr));
            cpu_set_C(sys, (result > 255));
            sys->cpu.A = (result & 255);
            cpu_set_Z(sys, (sys->cpu.A == 0));
            sys->cpu.cycle_count += 4;
            break;
        }
        case 0x0B: /* JMP abs16 */ {
            sys->cpu.PC = read_imm16(sys);
            sys->cpu.cycle_count += 3;
            break;
        }
        case 0x0C: /* BCC abs16 */ {
            uint16_t target = read_imm16(sys);
            if ((!cpu_get_C(sys))) {
            sys->cpu.PC = target;
            }
            sys->cpu.cycle_count += 3;
            break;
        }
        case 0x0D: /* BCS abs16 */ {
            uint16_t target = read_imm16(sys);
            if (cpu_get_C(sys)) {
            sys->cpu.PC = target;
            }
            sys->cpu.cycle_count += 3;
            break;
        }
        case 0x0F: /* HALT */ {
            sys->cpu.halted = 1;
            sys->cpu.cycle_count += 1;
            break;
        }
        default:
            printf("Unknown opcode: 0x%02X at PC=0x%04X\n", opcode, sys->cpu.PC - 1);
            sys->cpu.halted = true;
            break;
    }
}

static void tinyfib_init(tinyfib_t* sys) {
    memset(sys, 0, sizeof(tinyfib_t));
}

static void tinyfib_step(tinyfib_t* sys) {
    cpu_step(sys);
}
/* ===================== main ===================== */

int main(void) {
    tinyfib_t sys;
    tinyfib_init(&sys);

    /* Load program into ROM */
    uint8_t program[] = { 0x01, 0x00, 0x03, 0x00, 0x00, 0x01, 0x01, 0x03, 0x01, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0x20, 0x04, 0x01, 0x00, 0x03, 0x00, 0x20, 0x04, 0x00, 0x00, 0x09, 0x01, 0x00, 0x0D, 0x2F, 0x80, 0x03, 0x00, 0x20, 0x07, 0x04, 0x01, 0x00, 0x03, 0x00, 0x00, 0x05, 0x01, 0x00, 0x0B, 0x16, 0x80, 0x0F };
    memcpy(sys.cpu.rom, program, sizeof(program));
    sys.cpu.PC = 0x8000;

    /* Run until halted */
    printf("Fibonacci sequence (8-bit):\n");
    while (!sys.cpu.halted) {
        tinyfib_step(&sys);
    }
    printf("Done! (%llu cycles)\n", (unsigned long long)sys.cpu.cycle_count);

    return 0;
}