rajamesandClaude Opus 5.5
dac7ffac92
The fourth layer of the compiler capsule. compile.v4: INTERPRET's loop, STATE [ ] : ; EXIT IMMEDIATE LITERAL COMPILE [COMPILE] ' EXECUTE, CREATE VARIABLE CONSTANT DOES>, and IF ELSE THEN BEGIN UNTIL AGAIN WHILE REPEAT DO ?DO LOOP +LOOP on a control-flow stack in memory. forth.v4: the first words of the vocabulary, the in-line ones. FORTH source now goes in and running code comes out. 49 programmes were run through the v3 binary and through this; every result agrees, bar COMPILE, which v3 cannot run. The code laid down for each control structure is word for word the expansion DECOMPOSITION.md gives. A line may have six values on the stack while it is interpreted, and words called from the interpreter may nest eight deep. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
73 lines
3.1 KiB
Plaintext
73 lines
3.1 KiB
Plaintext
\ forth.v4 -- the first words of the FORTH vocabulary: the ones that are
|
|
\ opcodes or short runs of them, and the variables that are in-line addresses.
|
|
\
|
|
\ Each is the definition DECOMPOSITION.md gives (sections 4, 5.1 - 5.5, 5.18).
|
|
\ A word flagged inline is copied into a definition in place of a call; the
|
|
\ ones that touch the return stack are compile-only as well. Rests on core.v4
|
|
\ and compile.v4's loader constants.
|
|
|
|
\ ---- stack ----
|
|
header DUP inline : DUP dup ;
|
|
header DROP inline : DROP drop ;
|
|
header OVER inline : OVER over ;
|
|
header SWAP inline : SWAP' SWAP ;
|
|
header ROT inline : ROT' ROT ;
|
|
header -ROT inline : -ROT SWAP push SWAP pop ;
|
|
header ?DUP : ?DUP if Z dup ; Z: ;
|
|
header 2DUP inline : 2DUP over over ;
|
|
header 2DROP inline : 2DROP drop drop ;
|
|
|
|
\ ---- return stack: in line, and only inside a definition ----
|
|
header >R inline compile-only : >R push ;
|
|
header R> inline compile-only : R> pop ;
|
|
header R@ inline compile-only : R@ pop dup push ;
|
|
header I inline compile-only : I pop dup push ;
|
|
header J inline compile-only : J pop pop pop dup push a! push push a ;
|
|
header LEAVE inline compile-only : LEAVE pop pop drop dup push push ;
|
|
header UNLOOP inline compile-only : UNLOOP pop drop pop drop ;
|
|
|
|
\ ---- memory ----
|
|
header @ inline : FETCH a! @ ;
|
|
header ! inline : STORE a! ! ;
|
|
header +! inline : +! a! @ + ! ;
|
|
header CELLS inline : CELLS ; \ an address unit is a cell (D-1)
|
|
|
|
\ ---- arithmetic ----
|
|
header + inline : PLUS + ;
|
|
header - inline : MINUS - ;
|
|
\ The low cell of the product, by N steps of +* with nothing but the count on
|
|
\ the return stack. UM* drop gives the same cell but needs two more return
|
|
\ entries, which a word inside two DO loops does not have (D-2). The low
|
|
\ cell is exact: what +* loses at the top of T (D-3) takes N shifts to reach
|
|
\ the bit that moves into A, and the loop ends first.
|
|
header * : STAR a! 0 N-1 FOR +* UNEXT drop drop a ;
|
|
header NEGATE inline : NEGATE' NEGATE ;
|
|
header 1+ inline : 1+ 1 + ;
|
|
header 1- inline : 1- -1 + ;
|
|
header 2+ inline : 2+ 2 + ;
|
|
header 2- inline : 2- -2 + ;
|
|
header 2* inline : TWO* 2* ;
|
|
header 2/ inline : TWO/ 2/ ;
|
|
|
|
\ ---- logic and comparison ----
|
|
header AND inline : AND and ;
|
|
header XOR inline : XOR xor ;
|
|
header OR inline : OR' OR ;
|
|
header 0= : 0= if L1 drop 0 ; L1: drop -1 ;
|
|
header 0< : 0< -if L1 drop -1 ; L1: drop 0 ;
|
|
header NOT : NOT jump 0=
|
|
header = : EQUALS xor jump 0=
|
|
header < : LESS
|
|
over over xor -if SAME drop drop jump 0<
|
|
SAME: drop - jump 0<
|
|
header > : GREATER SWAP jump LESS
|
|
|
|
\ ---- in-line addresses and constants ----
|
|
header BL inline : BL' BL ;
|
|
header TIB inline : TIB' TIB ;
|
|
header >IN inline : >IN' >IN ;
|
|
header SPAN inline : SPAN' SPAN ;
|
|
header BASE inline : BASE' BASE ;
|
|
header PAD inline : PAD' PAD ;
|
|
header STATE inline : STATE' STATE ;
|