v3's whole POST on v4 at 983 of 1010 (the table's own count with its drops), from 850.
What remains is capacity ("Dictionary full", the 100-900-deep stacks): next, as ruled.
Found and fixed under the rulings (docs/v4.0.0/POST-PARITY.md):
- IS and DEFER@ refuse a word DEFER did not make, as v3: error 22, "Not deferred".
v4's IS stored into any word -- POST's `42 IS DUP` broke DUP for every case after it.
DEFER marks its word with flag 128 (dict.f18).
- SMUDGE and HIDDEN are compile-only, as v3's table: at the prompt v4's hid the newest word.
- Q./ by zero gives 0 and no error (ruled: v3's table); error 11 retired. The ROM's,
the test's reference and its hand-assembled copy changed alike.
- FENCE is v3's: it protects what is defined so far. The variable is (FENCE).
- The line's length is (#SRC), no longer SPAN: an EXPECT in a line cut the rest of
the line off, and 0 EXPECT could not leave SPAN 0 (FORTH-83).
- POST gains V4_POST_HEAD: the values left and how the output begins -- the form of a
printout whose values are the run's own (TOP-WORDS, WORD-ENTROPY).
post_all_rules.py: the rest of the whole table where it is not taken as v3 ran it --
v4's units for the cases that wrote through HERE as a byte address (CMOVE>, BLANK,
ERASE, FILL wrote into the system's code), the standard's results (COMPARE, SEARCH,
BASE output, THRU, >BODY with FIND's address), v3's descriptions where v3 printed
otherwise, and the cases dropped with their reasons (SP@/SP! by D-2, DABS/DMIN
underflow, CMOVE>.bounds, THRU.negative_end).
make -C v4 test: all v4 tests passed (both widths, mesh-boot, inference).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RzZgrf7V7Zk2iczBXDRbm
127 lines
4.9 KiB
C
127 lines
4.9 KiB
C
/* SPDX-License-Identifier: LicenseRef-Starship-1.0
|
|
* Copyright (c) 2023-2026 Robert A. James
|
|
*/
|
|
/* post.c -- POST's runner: the kernel feeds a case to the node and judges it
|
|
* from outside. See post.h; docs/v4.0.0/NUCLEUS.md section 6.3.
|
|
*
|
|
* Nothing here uses the C library: the bare-metal kernel links this file.
|
|
*/
|
|
#include "v4/post.h"
|
|
#include "v4/message.h"
|
|
|
|
#define SHOWN_OUT 255u /* how much of a failing case's printing is shown */
|
|
#define SHOWN_STACK 32u /* and how many of the values it left */
|
|
|
|
static const char state_line[] = "DECIMAL FORTH DEFINITIONS";
|
|
|
|
static unsigned length(const char *s)
|
|
{
|
|
unsigned n = 0;
|
|
while (s[n]) n++;
|
|
return n;
|
|
}
|
|
|
|
static void say(const v4_post_host *h, const char *s)
|
|
{
|
|
h->say(h->self, s, length(s));
|
|
}
|
|
|
|
static void say_number(const v4_post_host *h, long long v)
|
|
{
|
|
char text[24];
|
|
unsigned at = sizeof text;
|
|
unsigned long long u = v < 0 ? 0ull - (unsigned long long)v : (unsigned long long)v;
|
|
|
|
do { text[--at] = (char)('0' + u % 10u); u /= 10u; } while (u);
|
|
if (v < 0) text[--at] = '-';
|
|
h->say(h->self, text + at, (unsigned)sizeof text - at);
|
|
}
|
|
|
|
int v4_post_run(const v4_post_host *h, const v4_post_case *cases, unsigned count, v4_post_tally *tally)
|
|
{
|
|
static char out[V4_POST_OUT]; /* what the case being run has printed */
|
|
v4_cell left[SHOWN_STACK]; /* what it left on the stack, the top first */
|
|
unsigned i, k;
|
|
|
|
tally->tests = 0; tally->pass = 0; tally->fail = 0;
|
|
for (i = 0; i < count; i++) {
|
|
const v4_post_case *c = &cases[i];
|
|
unsigned kept = 0, total = 0, len = 0, depth;
|
|
int errored = 0, came_back = 1, lost = 0, no_state = 0, quit = 0, ok, how;
|
|
|
|
/* every case starts from the same state */
|
|
v4_dstack_reset(&h->n->ds);
|
|
how = h->line(h->self, state_line, (unsigned)sizeof state_line - 1u, out, V4_POST_OUT, &len);
|
|
if (how < 0) lost = 1;
|
|
if (how != V4_TEXT_COMPLETED) { /* what the node said of it is what is shown */
|
|
came_back = 0; no_state = 1;
|
|
total = len; kept = len < V4_POST_OUT ? len : V4_POST_OUT;
|
|
}
|
|
v4_dstack_reset(&h->n->ds);
|
|
|
|
for (k = 0; came_back && k < c->line_count; k++) {
|
|
len = 0;
|
|
how = h->line(h->self, c->lines[k], length(c->lines[k]), out + kept, V4_POST_OUT - kept, &len);
|
|
if (how < 0) { came_back = 0; lost = 1; break; }
|
|
if (how == V4_TEXT_ERROR) errored = 1;
|
|
if (how == V4_TEXT_QUIT) quit = 1; /* it went back to the terminal: it did not complete */
|
|
total += len;
|
|
kept = total < V4_POST_OUT ? total : V4_POST_OUT;
|
|
}
|
|
|
|
/* what it left, read before anything is judged */
|
|
depth = h->n->ds.depth;
|
|
for (k = 0; k < depth; k++) {
|
|
v4_cell v = v4_dstack_pop(&h->n->ds);
|
|
if (k < SHOWN_STACK) left[k] = v;
|
|
}
|
|
v4_dstack_reset(&h->n->ds);
|
|
|
|
if (!came_back || quit) {
|
|
ok = 0;
|
|
} else if (c->expect == V4_POST_ERROR) {
|
|
ok = errored;
|
|
} else if (errored) {
|
|
ok = 0;
|
|
} else {
|
|
ok = depth == c->depth;
|
|
if (ok && c->expect == V4_POST_STACK) {
|
|
if (depth > SHOWN_STACK) ok = 0;
|
|
for (k = 0; ok && k < depth; k++) ok = left[k] == (v4_cell)c->stack[depth - 1u - k];
|
|
}
|
|
if (ok && c->expect == V4_POST_HEAD) {
|
|
ok = c->output_len <= kept;
|
|
for (k = 0; ok && k < c->output_len; k++) ok = out[k] == c->output[k];
|
|
} else if (ok && c->expect != V4_POST_DEPTH) {
|
|
ok = total == c->output_len && total <= V4_POST_OUT;
|
|
for (k = 0; ok && k < total; k++) ok = out[k] == c->output[k];
|
|
}
|
|
}
|
|
|
|
tally->tests++;
|
|
if (ok) { tally->pass++; continue; }
|
|
tally->fail++;
|
|
say(h, "POST FAIL: "); say(h, c->name);
|
|
if (no_state) say(h, " could not be put in its starting state:");
|
|
if (quit) say(h, " ended with QUIT:");
|
|
say(h, " out<"); h->say(h->self, out, kept < SHOWN_OUT ? kept : SHOWN_OUT);
|
|
say(h, "> stack<");
|
|
for (k = depth < SHOWN_STACK ? depth : SHOWN_STACK; k-- > 0; ) { say_number(h, (long long)left[k]); say(h, " "); }
|
|
say(h, ">\n");
|
|
|
|
/* The node did not come back from a line: it is stopped, or will
|
|
* run for ever. Nothing more can be asked of it, so POST ends
|
|
* here and says which case it was. */
|
|
if (lost) {
|
|
say(h, "POST: the node did not come back from "); say(h, c->name);
|
|
say(h, "; "); say_number(h, (long long)(count - i - 1u)); say(h, " not run\n");
|
|
break;
|
|
}
|
|
}
|
|
say(h, "PARITY:V4_POST tests="); say_number(h, (long long)tally->tests);
|
|
say(h, " pass="); say_number(h, (long long)tally->pass);
|
|
say(h, " fail="); say_number(h, (long long)tally->fail);
|
|
say(h, "\n");
|
|
return tally->fail == 0;
|
|
}
|