rajamesandClaude Opus 5.5
cbe1cd5e44
Text for a node from its console, arriving while the node waits for an answer (AWAIT), is kept as any message is; the wait ends in error 21, Interrupted; and the text is then done as usual. Console text for another node, passing through a node that is waiting, does not end its wait. On the hosted program 5 AWAIT ended the program with "the node stopped". The boot now reports that the line is waiting, the host reads the next line and hands it over, which breaks the wait, and then has the kept line done. The bare-metal host does the same; it is booted in the commit that follows. test_host_mesh.c: 76 checks, both widths and the sanitizers. hosted-check types 5 AWAIT and two more lines: Interrupted, then 3 and 56. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
101 lines
3.9 KiB
C
101 lines
3.9 KiB
C
/* hosted.c -- StarForth v4 as a Linux program: the nucleus image on the
|
|
* golden model, 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;
|
|
|
|
/* 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;
|
|
}
|
|
}
|
|
|
|
/* 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;
|
|
|
|
boot.n = &n; boot.es = &es; boot.h = &h; boot.im = &v4_capsule_image;
|
|
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;
|
|
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 (;;) {
|
|
size_t len;
|
|
int how;
|
|
|
|
fputs("ok> ", stdout);
|
|
fflush(stdout);
|
|
if (!fgets(line, sizeof line, stdin)) { putchar('\n'); return 0; }
|
|
len = strlen(line);
|
|
if (len && line[len - 1] == '\n') len--;
|
|
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 (!fgets(line, sizeof line, stdin)) { putchar('\n'); return 0; }
|
|
len = strlen(line);
|
|
if (len && line[len - 1] == '\n') len--;
|
|
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_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; }
|
|
}
|
|
}
|