/* rom_harness.h -- run the ROM's routines on a host node, for tests.
 *
 * The ROM (capsules/v4/rom, built by tools/mkrom.c into $(BINDIR)/rom-<w>.c)
 * is attached to a host node as the machine's ROM.  A routine is called
 * through the ROM's entry table, as a payload calls it (MACHINE.md 2.1): the
 * table's order is fixed, and is rom_entries[] below.  Where a test needs to
 * know whether P is inside a routine, the ROM's symbols are read from
 * $(BINDIR)/rom-<w>.sym (V4_ROM_SYM).
 */
#ifndef V4_TESTS_ROM_HARNESS_H
#define V4_TESTS_ROM_HARNESS_H

#include "v4/testcode.h"
#include "host_map.h"
#include <stdio.h>
#include <string.h>

#if V4_CELL_BITS == 64
extern const v4_cell v4_rom_64[];
extern const unsigned v4_rom_64_words;
#define ROM_IMAGE v4_rom_64
#define ROM_IMAGE_WORDS v4_rom_64_words
#else
extern const v4_cell v4_rom_32[];
extern const unsigned v4_rom_32_words;
#define ROM_IMAGE v4_rom_32
#define ROM_IMAGE_WORDS v4_rom_32_words
#endif

/* The entry table, in its fixed order: entry i is at V4_ROM_BASE + i. */
static const char *const rom_entries[] = {
    "(KEY)", "(TOKEN)", "(NUMBER)", "(FIND)", "(DEFINE)", "(OPCODE)",
    "(OP)", "(LIT)", "(BRANCH)", "(BRANCH>)", "(RESOLVE)", "(LABEL)"
};
#define ROM_ENTRIES (sizeof rom_entries / sizeof rom_entries[0])

static v4_exec_state rom_es;
static v4_heat       rom_h;

/* The address a payload calls for the routine `name`: its entry. */
static v4_cell rom_entry(const char *name)
{
    unsigned i;
    for (i = 0; i < ROM_ENTRIES; i++) if (strcmp(rom_entries[i], name) == 0) return V4_ROM_BASE + (v4_cell)i;
    printf("rom_harness: %s is not in the entry table\n", name);
    return -1;
}

/* Call the routine through its entry.  1 if it returned within `max_words`
 * instruction words; 0 if not, and the node is left where it got to, to be
 * fed and resumed. */
static int rom_call(v4_node *n, const char *name, long max_words)
{
    return v4_test_call(n, &rom_es, &rom_h, rom_entry(name), max_words) >= 0;
}

/* Go on with a call that had not returned.  1 if it now has. */
static int rom_resume(v4_node *n, long max_words)
{
    long words = 0;
    while (n->p != V4_TEST_HALT) {
        if (words++ >= max_words || n->stopped) return 0;
        (void)v4_exec_step_word(n, &rom_es, &rom_h);
    }
    return 1;
}

/* 1 if P is inside the ROM's word `name`: at or after it, and before the
 * next word the ROM has. */
static int rom_in(const v4_node *n, const char *name)
{
    FILE *f = fopen(V4_ROM_SYM, "r");
    char sym[80];
    long addr, start = -1, next = -1;
    if (!f) { printf("rom_harness: cannot read %s\n", V4_ROM_SYM); return 0; }
    while (fscanf(f, "%79s %ld", sym, &addr) == 2)
        if (strcmp(sym, name) == 0) start = addr;
    rewind(f);
    while (fscanf(f, "%79s %ld", sym, &addr) == 2)
        if (start >= 0 && addr > start && (next < 0 || addr < next)) next = addr;
    fclose(f);
    if (start < 0) return 0;
    if (next < 0) next = (long)V4_ROM_BASE + (long)ROM_IMAGE_WORDS;
    return (long)n->p >= start && (long)n->p < next;
}

/* Reset `n`, attach the ROM and the console's receive registers. */
static void rom_boot(v4_node *n)
{
    (void)host_load;                         /* host_map.h's loader is not used here */
    (void)host_branch_slots;
    (void)rom_call;                          /* not every test uses every helper */
    (void)rom_resume;
    (void)rom_in;
    v4_node_reset(n);
    v4_exec_reset(&rom_es);
    v4_heat_reset(&rom_h);
    v4_node_rom_attach(n, ROM_IMAGE, ROM_IMAGE_WORDS);
    v4_node_console_input_attach(n, CONSOLE_RX, CONSOLE_ST);
}

#endif /* V4_TESTS_ROM_HARNESS_H */