LithosAnanke/v4/tools/hosted.c

/* SPDX-License-Identifier: LicenseRef-Starship-1.0
 * Copyright (c) 2023-2026 Robert A. James
 */
/* hosted.c -- StarForth v4 as a Linux program: the golden model with its
 * ROM, which assembles the system from its source, and its capsules loaded
 * as the system comes up (v4/include/v4/boot.h, the same boot the
 * bare-metal kernel runs), the console on stdin and stdout.
 *
 * It runs until its input ends.  Blocks are kept in memory and are gone
 * when it stops.
 */
#include "v4/boot.h"
#include "block_subsystem.h"
#include <stdio.h>
#include <string.h>

static v4_node       n;
static v4_exec_state es;
static v4_heat       h;
static v4_image      im;

/* STORAGE.  The node asks its kernel for its blocks (v4/blocks.h), and the
 * kernel's block subsystem has them (docs/v4.0.0/MESH.md section 8).  A
 * Linux program is given what hosted v3 has when it is started with no
 * disk: the chain's fast RAM, blocks 1 to 2047, which is gone when the
 * program ends. */
static unsigned char block_ram[(size_t)BLK_RAM_BLOCKS * BLK_FORTH_SIZE];
extern void sf_time_init(void);

static void console_out(const char *text, unsigned len)
{
    (void)fwrite(text, 1, len, stdout);
}

/* a character for a line that reads the keyboard */
static int console_key(void)
{
    int c;
    fflush(stdout);
    c = getchar();
    return c == EOF ? V4_BOOT_KEY_END : c;
}

/* THE KERNEL'S WORDS, for a node that is a Linux program: the words that
 * are C in hosted v3 because only the host can do them. */
static const char *const kernel_words[] = { "BYE" };
static int leaving;

static void serve(v4_node *node, unsigned request)
{
    (void)node;
    if (request == 1) {                              /* BYE ( -- ): as hosted v3, say so and leave */
        fputs("Goodbye!\n", stdout);
        leaving = 1;
    }
}

/* A line from stdin, its new line taken off.  Returns its length, or -1 when
 * the input has ended.  A line longer than the buffer is read to its end and
 * the rest thrown away, so that no part of it is run as a line of its own:
 * the length returned is then the buffer's, which is more than a line may be,
 * and the boot refuses it as too long. */
static long read_line(char *line, unsigned cap)
{
    size_t len;
    int c;

    if (!fgets(line, (int)cap, stdin)) return -1;
    len = strlen(line);
    if (len && line[len - 1] == '\n') return (long)(len - 1);
    if (len == cap - 1u)
        while ((c = getchar()) != EOF && c != '\n') { }
    return (long)len;
}

/* The prompt is the host's, as it is the kernel's REPL's for a v3 VM: read a
 * line, hand it to the node, say how it ended. */
int main(void)
{
    static char line[1026];
    v4_boot boot;

    im = v4_map_image;
    boot.n = &n; boot.es = &es; boot.h = &h; boot.im = &im;
    boot.out = console_out; boot.key = console_key;
    boot.words = kernel_words; boot.word_count = sizeof kernel_words / sizeof kernel_words[0]; boot.serve = serve;
    boot.request = 0; boot.request_self = 0;          /* no registry, and no capsules of its own: the hosted product */
    boot.capsules = 0; boot.capsule_count = 0;
    sf_time_init();
    if (blk_subsys_init(block_ram, sizeof block_ram) != BLK_OK) { fputs("V4: no block storage\n", stderr); return 1; }
    if (!v4_boot_run(&boot)) { fflush(stdout); return 1; }

    for (;;) {
        long len;
        int how;

        fputs("ok> ", stdout);
        fflush(stdout);
        if ((len = read_line(line, sizeof line)) < 0) { putchar('\n'); return 0; }
        how = v4_boot_line(&boot, line, (unsigned)len);
        /* The line is waiting for an answer no one here can send.  The next
         * line typed breaks the wait: the line that was waiting ends in an
         * error, and then the line just typed is done (boot.h). */
        while (how == V4_BOOT_LINE_WAITING) {
            fflush(stdout);
            if ((len = read_line(line, sizeof line)) < 0) { putchar('\n'); return 0; }
            how = v4_boot_line(&boot, line, (unsigned)len);
            if (how == V4_BOOT_LINE_TOO_LONG) { fputs("Line too long\n ERROR\n", stdout); how = V4_BOOT_LINE_WAITING; continue; }
            if (how == V4_TEXT_ERROR) fputs(" ERROR\nok> ", stdout);
            else if (how == V4_TEXT_COMPLETED) fputs(" ok\nok> ", stdout);
            else break;
            how = v4_boot_line(&boot, 0, 0);
        }
        if (how == V4_TEXT_COMPLETED) fputs(" ok\n", stdout);
        if (leaving) { fflush(stdout); return 0; }
        else if (how == V4_TEXT_ERROR) fputs(" ERROR\n", stdout);
        else if (how == V4_BOOT_LINE_TOO_LONG) fputs("Line too long\n ERROR\n", stdout);
        else if (how == V4_BOOT_LINE_REFUSED) fputs("Message refused\n ERROR\n", stdout);     /* the node's wire is full: error 19's words */
        else if (how == V4_BOOT_LINE_NO_INPUT) { putchar('\n'); return 0; }
        else if (how == V4_BOOT_LINE_STOPPED) { fflush(stdout); fprintf(stderr, "starforth4: the node stopped on a fault\n"); return 1; }
    }
}