/* host_map.h -- the memory map the host-node tests give the compiler capsule,
 * and the loader that assembles it.
 *
 * The node's memory map is open (DECOMPOSITION.md D-4), so the tests choose
 * one.  Every test_host_*.c uses this one, so that the capsule's variables
 * and buffers are in the same place in all of them:
 *
 *     16 ..               the capsule's code, assembled from capsule/ *.v4
 *     DICT_W .. DICT_END_W   dictionary space for what is defined at run time
 *     top of memory       buffers, then variables, as below
 */
#ifndef V4_TESTS_HOST_MAP_H
#define V4_TESTS_HOST_MAP_H

#include "v4/text.h"
#include <stdio.h>

#define TOP          ((v4_cell)V4_NODE_WORDS)

/* registers and single variables */
#define NODE_ERROR   (TOP - 2)
#define CONSOLE_TX   (TOP - 4)
#define CONSOLE_RX   (TOP - 6)
#define CONSOLE_ST   (TOP - 7)
#define BASE         (TOP - 8)
#define TO_IN        (TOP - 9)
#define SPAN         (TOP - 10)
#define DP           (TOP - 11)
#define LATEST       (TOP - 12)
#define STATE        (TOP - 13)
#define CFP          (TOP - 14)                 /* the control-flow stack's pointer */
#define DSTACK_REG   (TOP - 15)                 /* DSTACK-DEPTH (D-16) */
#define RSTACK_REG   (TOP - 16)                 /* RSTACK-DEPTH */

/* each capsule file's scratch cells */
#define PVARS        (TOP - 24)                 /* (P): input.v4, 8 cells */
#define DVARS        (TOP - 32)                 /* (D): dict.v4, 5 cells */
#define CGVARS       (TOP - 48)                 /* (CG): codegen.v4, 14 cells */
#define CVARS        (TOP - 62)                 /* (C): compile.v4, 10 cells */
#define FVARS        (TOP - 105)                /* (F): forth.v4, 7 cells */
#define SVARS        (TOP - 540 - (v4_cell)V4_DATA_DEPTH)   /* (S): where PICK and ROLL set stack values aside, one cell for each cell of the stack */
#define WVARS        (TOP - 99)                 /* (W): numout.v4, 3 cells */
#define HLD          (TOP - 25)                 /* where the pictured number has got to */
#define QVARS        (TOP - 52)                 /* (Q): quit.v4, 2 cells */

/* buffers (word addresses; a byte address is four times this) */
#define CFS_W        (TOP - 96)                 /* the control-flow stack, 32 cells */
#define CFS_CELLS    32
#define WBUF_W       (TOP - 170)                /* WORD's buffer: 65 cells = 260 bytes */
#define WBUF_CELLS   65
#define TIB_W        (TOP - 440)                /* the text input buffer: 260 cells = 1040 bytes */
#define PAD_W        (TOP - 470)                /* PAD: 21 cells = 84 bytes */
#define SBUF_W       (TOP - 540)                /* 64 cells for the tests' own strings */
#define HBUF_W       (SVARS - 16)               /* the hold buffer: 16 cells = 64 bytes */
#define HEND         ((HBUF_W + 16) * 4)
#define WBUF         (WBUF_W * 4)
#define TIB          (TIB_W * 4)
#define PAD          (PAD_W * 4)
#define SBUF         (SBUF_W * 4)

/* dictionary space */
#ifndef DICT_W
#define DICT_W       ((v4_cell)8192)
#endif
#ifndef DICT_END_W
#define DICT_END_W   ((v4_cell)14336)
#endif

/* How many slots, from slot 0, a branch may sit in on a node this size: those
 * whose address field reaches every word of it. */
static unsigned host_branch_slots(void)
{
    unsigned k, slots = 0;
    for (k = 0; k < 4; k++) if ((v4_ucell)v4_iword_slot_mask(k) >= (v4_ucell)(V4_NODE_WORDS - 1u)) slots = k + 1;
    return slots;
}

/* Reset `n`, give the assembler every constant the capsule files ask for, and
 * assemble the `count` files named.  Returns 1 if all assembled; otherwise
 * prints which did not and why.  The caller may assemble more text and must
 * call v4_text_finish. */
static int host_load(v4_text *tx, v4_node *n, const char *const *files, unsigned count)
{
    char path[512];
    unsigned i;

    v4_node_reset(n);
    v4_text_begin(tx, n, 16);
    v4_text_constant(tx, "N-1", V4_CELL_BITS - 1);
    v4_text_constant(tx, "NODE-ERROR", NODE_ERROR);
    v4_text_constant(tx, "CONSOLE-TX", CONSOLE_TX);
    v4_text_constant(tx, "CONSOLE-RX", CONSOLE_RX);
    v4_text_constant(tx, "CONSOLE-STATUS", CONSOLE_ST);
    v4_text_constant(tx, "BASE", BASE);
    v4_text_constant(tx, "TIB", TIB);
    v4_text_constant(tx, ">IN", TO_IN);
    v4_text_constant(tx, "SPAN", SPAN);
    v4_text_constant(tx, "WBUF", WBUF);
    v4_text_constant(tx, "(P)", PVARS);
    v4_text_constant(tx, "DP", DP);
    v4_text_constant(tx, "(LATEST)", LATEST);
    v4_text_constant(tx, "DBASE", DICT_W * 4);
    v4_text_constant(tx, "DLIMIT", DICT_END_W * 4);
    v4_text_constant(tx, "PAD", PAD);
    v4_text_constant(tx, "(D)", DVARS);
    v4_text_constant(tx, "(CG)", CGVARS);
    v4_text_constant(tx, "CG-BSLOTS", (v4_cell)host_branch_slots());
    v4_text_constant(tx, "STATE", STATE);
    v4_text_constant(tx, "(C)", CVARS);
    v4_text_constant(tx, "(CFP)", CFP);
    v4_text_constant(tx, "(Q)", QVARS);
    v4_text_constant(tx, "(F)", FVARS);
    v4_text_constant(tx, "(S)", SVARS);
    v4_text_constant(tx, "(W)", WVARS);
    v4_text_constant(tx, "HLD", HLD);
    v4_text_constant(tx, "HEND", HEND);
    v4_text_constant(tx, "-HFLOOR", -(HEND - 62));
    v4_text_constant(tx, "DSTACK-DEPTH", DSTACK_REG);
    v4_text_constant(tx, "RSTACK-DEPTH", RSTACK_REG);
    v4_node_stack_regs_attach(n, DSTACK_REG, RSTACK_REG);
    v4_text_constant(tx, "CFBASE", CFS_W);
    v4_text_constant(tx, "CFEND", CFS_W + CFS_CELLS);
    for (i = 0; i < count; i++) {
        snprintf(path, sizeof path, "%s/%s", V4_CAPSULE_DIR, files[i]);
        if (!v4_text_assemble_file(tx, path)) {
            printf("    %s does not assemble: %s\n", files[i], v4_text_error(tx));
            return 0;
        }
    }
    return 1;
}

#endif /* V4_TESTS_HOST_MAP_H */