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
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 |