Files
LithosAnanke/docs/v4.0.0/POST.md
T
Claude 37469f6c54 feat(v4): v3's whole POST is v4's POST -- 990 cases, all passed on Hera (#189)
Phase 7, Task 8: PARITY:V4_POST tests=990 pass=990 fail=0 on Hera (mesh-boot); the hosted
product 945 of them, all passed -- the 45 cases of physics.4th's words need the kernel.

- Enlarged, as ruled ("Enlarge v4 to fit"): a node is 32768 words, its data stack 1024
  deep (v3's), host and kernel alike; the dictionary's end moves with them.
- POST's runner compares every value a case leaves (v3's leave 101); V4_POST_KERNEL marks
  a case of the kernel's words, and a host without a kernel does not run it.
- mkpost.py --all is POST's table (make -C v4 post79), with docs/v4.0.0/POST.md; it reads a
  module's #defines (v3's Mama cases are MAMA_IMPLEMENTED, 0: v3's own POST skips all 20);
  it cuts no line between a word and the name it takes.
- Rules for the last of the table: the min/max and array-sum programs written as meant,
  CREATE's 26-character name (FORTH-79: 31), many_defs.
- POST_FLOOR 990.
- Tests sized for a 32-deep stack and a 16384-word node made deep-stack-ready
  (test_host_depth, test_host_quit, test_host_node, hosted-check, depthsweep.py).

make -C v4 test: all v4 tests passed. make -C kernel/tests test: all passed.
depthsweep at 1024: 230 runs, 0 failures. v4-checks running.

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

57 KiB

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 0 \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 1 \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