Files
LithosAnanke/docs/v4.0.0/POST.md
T
Claude 281972abb2 perf(v4): POST at a boot's pace -- v3's per-suite put-back, and a lookup that rejects by two bytes (#189)
Ruled (Captain Bob, 2026-11-14): "Find the TCG cost first". v3's whole POST took the amd64
accept from about 3 m 15 s to 8 m 45 s, and aarch64 past its 570 s (logs/20261114-091651,
STOPPED, committed). Profiled on the host (gprof, mesh-boot): 87% of the time in POST's
lines, about 280,000 opcodes a line -- the interpreter's dictionary lookup.

- POST puts the dictionary back before each of v3's suites, as v3's run_test_suite does
  ("to remove test-created words"): a mark, (POST), forgotten and made again
  (V4_POST_SUITE). Only the dictionary: SCR, BASE and the rest stay as the cases left them.
- (LOOKUP) tries each entry by its count and first character first -- one fetch of the
  name's first cell, masked -- and only then its hidden flag and the whole name. The answer
  is the same; an entry that cannot be it costs a few opcodes, not some forty.

mesh-boot: 37.7 s -> 15.7 s, POST 990 of 990. make -C v4 test: all v4 tests passed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RzZgrf7V7Zk2iczBXDRbm
2026-11-14 13:26:45 +00:00

329 lines
57 KiB
Markdown

# POST: v3's whole POST on v4, where it departs from v3
Written by `v4/tools/mkpost.py --all` from `v4/tools/post79_rules.py` and
`v4/tools/post_all_rules.py`; do not edit. The rulings: `POST-PARITY.md` (#189 Phase 7:
the standard first -- FORTH-79, FORTH-83, ANS 1994 -- then v3's table, not v3's bugs).
The cases are `v4/system/post_cases.c`; those of the words `capsules/v4/physics.4th` defines
need the kernel and are not run by the hosted product.
POST runs 990 cases. 783 are v3's, with what the hosted v3 binary did as the
expected result. This file lists every other case, and why.
## 1. Rewritten: the standard's result, or v3's table's (159)
v3 departs from the standard, or the case is written for v3's machine. v4
follows the standard (standing ruling), so the expected result is the
standard's and not v3's.
| Case | v3's line | What v3 did | As POST runs it | Must do | Why |
|---|---|---|---|---|---|
| `PICK.pick_0` | `1 2 3 0 PICK . CR` | stack `1 2 3`, printed `3 \n` | unchanged | an error | FORTH-79: PICK and ROLL count from 1; v3 counts from 0; 0 PICK is an error |
| `PICK.pick_1` | `1 2 3 1 PICK . CR` | stack `1 2 3`, printed `2 \n` | unchanged | stack `1 2 3`, prints `3 \n` | FORTH-79: PICK and ROLL count from 1; v3 counts from 0 |
| `PICK.pick_2` | `1 2 3 2 PICK . CR` | stack `1 2 3`, printed `1 \n` | unchanged | stack `1 2 3`, prints `2 \n` | FORTH-79: PICK and ROLL count from 1; v3 counts from 0 |
| `ROLL.roll_1` | `1 2 3 1 ROLL . . . CR` | stack `empty`, printed `1 3 2 \n` | unchanged | stack `empty`, prints `3 2 1 \n` | FORTH-79: PICK and ROLL count from 1; v3 counts from 0 |
| `>R.basic` | `42 >R R@ . R> . CR` | stack `empty`, printed `42 42 \n` | `: RS1 42 >R R@ . R> . CR ; RS1` | stack `empty`, prints `42 42 \n` | FORTH-79: >R R> R@ are for use inside a definition; v4 refuses them at the prompt |
| `>R.zero` | `0 >R R@ . R> . CR` | stack `empty`, printed `0 0 \n` | `: RS2 0 >R R@ . R> . CR ; RS2` | stack `empty`, prints `0 0 \n` | FORTH-79: >R R> R@ are for use inside a definition; v4 refuses them at the prompt |
| `>R.negative` | `-123 >R R@ . R> . CR` | stack `empty`, printed `-123 -123 \n` | `: RS3 -123 >R R@ . R> . CR ; RS3` | stack `empty`, prints `-123 -123 \n` | FORTH-79: >R R> R@ are for use inside a definition; v4 refuses them at the prompt |
| `>R.multiple` | `1 2 >R >R R@ . R> . R@ . R> . CR` | stack `empty`, printed `1 1 2 2 \n` | `: RS4 1 2 >R >R R@ . R> . R@ . R> . CR ; RS4` | stack `empty`, prints `1 1 2 2 \n` | FORTH-79: >R R> R@ are for use inside a definition; v4 refuses them at the prompt |
| `R>.basic` | `42 >R R> . CR` | stack `empty`, printed `42 \n` | `: RS5 42 >R R> . CR ; RS5` | stack `empty`, prints `42 \n` | FORTH-79: >R R> R@ are for use inside a definition; v4 refuses them at the prompt |
| `R>.lifo_order` | `1 2 >R >R R> . R> . CR` | stack `empty`, printed `1 2 \n` | `: RS6 1 2 >R >R R> . R> . CR ; RS6` | stack `empty`, prints `1 2 \n` | FORTH-79: >R R> R@ are for use inside a definition; v4 refuses them at the prompt |
| `R@.basic` | `42 >R R@ . R> DROP CR` | stack `empty`, printed `42 \n` | `: RS7 42 >R R@ . R> DROP CR ; RS7` | stack `empty`, prints `42 \n` | FORTH-79: >R R> R@ are for use inside a definition; v4 refuses them at the prompt |
| `R@.non_destructive` | `99 >R R@ R@ = . R> DROP CR` | stack `empty`, printed `-1 \n` | `: RS8 99 >R R@ R@ = . R> DROP CR ; RS8` | stack `empty`, prints `-1 \n` | FORTH-79: >R R> R@ are for use inside a definition; v4 refuses them at the prompt |
| `,.basic` | `42 , HERE 8 - @ . CR` | stack `empty`, printed `42 \n` | `42 , HERE 1 - @ . CR` | stack `empty`, prints `42 \n` | v3's address unit is a byte; a v4 address unit is a cell (D-1) |
| `,.negative` | `-999 , HERE 8 - @ . CR` | stack `empty`, printed `-999 \n` | `-999 , HERE 1 - @ . CR` | stack `empty`, prints `-999 \n` | v3's address unit is a byte; a v4 address unit is a cell (D-1) |
| `+!.basic` | `10 HERE ! 5 HERE +! HERE @ . CR` | error | unchanged | stack `empty`, prints `15 \n` | v3 raises an error FORTH-79 does not ask for: a store to HERE |
| `+!.by_zero` | `42 HERE ! 0 HERE +! HERE @ . CR` | error | unchanged | stack `empty`, prints `42 \n` | v3 raises an error FORTH-79 does not ask for: a store to HERE |
| `+!.negative` | `10 HERE ! -3 HERE +! HERE @ . CR` | error | unchanged | stack `empty`, prints `7 \n` | v3 raises an error FORTH-79 does not ask for: a store to HERE |
| `+!.accumulate` | `0 HERE ! 1 HERE +! 2 HERE +! 3 HERE +! HERE @ . CR` | error | unchanged | stack `empty`, prints `6 \n` | v3 raises an error FORTH-79 does not ask for: a store to HERE |
| `HERE.after_comma~2` | `HERE 42 , HERE SWAP - 1 CELLS = 0 SWAP /` | error | unchanged | stack `0`, prints nothing | v3 raises an error its table says it does not: HERE moves by 1 CELLS, so the flag is -1 and 0 -1 / is 0 (ruled: v3's table) |
| `MOVE.basic` | `HERE 65 OVER C! HERE 1+ 66 OVER C! HERE HERE 16 + 2 MOVE HERE 16 + C@ . HERE 17 + C@ . CR` | stack `334 335`, printed `65 66 \n` | `65 HERE ! 66 HERE 1+ ! HERE HERE 16 + 2 MOVE HERE 16 + @ . HERE 17 + @ . CR` | stack `empty`, prints `65 66 \n` | FORTH-79: MOVE moves cells; and v3's address unit is a byte; a v4 address unit is a cell (D-1) |
| `BASE.base_store` | `16 BASE ! 255 . CR` | stack `empty`, printed `597 \n` | unchanged | stack `empty`, prints `255 \n` | 255 read in base 16 and printed in base 16 is 255; v3 printed 467 |
| `<#.basic` | `DECIMAL 42 S>D <# #S #> TYPE CR` | stack `empty`, printed `774763251095801167872\n` | unchanged | stack `empty`, prints `42\n` | v3 prints 774763251095801167872 for 42 S>D <# #S #> |
| `<#.empty` | `0 <# #> TYPE CR` | stack `0`, printed `\n` | `0 0 <# #> TYPE CR` | stack `empty`, prints `\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `<#.negative` | `-42 <# #S #> TYPE CR` | stack `empty`, printed `42\n` | `-42 DUP ABS 0 <# #S ROT SIGN #> TYPE CR` | stack `empty`, prints `-42\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `#.single_digit` | `15 <# # #> TYPE CR` | stack `empty`, printed `5\n` | `15 0 <# # #> TYPE CR` | stack `empty`, prints `5\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `#.multiple` | `15 <# # # #> TYPE CR` | stack `empty`, printed `15\n` | `15 0 <# # # #> TYPE CR` | stack `empty`, prints `15\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `#.zero_pad` | `5 <# # 0 # #> TYPE CR` | stack `0`, printed `05\n` | `5 0 <# # # #> TYPE CR` | stack `empty`, prints `05\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `#S.basic` | `42 <# #S #> TYPE CR` | stack `empty`, printed `42\n` | `42 0 <# #S #> TYPE CR` | stack `empty`, prints `42\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `#S.zero` | `0 <# #S #> TYPE CR` | stack `empty`, printed `0\n` | `0 0 <# #S #> TYPE CR` | stack `empty`, prints `0\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `#S.large` | `1234567890 <# #S #> TYPE CR` | stack `empty`, printed `1234567890\n` | `1234567890 0 <# #S #> TYPE CR` | stack `empty`, prints `1234567890\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `SIGN.negative` | `-42 ABS <# #S SIGN #> TYPE CR` | stack `0`, printed `42\n` | `-42 DUP ABS 0 <# #S ROT SIGN #> TYPE CR` | stack `empty`, prints `-42\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `SIGN.positive` | `42 <# #S SIGN #> TYPE CR` | stack `0`, printed `42\n` | `42 DUP ABS 0 <# #S ROT SIGN #> TYPE CR` | stack `empty`, prints `42\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `SIGN.zero` | `0 <# #S SIGN #> TYPE CR` | stack `0`, printed `0\n` | `0 DUP ABS 0 <# #S ROT SIGN #> TYPE CR` | stack `empty`, prints `0\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `#>.normal` | `42 <# #S #> TYPE CR` | stack `empty`, printed `42\n` | `42 0 <# #S #> TYPE CR` | stack `empty`, prints `42\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `#>.empty` | `0 <# #> TYPE CR` | stack `0`, printed `\n` | `0 0 <# #> TYPE CR` | stack `empty`, prints `\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `#>.stack_effect` | `42 <# #S #> SWAP . . CR` | stack `empty`, printed `24 2 \n` | `42 0 <# #S #> SWAP DROP . CR` | stack `empty`, prints `2 \n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `HOLD.basic` | `42 <# 46 HOLD #S #> TYPE CR` | stack `empty`, printed `42.\n` | `42 0 <# 46 HOLD #S #> TYPE CR` | stack `empty`, prints `42.\n` | FORTH-79: <# # #S #> work on a double number; v3 takes a single |
| `COUNT.basic` | `HERE S" Test" DROP COUNT . . CR` | stack `334`, printed `84 335 \n` | `4 PAD C! PAD COUNT . PAD - . CR` | stack `empty`, prints `4 1 \n` | v3's address unit is a byte; a v4 address unit is a cell (D-1); and S" is not FORTH-79 |
| `COUNT.empty` | `HERE 0 OVER C! COUNT . . CR` | stack `empty`, printed `0 340 \n` | `0 PAD C! PAD COUNT . PAD - . CR` | stack `empty`, prints `0 1 \n` | v3's address unit is a byte; a v4 address unit is a cell (D-1) |
| `COUNT.max_length` | `HERE 255 OVER C! COUNT . . CR` | stack `empty`, printed `255 340 \n` | `255 PAD C! PAD COUNT . PAD - . CR` | stack `empty`, prints `255 1 \n` | v3's address unit is a byte; a v4 address unit is a cell (D-1) |
| `COUNT.basic~2` | `HERE S" Test" DROP C@ HERE 1+ SWAP COUNT . . CR` | stack `748 754`, printed `0 85 \n` | `4 PAD C! PAD COUNT . PAD - . CR` | stack `empty`, prints `4 1 \n` | v3's address unit is a byte; a v4 address unit is a cell (D-1) |
| `COUNT.empty~2` | `HERE 0 OVER C! COUNT . . CR` | stack `empty`, printed `0 754 \n` | `0 PAD C! PAD COUNT . PAD - . CR` | stack `empty`, prints `0 1 \n` | v3's address unit is a byte; a v4 address unit is a cell (D-1) |
| `COUNT.max_length~2` | `HERE 255 OVER C! COUNT . . CR` | stack `empty`, printed `255 754 \n` | `255 PAD C! PAD COUNT . PAD - . CR` | stack `empty`, prints `255 1 \n` | v3's address unit is a byte; a v4 address unit is a cell (D-1) |
| `CMOVE.basic` | `HERE S" Test" DUP >R HERE 10 + SWAP CMOVE CR` | stack `357`, printed `\n` | `65 PAD C! 66 PAD 1+ C! PAD PAD 10 + 2 CMOVE PAD 10 + C@ . PAD 11 + C@ . CR` | stack `empty`, prints `65 66 \n` | v3's address unit is a byte; a v4 address unit is a cell (D-1); and the v3 case leaves a value on the return stack |
| `TYPE.basic_string` | `HERE S" Hello" DUP >R HERE SWAP CMOVE HERE R> TYPE CR` | stack `736`, printed `Hello\n` | `72 PAD C! 105 PAD 1+ C! PAD 2 TYPE CR` | stack `empty`, prints `Hi\n` | v3's address unit is a byte; a v4 address unit is a cell (D-1); and FORTH-79: >R R> R@ are for use inside a definition; v4 refuses them at the prompt |
| `TYPE.numbers` | `HERE S" 12345" DUP >R HERE SWAP CMOVE HERE R> TYPE CR` | stack `742`, printed `12345\n` | `49 PAD C! 50 PAD 1+ C! PAD 2 TYPE CR` | stack `empty`, prints `12\n` | v3's address unit is a byte; a v4 address unit is a cell (D-1); and FORTH-79: >R R> R@ are for use inside a definition; v4 refuses them at the prompt |
| `>IN.initial` | `>IN @ . CR` | stack `empty`, printed `7884064 \n` | unchanged | stack `empty`, prints `6 \n` | FORTH-79: >IN is the offset into the input, 6 here; v3 prints an address |
| `UPDATE.no_block` | `0 SCR ! UPDATE` | error | unchanged | stack `empty`, prints nothing | v3 raises an error FORTH-79 does not ask for |
| `SCR.after_load` | `1 LOAD SCR @ . CR` | stack `empty`, printed `1 \n` | unchanged | stack `empty`, prints `1 \n` | v3 prints nothing after 1 LOAD; SCR is still 1 from the LIST before |
| `FIND.existing` | `FIND DUP . CR` | stack `empty`, printed `7883424 \n` | unchanged | 0 value(s) left; output not compared | FORTH-79: FIND takes the next word, DUP here, and leaves its address, which is printed |
| `FIND.user_word` | `: test5 44 ; FIND test5 . CR` | stack `empty`, printed `8206544 \n` | unchanged | 0 value(s) left; output not compared | the address FIND leaves is printed |
| `FIND.empty` | `FIND` | error | unchanged | stack `0`, prints nothing | FORTH-79: FIND leaves 0 when there is no word; v3 raises an error |
| `VOCABULARY.cross_vocab_access` | `VOCABULARY V1 V1 DEFINITIONS : V1WORD 11 ; FORTH V1WORD . CR` | stack `empty`, printed `11 \n` | unchanged | an error | FORTH-79: a word defined in another vocabulary is not found from FORTH; v3 finds it |
| `VOCABULARY.duplicate` | `VOCABULARY TESTVOC VOCABULARY TESTVOC` | error | unchanged | stack `empty`, prints nothing | v3 raises an error FORTH-79 does not ask for: defining a name again |
| `IF.true` | `: TEST1 IF 42 ELSE 24 THEN ; -1 TEST1 . CR` | stack `empty`, printed `42 \n` | unchanged | stack `empty`, prints `42 \n` | v3 runs an older TEST1 from another vocabulary and leaves the flag |
| `IF.false` | `: TEST2 IF 42 ELSE 24 THEN ; 0 TEST2 . CR` | stack `empty`, printed `24 \n` | unchanged | stack `empty`, prints `24 \n` | v3 runs an older TEST2 from another vocabulary and leaves the flag |
| `LEAVE.basic` | `: TLV 0 5 0 DO I 3 = IF LEAVE THEN 1+ LOOP ; TLV . CR` | stack `empty`, printed `3 \n` | unchanged | stack `empty`, prints `4 \n` | FORTH-79: LEAVE ends the loop at the next LOOP; v3 jumps out at once |
| `LEAVE.at_start` | `: TLV2 0 5 0 DO LEAVE 1+ LOOP ; TLV2 . CR` | stack `empty`, printed `0 \n` | unchanged | stack `empty`, prints `1 \n` | FORTH-79: LEAVE ends the loop at the next LOOP; v3 jumps out at once |
| `LEAVE.qdloop` | `: TLV3 0 5 0 ?DO I 2 = IF LEAVE THEN 1+ LOOP ; TLV3 . CR` | stack `empty`, printed `2 \n` | unchanged | stack `empty`, prints `3 \n` | FORTH-79: LEAVE ends the loop at the next LOOP; v3 jumps out at once |
| `C,.basic` | `65 C, HERE 1 - C@ . CR` | stack `empty`, printed `65 \n` | `ALIGN HERE 4 * 65 C, C@ . CR` | stack `empty`, prints `65 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `C,.zero` | `0 C, HERE 1 - C@ . CR` | stack `empty`, printed `0 \n` | `ALIGN HERE 4 * 0 C, C@ . CR` | stack `empty`, prints `0 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `2,.roundtrip` | `12345 67890 2, HERE 16 - 2@ . . CR` | stack `empty`, printed `67890 12345 \n` | `12345 67890 2, HERE 2 - 2@ . . CR` | stack `empty`, prints `67890 12345 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `2,.save-and-verify` | `12345 67890 2, HERE 16 - 2@ 67890 = SWAP 12345 = AND . CR` | stack `empty`, printed `-1 \n` | `12345 67890 2, HERE 2 - 2@ 67890 = SWAP 12345 = AND . CR` | stack `empty`, prints `-1 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `-!.basic` | `10 HERE ! 3 HERE -! HERE @ . CR` | error | unchanged | stack `empty`, prints `7 \n` | v3's own word: v3 raises an error its table says it does not (ruled: v3's table, not v3's bugs) |
| `-!.by_zero` | `42 HERE ! 0 HERE -! HERE @ . CR` | error | unchanged | stack `empty`, prints `42 \n` | v3's own word: v3 raises an error its table says it does not (ruled: v3's table, not v3's bugs) |
| `-!.negative` | `10 HERE ! -5 HERE -! HERE @ . CR` | error | unchanged | stack `empty`, prints `15 \n` | v3's own word: v3 raises an error its table says it does not (ruled: v3's table, not v3's bugs) |
| `2!.basic` | `11 22 HERE 2! HERE @ . HERE 8 + @ . CR` | error | `11 22 HERE 2! HERE @ . HERE 1 + @ . CR` | stack `empty`, prints `22 11 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's; FORTH-83 ('number'): a double is stored with its high cell at the lower address (ruled 2026-11-14) |
| `2!.zeros` | `0 0 HERE 2! HERE @ . HERE 8 + @ . CR` | error | `0 0 HERE 2! HERE @ . HERE 1 + @ . CR` | stack `empty`, prints `0 0 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's; FORTH-83 ('number'): a double is stored with its high cell at the lower address (ruled 2026-11-14) |
| `2!.negative` | `-1 -2 HERE 2! HERE @ . HERE 8 + @ . CR` | error | `-1 -2 HERE 2! HERE @ . HERE 1 + @ . CR` | stack `empty`, prints `-2 -1 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's; FORTH-83 ('number'): a double is stored with its high cell at the lower address (ruled 2026-11-14) |
| `ERASE.basic` | `HERE 4 65 FILL HERE 4 ERASE HERE C@ . HERE 3 + C@ . CR` | stack `empty`, printed `0 0 \n` | `HERE 4 * 4 65 FILL HERE 4 * 4 ERASE HERE 4 * C@ . HERE 4 * 3 + C@ . CR` | stack `empty`, prints `0 0 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's; v3's case in v3's units, run in v4's, writes into the system's code (FILL at a cell address taken as a byte address) |
| `ERASE.zero_n` | `HERE 0 ERASE` | stack `empty`, printed `` | `HERE 4 * 0 ERASE` | stack `empty`, prints nothing | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `FILL.zero_n` | `HERE 0 88 FILL` | stack `empty`, printed `` | `HERE 4 * 0 88 FILL` | stack `empty`, prints nothing | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `MOVE.zero_n` | `HERE HERE 8 + 0 MOVE` | stack `empty`, printed `` | `HERE HERE 1 + 0 MOVE` | stack `empty`, prints nothing | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `CMOVE>.basic` | `HERE S" Test" DUP >R HERE 10 + SWAP CMOVE> CR` | stack `362`, printed `\n` | `: PTCM S" Test" HERE 4 * 10 + SWAP CMOVE> ; PTCM HERE 4 * 10 + 4 TYPE CR` | stack `empty`, prints `Test\n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's; v3's case in v3's units, run in v4's, writes into the system's code (HERE, a cell address, taken as a byte address); ANS Forth 6.1.0580 >R: 'Interpretation semantics for this word are undefined' -- the case run inside a definition (v3's DUP >R left the count on the return stack) |
| `CMOVE>.overlap` | `HERE DUP 1+ 5 CMOVE>` | stack `empty`, printed `` | `HERE 4 * DUP 1+ 5 CMOVE>` | stack `empty`, prints nothing | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's; v3's case in v3's units, run in v4's, writes into the system's code (HERE, a cell address, taken as a byte address) |
| `BLANK.basic` | `HERE 5 BLANK HERE 5 TYPE CR` | stack `empty`, printed ` \n` | `HERE 4 * 5 BLANK HERE 4 * 5 TYPE CR` | stack `empty`, prints ` \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's; v3's case in v3's units, run in v4's, writes into the system's code (HERE, a cell address, taken as a byte address) |
| `COMPARE.equal` | `HERE S" Test" HERE S" Test" COMPARE . CR` | stack `367 367`, printed `-1 \n` | `: PTC1 S" Test" S" Test" COMPARE . ; PTC1 CR` | stack `empty`, prints `0 \n` | ANS Forth 17.6.1.0935 COMPARE and 17.6.1.2191 SEARCH, as their descriptions have them; v3's case compares S"'s string with HERE taken as a length. In a definition, as ANS 11.6.1.2165 S" keeps one interpreted string only |
| `COMPARE.less` | `HERE S" Test1" HERE S" Test2" COMPARE . CR` | stack `377 377`, printed `-1 \n` | `: PTC2 S" Test1" S" Test2" COMPARE . ; PTC2 CR` | stack `empty`, prints `-1 \n` | ANS Forth 17.6.1.0935 COMPARE and 17.6.1.2191 SEARCH, as their descriptions have them; v3's case compares S"'s string with HERE taken as a length. In a definition, as ANS 11.6.1.2165 S" keeps one interpreted string only |
| `COMPARE.greater` | `HERE S" Test2" HERE S" Test1" COMPARE . CR` | stack `389 389`, printed `-1 \n` | `: PTC3 S" Test2" S" Test1" COMPARE . ; PTC3 CR` | stack `empty`, prints `1 \n` | ANS Forth 17.6.1.0935 COMPARE and 17.6.1.2191 SEARCH, as their descriptions have them; v3's case compares S"'s string with HERE taken as a length. In a definition, as ANS 11.6.1.2165 S" keeps one interpreted string only |
| `COMPARE.different_lengths` | `HERE S" Test" HERE S" Testing" COMPARE . CR` | stack `401 401`, printed `-1 \n` | `: PTC4 S" Test" S" Testing" COMPARE . ; PTC4 CR` | stack `empty`, prints `-1 \n` | ANS Forth 17.6.1.0935 COMPARE and 17.6.1.2191 SEARCH, as their descriptions have them; v3's case compares S"'s string with HERE taken as a length. In a definition, as ANS 11.6.1.2165 S" keeps one interpreted string only |
| `SEARCH.found` | `HERE S" Testing" HERE S" Test" SEARCH . . . CR` | stack `414 414`, printed `-1 95 334 \n` | `: PTS1 S" Testing" S" Test" SEARCH . . DROP ; PTS1 CR` | stack `empty`, prints `-1 7 \n` | ANS Forth 17.6.1.0935 COMPARE and 17.6.1.2191 SEARCH, as their descriptions have them; v3's case compares S"'s string with HERE taken as a length. In a definition, as ANS 11.6.1.2165 S" keeps one interpreted string only |
| `SEARCH.not_found` | `HERE S" Testing" HERE S" Xyz" SEARCH . . . CR` | stack `427 427`, printed `-1 7 435 \n` | `: PTS2 S" Testing" S" Xyz" SEARCH . . DROP ; PTS2 CR` | stack `empty`, prints `0 7 \n` | ANS Forth 17.6.1.0935 COMPARE and 17.6.1.2191 SEARCH, as their descriptions have them; v3's case compares S"'s string with HERE taken as a length. In a definition, as ANS 11.6.1.2165 S" keeps one interpreted string only |
| `SEARCH.empty_pattern` | `HERE S" Test" HERE 0 SEARCH . . . CR` | stack `439`, printed `-1 4 439 \n` | `: PTS3 S" Test" HERE 4 * 0 SEARCH . . DROP ; PTS3 CR` | stack `empty`, prints `-1 4 \n` | ANS Forth 17.6.1.0935 COMPARE and 17.6.1.2191 SEARCH, as their descriptions have them; v3's case compares S"'s string with HERE taken as a length. In a definition, as ANS 11.6.1.2165 S" keeps one interpreted string only; v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `SEARCH.empty_string` | `HERE 0 HERE S" Test" SEARCH . . . CR` | stack `444`, printed `-1 110 334 \n` | `: PTS4 HERE 4 * 0 S" Test" SEARCH . . DROP ; PTS4 CR` | stack `empty`, prints `0 0 \n` | ANS Forth 17.6.1.0935 COMPARE and 17.6.1.2191 SEARCH, as their descriptions have them; v3's case compares S"'s string with HERE taken as a length. In a definition, as ANS 11.6.1.2165 S" keeps one interpreted string only; v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `SCAN.basic` | `HERE S" Test,Data" BL SCAN TYPE CR` | stack `449`, printed `\n` | `S" Test,Data" BL SCAN TYPE CR` | stack `empty`, prints `\n` | v3's own word, as its table's description has it; v3's case leaves HERE on the stack |
| `SCAN.not_found` | `HERE S" TestData" BL SCAN TYPE CR` | stack `459`, printed `\n` | `S" TestData" BL SCAN TYPE CR` | stack `empty`, prints `\n` | v3's own word, as its table's description has it; v3's case leaves HERE on the stack |
| `SCAN.all_delims` | `HERE S" " BL SCAN TYPE CR` | stack `468`, printed ` \n` | `S" " BL SCAN TYPE CR` | stack `empty`, prints ` \n` | v3's own word, as its table's description has it; v3's case leaves HERE on the stack |
| `SKIP.basic` | `HERE S" Test" BL SKIP TYPE CR` | stack `473`, printed `Test\n` | `S" Test" BL SKIP TYPE CR` | stack `empty`, prints `Test\n` | v3's own word, as its table's description has it; v3's case leaves HERE on the stack |
| `SKIP.no_delims` | `HERE S" Test" BL SKIP TYPE CR` | stack `480`, printed `Test\n` | `S" Test" BL SKIP TYPE CR` | stack `empty`, prints `Test\n` | v3's own word, as its table's description has it; v3's case leaves HERE on the stack |
| `SKIP.all_delims` | `HERE S" " BL SKIP TYPE CR` | stack `485`, printed `\n` | `S" " BL SKIP TYPE CR` | stack `empty`, prints `\n` | v3's own word, as its table's description has it; v3's case leaves HERE on the stack |
| `BL.in_scan` | `HERE S" a b" BL SCAN SWAP DROP . CR` | stack `664`, printed `2 \n` | `S" a b" BL SCAN SWAP DROP . CR` | stack `empty`, prints `2 \n` | v3's own word, as its table's description has it; v3's case leaves HERE on the stack |
| `S".interpret_len` | `S" hello" . CR` | stack `490`, printed `5 \n` | `S" hello" . DROP CR` | stack `empty`, prints `5 \n` | the case leaves an address on the stack (HERE's, or S"'s), a different number on each machine: the case without it |
| `S".empty` | `S" " . CR` | stack `502`, printed `0 \n` | `S" " . DROP CR` | stack `empty`, prints `0 \n` | the case leaves an address on the stack (HERE's, or S"'s), a different number on each machine: the case without it |
| `BASE_OUTPUT.hex` | `16 BASE ! 255 . CR` | stack `empty`, printed `597 \n` | unchanged | stack `empty`, prints `255 \n` | FORTH-79 BASE: numbers are converted in and out in BASE -- after 16 BASE ! the line's 255 is hexadecimal and is printed 255; v3 printed it in decimal |
| `BASE_OUTPUT.octal` | `8 BASE ! 64 . CR` | stack `empty`, printed `52 \n` | unchanged | stack `empty`, prints `64 \n` | FORTH-79 BASE: numbers are converted in and out in BASE -- after 16 BASE ! the line's 255 is hexadecimal and is printed 255; v3 printed it in decimal |
| `BASE_OUTPUT.binary` | `5 2 BASE ! . CR` | stack `empty`, printed `5 \n` | unchanged | stack `empty`, prints `101 \n` | FORTH-79 BASE: numbers are converted in and out in BASE -- after 16 BASE ! the line's 255 is hexadecimal and is printed 255; v3 printed it in decimal (5 is read before BASE changes) |
| `BASE_OUTPUT.base_restore` | `BASE @ DECIMAL 255 16 BASE ! . BASE ! CR` | stack `empty`, printed `255 \n` | unchanged | stack `empty`, prints `FF \n` | FORTH-79 BASE: numbers are converted in and out in BASE -- after 16 BASE ! the line's 255 is hexadecimal and is printed 255; v3 printed it in decimal (255 is read in decimal) |
| `FLUSH.dirty_blocks` | `1 BLOCK UPDATE FLUSH` | stack `5238784`, printed `` | `1 BLOCK DROP UPDATE FLUSH` | stack `empty`, prints nothing | the case leaves an address on the stack (HERE's, or S"'s), a different number on each machine: the case without it (BLOCK's) |
| `THRU.zero_end` | `1 0 THRU` | error | unchanged | stack `empty`, prints nothing | FORTH-83 THRU loads n1 through n2: with n2 below n1 there is none to load, and no error |
| `C,.basic~2` | `65 C, HERE 1 - C@ . CR` | stack `empty`, printed `65 \n` | `ALIGN HERE 4 * 65 C, C@ . CR` | stack `empty`, prints `65 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `C,.zero~2` | `0 C, HERE 1 - C@ . CR` | stack `empty`, printed `0 \n` | `ALIGN HERE 4 * 0 C, C@ . CR` | stack `empty`, prints `0 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `C,.high_byte` | `255 C, HERE 1 - C@ . CR` | stack `empty`, printed `255 \n` | `ALIGN HERE 4 * 255 C, C@ . CR` | stack `empty`, prints `255 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `C,.truncation` | `256 C, HERE 1 - C@ . CR` | stack `empty`, printed `0 \n` | `ALIGN HERE 4 * 256 C, C@ . CR` | stack `empty`, prints `0 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `C,.negative` | `-1 C, HERE 1 - C@ . CR` | stack `empty`, printed `255 \n` | `ALIGN HERE 4 * -1 C, C@ . CR` | stack `empty`, prints `255 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `C,.multiple` | `65 C, 66 C, HERE 2 - C@ . HERE 1 - C@ . CR` | stack `empty`, printed `65 66 \n` | `ALIGN HERE 4 * 65 C, 66 C, DUP C@ . 1+ C@ . CR` | stack `empty`, prints `65 66 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `LATEST.stability` | `LATEST DUP LATEST = . CR` | stack `1032`, printed `-1 \n` | `LATEST DUP LATEST = . DROP CR` | stack `empty`, prints `-1 \n` | the case leaves an address on the stack (HERE's, or S"'s), a different number on each machine: the case without it (LATEST's) |
| `COMPILATION.pad_isolation` | `PAD 999 OVER ! HERE 42 , PAD @ 999 = . CR` | stack `5242368 1112`, printed `-1 \n` | `PAD 4 / 999 OVER ! HERE 42 , PAD 4 / @ 999 = . DROP DROP CR` | stack `empty`, prints `-1 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's (PAD is a byte address, ! takes a cell's); the case leaves an address on the stack (HERE's, or S"'s), a different number on each machine: the case without it |
| `LATEST.basic~2` | `LATEST @ . CR` | stack `empty`, printed `0 \n` | `LATEST 0<> . CR` | stack `empty`, prints `-1 \n` | v3's own word: v3 prints a value of its own machine (its DictEntry); the case as its description has it |
| `LATEST.after_def` | `: test7 46 ; LATEST @ . CR` | stack `empty`, printed `0 \n` | `: test7 46 ; LATEST ' test7 = . CR` | stack `empty`, prints `-1 \n` | v3's own word: v3 prints a value of its own machine (its DictEntry); the case as its description has it |
| `LATEST.after_forget` | `CREATE test8 FORGET test8 LATEST @ . CR` | stack `empty`, printed `0 \n` | `LATEST CREATE test8 FORGET test8 LATEST = . CR` | stack `empty`, prints `-1 \n` | v3's own word: v3 prints a value of its own machine (its DictEntry); the case as its description has it |
| `>BODY.basic` | `CREATE test9 ' test9 >BODY . CR` | stack `empty`, printed `8207624 \n` | `CREATE test9 FIND test9 >BODY ' test9 = . CR` | stack `empty`, prints `-1 \n` | FORTH-83 >BODY takes a compilation address -- FORTH-79's FIND gives one; FORTH-79's ' gives the parameter field already, so v3's ' xxx >BODY goes one too far. v3 prints an address: the case shows >BODY's field is ''s (and VARIABLE's) |
| `>BODY.variable` | `VARIABLE var1 ' var1 >BODY . CR` | stack `empty`, printed `8208136 \n` | `VARIABLE var1 FIND var1 >BODY var1 = . CR` | stack `empty`, prints `-1 \n` | FORTH-83 >BODY takes a compilation address -- FORTH-79's FIND gives one; FORTH-79's ' gives the parameter field already, so v3's ' xxx >BODY goes one too far. v3 prints an address: the case shows >BODY's field is ''s (and VARIABLE's) |
| `ORDER.basic` | `ORDER` | stack `empty`, printed `Search order: (FIND)\nCurrent: (FIND)\n` | unchanged | stack `empty`, prints `Search order: FORTH \nCurrent: FORTH\n` | ANS Forth 16.6.2.1985 ORDER: the form is the system's; v3 names FORTH '(FIND)' -- v4's form with v4's names |
| `ORDER.multiple` | `VOCABULARY TEST-VOC9 TEST-VOC9 DEFINITIONS ORDER` | stack `empty`, printed `Search order: TEST-VOC9 (FIND)\nCurrent:` | unchanged | stack `empty`, prints `Search order: TEST-VOC9 FORTH\nCurrent: TEST-VOC9\n` | ANS Forth 16.6.2.1985 ORDER: the form is the system's; v3 names FORTH '(FIND)' -- v4's form with v4's names |
| `ORDER.after_forth` | `TEST-VOC9 FORTH ORDER` | stack `empty`, printed `Search order: (FIND)\nCurrent: (FIND)\n` | unchanged | stack `empty`, prints `Search order: FORTH \nCurrent: FORTH\n` | ANS Forth 16.6.2.1985 ORDER: the form is the system's; v3 names FORTH '(FIND)' -- v4's form with v4's names |
| `FREEZE-WORD.basic` | `: __freeze_test_word__ ; S" __freeze_test_word__" FREEZE-WORD S" __freeze_test_word__" FROZEN? . CR` | stack `empty`, printed `7093 \n` | unchanged | stack `empty`, prints `-1 \n` | v3 prints a number its table's description does not ask for; the description's value |
| `UNFREEZE-WORD.basic` | `: __unfreeze_test_word__ ; S" __unfreeze_test_word__" FREEZE-WORD S" __unfreeze_test_word__" UNFREEZE-WORD S" __unfreeze_test_word__" FROZEN? . CR` | stack `empty`, printed `7174 \n` | unchanged | stack `empty`, prints `0 \n` | v3 prints a number its table's description does not ask for; the description's value |
| `FROZEN?.not_frozen` | `: __frozen_test_word__ ; S" __frozen_test_word__" FROZEN? . CR` | stack `empty`, printed `7208 \n` | unchanged | stack `empty`, prints `0 \n` | v3 prints a number its table's description does not ask for; the description's value |
| `FROZEN?.not_found` | `S" __nonexistent_freeze_xyz__" FROZEN? . CR` | stack `empty`, printed `7229 \n` | unchanged | stack `empty`, prints `0 \n` | v3 prints a number its table's description does not ask for; the description's value |
| `HEAT!.basic` | `: __heat_store_test_word__ ; 999 S" __heat_store_test_word__" HEAT! S" __heat_store_test_word__" HEAT@ . CR` | stack `empty`, printed `7289 \n` | unchanged | stack `empty`, prints `999 \n` | v3 prints a number its table's description does not ask for; the description's value |
| `HEAT@.of_fresh_word` | `: __heat_fetch_test_word__ ; S" __heat_fetch_test_word__" HEAT@ . CR` | stack `empty`, printed `7328 \n` | unchanged | stack `empty`, prints `0 \n` | v3 prints a number its table's description does not ask for; the description's value |
| `DECAY-RATE@.basic` | `DECAY-RATE@ . CR` | stack `empty`, printed `0 \n` | unchanged | stack `empty`, prints `1 \n` | v3's own word: the build's DECAY_RATE_PER_US_Q16, 1 by default (v3/Makefile, Kconfig.physics); the v3 that made the table was built with 0 |
| `Q.VARIANCE.three_cells` | `100 HERE ! 200 HERE 8 + ! 300 HERE 16 + ! HERE 3 Q.VARIANCE Q.TO-INT . CR` | stack `empty`, printed `6666 \n` | `100 HERE ! 200 HERE 1 + ! 300 HERE 2 + ! HERE 3 Q.VARIANCE Q.TO-INT . CR` | stack `empty`, prints `6666 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `INFER-DECAY-SLOPE.three_cells` | `300 HERE ! 200 HERE 8 + ! 100 HERE 16 + ! HERE 3 INFER-DECAY-SLOPE Q.TO-INT . CR` | stack `empty`, printed `0 \n` | `300 HERE ! 200 HERE 1 + ! 100 HERE 2 + ! HERE 3 INFER-DECAY-SLOPE Q.TO-INT . CR` | stack `empty`, prints `0 \n` | v3's address unit is a byte in 8-byte cells; v4's is a cell (D-1): the case in v4's units, a byte address 4 * a cell's |
| `INFER-VARIANCE@.after_run` | `INFER-RUN INFER-VARIANCE@ Q.TO-INT . CR` | stack `empty`, printed `39 \n` | `INFER-RUN INFER-VARIANCE@ Q.TO-INT DROP CR` | stack `empty`, prints `\n` | the value comes of the run's own history, the same on no two runs or machines: the case as its description has it ('no error') |
| `INFER-WINDOW@.after_run` | `INFER-RUN INFER-WINDOW@ . CR` | stack `empty`, printed `0 \n` | `INFER-RUN INFER-WINDOW@ DROP CR` | stack `empty`, prints `\n` | the value comes of the run's own history, the same on no two runs or machines: the case as its description has it ('no error') |
| `INFER-EARLY-EXIT@.after_run` | `INFER-RUN INFER-EARLY-EXIT@ . CR` | stack `empty`, printed `0 \n` | `INFER-RUN INFER-EARLY-EXIT@ DUP 0= SWAP 1 = OR . CR` | stack `empty`, prints `-1 \n` | the value comes of the run's own history, the same on no two runs or machines: the case as its description has it ('no error') (0 or 1) |
| `Q.1.raw_value` | `Q.1 . CR` | stack `empty`, printed `65536 \n` | `Q.1 D. CR` | stack `empty`, prints `65536 \n` | Q48.16 on v4 is a double, low cell then high (ruled 2026-11-14): its raw value printed with D. |
| `Q.0.raw_value` | `Q.0 . CR` | stack `empty`, printed `0 \n` | `Q.0 D. CR` | stack `empty`, prints `0 \n` | Q48.16 on v4 is a double, low cell then high (ruled 2026-11-14): its raw value printed with D. |
| `Q.SCALE.raw_value` | `Q.SCALE . CR` | stack `empty`, printed `65536 \n` | `Q.SCALE D. CR` | stack `empty`, prints `65536 \n` | Q48.16 on v4 is a double, low cell then high (ruled 2026-11-14): its raw value printed with D. |
| `RETURN_STACK.basic_to_r` | `1 2 3 >R >R >R R> R> R> + + . CR` | stack `empty`, printed `6 \n` | `: PTRS1 1 2 3 >R >R >R R> R> R> + + . ; PTRS1 CR` | stack `empty`, prints `6 \n` | ANS Forth 6.1.0580 >R: 'Interpretation semantics for this word are undefined' -- the case run inside a definition |
| `RETURN_STACK.r_fetch` | `42 >R R@ . CR R> DROP` | stack `empty`, printed `42 \n` | `: PTRS2 42 >R R@ . R> DROP ; PTRS2 CR` | stack `empty`, prints `42 \n` | ANS Forth 6.1.0580 >R: 'Interpretation semantics for this word are undefined' -- the case run inside a definition |
| `WORD-ENTROPY.display_all` | `1 DUP DUP DUP DROP DROP DROP DROP WORD-ENTROPY` | stack `empty`, printed `Word Usage Statistics (Execution Heat Co` | unchanged | 0 value(s) left; prints, to begin with, `Word Usage Statistics (Execution Heat Counts):\n=============================================\n` | v3's own word, its output v3's own words and counts: the form kept, v4's values (ruled 2026-11-14) -- they come of the run's history, so the printout's head is compared |
| `WORD-ENTROPY.after_execution` | `: WDENT 1 2 + DROP ; WDENT WDENT WORD-ENTROPY` | stack `empty`, printed `Word Usage Statistics (Execution Heat Co` | unchanged | 0 value(s) left; prints, to begin with, `Word Usage Statistics (Execution Heat Counts):\n=============================================\n` | v3's own word, its output v3's own words and counts: the form kept, v4's values (ruled 2026-11-14) -- they come of the run's history, so the printout's head is compared |
| `WORD-ENTROPY.stack_preserved` | `DEPTH WORD-ENTROPY DEPTH = . CR` | stack `empty`, printed `Word Usage Statistics (Execution Heat Co` | unchanged | 0 value(s) left; prints, to begin with, `Word Usage Statistics (Execution Heat Counts):\n=============================================\n` | v3's own word, its output v3's own words and counts: the form kept, v4's values (ruled 2026-11-14) -- they come of the run's history, so the printout's head is compared |
| `TOP-WORDS.display_top5` | `: TOPTEST 1 DROP ; TOPTEST TOPTEST TOPTEST TOPTEST TOPTEST 5 TOP-WORDS` | stack `empty`, printed `Top 5 most frequently used words:\n=====` | unchanged | 0 value(s) left; prints, to begin with, `Top 5 most frequently used words:\n==================================\n` | v3's own word, its output v3's own words and counts: the form kept, v4's values (ruled 2026-11-14) -- they come of the run's history, so the printout's head is compared |
| `TOP-WORDS.display_top10` | `10 TOP-WORDS` | stack `empty`, printed `Top 10 most frequently used words:\n====` | unchanged | 0 value(s) left; prints, to begin with, `Top 10 most frequently used words:\n==================================\n` | v3's own word, its output v3's own words and counts: the form kept, v4's values (ruled 2026-11-14) -- they come of the run's history, so the printout's head is compared |
| `TOP-WORDS.after_reset` | `RESET-ENTROPY 5 TOP-WORDS` | stack `empty`, printed `Top 5 most frequently used words:\n=====` | unchanged | 0 value(s) left; prints, to begin with, `Top 5 most frequently used words:\n==================================\n` | v3's own word, its output v3's own words and counts: the form kept, v4's values (ruled 2026-11-14) -- they come of the run's history, so the printout's head is compared |
| `TOP-WORDS.single_word` | `1 TOP-WORDS` | stack `empty`, printed `Top 1 most frequently used words:\n=====` | unchanged | 0 value(s) left; prints, to begin with, `Top 1 most frequently used words:\n==================================\n` | v3's own word, its output v3's own words and counts: the form kept, v4's values (ruled 2026-11-14) -- they come of the run's history, so the printout's head is compared |
| `TOP-WORDS.large_count` | `100 TOP-WORDS` | stack `empty`, printed `Top 100 most frequently used words:\n===` | unchanged | 0 value(s) left; prints, to begin with, `Top 100 most frequently used words:\n==================================\n` | v3's own word, its output v3's own words and counts: the form kept, v4's values (ruled 2026-11-14) -- they come of the run's history, so the printout's head is compared |
| `DATA_STRUCTURES.stack_min_max` | `: INIT-MINMAX 2147483647 VARIABLE MIN -2147483648 VARIABLE MAX ; : UPDATE-MINMAX ( n -- ) DUP MIN @ < IF DUP MIN ! ELSE DROP THEN DUP MAX @ > IF DUP MAX ! ELSE DROP THEN ; INIT-MINMAX 42 UPDATE-MINMAX 17 UPDATE-MINMAX 99 UPDATE-MINMAX MIN @ . MAX @ . CR` | error | `VARIABLE TMIN 2147483647 TMIN ! VARIABLE TMAX -2147483648 TMAX ! : UPDATE-MINMAX ( n -- ) DUP TMIN @ < IF DUP TMIN ! ELSE DROP THEN DUP TMAX @ > IF DUP TMAX ! ELSE DROP THEN ; 42 UPDATE-MINMAX 17 UPDATE-MINMAX 99 UPDATE-MINMAX TMIN @ . TMAX @ . CR` | stack `empty`, prints `17 42 \n` | FORTH-79 VARIABLE is a defining word: run inside INIT-MINMAX it takes its name from the input then -- '42', then 'UPDATE-MINMAX' -- and a word named 42 hides the number from every case after it (42 U. printed an address). v3's table says the case runs (TEST_NORMAL, 'Min/Max tracker'): written as meant, the variables made outside, named so as not to hide MIN and MAX -- and run as FORTH runs it: UPDATE-MINMAX's ELSE DROP drops n when it is no new minimum, so 99 never reaches the maximum's test, which takes the 42 the first call left |
| `CREATE.long_name` | `CREATE abcdefghijklmnopqrstuvwxyz` | stack `empty`, printed `` | unchanged | stack `empty`, prints nothing | FORTH-79: a name is up to 31 characters -- 26 is no error; v3's table expects one, v3 raised none (the standard first) |
| `DICT_PRESSURE.many_defs` | `: T1 1 ; : T2 2 ; : T3 3 ; : T4 4 ; : T5 5 ; : T6 6 ; : T7 7 ; : T8 8 ; : T9 9 ; : T10 10 ; : T11 11 ; : T12 12 ; : T13 13 ; : T14 14 ; : T15 15 ; : T16 16 ; : T17 17 ; : T18 18 ; : T19 19 ; : T20 20 ; T20 . CR` | stack `empty`, printed `20 \n` | unchanged | stack `empty`, prints `20 \n` | v3's table says the case runs (TEST_NORMAL); v3 raised an error it does not say |
| `COMPLETE_PROGRAMS.array_sum` | `: ARRAY 5 CELLS ALLOT ; ARRAY NUMS : STORE-NUMS 10 NUMS 0 CELLS + ! 20 NUMS 1 CELLS + ! 30 NUMS 2 CELLS + ! 40 NUMS 3 CELLS + ! 50 NUMS 4 CELLS + ! ; : SUM-NUMS 0 5 0 DO NUMS I CELLS + @ + LOOP ; STORE-NUMS SUM-NUMS . CR` | error | `CREATE NUMS 5 CELLS ALLOT : STORE-NUMS 10 NUMS 0 CELLS + ! 20 NUMS 1 CELLS + ! 30 NUMS 2 CELLS + ! 40 NUMS 3 CELLS + ! 50 NUMS 4 CELLS + ! ; : SUM-NUMS 0 5 0 DO NUMS I CELLS + @ + LOOP ; STORE-NUMS SUM-NUMS . CR` | stack `empty`, prints `150 \n` | v3's table says the case runs (TEST_NORMAL, 'Array sum program'), but as written ': ARRAY 5 CELLS ALLOT ;' names nothing and 'ARRAY NUMS' is an unknown word in any FORTH: written as meant, NUMS made by CREATE |
| `M+.basic` | `0 100 200 M+ . . CR` | stack `empty`, printed `300 0 \n` | unchanged | stack `empty`, prints `100 200 \n` | ANS Forth 8.6.1.1830 M+ ( d1 n -- d2 ); v3's results, and its descriptions, are not |
| `M+.overflow` | `0 2147483647 1 M+ . . CR` | stack `empty`, printed `2147483648 0 \n` | unchanged | stack `empty`, prints `2147483647 1 \n` | ANS Forth 8.6.1.1830 M+ ( d1 n -- d2 ); v3's results, and its descriptions, are not |
| `M+.negative` | `0 -100 50 M+ . . CR` | stack `empty`, printed `-50 0 \n` | unchanged | stack `empty`, prints `-100 50 \n` | ANS Forth 8.6.1.1830 M+ ( d1 n -- d2 ); v3's results, and its descriptions, are not |
| `M+.both_negative` | `0 -100 -200 M+ . . CR` | stack `empty`, printed `-300 0 \n` | unchanged | stack `empty`, prints `-101 -200 \n` | ANS Forth 8.6.1.1830 M+ ( d1 n -- d2 ); v3's results, and its descriptions, are not |
| `M/MOD.basic` | `0 1000 100 M/MOD . . CR` | stack `empty`, printed `10 0 \n` | `1000 0 100 M/MOD . . CR` | stack `empty`, prints `10 0 \n` | FORTH-79: a double on the stack has its high cell on top; the case's double was written low-cell-last (1000 / 100) |
| `M/MOD.with_remainder` | `0 1234 100 M/MOD . . CR` | stack `empty`, printed `12 34 \n` | `1234 0 100 M/MOD . . CR` | stack `empty`, prints `12 34 \n` | FORTH-79: a double on the stack has its high cell on top; the case's double was written low-cell-last (1234 / 100) |
| `M/MOD.double_dividend` | `5001 0 10 M/MOD . . CR` | stack `empty`, printed `1844674407370955161 6 \n` | unchanged | stack `empty`, prints `500 1 \n` | its description: 5001 / 10 is 500 remainder 1; v3 prints otherwise |
| `M/MOD.by_one` | `0 42 1 M/MOD . . CR` | stack `empty`, printed `42 0 \n` | `42 0 1 M/MOD . . CR` | stack `empty`, prints `42 0 \n` | FORTH-79: a double on the stack has its high cell on top; the case's double was written low-cell-last (42 / 1) |
| `M/MOD.negative_dividend` | `-1 1000 100 M/MOD . . CR` | stack `empty`, printed `-184467440737095506 -16 \n` | `-1000 -1 100 M/MOD . . CR` | stack `empty`, prints `-10 0 \n` | FORTH-79: a double on the stack has its high cell on top; the case's double was written low-cell-last (-1000 / 100) |
| `2>R.roundtrip` | `10 20 2>R 2R> . . CR` | stack `empty`, printed `20 10 \n` | `: PT2R1 10 20 2>R 2R> . . ; PT2R1 CR` | stack `empty`, prints `20 10 \n` | ANS Forth 6.2.0340 2>R: 'Interpretation semantics for this word are undefined' -- the case run inside a definition |
| `2>R.depth_after` | `1 2 2>R DEPTH . 2R> DROP DROP CR` | stack `empty`, printed `0 \n` | `: PT2R2 1 2 2>R DEPTH . 2R> DROP DROP ; PT2R2 CR` | stack `empty`, prints `0 \n` | ANS Forth 6.2.0340 2>R: 'Interpretation semantics for this word are undefined' -- the case run inside a definition |
| `2R>.roundtrip` | `5 6 2>R 2R> . . CR` | stack `empty`, printed `6 5 \n` | `: PT2R3 5 6 2>R 2R> . . ; PT2R3 CR` | stack `empty`, prints `6 5 \n` | ANS Forth 6.2.0340 2>R: 'Interpretation semantics for this word are undefined' -- the case run inside a definition |
| `2R>.depth` | `9 8 2>R 2R> DEPTH . CR` | stack `9 8`, printed `2 \n` | `: PT2R4 9 8 2>R 2R> DEPTH . ; PT2R4 CR` | stack `9 8`, prints `2 \n` | ANS Forth 6.2.0340 2>R: 'Interpretation semantics for this word are undefined' -- the case run inside a definition |
| `2R@.peek` | `3 4 2>R 2R@ . . 2R> DROP DROP CR` | stack `empty`, printed `4 3 \n` | `: PT2R5 3 4 2>R 2R@ . . 2R> DROP DROP ; PT2R5 CR` | stack `empty`, prints `4 3 \n` | ANS Forth 6.2.0340 2>R: 'Interpretation semantics for this word are undefined' -- the case run inside a definition |
| `2R@.non_destructive` | `7 8 2>R 2R@ DROP DROP 2R> . . CR` | stack `empty`, printed `8 7 \n` | `: PT2R6 7 8 2>R 2R@ DROP DROP 2R> . . ; PT2R6 CR` | stack `empty`, prints `8 7 \n` | ANS Forth 6.2.0340 2>R: 'Interpretation semantics for this word are undefined' -- the case run inside a definition |
## 2. Address-dependent (20)
The case leaves or prints a memory address, which is a different number on
the two machines. The number of values left is checked, and what is
printed unless an address is printed; the values are not.
| Case | Line | Checked |
|---|---|---|
| `-TRAILING.basic` | `HERE S" Test " -TRAILING TYPE CR` | values left, and output |
| `-TRAILING.all_spaces` | `HERE S" " -TRAILING TYPE CR` | values left, and output |
| `-TRAILING.no_spaces` | `HERE S" Test" -TRAILING TYPE CR` | values left, and output |
| `HERE.stability` | `HERE DUP HERE = . CR` | values left, and output |
| `PAD.stability` | `PAD DUP PAD = . CR` | values left, and output |
| `UPDATE.basic` | `1 BLOCK UPDATE` | values left, and output |
| `UPDATE.multiple` | `1 BLOCK UPDATE UPDATE` | values left, and output |
| `SAVE-BUFFERS.dirty_blocks` | `1 BLOCK UPDATE SAVE-BUFFERS` | values left, and output |
| `EMPTY-BUFFERS.after_use` | `1 BLOCK EMPTY-BUFFERS` | values left, and output |
| `EMPTY-BUFFERS.dirty_blocks` | `1 BLOCK UPDATE EMPTY-BUFFERS` | values left, and output |
| `BUFFER.flush_dirty` | `2 BLOCK 1+ 2 BUFFER` | values left, and output |
| `BLOCK.basic` | `1 BLOCK DUP . CR` | values left only |
| `BUFFER.basic` | `1 BUFFER DUP . CR` | values left only |
| `VOCABULARY.create_and_switch` | `VOCABULARY MYVOC MYVOC DEFINITIONS CONTEXT @ . CR` | values left only |
| `CONTEXT.basic` | `CONTEXT @ . CR` | values left only |
| `CONTEXT.initial` | `FORTH CONTEXT @ . CR` | values left only |
| `CURRENT.basic` | `CURRENT @ . CR` | values left only |
| `CURRENT.after_def` | `VOCABULARY TEST-VOC8 TEST-VOC8 DEFINITIONS CURRENT @ . CR` | values left only |
| `LIST.basic` | `1 LIST` | values left only |
| `SCR.after_list` | `1 LIST SCR @ . CR` | values left only |
## 3. Written by hand (28)
For required words v3 has no case for. The expected results are the
standard's; no v3 run stands behind them.
| Case | Line | Must do |
|---|---|---|
| `U*.small` | `3 4 U* . . CR` | stack `empty`, prints `0 12 \n` |
| `U*.zero` | `0 5 U* . . CR` | stack `empty`, prints `0 0 \n` |
| `U*.full` | `-1 -1 U* 2+ . 1 = . CR` | stack `empty`, prints `0 -1 \n` |
| `U/MOD.small` | `7 0 2 U/MOD . . CR` | stack `empty`, prints `3 1 \n` |
| `U/MOD.exact` | `12 0 4 U/MOD . . CR` | stack `empty`, prints `3 0 \n` |
| `U/MOD.double` | `0 1 2 U/MOD 2* . . CR` | stack `empty`, prints `0 0 \n` |
| `U/MOD.inverse` | `-1 -1 U* -1 U/MOD 1+ . . CR` | stack `empty`, prints `0 0 \n` |
| `U/MOD.carry` | `-1 -2 -1 U/MOD 1+ . 2+ . CR` | stack `empty`, prints `0 0 \n` |
| `U/MOD.by_zero` | `1 0 0 U/MOD` | an error |
| `?.basic` | `VARIABLE Q1 42 Q1 ! Q1 ? CR` | stack `empty`, prints `42 \n` |
| `EXECUTE.found` | `: E1 7 ; FIND E1 EXECUTE . CR` | stack `empty`, prints `7 \n` |
| `U..small` | `42 U. CR` | stack `empty`, prints `42 \n` |
| `U..unsigned` | `-1 U. CR` | stack `empty`, prints `18446744073709551615 \n` |
| `CONVERT.digits` | `: C1 0 0 BL WORD CONVERT DROP ; C1 123 . . CR` | stack `empty`, prints `0 123 \n` |
| `'.found` | `' DUP 0= . CR` | stack `empty`, prints `0 \n` |
| `.".in_definition` | `: Q3 ." hi there" ; Q3 CR` | stack `empty`, prints `hi there\n` |
| `LITERAL.basic` | `: Q4 [ 5 ] LITERAL ; Q4 . CR` | stack `empty`, prints `5 \n` |
| `STATE.interpreting` | `STATE @ . CR` | stack `empty`, prints `0 \n` |
| `STATE.compiling` | `: Q5 STATE @ 0= . ; IMMEDIATE : Q6 Q5 ; CR` | stack `empty`, prints `0 \n` |
| `COMPILE.basic` | `: Q7 COMPILE DUP ; IMMEDIATE : Q8 Q7 ; 3 Q8 . . CR` | stack `empty`, prints `3 3 \n` |
| `[COMPILE].basic` | `: Q9 [COMPILE] IF ; IMMEDIATE : Q10 Q9 1 ELSE 2 THEN ; 0 Q10 . -1 Q10 . CR` | stack `empty`, prints `2 1 \n` |
| `(.comment` | `1 ( 2 ) 3 . . CR` | stack `empty`, prints `3 1 \n` |
| `BLK.terminal` | `BLK @ . CR` | stack `empty`, prints `0 \n` |
| `79-STANDARD.present` | `79-STANDARD` | stack `empty`, prints nothing |
| `WORD.next_word` | `: W1 BL WORD COUNT TYPE ; W1 HELLO` | stack `empty`, prints `HELLO` |
| `WORD.delimiter` | `: W2 44 WORD COUNT TYPE ; W2 A B,` | stack `empty`, prints `A B` |
| `WORD.count` | `: W3 BL WORD C@ . ; W3 ABC` | stack `empty`, prints `3 ` |
| `WORD.skips_leading` | `: W4 BL WORD COUNT TYPE ; W4 X` | stack `empty`, prints `X` |
## 4. v3 cases left out (52)
| Case | Why |
|---|---|
| `EXPECT.zero_length` | reads the keyboard |
| `EXPECT.one_item` | reads the keyboard |
| `EXPECT.empty_stack` | reads the keyboard |
| `FORGET.nonexistent` | forgets a word of the system |
| `FORGET.protected` | forgets a word of the system |
| `CONTEXT.modify` | damages the system on purpose |
| `CURRENT.protect` | damages the system on purpose |
| `QUIT.in_definition` | v3 did not get through it in one session |
| `:.nested` | v3 did not get through it in one session |
| `].basic` | v3 did not get through it in one session |
| `['].not_found` | v3 did not get through it in one session |
| `ELSE.double` | v3 did not get through it in one session |
| `THEN.extra` | v3 did not get through it in one session |
| `DATA_STRUCTURES.linked_list` | v3 did not get through it in one session |
| `ALGORITHMS.gcd` | v3 did not get through it in one session |
| `C!.basic` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `C!.zero` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `C!.high_byte` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `C!.truncation` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `C@.after_cstore` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `C@.zero_byte` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `FILL.basic` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `FILL.zero_byte` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `DABS.one_item` | ANS Forth 8.6.1.1160 DABS / 8.6.1.1220 DMIN: given too few values, stack underflow is an ambiguous condition (ANS 4.1.2); no standard asks for an error. |
| `DMIN.three_items` | ANS Forth 8.6.1.1160 DABS / 8.6.1.1220 DMIN: given too few values, stack underflow is an ambiguous condition (ANS 4.1.2); no standard asks for an error. |
| `COUNT.string_bounds` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `CMOVE.overlap` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `CMOVE.bounds` | moves 1000 bytes over the system; v3 refuses by a bounds rule FORTH-79 has not got |
| `CMOVE>.bounds` | ANS Forth 17.6.1.0920 CMOVE> raises no error for a count past a buffer; 1000 bytes at PAD (84 bytes or more) is in v4's memory and writes over what the system keeps above PAD. v3's error is v3's own bounds check, which no standard asks for; there is nothing to expect. |
| `TYPE.single_char` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `COUNT.zero_addr_plus_one` | OPEN: HERE is a cell address on v4 and this word takes a byte address (D-1): the case wrote to or read from the nucleus's code at cell HERE/4 |
| `WORD.empty_input` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.space_delim` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.newline_delim` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.tab_delim` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.comma_delim` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.skip_leading` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.single_char` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.long_word` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.zero_delim` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.high_ascii` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.count_format` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.count_value` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `WORD.multi_delim` | v3's WORD does not take the next word from the input, as FORTH-79's does; see the WORD cases written by hand |
| `THRU.negative_end` | FORTH-83 THRU takes block numbers, unsigned: -3 is not one (ANS 15.6.2.2280: an ambiguous condition); v3's error is its own, which no standard asks for. |
| `PAD.usable` | OPEN: PAD 42 OVER ! faults on v4 -- PAD is a byte address and ! takes a cell address (D-1) |
| `SP@.depth_effect` | SP@ and SP! are no standard's; no stack pointer is visible to code (DECOMPOSITION.md D-2), ruled to stand (Captain Bob, 2026-11-14: "D-2 for SP@"). |
| `SP@.empty_stack` | SP@ and SP! are no standard's; no stack pointer is visible to code (DECOMPOSITION.md D-2), ruled to stand (Captain Bob, 2026-11-14: "D-2 for SP@"). |
| `SP@.multiple_items` | SP@ and SP! are no standard's; no stack pointer is visible to code (DECOMPOSITION.md D-2), ruled to stand (Captain Bob, 2026-11-14: "D-2 for SP@"). |
| `SP!.basic_restore` | SP@ and SP! are no standard's; no stack pointer is visible to code (DECOMPOSITION.md D-2), ruled to stand (Captain Bob, 2026-11-14: "D-2 for SP@"). |
| `STACK_MGMT.sp_round_trip` | SP@ and SP! are no standard's; no stack pointer is visible to code (DECOMPOSITION.md D-2), ruled to stand (Captain Bob, 2026-11-14: "D-2 for SP@"). |
| `STACK_MGMT.depth_preservation` | SP@ and SP! are no standard's; no stack pointer is visible to code (DECOMPOSITION.md D-2), ruled to stand (Captain Bob, 2026-11-14: "D-2 for SP@"). |
## 5. Required words POST does not test
`KEY` `EXPECT` `QUERY` `QUIT`.
`KEY`, `EXPECT` and `QUERY` wait for the keyboard, which a boot cannot type
at. `QUIT` returns to the terminal without `ok`.
## 6. Where v3 did not do what its own table expects (14)
POST expects what v3 did, unless section 1 says otherwise.
| Case | |
|---|---|
| `+!.basic` | v3's table says no error, v3 raised one |
| `+!.by_zero` | v3's table says no error, v3 raised one |
| `+!.negative` | v3's table says no error, v3 raised one |
| `+!.accumulate` | v3's table says no error, v3 raised one |
| `-!.basic` | v3's table says no error, v3 raised one |
| `-!.by_zero` | v3's table says no error, v3 raised one |
| `-!.negative` | v3's table says no error, v3 raised one |
| `2!.basic` | v3's table says no error, v3 raised one |
| `2!.zeros` | v3's table says no error, v3 raised one |
| `2!.negative` | v3's table says no error, v3 raised one |
| `HERE.after_comma~2` | v3's table says no error, v3 raised one |
| `CREATE.long_name` | v3's table says error, v3 raised none |
| `COMPLETE_PROGRAMS.array_sum` | v3's table says no error, v3 raised one |
| `DATA_STRUCTURES.stack_min_max` | v3's table says no error, v3 raised one |