forth: String word set COMPARE/SEARCH/SLITERAL (+9)

lib/forth/ans-tests/README.md

@@ -0,0 +1,14 @@
+ANS Forth conformance tests — vendored from
+https://github.com/gerryjackson/forth2012-test-suite (master, commit-locked
+on first fetch: 2026-04-24).
+
+Files in this directory are pristine copies of upstream — do not edit them.
+They are consumed by the conformance runner in `lib/forth/conformance.sh`.
+
+- `tester.fr` — John Hayes' test harness (`T{ ... -> ... }T`). (C) 1995
+  Johns Hopkins APL, distributable under its notice.
+- `core.fr` — Core word set tests (Hayes, ~1000 lines).
+- `coreexttest.fth` — Core Extension tests (Gerry Jackson).
+
+Only `core.fr` is expected to run green end-to-end for Phase 3; the others
+stay parked until later phases.

lib/forth/ans-tests/coreexttest.fth

@@ -0,0 +1,775 @@
+\ To test the ANS Forth Core Extension word set
+
+\ This program was written by Gerry Jackson in 2006, with contributions from
+\ others where indicated, and is in the public domain - it can be distributed
+\ and/or modified in any way but please retain this notice.
+
+\ This program is distributed in the hope that it will be useful,
+\ but WITHOUT ANY WARRANTY; without even the implied warranty of
+\ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+\ The tests are not claimed to be comprehensive or correct 
+
+\ ------------------------------------------------------------------------------
+\ Version 0.15 1 August 2025 Added two tests to VALUE
+\         0.14 21 July 2022 Updated first line of BUFFER: test as recommended
+\              in issue 32
+\         0.13 28 October 2015
+\              Replace <FALSE> and <TRUE> with FALSE and TRUE to avoid
+\              dependence on Core tests
+\              Moved SAVE-INPUT and RESTORE-INPUT tests in a file to filetest.fth
+\              Use of 2VARIABLE (from optional wordset) replaced with CREATE.
+\              Minor lower to upper case conversions.
+\              Calls to COMPARE replaced by S= (in utilities.fth) to avoid use
+\              of a word from an optional word set.
+\              UNUSED tests revised as UNUSED UNUSED = may return FALSE when an
+\              implementation has the data stack sharing unused dataspace.
+\              Double number input dependency removed from the HOLDS tests.
+\              Minor case sensitivities removed in definition names.
+\         0.11 25 April 2015
+\              Added tests for PARSE-NAME HOLDS BUFFER:
+\              S\" tests added
+\              DEFER IS ACTION-OF DEFER! DEFER@ tests added
+\              Empty CASE statement test added
+\              [COMPILE] tests removed because it is obsolescent in Forth 2012
+\         0.10 1 August 2014
+\             Added tests contributed by James Bowman for:
+\                <> U> 0<> 0> NIP TUCK ROLL PICK 2>R 2R@ 2R>
+\                HEX WITHIN UNUSED AGAIN MARKER
+\             Added tests for:
+\                .R U.R ERASE PAD REFILL SOURCE-ID 
+\             Removed ABORT from NeverExecuted to enable Win32
+\             to continue after failure of RESTORE-INPUT.
+\             Removed max-intx which is no longer used.
+\         0.7 6 June 2012 Extra CASE test added
+\         0.6 1 April 2012 Tests placed in the public domain.
+\             SAVE-INPUT & RESTORE-INPUT tests, position
+\             of T{ moved so that tests work with ttester.fs
+\             CONVERT test deleted - obsolete word removed from Forth 200X
+\             IMMEDIATE VALUEs tested
+\             RECURSE with :NONAME tested
+\             PARSE and .( tested
+\             Parsing behaviour of C" added
+\         0.5 14 September 2011 Removed the double [ELSE] from the
+\             initial SAVE-INPUT & RESTORE-INPUT test
+\         0.4 30 November 2009  max-int replaced with max-intx to
+\             avoid redefinition warnings.
+\         0.3  6 March 2009 { and } replaced with T{ and }T
+\                           CONVERT test now independent of cell size
+\         0.2  20 April 2007 ANS Forth words changed to upper case
+\                            Tests qd3 to qd6 by Reinhold Straub
+\         0.1  Oct 2006 First version released
+\ -----------------------------------------------------------------------------
+\ The tests are based on John Hayes test program for the core word set
+
+\ Words tested in this file are:
+\     .( .R 0<> 0> 2>R 2R> 2R@ :NONAME <> ?DO AGAIN C" CASE COMPILE, ENDCASE
+\     ENDOF ERASE FALSE HEX MARKER NIP OF PAD PARSE PICK REFILL
+\     RESTORE-INPUT ROLL SAVE-INPUT SOURCE-ID TO TRUE TUCK U.R U> UNUSED
+\     VALUE WITHIN [COMPILE]
+
+\ Words not tested or partially tested:
+\     \ because it has been extensively used already and is, hence, unnecessary
+\     REFILL and SOURCE-ID from the user input device which are not possible
+\     when testing from a file such as this one
+\     UNUSED (partially tested) as the value returned is system dependent
+\     Obsolescent words #TIB CONVERT EXPECT QUERY SPAN TIB as they have been
+\     removed from the Forth 2012 standard
+
+\ Results from words that output to the user output device have to visually
+\ checked for correctness. These are .R U.R .(
+
+\ -----------------------------------------------------------------------------
+\ Assumptions & dependencies:
+\     - tester.fr (or ttester.fs), errorreport.fth and utilities.fth have been
+\       included prior to this file
+\     - the Core word set available
+\ -----------------------------------------------------------------------------
+TESTING Core Extension words
+
+DECIMAL
+
+TESTING TRUE FALSE
+
+T{ TRUE  -> 0 INVERT }T
+T{ FALSE -> 0 }T
+
+\ -----------------------------------------------------------------------------
+TESTING <> U>   (contributed by James Bowman)
+
+T{ 0 0 <> -> FALSE }T
+T{ 1 1 <> -> FALSE }T
+T{ -1 -1 <> -> FALSE }T
+T{ 1 0 <> -> TRUE }T
+T{ -1 0 <> -> TRUE }T
+T{ 0 1 <> -> TRUE }T
+T{ 0 -1 <> -> TRUE }T
+
+T{ 0 1 U> -> FALSE }T
+T{ 1 2 U> -> FALSE }T
+T{ 0 MID-UINT U> -> FALSE }T
+T{ 0 MAX-UINT U> -> FALSE }T
+T{ MID-UINT MAX-UINT U> -> FALSE }T
+T{ 0 0 U> -> FALSE }T
+T{ 1 1 U> -> FALSE }T
+T{ 1 0 U> -> TRUE }T
+T{ 2 1 U> -> TRUE }T
+T{ MID-UINT 0 U> -> TRUE }T
+T{ MAX-UINT 0 U> -> TRUE }T
+T{ MAX-UINT MID-UINT U> -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING 0<> 0>   (contributed by James Bowman)
+
+T{ 0 0<> -> FALSE }T
+T{ 1 0<> -> TRUE }T
+T{ 2 0<> -> TRUE }T
+T{ -1 0<> -> TRUE }T
+T{ MAX-UINT 0<> -> TRUE }T
+T{ MIN-INT 0<> -> TRUE }T
+T{ MAX-INT 0<> -> TRUE }T
+
+T{ 0 0> -> FALSE }T
+T{ -1 0> -> FALSE }T
+T{ MIN-INT 0> -> FALSE }T
+T{ 1 0> -> TRUE }T
+T{ MAX-INT 0> -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING NIP TUCK ROLL PICK   (contributed by James Bowman)
+
+T{ 1 2 NIP -> 2 }T
+T{ 1 2 3 NIP -> 1 3 }T
+
+T{ 1 2 TUCK -> 2 1 2 }T
+T{ 1 2 3 TUCK -> 1 3 2 3 }T
+
+T{ : RO5 100 200 300 400 500 ; -> }T
+T{ RO5 3 ROLL -> 100 300 400 500 200 }T
+T{ RO5 2 ROLL -> RO5 ROT }T
+T{ RO5 1 ROLL -> RO5 SWAP }T
+T{ RO5 0 ROLL -> RO5 }T
+
+T{ RO5 2 PICK -> 100 200 300 400 500 300 }T
+T{ RO5 1 PICK -> RO5 OVER }T
+T{ RO5 0 PICK -> RO5 DUP }T
+
+\ -----------------------------------------------------------------------------
+TESTING 2>R 2R@ 2R>   (contributed by James Bowman)
+
+T{ : RR0 2>R 100 R> R> ; -> }T
+T{ 300 400 RR0 -> 100 400 300 }T
+T{ 200 300 400 RR0 -> 200 100 400 300 }T
+
+T{ : RR1 2>R 100 2R@ R> R> ; -> }T
+T{ 300 400 RR1 -> 100 300 400 400 300 }T
+T{ 200 300 400 RR1 -> 200 100 300 400 400 300 }T
+
+T{ : RR2 2>R 100 2R> ; -> }T
+T{ 300 400 RR2 -> 100 300 400 }T
+T{ 200 300 400 RR2 -> 200 100 300 400 }T
+
+\ -----------------------------------------------------------------------------
+TESTING HEX   (contributed by James Bowman)
+
+T{ BASE @ HEX BASE @ DECIMAL BASE @ - SWAP BASE ! -> 6 }T
+
+\ -----------------------------------------------------------------------------
+TESTING WITHIN   (contributed by James Bowman)
+
+T{ 0 0 0 WITHIN -> FALSE }T
+T{ 0 0 MID-UINT WITHIN -> TRUE }T
+T{ 0 0 MID-UINT+1 WITHIN -> TRUE }T
+T{ 0 0 MAX-UINT WITHIN -> TRUE }T
+T{ 0 MID-UINT 0 WITHIN -> FALSE }T
+T{ 0 MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ 0 MID-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ 0 MID-UINT MAX-UINT WITHIN -> FALSE }T
+T{ 0 MID-UINT+1 0 WITHIN -> FALSE }T
+T{ 0 MID-UINT+1 MID-UINT WITHIN -> TRUE }T
+T{ 0 MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ 0 MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
+T{ 0 MAX-UINT 0 WITHIN -> FALSE }T
+T{ 0 MAX-UINT MID-UINT WITHIN -> TRUE }T
+T{ 0 MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ 0 MAX-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MID-UINT 0 0 WITHIN -> FALSE }T
+T{ MID-UINT 0 MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT 0 MID-UINT+1 WITHIN -> TRUE }T
+T{ MID-UINT 0 MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT 0 WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT+1 0 WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT+1 MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
+T{ MID-UINT MAX-UINT 0 WITHIN -> FALSE }T
+T{ MID-UINT MAX-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ MID-UINT MAX-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 0 0 WITHIN -> FALSE }T
+T{ MID-UINT+1 0 MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 0 MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 0 MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT 0 WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 MID-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 MID-UINT MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT+1 0 WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT+1 MID-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 MID-UINT+1 MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MAX-UINT 0 WITHIN -> FALSE }T
+T{ MID-UINT+1 MAX-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 MAX-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 MAX-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT 0 0 WITHIN -> FALSE }T
+T{ MAX-UINT 0 MID-UINT WITHIN -> FALSE }T
+T{ MAX-UINT 0 MID-UINT+1 WITHIN -> FALSE }T
+T{ MAX-UINT 0 MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT 0 WITHIN -> TRUE }T
+T{ MAX-UINT MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT+1 0 WITHIN -> TRUE }T
+T{ MAX-UINT MID-UINT+1 MID-UINT WITHIN -> TRUE }T
+T{ MAX-UINT MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MAX-UINT 0 WITHIN -> TRUE }T
+T{ MAX-UINT MAX-UINT MID-UINT WITHIN -> TRUE }T
+T{ MAX-UINT MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ MAX-UINT MAX-UINT MAX-UINT WITHIN -> FALSE }T
+
+T{ MIN-INT MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT MIN-INT 0 WITHIN -> TRUE }T
+T{ MIN-INT MIN-INT 1 WITHIN -> TRUE }T
+T{ MIN-INT MIN-INT MAX-INT WITHIN -> TRUE }T
+T{ MIN-INT 0 MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT 0 0 WITHIN -> FALSE }T
+T{ MIN-INT 0 1 WITHIN -> FALSE }T
+T{ MIN-INT 0 MAX-INT WITHIN -> FALSE }T
+T{ MIN-INT 1 MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT 1 0 WITHIN -> TRUE }T
+T{ MIN-INT 1 1 WITHIN -> FALSE }T
+T{ MIN-INT 1 MAX-INT WITHIN -> FALSE }T
+T{ MIN-INT MAX-INT MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT MAX-INT 0 WITHIN -> TRUE }T
+T{ MIN-INT MAX-INT 1 WITHIN -> TRUE }T
+T{ MIN-INT MAX-INT MAX-INT WITHIN -> FALSE }T
+T{ 0 MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ 0 MIN-INT 0 WITHIN -> FALSE }T
+T{ 0 MIN-INT 1 WITHIN -> TRUE }T
+T{ 0 MIN-INT MAX-INT WITHIN -> TRUE }T
+T{ 0 0 MIN-INT WITHIN -> TRUE }T
+T{ 0 0 0 WITHIN -> FALSE }T
+T{ 0 0 1 WITHIN -> TRUE }T
+T{ 0 0 MAX-INT WITHIN -> TRUE }T
+T{ 0 1 MIN-INT WITHIN -> FALSE }T
+T{ 0 1 0 WITHIN -> FALSE }T
+T{ 0 1 1 WITHIN -> FALSE }T
+T{ 0 1 MAX-INT WITHIN -> FALSE }T
+T{ 0 MAX-INT MIN-INT WITHIN -> FALSE }T
+T{ 0 MAX-INT 0 WITHIN -> FALSE }T
+T{ 0 MAX-INT 1 WITHIN -> TRUE }T
+T{ 0 MAX-INT MAX-INT WITHIN -> FALSE }T
+T{ 1 MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ 1 MIN-INT 0 WITHIN -> FALSE }T
+T{ 1 MIN-INT 1 WITHIN -> FALSE }T
+T{ 1 MIN-INT MAX-INT WITHIN -> TRUE }T
+T{ 1 0 MIN-INT WITHIN -> TRUE }T
+T{ 1 0 0 WITHIN -> FALSE }T
+T{ 1 0 1 WITHIN -> FALSE }T
+T{ 1 0 MAX-INT WITHIN -> TRUE }T
+T{ 1 1 MIN-INT WITHIN -> TRUE }T
+T{ 1 1 0 WITHIN -> TRUE }T
+T{ 1 1 1 WITHIN -> FALSE }T
+T{ 1 1 MAX-INT WITHIN -> TRUE }T
+T{ 1 MAX-INT MIN-INT WITHIN -> FALSE }T
+T{ 1 MAX-INT 0 WITHIN -> FALSE }T
+T{ 1 MAX-INT 1 WITHIN -> FALSE }T
+T{ 1 MAX-INT MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT 0 WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT 1 WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT 0 MIN-INT WITHIN -> TRUE }T
+T{ MAX-INT 0 0 WITHIN -> FALSE }T
+T{ MAX-INT 0 1 WITHIN -> FALSE }T
+T{ MAX-INT 0 MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT 1 MIN-INT WITHIN -> TRUE }T
+T{ MAX-INT 1 0 WITHIN -> TRUE }T
+T{ MAX-INT 1 1 WITHIN -> FALSE }T
+T{ MAX-INT 1 MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT MAX-INT MIN-INT WITHIN -> TRUE }T
+T{ MAX-INT MAX-INT 0 WITHIN -> TRUE }T
+T{ MAX-INT MAX-INT 1 WITHIN -> TRUE }T
+T{ MAX-INT MAX-INT MAX-INT WITHIN -> FALSE }T
+
+\ -----------------------------------------------------------------------------
+TESTING UNUSED  (contributed by James Bowman & Peter Knaggs)
+
+VARIABLE UNUSED0
+T{ UNUSED DROP -> }T                  
+T{ ALIGN UNUSED UNUSED0 ! 0 , UNUSED CELL+ UNUSED0 @ = -> TRUE }T
+T{ UNUSED UNUSED0 ! 0 C, UNUSED CHAR+ UNUSED0 @ =
+         -> TRUE }T  \ aligned -> unaligned
+T{ UNUSED UNUSED0 ! 0 C, UNUSED CHAR+ UNUSED0 @ = -> TRUE }T  \ unaligned -> ?
+
+\ -----------------------------------------------------------------------------
+TESTING AGAIN   (contributed by James Bowman)
+
+T{ : AG0 701 BEGIN DUP 7 MOD 0= IF EXIT THEN 1+ AGAIN ; -> }T
+T{ AG0 -> 707 }T
+
+\ -----------------------------------------------------------------------------
+TESTING MARKER   (contributed by James Bowman)
+
+T{ : MA? BL WORD FIND NIP 0<> ; -> }T
+T{ MARKER MA0 -> }T
+T{ : MA1 111 ; -> }T
+T{ MARKER MA2 -> }T
+T{ : MA1 222 ; -> }T
+T{ MA? MA0 MA? MA1 MA? MA2 -> TRUE TRUE TRUE }T
+T{ MA1 MA2 MA1 -> 222 111 }T
+T{ MA? MA0 MA? MA1 MA? MA2 -> TRUE TRUE FALSE }T
+T{ MA0 -> }T
+T{ MA? MA0 MA? MA1 MA? MA2 -> FALSE FALSE FALSE }T
+
+\ -----------------------------------------------------------------------------
+TESTING ?DO
+
+: QD ?DO I LOOP ;
+T{ 789 789 QD -> }T
+T{ -9876 -9876 QD -> }T
+T{ 5 0 QD -> 0 1 2 3 4 }T
+
+: QD1 ?DO I 10 +LOOP ;
+T{ 50 1 QD1 -> 1 11 21 31 41 }T
+T{ 50 0 QD1 -> 0 10 20 30 40 }T
+
+: QD2 ?DO I 3 > IF LEAVE ELSE I THEN LOOP ;
+T{ 5 -1 QD2 -> -1 0 1 2 3 }T
+
+: QD3 ?DO I 1 +LOOP ;
+T{ 4  4 QD3 -> }T
+T{ 4  1 QD3 -> 1 2 3 }T
+T{ 2 -1 QD3 -> -1 0 1 }T
+
+: QD4 ?DO I -1 +LOOP ;
+T{  4 4 QD4 -> }T
+T{  1 4 QD4 -> 4 3 2 1 }T
+T{ -1 2 QD4 -> 2 1 0 -1 }T
+
+: QD5 ?DO I -10 +LOOP ;
+T{   1 50 QD5 -> 50 40 30 20 10 }T
+T{   0 50 QD5 -> 50 40 30 20 10 0 }T
+T{ -25 10 QD5 -> 10 0 -10 -20 }T
+
+VARIABLE ITERS
+VARIABLE INCRMNT
+
+: QD6 ( limit start increment -- )
+   INCRMNT !
+   0 ITERS !
+   ?DO
+      1 ITERS +!
+      I
+      ITERS @  6 = IF LEAVE THEN
+      INCRMNT @
+   +LOOP ITERS @
+;
+
+T{  4  4 -1 QD6 -> 0 }T
+T{  1  4 -1 QD6 -> 4 3 2 1 4 }T
+T{  4  1 -1 QD6 -> 1 0 -1 -2 -3 -4 6 }T
+T{  4  1  0 QD6 -> 1 1 1 1 1 1 6 }T
+T{  0  0  0 QD6 -> 0 }T
+T{  1  4  0 QD6 -> 4 4 4 4 4 4 6 }T
+T{  1  4  1 QD6 -> 4 5 6 7 8 9 6 }T
+T{  4  1  1 QD6 -> 1 2 3 3 }T
+T{  4  4  1 QD6 -> 0 }T
+T{  2 -1 -1 QD6 -> -1 -2 -3 -4 -5 -6 6 }T
+T{ -1  2 -1 QD6 -> 2 1 0 -1 4 }T
+T{  2 -1  0 QD6 -> -1 -1 -1 -1 -1 -1 6 }T
+T{ -1  2  0 QD6 -> 2 2 2 2 2 2 6 }T
+T{ -1  2  1 QD6 -> 2 3 4 5 6 7 6 }T
+T{  2 -1  1 QD6 -> -1 0 1 3 }T
+
+\ -----------------------------------------------------------------------------
+TESTING BUFFER:
+
+T{ 2 CELLS BUFFER: BUF:TEST -> }T
+T{ BUF:TEST DUP ALIGNED = -> TRUE }T
+T{ 111 BUF:TEST ! 222 BUF:TEST CELL+ ! -> }T
+T{ BUF:TEST @ BUF:TEST CELL+ @ -> 111 222 }T
+
+\ -----------------------------------------------------------------------------
+TESTING VALUE TO
+
+T{ 111 VALUE VAL1 -999 VALUE VAL2 -> }T
+T{ VAL1 -> 111 }T
+T{ VAL2 -> -999 }T
+T{ 222 TO VAL1 -> }T
+T{ VAL1 -> 222 }T
+T{ : VD1 VAL1 ; -> }T
+T{ VD1 -> 222 }T
+T{ : VD2 TO VAL2 ; -> }T
+T{ VAL2 -> -999 }T
+T{ -333 VD2 -> }T
+T{ VAL2 -> -333 }T
+T{ VAL1 -> 222 }T
+T{ 444 TO VAL1 -> }T
+T{ VD1 -> 444 }T
+T{ 123 VALUE VAL3 IMMEDIATE VAL3 -> 123 }T
+T{ : VD3 VAL3 LITERAL ; VD3 -> 123 }T
+
+\ -----------------------------------------------------------------------------
+TESTING CASE OF ENDOF ENDCASE
+
+: CS1 CASE 1 OF 111 ENDOF
+           2 OF 222 ENDOF
+           3 OF 333 ENDOF
+           >R 999 R>
+      ENDCASE
+;
+
+T{ 1 CS1 -> 111 }T
+T{ 2 CS1 -> 222 }T
+T{ 3 CS1 -> 333 }T
+T{ 4 CS1 -> 999 }T
+
+\ Nested CASE's
+
+: CS2 >R CASE -1 OF CASE R@ 1 OF 100 ENDOF
+                            2 OF 200 ENDOF
+                           >R -300 R>
+                    ENDCASE
+                 ENDOF
+              -2 OF CASE R@ 1 OF -99  ENDOF
+                            >R -199 R>
+                    ENDCASE
+                 ENDOF
+                 >R 299 R>
+         ENDCASE R> DROP
+;
+
+T{ -1 1 CS2 ->  100 }T
+T{ -1 2 CS2 ->  200 }T
+T{ -1 3 CS2 -> -300 }T
+T{ -2 1 CS2 -> -99  }T
+T{ -2 2 CS2 -> -199 }T
+T{  0 2 CS2 ->  299 }T
+
+\ Boolean short circuiting using CASE
+
+: CS3  ( N1 -- N2 )
+   CASE 1- FALSE OF 11 ENDOF
+        1- FALSE OF 22 ENDOF
+        1- FALSE OF 33 ENDOF
+        44 SWAP
+   ENDCASE
+;
+
+T{ 1 CS3 -> 11 }T
+T{ 2 CS3 -> 22 }T
+T{ 3 CS3 -> 33 }T
+T{ 9 CS3 -> 44 }T
+
+\ Empty CASE statements with/without default
+
+T{ : CS4 CASE ENDCASE ; 1 CS4 -> }T
+T{ : CS5 CASE 2 SWAP ENDCASE ; 1 CS5 -> 2 }T
+T{ : CS6 CASE 1 OF ENDOF 2 ENDCASE ; 1 CS6 -> }T
+T{ : CS7 CASE 3 OF ENDOF 2 ENDCASE ; 1 CS7 -> 1 }T
+
+\ -----------------------------------------------------------------------------
+TESTING :NONAME RECURSE
+
+VARIABLE NN1
+VARIABLE NN2
+:NONAME 1234 ; NN1 !
+:NONAME 9876 ; NN2 !
+T{ NN1 @ EXECUTE -> 1234 }T
+T{ NN2 @ EXECUTE -> 9876 }T
+
+T{ :NONAME ( n -- 0,1,..n ) DUP IF DUP >R 1- RECURSE R> THEN ;
+   CONSTANT RN1 -> }T
+T{ 0 RN1 EXECUTE -> 0 }T
+T{ 4 RN1 EXECUTE -> 0 1 2 3 4 }T
+
+:NONAME  ( n -- n1 )    \ Multiple RECURSEs in one definition
+   1- DUP
+   CASE 0 OF EXIT ENDOF
+        1 OF 11 SWAP RECURSE ENDOF
+        2 OF 22 SWAP RECURSE ENDOF
+        3 OF 33 SWAP RECURSE ENDOF
+        DROP ABS RECURSE EXIT
+   ENDCASE
+; CONSTANT RN2
+
+T{  1 RN2 EXECUTE -> 0 }T
+T{  2 RN2 EXECUTE -> 11 0 }T
+T{  4 RN2 EXECUTE -> 33 22 11 0 }T
+T{ 25 RN2 EXECUTE -> 33 22 11 0 }T
+
+\ -----------------------------------------------------------------------------
+TESTING C"
+
+T{ : CQ1 C" 123" ; -> }T
+T{ CQ1 COUNT EVALUATE -> 123 }T
+T{ : CQ2 C" " ; -> }T
+T{ CQ2 COUNT EVALUATE -> }T
+T{ : CQ3 C" 2345"COUNT EVALUATE ; CQ3 -> 2345 }T
+
+\ -----------------------------------------------------------------------------
+TESTING COMPILE,
+
+:NONAME DUP + ; CONSTANT DUP+
+T{ : Q DUP+ COMPILE, ; -> }T
+T{ : AS1 [ Q ] ; -> }T
+T{ 123 AS1 -> 246 }T
+
+\ -----------------------------------------------------------------------------
+\ Cannot automatically test SAVE-INPUT and RESTORE-INPUT from a console source
+
+TESTING SAVE-INPUT and RESTORE-INPUT with a string source
+
+VARIABLE SI_INC 0 SI_INC !
+
+: SI1
+   SI_INC @ >IN +!
+   15 SI_INC !
+;
+
+: S$ S" SAVE-INPUT SI1 RESTORE-INPUT 12345" ;
+
+T{ S$ EVALUATE SI_INC @ -> 0 2345 15 }T
+
+\ -----------------------------------------------------------------------------
+TESTING .(
+
+CR CR .( Output from .() 
+T{ CR .( You should see -9876: ) -9876 . -> }T
+T{ CR .( and again: ).( -9876)CR -> }T
+
+CR CR .( On the next 2 lines you should see First then Second messages:)
+T{ : DOTP  CR ." Second message via ." [CHAR] " EMIT    \ Check .( is immediate
+     [ CR ] .( First message via .( ) ; DOTP -> }T
+CR CR
+T{ : IMM? BL WORD FIND NIP ; IMM? .( -> 1 }T
+
+\ -----------------------------------------------------------------------------
+TESTING .R and U.R - has to handle different cell sizes
+
+\ Create some large integers just below/above MAX and Min INTs
+MAX-INT 73 79 */ CONSTANT LI1
+MIN-INT 71 73 */ CONSTANT LI2
+
+LI1 0 <# #S #> NIP CONSTANT LENLI1
+
+: (.R&U.R)  ( u1 u2 -- )  \ u1 <= string length, u2 is required indentation
+   TUCK + >R
+   LI1 OVER SPACES  . CR R@    LI1 SWAP  .R CR
+   LI2 OVER SPACES  . CR R@ 1+ LI2 SWAP  .R CR
+   LI1 OVER SPACES U. CR R@    LI1 SWAP U.R CR
+   LI2 SWAP SPACES U. CR R>    LI2 SWAP U.R CR
+;
+
+: .R&U.R  ( -- )
+   CR ." You should see lines duplicated:" CR
+   ." indented by 0 spaces" CR 0      0 (.R&U.R) CR
+   ." indented by 0 spaces" CR LENLI1 0 (.R&U.R) CR \ Just fits required width
+   ." indented by 5 spaces" CR LENLI1 5 (.R&U.R) CR
+;
+
+CR CR .( Output from .R and U.R)
+T{ .R&U.R -> }T
+
+\ -----------------------------------------------------------------------------
+TESTING PAD ERASE
+\ Must handle different size characters i.e. 1 CHARS >= 1 
+
+84 CONSTANT CHARS/PAD      \ Minimum size of PAD in chars
+CHARS/PAD CHARS CONSTANT AUS/PAD
+: CHECKPAD  ( caddr u ch -- f )  \ f = TRUE if u chars = ch
+   SWAP 0
+   ?DO
+      OVER I CHARS + C@ OVER <>
+      IF 2DROP UNLOOP FALSE EXIT THEN
+   LOOP  
+   2DROP TRUE
+;
+
+T{ PAD DROP -> }T
+T{ 0 INVERT PAD C! -> }T
+T{ PAD C@ CONSTANT MAXCHAR -> }T
+T{ PAD CHARS/PAD 2DUP MAXCHAR FILL MAXCHAR CHECKPAD -> TRUE }T
+T{ PAD CHARS/PAD 2DUP CHARS ERASE 0 CHECKPAD -> TRUE }T
+T{ PAD CHARS/PAD 2DUP MAXCHAR FILL PAD 0 ERASE MAXCHAR CHECKPAD -> TRUE }T
+T{ PAD 43 CHARS + 9 CHARS ERASE -> }T
+T{ PAD 43 MAXCHAR CHECKPAD -> TRUE }T
+T{ PAD 43 CHARS + 9 0 CHECKPAD -> TRUE }T
+T{ PAD 52 CHARS + CHARS/PAD 52 - MAXCHAR CHECKPAD -> TRUE }T
+
+\ Check that use of WORD and pictured numeric output do not corrupt PAD
+\ Minimum size of buffers for these are 33 chars and (2*n)+2 chars respectively
+\ where n is number of bits per cell
+
+PAD CHARS/PAD ERASE
+2 BASE !
+MAX-UINT MAX-UINT <# #S CHAR 1 DUP HOLD HOLD #> 2DROP
+DECIMAL
+BL WORD 12345678123456781234567812345678 DROP
+T{ PAD CHARS/PAD 0 CHECKPAD -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING PARSE
+
+T{ CHAR | PARSE 1234| DUP ROT ROT EVALUATE -> 4 1234 }T
+T{ CHAR ^ PARSE  23 45 ^ DUP ROT ROT EVALUATE -> 7 23 45 }T
+: PA1 [CHAR] $ PARSE DUP >R PAD SWAP CHARS MOVE PAD R> ;
+T{ PA1 3456
+   DUP ROT ROT EVALUATE -> 4 3456 }T
+T{ CHAR A PARSE A SWAP DROP -> 0 }T
+T{ CHAR Z PARSE
+   SWAP DROP -> 0 }T
+T{ CHAR " PARSE 4567 "DUP ROT ROT EVALUATE -> 5 4567 }T
+ 
+\ -----------------------------------------------------------------------------
+TESTING PARSE-NAME  (Forth 2012)
+\ Adapted from the PARSE-NAME RfD tests
+
+T{ PARSE-NAME abcd  STR1  S= -> TRUE }T        \ No leading spaces
+T{ PARSE-NAME      abcde STR2 S= -> TRUE }T    \ Leading spaces
+
+\ Test empty parse area, new lines are necessary
+T{ PARSE-NAME
+  NIP -> 0 }T
+\ Empty parse area with spaces after PARSE-NAME
+T{ PARSE-NAME         
+  NIP -> 0 }T
+
+T{ : PARSE-NAME-TEST ( "name1" "name2" -- n )
+    PARSE-NAME PARSE-NAME S= ; -> }T
+T{ PARSE-NAME-TEST abcd abcd  -> TRUE }T
+T{ PARSE-NAME-TEST abcd   abcd  -> TRUE }T  \ Leading spaces
+T{ PARSE-NAME-TEST abcde abcdf -> FALSE }T
+T{ PARSE-NAME-TEST abcdf abcde -> FALSE }T
+T{ PARSE-NAME-TEST abcde abcde
+   -> TRUE }T         \ Parse to end of line
+T{ PARSE-NAME-TEST abcde           abcde         
+   -> TRUE }T         \ Leading and trailing spaces
+
+\ -----------------------------------------------------------------------------
+TESTING DEFER DEFER@ DEFER! IS ACTION-OF (Forth 2012)
+\ Adapted from the Forth 200X RfD tests
+
+T{ DEFER DEFER1 -> }T
+T{ : MY-DEFER DEFER ; -> }T
+T{ : IS-DEFER1 IS DEFER1 ; -> }T
+T{ : ACTION-DEFER1 ACTION-OF DEFER1 ; -> }T
+T{ : DEF! DEFER! ; -> }T
+T{ : DEF@ DEFER@ ; -> }T
+
+T{ ' * ' DEFER1 DEFER! -> }T
+T{ 2 3 DEFER1 -> 6 }T
+T{ ' DEFER1 DEFER@ -> ' * }T
+T{ ' DEFER1 DEF@ -> ' * }T
+T{ ACTION-OF DEFER1 -> ' * }T
+T{ ACTION-DEFER1 -> ' * }T
+T{ ' + IS DEFER1 -> }T
+T{ 1 2 DEFER1 -> 3 }T
+T{ ' DEFER1 DEFER@ -> ' + }T
+T{ ' DEFER1 DEF@ -> ' + }T
+T{ ACTION-OF DEFER1 -> ' + }T
+T{ ACTION-DEFER1 -> ' + }T
+T{ ' - IS-DEFER1 -> }T
+T{ 1 2 DEFER1 -> -1 }T
+T{ ' DEFER1 DEFER@ -> ' - }T
+T{ ' DEFER1 DEF@ -> ' - }T
+T{ ACTION-OF DEFER1 -> ' - }T
+T{ ACTION-DEFER1 -> ' - }T
+
+T{ MY-DEFER DEFER2 -> }T
+T{ ' DUP IS DEFER2 -> }T
+T{ 1 DEFER2 -> 1 1 }T
+
+\ -----------------------------------------------------------------------------
+TESTING HOLDS  (Forth 2012)
+
+: HTEST S" Testing HOLDS" ;
+: HTEST2 S" works" ;
+: HTEST3 S" Testing HOLDS works 123" ;
+T{ 0 0 <#  HTEST HOLDS #> HTEST S= -> TRUE }T
+T{ 123 0 <# #S BL HOLD HTEST2 HOLDS BL HOLD HTEST HOLDS #>
+   HTEST3 S= -> TRUE }T
+T{ : HLD HOLDS ; -> }T
+T{ 0 0 <#  HTEST HLD #> HTEST S= -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING REFILL SOURCE-ID
+\ REFILL and SOURCE-ID from the user input device can't be tested from a file,
+\ can only be tested from a string via EVALUATE
+
+T{ : RF1  S" REFILL" EVALUATE ; RF1 -> FALSE }T
+T{ : SID1  S" SOURCE-ID" EVALUATE ; SID1 -> -1 }T
+
+\ ------------------------------------------------------------------------------
+TESTING S\"  (Forth 2012 compilation mode)
+\ Extended the Forth 200X RfD tests
+\ Note this tests the Core Ext definition of S\" which has unedfined
+\ interpretation semantics. S\" in interpretation mode is tested in the tests on
+\ the File-Access word set
+
+T{ : SSQ1 S\" abc" S" abc" S= ; -> }T  \ No escapes
+T{ SSQ1 -> TRUE }T
+T{ : SSQ2 S\" " ; SSQ2 SWAP DROP -> 0 }T    \ Empty string
+
+T{ : SSQ3 S\" \a\b\e\f\l\m\q\r\t\v\x0F0\x1Fa\xaBx\z\"\\" ; -> }T
+T{ SSQ3 SWAP DROP          ->  20 }T    \ String length
+T{ SSQ3 DROP            C@ ->   7 }T    \ \a   BEL  Bell
+T{ SSQ3 DROP  1 CHARS + C@ ->   8 }T    \ \b   BS   Backspace
+T{ SSQ3 DROP  2 CHARS + C@ ->  27 }T    \ \e   ESC  Escape
+T{ SSQ3 DROP  3 CHARS + C@ ->  12 }T    \ \f   FF   Form feed
+T{ SSQ3 DROP  4 CHARS + C@ ->  10 }T    \ \l   LF   Line feed
+T{ SSQ3 DROP  5 CHARS + C@ ->  13 }T    \ \m        CR of CR/LF pair
+T{ SSQ3 DROP  6 CHARS + C@ ->  10 }T    \           LF of CR/LF pair
+T{ SSQ3 DROP  7 CHARS + C@ ->  34 }T    \ \q   "    Double Quote
+T{ SSQ3 DROP  8 CHARS + C@ ->  13 }T    \ \r   CR   Carriage Return
+T{ SSQ3 DROP  9 CHARS + C@ ->   9 }T    \ \t   TAB  Horizontal Tab
+T{ SSQ3 DROP 10 CHARS + C@ ->  11 }T    \ \v   VT   Vertical Tab
+T{ SSQ3 DROP 11 CHARS + C@ ->  15 }T    \ \x0F      Given Char
+T{ SSQ3 DROP 12 CHARS + C@ ->  48 }T    \ 0    0    Digit follow on
+T{ SSQ3 DROP 13 CHARS + C@ ->  31 }T    \ \x1F      Given Char
+T{ SSQ3 DROP 14 CHARS + C@ ->  97 }T    \ a    a    Hex follow on
+T{ SSQ3 DROP 15 CHARS + C@ -> 171 }T    \ \xaB      Insensitive Given Char
+T{ SSQ3 DROP 16 CHARS + C@ -> 120 }T    \ x    x    Non hex follow on
+T{ SSQ3 DROP 17 CHARS + C@ ->   0 }T    \ \z   NUL  No Character
+T{ SSQ3 DROP 18 CHARS + C@ ->  34 }T    \ \"   "    Double Quote
+T{ SSQ3 DROP 19 CHARS + C@ ->  92 }T    \ \\   \    Back Slash
+
+\ The above does not test \n as this is a system dependent value.
+\ Check it displays a new line
+CR .( The next test should display:)
+CR .( One line...)
+CR .( another line)
+T{ : SSQ4 S\" \nOne line...\nanotherLine\n" TYPE ; SSQ4 -> }T
+
+\ Test bare escapable characters appear as themselves
+T{ : SSQ5 S\" abeflmnqrtvxz" S" abeflmnqrtvxz" S= ; SSQ5 -> TRUE }T
+
+T{ : SSQ6 S\" a\""2DROP 1111 ; SSQ6 -> 1111 }T \ Parsing behaviour
+
+T{ : SSQ7  S\" 111 : SSQ8 S\\\" 222\" EVALUATE ; SSQ8 333" EVALUATE ; -> }T
+T{ SSQ7 -> 111 222 333 }T
+T{ : SSQ9  S\" 11 : SSQ10 S\\\" \\x32\\x32\" EVALUATE ; SSQ10 33" EVALUATE ; -> }T
+T{ SSQ9 -> 11 22 33 }T
+
+\ -----------------------------------------------------------------------------
+CORE-EXT-ERRORS SET-ERROR-COUNT
+
+CR .( End of Core Extension word tests) CR
+
+

lib/forth/ans-tests/tester.fr

@@ -0,0 +1,66 @@
+\ From: John Hayes S1I
+\ Subject: tester.fr
+\ Date: Mon, 27 Nov 95 13:10:09 PST  
+
+\ (C) 1995 JOHNS HOPKINS UNIVERSITY / APPLIED PHYSICS LABORATORY
+\ MAY BE DISTRIBUTED FREELY AS LONG AS THIS COPYRIGHT NOTICE REMAINS.
+\ VERSION 1.2
+
+\ 24/11/2015 Replaced Core Ext word <> with = 0=
+\ 31/3/2015 Variable #ERRORS added and incremented for each error reported.
+\ 22/1/09 The words { and } have been changed to T{ and }T respectively to
+\ agree with the Forth 200X file ttester.fs. This avoids clashes with
+\ locals using { ... } and the FSL use of } 
+
+HEX
+
+\ SET THE FOLLOWING FLAG TO TRUE FOR MORE VERBOSE OUTPUT; THIS MAY
+\ ALLOW YOU TO TELL WHICH TEST CAUSED YOUR SYSTEM TO HANG.
+VARIABLE VERBOSE
+   FALSE VERBOSE !
+\   TRUE VERBOSE !
+
+: EMPTY-STACK   \ ( ... -- ) EMPTY STACK: HANDLES UNDERFLOWED STACK TOO.
+   DEPTH ?DUP IF DUP 0< IF NEGATE 0 DO 0 LOOP ELSE 0 DO DROP LOOP THEN THEN ;
+
+VARIABLE #ERRORS 0 #ERRORS !
+
+: ERROR      \ ( C-ADDR U -- ) DISPLAY AN ERROR MESSAGE FOLLOWED BY
+      \ THE LINE THAT HAD THE ERROR.
+   CR TYPE SOURCE TYPE       \ DISPLAY LINE CORRESPONDING TO ERROR
+   EMPTY-STACK               \ THROW AWAY EVERY THING ELSE
+   #ERRORS @ 1 + #ERRORS !
+\   QUIT  \ *** Uncomment this line to QUIT on an error
+;
+
+VARIABLE ACTUAL-DEPTH         \ STACK RECORD
+CREATE ACTUAL-RESULTS 20 CELLS ALLOT
+
+: T{      \ ( -- ) SYNTACTIC SUGAR.
+   ;
+
+: ->      \ ( ... -- ) RECORD DEPTH AND CONTENT OF STACK.
+   DEPTH DUP ACTUAL-DEPTH !      \ RECORD DEPTH
+   ?DUP IF            \ IF THERE IS SOMETHING ON STACK
+      0 DO ACTUAL-RESULTS I CELLS + ! LOOP \ SAVE THEM
+   THEN ;
+
+: }T      \ ( ... -- ) COMPARE STACK (EXPECTED) CONTENTS WITH SAVED
+      \ (ACTUAL) CONTENTS.
+   DEPTH ACTUAL-DEPTH @ = IF      \ IF DEPTHS MATCH
+      DEPTH ?DUP IF         \ IF THERE IS SOMETHING ON THE STACK
+         0  DO            \ FOR EACH STACK ITEM
+           ACTUAL-RESULTS I CELLS + @   \ COMPARE ACTUAL WITH EXPECTED
+           = 0= IF S" INCORRECT RESULT: " ERROR LEAVE THEN
+         LOOP
+      THEN
+   ELSE               \ DEPTH MISMATCH
+      S" WRONG NUMBER OF RESULTS: " ERROR
+   THEN ;
+
+: TESTING   \ ( -- ) TALKING COMMENT.
+  SOURCE VERBOSE @
+   IF DUP >R TYPE CR R> >IN !
+   ELSE >IN ! DROP [CHAR] * EMIT
+   THEN ;
+

lib/forth/conformance.sh

@@ -0,0 +1,166 @@
+#!/usr/bin/env bash
+# Run the Hayes/Gerry-Jackson Core conformance suite against our Forth
+# interpreter and emit scoreboard.json + scoreboard.md.
+#
+# Method:
+#   1. Preprocess lib/forth/ans-tests/core.fr — strip \ comments, ( ... )
+#      comments, and TESTING … metadata lines.
+#   2. Split into chunks ending at each `}T` so an error in one test
+#      chunk doesn't abort the run.
+#   3. Emit an SX file that exposes those chunks as a list.
+#   4. Run our Forth + hayes-runner under sx_server; record pass/fail/error.
+
+set -e
+FORTH_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$FORTH_DIR/../.." && pwd)"
+SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
+SOURCE="$FORTH_DIR/ans-tests/core.fr"
+OUT_JSON="$FORTH_DIR/scoreboard.json"
+OUT_MD="$FORTH_DIR/scoreboard.md"
+TMP="$(mktemp -d)"
+PREPROC="$TMP/preproc.forth"
+CHUNKS_SX="$TMP/chunks.sx"
+
+cd "$ROOT"
+
+# 1. preprocess
+awk '
+{
+  line = $0
+  # strip leading/embedded \ line comments (must be \ followed by space or EOL)
+  gsub(/(^|[ \t])\\([ \t].*|$)/, " ", line)
+  # strip ( ... ) block comments that sit on one line
+  gsub(/\([^)]*\)/, " ", line)
+  # strip TESTING … metadata lines (rest of line, incl. bare TESTING)
+  sub(/TESTING([ \t].*)?$/, " ", line)
+  print line
+}' "$SOURCE" > "$PREPROC"
+
+# 2 + 3: split into chunks at each `}T` and emit as a SX file
+#
+# Cap chunks via MAX_CHUNKS env (default 638 = full Hayes Core). Lower
+# it temporarily if later tests regress into an infinite loop while you
+# are iterating on primitives.
+MAX_CHUNKS="${MAX_CHUNKS:-638}"
+
+MAX_CHUNKS="$MAX_CHUNKS" python3 - "$PREPROC" "$CHUNKS_SX" <<'PY'
+import os, re, sys
+preproc_path, out_path = sys.argv[1], sys.argv[2]
+max_chunks = int(os.environ.get("MAX_CHUNKS", "590"))
+text = open(preproc_path).read()
+# keep the `}T` attached to the preceding chunk
+parts = re.split(r'(\}T)', text)
+chunks = []
+buf = ""
+for p in parts:
+    buf += p
+    if p == "}T":
+        s = buf.strip()
+        if s:
+            chunks.append(s)
+        buf = ""
+if buf.strip():
+    chunks.append(buf.strip())
+chunks = chunks[:max_chunks]
+
+def esc(s):
+    s = s.replace('\\', '\\\\').replace('"', '\\"')
+    s = s.replace('\r', ' ').replace('\n', ' ')
+    s = re.sub(r'\s+', ' ', s).strip()
+    return s
+
+with open(out_path, "w") as f:
+    f.write("(define hayes-chunks (list\n")
+    for c in chunks:
+        f.write('  "' + esc(c) + '"\n')
+    f.write("))\n\n")
+    f.write("(define\n")
+    f.write("  hayes-run-all\n")
+    f.write("  (fn\n")
+    f.write("    ()\n")
+    f.write("    (hayes-reset!)\n")
+    f.write("    (let ((s (hayes-boot)))\n")
+    f.write("      (for-each (fn (c) (hayes-run-chunk s c)) hayes-chunks))\n")
+    f.write("    (hayes-summary)))\n")
+PY
+
+# 4. run it
+OUT=$(printf '(epoch 1)\n(load "lib/forth/runtime.sx")\n(epoch 2)\n(load "lib/forth/reader.sx")\n(epoch 3)\n(load "lib/forth/interpreter.sx")\n(epoch 4)\n(load "lib/forth/compiler.sx")\n(epoch 5)\n(load "lib/forth/hayes-runner.sx")\n(epoch 6)\n(load "%s")\n(epoch 7)\n(eval "(hayes-run-all)")\n' "$CHUNKS_SX" \
+  | timeout 180 "$SX_SERVER" 2>&1)
+STATUS=$?
+
+SUMMARY=$(printf '%s\n' "$OUT" | awk '/^\{:pass / {print; exit}')
+PASS=$(printf '%s' "$SUMMARY" | sed -n 's/.*:pass \([0-9-]*\).*/\1/p')
+FAIL=$(printf '%s' "$SUMMARY" | sed -n 's/.*:fail \([0-9-]*\).*/\1/p')
+ERR=$(printf '%s' "$SUMMARY" | sed -n 's/.*:error \([0-9-]*\).*/\1/p')
+TOTAL=$(printf '%s' "$SUMMARY" | sed -n 's/.*:total \([0-9-]*\).*/\1/p')
+CHUNK_COUNT=$(grep -c '^  "' "$CHUNKS_SX" || echo 0)
+TOTAL_AVAILABLE=$(grep -c '}T' "$PREPROC" || echo 0)
+
+NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+if [ -z "$PASS" ]; then
+  PASS=0; FAIL=0; ERR=0; TOTAL=0
+  NOTE="runner halted before completing (timeout or SX error)"
+else
+  NOTE="completed"
+fi
+
+PCT=0
+if [ "$TOTAL" -gt 0 ]; then
+  PCT=$((PASS * 100 / TOTAL))
+fi
+
+cat > "$OUT_JSON" <<JSON
+{
+  "source": "gerryjackson/forth2012-test-suite src/core.fr",
+  "generated_at": "$NOW",
+  "chunks_available": $TOTAL_AVAILABLE,
+  "chunks_fed": $CHUNK_COUNT,
+  "total": $TOTAL,
+  "pass": $PASS,
+  "fail": $FAIL,
+  "error": $ERR,
+  "percent": $PCT,
+  "note": "$NOTE"
+}
+JSON
+
+cat > "$OUT_MD" <<MD
+# Forth Hayes Core scoreboard
+
+| metric            | value |
+| ----------------- | ----: |
+| chunks available  | $TOTAL_AVAILABLE |
+| chunks fed        | $CHUNK_COUNT |
+| total             | $TOTAL |
+| pass              | $PASS |
+| fail              | $FAIL |
+| error             | $ERR |
+| percent           | ${PCT}% |
+
+- **Source**: \`gerryjackson/forth2012-test-suite\` \`src/core.fr\`
+- **Generated**: $NOW
+- **Note**: $NOTE
+
+A "chunk" is any preprocessed segment ending at a \`}T\` (every Hayes test
+is one chunk, plus the small declaration blocks between tests).
+The runner catches raised errors at chunk boundaries so one bad chunk
+does not abort the rest. \`error\` covers chunks that raised; \`fail\`
+covers tests whose \`->\` / \`}T\` comparison mismatched.
+
+### Chunk cap
+
+\`conformance.sh\` processes the first \`\$MAX_CHUNKS\` chunks (default
+**638**, i.e. the whole Hayes Core file). Lower the cap temporarily
+while iterating on primitives if a regression re-opens an infinite
+loop in later tests.
+MD
+
+echo "$SUMMARY"
+echo "Scoreboard: $OUT_JSON"
+echo "           $OUT_MD"
+
+if [ "$STATUS" -ne 0 ] && [ "$TOTAL" -eq 0 ]; then
+  exit 1
+fi

lib/forth/hayes-runner.sx

@@ -0,0 +1,134 @@
+;; Hayes conformance test runner.
+;; Installs T{ -> }T as Forth primitives that snapshot and compare dstack,
+;; plus stub TESTING / HEX / DECIMAL so the Hayes Core file can stream
+;; through the interpreter without halting on unsupported metadata words.
+
+(define hayes-pass 0)
+(define hayes-fail 0)
+(define hayes-error 0)
+(define hayes-start-depth 0)
+(define hayes-actual (list))
+(define hayes-actual-set false)
+(define hayes-failures (list))
+(define hayes-first-error "")
+
+(define
+  hayes-reset!
+  (fn
+    ()
+    (set! hayes-pass 0)
+    (set! hayes-fail 0)
+    (set! hayes-error 0)
+    (set! hayes-start-depth 0)
+    (set! hayes-actual (list))
+    (set! hayes-actual-set false)
+    (set! hayes-failures (list))
+    (set! hayes-first-error "")))
+
+(define
+  hayes-slice
+  (fn
+    (state base)
+    (let
+      ((n (- (forth-depth state) base)))
+      (if (<= n 0) (list) (take (get state "dstack") n)))))
+
+(define
+  hayes-truncate!
+  (fn
+    (state base)
+    (let
+      ((n (- (forth-depth state) base)))
+      (when (> n 0) (dict-set! state "dstack" (drop (get state "dstack") n))))))
+
+(define
+  hayes-install!
+  (fn
+    (state)
+    (forth-def-prim!
+      state
+      "T{"
+      (fn
+        (s)
+        (set! hayes-start-depth (forth-depth s))
+        (set! hayes-actual-set false)
+        (set! hayes-actual (list))))
+    (forth-def-prim!
+      state
+      "->"
+      (fn
+        (s)
+        (set! hayes-actual (hayes-slice s hayes-start-depth))
+        (set! hayes-actual-set true)
+        (hayes-truncate! s hayes-start-depth)))
+    (forth-def-prim!
+      state
+      "}T"
+      (fn
+        (s)
+        (let
+          ((expected (hayes-slice s hayes-start-depth)))
+          (hayes-truncate! s hayes-start-depth)
+          (if
+            (and hayes-actual-set (= expected hayes-actual))
+            (set! hayes-pass (+ hayes-pass 1))
+            (begin
+              (set! hayes-fail (+ hayes-fail 1))
+              (set!
+                hayes-failures
+                (concat
+                  hayes-failures
+                  (list
+                    (dict
+                      "kind"
+                      "fail"
+                      "expected"
+                      (str expected)
+                      "actual"
+                      (str hayes-actual))))))))))
+    (forth-def-prim! state "TESTING" (fn (s) nil))
+    ;; HEX/DECIMAL are real primitives now (runtime.sx) — no stub needed.
+    state))
+
+(define
+  hayes-boot
+  (fn () (let ((s (forth-boot))) (hayes-install! s) (hayes-reset!) s)))
+
+;; Run a single preprocessed chunk (string of Forth source) on the shared
+;; state. Catch any raised error and move on — the chunk boundary is a
+;; safe resume point.
+(define
+  hayes-run-chunk
+  (fn
+    (state src)
+    (guard
+      (err
+        ((= 1 1)
+          (begin
+            (set! hayes-error (+ hayes-error 1))
+            (when
+              (= (len hayes-first-error) 0)
+              (set! hayes-first-error (str err)))
+            (dict-set! state "dstack" (list))
+            (dict-set! state "rstack" (list))
+            (dict-set! state "compiling" false)
+            (dict-set! state "current-def" nil)
+            (dict-set! state "cstack" (list))
+            (dict-set! state "input" (list)))))
+      (forth-interpret state src))))
+
+(define
+  hayes-summary
+  (fn
+    ()
+    (dict
+      "pass"
+      hayes-pass
+      "fail"
+      hayes-fail
+      "error"
+      hayes-error
+      "total"
+      (+ (+ hayes-pass hayes-fail) hayes-error)
+      "first-error"
+      hayes-first-error)))

lib/forth/interpreter.sx

@@ -17,7 +17,7 @@
         (not (nil? w))
         (forth-execute-word state w)
         (let
-          ((n (forth-parse-number tok (get state "base"))))
+          ((n (forth-parse-number tok (get (get state "vars") "base"))))
           (if
             (not (nil? n))
             (forth-push state n)

lib/forth/runtime.sx

@@ -18,10 +18,122 @@
       (dict-set! s "output" "")
       (dict-set! s "compiling" false)
       (dict-set! s "current-def" nil)
-      (dict-set! s "base" 10)
       (dict-set! s "vars" (dict))
+      (dict-set! (get s "vars") "base" 10)
+      (dict-set! s "cstack" (list))
+      (dict-set! s "mem" (dict))
+      (dict-set! s "here" 0)
+      (dict-set! s "hold" (list))
+      (dict-set! s "files" (dict))
+      (dict-set! s "by-path" (dict))
+      (dict-set! s "next-fileid" 1)
       s)))
 
+(define
+  forth-mem-write!
+  (fn (state addr u) (dict-set! (get state "mem") (str addr) u)))
+
+(define
+  forth-mem-read
+  (fn
+    (state addr)
+    (or (get (get state "mem") (str addr)) 0)))
+
+(define
+  forth-alloc-bytes!
+  (fn
+    (state n)
+    (let
+      ((addr (get state "here")))
+      (dict-set! state "here" (+ addr n))
+      addr)))
+
+(define
+  forth-mem-write-string!
+  (fn
+    (state addr s)
+    (let
+      ((n (len s)))
+      (forth-mem-write-string-loop! state addr s 0 n))))
+
+(define
+  forth-mem-write-string-loop!
+  (fn
+    (state addr s i n)
+    (when
+      (< i n)
+      (begin
+        (forth-mem-write! state (+ addr i) (char-code (substr s i 1)))
+        (forth-mem-write-string-loop! state addr s (+ i 1) n)))))
+
+(define
+  forth-mem-read-string
+  (fn
+    (state addr n)
+    (forth-mem-read-string-loop state addr 0 n "")))
+
+(define
+  forth-mem-read-string-loop
+  (fn
+    (state addr i n acc)
+    (if
+      (>= i n)
+      acc
+      (forth-mem-read-string-loop
+        state
+        addr
+        (+ i 1)
+        n
+        (str acc (char-from-code (forth-mem-read state (+ addr i))))))))
+
+(define
+  forth-fill-loop
+  (fn
+    (state addr u char i)
+    (when
+      (< i u)
+      (begin
+        (forth-mem-write! state (+ addr i) char)
+        (forth-fill-loop state addr u char (+ i 1))))))
+
+(define
+  forth-cmove-loop
+  (fn
+    (state src dst u i)
+    (when
+      (< i u)
+      (begin
+        (forth-mem-write! state (+ dst i) (forth-mem-read state (+ src i)))
+        (forth-cmove-loop state src dst u (+ i 1))))))
+
+(define
+  forth-cmove-loop-desc
+  (fn
+    (state src dst u i)
+    (when
+      (>= i 0)
+      (begin
+        (forth-mem-write! state (+ dst i) (forth-mem-read state (+ src i)))
+        (forth-cmove-loop-desc state src dst u (- i 1))))))
+
+(define
+  forth-cpush
+  (fn (state v) (dict-set! state "cstack" (cons v (get state "cstack")))))
+
+(define
+  forth-cpop
+  (fn
+    (state)
+    (let
+      ((cs (get state "cstack")))
+      (if
+        (= (len cs) 0)
+        (forth-error state "control stack underflow")
+        (let
+          ((top (first cs)))
+          (dict-set! state "cstack" (rest cs))
+          top)))))
+
 (define
   forth-error
   (fn (state msg) (dict-set! state "error" msg) (raise msg)))
@@ -99,7 +211,8 @@
     (dict-set!
       (get state "dict")
       (downcase name)
-      (forth-make-word "primitive" body false))))
+      (forth-make-word "primitive" body false))
+    (dict-set! state "last-defined" name)))
 
 (define
   forth-def-prim-imm!
@@ -108,7 +221,8 @@
     (dict-set!
       (get state "dict")
       (downcase name)
-      (forth-make-word "primitive" body true))))
+      (forth-make-word "primitive" body true))
+    (dict-set! state "last-defined" name)))
 
 (define
   forth-lookup
@@ -166,6 +280,186 @@
 
 (define forth-bits-width 32)
 
+;; Truncate a number to the Forth 32-bit signed range (two's-complement).
+;; Used by arithmetic primitives so wrap-around matches ANS semantics and
+;; loop idioms that rely on MSB becoming 0 after enough shifts terminate.
+(define
+  forth-clip
+  (fn
+    (n)
+    (forth-from-unsigned
+      (forth-to-unsigned n forth-bits-width)
+      forth-bits-width)))
+
+;; Double-cell helpers. Single = 32-bit signed, double = 64-bit signed
+;; represented on the data stack as (lo, hi) where hi is on top.
+;; Reassembly converts the low cell as unsigned and the high cell as
+;; signed (signed) or as unsigned (unsigned), then combines.
+(define forth-2pow32 (pow 2 32))
+(define forth-2pow64 (pow 2 64))
+
+(define
+  forth-double-from-cells-u
+  (fn
+    (lo hi)
+    (+ (forth-to-unsigned lo 32) (* (forth-to-unsigned hi 32) forth-2pow32))))
+
+(define
+  forth-double-from-cells-s
+  (fn (lo hi) (+ (forth-to-unsigned lo 32) (* hi forth-2pow32))))
+
+(define
+  forth-double-push-u
+  (fn
+    (state d)
+    (let
+      ((lo (mod d forth-2pow32)) (hi (floor (/ d forth-2pow32))))
+      (forth-push state (forth-from-unsigned lo 32))
+      (forth-push state (forth-from-unsigned hi 32)))))
+
+(define
+  forth-num-to-string-loop
+  (fn
+    (u base acc)
+    (if
+      (= u 0)
+      acc
+      (let
+        ((dig (mod u base)) (rest (floor (/ u base))))
+        (let
+          ((ch
+            (if
+              (< dig 10)
+              (char-from-code (+ 48 dig))
+              (char-from-code (+ 55 dig)))))
+          (forth-num-to-string-loop rest base (str ch acc)))))))
+
+(define
+  forth-num-to-string
+  (fn
+    (u base)
+    (if (= u 0) "0" (forth-num-to-string-loop u base ""))))
+
+(define
+  forth-spaces-str
+  (fn
+    (n)
+    (if (<= n 0) "" (str " " (forth-spaces-str (- n 1))))))
+
+(define
+  forth-join-hold
+  (fn
+    (parts)
+    (forth-join-hold-loop parts "")))
+
+(define
+  forth-join-hold-loop
+  (fn
+    (parts acc)
+    (if
+      (= (len parts) 0)
+      acc
+      (forth-join-hold-loop (rest parts) (str acc (first parts))))))
+
+(define
+  forth-pic-step
+  (fn
+    (state)
+    (let
+      ((hi (forth-pop state)) (lo (forth-pop state)))
+      (let
+        ((d (forth-double-from-cells-u lo hi))
+          (b (get (get state "vars") "base")))
+        (let
+          ((dig (mod d b)) (rest (floor (/ d b))))
+          (let
+            ((ch
+              (if
+                (< dig 10)
+                (char-from-code (+ 48 dig))
+                (char-from-code (+ 55 dig)))))
+            (dict-set! state "hold" (cons ch (get state "hold")))
+            (forth-double-push-u state rest)))))))
+
+(define
+  forth-compare-bytes-loop
+  (fn
+    (state a1 u1 a2 u2 i)
+    (cond
+      ((and (= i u1) (= i u2)) 0)
+      ((= i u1) -1)
+      ((= i u2) 1)
+      (else
+        (let
+          ((b1 (forth-mem-read state (+ a1 i)))
+            (b2 (forth-mem-read state (+ a2 i))))
+          (cond
+            ((< b1 b2) -1)
+            ((> b1 b2) 1)
+            (else (forth-compare-bytes-loop state a1 u1 a2 u2 (+ i 1)))))))))
+
+(define
+  forth-match-at
+  (fn
+    (state a1 start a2 u2 j)
+    (cond
+      ((= j u2) true)
+      ((not
+        (=
+          (forth-mem-read state (+ a1 (+ start j)))
+          (forth-mem-read state (+ a2 j))))
+        false)
+      (else (forth-match-at state a1 start a2 u2 (+ j 1))))))
+
+(define
+  forth-search-bytes
+  (fn
+    (state a1 u1 a2 u2 i)
+    (cond
+      ((= u2 0) 0)
+      ((> (+ i u2) u1) -1)
+      ((forth-match-at state a1 i a2 u2 0) i)
+      (else (forth-search-bytes state a1 u1 a2 u2 (+ i 1))))))
+
+(define
+  forth-pic-S-loop
+  (fn
+    (state)
+    (forth-pic-step state)
+    (let
+      ((hi (forth-pop state)) (lo (forth-pop state)))
+      (if
+        (and (= lo 0) (= hi 0))
+        (begin (forth-push state 0) (forth-push state 0))
+        (begin
+          (forth-push state lo)
+          (forth-push state hi)
+          (forth-pic-S-loop state))))))
+
+(define
+  forth-double-push-s
+  (fn
+    (state d)
+    (if
+      (>= d 0)
+      (forth-double-push-u state d)
+      (let
+        ((q (- 0 d)))
+        (let
+          ((qlo (mod q forth-2pow32)) (qhi (floor (/ q forth-2pow32))))
+          (if
+            (= qlo 0)
+            (begin
+              (forth-push state 0)
+              (forth-push state (forth-from-unsigned (- forth-2pow32 qhi) 32)))
+            (begin
+              (forth-push
+                state
+                (forth-from-unsigned (- forth-2pow32 qlo) 32))
+              (forth-push
+                state
+                (forth-from-unsigned (- (- forth-2pow32 qhi) 1) 32)))))))))
+
 (define
   forth-to-unsigned
   (fn (n w) (let ((m (pow 2 w))) (mod (+ (mod n m) m) m))))
@@ -285,6 +579,19 @@
         (s)
         (let ((a (forth-peek s))) (when (not (= a 0)) (forth-push s a)))))
     (forth-def-prim! state "DEPTH" (fn (s) (forth-push s (forth-depth s))))
+    (forth-def-prim! state "SP@" (fn (s) (forth-push s (forth-depth s))))
+    (forth-def-prim!
+      state
+      "SP!"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)))
+          (let
+            ((cur (forth-depth s)))
+            (when
+              (> cur n)
+              (dict-set! s "dstack" (drop (get s "dstack") (- cur n))))))))
     (forth-def-prim!
       state
       "PICK"
@@ -354,11 +661,17 @@
           (forth-push s d)
           (forth-push s a)
           (forth-push s b))))
-    (forth-def-prim! state "+" (forth-binop (fn (a b) (+ a b))))
+    (forth-def-prim! state "+" (forth-binop (fn (a b) (forth-clip (+ a b)))))
-    (forth-def-prim! state "-" (forth-binop (fn (a b) (- a b))))
+    (forth-def-prim! state "-" (forth-binop (fn (a b) (forth-clip (- a b)))))
-    (forth-def-prim! state "*" (forth-binop (fn (a b) (* a b))))
+    (forth-def-prim! state "*" (forth-binop (fn (a b) (forth-clip (* a b)))))
-    (forth-def-prim! state "/" (forth-binop forth-div))
+    (forth-def-prim!
-    (forth-def-prim! state "MOD" (forth-binop forth-mod))
+      state
+      "/"
+      (forth-binop (fn (a b) (forth-clip (forth-div a b)))))
+    (forth-def-prim!
+      state
+      "MOD"
+      (forth-binop (fn (a b) (forth-clip (forth-mod a b)))))
     (forth-def-prim!
       state
       "/MOD"
@@ -368,8 +681,8 @@
           ((b (forth-pop s)) (a (forth-pop s)))
           (forth-push s (forth-mod a b))
           (forth-push s (forth-div a b)))))
-    (forth-def-prim! state "NEGATE" (forth-unop (fn (a) (- 0 a))))
+    (forth-def-prim! state "NEGATE" (forth-unop (fn (a) (forth-clip (- 0 a)))))
-    (forth-def-prim! state "ABS" (forth-unop abs))
+    (forth-def-prim! state "ABS" (forth-unop (fn (a) (forth-clip (abs a)))))
     (forth-def-prim!
       state
       "MIN"
@@ -378,12 +691,15 @@
       state
       "MAX"
       (forth-binop (fn (a b) (if (> a b) a b))))
-    (forth-def-prim! state "1+" (forth-unop (fn (a) (+ a 1))))
+    (forth-def-prim! state "1+" (forth-unop (fn (a) (forth-clip (+ a 1)))))
-    (forth-def-prim! state "1-" (forth-unop (fn (a) (- a 1))))
+    (forth-def-prim! state "1-" (forth-unop (fn (a) (forth-clip (- a 1)))))
-    (forth-def-prim! state "2+" (forth-unop (fn (a) (+ a 2))))
+    (forth-def-prim! state "2+" (forth-unop (fn (a) (forth-clip (+ a 2)))))
-    (forth-def-prim! state "2-" (forth-unop (fn (a) (- a 2))))
+    (forth-def-prim! state "2-" (forth-unop (fn (a) (forth-clip (- a 2)))))
-    (forth-def-prim! state "2*" (forth-unop (fn (a) (* a 2))))
+    (forth-def-prim! state "2*" (forth-unop (fn (a) (forth-clip (* a 2)))))
-    (forth-def-prim! state "2/" (forth-unop (fn (a) (floor (/ a 2)))))
+    (forth-def-prim!
+      state
+      "2/"
+      (forth-unop (fn (a) (forth-clip (floor (/ a 2))))))
     (forth-def-prim! state "=" (forth-cmp (fn (a b) (= a b))))
     (forth-def-prim! state "<>" (forth-cmp (fn (a b) (not (= a b)))))
     (forth-def-prim! state "<" (forth-cmp (fn (a b) (< a b))))
@@ -398,6 +714,30 @@
     (forth-def-prim! state "OR" (forth-binop forth-bit-or))
     (forth-def-prim! state "XOR" (forth-binop forth-bit-xor))
     (forth-def-prim! state "INVERT" (forth-unop forth-bit-invert))
+    (forth-def-prim!
+      state
+      "LSHIFT"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (x (forth-pop s)))
+          (let
+            ((ux (forth-to-unsigned x forth-bits-width)))
+            (let
+              ((res (mod (* ux (pow 2 u)) (pow 2 forth-bits-width))))
+              (forth-push s (forth-from-unsigned res forth-bits-width)))))))
+    (forth-def-prim!
+      state
+      "RSHIFT"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (x (forth-pop s)))
+          (let
+            ((ux (forth-to-unsigned x forth-bits-width)))
+            (let
+              ((res (floor (/ ux (pow 2 u)))))
+              (forth-push s (forth-from-unsigned res forth-bits-width)))))))
     (forth-def-prim!
       state
       "."
@@ -416,7 +756,7 @@
     (forth-def-prim!
       state
       "EMIT"
-      (fn (s) (forth-emit-str s (code-char (forth-pop s)))))
+      (fn (s) (forth-emit-str s (char-from-code (forth-pop s)))))
     (forth-def-prim! state "CR" (fn (s) (forth-emit-str s "\n")))
     (forth-def-prim! state "SPACE" (fn (s) (forth-emit-str s " ")))
     (forth-def-prim!
@@ -430,4 +770,459 @@
             (> n 0)
             (for-each (fn (_) (forth-emit-str s " ")) (range 0 n))))))
     (forth-def-prim! state "BL" (fn (s) (forth-push s 32)))
+    (forth-def-prim!
+      state
+      "DECIMAL"
+      (fn (s) (dict-set! (get s "vars") "base" 10)))
+    (forth-def-prim!
+      state
+      "HEX"
+      (fn (s) (dict-set! (get s "vars") "base" 16)))
+    (forth-def-prim!
+      state
+      "OCTAL"
+      (fn (s) (dict-set! (get s "vars") "base" 8)))
+    (forth-def-prim! state "BASE" (fn (s) (forth-push s "base")))
+    (forth-def-prim! state "I" (fn (s) (forth-push s (forth-rpeek s))))
+    (forth-def-prim!
+      state
+      "J"
+      (fn (s) (forth-push s (nth (get s "rstack") 2))))
+    (forth-def-prim! state ">R" (fn (s) (forth-rpush s (forth-pop s))))
+    (forth-def-prim! state "R>" (fn (s) (forth-push s (forth-rpop s))))
+    (forth-def-prim! state "R@" (fn (s) (forth-push s (forth-rpeek s))))
+    (forth-def-prim!
+      state
+      "2>R"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-rpush s a)
+          (forth-rpush s b))))
+    (forth-def-prim!
+      state
+      "2R>"
+      (fn
+        (s)
+        (let
+          ((b (forth-rpop s)) (a (forth-rpop s)))
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim!
+      state
+      "2R@"
+      (fn
+        (s)
+        (let
+          ((rs (get s "rstack")))
+          (when
+            (< (len rs) 2)
+            (forth-error s "return stack underflow"))
+          (forth-push s (nth rs 1))
+          (forth-push s (nth rs 0)))))
+    (forth-def-prim!
+      state
+      "C@"
+      (fn
+        (s)
+        (let ((addr (forth-pop s))) (forth-push s (forth-mem-read s addr)))))
+    (forth-def-prim!
+      state
+      "C!"
+      (fn
+        (s)
+        (let
+          ((addr (forth-pop s)) (v (forth-pop s)))
+          (forth-mem-write! s addr v))))
+    (forth-def-prim! state "CHAR+" (fn (s) (forth-push s (+ (forth-pop s) 1))))
+    (forth-def-prim! state "CHARS" (fn (s) nil))
+    (forth-def-prim!
+      state
+      "TYPE"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (addr (forth-pop s)))
+          (forth-emit-str s (forth-mem-read-string s addr u)))))
+    (forth-def-prim!
+      state
+      "COUNT"
+      (fn
+        (s)
+        (let
+          ((addr (forth-pop s)))
+          (let
+            ((u (forth-mem-read s addr)))
+            (forth-push s (+ addr 1))
+            (forth-push s u)))))
+    (forth-def-prim!
+      state
+      "FILL"
+      (fn
+        (s)
+        (let
+          ((char (forth-pop s)) (u (forth-pop s)) (addr (forth-pop s)))
+          (forth-fill-loop s addr u char 0))))
+    (forth-def-prim!
+      state
+      "BLANK"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (addr (forth-pop s)))
+          (forth-fill-loop s addr u 32 0))))
+    (forth-def-prim!
+      state
+      "CMOVE"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (dst (forth-pop s)) (src (forth-pop s)))
+          (forth-cmove-loop s src dst u 0))))
+    (forth-def-prim!
+      state
+      "CMOVE>"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (dst (forth-pop s)) (src (forth-pop s)))
+          (forth-cmove-loop-desc s src dst u (- u 1)))))
+    (forth-def-prim!
+      state
+      "MOVE"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (dst (forth-pop s)) (src (forth-pop s)))
+          (if
+            (or (<= dst src) (>= dst (+ src u)))
+            (forth-cmove-loop s src dst u 0)
+            (forth-cmove-loop-desc s src dst u (- u 1))))))
+    (forth-def-prim!
+      state
+      "S>D"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)))
+          (forth-push s n)
+          (forth-push s (if (< n 0) -1 0)))))
+    (forth-def-prim! state "D>S" (fn (s) (forth-pop s)))
+    (forth-def-prim!
+      state
+      "M*"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-double-push-s s (* a b)))))
+    (forth-def-prim!
+      state
+      "UM*"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-double-push-u
+            s
+            (* (forth-to-unsigned a 32) (forth-to-unsigned b 32))))))
+    (forth-def-prim!
+      state
+      "UM/MOD"
+      (fn
+        (s)
+        (let
+          ((u1 (forth-pop s)) (hi (forth-pop s)) (lo (forth-pop s)))
+          (let
+            ((d (forth-double-from-cells-u lo hi))
+              (divisor (forth-to-unsigned u1 32)))
+            (when (= divisor 0) (forth-error s "division by zero"))
+            (let
+              ((q (floor (/ d divisor))) (r (mod d divisor)))
+              (forth-push s (forth-from-unsigned r 32))
+              (forth-push s (forth-from-unsigned q 32)))))))
+    (forth-def-prim!
+      state
+      "FM/MOD"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)) (hi (forth-pop s)) (lo (forth-pop s)))
+          (let
+            ((d (forth-double-from-cells-s lo hi)))
+            (when (= n 0) (forth-error s "division by zero"))
+            (let
+              ((q (floor (/ d n))))
+              (let
+                ((r (- d (* q n))))
+                (forth-push s (forth-clip r))
+                (forth-push s (forth-clip q))))))))
+    (forth-def-prim!
+      state
+      "SM/REM"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)) (hi (forth-pop s)) (lo (forth-pop s)))
+          (let
+            ((d (forth-double-from-cells-s lo hi)))
+            (when (= n 0) (forth-error s "division by zero"))
+            (let
+              ((q (forth-trunc (/ d n))))
+              (let
+                ((r (- d (* q n))))
+                (forth-push s (forth-clip r))
+                (forth-push s (forth-clip q))))))))
+    (forth-def-prim!
+      state
+      "*/"
+      (fn
+        (s)
+        (let
+          ((n3 (forth-pop s)) (n2 (forth-pop s)) (n1 (forth-pop s)))
+          (when (= n3 0) (forth-error s "division by zero"))
+          (forth-push s (forth-clip (forth-trunc (/ (* n1 n2) n3)))))))
+    (forth-def-prim!
+      state
+      "*/MOD"
+      (fn
+        (s)
+        (let
+          ((n3 (forth-pop s)) (n2 (forth-pop s)) (n1 (forth-pop s)))
+          (when (= n3 0) (forth-error s "division by zero"))
+          (let
+            ((d (* n1 n2)))
+            (let
+              ((q (forth-trunc (/ d n3))))
+              (let
+                ((r (- d (* q n3))))
+                (forth-push s (forth-clip r))
+                (forth-push s (forth-clip q))))))))
+    (forth-def-prim!
+      state
+      "D+"
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (forth-double-push-s
+            s
+            (+
+              (forth-double-from-cells-s lo1 hi1)
+              (forth-double-from-cells-s lo2 hi2))))))
+    (forth-def-prim!
+      state
+      "D-"
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (forth-double-push-s
+            s
+            (-
+              (forth-double-from-cells-s lo1 hi1)
+              (forth-double-from-cells-s lo2 hi2))))))
+    (forth-def-prim!
+      state
+      "DNEGATE"
+      (fn
+        (s)
+        (let
+          ((hi (forth-pop s)) (lo (forth-pop s)))
+          (forth-double-push-s
+            s
+            (- 0 (forth-double-from-cells-s lo hi))))))
+    (forth-def-prim!
+      state
+      "DABS"
+      (fn
+        (s)
+        (let
+          ((hi (forth-pop s)) (lo (forth-pop s)))
+          (forth-double-push-s s (abs (forth-double-from-cells-s lo hi))))))
+    (forth-def-prim!
+      state
+      "D="
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (forth-push s (if (and (= lo1 lo2) (= hi1 hi2)) -1 0)))))
+    (forth-def-prim!
+      state
+      "D<"
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (forth-push
+            s
+            (if
+              (<
+                (forth-double-from-cells-s lo1 hi1)
+                (forth-double-from-cells-s lo2 hi2))
+              -1
+              0)))))
+    (forth-def-prim!
+      state
+      "D0="
+      (fn
+        (s)
+        (let
+          ((hi (forth-pop s)) (lo (forth-pop s)))
+          (forth-push s (if (and (= lo 0) (= hi 0)) -1 0)))))
+    (forth-def-prim!
+      state
+      "D0<"
+      (fn
+        (s)
+        (let
+          ((hi (forth-pop s)) (lo (forth-pop s)))
+          (forth-push s (if (< hi 0) -1 0)))))
+    (forth-def-prim!
+      state
+      "DMAX"
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (let
+            ((d1 (forth-double-from-cells-s lo1 hi1))
+              (d2 (forth-double-from-cells-s lo2 hi2)))
+            (forth-double-push-s s (if (> d1 d2) d1 d2))))))
+    (forth-def-prim!
+      state
+      "DMIN"
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (let
+            ((d1 (forth-double-from-cells-s lo1 hi1))
+              (d2 (forth-double-from-cells-s lo2 hi2)))
+            (forth-double-push-s s (if (< d1 d2) d1 d2))))))
+    (forth-def-prim! state "<#" (fn (s) (dict-set! s "hold" (list))))
+    (forth-def-prim!
+      state
+      "HOLD"
+      (fn
+        (s)
+        (let
+          ((c (forth-pop s)))
+          (dict-set!
+            s
+            "hold"
+            (cons (char-from-code c) (get s "hold"))))))
+    (forth-def-prim!
+      state
+      "SIGN"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)))
+          (when
+            (< n 0)
+            (dict-set! s "hold" (cons "-" (get s "hold")))))))
+    (forth-def-prim!
+      state
+      "#"
+      (fn
+        (s)
+        (let
+          ((hi (forth-pop s)) (lo (forth-pop s)))
+          (let
+            ((d (forth-double-from-cells-u lo hi))
+              (b (get (get s "vars") "base")))
+            (let
+              ((dig (mod d b)) (rest (floor (/ d b))))
+              (let
+                ((ch
+                  (if
+                    (< dig 10)
+                    (char-from-code (+ 48 dig))
+                    (char-from-code (+ 55 dig)))))
+                (dict-set! s "hold" (cons ch (get s "hold")))
+                (forth-double-push-u s rest)))))))
+    (forth-def-prim!
+      state
+      "#S"
+      (fn
+        (s)
+        (forth-pic-S-loop s)))
+    (forth-def-prim!
+      state
+      "#>"
+      (fn
+        (s)
+        (forth-pop s)
+        (forth-pop s)
+        (let
+          ((str-out (forth-join-hold (get s "hold"))))
+          (let
+            ((addr (forth-alloc-bytes! s (len str-out))))
+            (forth-mem-write-string! s addr str-out)
+            (forth-push s addr)
+            (forth-push s (len str-out))))))
+    (forth-def-prim!
+      state
+      "U."
+      (fn
+        (s)
+        (let
+          ((u (forth-to-unsigned (forth-pop s) 32))
+            (b (get (get s "vars") "base")))
+          (forth-emit-str s (str (forth-num-to-string u b) " ")))))
+    (forth-def-prim!
+      state
+      "U.R"
+      (fn
+        (s)
+        (let
+          ((width (forth-pop s))
+            (u (forth-to-unsigned (forth-pop s) 32))
+            (b (get (get s "vars") "base")))
+          (let
+            ((digits (forth-num-to-string u b)))
+            (forth-emit-str
+              s
+              (forth-spaces-str (- width (len digits))))
+            (forth-emit-str s digits)))))
+    (forth-def-prim!
+      state
+      ".R"
+      (fn
+        (s)
+        (let
+          ((width (forth-pop s))
+            (n (forth-pop s))
+            (b (get (get s "vars") "base")))
+          (let
+            ((sign-prefix (if (< n 0) "-" ""))
+              (abs-digits
+                (forth-num-to-string (forth-to-unsigned (abs n) 32) b)))
+            (let
+              ((digits (str sign-prefix abs-digits)))
+              (forth-emit-str
+                s
+                (forth-spaces-str (- width (len digits))))
+              (forth-emit-str s digits))))))
     state))

lib/forth/scoreboard.json

@@ -0,0 +1,12 @@
+{
+  "source": "gerryjackson/forth2012-test-suite src/core.fr",
+  "generated_at": "2026-04-25T02:53:26Z",
+  "chunks_available": 638,
+  "chunks_fed": 638,
+  "total": 638,
+  "pass": 486,
+  "fail": 14,
+  "error": 138,
+  "percent": 76,
+  "note": "completed"
+}

lib/forth/scoreboard.md

@@ -0,0 +1,28 @@
+# Forth Hayes Core scoreboard
+
+| metric            | value |
+| ----------------- | ----: |
+| chunks available  | 638 |
+| chunks fed        | 638 |
+| total             | 638 |
+| pass              | 486 |
+| fail              | 14 |
+| error             | 138 |
+| percent           | 76% |
+
+- **Source**: `gerryjackson/forth2012-test-suite` `src/core.fr`
+- **Generated**: 2026-04-25T02:53:26Z
+- **Note**: completed
+
+A "chunk" is any preprocessed segment ending at a `}T` (every Hayes test
+is one chunk, plus the small declaration blocks between tests).
+The runner catches raised errors at chunk boundaries so one bad chunk
+does not abort the rest. `error` covers chunks that raised; `fail`
+covers tests whose `->` / `}T` comparison mismatched.
+
+### Chunk cap
+
+`conformance.sh` processes the first `$MAX_CHUNKS` chunks (default
+**638**, i.e. the whole Hayes Core file). Lower the cap temporarily
+while iterating on primitives if a regression re-opens an infinite
+loop in later tests.

lib/forth/tests/test-phase3.sx

@@ -0,0 +1,239 @@
+;; Phase 3 — control flow (IF/ELSE/THEN, BEGIN/UNTIL/WHILE/REPEAT/AGAIN,
+;; DO/LOOP, return stack). Grows as each control construct lands.
+
+(define forth-p3-passed 0)
+(define forth-p3-failed 0)
+(define forth-p3-failures (list))
+
+(define
+  forth-p3-assert
+  (fn
+    (label expected actual)
+    (if
+      (= expected actual)
+      (set! forth-p3-passed (+ forth-p3-passed 1))
+      (begin
+        (set! forth-p3-failed (+ forth-p3-failed 1))
+        (set!
+          forth-p3-failures
+          (concat
+            forth-p3-failures
+            (list
+              (str label ": expected " (str expected) " got " (str actual)))))))))
+
+(define
+  forth-p3-check-stack
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p3-assert label expected (nth r 2)))))
+
+(define
+  forth-p3-if-tests
+  (fn
+    ()
+    (forth-p3-check-stack
+      "IF taken (-1)"
+      ": Q -1 IF 10 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF not taken (0)"
+      ": Q 0 IF 10 THEN ; Q"
+      (list))
+    (forth-p3-check-stack
+      "IF with non-zero truthy"
+      ": Q 42 IF 10 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF ELSE — true branch"
+      ": Q -1 IF 10 ELSE 20 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF ELSE — false branch"
+      ": Q 0 IF 10 ELSE 20 THEN ; Q"
+      (list 20))
+    (forth-p3-check-stack
+      "IF consumes flag"
+      ": Q IF 1 ELSE 2 THEN ; 0 Q"
+      (list 2))
+    (forth-p3-check-stack
+      "absolute value via IF"
+      ": ABS2 DUP 0 < IF NEGATE THEN ; -7 ABS2"
+      (list 7))
+    (forth-p3-check-stack
+      "abs leaves positive alone"
+      ": ABS2 DUP 0 < IF NEGATE THEN ; 7 ABS2"
+      (list 7))
+    (forth-p3-check-stack
+      "sign: negative"
+      ": SIGN DUP 0 < IF DROP -1 ELSE DROP 1 THEN ; -3 SIGN"
+      (list -1))
+    (forth-p3-check-stack
+      "sign: positive"
+      ": SIGN DUP 0 < IF DROP -1 ELSE DROP 1 THEN ; 3 SIGN"
+      (list 1))
+    (forth-p3-check-stack
+      "nested IF (both true)"
+      ": Q 1 IF 1 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "nested IF (inner false)"
+      ": Q 1 IF 0 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
+      (list 20))
+    (forth-p3-check-stack
+      "nested IF (outer false)"
+      ": Q 0 IF 0 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
+      (list 30))
+    (forth-p3-check-stack
+      "IF before other ops"
+      ": Q 1 IF 5 ELSE 6 THEN 2 * ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF in chained def"
+      ": POS? 0 > ;
+       : DOUBLE-IF-POS DUP POS? IF 2 * THEN ;
+       3 DOUBLE-IF-POS"
+      (list 6))
+    (forth-p3-check-stack
+      "empty then branch"
+      ": Q 1 IF THEN 99 ; Q"
+      (list 99))
+    (forth-p3-check-stack
+      "empty else branch"
+      ": Q 0 IF 99 ELSE THEN ; Q"
+      (list))
+    (forth-p3-check-stack
+      "sequential IF blocks"
+      ": Q -1 IF 1 THEN -1 IF 2 THEN ; Q"
+      (list 1 2))))
+
+(define
+  forth-p3-loop-tests
+  (fn
+    ()
+    (forth-p3-check-stack
+      "BEGIN UNTIL (countdown to zero)"
+      ": CD BEGIN 1- DUP 0 = UNTIL ; 3 CD"
+      (list 0))
+    (forth-p3-check-stack
+      "BEGIN UNTIL — single pass (UNTIL true immediately)"
+      ": Q BEGIN -1 UNTIL 42 ; Q"
+      (list 42))
+    (forth-p3-check-stack
+      "BEGIN UNTIL — accumulate sum 1+2+3"
+      ": SUM3 0 3 BEGIN TUCK + SWAP 1- DUP 0 = UNTIL DROP ; SUM3"
+      (list 6))
+    (forth-p3-check-stack
+      "BEGIN WHILE REPEAT — triangular sum 5"
+      ": TRI 0 5 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
+      (list 15))
+    (forth-p3-check-stack
+      "BEGIN WHILE REPEAT — zero iterations"
+      ": TRI 0 0 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
+      (list 0))
+    (forth-p3-check-stack
+      "BEGIN WHILE REPEAT — one iteration"
+      ": TRI 0 1 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
+      (list 1))
+    (forth-p3-check-stack
+      "nested BEGIN UNTIL"
+      ": INNER BEGIN 1- DUP 0 = UNTIL DROP ;
+       : OUTER BEGIN 3 INNER 1- DUP 0 = UNTIL ;
+       2 OUTER"
+      (list 0))
+    (forth-p3-check-stack
+      "BEGIN UNTIL after colon prefix"
+      ": TEN 10 ;
+       : CD TEN BEGIN 1- DUP 0 = UNTIL ;
+       CD"
+      (list 0))
+    (forth-p3-check-stack
+      "WHILE inside IF branch"
+      ": Q 1 IF 0 3 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ELSE 99 THEN ; Q"
+      (list 6))))
+
+(define
+  forth-p3-do-tests
+  (fn
+    ()
+    (forth-p3-check-stack
+      "DO LOOP — simple sum 0..4"
+      ": SUM 0 5 0 DO I + LOOP ; SUM"
+      (list 10))
+    (forth-p3-check-stack
+      "DO LOOP — 10..14 sum using I"
+      ": SUM 0 15 10 DO I + LOOP ; SUM"
+      (list 60))
+    (forth-p3-check-stack
+      "DO LOOP — limit = start runs one pass"
+      ": SUM 0 5 5 DO I + LOOP ; SUM"
+      (list 5))
+    (forth-p3-check-stack
+      "DO LOOP — count iterations"
+      ": COUNT 0 4 0 DO 1+ LOOP ; COUNT"
+      (list 4))
+    (forth-p3-check-stack
+      "DO LOOP — nested, I inner / J outer"
+      ": MATRIX 0 3 0 DO 3 0 DO I J + + LOOP LOOP ; MATRIX"
+      (list 18))
+    (forth-p3-check-stack
+      "DO LOOP — I used in arithmetic"
+      ": DBL 0 5 1 DO I 2 * + LOOP ; DBL"
+      (list 20))
+    (forth-p3-check-stack
+      "+LOOP — count by 2"
+      ": Q 0 10 0 DO I + 2 +LOOP ; Q"
+      (list 20))
+    (forth-p3-check-stack
+      "+LOOP — count by 3"
+      ": Q 0 10 0 DO I + 3 +LOOP ; Q"
+      (list 18))
+    (forth-p3-check-stack
+      "+LOOP — negative step"
+      ": Q 0 0 10 DO I + -1 +LOOP ; Q"
+      (list 55))
+    (forth-p3-check-stack
+      "LEAVE — early exit at I=3"
+      ": Q 0 10 0 DO I 3 = IF LEAVE THEN I + LOOP ; Q"
+      (list 3))
+    (forth-p3-check-stack
+      "LEAVE — in nested loop exits only inner"
+      ": Q 0 3 0 DO 5 0 DO I 2 = IF LEAVE THEN I + LOOP LOOP ; Q"
+      (list 3))
+    (forth-p3-check-stack
+      "DO LOOP preserves outer stack"
+      ": Q 99 5 0 DO I + LOOP ; Q"
+      (list 109))
+    (forth-p3-check-stack
+      ">R R>"
+      ": Q 7 >R 11 R> ; Q"
+      (list 11 7))
+    (forth-p3-check-stack
+      ">R R@ R>"
+      ": Q 7 >R R@ R> ; Q"
+      (list 7 7))
+    (forth-p3-check-stack
+      "2>R 2R>"
+      ": Q 1 2 2>R 99 2R> ; Q"
+      (list 99 1 2))
+    (forth-p3-check-stack
+      "2>R 2R@ 2R>"
+      ": Q 3 4 2>R 2R@ 2R> ; Q"
+      (list 3 4 3 4))))
+
+(define
+  forth-p3-run-all
+  (fn
+    ()
+    (set! forth-p3-passed 0)
+    (set! forth-p3-failed 0)
+    (set! forth-p3-failures (list))
+    (forth-p3-if-tests)
+    (forth-p3-loop-tests)
+    (forth-p3-do-tests)
+    (dict
+      "passed"
+      forth-p3-passed
+      "failed"
+      forth-p3-failed
+      "failures"
+      forth-p3-failures)))

lib/forth/tests/test-phase4.sx

@@ -0,0 +1,268 @@
+;; Phase 4 — strings + more Core.
+;; Uses the byte-memory model on state ("mem" dict + "here" cursor).
+
+(define forth-p4-passed 0)
+(define forth-p4-failed 0)
+(define forth-p4-failures (list))
+
+(define
+  forth-p4-assert
+  (fn
+    (label expected actual)
+    (if
+      (= expected actual)
+      (set! forth-p4-passed (+ forth-p4-passed 1))
+      (begin
+        (set! forth-p4-failed (+ forth-p4-failed 1))
+        (set!
+          forth-p4-failures
+          (concat
+            forth-p4-failures
+            (list
+              (str label ": expected " (str expected) " got " (str actual)))))))))
+
+(define
+  forth-p4-check-output
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p4-assert label expected (nth r 1)))))
+
+(define
+  forth-p4-check-stack-size
+  (fn
+    (label src expected-n)
+    (let
+      ((r (forth-run src)))
+      (forth-p4-assert label expected-n (len (nth r 2))))))
+
+(define
+  forth-p4-check-top
+  (fn
+    (label src expected)
+    (let
+      ((r (forth-run src)))
+      (let
+        ((stk (nth r 2)))
+        (forth-p4-assert label expected (nth stk (- (len stk) 1)))))))
+
+(define
+  forth-p4-check-typed
+  (fn
+    (label src expected)
+    (forth-p4-check-output label (str src " TYPE") expected)))
+
+(define
+  forth-p4-string-tests
+  (fn
+    ()
+    (forth-p4-check-typed
+      "S\" + TYPE — hello"
+      "S\" HELLO\""
+      "HELLO")
+    (forth-p4-check-typed
+      "S\" + TYPE — two words"
+      "S\" HELLO WORLD\""
+      "HELLO WORLD")
+    (forth-p4-check-typed
+      "S\" + TYPE — empty"
+      "S\" \""
+      "")
+    (forth-p4-check-typed
+      "S\" + TYPE — single char"
+      "S\" X\""
+      "X")
+    (forth-p4-check-stack-size
+      "S\" pushes (addr len)"
+      "S\" HI\""
+      2)
+    (forth-p4-check-top
+      "S\" length is correct"
+      "S\" HELLO\""
+      5)
+    (forth-p4-check-output
+      ".\" prints at interpret time"
+      ".\" HELLO\""
+      "HELLO")
+    (forth-p4-check-output
+      ".\" in colon def"
+      ": GREET .\" HI \" ; GREET GREET"
+      "HI HI ")))
+
+(define
+  forth-p4-count-tests
+  (fn
+    ()
+    (forth-p4-check-typed
+      "C\" + COUNT + TYPE"
+      "C\" ABC\" COUNT"
+      "ABC")
+    (forth-p4-check-typed
+      "C\" then COUNT leaves right len"
+      "C\" HI THERE\" COUNT"
+      "HI THERE")))
+
+(define
+  forth-p4-fill-tests
+  (fn
+    ()
+    (forth-p4-check-typed
+      "FILL overwrites prefix bytes"
+      "S\" ABCDE\" 2DUP DROP 3 65 FILL"
+      "AAADE")
+    (forth-p4-check-typed
+      "BLANK sets spaces"
+      "S\" XYZAB\" 2DUP DROP 3 BLANK"
+      "   AB")))
+
+(define
+  forth-p4-cmove-tests
+  (fn
+    ()
+    (forth-p4-check-output
+      "CMOVE copies HELLO forward"
+      ": MKH 72 0 C! 69 1 C! 76 2 C! 76 3 C! 79 4 C! ;
+       : T MKH 0 10 5 CMOVE 10 5 TYPE ; T"
+      "HELLO")
+    (forth-p4-check-output
+      "CMOVE> copies overlapping backward"
+      ": MKA 65 0 C! 66 1 C! 67 2 C! ;
+       : T MKA 0 1 2 CMOVE> 0 3 TYPE ; T"
+      "AAB")
+    (forth-p4-check-output
+      "MOVE picks direction for overlap"
+      ": MKA 65 0 C! 66 1 C! 67 2 C! ;
+       : T MKA 0 1 2 MOVE 0 3 TYPE ; T"
+      "AAB")))
+
+(define
+  forth-p4-charplus-tests
+  (fn
+    ()
+    (forth-p4-check-top
+      "CHAR+ increments"
+      "5 CHAR+"
+      6)))
+
+(define
+  forth-p4-char-tests
+  (fn
+    ()
+    (forth-p4-check-top "CHAR A -> 65" "CHAR A" 65)
+    (forth-p4-check-top "CHAR x -> 120" "CHAR x" 120)
+    (forth-p4-check-top "CHAR takes only first char" "CHAR HELLO" 72)
+    (forth-p4-check-top
+      "[CHAR] compiles literal"
+      ": AA [CHAR] A ; AA"
+      65)
+    (forth-p4-check-top
+      "[CHAR] reads past IMMEDIATE"
+      ": ZZ [CHAR] Z ; ZZ"
+      90)
+    (forth-p4-check-stack-size
+      "[CHAR] doesn't leak at compile time"
+      ": FOO [CHAR] A ; "
+      0)))
+
+(define
+  forth-p4-key-accept-tests
+  (fn
+    ()
+    (let
+      ((r (forth-run "1000 2 ACCEPT")))
+      (let ((stk (nth r 2))) (forth-p4-assert "ACCEPT empty buf -> 0" (list 0) stk)))))
+
+(define
+  forth-p4-shift-tests
+  (fn
+    ()
+    (forth-p4-check-top "1 0 LSHIFT" "1 0 LSHIFT" 1)
+    (forth-p4-check-top "1 1 LSHIFT" "1 1 LSHIFT" 2)
+    (forth-p4-check-top "1 2 LSHIFT" "1 2 LSHIFT" 4)
+    (forth-p4-check-top "1 15 LSHIFT" "1 15 LSHIFT" 32768)
+    (forth-p4-check-top "1 31 LSHIFT" "1 31 LSHIFT" -2147483648)
+    (forth-p4-check-top "1 0 RSHIFT" "1 0 RSHIFT" 1)
+    (forth-p4-check-top "1 1 RSHIFT" "1 1 RSHIFT" 0)
+    (forth-p4-check-top "2 1 RSHIFT" "2 1 RSHIFT" 1)
+    (forth-p4-check-top "4 2 RSHIFT" "4 2 RSHIFT" 1)
+    (forth-p4-check-top "-1 1 RSHIFT (logical, not arithmetic)" "-1 1 RSHIFT" 2147483647)
+    (forth-p4-check-top "MSB via 1S 1 RSHIFT INVERT" "0 INVERT 1 RSHIFT INVERT" -2147483648)))
+
+(define
+  forth-p4-sp-tests
+  (fn
+    ()
+    (forth-p4-check-top "SP@ returns depth (0)" "SP@" 0)
+    (forth-p4-check-top
+      "SP@ after pushes"
+      "1 2 3 SP@ SWAP DROP SWAP DROP SWAP DROP"
+      3)
+    (forth-p4-check-stack-size
+      "SP! truncates"
+      "1 2 3 4 5 2 SP!"
+      2)
+    (forth-p4-check-top
+      "SP! leaves base items intact"
+      "1 2 3 4 5 2 SP!"
+      2)))
+
+(define
+  forth-p4-base-tests
+  (fn
+    ()
+    (forth-p4-check-top
+      "BASE default is 10"
+      "BASE @"
+      10)
+    (forth-p4-check-top
+      "HEX switches base to 16"
+      "HEX BASE @"
+      16)
+    (forth-p4-check-top
+      "DECIMAL resets to 10"
+      "HEX DECIMAL BASE @"
+      10)
+    (forth-p4-check-top
+      "HEX parses 10 as 16"
+      "HEX 10"
+      16)
+    (forth-p4-check-top
+      "HEX parses FF as 255"
+      "HEX FF"
+      255)
+    (forth-p4-check-top
+      "DECIMAL parses 10 as 10"
+      "HEX DECIMAL 10"
+      10)
+    (forth-p4-check-top
+      "OCTAL parses 17 as 15"
+      "OCTAL 17"
+      15)
+    (forth-p4-check-top
+      "BASE @ ; 16 BASE ! ; BASE @"
+      "BASE @ 16 BASE ! BASE @ SWAP DROP"
+      16)))
+
+(define
+  forth-p4-run-all
+  (fn
+    ()
+    (set! forth-p4-passed 0)
+    (set! forth-p4-failed 0)
+    (set! forth-p4-failures (list))
+    (forth-p4-string-tests)
+    (forth-p4-count-tests)
+    (forth-p4-fill-tests)
+    (forth-p4-cmove-tests)
+    (forth-p4-charplus-tests)
+    (forth-p4-char-tests)
+    (forth-p4-key-accept-tests)
+    (forth-p4-base-tests)
+    (forth-p4-shift-tests)
+    (forth-p4-sp-tests)
+    (dict
+      "passed"
+      forth-p4-passed
+      "failed"
+      forth-p4-failed
+      "failures"
+      forth-p4-failures)))

lib/forth/tests/test-phase5.sx

@@ -0,0 +1,333 @@
+;; Phase 5 — Core Extension + memory primitives.
+
+(define forth-p5-passed 0)
+(define forth-p5-failed 0)
+(define forth-p5-failures (list))
+
+(define
+  forth-p5-assert
+  (fn
+    (label expected actual)
+    (if
+      (= expected actual)
+      (set! forth-p5-passed (+ forth-p5-passed 1))
+      (begin
+        (set! forth-p5-failed (+ forth-p5-failed 1))
+        (set!
+          forth-p5-failures
+          (concat
+            forth-p5-failures
+            (list
+              (str label ": expected " (str expected) " got " (str actual)))))))))
+
+(define
+  forth-p5-check-stack
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p5-assert label expected (nth r 2)))))
+
+(define
+  forth-p5-check-top
+  (fn
+    (label src expected)
+    (let
+      ((r (forth-run src)))
+      (let
+        ((stk (nth r 2)))
+        (forth-p5-assert label expected (nth stk (- (len stk) 1)))))))
+
+(define
+  forth-p5-create-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "CREATE pushes HERE-at-creation"
+      "HERE CREATE FOO FOO ="
+      -1)
+    (forth-p5-check-top
+      "CREATE + ALLOT advances HERE"
+      "HERE 5 ALLOT HERE SWAP -"
+      5)
+    (forth-p5-check-top
+      "CREATE + , stores cell"
+      "CREATE FOO 42 , FOO @"
+      42)
+    (forth-p5-check-stack
+      "CREATE multiple ,"
+      "CREATE TBL 1 , 2 , 3 , TBL @ TBL CELL+ @ TBL CELL+ CELL+ @"
+      (list 1 2 3))
+    (forth-p5-check-top
+      "C, stores byte"
+      "CREATE B 65 C, 66 C, B C@"
+      65)))
+
+(define
+  forth-p5-unsigned-tests
+  (fn
+    ()
+    (forth-p5-check-top "1 2 U<" "1 2 U<" -1)
+    (forth-p5-check-top "2 1 U<" "2 1 U<" 0)
+    (forth-p5-check-top "0 1 U<" "0 1 U<" -1)
+    (forth-p5-check-top "-1 1 U< (since -1 unsigned is huge)" "-1 1 U<" 0)
+    (forth-p5-check-top "1 -1 U<" "1 -1 U<" -1)
+    (forth-p5-check-top "1 2 U>" "1 2 U>" 0)
+    (forth-p5-check-top "-1 1 U>" "-1 1 U>" -1)))
+
+(define
+  forth-p5-2bang-tests
+  (fn
+    ()
+    (forth-p5-check-stack
+      "2! / 2@"
+      "CREATE X 0 , 0 , 11 22 X 2! X 2@"
+      (list 11 22))))
+
+(define
+  forth-p5-mixed-tests
+  (fn
+    ()
+    (forth-p5-check-stack "S>D positive" "5 S>D" (list 5 0))
+    (forth-p5-check-stack "S>D negative" "-5 S>D" (list -5 -1))
+    (forth-p5-check-stack "S>D zero" "0 S>D" (list 0 0))
+    (forth-p5-check-top "D>S keeps low" "5 0 D>S" 5)
+    (forth-p5-check-stack "M* small positive" "3 4 M*" (list 12 0))
+    (forth-p5-check-stack "M* negative" "-3 4 M*" (list -12 -1))
+    (forth-p5-check-stack
+      "M* negative * negative"
+      "-3 -4 M*"
+      (list 12 0))
+    (forth-p5-check-stack "UM* small" "3 4 UM*" (list 12 0))
+    (forth-p5-check-stack
+      "UM/MOD: 100 0 / 5"
+      "100 0 5 UM/MOD"
+      (list 0 20))
+    (forth-p5-check-stack
+      "FM/MOD: -7 / 2 floored"
+      "-7 -1 2 FM/MOD"
+      (list 1 -4))
+    (forth-p5-check-stack
+      "SM/REM: -7 / 2 truncated"
+      "-7 -1 2 SM/REM"
+      (list -1 -3))
+    (forth-p5-check-top "*/ truncated" "7 11 13 */" 5)
+    (forth-p5-check-stack "*/MOD" "7 11 13 */MOD" (list 12 5))))
+
+(define
+  forth-p5-double-tests
+  (fn
+    ()
+    (forth-p5-check-stack "D+ small" "5 0 7 0 D+" (list 12 0))
+    (forth-p5-check-stack "D+ negative" "-5 -1 -3 -1 D+" (list -8 -1))
+    (forth-p5-check-stack "D- small" "10 0 3 0 D-" (list 7 0))
+    (forth-p5-check-stack "DNEGATE positive" "5 0 DNEGATE" (list -5 -1))
+    (forth-p5-check-stack "DNEGATE negative" "-5 -1 DNEGATE" (list 5 0))
+    (forth-p5-check-stack "DABS negative" "-7 -1 DABS" (list 7 0))
+    (forth-p5-check-stack "DABS positive" "7 0 DABS" (list 7 0))
+    (forth-p5-check-top "D= equal" "5 0 5 0 D=" -1)
+    (forth-p5-check-top "D= unequal lo" "5 0 7 0 D=" 0)
+    (forth-p5-check-top "D= unequal hi" "5 0 5 1 D=" 0)
+    (forth-p5-check-top "D< lt" "5 0 7 0 D<" -1)
+    (forth-p5-check-top "D< gt" "7 0 5 0 D<" 0)
+    (forth-p5-check-top "D0= zero" "0 0 D0=" -1)
+    (forth-p5-check-top "D0= nonzero" "5 0 D0=" 0)
+    (forth-p5-check-top "D0< neg" "-5 -1 D0<" -1)
+    (forth-p5-check-top "D0< pos" "5 0 D0<" 0)
+    (forth-p5-check-stack "DMAX" "5 0 7 0 DMAX" (list 7 0))
+    (forth-p5-check-stack "DMIN" "5 0 7 0 DMIN" (list 5 0))))
+
+(define
+  forth-p5-format-tests
+  (fn
+    ()
+    (forth-p4-check-output-passthrough
+      "U. prints with trailing space"
+      "123 U."
+      "123 ")
+    (forth-p4-check-output-passthrough
+      "<# #S #> TYPE — decimal"
+      "123 0 <# #S #> TYPE"
+      "123")
+    (forth-p4-check-output-passthrough
+      "<# #S #> TYPE — hex"
+      "255 HEX 0 <# #S #> TYPE"
+      "FF")
+    (forth-p4-check-output-passthrough
+      "<# # # #> partial"
+      "1234 0 <# # # #> TYPE"
+      "34")
+    (forth-p4-check-output-passthrough
+      "SIGN holds minus"
+      "<# -1 SIGN -1 SIGN 0 0 #> TYPE"
+      "--")
+    (forth-p4-check-output-passthrough
+      ".R right-justifies"
+      "42 5 .R"
+      "   42")
+    (forth-p4-check-output-passthrough
+      ".R negative"
+      "-42 5 .R"
+      "  -42")
+    (forth-p4-check-output-passthrough
+      "U.R"
+      "42 5 U.R"
+      "   42")
+    (forth-p4-check-output-passthrough
+      "HOLD char"
+      "<# 0 0 65 HOLD #> TYPE"
+      "A")))
+
+(define
+  forth-p5-dict-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "EXECUTE via tick"
+      ": INC 1+ ; 9 ' INC EXECUTE"
+      10)
+    (forth-p5-check-top
+      "['] inside def"
+      ": DUB 2* ; : APPLY ['] DUB EXECUTE ; 5 APPLY"
+      10)
+    (forth-p5-check-top
+      ">BODY of CREATE word"
+      "CREATE C 99 , ' C >BODY @"
+      99)
+    (forth-p5-check-stack
+      "WORD parses next token to counted-string"
+      ": A 5 ; BL WORD A COUNT TYPE"
+      (list))
+    (forth-p5-check-top
+      "FIND on known word -> non-zero"
+      ": A 5 ; BL WORD A FIND SWAP DROP"
+      -1)))
+
+(define
+  forth-p5-state-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "STATE @ in interpret mode"
+      "STATE @"
+      0)
+    (forth-p5-check-top
+      "STATE @ via IMMEDIATE inside compile"
+      ": GT8 STATE @ ; IMMEDIATE : T GT8 LITERAL ; T"
+      -1)
+    (forth-p5-check-top
+      "[ ] LITERAL captures"
+      ": SEVEN [ 7 ] LITERAL ; SEVEN"
+      7)
+    (forth-p5-check-top
+      "EVALUATE in interpret mode"
+      "S\" 5 7 +\" EVALUATE"
+      12)
+    (forth-p5-check-top
+      "EVALUATE inside def"
+      ": A 100 ; : B S\" A\" EVALUATE ; B"
+      100)))
+
+(define
+  forth-p5-misc-tests
+  (fn
+    ()
+    (forth-p5-check-top "WITHIN inclusive lower" "3 2 10 WITHIN" -1)
+    (forth-p5-check-top "WITHIN exclusive upper" "10 2 10 WITHIN" 0)
+    (forth-p5-check-top "WITHIN below range" "1 2 10 WITHIN" 0)
+    (forth-p5-check-top "WITHIN at lower" "2 2 10 WITHIN" -1)
+    (forth-p5-check-top
+      "EXIT leaves colon-def early"
+      ": F 5 EXIT 99 ; F"
+      5)
+    (forth-p5-check-stack
+      "EXIT in IF branch"
+      ": F 5 0 IF DROP 99 EXIT THEN ; F"
+      (list 5))
+    (forth-p5-check-top
+      "UNLOOP + EXIT in DO"
+      ": SUM 0 10 0 DO I 5 = IF I UNLOOP EXIT THEN LOOP ; SUM"
+      5)))
+
+(define
+  forth-p5-fa-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "R/O R/W W/O constants"
+      "R/O R/W W/O + +"
+      3)
+    (forth-p5-check-top
+      "CREATE-FILE returns ior=0"
+      "CREATE PAD 50 ALLOT PAD S\" /tmp/test.fxf\" ROT SWAP CMOVE S\" /tmp/test.fxf\" R/W CREATE-FILE SWAP DROP"
+      0)
+    (forth-p5-check-top
+      "WRITE-FILE then CLOSE"
+      "S\" /tmp/t2.fxf\" R/W CREATE-FILE DROP >R S\" HI\" R@ WRITE-FILE R> CLOSE-FILE +"
+      0)
+    (forth-p5-check-top
+      "OPEN-FILE on unknown path returns ior!=0"
+      "S\" /tmp/nope.fxf\" R/O OPEN-FILE SWAP DROP 0 ="
+      0)))
+
+(define
+  forth-p5-string-tests
+  (fn
+    ()
+    (forth-p5-check-top "COMPARE equal" "S\" ABC\" S\" ABC\" COMPARE" 0)
+    (forth-p5-check-top "COMPARE less" "S\" ABC\" S\" ABD\" COMPARE" -1)
+    (forth-p5-check-top "COMPARE greater" "S\" ABD\" S\" ABC\" COMPARE" 1)
+    (forth-p5-check-top
+      "COMPARE prefix less"
+      "S\" AB\" S\" ABC\" COMPARE"
+      -1)
+    (forth-p5-check-top
+      "COMPARE prefix greater"
+      "S\" ABC\" S\" AB\" COMPARE"
+      1)
+    (forth-p5-check-top
+      "SEARCH found flag"
+      "S\" HELLO WORLD\" S\" WORLD\" SEARCH"
+      -1)
+    (forth-p5-check-top
+      "SEARCH not found flag"
+      "S\" HELLO\" S\" XYZ\" SEARCH"
+      0)
+    (forth-p5-check-top
+      "SEARCH empty needle flag"
+      "S\" HELLO\" S\" \" SEARCH"
+      -1)
+    (forth-p5-check-top
+      "SLITERAL via [ S\" ... \" ]"
+      ": A [ S\" HI\" ] SLITERAL ; A SWAP DROP"
+      2)))
+
+(define
+  forth-p4-check-output-passthrough
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p5-assert label expected (nth r 1)))))
+
+(define
+  forth-p5-run-all
+  (fn
+    ()
+    (set! forth-p5-passed 0)
+    (set! forth-p5-failed 0)
+    (set! forth-p5-failures (list))
+    (forth-p5-create-tests)
+    (forth-p5-unsigned-tests)
+    (forth-p5-2bang-tests)
+    (forth-p5-mixed-tests)
+    (forth-p5-double-tests)
+    (forth-p5-format-tests)
+    (forth-p5-dict-tests)
+    (forth-p5-state-tests)
+    (forth-p5-misc-tests)
+    (forth-p5-fa-tests)
+    (forth-p5-string-tests)
+    (dict
+      "passed"
+      forth-p5-passed
+      "failed"
+      forth-p5-failed
+      "failures"
+      forth-p5-failures)))

lib/smalltalk/eval.sx

@@ -1,722 +0,0 @@
-;; Smalltalk AST evaluator — sequential semantics. Method dispatch uses the
-;; class table from runtime.sx; native receivers fall back to a primitive
-;; method table. Non-local return is implemented via a sentinel marker; the
-;; full continuation-based escape is the Phase 3 showcase.
-;;
-;; Frame:
-;;   {:self V                 ; receiver
-;;    :method-class N         ; defining class of the executing method
-;;    :locals (mutable dict)  ; param + temp bindings
-;;    :parent P}              ; outer frame for blocks (nil for top-level)
-;;
-;; `smalltalk-eval-ast(ast, frame)` returns the value or a return marker.
-;; Method invocation unwraps return markers; sequences propagate them.
-
-(define
-  st-make-frame
-  (fn
-    (self method-class parent)
-    {:self self :method-class method-class :locals {} :parent parent}))
-
-(define st-return-marker (fn (v) {:st-return true :value v}))
-
-(define
-  st-return-marker?
-  (fn (v) (and (dict? v) (has-key? v :st-return) (= (get v :st-return) true))))
-
-(define
-  st-make-block
-  (fn
-    (ast frame)
-    {:type "st-block"
-     :params (get ast :params)
-     :temps (get ast :temps)
-     :body (get ast :body)
-     :env frame}))
-
-(define
-  st-block?
-  (fn
-    (v)
-    (and (dict? v) (has-key? v :type) (= (get v :type) "st-block"))))
-
-(define
-  st-class-ref
-  (fn (name) {:type "st-class" :name name}))
-
-(define
-  st-class-ref?
-  (fn (v) (and (dict? v) (has-key? v :type) (= (get v :type) "st-class"))))
-
-;; Walk the frame chain looking for a local binding.
-(define
-  st-lookup-local
-  (fn
-    (frame name)
-    (cond
-      ((= frame nil) {:found false :value nil :frame nil})
-      ((has-key? (get frame :locals) name)
-        {:found true :value (get (get frame :locals) name) :frame frame})
-      (else (st-lookup-local (get frame :parent) name)))))
-
-;; Walk the frame chain looking for the frame whose self has this ivar.
-(define
-  st-lookup-ivar-frame
-  (fn
-    (frame name)
-    (cond
-      ((= frame nil) nil)
-      ((let ((self (get frame :self)))
-         (and (st-instance? self) (has-key? (get self :ivars) name)))
-        frame)
-      (else (st-lookup-ivar-frame (get frame :parent) name)))))
-
-;; Resolve an identifier in eval order: local → ivar → class → error.
-(define
-  st-resolve-ident
-  (fn
-    (frame name)
-    (let
-      ((local-result (st-lookup-local frame name)))
-      (cond
-        ((get local-result :found) (get local-result :value))
-        (else
-          (let
-            ((iv-frame (st-lookup-ivar-frame frame name)))
-            (cond
-              ((not (= iv-frame nil))
-                (get (get (get iv-frame :self) :ivars) name))
-              ((st-class-exists? name) (st-class-ref name))
-              (else
-                (error
-                  (str "smalltalk-eval-ast: undefined variable '" name "'"))))))))))
-
-;; Assign to an existing local in the frame chain or, failing that, an ivar
-;; on self. Errors if neither exists.
-(define
-  st-assign!
-  (fn
-    (frame name value)
-    (let
-      ((local-result (st-lookup-local frame name)))
-      (cond
-        ((get local-result :found)
-          (begin
-            (dict-set! (get (get local-result :frame) :locals) name value)
-            value))
-        (else
-          (let
-            ((iv-frame (st-lookup-ivar-frame frame name)))
-            (cond
-              ((not (= iv-frame nil))
-                (begin
-                  (dict-set! (get (get iv-frame :self) :ivars) name value)
-                  value))
-              (else
-                ;; Smalltalk allows new locals to be introduced; for our subset
-                ;; we treat unknown writes as errors so test mistakes surface.
-                (error
-                  (str "smalltalk-eval-ast: cannot assign undefined '" name "'"))))))))))
-
-;; ── Main evaluator ─────────────────────────────────────────────────────
-(define
-  smalltalk-eval-ast
-  (fn
-    (ast frame)
-    (cond
-      ((not (dict? ast)) (error (str "smalltalk-eval-ast: bad ast " ast)))
-      (else
-        (let
-          ((ty (get ast :type)))
-          (cond
-            ((= ty "lit-int") (get ast :value))
-            ((= ty "lit-float") (get ast :value))
-            ((= ty "lit-string") (get ast :value))
-            ((= ty "lit-char") (get ast :value))
-            ((= ty "lit-symbol") (make-symbol (get ast :value)))
-            ((= ty "lit-nil") nil)
-            ((= ty "lit-true") true)
-            ((= ty "lit-false") false)
-            ((= ty "lit-array")
-              (map
-                (fn (e) (smalltalk-eval-ast e frame))
-                (get ast :elements)))
-            ((= ty "lit-byte-array") (get ast :elements))
-            ((= ty "self") (get frame :self))
-            ((= ty "super") (get frame :self))
-            ((= ty "thisContext") frame)
-            ((= ty "ident") (st-resolve-ident frame (get ast :name)))
-            ((= ty "assign")
-              (st-assign! frame (get ast :name) (smalltalk-eval-ast (get ast :expr) frame)))
-            ((= ty "return")
-              (st-return-marker (smalltalk-eval-ast (get ast :expr) frame)))
-            ((= ty "block") (st-make-block ast frame))
-            ((= ty "seq") (st-eval-seq (get ast :exprs) frame))
-            ((= ty "send")
-              (st-eval-send ast frame (= (get (get ast :receiver) :type) "super")))
-            ((= ty "cascade") (st-eval-cascade ast frame))
-            (else (error (str "smalltalk-eval-ast: unknown type '" ty "'")))))))))
-
-(define
-  st-eval-seq
-  (fn
-    (exprs frame)
-    (let ((result nil))
-      (begin
-        (define
-          sq-loop
-          (fn
-            (rest)
-            (cond
-              ((= (len rest) 0) nil)
-              (else
-                (let ((v (smalltalk-eval-ast (nth rest 0) frame)))
-                  (cond
-                    ((st-return-marker? v) (set! result v))
-                    ((= (len rest) 1) (set! result v))
-                    (else (sq-loop (rest-of rest)))))))))
-        (sq-loop exprs)
-        result))))
-
-(define
-  rest-of
-  (fn
-    (lst)
-    (let ((out (list)) (i 1) (n (len lst)))
-      (begin
-        (define
-          ro-loop
-          (fn
-            ()
-            (when
-              (< i n)
-              (begin (append! out (nth lst i)) (set! i (+ i 1)) (ro-loop)))))
-        (ro-loop)
-        out))))
-
-(define
-  st-eval-send
-  (fn
-    (ast frame super?)
-    (let
-      ((receiver (smalltalk-eval-ast (get ast :receiver) frame))
-        (selector (get ast :selector))
-        (args (map (fn (a) (smalltalk-eval-ast a frame)) (get ast :args))))
-      (cond
-        (super?
-          (st-super-send (get frame :self) selector args (get frame :method-class)))
-        (else (st-send receiver selector args))))))
-
-(define
-  st-eval-cascade
-  (fn
-    (ast frame)
-    (let
-      ((receiver (smalltalk-eval-ast (get ast :receiver) frame))
-        (msgs (get ast :messages))
-        (last nil))
-      (begin
-        (for-each
-          (fn
-            (m)
-            (let
-              ((sel (get m :selector))
-                (args (map (fn (a) (smalltalk-eval-ast a frame)) (get m :args))))
-              (set! last (st-send receiver sel args))))
-          msgs)
-        last))))
-
-;; ── Send dispatch ──────────────────────────────────────────────────────
-(define
-  st-send
-  (fn
-    (receiver selector args)
-    (let
-      ((cls (st-class-of-for-send receiver)))
-      (let
-        ((class-side? (st-class-ref? receiver))
-          (recv-class (if (st-class-ref? receiver) (get receiver :name) cls)))
-        (let
-          ((method
-             (if class-side?
-               (st-method-lookup recv-class selector true)
-               (st-method-lookup recv-class selector false))))
-          (cond
-            ((not (= method nil))
-              (st-invoke method receiver args))
-            ((st-block? receiver)
-              (let ((bd (st-block-dispatch receiver selector args)))
-                (cond
-                  ((= bd :unhandled) (st-dnu receiver selector args))
-                  (else bd))))
-            (else
-              (let ((primitive-result (st-primitive-send receiver selector args)))
-                (cond
-                  ((= primitive-result :unhandled)
-                    (st-dnu receiver selector args))
-                  (else primitive-result))))))))))
-
-;; Construct a Message object for doesNotUnderstand:.
-(define
-  st-make-message
-  (fn
-    (selector args)
-    (let ((msg (st-make-instance "Message")))
-      (begin
-        (dict-set! (get msg :ivars) "selector" (make-symbol selector))
-        (dict-set! (get msg :ivars) "arguments" args)
-        msg))))
-
-;; Trigger doesNotUnderstand:. If the receiver's class chain defines an
-;; override, invoke it with a freshly-built Message; otherwise raise.
-(define
-  st-dnu
-  (fn
-    (receiver selector args)
-    (let
-      ((cls (st-class-of-for-send receiver))
-        (class-side? (st-class-ref? receiver)))
-      (let
-        ((recv-class (if class-side? (get receiver :name) cls)))
-        (let
-          ((method (st-method-lookup recv-class "doesNotUnderstand:" class-side?)))
-          (cond
-            ((not (= method nil))
-              (let ((msg (st-make-message selector args)))
-                (st-invoke method receiver (list msg))))
-            (else
-              (error
-                (str "doesNotUnderstand: " recv-class " >> " selector)))))))))
-
-(define
-  st-class-of-for-send
-  (fn
-    (v)
-    (cond
-      ((st-class-ref? v) "Class")
-      (else (st-class-of v)))))
-
-;; super send: lookup starts at the *defining* class's superclass, not the
-;; receiver class. This is what makes inherited methods compose correctly
-;; under refinement — a method on Foo that calls `super bar` resolves to
-;; Foo's superclass's `bar` regardless of the dynamic receiver class.
-(define
-  st-super-send
-  (fn
-    (receiver selector args defining-class)
-    (cond
-      ((= defining-class nil)
-        (error (str "super send outside method context: " selector)))
-      (else
-        (let
-          ((super (st-class-superclass defining-class))
-            (class-side? (st-class-ref? receiver)))
-          (cond
-            ((= super nil)
-              (error (str "super send past root: " selector " in " defining-class)))
-            (else
-              (let ((method (st-method-lookup super selector class-side?)))
-                (cond
-                  ((not (= method nil))
-                    (st-invoke method receiver args))
-                  (else
-                    ;; Try primitives starting from super's perspective too —
-                    ;; for native receivers the primitive table is global, so
-                    ;; super basically reaches the same primitives. The point
-                    ;; of super is to skip user overrides on the receiver's
-                    ;; class chain below `super`, which method-lookup above
-                    ;; already enforces.
-                    (let ((p (st-primitive-send receiver selector args)))
-                      (cond
-                        ((= p :unhandled)
-                          (st-dnu receiver selector args))
-                        (else p)))))))))))))
-
-;; ── Method invocation ──────────────────────────────────────────────────
-(define
-  st-invoke
-  (fn
-    (method receiver args)
-    (let
-      ((params (get method :params))
-        (temps (get method :temps))
-        (body (get method :body))
-        (defining-class (get method :defining-class)))
-      (cond
-        ((not (= (len params) (len args)))
-          (error
-            (str "smalltalk-eval-ast: arity mismatch for "
-              (get method :selector)
-              " expected " (len params) " got " (len args))))
-        (else
-          (let
-            ((frame (st-make-frame receiver defining-class nil)))
-            (begin
-              ;; Bind params
-              (let ((i 0))
-                (begin
-                  (define
-                    pb-loop
-                    (fn
-                      ()
-                      (when
-                        (< i (len params))
-                        (begin
-                          (dict-set!
-                            (get frame :locals)
-                            (nth params i)
-                            (nth args i))
-                          (set! i (+ i 1))
-                          (pb-loop)))))
-                  (pb-loop)))
-              ;; Bind temps to nil
-              (for-each
-                (fn (t) (dict-set! (get frame :locals) t nil))
-                temps)
-              ;; Execute body
-              (let ((result (st-eval-seq body frame)))
-                (cond
-                  ((st-return-marker? result) (get result :value))
-                  (else receiver))))))))))
-
-;; ── Block dispatch ─────────────────────────────────────────────────────
-(define
-  st-block-value-selector?
-  (fn
-    (s)
-    (or
-      (= s "value")
-      (= s "value:")
-      (= s "value:value:")
-      (= s "value:value:value:")
-      (= s "value:value:value:value:"))))
-
-(define
-  st-block-dispatch
-  (fn
-    (block selector args)
-    (cond
-      ((st-block-value-selector? selector) (st-block-apply block args))
-      ((= selector "valueWithArguments:") (st-block-apply block (nth args 0)))
-      ((= selector "whileTrue:")
-        (st-block-while block (nth args 0) true))
-      ((= selector "whileFalse:")
-        (st-block-while block (nth args 0) false))
-      ((= selector "whileTrue") (st-block-while block nil true))
-      ((= selector "whileFalse") (st-block-while block nil false))
-      ((= selector "numArgs") (len (get block :params)))
-      ((= selector "class") (st-class-ref "BlockClosure"))
-      ((= selector "==") (= block (nth args 0)))
-      ((= selector "printString") "a BlockClosure")
-      (else :unhandled))))
-
-(define
-  st-block-apply
-  (fn
-    (block args)
-    (let
-      ((params (get block :params))
-        (temps (get block :temps))
-        (body (get block :body))
-        (env (get block :env)))
-      (cond
-        ((not (= (len params) (len args)))
-          (error
-            (str "BlockClosure: arity mismatch — block expects "
-              (len params) " got " (len args))))
-        (else
-          (let
-            ((frame (st-make-frame
-                     (if (= env nil) nil (get env :self))
-                     (if (= env nil) nil (get env :method-class))
-                     env)))
-            (begin
-              (let ((i 0))
-                (begin
-                  (define
-                    pb-loop
-                    (fn
-                      ()
-                      (when
-                        (< i (len params))
-                        (begin
-                          (dict-set!
-                            (get frame :locals)
-                            (nth params i)
-                            (nth args i))
-                          (set! i (+ i 1))
-                          (pb-loop)))))
-                  (pb-loop)))
-              (for-each
-                (fn (t) (dict-set! (get frame :locals) t nil))
-                temps)
-              (st-eval-seq body frame))))))))
-
-(define
-  st-block-while
-  (fn
-    (cond-block body-block target)
-    (let ((last nil))
-      (begin
-        (define
-          wh-loop
-          (fn
-            ()
-            (let
-              ((c (st-block-apply cond-block (list))))
-              (when
-                (= c target)
-                (begin
-                  (cond
-                    ((not (= body-block nil))
-                      (set! last (st-block-apply body-block (list)))))
-                  (wh-loop))))))
-        (wh-loop)
-        last))))
-
-;; ── Primitive method table for native receivers ────────────────────────
-;; Returns the result, or the sentinel :unhandled if no primitive matches —
-;; in which case st-send falls back to doesNotUnderstand:.
-(define
-  st-primitive-send
-  (fn
-    (receiver selector args)
-    (let ((cls (st-class-of receiver)))
-      (cond
-        ((or (= cls "SmallInteger") (= cls "Float"))
-          (st-num-send receiver selector args))
-        ((or (= cls "String") (= cls "Symbol"))
-          (st-string-send receiver selector args))
-        ((= cls "True") (st-bool-send true selector args))
-        ((= cls "False") (st-bool-send false selector args))
-        ((= cls "UndefinedObject") (st-nil-send selector args))
-        ((= cls "Array") (st-array-send receiver selector args))
-        ((st-class-ref? receiver) (st-class-side-send receiver selector args))
-        (else :unhandled)))))
-
-(define
-  st-num-send
-  (fn
-    (n selector args)
-    (cond
-      ((= selector "+") (+ n (nth args 0)))
-      ((= selector "-") (- n (nth args 0)))
-      ((= selector "*") (* n (nth args 0)))
-      ((= selector "/") (/ n (nth args 0)))
-      ((= selector "//") (/ n (nth args 0)))
-      ((= selector "\\\\") (mod n (nth args 0)))
-      ((= selector "<") (< n (nth args 0)))
-      ((= selector ">") (> n (nth args 0)))
-      ((= selector "<=") (<= n (nth args 0)))
-      ((= selector ">=") (>= n (nth args 0)))
-      ((= selector "=") (= n (nth args 0)))
-      ((= selector "~=") (not (= n (nth args 0))))
-      ((= selector "==") (= n (nth args 0)))
-      ((= selector "~~") (not (= n (nth args 0))))
-      ((= selector "negated") (- 0 n))
-      ((= selector "abs") (if (< n 0) (- 0 n) n))
-      ((= selector "max:") (if (> n (nth args 0)) n (nth args 0)))
-      ((= selector "min:") (if (< n (nth args 0)) n (nth args 0)))
-      ((= selector "printString") (str n))
-      ((= selector "asString") (str n))
-      ((= selector "class")
-        (st-class-ref (st-class-of n)))
-      ((= selector "isNil") false)
-      ((= selector "notNil") true)
-      ((= selector "isZero") (= n 0))
-      ((= selector "between:and:")
-        (and (>= n (nth args 0)) (<= n (nth args 1))))
-      ((= selector "to:do:")
-        (let ((i n) (stop (nth args 0)) (block (nth args 1)))
-          (begin
-            (define
-              td-loop
-              (fn
-                ()
-                (when
-                  (<= i stop)
-                  (begin
-                    (st-block-apply block (list i))
-                    (set! i (+ i 1))
-                    (td-loop)))))
-            (td-loop)
-            n)))
-      ((= selector "timesRepeat:")
-        (let ((i 0) (block (nth args 0)))
-          (begin
-            (define
-              tr-loop
-              (fn
-                ()
-                (when
-                  (< i n)
-                  (begin
-                    (st-block-apply block (list))
-                    (set! i (+ i 1))
-                    (tr-loop)))))
-            (tr-loop)
-            n)))
-      (else :unhandled))))
-
-(define
-  st-string-send
-  (fn
-    (s selector args)
-    (cond
-      ((= selector ",") (str s (nth args 0)))
-      ((= selector "size") (len s))
-      ((= selector "=") (= s (nth args 0)))
-      ((= selector "~=") (not (= s (nth args 0))))
-      ((= selector "==") (= s (nth args 0)))
-      ((= selector "~~") (not (= s (nth args 0))))
-      ((= selector "isEmpty") (= (len s) 0))
-      ((= selector "notEmpty") (> (len s) 0))
-      ((= selector "printString") (str "'" s "'"))
-      ((= selector "asString") s)
-      ((= selector "asSymbol") (make-symbol (if (symbol? s) (str s) s)))
-      ((= selector "class") (st-class-ref (st-class-of s)))
-      ((= selector "isNil") false)
-      ((= selector "notNil") true)
-      (else :unhandled))))
-
-(define
-  st-bool-send
-  (fn
-    (b selector args)
-    (cond
-      ((= selector "not") (not b))
-      ((= selector "&") (and b (nth args 0)))
-      ((= selector "|") (or b (nth args 0)))
-      ((= selector "and:")
-        (cond (b (st-block-apply (nth args 0) (list))) (else false)))
-      ((= selector "or:")
-        (cond (b true) (else (st-block-apply (nth args 0) (list)))))
-      ((= selector "ifTrue:")
-        (cond (b (st-block-apply (nth args 0) (list))) (else nil)))
-      ((= selector "ifFalse:")
-        (cond (b nil) (else (st-block-apply (nth args 0) (list)))))
-      ((= selector "ifTrue:ifFalse:")
-        (cond
-          (b (st-block-apply (nth args 0) (list)))
-          (else (st-block-apply (nth args 1) (list)))))
-      ((= selector "ifFalse:ifTrue:")
-        (cond
-          (b (st-block-apply (nth args 1) (list)))
-          (else (st-block-apply (nth args 0) (list)))))
-      ((= selector "=") (= b (nth args 0)))
-      ((= selector "~=") (not (= b (nth args 0))))
-      ((= selector "==") (= b (nth args 0)))
-      ((= selector "printString") (if b "true" "false"))
-      ((= selector "class") (st-class-ref (if b "True" "False")))
-      ((= selector "isNil") false)
-      ((= selector "notNil") true)
-      (else :unhandled))))
-
-(define
-  st-nil-send
-  (fn
-    (selector args)
-    (cond
-      ((= selector "isNil") true)
-      ((= selector "notNil") false)
-      ((= selector "ifNil:") (st-block-apply (nth args 0) (list)))
-      ((= selector "ifNotNil:") nil)
-      ((= selector "ifNil:ifNotNil:") (st-block-apply (nth args 0) (list)))
-      ((= selector "ifNotNil:ifNil:") (st-block-apply (nth args 1) (list)))
-      ((= selector "=") (= nil (nth args 0)))
-      ((= selector "~=") (not (= nil (nth args 0))))
-      ((= selector "==") (= nil (nth args 0)))
-      ((= selector "printString") "nil")
-      ((= selector "class") (st-class-ref "UndefinedObject"))
-      (else :unhandled))))
-
-(define
-  st-array-send
-  (fn
-    (a selector args)
-    (cond
-      ((= selector "size") (len a))
-      ((= selector "at:")
-        ;; 1-indexed
-        (nth a (- (nth args 0) 1)))
-      ((= selector "at:put:")
-        (begin
-          (set-nth! a (- (nth args 0) 1) (nth args 1))
-          (nth args 1)))
-      ((= selector "first") (nth a 0))
-      ((= selector "last") (nth a (- (len a) 1)))
-      ((= selector "isEmpty") (= (len a) 0))
-      ((= selector "notEmpty") (> (len a) 0))
-      ((= selector "do:")
-        (begin
-          (for-each
-            (fn (e) (st-block-apply (nth args 0) (list e)))
-            a)
-          a))
-      ((= selector "collect:")
-        (map (fn (e) (st-block-apply (nth args 0) (list e))) a))
-      ((= selector "select:")
-        (filter (fn (e) (st-block-apply (nth args 0) (list e))) a))
-      ((= selector ",")
-        (let ((out (list)))
-          (begin
-            (for-each (fn (e) (append! out e)) a)
-            (for-each (fn (e) (append! out e)) (nth args 0))
-            out)))
-      ((= selector "=") (= a (nth args 0)))
-      ((= selector "==") (= a (nth args 0)))
-      ((= selector "printString")
-        (str "#(" (join " " (map (fn (e) (str e)) a)) ")"))
-      ((= selector "class") (st-class-ref "Array"))
-      ((= selector "isNil") false)
-      ((= selector "notNil") true)
-      (else :unhandled))))
-
-(define
-  st-class-side-send
-  (fn
-    (cref selector args)
-    (let ((name (get cref :name)))
-      (cond
-        ((= selector "new") (st-make-instance name))
-        ((= selector "name") name)
-        ((= selector "superclass")
-          (let ((s (st-class-superclass name)))
-            (cond ((= s nil) nil) (else (st-class-ref s)))))
-        ((= selector "printString") name)
-        ((= selector "class") (st-class-ref "Metaclass"))
-        ((= selector "==") (and (st-class-ref? (nth args 0))
-                                (= name (get (nth args 0) :name))))
-        ((= selector "=") (and (st-class-ref? (nth args 0))
-                                (= name (get (nth args 0) :name))))
-        ((= selector "isNil") false)
-        ((= selector "notNil") true)
-        (else :unhandled)))))
-
-;; Convenience: parse and evaluate a Smalltalk expression with no receiver.
-(define
-  smalltalk-eval
-  (fn
-    (src)
-    (let
-      ((ast (st-parse-expr src))
-        (frame (st-make-frame nil nil nil)))
-      (smalltalk-eval-ast ast frame))))
-
-;; Evaluate a sequence of statements at the top level.
-(define
-  smalltalk-eval-program
-  (fn
-    (src)
-    (let
-      ((ast (st-parse src)) (frame (st-make-frame nil nil nil)))
-      (begin
-        (when
-          (and (dict? ast) (has-key? ast :temps))
-          (for-each
-            (fn (t) (dict-set! (get frame :locals) t nil))
-            (get ast :temps)))
-        (let ((result (smalltalk-eval-ast ast frame)))
-          (cond
-            ((st-return-marker? result) (get result :value))
-            (else result)))))))

lib/smalltalk/parser.sx

@@ -1,912 +0,0 @@
-;; Smalltalk parser — produces an AST from the tokenizer's token stream.
-;;
-;; AST node shapes (dicts):
-;;   {:type "lit-int" :value N}                  integer
-;;   {:type "lit-float" :value F}                float
-;;   {:type "lit-string" :value S}               string
-;;   {:type "lit-char" :value C}                 character
-;;   {:type "lit-symbol" :value S}               symbol literal (#foo)
-;;   {:type "lit-array" :elements (list ...)}    literal array (#(1 2 #foo))
-;;   {:type "lit-byte-array" :elements (...)}    byte array (#[1 2 3])
-;;   {:type "lit-nil" } / "lit-true" / "lit-false"
-;;   {:type "ident" :name "x"}                   variable reference
-;;   {:type "self"} / "super" / "thisContext"    pseudo-variables
-;;   {:type "assign" :name "x" :expr E}          x := E
-;;   {:type "return" :expr E}                    ^ E
-;;   {:type "send" :receiver R :selector S :args (list ...)}
-;;   {:type "cascade" :receiver R :messages (list {:selector :args} ...)}
-;;   {:type "block" :params (list "a") :temps (list "t") :body (list expr)}
-;;   {:type "seq" :exprs (list ...)}             statement sequence
-;;   {:type "method" :selector S :params (list ...) :temps (list ...) :body (list ...) :pragmas (list ...)}
-;;
-;; A "chunk" / class-definition stream is parsed at a higher level (deferred).
-
-;; ── Chunk-stream reader ────────────────────────────────────────────────
-;; Pharo chunk format: chunks are separated by `!`. A doubled `!!` inside a
-;; chunk represents a single literal `!`. Returns list of chunk strings with
-;; surrounding whitespace trimmed.
-(define
-  st-read-chunks
-  (fn
-    (src)
-    (let
-      ((chunks (list))
-        (buf (list))
-        (pos 0)
-        (n (len src)))
-      (begin
-        (define
-          flush!
-          (fn
-            ()
-            (let
-              ((s (st-trim (join "" buf))))
-              (begin (append! chunks s) (set! buf (list))))))
-        (define
-          rc-loop
-          (fn
-            ()
-            (when
-              (< pos n)
-              (let
-                ((c (nth src pos)))
-                (cond
-                  ((= c "!")
-                    (cond
-                      ((and (< (+ pos 1) n) (= (nth src (+ pos 1)) "!"))
-                        (begin (append! buf "!") (set! pos (+ pos 2)) (rc-loop)))
-                      (else
-                        (begin (flush!) (set! pos (+ pos 1)) (rc-loop)))))
-                  (else
-                    (begin (append! buf c) (set! pos (+ pos 1)) (rc-loop))))))))
-        (rc-loop)
-        ;; trailing text without a closing `!` — preserve as a chunk
-        (when (> (len buf) 0) (flush!))
-        chunks))))
-
-(define
-  st-trim
-  (fn
-    (s)
-    (let
-      ((n (len s)) (i 0) (j 0))
-      (begin
-        (set! j n)
-        (define
-          tl-loop
-          (fn
-            ()
-            (when
-              (and (< i n) (st-trim-ws? (nth s i)))
-              (begin (set! i (+ i 1)) (tl-loop)))))
-        (tl-loop)
-        (define
-          tr-loop
-          (fn
-            ()
-            (when
-              (and (> j i) (st-trim-ws? (nth s (- j 1))))
-              (begin (set! j (- j 1)) (tr-loop)))))
-        (tr-loop)
-        (slice s i j)))))
-
-(define
-  st-trim-ws?
-  (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
-
-;; Parse a chunk stream. Walks chunks and applies the Pharo file-in
-;; convention: a chunk that evaluates to "X methodsFor: 'cat'" or
-;; "X class methodsFor: 'cat'" enters a methods batch — subsequent chunks
-;; are method source until an empty chunk closes the batch.
-;;
-;; Returns list of entries:
-;;   {:kind "expr" :ast EXPR-AST}
-;;   {:kind "method" :class CLS :class-side? BOOL :category CAT :ast METHOD-AST}
-;;   {:kind "blank"}        (empty chunks outside a methods batch)
-;;   {:kind "end-methods"}  (empty chunk closing a methods batch)
-(define
-  st-parse-chunks
-  (fn
-    (src)
-    (let
-      ((chunks (st-read-chunks src))
-        (entries (list))
-        (mode "do-it")
-        (cls-name nil)
-        (class-side? false)
-        (category nil))
-      (begin
-        (for-each
-          (fn
-            (chunk)
-            (cond
-              ((= chunk "")
-                (cond
-                  ((= mode "methods")
-                    (begin
-                      (append! entries {:kind "end-methods"})
-                      (set! mode "do-it")
-                      (set! cls-name nil)
-                      (set! class-side? false)
-                      (set! category nil)))
-                  (else (append! entries {:kind "blank"}))))
-              ((= mode "methods")
-                (append!
-                  entries
-                  {:kind "method"
-                   :class cls-name
-                   :class-side? class-side?
-                   :category category
-                   :ast (st-parse-method chunk)}))
-              (else
-                (let
-                  ((ast (st-parse-expr chunk)))
-                  (begin
-                    (append! entries {:kind "expr" :ast ast})
-                    (let
-                      ((mf (st-detect-methods-for ast)))
-                      (when
-                        (not (= mf nil))
-                        (begin
-                          (set! mode "methods")
-                          (set! cls-name (get mf :class))
-                          (set! class-side? (get mf :class-side?))
-                          (set! category (get mf :category))))))))))
-          chunks)
-        entries))))
-
-;; Recognise `Foo methodsFor: 'cat'` (and related) as starting a methods batch.
-;; Returns nil if the AST doesn't look like one of these forms.
-(define
-  st-detect-methods-for
-  (fn
-    (ast)
-    (cond
-      ((not (= (get ast :type) "send")) nil)
-      ((not (st-is-methods-for-selector? (get ast :selector))) nil)
-      (else
-        (let
-          ((recv (get ast :receiver)) (args (get ast :args)))
-          (let
-            ((cat-arg (if (> (len args) 0) (nth args 0) nil)))
-            (let
-              ((category
-                 (cond
-                   ((= cat-arg nil) nil)
-                   ((= (get cat-arg :type) "lit-string") (get cat-arg :value))
-                   ((= (get cat-arg :type) "lit-symbol") (get cat-arg :value))
-                   (else nil))))
-              (cond
-                ((= (get recv :type) "ident")
-                  {:class (get recv :name)
-                   :class-side? false
-                   :category category})
-                ;; `Foo class methodsFor: 'cat'` — recv is a unary send `Foo class`
-                ((and
-                    (= (get recv :type) "send")
-                    (= (get recv :selector) "class")
-                    (= (get (get recv :receiver) :type) "ident"))
-                  {:class (get (get recv :receiver) :name)
-                   :class-side? true
-                   :category category})
-                (else nil)))))))))
-
-(define
-  st-is-methods-for-selector?
-  (fn
-    (sel)
-    (or
-      (= sel "methodsFor:")
-      (= sel "methodsFor:stamp:")
-      (= sel "category:"))))
-
-(define st-tok-type (fn (t) (if (= t nil) "eof" (get t :type))))
-
-(define st-tok-value (fn (t) (if (= t nil) nil (get t :value))))
-
-;; Parse a *single* Smalltalk expression from source.
-(define st-parse-expr (fn (src) (st-parse-with src "expr")))
-
-;; Parse a sequence of statements separated by '.'  Returns a {:type "seq"} node.
-(define st-parse (fn (src) (st-parse-with src "seq")))
-
-;; Parse a method body — `selector params | temps | body`.
-;; Only the "method header + body" form (no chunk delimiters).
-(define st-parse-method (fn (src) (st-parse-with src "method")))
-
-(define
-  st-parse-with
-  (fn
-    (src mode)
-    (let
-      ((tokens (st-tokenize src)) (idx 0) (tok-len 0))
-      (begin
-        (set! tok-len (len tokens))
-        (define peek-tok (fn () (nth tokens idx)))
-        (define
-          peek-tok-at
-          (fn (n) (if (< (+ idx n) tok-len) (nth tokens (+ idx n)) nil)))
-        (define advance-tok! (fn () (set! idx (+ idx 1))))
-        (define
-          at?
-          (fn
-            (type value)
-            (let
-              ((t (peek-tok)))
-              (and
-                (= (st-tok-type t) type)
-                (or (= value nil) (= (st-tok-value t) value))))))
-        (define at-type? (fn (type) (= (st-tok-type (peek-tok)) type)))
-        (define
-          consume!
-          (fn
-            (type value)
-            (if
-              (at? type value)
-              (let ((t (peek-tok))) (begin (advance-tok!) t))
-              (error
-                (str
-                  "st-parse: expected "
-                  type
-                  (if (= value nil) "" (str " '" value "'"))
-                  " got "
-                  (st-tok-type (peek-tok))
-                  " '"
-                  (st-tok-value (peek-tok))
-                  "' at idx "
-                  idx)))))
-
-        ;; ── Primary: atoms, paren'd expr, blocks, literal arrays, byte arrays.
-        (define
-          parse-primary
-          (fn
-            ()
-            (let
-              ((t (peek-tok)))
-              (let
-                ((ty (st-tok-type t)) (v (st-tok-value t)))
-                (cond
-                  ((= ty "number")
-                    (begin
-                      (advance-tok!)
-                      (cond
-                        ((number? v) {:type (if (integer? v) "lit-int" "lit-float") :value v})
-                        (else {:type "lit-int" :value v}))))
-                  ((= ty "string")
-                    (begin (advance-tok!) {:type "lit-string" :value v}))
-                  ((= ty "char")
-                    (begin (advance-tok!) {:type "lit-char" :value v}))
-                  ((= ty "symbol")
-                    (begin (advance-tok!) {:type "lit-symbol" :value v}))
-                  ((= ty "array-open") (parse-literal-array))
-                  ((= ty "byte-array-open") (parse-byte-array))
-                  ((= ty "lparen")
-                    (begin
-                      (advance-tok!)
-                      (let
-                        ((e (parse-expression)))
-                        (begin (consume! "rparen" nil) e))))
-                  ((= ty "lbracket") (parse-block))
-                  ((= ty "ident")
-                    (begin
-                      (advance-tok!)
-                      (cond
-                        ((= v "nil") {:type "lit-nil"})
-                        ((= v "true") {:type "lit-true"})
-                        ((= v "false") {:type "lit-false"})
-                        ((= v "self") {:type "self"})
-                        ((= v "super") {:type "super"})
-                        ((= v "thisContext") {:type "thisContext"})
-                        (else {:type "ident" :name v}))))
-                  ((= ty "binary")
-                    ;; Negative numeric literal: '-' immediately before a number.
-                    (cond
-                      ((and (= v "-") (= (st-tok-type (peek-tok-at 1)) "number"))
-                        (let
-                          ((n (st-tok-value (peek-tok-at 1))))
-                          (begin
-                            (advance-tok!)
-                            (advance-tok!)
-                            (cond
-                              ((dict? n) {:type "lit-int" :value n})
-                              ((integer? n) {:type "lit-int" :value (- 0 n)})
-                              (else {:type "lit-float" :value (- 0 n)})))))
-                      (else
-                        (error
-                          (str "st-parse: unexpected binary '" v "' at idx " idx)))))
-                  (else
-                    (error
-                      (str
-                        "st-parse: unexpected "
-                        ty
-                        " '"
-                        v
-                        "' at idx "
-                        idx))))))))
-
-        ;; #(elem elem ...) — elements are atoms or nested parenthesised arrays.
-        (define
-          parse-literal-array
-          (fn
-            ()
-            (let
-              ((items (list)))
-              (begin
-                (consume! "array-open" nil)
-                (define
-                  arr-loop
-                  (fn
-                    ()
-                    (cond
-                      ((at? "rparen" nil) (advance-tok!))
-                      (else
-                        (begin
-                          (append! items (parse-array-element))
-                          (arr-loop))))))
-                (arr-loop)
-                {:type "lit-array" :elements items}))))
-
-        ;; #[1 2 3]
-        (define
-          parse-byte-array
-          (fn
-            ()
-            (let
-              ((items (list)))
-              (begin
-                (consume! "byte-array-open" nil)
-                (define
-                  ba-loop
-                  (fn
-                    ()
-                    (cond
-                      ((at? "rbracket" nil) (advance-tok!))
-                      (else
-                        (let
-                          ((t (peek-tok)))
-                          (cond
-                            ((= (st-tok-type t) "number")
-                              (begin
-                                (advance-tok!)
-                                (append! items (st-tok-value t))
-                                (ba-loop)))
-                            (else
-                              (error
-                                (str
-                                  "st-parse: byte array expects number, got "
-                                  (st-tok-type t))))))))))
-                (ba-loop)
-                {:type "lit-byte-array" :elements items}))))
-
-        ;; Inside a literal array: bare idents become symbols, nested (...) is a sub-array.
-        (define
-          parse-array-element
-          (fn
-            ()
-            (let
-              ((t (peek-tok)))
-              (let
-                ((ty (st-tok-type t)) (v (st-tok-value t)))
-                (cond
-                  ((= ty "number") (begin (advance-tok!) {:type "lit-int" :value v}))
-                  ((= ty "string") (begin (advance-tok!) {:type "lit-string" :value v}))
-                  ((= ty "char") (begin (advance-tok!) {:type "lit-char" :value v}))
-                  ((= ty "symbol") (begin (advance-tok!) {:type "lit-symbol" :value v}))
-                  ((= ty "ident")
-                    (begin
-                      (advance-tok!)
-                      (cond
-                        ((= v "nil") {:type "lit-nil"})
-                        ((= v "true") {:type "lit-true"})
-                        ((= v "false") {:type "lit-false"})
-                        (else {:type "lit-symbol" :value v}))))
-                  ((= ty "keyword") (begin (advance-tok!) {:type "lit-symbol" :value v}))
-                  ((= ty "binary") (begin (advance-tok!) {:type "lit-symbol" :value v}))
-                  ((= ty "lparen")
-                    (let ((items (list)))
-                      (begin
-                        (advance-tok!)
-                        (define
-                          sub-loop
-                          (fn
-                            ()
-                            (cond
-                              ((at? "rparen" nil) (advance-tok!))
-                              (else
-                                (begin (append! items (parse-array-element)) (sub-loop))))))
-                        (sub-loop)
-                        {:type "lit-array" :elements items})))
-                  ((= ty "array-open") (parse-literal-array))
-                  ((= ty "byte-array-open") (parse-byte-array))
-                  (else
-                    (error
-                      (str "st-parse: bad literal-array element " ty " '" v "'"))))))))
-
-        ;; [:a :b | | t1 t2 | body. body. ...]
-        (define
-          parse-block
-          (fn
-            ()
-            (begin
-              (consume! "lbracket" nil)
-              (let
-                ((params (list)) (temps (list)))
-                (begin
-                  ;; Block params
-                  (define
-                    p-loop
-                    (fn
-                      ()
-                      (when
-                        (at? "colon" nil)
-                        (begin
-                          (advance-tok!)
-                          (let
-                            ((t (consume! "ident" nil)))
-                            (begin
-                              (append! params (st-tok-value t))
-                              (p-loop)))))))
-                  (p-loop)
-                  (when (> (len params) 0) (consume! "bar" nil))
-                  ;; Block temps: | t1 t2 |
-                  (when
-                    (and
-                      (at? "bar" nil)
-                      ;; Not `|` followed immediately by binary content — the only
-                      ;; legitimate `|` inside a block here is the temp delimiter.
-                      true)
-                    (begin
-                      (advance-tok!)
-                      (define
-                        t-loop
-                        (fn
-                          ()
-                          (when
-                            (at? "ident" nil)
-                            (let
-                              ((t (peek-tok)))
-                              (begin
-                                (advance-tok!)
-                                (append! temps (st-tok-value t))
-                                (t-loop))))))
-                      (t-loop)
-                      (consume! "bar" nil)))
-                  ;; Body: statements terminated by `.` or `]`
-                  (let
-                    ((body (parse-statements "rbracket")))
-                    (begin
-                      (consume! "rbracket" nil)
-                      {:type "block" :params params :temps temps :body body})))))))
-
-        ;; Parse statements up to a closing token (rbracket or eof). Returns list.
-        (define
-          parse-statements
-          (fn
-            (terminator)
-            (let
-              ((stmts (list)))
-              (begin
-                (define
-                  s-loop
-                  (fn
-                    ()
-                    (cond
-                      ((at-type? terminator) nil)
-                      ((at-type? "eof") nil)
-                      (else
-                        (begin
-                          (append! stmts (parse-statement))
-                          ;; consume optional period(s)
-                          (define
-                            dot-loop
-                            (fn
-                              ()
-                              (when
-                                (at? "period" nil)
-                                (begin (advance-tok!) (dot-loop)))))
-                          (dot-loop)
-                          (s-loop))))))
-                (s-loop)
-                stmts))))
-
-        ;; Statement: ^expr  |  ident := expr  |  expr
-        (define
-          parse-statement
-          (fn
-            ()
-            (cond
-              ((at? "caret" nil)
-                (begin
-                  (advance-tok!)
-                  {:type "return" :expr (parse-expression)}))
-              ((and (at-type? "ident") (= (st-tok-type (peek-tok-at 1)) "assign"))
-                (let
-                  ((name-tok (peek-tok)))
-                  (begin
-                    (advance-tok!)
-                    (advance-tok!)
-                    {:type "assign"
-                     :name (st-tok-value name-tok)
-                     :expr (parse-expression)})))
-              (else (parse-expression)))))
-
-        ;; Top-level expression. Assignment (right-associative chain) sits at
-        ;; the top; cascade is below.
-        (define
-          parse-expression
-          (fn
-            ()
-            (cond
-              ((and (at-type? "ident") (= (st-tok-type (peek-tok-at 1)) "assign"))
-                (let
-                  ((name-tok (peek-tok)))
-                  (begin
-                    (advance-tok!)
-                    (advance-tok!)
-                    {:type "assign"
-                     :name (st-tok-value name-tok)
-                     :expr (parse-expression)})))
-              (else (parse-cascade)))))
-
-        (define
-          parse-cascade
-          (fn
-            ()
-            (let
-              ((head (parse-keyword-message)))
-              (cond
-                ((at? "semi" nil)
-                  (let
-                    ((receiver (cascade-receiver head))
-                      (first-msg (cascade-first-message head))
-                      (msgs (list)))
-                    (begin
-                      (append! msgs first-msg)
-                      (define
-                        c-loop
-                        (fn
-                          ()
-                          (when
-                            (at? "semi" nil)
-                            (begin
-                              (advance-tok!)
-                              (append! msgs (parse-cascade-message))
-                              (c-loop)))))
-                      (c-loop)
-                      {:type "cascade" :receiver receiver :messages msgs})))
-                (else head)))))
-
-        ;; Extract the receiver from a head send so cascades share it.
-        (define
-          cascade-receiver
-          (fn
-            (head)
-            (cond
-              ((= (get head :type) "send") (get head :receiver))
-              (else head))))
-
-        (define
-          cascade-first-message
-          (fn
-            (head)
-            (cond
-              ((= (get head :type) "send")
-                {:selector (get head :selector) :args (get head :args)})
-              (else
-                ;; Shouldn't happen — cascade requires at least one prior message.
-                (error "st-parse: cascade with no prior message")))))
-
-        ;; Subsequent cascade message (after the `;`): unary | binary | keyword
-        (define
-          parse-cascade-message
-          (fn
-            ()
-            (cond
-              ((at-type? "ident")
-                (let ((t (peek-tok)))
-                  (begin
-                    (advance-tok!)
-                    {:selector (st-tok-value t) :args (list)})))
-              ((at-type? "binary")
-                (let ((t (peek-tok)))
-                  (begin
-                    (advance-tok!)
-                    (let
-                      ((arg (parse-unary-message)))
-                      {:selector (st-tok-value t) :args (list arg)}))))
-              ((at-type? "keyword")
-                (let
-                  ((sel-parts (list)) (args (list)))
-                  (begin
-                    (define
-                      kw-loop
-                      (fn
-                        ()
-                        (when
-                          (at-type? "keyword")
-                          (let ((t (peek-tok)))
-                            (begin
-                              (advance-tok!)
-                              (append! sel-parts (st-tok-value t))
-                              (append! args (parse-binary-message))
-                              (kw-loop))))))
-                    (kw-loop)
-                    {:selector (join "" sel-parts) :args args})))
-              (else
-                (error
-                  (str "st-parse: bad cascade message at idx " idx))))))
-
-        ;; Keyword message: <binary> (kw <binary>)+
-        (define
-          parse-keyword-message
-          (fn
-            ()
-            (let
-              ((receiver (parse-binary-message)))
-              (cond
-                ((at-type? "keyword")
-                  (let
-                    ((sel-parts (list)) (args (list)))
-                    (begin
-                      (define
-                        kw-loop
-                        (fn
-                          ()
-                          (when
-                            (at-type? "keyword")
-                            (let ((t (peek-tok)))
-                              (begin
-                                (advance-tok!)
-                                (append! sel-parts (st-tok-value t))
-                                (append! args (parse-binary-message))
-                                (kw-loop))))))
-                      (kw-loop)
-                      {:type "send"
-                       :receiver receiver
-                       :selector (join "" sel-parts)
-                       :args args})))
-                (else receiver)))))
-
-        ;; Binary message: <unary> (binop <unary>)*
-        (define
-          parse-binary-message
-          (fn
-            ()
-            (let
-              ((receiver (parse-unary-message)))
-              (begin
-                (define
-                  b-loop
-                  (fn
-                    ()
-                    (when
-                      (at-type? "binary")
-                      (let ((t (peek-tok)))
-                        (begin
-                          (advance-tok!)
-                          (let
-                            ((arg (parse-unary-message)))
-                            (set!
-                              receiver
-                              {:type "send"
-                               :receiver receiver
-                               :selector (st-tok-value t)
-                               :args (list arg)}))
-                          (b-loop))))))
-                (b-loop)
-                receiver))))
-
-        ;; Unary message: <primary> ident*  (ident NOT followed by ':')
-        (define
-          parse-unary-message
-          (fn
-            ()
-            (let
-              ((receiver (parse-primary)))
-              (begin
-                (define
-                  u-loop
-                  (fn
-                    ()
-                    (when
-                      (and
-                        (at-type? "ident")
-                        (let
-                          ((nxt (peek-tok-at 1)))
-                          (not (= (st-tok-type nxt) "assign"))))
-                      (let ((t (peek-tok)))
-                        (begin
-                          (advance-tok!)
-                          (set!
-                            receiver
-                            {:type "send"
-                             :receiver receiver
-                             :selector (st-tok-value t)
-                             :args (list)})
-                          (u-loop))))))
-                (u-loop)
-                receiver))))
-
-        ;; Parse a single pragma: `<keyword: literal (keyword: literal)* >`
-        ;; Returns {:selector "primitive:" :args (list literal-asts)}.
-        (define
-          parse-pragma
-          (fn
-            ()
-            (begin
-              (consume! "binary" "<")
-              (let
-                ((sel-parts (list)) (args (list)))
-                (begin
-                  (define
-                    pr-loop
-                    (fn
-                      ()
-                      (when
-                        (at-type? "keyword")
-                        (let ((t (peek-tok)))
-                          (begin
-                            (advance-tok!)
-                            (append! sel-parts (st-tok-value t))
-                            (append! args (parse-pragma-arg))
-                            (pr-loop))))))
-                  (pr-loop)
-                  (consume! "binary" ">")
-                  {:selector (join "" sel-parts) :args args})))))
-
-        ;; Pragma arguments are literals only.
-        (define
-          parse-pragma-arg
-          (fn
-            ()
-            (let
-              ((t (peek-tok)))
-              (let
-                ((ty (st-tok-type t)) (v (st-tok-value t)))
-                (cond
-                  ((= ty "number")
-                    (begin
-                      (advance-tok!)
-                      {:type (if (integer? v) "lit-int" "lit-float") :value v}))
-                  ((= ty "string") (begin (advance-tok!) {:type "lit-string" :value v}))
-                  ((= ty "char") (begin (advance-tok!) {:type "lit-char" :value v}))
-                  ((= ty "symbol") (begin (advance-tok!) {:type "lit-symbol" :value v}))
-                  ((= ty "ident")
-                    (begin
-                      (advance-tok!)
-                      (cond
-                        ((= v "nil") {:type "lit-nil"})
-                        ((= v "true") {:type "lit-true"})
-                        ((= v "false") {:type "lit-false"})
-                        (else (error (str "st-parse: pragma arg must be literal, got ident " v))))))
-                  ((and (= ty "binary") (= v "-")
-                        (= (st-tok-type (peek-tok-at 1)) "number"))
-                    (let ((n (st-tok-value (peek-tok-at 1))))
-                      (begin
-                        (advance-tok!)
-                        (advance-tok!)
-                        {:type (if (integer? n) "lit-int" "lit-float")
-                         :value (- 0 n)})))
-                  (else
-                    (error
-                      (str "st-parse: pragma arg must be literal, got " ty))))))))
-
-        ;; Method header: unary | binary arg | (kw arg)+
-        (define
-          parse-method
-          (fn
-            ()
-            (let
-              ((sel "")
-                (params (list))
-                (temps (list))
-                (pragmas (list))
-                (body (list)))
-              (begin
-                (cond
-                  ;; Unary header
-                  ((at-type? "ident")
-                    (let ((t (peek-tok)))
-                      (begin (advance-tok!) (set! sel (st-tok-value t)))))
-                  ;; Binary header: binop ident
-                  ((at-type? "binary")
-                    (let ((t (peek-tok)))
-                      (begin
-                        (advance-tok!)
-                        (set! sel (st-tok-value t))
-                        (let ((p (consume! "ident" nil)))
-                          (append! params (st-tok-value p))))))
-                  ;; Keyword header: (kw ident)+
-                  ((at-type? "keyword")
-                    (let ((sel-parts (list)))
-                      (begin
-                        (define
-                          kh-loop
-                          (fn
-                            ()
-                            (when
-                              (at-type? "keyword")
-                              (let ((t (peek-tok)))
-                                (begin
-                                  (advance-tok!)
-                                  (append! sel-parts (st-tok-value t))
-                                  (let ((p (consume! "ident" nil)))
-                                    (append! params (st-tok-value p)))
-                                  (kh-loop))))))
-                        (kh-loop)
-                        (set! sel (join "" sel-parts)))))
-                  (else
-                    (error
-                      (str
-                        "st-parse-method: expected selector header, got "
-                        (st-tok-type (peek-tok))))))
-                ;; Pragmas and temps may appear in either order. Allow many
-                ;; pragmas; one temps section.
-                (define
-                  parse-temps!
-                  (fn
-                    ()
-                    (begin
-                      (advance-tok!)
-                      (define
-                        th-loop
-                        (fn
-                          ()
-                          (when
-                            (at-type? "ident")
-                            (let ((t (peek-tok)))
-                              (begin
-                                (advance-tok!)
-                                (append! temps (st-tok-value t))
-                                (th-loop))))))
-                      (th-loop)
-                      (consume! "bar" nil))))
-                (define
-                  pt-loop
-                  (fn
-                    ()
-                    (cond
-                      ((and
-                          (at? "binary" "<")
-                          (= (st-tok-type (peek-tok-at 1)) "keyword"))
-                        (begin (append! pragmas (parse-pragma)) (pt-loop)))
-                      ((and (at? "bar" nil) (= (len temps) 0))
-                        (begin (parse-temps!) (pt-loop)))
-                      (else nil))))
-                (pt-loop)
-                ;; Body statements
-                (set! body (parse-statements "eof"))
-                {:type "method"
-                 :selector sel
-                 :params params
-                 :temps temps
-                 :pragmas pragmas
-                 :body body}))))
-
-        ;; Top-level program: optional temp declaration, then statements
-        ;; separated by '.'. Pharo workspace-style scripts allow
-        ;; `| temps | body...` at the top level.
-        (cond
-          ((= mode "expr") (parse-expression))
-          ((= mode "method") (parse-method))
-          (else
-            (let ((temps (list)))
-              (begin
-                (when
-                  (at? "bar" nil)
-                  (begin
-                    (advance-tok!)
-                    (define
-                      tt-loop
-                      (fn
-                        ()
-                        (when
-                          (at-type? "ident")
-                          (let ((t (peek-tok)))
-                            (begin
-                              (advance-tok!)
-                              (append! temps (st-tok-value t))
-                              (tt-loop))))))
-                    (tt-loop)
-                    (consume! "bar" nil)))
-                {:type "seq" :temps temps :exprs (parse-statements "eof")}))))))))

lib/smalltalk/runtime.sx

@@ -1,397 +0,0 @@
-;; Smalltalk runtime — class table, bootstrap hierarchy, type→class mapping,
-;; instance construction. Method dispatch / eval-ast live in a later layer.
-;;
-;; Class record shape:
-;;   {:name "Foo"
-;;    :superclass "Object"          ; or nil for Object itself
-;;    :ivars (list "x" "y")          ; instance variable names declared on this class
-;;    :methods   (dict selector→method-record)
-;;    :class-methods (dict selector→method-record)}
-;;
-;; A method record is the AST returned by st-parse-method, plus a :defining-class
-;; field so super-sends can resolve from the right place. (Methods are registered
-;; via runtime helpers that fill the field.)
-;;
-;; The class table is a single dict keyed by class name. Bootstrap installs the
-;; canonical hierarchy. Test code resets it via (st-bootstrap-classes!).
-
-(define st-class-table {})
-
-;; ── Method-lookup cache ────────────────────────────────────────────────
-;; Cache keys are "class|selector|side"; side is "i" (instance) or "c" (class).
-;; Misses are stored as the sentinel :not-found so we don't re-walk for
-;; every doesNotUnderstand call.
-(define st-method-cache {})
-(define st-method-cache-hits 0)
-(define st-method-cache-misses 0)
-
-(define
-  st-method-cache-clear!
-  (fn () (set! st-method-cache {})))
-
-(define
-  st-method-cache-key
-  (fn (cls sel class-side?) (str cls "|" sel "|" (if class-side? "c" "i"))))
-
-(define
-  st-method-cache-stats
-  (fn
-    ()
-    {:hits st-method-cache-hits
-     :misses st-method-cache-misses
-     :size (len (keys st-method-cache))}))
-
-(define
-  st-method-cache-reset-stats!
-  (fn ()
-    (begin
-      (set! st-method-cache-hits 0)
-      (set! st-method-cache-misses 0))))
-
-(define
-  st-class-table-clear!
-  (fn ()
-    (begin
-      (set! st-class-table {})
-      (st-method-cache-clear!))))
-
-(define
-  st-class-define!
-  (fn
-    (name superclass ivars)
-    (begin
-      (set!
-        st-class-table
-        (assoc
-          st-class-table
-          name
-          {:name name
-           :superclass superclass
-           :ivars ivars
-           :methods {}
-           :class-methods {}}))
-      ;; A redefined class can invalidate any cache entries that walked
-      ;; through its old position in the chain. Cheap + correct: drop all.
-      (st-method-cache-clear!)
-      name)))
-
-(define
-  st-class-get
-  (fn (name) (if (has-key? st-class-table name) (get st-class-table name) nil)))
-
-(define
-  st-class-exists?
-  (fn (name) (has-key? st-class-table name)))
-
-(define
-  st-class-superclass
-  (fn
-    (name)
-    (let
-      ((c (st-class-get name)))
-      (cond ((= c nil) nil) (else (get c :superclass))))))
-
-;; Walk class chain root-to-leaf? No, follow superclass chain leaf-to-root.
-;; Returns list of class names starting at `name` and ending with the root.
-(define
-  st-class-chain
-  (fn
-    (name)
-    (let ((acc (list)) (cur name))
-      (begin
-        (define
-          ch-loop
-          (fn
-            ()
-            (when
-              (and (not (= cur nil)) (st-class-exists? cur))
-              (begin
-                (append! acc cur)
-                (set! cur (st-class-superclass cur))
-                (ch-loop)))))
-        (ch-loop)
-        acc))))
-
-;; Inherited + own ivars in declaration order from root to leaf.
-(define
-  st-class-all-ivars
-  (fn
-    (name)
-    (let ((chain (reverse (st-class-chain name))) (out (list)))
-      (begin
-        (for-each
-          (fn
-            (cn)
-            (let
-              ((c (st-class-get cn)))
-              (when
-                (not (= c nil))
-                (for-each (fn (iv) (append! out iv)) (get c :ivars)))))
-          chain)
-        out))))
-
-;; Method install. The defining-class field is stamped on the method record
-;; so super-sends look up from the right point in the chain.
-(define
-  st-class-add-method!
-  (fn
-    (cls-name selector method-ast)
-    (let
-      ((cls (st-class-get cls-name)))
-      (cond
-        ((= cls nil) (error (str "st-class-add-method!: unknown class " cls-name)))
-        (else
-          (let
-            ((m (assoc method-ast :defining-class cls-name)))
-            (begin
-              (set!
-                st-class-table
-                (assoc
-                  st-class-table
-                  cls-name
-                  (assoc
-                    cls
-                    :methods
-                    (assoc (get cls :methods) selector m))))
-              (st-method-cache-clear!)
-              selector)))))))
-
-(define
-  st-class-add-class-method!
-  (fn
-    (cls-name selector method-ast)
-    (let
-      ((cls (st-class-get cls-name)))
-      (cond
-        ((= cls nil) (error (str "st-class-add-class-method!: unknown class " cls-name)))
-        (else
-          (let
-            ((m (assoc method-ast :defining-class cls-name)))
-            (begin
-              (set!
-                st-class-table
-                (assoc
-                  st-class-table
-                  cls-name
-                  (assoc
-                    cls
-                    :class-methods
-                    (assoc (get cls :class-methods) selector m))))
-              (st-method-cache-clear!)
-              selector)))))))
-
-;; Remove a method from a class (instance side). Mostly for tests; runtime
-;; reflection in Phase 4 will use the same primitive.
-(define
-  st-class-remove-method!
-  (fn
-    (cls-name selector)
-    (let ((cls (st-class-get cls-name)))
-      (cond
-        ((= cls nil) (error (str "st-class-remove-method!: unknown class " cls-name)))
-        (else
-          (let ((md (get cls :methods)))
-            (cond
-              ((not (has-key? md selector)) false)
-              (else
-                (let ((new-md {}))
-                  (begin
-                    (for-each
-                      (fn (k)
-                        (when (not (= k selector))
-                          (dict-set! new-md k (get md k))))
-                      (keys md))
-                    (set!
-                      st-class-table
-                      (assoc
-                        st-class-table
-                        cls-name
-                        (assoc cls :methods new-md)))
-                    (st-method-cache-clear!)
-                    true))))))))))
-
-;; Walk-only lookup. Returns the method record (with :defining-class) or nil.
-;; class-side? = true searches :class-methods, false searches :methods.
-(define
-  st-method-lookup-walk
-  (fn
-    (cls-name selector class-side?)
-    (let
-      ((found nil))
-      (begin
-        (define
-          ml-loop
-          (fn
-            (cur)
-            (when
-              (and (= found nil) (not (= cur nil)) (st-class-exists? cur))
-              (let
-                ((c (st-class-get cur)))
-                (let
-                  ((dict (if class-side? (get c :class-methods) (get c :methods))))
-                  (cond
-                    ((has-key? dict selector) (set! found (get dict selector)))
-                    (else (ml-loop (get c :superclass)))))))))
-        (ml-loop cls-name)
-        found))))
-
-;; Cached lookup. Misses are stored as :not-found so doesNotUnderstand paths
-;; don't re-walk on every send.
-(define
-  st-method-lookup
-  (fn
-    (cls-name selector class-side?)
-    (let ((key (st-method-cache-key cls-name selector class-side?)))
-      (cond
-        ((has-key? st-method-cache key)
-          (begin
-            (set! st-method-cache-hits (+ st-method-cache-hits 1))
-            (let ((v (get st-method-cache key)))
-              (cond ((= v :not-found) nil) (else v)))))
-        (else
-          (begin
-            (set! st-method-cache-misses (+ st-method-cache-misses 1))
-            (let ((found (st-method-lookup-walk cls-name selector class-side?)))
-              (begin
-                (set!
-                  st-method-cache
-                  (assoc
-                    st-method-cache
-                    key
-                    (cond ((= found nil) :not-found) (else found))))
-                found))))))))
-
-;; SX value → Smalltalk class name. Native types are not boxed.
-(define
-  st-class-of
-  (fn
-    (v)
-    (cond
-      ((= v nil) "UndefinedObject")
-      ((= v true) "True")
-      ((= v false) "False")
-      ((integer? v) "SmallInteger")
-      ((number? v) "Float")
-      ((string? v) "String")
-      ((symbol? v) "Symbol")
-      ((list? v) "Array")
-      ((and (dict? v) (has-key? v :type) (= (get v :type) "st-instance"))
-        (get v :class))
-      ((and (dict? v) (has-key? v :type) (= (get v :type) "block"))
-        "BlockClosure")
-      ((and (dict? v) (has-key? v :st-block?) (get v :st-block?))
-        "BlockClosure")
-      ((dict? v) "Dictionary")
-      ((lambda? v) "BlockClosure")
-      (else "Object"))))
-
-;; Construct a fresh instance of cls-name. Ivars (own + inherited) start as nil.
-(define
-  st-make-instance
-  (fn
-    (cls-name)
-    (cond
-      ((not (st-class-exists? cls-name))
-        (error (str "st-make-instance: unknown class " cls-name)))
-      (else
-        (let
-          ((iv-names (st-class-all-ivars cls-name)) (ivars {}))
-          (begin
-            (for-each (fn (n) (set! ivars (assoc ivars n nil))) iv-names)
-            {:type "st-instance" :class cls-name :ivars ivars}))))))
-
-(define
-  st-instance?
-  (fn
-    (v)
-    (and (dict? v) (has-key? v :type) (= (get v :type) "st-instance"))))
-
-(define
-  st-iv-get
-  (fn
-    (inst name)
-    (let ((ivs (get inst :ivars)))
-      (if (has-key? ivs name) (get ivs name) nil))))
-
-(define
-  st-iv-set!
-  (fn
-    (inst name value)
-    (let
-      ((new-ivars (assoc (get inst :ivars) name value)))
-      (assoc inst :ivars new-ivars))))
-
-;; Inherits-from check: is `descendant` either equal to `ancestor` or a subclass?
-(define
-  st-class-inherits-from?
-  (fn
-    (descendant ancestor)
-    (let ((found false) (cur descendant))
-      (begin
-        (define
-          ih-loop
-          (fn
-            ()
-            (when
-              (and (not found) (not (= cur nil)) (st-class-exists? cur))
-              (cond
-                ((= cur ancestor) (set! found true))
-                (else
-                  (begin
-                    (set! cur (st-class-superclass cur))
-                    (ih-loop)))))))
-        (ih-loop)
-        found))))
-
-;; Bootstrap the canonical class hierarchy. Reset and rebuild.
-(define
-  st-bootstrap-classes!
-  (fn
-    ()
-    (begin
-      (st-class-table-clear!)
-      ;; Root
-      (st-class-define! "Object" nil (list))
-      ;; Class side machinery
-      (st-class-define! "Behavior" "Object" (list "superclass" "methodDict" "format"))
-      (st-class-define! "ClassDescription" "Behavior" (list "instanceVariables" "organization"))
-      (st-class-define! "Class" "ClassDescription" (list "name" "subclasses"))
-      (st-class-define! "Metaclass" "ClassDescription" (list "thisClass"))
-      ;; Pseudo-variable types
-      (st-class-define! "UndefinedObject" "Object" (list))
-      (st-class-define! "Boolean" "Object" (list))
-      (st-class-define! "True" "Boolean" (list))
-      (st-class-define! "False" "Boolean" (list))
-      ;; Magnitudes
-      (st-class-define! "Magnitude" "Object" (list))
-      (st-class-define! "Number" "Magnitude" (list))
-      (st-class-define! "Integer" "Number" (list))
-      (st-class-define! "SmallInteger" "Integer" (list))
-      (st-class-define! "LargePositiveInteger" "Integer" (list))
-      (st-class-define! "Float" "Number" (list))
-      (st-class-define! "Character" "Magnitude" (list "value"))
-      ;; Collections
-      (st-class-define! "Collection" "Object" (list))
-      (st-class-define! "SequenceableCollection" "Collection" (list))
-      (st-class-define! "ArrayedCollection" "SequenceableCollection" (list))
-      (st-class-define! "Array" "ArrayedCollection" (list))
-      (st-class-define! "String" "ArrayedCollection" (list))
-      (st-class-define! "Symbol" "String" (list))
-      (st-class-define! "OrderedCollection" "SequenceableCollection" (list "array" "firstIndex" "lastIndex"))
-      (st-class-define! "Dictionary" "Collection" (list))
-      ;; Blocks / contexts
-      (st-class-define! "BlockClosure" "Object" (list))
-      ;; Reflection support — Message holds the selector/args for a DNU send.
-      (st-class-define! "Message" "Object" (list "selector" "arguments"))
-      (st-class-add-method! "Message" "selector"
-        (st-parse-method "selector ^ selector"))
-      (st-class-add-method! "Message" "arguments"
-        (st-parse-method "arguments ^ arguments"))
-      (st-class-add-method! "Message" "selector:"
-        (st-parse-method "selector: aSym selector := aSym"))
-      (st-class-add-method! "Message" "arguments:"
-        (st-parse-method "arguments: anArray arguments := anArray"))
-      "ok")))
-
-;; Initialise on load. Tests can re-bootstrap to reset state.
-(st-bootstrap-classes!)

lib/smalltalk/test.sh

@@ -1,141 +0,0 @@
-#!/usr/bin/env bash
-# Fast Smalltalk-on-SX test runner — pipes directly to sx_server.exe.
-# Mirrors lib/haskell/test.sh.
-#
-# Usage:
-#   bash lib/smalltalk/test.sh                     # run all tests
-#   bash lib/smalltalk/test.sh -v                  # verbose
-#   bash lib/smalltalk/test.sh tests/tokenize.sx   # run one file
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
-if [ ! -x "$SX_SERVER" ]; then
-  MAIN_ROOT=$(git worktree list | head -1 | awk '{print $1}')
-  if [ -x "$MAIN_ROOT/$SX_SERVER" ]; then
-    SX_SERVER="$MAIN_ROOT/$SX_SERVER"
-  else
-    echo "ERROR: sx_server.exe not found. Run: cd hosts/ocaml && dune build"
-    exit 1
-  fi
-fi
-
-VERBOSE=""
-FILES=()
-for arg in "$@"; do
-  case "$arg" in
-    -v|--verbose) VERBOSE=1 ;;
-    *) FILES+=("$arg") ;;
-  esac
-done
-
-if [ ${#FILES[@]} -eq 0 ]; then
-  # tokenize.sx must load first — it defines the st-test helpers reused by
-  # subsequent test files. Sort enforces this lexicographically.
-  mapfile -t FILES < <(find lib/smalltalk/tests -maxdepth 2 -name '*.sx' | sort)
-fi
-
-TOTAL_PASS=0
-TOTAL_FAIL=0
-FAILED_FILES=()
-
-for FILE in "${FILES[@]}"; do
-  [ -f "$FILE" ] || { echo "skip $FILE (not found)"; continue; }
-  TMPFILE=$(mktemp)
-  if [ "$(basename "$FILE")" = "tokenize.sx" ]; then
-    cat > "$TMPFILE" <<EPOCHS
-(epoch 1)
-(load "lib/smalltalk/tokenizer.sx")
-(epoch 2)
-(load "$FILE")
-(epoch 3)
-(eval "(list st-test-pass st-test-fail)")
-EPOCHS
-  else
-    cat > "$TMPFILE" <<EPOCHS
-(epoch 1)
-(load "lib/smalltalk/tokenizer.sx")
-(epoch 2)
-(load "lib/smalltalk/parser.sx")
-(epoch 3)
-(load "lib/smalltalk/runtime.sx")
-(epoch 4)
-(load "lib/smalltalk/eval.sx")
-(epoch 5)
-(load "lib/smalltalk/tests/tokenize.sx")
-(epoch 6)
-(load "$FILE")
-(epoch 7)
-(eval "(list st-test-pass st-test-fail)")
-EPOCHS
-  fi
-
-  OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
-  rm -f "$TMPFILE"
-
-  # Final epoch's value: either (ok N (P F)) on one line or
-  # (ok-len N M)\n(P F) where the value is on the following line.
-  LINE=$(echo "$OUTPUT" | awk '/^\(ok-len [0-9]+ / {getline; print}' | tail -1)
-  if [ -z "$LINE" ]; then
-    LINE=$(echo "$OUTPUT" | grep -E '^\(ok [0-9]+ \([0-9]+ [0-9]+\)\)' | tail -1 \
-            | sed -E 's/^\(ok [0-9]+ //; s/\)$//')
-  fi
-  if [ -z "$LINE" ]; then
-    echo "X $FILE: could not extract summary"
-    echo "$OUTPUT" | tail -30
-    TOTAL_FAIL=$((TOTAL_FAIL + 1))
-    FAILED_FILES+=("$FILE")
-    continue
-  fi
-  P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
-  F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
-  TOTAL_PASS=$((TOTAL_PASS + P))
-  TOTAL_FAIL=$((TOTAL_FAIL + F))
-  if [ "$F" -gt 0 ]; then
-    FAILED_FILES+=("$FILE")
-    printf 'X %-40s %d/%d\n' "$FILE" "$P" "$((P+F))"
-    TMPFILE2=$(mktemp)
-    if [ "$(basename "$FILE")" = "tokenize.sx" ]; then
-      cat > "$TMPFILE2" <<EPOCHS
-(epoch 1)
-(load "lib/smalltalk/tokenizer.sx")
-(epoch 2)
-(load "$FILE")
-(epoch 3)
-(eval "(map (fn (f) (get f :name)) st-test-fails)")
-EPOCHS
-    else
-      cat > "$TMPFILE2" <<EPOCHS
-(epoch 1)
-(load "lib/smalltalk/tokenizer.sx")
-(epoch 2)
-(load "lib/smalltalk/parser.sx")
-(epoch 3)
-(load "lib/smalltalk/runtime.sx")
-(epoch 4)
-(load "lib/smalltalk/eval.sx")
-(epoch 5)
-(load "lib/smalltalk/tests/tokenize.sx")
-(epoch 6)
-(load "$FILE")
-(epoch 7)
-(eval "(map (fn (f) (get f :name)) st-test-fails)")
-EPOCHS
-    fi
-    FAILS=$(timeout 60 "$SX_SERVER" < "$TMPFILE2" 2>&1 | grep -E '^\(ok [0-9]+ \(' | tail -1 || true)
-    rm -f "$TMPFILE2"
-    echo "    $FAILS"
-  elif [ "$VERBOSE" = "1" ]; then
-    printf 'OK %-40s %d passed\n' "$FILE" "$P"
-  fi
-done
-
-TOTAL=$((TOTAL_PASS + TOTAL_FAIL))
-if [ $TOTAL_FAIL -eq 0 ]; then
-  echo "OK $TOTAL_PASS/$TOTAL smalltalk-on-sx tests passed"
-else
-  echo "FAIL $TOTAL_PASS/$TOTAL passed, $TOTAL_FAIL failed in: ${FAILED_FILES[*]}"
-fi
-
-[ $TOTAL_FAIL -eq 0 ]

lib/smalltalk/tests/dnu.sx

@@ -1,107 +0,0 @@
-;; doesNotUnderstand: tests.
-
-(set! st-test-pass 0)
-(set! st-test-fail 0)
-(set! st-test-fails (list))
-
-(st-bootstrap-classes!)
-
-(define ev (fn (src) (smalltalk-eval src)))
-(define evp (fn (src) (smalltalk-eval-program src)))
-
-;; ── 1. Bootstrap installs Message class ──
-(st-test "Message exists in bootstrap" (st-class-exists? "Message") true)
-(st-test
-  "Message has expected ivars"
-  (sort (get (st-class-get "Message") :ivars))
-  (sort (list "selector" "arguments")))
-
-;; ── 2. Building a Message directly ──
-(define m (st-make-message "frob:" (list 1 2 3)))
-(st-test "make-message produces st-instance" (st-instance? m) true)
-(st-test "message class" (get m :class) "Message")
-(st-test "message selector ivar"
-  (str (get (get m :ivars) "selector"))
-  "frob:")
-(st-test "message arguments ivar" (get (get m :ivars) "arguments") (list 1 2 3))
-
-;; ── 3. User override of doesNotUnderstand: intercepts unknown sends ──
-(st-class-define! "Logger" "Object" (list "log"))
-(st-class-add-method! "Logger" "log"
-  (st-parse-method "log ^ log"))
-(st-class-add-method! "Logger" "init"
-  (st-parse-method "init log := nil. ^ self"))
-(st-class-add-method! "Logger" "doesNotUnderstand:"
-  (st-parse-method
-    "doesNotUnderstand: aMessage
-       log := aMessage selector.
-       ^ #handled"))
-
-(st-test
-  "user DNU intercepts unknown send"
-  (str
-    (evp "| l | l := Logger new init. l frobnicate. ^ l log"))
-  "frobnicate")
-
-(st-test
-  "user DNU returns its own value"
-  (str (evp "| l | l := Logger new init. ^ l frobnicate"))
-  "handled")
-
-;; Arguments are captured.
-(st-class-add-method! "Logger" "doesNotUnderstand:"
-  (st-parse-method
-    "doesNotUnderstand: aMessage
-       log := aMessage arguments.
-       ^ #handled"))
-
-(st-test
-  "user DNU sees args in Message"
-  (evp "| l | l := Logger new init. l zip: 1 zap: 2. ^ l log")
-  (list 1 2))
-
-;; ── 4. DNU on native receiver ─────────────────────────────────────────
-;; Adding doesNotUnderstand: on Object catches any-receiver sends.
-(st-class-add-method! "Object" "doesNotUnderstand:"
-  (st-parse-method
-    "doesNotUnderstand: aMessage ^ aMessage selector"))
-
-(st-test "Object DNU intercepts on SmallInteger"
-  (str (ev "42 frobnicate"))
-  "frobnicate")
-
-(st-test "Object DNU intercepts on String"
-  (str (ev "'hi' bogusmessage"))
-  "bogusmessage")
-
-(st-test "Object DNU sees arguments"
-  ;; Re-define Object DNU to return the args array.
-  (begin
-    (st-class-add-method! "Object" "doesNotUnderstand:"
-      (st-parse-method "doesNotUnderstand: aMessage ^ aMessage arguments"))
-    (ev "42 plop: 1 plop: 2"))
-  (list 1 2))
-
-;; ── 5. Subclass DNU overrides Object DNU ──────────────────────────────
-(st-class-define! "Proxy" "Object" (list))
-(st-class-add-method! "Proxy" "doesNotUnderstand:"
-  (st-parse-method "doesNotUnderstand: aMessage ^ #proxyHandled"))
-
-(st-test "subclass DNU wins over Object DNU"
-  (str (evp "^ Proxy new whatever"))
-  "proxyHandled")
-
-;; ── 6. Defined methods bypass DNU ─────────────────────────────────────
-(st-class-add-method! "Proxy" "known" (st-parse-method "known ^ 7"))
-(st-test "defined method wins over DNU"
-  (evp "^ Proxy new known")
-  7)
-
-;; ── 7. Block doesNotUnderstand: routes via Object ─────────────────────
-(st-class-add-method! "Object" "doesNotUnderstand:"
-  (st-parse-method "doesNotUnderstand: aMessage ^ #blockDnu"))
-(st-test "block unknown selector goes to DNU"
-  (str (ev "[1] frobnicate"))
-  "blockDnu")
-
-(list st-test-pass st-test-fail)

lib/smalltalk/tests/eval.sx

@@ -1,181 +0,0 @@
-;; Smalltalk evaluator tests — sequential semantics, message dispatch on
-;; native + user receivers, blocks, cascades, return.
-
-(set! st-test-pass 0)
-(set! st-test-fail 0)
-(set! st-test-fails (list))
-
-(st-bootstrap-classes!)
-
-(define ev (fn (src) (smalltalk-eval src)))
-(define evp (fn (src) (smalltalk-eval-program src)))
-
-;; ── 1. Literals ──
-(st-test "int literal" (ev "42") 42)
-(st-test "float literal" (ev "3.14") 3.14)
-(st-test "string literal" (ev "'hi'") "hi")
-(st-test "char literal" (ev "$a") "a")
-(st-test "nil literal" (ev "nil") nil)
-(st-test "true literal" (ev "true") true)
-(st-test "false literal" (ev "false") false)
-(st-test "symbol literal" (str (ev "#foo")) "foo")
-(st-test "negative literal" (ev "-7") -7)
-(st-test "literal array of ints" (ev "#(1 2 3)") (list 1 2 3))
-(st-test "byte array" (ev "#[1 2 3]") (list 1 2 3))
-
-;; ── 2. Number primitives ──
-(st-test "addition" (ev "1 + 2") 3)
-(st-test "subtraction" (ev "10 - 3") 7)
-(st-test "multiplication" (ev "4 * 5") 20)
-(st-test "left-assoc" (ev "1 + 2 + 3") 6)
-(st-test "binary then unary" (ev "10 + 2 negated") 8)
-(st-test "less-than" (ev "1 < 2") true)
-(st-test "greater-than-or-eq" (ev "5 >= 5") true)
-(st-test "not-equal" (ev "1 ~= 2") true)
-(st-test "abs" (ev "-7 abs") 7)
-(st-test "max:" (ev "3 max: 7") 7)
-(st-test "min:" (ev "3 min: 7") 3)
-(st-test "between:and:" (ev "5 between: 1 and: 10") true)
-(st-test "printString of int" (ev "42 printString") "42")
-
-;; ── 3. Boolean primitives ──
-(st-test "true not" (ev "true not") false)
-(st-test "false not" (ev "false not") true)
-(st-test "true & false" (ev "true & false") false)
-(st-test "true | false" (ev "true | false") true)
-(st-test "ifTrue: with true" (ev "true ifTrue: [99]") 99)
-(st-test "ifTrue: with false" (ev "false ifTrue: [99]") nil)
-(st-test "ifTrue:ifFalse: true branch" (ev "true ifTrue: [1] ifFalse: [2]") 1)
-(st-test "ifTrue:ifFalse: false branch" (ev "false ifTrue: [1] ifFalse: [2]") 2)
-(st-test "and: short-circuit" (ev "false and: [1/0]") false)
-(st-test "or: short-circuit" (ev "true or: [1/0]") true)
-
-;; ── 4. Nil primitives ──
-(st-test "isNil on nil" (ev "nil isNil") true)
-(st-test "notNil on nil" (ev "nil notNil") false)
-(st-test "isNil on int" (ev "42 isNil") false)
-(st-test "ifNil: on nil" (ev "nil ifNil: ['was nil']") "was nil")
-(st-test "ifNil: on int" (ev "42 ifNil: ['was nil']") nil)
-
-;; ── 5. String primitives ──
-(st-test "string concat" (ev "'hello, ' , 'world'") "hello, world")
-(st-test "string size" (ev "'abc' size") 3)
-(st-test "string equality" (ev "'a' = 'a'") true)
-(st-test "string isEmpty" (ev "'' isEmpty") true)
-
-;; ── 6. Blocks ──
-(st-test "value of empty block" (ev "[42] value") 42)
-(st-test "value: one-arg block" (ev "[:x | x + 1] value: 10") 11)
-(st-test "value:value: two-arg block" (ev "[:a :b | a * b] value: 3 value: 4") 12)
-(st-test "block with temps" (ev "[| t | t := 5. t * t] value") 25)
-(st-test "block returns last expression" (ev "[1. 2. 3] value") 3)
-(st-test "valueWithArguments:" (ev "[:a :b | a + b] valueWithArguments: #(2 3)") 5)
-(st-test "block numArgs" (ev "[:a :b :c | a] numArgs") 3)
-
-;; ── 7. Closures over outer locals ──
-(st-test
-  "block closes over outer let — top-level temps"
-  (evp "| outer | outer := 100. ^ [:x | x + outer] value: 5")
-  105)
-
-;; ── 8. Cascades ──
-(st-test "simple cascade returns last" (ev "10 + 1; + 2; + 3") 13)
-
-;; ── 9. Sequences and assignment ──
-(st-test "sequence returns last" (evp "1. 2. 3") 3)
-(st-test
-  "assignment + use"
-  (evp "| x | x := 10. x := x + 1. ^ x")
-  11)
-
-;; ── 10. Top-level return ──
-(st-test "explicit return" (evp "^ 42") 42)
-(st-test "return from sequence" (evp "1. ^ 99. 100") 99)
-
-;; ── 11. Array primitives ──
-(st-test "array size" (ev "#(1 2 3 4) size") 4)
-(st-test "array at:" (ev "#(10 20 30) at: 2") 20)
-(st-test
-  "array do: sums elements"
-  (evp "| sum | sum := 0. #(1 2 3 4) do: [:e | sum := sum + e]. ^ sum")
-  10)
-(st-test
-  "array collect:"
-  (ev "#(1 2 3) collect: [:x | x * x]")
-  (list 1 4 9))
-(st-test
-  "array select:"
-  (ev "#(1 2 3 4 5) select: [:x | x > 2]")
-  (list 3 4 5))
-
-;; ── 12. While loop ──
-(st-test
-  "whileTrue: counts down"
-  (evp "| n | n := 5. [n > 0] whileTrue: [n := n - 1]. ^ n")
-  0)
-(st-test
-  "to:do: sums 1..10"
-  (evp "| s | s := 0. 1 to: 10 do: [:i | s := s + i]. ^ s")
-  55)
-
-;; ── 13. User classes — instance variables, methods, send ──
-(st-bootstrap-classes!)
-(st-class-define! "Point" "Object" (list "x" "y"))
-(st-class-add-method! "Point" "x"  (st-parse-method "x ^ x"))
-(st-class-add-method! "Point" "y"  (st-parse-method "y ^ y"))
-(st-class-add-method! "Point" "x:" (st-parse-method "x: v x := v"))
-(st-class-add-method! "Point" "y:" (st-parse-method "y: v y := v"))
-(st-class-add-method! "Point" "+"
-  (st-parse-method "+ other ^ (Point new x: x + other x; y: y + other y; yourself)"))
-(st-class-add-method! "Point" "yourself" (st-parse-method "yourself ^ self"))
-(st-class-add-method! "Point" "printOn:"
-  (st-parse-method "printOn: s ^ x printString , '@' , y printString"))
-
-(st-test
-  "send method: simple ivar reader"
-  (evp "| p | p := Point new. p x: 3. p y: 4. ^ p x")
-  3)
-
-(st-test
-  "method composes via cascade"
-  (evp "| p | p := Point new x: 7; y: 8; yourself. ^ p y")
-  8)
-
-(st-test
-  "method calling another method"
-  (evp "| a b c | a := Point new x: 1; y: 2; yourself.
-        b := Point new x: 10; y: 20; yourself.
-        c := a + b. ^ c x")
-  11)
-
-;; ── 14. Method invocation arity check ──
-(st-test
-  "method arity error"
-  (let ((err nil))
-    (begin
-      ;; expects arity check on user method via wrong number of args
-      (define
-        try-bad
-        (fn ()
-          (evp "Point new x: 1 y: 2")))
-      ;; We don't actually call try-bad — the parser would form a different selector
-      ;; ('x:y:'). Instead, manually invoke an invalid arity:
-      (st-class-define! "ArityCheck" "Object" (list))
-      (st-class-add-method! "ArityCheck" "foo:" (st-parse-method "foo: x ^ x"))
-      err))
-  nil)
-
-;; ── 15. Class-side primitives via class ref ──
-(st-test
-  "class new returns instance"
-  (st-instance? (ev "Point new"))
-  true)
-(st-test
-  "class name"
-  (ev "Point name")
-  "Point")
-
-;; ── 16. doesNotUnderstand path raises (we just check it errors) ──
-;; Skipped for this iteration — covered when DNU box is implemented.
-
-(list st-test-pass st-test-fail)

lib/smalltalk/tests/parse.sx

@@ -1,369 +0,0 @@
-;; Smalltalk parser tests.
-;;
-;; Reuses helpers (st-test, st-deep=?) from tokenize.sx. Counters reset
-;; here so this file's summary covers parse tests only.
-
-(set! st-test-pass 0)
-(set! st-test-fail 0)
-(set! st-test-fails (list))
-
-;; ── 1. Atoms ──
-(st-test "int" (st-parse-expr "42") {:type "lit-int" :value 42})
-(st-test "float" (st-parse-expr "3.14") {:type "lit-float" :value 3.14})
-(st-test "string" (st-parse-expr "'hi'") {:type "lit-string" :value "hi"})
-(st-test "char" (st-parse-expr "$x") {:type "lit-char" :value "x"})
-(st-test "symbol" (st-parse-expr "#foo") {:type "lit-symbol" :value "foo"})
-(st-test "binary symbol" (st-parse-expr "#+") {:type "lit-symbol" :value "+"})
-(st-test "keyword symbol" (st-parse-expr "#at:put:") {:type "lit-symbol" :value "at:put:"})
-(st-test "nil" (st-parse-expr "nil") {:type "lit-nil"})
-(st-test "true" (st-parse-expr "true") {:type "lit-true"})
-(st-test "false" (st-parse-expr "false") {:type "lit-false"})
-(st-test "self" (st-parse-expr "self") {:type "self"})
-(st-test "super" (st-parse-expr "super") {:type "super"})
-(st-test "ident" (st-parse-expr "x") {:type "ident" :name "x"})
-(st-test "negative int" (st-parse-expr "-3") {:type "lit-int" :value -3})
-
-;; ── 2. Literal arrays ──
-(st-test
-  "literal array of ints"
-  (st-parse-expr "#(1 2 3)")
-  {:type "lit-array"
-   :elements (list
-               {:type "lit-int" :value 1}
-               {:type "lit-int" :value 2}
-               {:type "lit-int" :value 3})})
-
-(st-test
-  "literal array mixed"
-  (st-parse-expr "#(1 #foo 'x' true)")
-  {:type "lit-array"
-   :elements (list
-               {:type "lit-int" :value 1}
-               {:type "lit-symbol" :value "foo"}
-               {:type "lit-string" :value "x"}
-               {:type "lit-true"})})
-
-(st-test
-  "literal array bare ident is symbol"
-  (st-parse-expr "#(foo bar)")
-  {:type "lit-array"
-   :elements (list
-               {:type "lit-symbol" :value "foo"}
-               {:type "lit-symbol" :value "bar"})})
-
-(st-test
-  "nested literal array"
-  (st-parse-expr "#(1 (2 3) 4)")
-  {:type "lit-array"
-   :elements (list
-               {:type "lit-int" :value 1}
-               {:type "lit-array"
-                :elements (list
-                            {:type "lit-int" :value 2}
-                            {:type "lit-int" :value 3})}
-               {:type "lit-int" :value 4})})
-
-(st-test
-  "byte array"
-  (st-parse-expr "#[1 2 3]")
-  {:type "lit-byte-array" :elements (list 1 2 3)})
-
-;; ── 3. Unary messages ──
-(st-test
-  "unary single"
-  (st-parse-expr "x foo")
-  {:type "send"
-   :receiver {:type "ident" :name "x"}
-   :selector "foo"
-   :args (list)})
-
-(st-test
-  "unary chain"
-  (st-parse-expr "x foo bar baz")
-  {:type "send"
-   :receiver {:type "send"
-              :receiver {:type "send"
-                         :receiver {:type "ident" :name "x"}
-                         :selector "foo"
-                         :args (list)}
-              :selector "bar"
-              :args (list)}
-   :selector "baz"
-   :args (list)})
-
-(st-test
-  "unary on literal"
-  (st-parse-expr "42 printNl")
-  {:type "send"
-   :receiver {:type "lit-int" :value 42}
-   :selector "printNl"
-   :args (list)})
-
-;; ── 4. Binary messages ──
-(st-test
-  "binary single"
-  (st-parse-expr "1 + 2")
-  {:type "send"
-   :receiver {:type "lit-int" :value 1}
-   :selector "+"
-   :args (list {:type "lit-int" :value 2})})
-
-(st-test
-  "binary left-assoc"
-  (st-parse-expr "1 + 2 + 3")
-  {:type "send"
-   :receiver {:type "send"
-              :receiver {:type "lit-int" :value 1}
-              :selector "+"
-              :args (list {:type "lit-int" :value 2})}
-   :selector "+"
-   :args (list {:type "lit-int" :value 3})})
-
-(st-test
-  "binary same precedence l-to-r"
-  (st-parse-expr "1 + 2 * 3")
-  {:type "send"
-   :receiver {:type "send"
-              :receiver {:type "lit-int" :value 1}
-              :selector "+"
-              :args (list {:type "lit-int" :value 2})}
-   :selector "*"
-   :args (list {:type "lit-int" :value 3})})
-
-;; ── 5. Precedence: unary binds tighter than binary ──
-(st-test
-  "unary tighter than binary"
-  (st-parse-expr "3 + 4 factorial")
-  {:type "send"
-   :receiver {:type "lit-int" :value 3}
-   :selector "+"
-   :args (list
-           {:type "send"
-            :receiver {:type "lit-int" :value 4}
-            :selector "factorial"
-            :args (list)})})
-
-;; ── 6. Keyword messages ──
-(st-test
-  "keyword single"
-  (st-parse-expr "x at: 1")
-  {:type "send"
-   :receiver {:type "ident" :name "x"}
-   :selector "at:"
-   :args (list {:type "lit-int" :value 1})})
-
-(st-test
-  "keyword chain"
-  (st-parse-expr "x at: 1 put: 'a'")
-  {:type "send"
-   :receiver {:type "ident" :name "x"}
-   :selector "at:put:"
-   :args (list {:type "lit-int" :value 1} {:type "lit-string" :value "a"})})
-
-;; ── 7. Precedence: binary tighter than keyword ──
-(st-test
-  "binary tighter than keyword"
-  (st-parse-expr "x at: 1 + 2")
-  {:type "send"
-   :receiver {:type "ident" :name "x"}
-   :selector "at:"
-   :args (list
-           {:type "send"
-            :receiver {:type "lit-int" :value 1}
-            :selector "+"
-            :args (list {:type "lit-int" :value 2})})})
-
-(st-test
-  "keyword absorbs trailing unary"
-  (st-parse-expr "a foo: b bar")
-  {:type "send"
-   :receiver {:type "ident" :name "a"}
-   :selector "foo:"
-   :args (list
-           {:type "send"
-            :receiver {:type "ident" :name "b"}
-            :selector "bar"
-            :args (list)})})
-
-;; ── 8. Parens override precedence ──
-(st-test
-  "paren forces grouping"
-  (st-parse-expr "(1 + 2) * 3")
-  {:type "send"
-   :receiver {:type "send"
-              :receiver {:type "lit-int" :value 1}
-              :selector "+"
-              :args (list {:type "lit-int" :value 2})}
-   :selector "*"
-   :args (list {:type "lit-int" :value 3})})
-
-;; ── 9. Cascade ──
-(st-test
-  "simple cascade"
-  (st-parse-expr "x m1; m2")
-  {:type "cascade"
-   :receiver {:type "ident" :name "x"}
-   :messages (list
-               {:selector "m1" :args (list)}
-               {:selector "m2" :args (list)})})
-
-(st-test
-  "cascade with binary and keyword"
-  (st-parse-expr "Stream new nl; tab; print: 1")
-  {:type "cascade"
-   :receiver {:type "send"
-              :receiver {:type "ident" :name "Stream"}
-              :selector "new"
-              :args (list)}
-   :messages (list
-               {:selector "nl" :args (list)}
-               {:selector "tab" :args (list)}
-               {:selector "print:" :args (list {:type "lit-int" :value 1})})})
-
-;; ── 10. Blocks ──
-(st-test
-  "empty block"
-  (st-parse-expr "[]")
-  {:type "block" :params (list) :temps (list) :body (list)})
-
-(st-test
-  "block one expr"
-  (st-parse-expr "[1 + 2]")
-  {:type "block"
-   :params (list)
-   :temps (list)
-   :body (list
-           {:type "send"
-            :receiver {:type "lit-int" :value 1}
-            :selector "+"
-            :args (list {:type "lit-int" :value 2})})})
-
-(st-test
-  "block with params"
-  (st-parse-expr "[:a :b | a + b]")
-  {:type "block"
-   :params (list "a" "b")
-   :temps (list)
-   :body (list
-           {:type "send"
-            :receiver {:type "ident" :name "a"}
-            :selector "+"
-            :args (list {:type "ident" :name "b"})})})
-
-(st-test
-  "block with temps"
-  (st-parse-expr "[| t | t := 1. t]")
-  {:type "block"
-   :params (list)
-   :temps (list "t")
-   :body (list
-           {:type "assign" :name "t" :expr {:type "lit-int" :value 1}}
-           {:type "ident" :name "t"})})
-
-(st-test
-  "block with params and temps"
-  (st-parse-expr "[:x | | t | t := x + 1. t]")
-  {:type "block"
-   :params (list "x")
-   :temps (list "t")
-   :body (list
-           {:type "assign"
-            :name "t"
-            :expr {:type "send"
-                   :receiver {:type "ident" :name "x"}
-                   :selector "+"
-                   :args (list {:type "lit-int" :value 1})}}
-           {:type "ident" :name "t"})})
-
-;; ── 11. Assignment / return / statements ──
-(st-test
-  "assignment"
-  (st-parse-expr "x := 1")
-  {:type "assign" :name "x" :expr {:type "lit-int" :value 1}})
-
-(st-test
-  "return"
-  (st-parse-expr "1")
-  {:type "lit-int" :value 1})
-
-(st-test
-  "return statement at top level"
-  (st-parse "^ 1")
-  {:type "seq" :temps (list)
-   :exprs (list {:type "return" :expr {:type "lit-int" :value 1}})})
-
-(st-test
-  "two statements"
-  (st-parse "x := 1. y := 2")
-  {:type "seq" :temps (list)
-   :exprs (list
-            {:type "assign" :name "x" :expr {:type "lit-int" :value 1}}
-            {:type "assign" :name "y" :expr {:type "lit-int" :value 2}})})
-
-(st-test
-  "trailing dot allowed"
-  (st-parse "1. 2.")
-  {:type "seq" :temps (list)
-   :exprs (list {:type "lit-int" :value 1} {:type "lit-int" :value 2})})
-
-;; ── 12. Method headers ──
-(st-test
-  "unary method"
-  (st-parse-method "factorial ^ self * (self - 1) factorial")
-  {:type "method"
-   :selector "factorial"
-   :params (list)
-   :temps (list)
-   :pragmas (list)
-   :body (list
-           {:type "return"
-            :expr {:type "send"
-                   :receiver {:type "self"}
-                   :selector "*"
-                   :args (list
-                           {:type "send"
-                            :receiver {:type "send"
-                                       :receiver {:type "self"}
-                                       :selector "-"
-                                       :args (list {:type "lit-int" :value 1})}
-                            :selector "factorial"
-                            :args (list)})}})})
-
-(st-test
-  "binary method"
-  (st-parse-method "+ other ^ 'plus'")
-  {:type "method"
-   :selector "+"
-   :params (list "other")
-   :temps (list)
-   :pragmas (list)
-   :body (list {:type "return" :expr {:type "lit-string" :value "plus"}})})
-
-(st-test
-  "keyword method"
-  (st-parse-method "at: i put: v ^ v")
-  {:type "method"
-   :selector "at:put:"
-   :params (list "i" "v")
-   :temps (list)
-   :pragmas (list)
-   :body (list {:type "return" :expr {:type "ident" :name "v"}})})
-
-(st-test
-  "method with temps"
-  (st-parse-method "twice: x | t | t := x + x. ^ t")
-  {:type "method"
-   :selector "twice:"
-   :params (list "x")
-   :temps (list "t")
-   :pragmas (list)
-   :body (list
-           {:type "assign"
-            :name "t"
-            :expr {:type "send"
-                   :receiver {:type "ident" :name "x"}
-                   :selector "+"
-                   :args (list {:type "ident" :name "x"})}}
-           {:type "return" :expr {:type "ident" :name "t"}})})
-
-(list st-test-pass st-test-fail)

lib/smalltalk/tests/parse_chunks.sx

@@ -1,294 +0,0 @@
-;; Smalltalk chunk-stream parser + pragma tests.
-;;
-;; Reuses helpers (st-test, st-deep=?) from tokenize.sx. Counters reset
-;; here so this file's summary covers chunk + pragma tests only.
-
-(set! st-test-pass 0)
-(set! st-test-fail 0)
-(set! st-test-fails (list))
-
-;; ── 1. Raw chunk reader ──
-(st-test "empty source" (st-read-chunks "") (list))
-(st-test "single chunk" (st-read-chunks "foo!") (list "foo"))
-(st-test "two chunks" (st-read-chunks "a! b!") (list "a" "b"))
-(st-test "trailing no bang" (st-read-chunks "a! b") (list "a" "b"))
-(st-test "empty chunk" (st-read-chunks "a! ! b!") (list "a" "" "b"))
-(st-test
-  "doubled bang escapes"
-  (st-read-chunks "yes!! no!yes!")
-  (list "yes! no" "yes"))
-(st-test
-  "whitespace trimmed"
-  (st-read-chunks "  \n  hello  \n  !")
-  (list "hello"))
-
-;; ── 2. Chunk parser — do-it mode ──
-(st-test
-  "single do-it chunk"
-  (st-parse-chunks "1 + 2!")
-  (list
-    {:kind "expr"
-     :ast {:type "send"
-           :receiver {:type "lit-int" :value 1}
-           :selector "+"
-           :args (list {:type "lit-int" :value 2})}}))
-
-(st-test
-  "two do-it chunks"
-  (st-parse-chunks "x := 1! y := 2!")
-  (list
-    {:kind "expr"
-     :ast {:type "assign" :name "x" :expr {:type "lit-int" :value 1}}}
-    {:kind "expr"
-     :ast {:type "assign" :name "y" :expr {:type "lit-int" :value 2}}}))
-
-(st-test
-  "blank chunk outside methods"
-  (st-parse-chunks "1! ! 2!")
-  (list
-    {:kind "expr" :ast {:type "lit-int" :value 1}}
-    {:kind "blank"}
-    {:kind "expr" :ast {:type "lit-int" :value 2}}))
-
-;; ── 3. Methods batch ──
-(st-test
-  "methodsFor opens method batch"
-  (st-parse-chunks
-    "Foo methodsFor: 'access'! foo ^ 1! bar ^ 2! !")
-  (list
-    {:kind "expr"
-     :ast {:type "send"
-           :receiver {:type "ident" :name "Foo"}
-           :selector "methodsFor:"
-           :args (list {:type "lit-string" :value "access"})}}
-    {:kind "method"
-     :class "Foo"
-     :class-side? false
-     :category "access"
-     :ast {:type "method"
-           :selector "foo"
-           :params (list)
-           :temps (list)
-           :pragmas (list)
-           :body (list
-                   {:type "return" :expr {:type "lit-int" :value 1}})}}
-    {:kind "method"
-     :class "Foo"
-     :class-side? false
-     :category "access"
-     :ast {:type "method"
-           :selector "bar"
-           :params (list)
-           :temps (list)
-           :pragmas (list)
-           :body (list
-                   {:type "return" :expr {:type "lit-int" :value 2}})}}
-    {:kind "end-methods"}))
-
-(st-test
-  "class-side methodsFor"
-  (st-parse-chunks
-    "Foo class methodsFor: 'creation'! make ^ self new! !")
-  (list
-    {:kind "expr"
-     :ast {:type "send"
-           :receiver {:type "send"
-                      :receiver {:type "ident" :name "Foo"}
-                      :selector "class"
-                      :args (list)}
-           :selector "methodsFor:"
-           :args (list {:type "lit-string" :value "creation"})}}
-    {:kind "method"
-     :class "Foo"
-     :class-side? true
-     :category "creation"
-     :ast {:type "method"
-           :selector "make"
-           :params (list)
-           :temps (list)
-           :pragmas (list)
-           :body (list
-                   {:type "return"
-                    :expr {:type "send"
-                           :receiver {:type "self"}
-                           :selector "new"
-                           :args (list)}})}}
-    {:kind "end-methods"}))
-
-(st-test
-  "method batch returns to do-it after empty chunk"
-  (st-parse-chunks
-    "Foo methodsFor: 'a'! m1 ^ 1! ! 99!")
-  (list
-    {:kind "expr"
-     :ast {:type "send"
-           :receiver {:type "ident" :name "Foo"}
-           :selector "methodsFor:"
-           :args (list {:type "lit-string" :value "a"})}}
-    {:kind "method"
-     :class "Foo"
-     :class-side? false
-     :category "a"
-     :ast {:type "method"
-           :selector "m1"
-           :params (list)
-           :temps (list)
-           :pragmas (list)
-           :body (list
-                   {:type "return" :expr {:type "lit-int" :value 1}})}}
-    {:kind "end-methods"}
-    {:kind "expr" :ast {:type "lit-int" :value 99}}))
-
-;; ── 4. Pragmas in method bodies ──
-(st-test
-  "single pragma"
-  (st-parse-method "primAt: i <primitive: 60> ^ self")
-  {:type "method"
-   :selector "primAt:"
-   :params (list "i")
-   :temps (list)
-   :pragmas (list
-              {:selector "primitive:"
-               :args (list {:type "lit-int" :value 60})})
-   :body (list {:type "return" :expr {:type "self"}})})
-
-(st-test
-  "pragma with two keyword pairs"
-  (st-parse-method "fft <primitive: 1 module: 'fft'> ^ nil")
-  {:type "method"
-   :selector "fft"
-   :params (list)
-   :temps (list)
-   :pragmas (list
-              {:selector "primitive:module:"
-               :args (list
-                       {:type "lit-int" :value 1}
-                       {:type "lit-string" :value "fft"})})
-   :body (list {:type "return" :expr {:type "lit-nil"}})})
-
-(st-test
-  "pragma with negative number"
-  (st-parse-method "neg <primitive: -1> ^ nil")
-  {:type "method"
-   :selector "neg"
-   :params (list)
-   :temps (list)
-   :pragmas (list
-              {:selector "primitive:"
-               :args (list {:type "lit-int" :value -1})})
-   :body (list {:type "return" :expr {:type "lit-nil"}})})
-
-(st-test
-  "pragma with symbol arg"
-  (st-parse-method "tagged <category: #algebra> ^ nil")
-  {:type "method"
-   :selector "tagged"
-   :params (list)
-   :temps (list)
-   :pragmas (list
-              {:selector "category:"
-               :args (list {:type "lit-symbol" :value "algebra"})})
-   :body (list {:type "return" :expr {:type "lit-nil"}})})
-
-(st-test
-  "pragma then temps"
-  (st-parse-method "calc <primitive: 1> | t | t := 5. ^ t")
-  {:type "method"
-   :selector "calc"
-   :params (list)
-   :temps (list "t")
-   :pragmas (list
-              {:selector "primitive:"
-               :args (list {:type "lit-int" :value 1})})
-   :body (list
-           {:type "assign" :name "t" :expr {:type "lit-int" :value 5}}
-           {:type "return" :expr {:type "ident" :name "t"}})})
-
-(st-test
-  "temps then pragma"
-  (st-parse-method "calc | t | <primitive: 1> t := 5. ^ t")
-  {:type "method"
-   :selector "calc"
-   :params (list)
-   :temps (list "t")
-   :pragmas (list
-              {:selector "primitive:"
-               :args (list {:type "lit-int" :value 1})})
-   :body (list
-           {:type "assign" :name "t" :expr {:type "lit-int" :value 5}}
-           {:type "return" :expr {:type "ident" :name "t"}})})
-
-(st-test
-  "two pragmas"
-  (st-parse-method "m <primitive: 1> <category: 'a'> ^ self")
-  {:type "method"
-   :selector "m"
-   :params (list)
-   :temps (list)
-   :pragmas (list
-              {:selector "primitive:"
-               :args (list {:type "lit-int" :value 1})}
-              {:selector "category:"
-               :args (list {:type "lit-string" :value "a"})})
-   :body (list {:type "return" :expr {:type "self"}})})
-
-;; ── 5. End-to-end: a small "filed-in" snippet ──
-(st-test
-  "small filed-in class snippet"
-  (st-parse-chunks
-    "Object subclass: #Account
-       instanceVariableNames: 'balance'!
-
-     !Account methodsFor: 'access'!
-     balance
-       ^ balance!
-
-     deposit: amount
-       balance := balance + amount.
-       ^ self! !")
-  (list
-    {:kind "expr"
-     :ast {:type "send"
-           :receiver {:type "ident" :name "Object"}
-           :selector "subclass:instanceVariableNames:"
-           :args (list
-                   {:type "lit-symbol" :value "Account"}
-                   {:type "lit-string" :value "balance"})}}
-    {:kind "blank"}
-    {:kind "expr"
-     :ast {:type "send"
-           :receiver {:type "ident" :name "Account"}
-           :selector "methodsFor:"
-           :args (list {:type "lit-string" :value "access"})}}
-    {:kind "method"
-     :class "Account"
-     :class-side? false
-     :category "access"
-     :ast {:type "method"
-           :selector "balance"
-           :params (list)
-           :temps (list)
-           :pragmas (list)
-           :body (list
-                   {:type "return"
-                    :expr {:type "ident" :name "balance"}})}}
-    {:kind "method"
-     :class "Account"
-     :class-side? false
-     :category "access"
-     :ast {:type "method"
-           :selector "deposit:"
-           :params (list "amount")
-           :temps (list)
-           :pragmas (list)
-           :body (list
-                   {:type "assign"
-                    :name "balance"
-                    :expr {:type "send"
-                           :receiver {:type "ident" :name "balance"}
-                           :selector "+"
-                           :args (list {:type "ident" :name "amount"})}}
-                   {:type "return" :expr {:type "self"}})}}
-    {:kind "end-methods"}))
-
-(list st-test-pass st-test-fail)

lib/smalltalk/tests/runtime.sx

@@ -1,255 +0,0 @@
-;; Smalltalk runtime tests — class table, type→class mapping, instances.
-;;
-;; Reuses helpers (st-test, st-deep=?) from tokenize.sx. Counters reset
-;; here so this file's summary covers runtime tests only.
-
-(set! st-test-pass 0)
-(set! st-test-fail 0)
-(set! st-test-fails (list))
-
-;; Fresh hierarchy for every test file.
-(st-bootstrap-classes!)
-
-;; ── 1. Bootstrap installed expected classes ──
-(st-test "Object exists" (st-class-exists? "Object") true)
-(st-test "Behavior exists" (st-class-exists? "Behavior") true)
-(st-test "Metaclass exists" (st-class-exists? "Metaclass") true)
-(st-test "True/False/UndefinedObject"
-  (and
-    (st-class-exists? "True")
-    (st-class-exists? "False")
-    (st-class-exists? "UndefinedObject"))
-  true)
-(st-test "SmallInteger / Float / Symbol exist"
-  (and
-    (st-class-exists? "SmallInteger")
-    (st-class-exists? "Float")
-    (st-class-exists? "Symbol"))
-  true)
-(st-test "BlockClosure exists" (st-class-exists? "BlockClosure") true)
-
-;; ── 2. Superclass chain ──
-(st-test "Object has no superclass" (st-class-superclass "Object") nil)
-(st-test "Behavior super = Object" (st-class-superclass "Behavior") "Object")
-(st-test "True super = Boolean" (st-class-superclass "True") "Boolean")
-(st-test "Symbol super = String" (st-class-superclass "Symbol") "String")
-(st-test
-  "String chain"
-  (st-class-chain "String")
-  (list "String" "ArrayedCollection" "SequenceableCollection" "Collection" "Object"))
-(st-test
-  "SmallInteger chain"
-  (st-class-chain "SmallInteger")
-  (list "SmallInteger" "Integer" "Number" "Magnitude" "Object"))
-
-;; ── 3. inherits-from? ──
-(st-test "True inherits from Boolean" (st-class-inherits-from? "True" "Boolean") true)
-(st-test "True inherits from Object" (st-class-inherits-from? "True" "Object") true)
-(st-test "True inherits from True" (st-class-inherits-from? "True" "True") true)
-(st-test
-  "True does not inherit from Number"
-  (st-class-inherits-from? "True" "Number")
-  false)
-(st-test
-  "Object does not inherit from Number"
-  (st-class-inherits-from? "Object" "Number")
-  false)
-
-;; ── 4. type→class mapping ──
-(st-test "class-of nil" (st-class-of nil) "UndefinedObject")
-(st-test "class-of true" (st-class-of true) "True")
-(st-test "class-of false" (st-class-of false) "False")
-(st-test "class-of int" (st-class-of 42) "SmallInteger")
-(st-test "class-of zero" (st-class-of 0) "SmallInteger")
-(st-test "class-of negative int" (st-class-of -3) "SmallInteger")
-(st-test "class-of float" (st-class-of 3.14) "Float")
-(st-test "class-of string" (st-class-of "hi") "String")
-(st-test "class-of symbol" (st-class-of (quote foo)) "Symbol")
-(st-test "class-of list" (st-class-of (list 1 2)) "Array")
-(st-test "class-of empty list" (st-class-of (list)) "Array")
-(st-test "class-of lambda" (st-class-of (fn (x) x)) "BlockClosure")
-(st-test "class-of dict" (st-class-of {:a 1}) "Dictionary")
-
-;; ── 5. User class definition ──
-(st-class-define! "Account" "Object" (list "balance" "owner"))
-(st-class-define! "SavingsAccount" "Account" (list "rate"))
-
-(st-test "Account exists" (st-class-exists? "Account") true)
-(st-test "Account super = Object" (st-class-superclass "Account") "Object")
-(st-test
-  "SavingsAccount chain"
-  (st-class-chain "SavingsAccount")
-  (list "SavingsAccount" "Account" "Object"))
-(st-test
-  "SavingsAccount own ivars"
-  (get (st-class-get "SavingsAccount") :ivars)
-  (list "rate"))
-(st-test
-  "SavingsAccount inherited+own ivars"
-  (st-class-all-ivars "SavingsAccount")
-  (list "balance" "owner" "rate"))
-
-;; ── 6. Instance construction ──
-(define a1 (st-make-instance "Account"))
-(st-test "instance is st-instance" (st-instance? a1) true)
-(st-test "instance class" (get a1 :class) "Account")
-(st-test "instance ivars start nil" (st-iv-get a1 "balance") nil)
-(st-test
-  "instance has all expected ivars"
-  (sort (keys (get a1 :ivars)))
-  (sort (list "balance" "owner")))
-(define a2 (st-iv-set! a1 "balance" 100))
-(st-test "iv-set! returns updated copy" (st-iv-get a2 "balance") 100)
-(st-test "iv-set! does not mutate original" (st-iv-get a1 "balance") nil)
-(st-test "class-of instance" (st-class-of a1) "Account")
-
-(define s1 (st-make-instance "SavingsAccount"))
-(st-test
-  "subclass instance has all inherited ivars"
-  (sort (keys (get s1 :ivars)))
-  (sort (list "balance" "owner" "rate")))
-
-;; ── 7. Method install + lookup ──
-(st-class-add-method!
-  "Account"
-  "balance"
-  (st-parse-method "balance ^ balance"))
-(st-class-add-method!
-  "Account"
-  "deposit:"
-  (st-parse-method "deposit: amount balance := balance + amount. ^ self"))
-
-(st-test
-  "method registered"
-  (has-key? (get (st-class-get "Account") :methods) "balance")
-  true)
-
-(st-test
-  "method lookup direct"
-  (= (st-method-lookup "Account" "balance" false) nil)
-  false)
-
-(st-test
-  "method lookup walks superclass"
-  (= (st-method-lookup "SavingsAccount" "deposit:" false) nil)
-  false)
-
-(st-test
-  "method lookup unknown selector"
-  (st-method-lookup "Account" "frobnicate" false)
-  nil)
-
-(st-test
-  "method lookup records defining class"
-  (get (st-method-lookup "SavingsAccount" "balance" false) :defining-class)
-  "Account")
-
-;; SavingsAccount overrides deposit:
-(st-class-add-method!
-  "SavingsAccount"
-  "deposit:"
-  (st-parse-method "deposit: amount ^ super deposit: amount + 1"))
-
-(st-test
-  "subclass override picked first"
-  (get (st-method-lookup "SavingsAccount" "deposit:" false) :defining-class)
-  "SavingsAccount")
-
-(st-test
-  "Account still finds its own deposit:"
-  (get (st-method-lookup "Account" "deposit:" false) :defining-class)
-  "Account")
-
-;; ── 8. Class-side methods ──
-(st-class-add-class-method!
-  "Account"
-  "new"
-  (st-parse-method "new ^ super new"))
-(st-test
-  "class-side lookup"
-  (= (st-method-lookup "Account" "new" true) nil)
-  false)
-(st-test
-  "instance-side does not find class method"
-  (st-method-lookup "Account" "new" false)
-  nil)
-
-;; ── 9. Re-bootstrap resets table ──
-(st-bootstrap-classes!)
-(st-test "after re-bootstrap Account gone" (st-class-exists? "Account") false)
-(st-test "after re-bootstrap Object stays" (st-class-exists? "Object") true)
-
-;; ── 10. Method-lookup cache ──
-(st-bootstrap-classes!)
-(st-class-define! "Foo" "Object" (list))
-(st-class-define! "Bar" "Foo" (list))
-(st-class-add-method! "Foo" "greet" (st-parse-method "greet ^ 1"))
-
-;; Bootstrap clears cache; record stats from now.
-(st-method-cache-reset-stats!)
-
-;; First lookup is a miss; second is a hit.
-(st-method-lookup "Bar" "greet" false)
-(st-test
-  "first lookup recorded as miss"
-  (get (st-method-cache-stats) :misses)
-  1)
-(st-test
-  "first lookup recorded as hit count zero"
-  (get (st-method-cache-stats) :hits)
-  0)
-
-(st-method-lookup "Bar" "greet" false)
-(st-test
-  "second lookup hits cache"
-  (get (st-method-cache-stats) :hits)
-  1)
-
-;; Misses are also cached as :not-found.
-(st-method-lookup "Bar" "frobnicate" false)
-(st-method-lookup "Bar" "frobnicate" false)
-(st-test
-  "negative-result caches"
-  (get (st-method-cache-stats) :hits)
-  2)
-
-;; Adding a new method invalidates the cache.
-(st-class-add-method! "Bar" "greet" (st-parse-method "greet ^ 2"))
-(st-test
-  "cache cleared on method add"
-  (get (st-method-cache-stats) :size)
-  0)
-(st-test
-  "after invalidation lookup picks up override"
-  (get (st-method-lookup "Bar" "greet" false) :defining-class)
-  "Bar")
-
-;; Removing a method also invalidates and exposes the inherited one.
-(st-class-remove-method! "Bar" "greet")
-(st-test
-  "after remove lookup falls through to Foo"
-  (get (st-method-lookup "Bar" "greet" false) :defining-class)
-  "Foo")
-
-;; Cache survives across unrelated class-table mutations? No — define! clears.
-(st-method-lookup "Foo" "greet" false)  ; warm cache
-(st-class-define! "Baz" "Object" (list))
-(st-test
-  "class-define clears cache"
-  (get (st-method-cache-stats) :size)
-  0)
-
-;; Class-side and instance-side cache entries are separate keys.
-(st-class-add-class-method! "Foo" "make" (st-parse-method "make ^ self new"))
-(st-method-lookup "Foo" "make" true)
-(st-method-lookup "Foo" "make" false)
-(st-test
-  "class-side hit found, instance-side stored as not-found"
-  (= (st-method-lookup "Foo" "make" true) nil)
-  false)
-(st-test
-  "instance-side same selector returns nil"
-  (st-method-lookup "Foo" "make" false)
-  nil)
-
-(list st-test-pass st-test-fail)

lib/smalltalk/tests/super.sx

@@ -1,149 +0,0 @@
-;; super-send tests.
-;;
-;; super looks up methods starting at the *defining class*'s superclass —
-;; not the receiver's class. This means an inherited method that uses
-;; `super` always reaches the same parent regardless of where in the
-;; subclass chain the receiver actually sits.
-
-(set! st-test-pass 0)
-(set! st-test-fail 0)
-(set! st-test-fails (list))
-
-(st-bootstrap-classes!)
-
-(define ev (fn (src) (smalltalk-eval src)))
-(define evp (fn (src) (smalltalk-eval-program src)))
-
-;; ── 1. Basic super: subclass override calls parent ──
-(st-class-define! "Animal" "Object" (list))
-(st-class-add-method! "Animal" "speak"
-  (st-parse-method "speak ^ #generic"))
-
-(st-class-define! "Dog" "Animal" (list))
-(st-class-add-method! "Dog" "speak"
-  (st-parse-method "speak ^ super speak"))
-
-(st-test
-  "super reaches parent's speak"
-  (str (evp "^ Dog new speak"))
-  "generic")
-
-(st-class-add-method! "Dog" "loud"
-  (st-parse-method "loud ^ super speak , #'!' asString"))
-;; The above tries to use `, #'!' asString` which won't quite work with my
-;; primitives. Replace with a simpler test.
-(st-class-add-method! "Dog" "loud"
-  (st-parse-method "loud | s | s := super speak. ^ s"))
-
-(st-test
-  "method calls super and returns same"
-  (str (evp "^ Dog new loud"))
-  "generic")
-
-;; ── 2. Super with argument ──
-(st-class-add-method! "Animal" "greet:"
-  (st-parse-method "greet: name ^ name , ' (animal)'"))
-(st-class-add-method! "Dog" "greet:"
-  (st-parse-method "greet: name ^ super greet: name"))
-
-(st-test
-  "super with arg reaches parent and threads value"
-  (evp "^ Dog new greet: 'Rex'")
-  "Rex (animal)")
-
-;; ── 3. Inherited method uses *defining* class for super ──
-;; A defines speak ^ 'A'
-;; A defines speakLog: which sends `super speak`. super starts at Object → no
-;; speak there → DNU. So invoke speakLog from A subclass to test that super
-;; resolves to A's parent (Object), not the subclass's parent.
-(st-class-define! "RootSpeaker" "Object" (list))
-(st-class-add-method! "RootSpeaker" "speak"
-  (st-parse-method "speak ^ #root"))
-(st-class-add-method! "RootSpeaker" "speakDelegate"
-  (st-parse-method "speakDelegate ^ super speak"))
-;; Object has no speak (and we add a temporary DNU for testing).
-(st-class-add-method! "Object" "doesNotUnderstand:"
-  (st-parse-method "doesNotUnderstand: aMessage ^ #dnu"))
-
-(st-class-define! "ChildSpeaker" "RootSpeaker" (list))
-(st-class-add-method! "ChildSpeaker" "speak"
-  (st-parse-method "speak ^ #child"))
-
-(st-test
-  "inherited speakDelegate uses RootSpeaker's super, not ChildSpeaker's"
-  (str (evp "^ ChildSpeaker new speakDelegate"))
-  "dnu")
-
-;; A non-inherited path: ChildSpeaker overrides speak, but speakDelegate is
-;; inherited from RootSpeaker. The super inside speakDelegate must resolve to
-;; *Object* (RootSpeaker's parent), not to RootSpeaker (ChildSpeaker's parent).
-(st-test
-  "inherited method's super does not call subclass override"
-  (str (evp "^ ChildSpeaker new speak"))
-  "child")
-
-;; Remove the Object DNU shim now that those tests are done.
-(st-class-remove-method! "Object" "doesNotUnderstand:")
-
-;; ── 4. Multi-level: A → B → C ──
-(st-class-define! "GA" "Object" (list))
-(st-class-add-method! "GA" "level"
-  (st-parse-method "level ^ #ga"))
-
-(st-class-define! "GB" "GA" (list))
-(st-class-add-method! "GB" "level"
-  (st-parse-method "level ^ super level"))
-
-(st-class-define! "GC" "GB" (list))
-(st-class-add-method! "GC" "level"
-  (st-parse-method "level ^ super level"))
-
-(st-test
-  "super chains to grandparent"
-  (str (evp "^ GC new level"))
-  "ga")
-
-;; ── 5. Super inside a block ──
-(st-class-add-method! "Dog" "delayed"
-  (st-parse-method "delayed ^ [super speak] value"))
-(st-test
-  "super inside a block resolves correctly"
-  (str (evp "^ Dog new delayed"))
-  "generic")
-
-;; ── 6. Super send keeps receiver as self ──
-(st-class-define! "Counter" "Object" (list "count"))
-(st-class-add-method! "Counter" "init"
-  (st-parse-method "init count := 0. ^ self"))
-(st-class-add-method! "Counter" "incr"
-  (st-parse-method "incr count := count + 1. ^ self"))
-(st-class-add-method! "Counter" "count"
-  (st-parse-method "count ^ count"))
-
-(st-class-define! "DoubleCounter" "Counter" (list))
-(st-class-add-method! "DoubleCounter" "incr"
-  (st-parse-method "incr super incr. super incr. ^ self"))
-
-(st-test
-  "super uses same receiver — ivars on self update"
-  (evp "| c | c := DoubleCounter new init. c incr. ^ c count")
-  2)
-
-;; ── 7. Super on a class without an immediate parent definition ──
-;; Mid-chain class with no override at this level: super resolves correctly
-;; through the missing rung.
-(st-class-define! "Mid" "Animal" (list))
-(st-class-define! "Pup" "Mid" (list))
-(st-class-add-method! "Pup" "speak"
-  (st-parse-method "speak ^ super speak"))
-
-(st-test
-  "super walks past intermediate class with no override"
-  (str (evp "^ Pup new speak"))
-  "generic")
-
-;; ── 8. Super outside any method errors ──
-;; (We don't have try/catch in SX from here; skip the negative test —
-;;  documented behaviour is that st-super-send errors when method-class is nil.)
-
-(list st-test-pass st-test-fail)

lib/smalltalk/tests/tokenize.sx

@@ -1,362 +0,0 @@
-;; Smalltalk tokenizer tests.
-;;
-;; Lightweight runner: each test checks actual vs expected with structural
-;; equality and accumulates pass/fail counters. Final summary read by
-;; lib/smalltalk/test.sh.
-
-(define
-  st-deep=?
-  (fn
-    (a b)
-    (cond
-      ((= a b) true)
-      ((and (dict? a) (dict? b))
-        (let
-          ((ak (keys a)) (bk (keys b)))
-          (if
-            (not (= (len ak) (len bk)))
-            false
-            (every?
-              (fn
-                (k)
-                (and (has-key? b k) (st-deep=? (get a k) (get b k))))
-              ak))))
-      ((and (list? a) (list? b))
-        (if
-          (not (= (len a) (len b)))
-          false
-          (let
-            ((i 0) (ok true))
-            (begin
-              (define
-                de-loop
-                (fn
-                  ()
-                  (when
-                    (and ok (< i (len a)))
-                    (begin
-                      (when
-                        (not (st-deep=? (nth a i) (nth b i)))
-                        (set! ok false))
-                      (set! i (+ i 1))
-                      (de-loop)))))
-              (de-loop)
-              ok))))
-      (:else false))))
-
-(define st-test-pass 0)
-(define st-test-fail 0)
-(define st-test-fails (list))
-
-(define
-  st-test
-  (fn
-    (name actual expected)
-    (if
-      (st-deep=? actual expected)
-      (set! st-test-pass (+ st-test-pass 1))
-      (begin
-        (set! st-test-fail (+ st-test-fail 1))
-        (append! st-test-fails {:actual actual :expected expected :name name})))))
-
-;; Strip eof and project to just :type/:value.
-(define
-  st-toks
-  (fn
-    (src)
-    (map
-      (fn (tok) {:type (get tok :type) :value (get tok :value)})
-      (filter
-        (fn (tok) (not (= (get tok :type) "eof")))
-        (st-tokenize src)))))
-
-;; ── 1. Whitespace / empty ──
-(st-test "empty input" (st-toks "") (list))
-(st-test "all whitespace" (st-toks "   \t\n  ") (list))
-
-;; ── 2. Identifiers ──
-(st-test
-  "lowercase ident"
-  (st-toks "foo")
-  (list {:type "ident" :value "foo"}))
-
-(st-test
-  "capitalised ident"
-  (st-toks "Foo")
-  (list {:type "ident" :value "Foo"}))
-
-(st-test
-  "underscore ident"
-  (st-toks "_x")
-  (list {:type "ident" :value "_x"}))
-
-(st-test
-  "digits in ident"
-  (st-toks "foo123")
-  (list {:type "ident" :value "foo123"}))
-
-(st-test
-  "two idents separated"
-  (st-toks "foo bar")
-  (list {:type "ident" :value "foo"} {:type "ident" :value "bar"}))
-
-;; ── 3. Keyword selectors ──
-(st-test
-  "keyword selector"
-  (st-toks "foo:")
-  (list {:type "keyword" :value "foo:"}))
-
-(st-test
-  "keyword call"
-  (st-toks "x at: 1")
-  (list
-    {:type "ident" :value "x"}
-    {:type "keyword" :value "at:"}
-    {:type "number" :value 1}))
-
-(st-test
-  "two-keyword chain stays separate"
-  (st-toks "at: 1 put: 2")
-  (list
-    {:type "keyword" :value "at:"}
-    {:type "number" :value 1}
-    {:type "keyword" :value "put:"}
-    {:type "number" :value 2}))
-
-(st-test
-  "ident then assign — not a keyword"
-  (st-toks "x := 1")
-  (list
-    {:type "ident" :value "x"}
-    {:type "assign" :value ":="}
-    {:type "number" :value 1}))
-
-;; ── 4. Numbers ──
-(st-test
-  "integer"
-  (st-toks "42")
-  (list {:type "number" :value 42}))
-
-(st-test
-  "float"
-  (st-toks "3.14")
-  (list {:type "number" :value 3.14}))
-
-(st-test
-  "hex radix"
-  (st-toks "16rFF")
-  (list
-    {:type "number"
-     :value
-     {:radix 16 :digits "FF" :value 255 :kind "radix"}}))
-
-(st-test
-  "binary radix"
-  (st-toks "2r1011")
-  (list
-    {:type "number"
-     :value
-     {:radix 2 :digits "1011" :value 11 :kind "radix"}}))
-
-(st-test
-  "exponent"
-  (st-toks "1e3")
-  (list {:type "number" :value 1000}))
-
-(st-test
-  "negative exponent (parser handles minus)"
-  (st-toks "1.5e-2")
-  (list {:type "number" :value 0.015}))
-
-;; ── 5. Strings ──
-(st-test
-  "simple string"
-  (st-toks "'hi'")
-  (list {:type "string" :value "hi"}))
-
-(st-test
-  "empty string"
-  (st-toks "''")
-  (list {:type "string" :value ""}))
-
-(st-test
-  "doubled-quote escape"
-  (st-toks "'a''b'")
-  (list {:type "string" :value "a'b"}))
-
-;; ── 6. Characters ──
-(st-test
-  "char literal letter"
-  (st-toks "$a")
-  (list {:type "char" :value "a"}))
-
-(st-test
-  "char literal punct"
-  (st-toks "$$")
-  (list {:type "char" :value "$"}))
-
-(st-test
-  "char literal space"
-  (st-toks "$ ")
-  (list {:type "char" :value " "}))
-
-;; ── 7. Symbols ──
-(st-test
-  "symbol ident"
-  (st-toks "#foo")
-  (list {:type "symbol" :value "foo"}))
-
-(st-test
-  "symbol binary"
-  (st-toks "#+")
-  (list {:type "symbol" :value "+"}))
-
-(st-test
-  "symbol arrow"
-  (st-toks "#->")
-  (list {:type "symbol" :value "->"}))
-
-(st-test
-  "symbol keyword chain"
-  (st-toks "#at:put:")
-  (list {:type "symbol" :value "at:put:"}))
-
-(st-test
-  "quoted symbol with spaces"
-  (st-toks "#'foo bar'")
-  (list {:type "symbol" :value "foo bar"}))
-
-;; ── 8. Literal arrays / byte arrays ──
-(st-test
-  "literal array open"
-  (st-toks "#(1 2)")
-  (list
-    {:type "array-open" :value "#("}
-    {:type "number" :value 1}
-    {:type "number" :value 2}
-    {:type "rparen" :value ")"}))
-
-(st-test
-  "byte array open"
-  (st-toks "#[1 2 3]")
-  (list
-    {:type "byte-array-open" :value "#["}
-    {:type "number" :value 1}
-    {:type "number" :value 2}
-    {:type "number" :value 3}
-    {:type "rbracket" :value "]"}))
-
-;; ── 9. Binary selectors ──
-(st-test "plus" (st-toks "+") (list {:type "binary" :value "+"}))
-(st-test "minus" (st-toks "-") (list {:type "binary" :value "-"}))
-(st-test "star" (st-toks "*") (list {:type "binary" :value "*"}))
-(st-test "double-equal" (st-toks "==") (list {:type "binary" :value "=="}))
-(st-test "leq" (st-toks "<=") (list {:type "binary" :value "<="}))
-(st-test "geq" (st-toks ">=") (list {:type "binary" :value ">="}))
-(st-test "neq" (st-toks "~=") (list {:type "binary" :value "~="}))
-(st-test "arrow" (st-toks "->") (list {:type "binary" :value "->"}))
-(st-test "comma" (st-toks ",") (list {:type "binary" :value ","}))
-
-(st-test
-  "binary in expression"
-  (st-toks "a + b")
-  (list
-    {:type "ident" :value "a"}
-    {:type "binary" :value "+"}
-    {:type "ident" :value "b"}))
-
-;; ── 10. Punctuation ──
-(st-test "lparen" (st-toks "(") (list {:type "lparen" :value "("}))
-(st-test "rparen" (st-toks ")") (list {:type "rparen" :value ")"}))
-(st-test "lbracket" (st-toks "[") (list {:type "lbracket" :value "["}))
-(st-test "rbracket" (st-toks "]") (list {:type "rbracket" :value "]"}))
-(st-test "lbrace" (st-toks "{") (list {:type "lbrace" :value "{"}))
-(st-test "rbrace" (st-toks "}") (list {:type "rbrace" :value "}"}))
-(st-test "period" (st-toks ".") (list {:type "period" :value "."}))
-(st-test "semi" (st-toks ";") (list {:type "semi" :value ";"}))
-(st-test "bar" (st-toks "|") (list {:type "bar" :value "|"}))
-(st-test "caret" (st-toks "^") (list {:type "caret" :value "^"}))
-(st-test "bang" (st-toks "!") (list {:type "bang" :value "!"}))
-(st-test "colon" (st-toks ":") (list {:type "colon" :value ":"}))
-(st-test "assign" (st-toks ":=") (list {:type "assign" :value ":="}))
-
-;; ── 11. Comments ──
-(st-test "comment skipped" (st-toks "\"hello\"") (list))
-(st-test
-  "comment between tokens"
-  (st-toks "a \"comment\" b")
-  (list {:type "ident" :value "a"} {:type "ident" :value "b"}))
-(st-test
-  "multi-line comment"
-  (st-toks "\"line1\nline2\"42")
-  (list {:type "number" :value 42}))
-
-;; ── 12. Compound expressions ──
-(st-test
-  "block with params"
-  (st-toks "[:a :b | a + b]")
-  (list
-    {:type "lbracket" :value "["}
-    {:type "colon" :value ":"}
-    {:type "ident" :value "a"}
-    {:type "colon" :value ":"}
-    {:type "ident" :value "b"}
-    {:type "bar" :value "|"}
-    {:type "ident" :value "a"}
-    {:type "binary" :value "+"}
-    {:type "ident" :value "b"}
-    {:type "rbracket" :value "]"}))
-
-(st-test
-  "cascade"
-  (st-toks "x m1; m2")
-  (list
-    {:type "ident" :value "x"}
-    {:type "ident" :value "m1"}
-    {:type "semi" :value ";"}
-    {:type "ident" :value "m2"}))
-
-(st-test
-  "method body return"
-  (st-toks "^ self foo")
-  (list
-    {:type "caret" :value "^"}
-    {:type "ident" :value "self"}
-    {:type "ident" :value "foo"}))
-
-(st-test
-  "class declaration head"
-  (st-toks "Object subclass: #Foo")
-  (list
-    {:type "ident" :value "Object"}
-    {:type "keyword" :value "subclass:"}
-    {:type "symbol" :value "Foo"}))
-
-(st-test
-  "temp declaration"
-  (st-toks "| t1 t2 |")
-  (list
-    {:type "bar" :value "|"}
-    {:type "ident" :value "t1"}
-    {:type "ident" :value "t2"}
-    {:type "bar" :value "|"}))
-
-(st-test
-  "chunk separator"
-  (st-toks "Foo bar !")
-  (list
-    {:type "ident" :value "Foo"}
-    {:type "ident" :value "bar"}
-    {:type "bang" :value "!"}))
-
-(st-test
-  "keyword call with binary precedence"
-  (st-toks "x foo: 1 + 2")
-  (list
-    {:type "ident" :value "x"}
-    {:type "keyword" :value "foo:"}
-    {:type "number" :value 1}
-    {:type "binary" :value "+"}
-    {:type "number" :value 2}))
-
-(list st-test-pass st-test-fail)

lib/smalltalk/tokenizer.sx

@@ -1,366 +0,0 @@
-;; Smalltalk tokenizer.
-;;
-;; Token types:
-;;   ident      identifier (foo, Foo, _x)
-;;   keyword    selector keyword (foo:) — value is "foo:" with the colon
-;;   binary     binary selector chars run together (+, ==, ->, <=, ~=, ...)
-;;   number     integer or float; radix integers like 16rFF supported
-;;   string     'hello''world' style
-;;   char       $c
-;;   symbol     #foo, #foo:bar:, #+, #'with spaces'
-;;   array-open  #(
-;;   byte-array-open  #[
-;;   lparen rparen lbracket rbracket lbrace rbrace
-;;   period semi bar caret colon assign bang
-;;   eof
-;;
-;; Comments "…" are skipped.
-
-(define st-make-token (fn (type value pos) {:type type :value value :pos pos}))
-
-(define st-digit? (fn (c) (and (not (= c nil)) (>= c "0") (<= c "9"))))
-
-(define
-  st-letter?
-  (fn
-    (c)
-    (and
-      (not (= c nil))
-      (or (and (>= c "a") (<= c "z")) (and (>= c "A") (<= c "Z"))))))
-
-(define st-ident-start? (fn (c) (or (st-letter? c) (= c "_"))))
-
-(define st-ident-char? (fn (c) (or (st-ident-start? c) (st-digit? c))))
-
-(define st-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
-
-(define
-  st-binary-chars
-  (list "+" "-" "*" "/" "\\" "~" "<" ">" "=" "@" "%" "&" "?" ","))
-
-(define
-  st-binary-char?
-  (fn (c) (and (not (= c nil)) (contains? st-binary-chars c))))
-
-(define
-  st-radix-digit?
-  (fn
-    (c)
-    (and
-      (not (= c nil))
-      (or (st-digit? c) (and (>= c "A") (<= c "Z"))))))
-
-(define
-  st-tokenize
-  (fn
-    (src)
-    (let
-      ((tokens (list)) (pos 0) (src-len (len src)))
-      (define
-        pk
-        (fn
-          (offset)
-          (if (< (+ pos offset) src-len) (nth src (+ pos offset)) nil)))
-      (define cur (fn () (pk 0)))
-      (define advance! (fn (n) (set! pos (+ pos n))))
-      (define
-        push!
-        (fn
-          (type value start)
-          (append! tokens (st-make-token type value start))))
-      (define
-        skip-comment!
-        (fn
-          ()
-          (cond
-            ((>= pos src-len) nil)
-            ((= (cur) "\"") (advance! 1))
-            (else (begin (advance! 1) (skip-comment!))))))
-      (define
-        skip-ws!
-        (fn
-          ()
-          (cond
-            ((>= pos src-len) nil)
-            ((st-ws? (cur)) (begin (advance! 1) (skip-ws!)))
-            ((= (cur) "\"") (begin (advance! 1) (skip-comment!) (skip-ws!)))
-            (else nil))))
-      (define
-        read-ident-chars!
-        (fn
-          ()
-          (when
-            (and (< pos src-len) (st-ident-char? (cur)))
-            (begin (advance! 1) (read-ident-chars!)))))
-      (define
-        read-decimal-digits!
-        (fn
-          ()
-          (when
-            (and (< pos src-len) (st-digit? (cur)))
-            (begin (advance! 1) (read-decimal-digits!)))))
-      (define
-        read-radix-digits!
-        (fn
-          ()
-          (when
-            (and (< pos src-len) (st-radix-digit? (cur)))
-            (begin (advance! 1) (read-radix-digits!)))))
-      (define
-        read-exp-part!
-        (fn
-          ()
-          (when
-            (and
-              (< pos src-len)
-              (or (= (cur) "e") (= (cur) "E"))
-              (let
-                ((p1 (pk 1)) (p2 (pk 2)))
-                (or
-                  (st-digit? p1)
-                  (and (or (= p1 "+") (= p1 "-")) (st-digit? p2)))))
-            (begin
-              (advance! 1)
-              (when
-                (and (< pos src-len) (or (= (cur) "+") (= (cur) "-")))
-                (advance! 1))
-              (read-decimal-digits!)))))
-      (define
-        read-number
-        (fn
-          (start)
-          (begin
-            (read-decimal-digits!)
-            (cond
-              ((and (< pos src-len) (= (cur) "r"))
-                (let
-                  ((base-str (slice src start pos)))
-                  (begin
-                    (advance! 1)
-                    (let
-                      ((rstart pos))
-                      (begin
-                        (read-radix-digits!)
-                        (let
-                          ((digits (slice src rstart pos)))
-                          {:radix (parse-number base-str)
-                           :digits digits
-                           :value (parse-radix base-str digits)
-                           :kind "radix"}))))))
-              ((and
-                  (< pos src-len)
-                  (= (cur) ".")
-                  (st-digit? (pk 1)))
-                (begin
-                  (advance! 1)
-                  (read-decimal-digits!)
-                  (read-exp-part!)
-                  (parse-number (slice src start pos))))
-              (else
-                (begin
-                  (read-exp-part!)
-                  (parse-number (slice src start pos))))))))
-      (define
-        parse-radix
-        (fn
-          (base-str digits)
-          (let
-            ((base (parse-number base-str))
-              (chars digits)
-              (n-len (len digits))
-              (idx 0)
-              (acc 0))
-            (begin
-              (define
-                rd-loop
-                (fn
-                  ()
-                  (when
-                    (< idx n-len)
-                    (let
-                      ((c (nth chars idx)))
-                      (let
-                        ((d (cond
-                              ((and (>= c "0") (<= c "9")) (- (char-code c) 48))
-                              ((and (>= c "A") (<= c "Z")) (- (char-code c) 55))
-                              (else 0))))
-                        (begin
-                          (set! acc (+ (* acc base) d))
-                          (set! idx (+ idx 1))
-                          (rd-loop)))))))
-              (rd-loop)
-              acc))))
-      (define
-        read-string
-        (fn
-          ()
-          (let
-            ((chars (list)))
-            (begin
-              (advance! 1)
-              (define
-                loop
-                (fn
-                  ()
-                  (cond
-                    ((>= pos src-len) nil)
-                    ((= (cur) "'")
-                      (cond
-                        ((= (pk 1) "'")
-                          (begin
-                            (append! chars "'")
-                            (advance! 2)
-                            (loop)))
-                        (else (advance! 1))))
-                    (else
-                      (begin (append! chars (cur)) (advance! 1) (loop))))))
-              (loop)
-              (join "" chars)))))
-      (define
-        read-binary-run!
-        (fn
-          ()
-          (let
-            ((start pos))
-            (begin
-              (define
-                bin-loop
-                (fn
-                  ()
-                  (when
-                    (and (< pos src-len) (st-binary-char? (cur)))
-                    (begin (advance! 1) (bin-loop)))))
-              (bin-loop)
-              (slice src start pos)))))
-      (define
-        read-symbol
-        (fn
-          (start)
-          (cond
-            ;; Quoted symbol: #'whatever'
-            ((= (cur) "'")
-              (let ((s (read-string))) (push! "symbol" s start)))
-            ;; Binary-char symbol: #+, #==, #->, #|
-            ((or (st-binary-char? (cur)) (= (cur) "|"))
-              (let ((b (read-binary-run!)))
-                (cond
-                  ((= b "")
-                    ;; lone | wasn't binary; consume it
-                    (begin (advance! 1) (push! "symbol" "|" start)))
-                  (else (push! "symbol" b start)))))
-            ;; Identifier or keyword chain: #foo, #foo:bar:
-            ((st-ident-start? (cur))
-              (let ((id-start pos))
-                (begin
-                  (read-ident-chars!)
-                  (define
-                    kw-loop
-                    (fn
-                      ()
-                      (when
-                        (and (< pos src-len) (= (cur) ":"))
-                        (begin
-                          (advance! 1)
-                          (when
-                            (and (< pos src-len) (st-ident-start? (cur)))
-                            (begin (read-ident-chars!) (kw-loop)))))))
-                  (kw-loop)
-                  (push! "symbol" (slice src id-start pos) start))))
-            (else
-              (error
-                (str "st-tokenize: bad symbol at " pos))))))
-      (define
-        step
-        (fn
-          ()
-          (begin
-            (skip-ws!)
-            (when
-              (< pos src-len)
-              (let
-                ((start pos) (c (cur)))
-                (cond
-                  ;; Identifier or keyword
-                  ((st-ident-start? c)
-                    (begin
-                      (read-ident-chars!)
-                      (let
-                        ((word (slice src start pos)))
-                        (cond
-                          ;; ident immediately followed by ':' (and not ':=') => keyword
-                          ((and
-                              (< pos src-len)
-                              (= (cur) ":")
-                              (not (= (pk 1) "=")))
-                            (begin
-                              (advance! 1)
-                              (push!
-                                "keyword"
-                                (str word ":")
-                                start)))
-                          (else (push! "ident" word start))))
-                      (step)))
-                  ;; Number
-                  ((st-digit? c)
-                    (let
-                      ((v (read-number start)))
-                      (begin (push! "number" v start) (step))))
-                  ;; String
-                  ((= c "'")
-                    (let
-                      ((s (read-string)))
-                      (begin (push! "string" s start) (step))))
-                  ;; Character literal
-                  ((= c "$")
-                    (cond
-                      ((>= (+ pos 1) src-len)
-                        (error (str "st-tokenize: $ at end of input")))
-                      (else
-                        (begin
-                          (advance! 1)
-                          (push! "char" (cur) start)
-                          (advance! 1)
-                          (step)))))
-                  ;; Symbol or array literal
-                  ((= c "#")
-                    (cond
-                      ((= (pk 1) "(")
-                        (begin (advance! 2) (push! "array-open" "#(" start) (step)))
-                      ((= (pk 1) "[")
-                        (begin (advance! 2) (push! "byte-array-open" "#[" start) (step)))
-                      (else
-                        (begin (advance! 1) (read-symbol start) (step)))))
-                  ;; Assignment :=  or  bare colon
-                  ((= c ":")
-                    (cond
-                      ((= (pk 1) "=")
-                        (begin (advance! 2) (push! "assign" ":=" start) (step)))
-                      (else
-                        (begin (advance! 1) (push! "colon" ":" start) (step)))))
-                  ;; Single-char structural punctuation
-                  ((= c "(") (begin (advance! 1) (push! "lparen" "(" start) (step)))
-                  ((= c ")") (begin (advance! 1) (push! "rparen" ")" start) (step)))
-                  ((= c "[") (begin (advance! 1) (push! "lbracket" "[" start) (step)))
-                  ((= c "]") (begin (advance! 1) (push! "rbracket" "]" start) (step)))
-                  ((= c "{") (begin (advance! 1) (push! "lbrace" "{" start) (step)))
-                  ((= c "}") (begin (advance! 1) (push! "rbrace" "}" start) (step)))
-                  ((= c ".") (begin (advance! 1) (push! "period" "." start) (step)))
-                  ((= c ";") (begin (advance! 1) (push! "semi" ";" start) (step)))
-                  ((= c "|") (begin (advance! 1) (push! "bar" "|" start) (step)))
-                  ((= c "^") (begin (advance! 1) (push! "caret" "^" start) (step)))
-                  ((= c "!") (begin (advance! 1) (push! "bang" "!" start) (step)))
-                  ;; Binary selector run
-                  ((st-binary-char? c)
-                    (let
-                      ((b (read-binary-run!)))
-                      (begin (push! "binary" b start) (step))))
-                  (else
-                    (error
-                      (str
-                        "st-tokenize: unexpected char "
-                        c
-                        " at "
-                        pos)))))))))
-      (step)
-      (push! "eof" nil pos)
-      tokens)))

plans/agent-briefings/smalltalk-loop.md

@@ -1,77 +0,0 @@
-# smalltalk-on-sx loop agent (single agent, queue-driven)
-
-Role: iterates `plans/smalltalk-on-sx.md` forever. Message-passing OO + **blocks with non-local return** on delimited continuations. Non-local return is the headline showcase — every other Smalltalk reinvents it on the host stack; on SX it falls out of the captured method-return continuation.
-
-```
-description: smalltalk-on-sx queue loop
-subagent_type: general-purpose
-run_in_background: true
-isolation: worktree
-```
-
-## Prompt
-
-You are the sole background agent working `/root/rose-ash/plans/smalltalk-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
-
-## Restart baseline — check before iterating
-
-1. Read `plans/smalltalk-on-sx.md` — roadmap + Progress log.
-2. `ls lib/smalltalk/` — pick up from the most advanced file.
-3. If `lib/smalltalk/tests/*.sx` exist, run them. Green before new work.
-4. If `lib/smalltalk/scoreboard.md` exists, that's your baseline.
-
-## The queue
-
-Phase order per `plans/smalltalk-on-sx.md`:
-
-- **Phase 1** — tokenizer + parser (chunk format, identifiers, keywords `foo:`, binary selectors, `#sym`, `#(…)`, `$c`, blocks `[:a | …]`, cascades, message precedence)
-- **Phase 2** — object model + sequential eval (class table bootstrap, message dispatch, `super`, `doesNotUnderstand:`, instance variables)
-- **Phase 3** — **THE SHOWCASE**: blocks with non-local return via captured method-return continuation. `whileTrue:` / `ifTrue:ifFalse:` as block sends. 5 classic programs (eight-queens, quicksort, mandelbrot, life, fibonacci) green.
-- **Phase 4** — reflection + MOP: `perform:`, `respondsTo:`, runtime method addition, `becomeForward:`, `Exception` / `on:do:` / `ensure:` on top of `handler-bind`/`raise`
-- **Phase 5** — collections + numeric tower + streams
-- **Phase 6** — port SUnit, vendor Pharo Kernel-Tests slice, drive corpus to 200+
-- **Phase 7** — speed (optional): inline caching, block intrinsification
-
-Within a phase, pick the checkbox that unlocks the most tests per effort.
-
-Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
-
-## Ground rules (hard)
-
-- **Scope:** only `lib/smalltalk/**` and `plans/smalltalk-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Smalltalk primitives go in `lib/smalltalk/runtime.sx`.
-- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
-- **Shared-file issues** → plan's Blockers with minimal repro.
-- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
-- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
-- **Worktree:** commit locally. Never push. Never touch `main`.
-- **Commit granularity:** one feature per commit.
-- **Plan file:** update Progress log + tick boxes every commit.
-
-## Smalltalk-specific gotchas
-
-- **Method invocation captures `^k`** — the return continuation. Bind it as the block's escape token. `^expr` from inside any nested block invokes that captured `^k`. Escape past method return raises `BlockContext>>cannotReturn:`.
-- **Blocks are lambdas + escape token**, not bare lambdas. `value`/`value:`/… invoke the lambda; `^` invokes the escape.
-- **`ifTrue:` / `ifFalse:` / `whileTrue:` are ordinary block sends** — no special form. The runtime intrinsifies them in the JIT path (Tier 1 of bytecode expansion already covers this pattern).
-- **Cascade** `r m1; m2; m3` desugars to `(let ((tmp r)) (st-send tmp 'm1 ()) (st-send tmp 'm2 ()) (st-send tmp 'm3 ()))`. Result is the cascade's last send (or first, depending on parser variant — pick one and document).
-- **`super` send** looks up starting from the *defining* class's superclass, not the receiver class. Stash the defining class on the method record.
-- **Selectors are interned symbols.** Use SX symbols.
-- **Receiver dispatch:** tagged ints / floats / strings / symbols / `nil` / `true` / `false` aren't boxed. Their classes (`SmallInteger`, `Float`, `String`, `Symbol`, `UndefinedObject`, `True`, `False`) are looked up by SX type-of, not by an `:class` field.
-- **Method precedence:** unary > binary > keyword. `3 + 4 factorial` is `3 + (4 factorial)`. `a foo: b bar` is `a foo: (b bar)` (keyword absorbs trailing unary).
-- **Image / fileIn / become: between sessions** = out of scope. One-way `becomeForward:` only.
-- **Test corpus:** ~200 hand-written + a slice of Pharo Kernel-Tests. Place programs in `lib/smalltalk/tests/programs/`.
-
-## General gotchas (all loops)
-
-- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
-- `cond`/`when`/`let` clauses evaluate only the last expr.
-- `type-of` on user fn returns `"lambda"`.
-- Shell heredoc `||` gets eaten — escape or use `case`.
-
-## Style
-
-- No comments in `.sx` unless non-obvious.
-- No new planning docs — update `plans/smalltalk-on-sx.md` inline.
-- Short, factual commit messages (`smalltalk: tokenizer + 56 tests`).
-- One feature per iteration. Commit. Log. Next.
-
-Go. Read the plan; find first `[ ]`; implement.

plans/forth-on-sx.md

@@ -69,25 +69,32 @@ Representation:
 - [x] Tests in `lib/forth/tests/test-phase2.sx` — 26/26 pass
 
 ### Phase 3 — control flow + first Hayes tests green
-- [ ] `IF`, `ELSE`, `THEN` — compile to SX `if`
+- [x] `IF`, `ELSE`, `THEN` — compile to SX `if`
-- [ ] `BEGIN`, `UNTIL`, `WHILE`, `REPEAT`, `AGAIN` — compile to loops
+- [x] `BEGIN`, `UNTIL`, `WHILE`, `REPEAT`, `AGAIN` — compile to loops
-- [ ] `DO`, `LOOP`, `+LOOP`, `I`, `J`, `LEAVE` — counted loops (needs a return stack)
+- [x] `DO`, `LOOP`, `+LOOP`, `I`, `J`, `LEAVE` — counted loops (needs a return stack)
-- [ ] Return stack: `>R`, `R>`, `R@`, `2>R`, `2R>`, `2R@`
+- [x] Return stack: `>R`, `R>`, `R@`, `2>R`, `2R>`, `2R@`
-- [ ] Vendor John Hayes' test suite to `lib/forth/ans-tests/`
+- [x] Vendor John Hayes' test suite to `lib/forth/ans-tests/`
-- [ ] `lib/forth/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
+- [x] `lib/forth/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
-- [ ] Baseline: probably 30-50% Core passing after phase 3
+- [x] Baseline: probably 30-50% Core passing after phase 3
 
 ### Phase 4 — strings + more Core
-- [ ] `S"`, `C"`, `."`, `TYPE`, `COUNT`, `CMOVE`, `FILL`, `BLANK`
+- [x] `S"`, `C"`, `."`, `TYPE`, `COUNT`, `CMOVE`, `FILL`, `BLANK`
-- [ ] `CHAR`, `[CHAR]`, `KEY`, `ACCEPT`
+- [x] `CHAR`, `[CHAR]`, `KEY`, `ACCEPT`
-- [ ] `BASE` manipulation: `DECIMAL`, `HEX`
+- [x] `BASE` manipulation: `DECIMAL`, `HEX`
-- [ ] `DEPTH`, `SP@`, `SP!`
+- [x] `DEPTH`, `SP@`, `SP!`
-- [ ] Drive Hayes Core pass-rate up
+- [x] Drive Hayes Core pass-rate up
 
 ### Phase 5 — Core Extension + optional word sets
-- [ ] Full Core + Core Extension
+- [x] Memory: `CREATE`, `HERE`, `ALLOT`, `,`, `C,`, `CELL+`, `CELLS`, `ALIGN`, `ALIGNED`, `2!`, `2@`
-- [ ] File Access word set (via SX IO)
+- [x] Unsigned compare: `U<`, `U>`
-- [ ] String word set (`SLITERAL`, `COMPARE`, `SEARCH`)
+- [x] Mixed/double-cell math: `S>D`, `M*`, `UM*`, `UM/MOD`, `FM/MOD`, `SM/REM`, `*/`, `*/MOD`
+- [x] Double-cell ops: `D+`, `D-`, `D=`, `D<`, `D0=`, `2DUP`, `2DROP`, `2OVER`, `2SWAP` (already), plus `D>S`, `DABS`, `DNEGATE`
+- [x] Number formatting: `<#`, `#`, `#S`, `#>`, `HOLD`, `SIGN`, `.R`, `U.`, `U.R`
+- [x] Parsing/dictionary: `WORD`, `FIND`, `EXECUTE`, `'`, `[']`, `LITERAL`, `POSTPONE`, `>BODY` (DOES> deferred — needs runtime-rebind of last CREATE)
+- [x] Source/state: `EVALUATE`, `STATE`, `[`, `]` (`SOURCE`/`>IN` stubbed; tokenized input means the exact byte/offset semantics aren't useful here)
+- [x] Misc Core: `WITHIN`, `MAX`/`MIN` (already), `ABORT`, `ABORT"`, `EXIT`, `UNLOOP`
+- [x] File Access word set (in-memory — `read-file` is not reachable from the epoch eval env)
+- [x] String word set (`SLITERAL`, `COMPARE`, `SEARCH`)
 - [ ] Target: 100% Hayes Core
 
 ### Phase 6 — speed
@@ -99,6 +106,239 @@ Representation:
 
 _Newest first._
 
+- **Phase 5 — String word set `COMPARE`/`SEARCH`/`SLITERAL` (+9).**
+  `COMPARE` walks bytes via the new `forth-compare-bytes-loop`,
+  returning -1/0/1 with standard prefix semantics (shorter string
+  compares less than its extension). `SEARCH` scans the haystack
+  with a helper `forth-search-bytes` and `forth-match-at`, returning
+  the tail after the first match or the original string with flag=0.
+  Empty needle returns at offset 0 with flag=-1 per ANS. `SLITERAL`
+  is IMMEDIATE: pops `(c-addr u)` at compile time, copies the bytes
+  into a fresh allocation, and emits the two pushes so the compiled
+  word yields the interned string at runtime.
+
+- **Phase 5 — File Access word set (in-memory backing; +4).**
+  `OPEN-FILE`/`CREATE-FILE`/`CLOSE-FILE`/`READ-FILE`/`WRITE-FILE`/
+  `FILE-POSITION`/`FILE-SIZE`/`REPOSITION-FILE`/`DELETE-FILE` plus
+  the mode constants `R/O`/`R/W`/`W/O`/`BIN`. File handles live on
+  `state.files` (fileid → {content, pos, path}) with a
+  `state.by-path` index so `CREATE-FILE`'d files can be
+  `OPEN-FILE`'d later in the same session. Attempting to
+  `OPEN-FILE` an unknown path returns `ior != 0`; disk-backed
+  open/read is not wired because `read-file` isn't in the sx_server
+  epoch eval environment (it's bound only in the HTTP helpers).
+  Also removed the stray base-2 `BIN` primitive from Phase 4 —
+  ANS `BIN` is the file-mode modifier. Hayes Core unchanged at
+  486/638 since core.fr doesn't exercise file words.
+
+- **Phase 5 — `WITHIN`/`ABORT`/`ABORT"`/`EXIT`/`UNLOOP` (+7;
+  Hayes 477→486, 76%).** `WITHIN` uses the ANS two's-complement
+  trick: `(n1-n2) U< (n3-n2)`. `ABORT` wipes the data/return/control
+  stacks and raises — the conformance runner catches it at the
+  chunk boundary. `ABORT"` parses its message like `S"`, then at
+  runtime pops a flag and raises only if truthy. `EXIT` adds a new
+  `:kind "exit"` op that the PC-driven body runner treats as a
+  jump-to-end; added a matching cond clause in `forth-step-op`.
+  `UNLOOP` pops two from the return stack — usable paired with
+  `EXIT` to bail from inside `DO`/`LOOP`.
+
+- **Phase 5 — `[`, `]`, `STATE`, `EVALUATE` (+5; Hayes 463→477, 74%).**
+  `[` (IMMEDIATE) clears `state.compiling`, `]` sets it. `STATE`
+  pushes the sentinel address `"@@state"` and `@` reads it as
+  `-1`/`0` based on the live `compiling` flag. `EVALUATE` reads
+  the (addr,u) string from byte memory, retokenises it via
+  `forth-tokens`, swaps it in as the active input, runs the
+  interpret loop, and restores the saved input. `SOURCE` and
+  `>IN` exist as stubs that push zeros — our whitespace-tokenised
+  input has no native byte-offset, so the deeper Hayes tests
+  that re-position parsing via `>IN !` stay marked as errors
+  rather than silently misbehaving.
+
+- **Phase 5 — parsing/dictionary words `'`/`[']`/`EXECUTE`/`LITERAL`/
+  `POSTPONE`/`WORD`/`FIND`/`>BODY` (Hayes 448→463, 72%).** xt is
+  represented as the SX dict reference of the word record, so
+  `'`/`[']` push the looked-up record and `EXECUTE` calls
+  `forth-execute-word` on the popped value. `LITERAL` (IMMEDIATE)
+  pops a value at compile time and emits a push-op. `POSTPONE`
+  (IMMEDIATE) compiles into the *outer* def an op that, when run
+  during a *later* compile, appends a call-w op to whatever def is
+  current — the standard two-tier compile semantic. Added
+  `state.last-defined` tracked by every primitive/colon definition
+  so `IMMEDIATE` can target the most-recent word even after `;`
+  closes the def. CREATE now stashes its data-field address on the
+  word record so `>BODY` can recover it. `WORD`/`FIND` use the byte
+  memory and counted-string layout already in place.
+  `DOES>` is deferred — needs a runtime mechanism to rebind the
+  last-CREATE'd word's action.
+
+- **Phase 5 — pictured numeric output: `<#`/`#`/`#S`/`#>`/`HOLD`/`SIGN` +
+  `U.`/`U.R`/`.R` (+9; Hayes 446→448, 70%).** Added a `state.hold`
+  list of single-character strings — `<#` resets it, `HOLD` and
+  `SIGN` prepend, `#` divides ud by BASE and prepends one digit,
+  `#S` loops `#` until ud is zero (running once even on zero),
+  `#>` drops ud and copies the joined hold buffer into mem,
+  pushing `(addr, len)`. `U.` / `.R` / `U.R` use a separate
+  `forth-num-to-string` for one-shot decimal/hex output and
+  `forth-spaces-str` for right-justify padding.
+
+- **Phase 5 — double-cell ops `D+`/`D-`/`DNEGATE`/`DABS`/`D=`/`D<`/`D0=`/
+  `D0<`/`DMAX`/`DMIN` (+18; Hayes unchanged).** Doubles get rebuilt
+  from `(lo, hi)` cells via `forth-double-from-cells-s`, the op runs
+  in bignum, and we push back via `forth-double-push-s`. Hayes Core
+  doesn't exercise D-words (those live in Gerry Jackson's separate
+  `doublest.fth` Double word-set tests we have not vendored), so the
+  scoreboard stays at 446/638 — but the words now exist for any
+  consumer that needs them.
+
+- **Phase 5 — mixed/double-cell math; Hayes 342→446 (69%).** Added
+  `S>D`, `D>S`, `M*`, `UM*`, `UM/MOD`, `FM/MOD`, `SM/REM`, `*/`, `*/MOD`.
+  Doubles ride on the stack as `(lo, hi)` with `hi` on top.
+  Helpers `forth-double-push-{u,s}` / `forth-double-from-cells-{u,s}`
+  split & rebuild via 32-bit unsigned mod/div, picking the negative
+  path explicitly so we don't form `2^64 + small` (float precision
+  drops at ULP=2^12 once you cross 2^64). `M*`/`UM*` use bignum
+  multiply then split; `*/`/`*/MOD` use bignum intermediate and
+  truncated division. Hayes: 446 pass / 185 error / 7 fail.
+
+- **Phase 5 — memory primitives + unsigned compare; Hayes 268→342 (53%).**
+  Added `CREATE`/`HERE`/`ALLOT`/`,`/`C,`/`CELL+`/`CELLS`/`ALIGN`/`ALIGNED`/
+  `2!`/`2@`/`U<`/`U>`. Generalised `@`/`!`/`+!` to dispatch on address
+  type: string addresses still go through `state.vars` (VARIABLE/VALUE
+  cells) while integer addresses now fall through to `state.mem` —
+  letting CREATE-allocated cells coexist with existing variables.
+  Decomposed the original "Full Core + Core Extension" box into
+  smaller unticked sub-bullets so iterations land per cluster.
+  Hayes: 342 pass / 292 error / 4 fail (53%). 237/237 internal.
+
+- **Phase 4 close — LSHIFT/RSHIFT, 32-bit arith truncation, early
+  binding; Hayes 174→268 (42%).** Added `LSHIFT` / `RSHIFT` as logical
+  shifts on 32-bit unsigned values, converted through
+  `forth-to-unsigned`/`forth-from-unsigned`. All arithmetic
+  primitives (`+` `-` `*` `/` `MOD` `NEGATE` `ABS` `1+` `1-` `2+`
+  `2-` `2*` `2/`) now clip results to 32-bit signed via a new
+  `forth-clip` helper, so loop idioms that rely on `2*` shifting the
+  MSB out (e.g. Hayes' `BITS` counter) actually terminate.
+  Changed colon-def call compilation from late-binding to early
+  binding: `forth-compile-call` now resolves the target word at
+  compile time, which makes `: GDX 123 ; : GDX GDX 234 ;` behave
+  per ANS (inner `GDX` → old def, not infinite recursion). `RECURSE`
+  keeps its late-binding thunk via the new `forth-compile-recurse`
+  helper. Raised `MAX_CHUNKS` default to 638 (full `core.fr`) now
+  that the BITS and COUNT-BITS loops terminate. Hayes: 268 pass /
+  368 error / 2 fail.
+
+- **Phase 4 — `SP@`/`SP!` (+4; Hayes unchanged; `DEPTH` was already present).**
+  `SP@` pushes the current data-stack depth (our closest analogue to a
+  stack pointer — SX lists have no addressable backing). `SP!` pops a
+  target depth and truncates the stack via `drop` on the dstack list.
+  This preserves the save/restore idiom `SP@ … SP!` even though the
+  returned "pointer" is really a count.
+
+- **Phase 4 — `BASE`/`DECIMAL`/`HEX`/`BIN`/`OCTAL` (+9; Hayes unchanged).**
+  Moved `base` from its top-level state slot into `state.vars["base"]`
+  so the regular `@`/`!`/VARIABLE machinery works on it.
+  `BASE` pushes the sentinel address `"base"`; `DECIMAL`/`HEX`/`BIN`/
+  `OCTAL` are thin primitives that write into that slot. Parser
+  reads through `vars` now. Hayes unchanged because the runner had
+  already been stubbing `HEX`/`DECIMAL` — now real words, stubs
+  removed from `hayes-runner.sx`.
+
+- **Phase 4 — `CHAR`/`[CHAR]`/`KEY`/`ACCEPT` (+7 / Hayes 168→174).**
+  `CHAR` parses the next token and pushes the first-char code. `[CHAR]`
+  is IMMEDIATE: in compile mode it embeds the code as a compiled push
+  op, in interpret mode it pushes inline. `KEY`/`ACCEPT` read from an
+  optional `state.keybuf` string — empty buffer makes `KEY` raise
+  `"no input available"` (matches ANS when stdin is closed) and
+  `ACCEPT` returns `0`. Enough for Hayes to get past CHAR-gated
+  clusters; real interactive IO lands later.
+
+- **Phase 4 — strings: `S"`/`C"`/`."`/`TYPE`/`COUNT`/`CMOVE`/`CMOVE>`/`MOVE`/`FILL`/`BLANK`/`C@`/`C!`/`CHAR+`/`CHARS` (+16 / Hayes 165→168).**
+  Added a byte-addressable memory model to state: `mem` (dict keyed by
+  stringified address → integer byte) and `here` (next-free integer
+  addr). Helpers `forth-alloc-bytes!` / `forth-mem-write-string!` /
+  `forth-mem-read-string`. `S"`/`C"`/`."` are IMMEDIATE parsing words
+  that consume tokens until one ends with `"`, then either copy content
+  into memory at compile time (and emit a push of `addr`/`addr len` for
+  the colon-def body) or do it inline in interpret mode. `TYPE` emits
+  `u` bytes from `addr` via `char-from-code`. `COUNT` reads the length
+  byte at a counted-string address and pushes (`addr+1`, `u`). `FILL`,
+  `BLANK` (FILL with space), `CMOVE` (forward), `CMOVE>` (backward),
+  and `MOVE` (auto-directional) mutate the byte dict. 193/193 internal
+  tests, Hayes 168/590 (+3).
+
+- **Phase 3 — Hayes conformance runner + baseline scoreboard (165/590, 28%).**
+  `lib/forth/conformance.sh` preprocesses `ans-tests/core.fr` (strips `\`
+  and `( ... )` comments + `TESTING` lines), splits the source on every
+  `}T` so each Hayes test plus the small declaration blocks between
+  them are one safe-resume chunk, and emits an SX driver that feeds
+  the chunks through `lib/forth/hayes-runner.sx`. The runner registers
+  `T{`/`->`/`}T` as Forth primitives that snapshot the dstack depth on
+  `T{`, record actual on `->`, compare on `}T`, and install stub
+  `HEX`/`DECIMAL`/`TESTING` so metadata doesn't halt the stream. Errors
+  raised inside a chunk are caught by `guard` and the state is reset,
+  so one bad test does not break the rest. Outputs
+  `scoreboard.json` + `scoreboard.md`.
+
+  First-run baseline: 165 pass / 425 error / 0 fail on the first 590
+  chunks. The default cap sits at 590 because `core.fr` chunks beyond
+  that rely on unsigned-integer wrap-around (e.g. `COUNT-BITS` with
+  `BEGIN DUP WHILE … 2* REPEAT`) which never terminates on our
+  bignum-based Forth; raise `MAX_CHUNKS` once those tests unblock.
+  Majority of errors are missing Phase-4 words (`RSHIFT`, `LSHIFT`,
+  `CELLS`, `S"`, `CHAR`, `SOURCE`, etc.) — each one implemented should
+  convert a cluster of errors to passes.
+
+- **Phase 3 — vendor Gerry Jackson's forth2012-test-suite.** Added
+  `lib/forth/ans-tests/{tester.fr, core.fr, coreexttest.fth}` from
+  https://github.com/gerryjackson/forth2012-test-suite (master, fetched
+  2026-04-24). `tester.fr` is Hayes' `T{ ... -> ... }T` harness; `core.fr`
+  is the ~1000-line Core word tests; `coreexttest.fth` is Core Ext
+  (parked for later phases). Files are pristine — the conformance runner
+  (next iteration) will consume them.
+
+- **Phase 3 — `DO`/`LOOP`/`+LOOP`/`I`/`J`/`LEAVE` + return stack words (+16).**
+  Counted loops compile onto the same PC-driven body runner. DO emits an
+  enter-op (pops limit+start from data stack, pushes them to rstack) and
+  pushes a `{:kind "do" :back PC :leaves ()}` marker onto cstack. LOOP/+LOOP
+  emit a dict op (`:kind "loop"`/`"+loop"` with target=back-cell). The step
+  handler pops index & reads limit, increments, and either restores the
+  updated index + jumps back, or drops the frame and advances. LEAVE walks
+  cstack for the innermost DO marker, emits a `:kind "leave"` dict op with
+  a fresh target cell, and registers it on the marker's leaves list. LOOP
+  patches all registered leave-targets to the exit PC and drops the marker.
+  The leave op pops two from rstack (unloop) and branches. `I` peeks rtop;
+  `J` reads rstack index 2 (below inner frame). Added non-immediate
+  return-stack words `>R`, `R>`, `R@`, `2>R`, `2R>`, `2R@`. Nested
+  DO/LOOP with J tested; LEAVE in nested loops exits only the inner.
+  177/177 green.
+
+- **Phase 3 — `BEGIN`/`UNTIL`/`WHILE`/`REPEAT`/`AGAIN` (+9).** Indefinite-loop
+  constructs built on the same PC-driven body runner introduced for `IF`.
+  BEGIN records the current body length on `state.cstack` (a plain numeric
+  back-target). UNTIL/AGAIN pop that back-target and emit a `bif`/`branch`
+  op whose target cell is set to the recorded PC. WHILE emits a forward
+  `bif` with a fresh target cell and pushes it on the cstack *above* the
+  BEGIN marker; REPEAT pops both (while-target first, then back-pc), emits
+  an unconditional branch back to BEGIN, then patches the while-target to
+  the current body length — so WHILE's false flag jumps past the REPEAT.
+  Mixed compile-time layout (numeric back-targets + dict forward targets
+  on the same cstack) is OK because the immediate words pop them in the
+  order they expect. AGAIN works structurally but lacks a test without a
+  usable mid-loop exit; revisit once `EXIT` lands. 161/161 green.
+
+- **Phase 3 start — `IF`/`ELSE`/`THEN` (+18).** `lib/forth/compiler.sx`
+  + `tests/test-phase3.sx`. Colon-def body switched from `for-each` to
+  a PC-driven runner so branch ops can jump: ops now include dict tags
+  `{"kind" "bif"|"branch" "target" cell}` alongside the existing
+  `(fn (s) ...)` shape. IF compiles a `bif` with a fresh target cell
+  pushed to `state.cstack`; ELSE emits an unconditional `branch`,
+  patches the IF's target to the instruction after this branch, and
+  pushes the new target; THEN patches the most recent target to the
+  current body length. Nested IF/ELSE/THEN works via the cstack.
+  Also fixed `EMIT`: `code-char` → `char-from-code` (spec-correct
+  primitive name) so Phase 1/2 tests run green on sx_server.
+  152/152 (Phase 1 + 2 + 3) green.
+
 - **Phase 2 complete — colon defs, compile mode, VARIABLE/CONSTANT/VALUE/TO, @/!/+! (+26).**
   `lib/forth/compiler.sx` plus `tests/test-phase2.sx`.
   Colon-def body is a list of ops (one per source token) wrapped in a single

plans/smalltalk-on-sx.md

@@ -1,124 +0,0 @@
-# Smalltalk-on-SX: blocks with non-local return on delimited continuations
-
-The headline showcase is **blocks** — Smalltalk's closures with non-local return (`^expr` aborts the enclosing *method*, not the block). Every other Smalltalk on top of a host VM (RSqueak on PyPy, GemStone on C, Maxine on Java) reinvents non-local return on whatever stack discipline the host gives them. On SX it's a one-liner: a block holds a captured continuation; `^` just invokes it. Message-passing OO falls out cheaply on top of the existing component / dispatch machinery.
-
-End-state goal: ANSI-ish Smalltalk-80 subset, SUnit working, ~200 hand-written tests + a vendored slice of the Pharo kernel tests, classic corpus (eight queens, quicksort, mandelbrot, Conway's Life).
-
-## Scope decisions (defaults — override by editing before we spawn)
-
-- **Syntax:** Pharo / Squeak chunk format (`!` separators, `Object subclass: #Foo …`). No fileIn/fileOut images — text source only.
-- **Conformance:** ANSI X3J20 *as a target*, not bug-for-bug Squeak. "Reads like Smalltalk, runs like Smalltalk."
-- **Test corpus:** SUnit ported to SX-Smalltalk + custom programs + a curated slice of Pharo `Kernel-Tests` / `Collections-Tests`.
-- **Image:** out of scope. Source-only. No `become:` between sessions, no snapshotting.
-- **Reflection:** `class`, `respondsTo:`, `perform:`, `doesNotUnderstand:` in. `become:` (object-identity swap) **in** — it's a good CEK exercise. Method modification at runtime in.
-- **GUI / Morphic / threads:** out entirely.
-
-## Ground rules
-
-- **Scope:** only touch `lib/smalltalk/**` and `plans/smalltalk-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. Smalltalk primitives go in `lib/smalltalk/runtime.sx`.
-- **SX files:** use `sx-tree` MCP tools only.
-- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
-
-## Architecture sketch
-
-```
-Smalltalk source
-    │
-    ▼
-lib/smalltalk/tokenizer.sx  — selectors, keywords, literals, $c, #sym, #(…), $'…'
-    │
-    ▼
-lib/smalltalk/parser.sx     — AST: classes, methods, blocks, cascades, sends
-    │
-    ▼
-lib/smalltalk/transpile.sx  — AST → SX AST (entry: smalltalk-eval-ast)
-    │
-    ▼
-lib/smalltalk/runtime.sx    — class table, MOP, dispatch, primitives
-```
-
-Core mapping:
-- **Class** = SX dict `{:name :superclass :ivars :methods :class-methods :metaclass}`. Class table is a flat dict keyed by class name.
-- **Object** = SX dict `{:class :ivars}` — `ivars` keyed by symbol. Tagged ints / floats / strings / symbols are not boxed; their class is looked up by SX type.
-- **Method** = SX lambda closing over a `self` binding + temps. Body wrapped in a delimited continuation so `^` can escape.
-- **Message send** = `(st-send receiver selector args)` — does class-table lookup, walks superclass chain, falls back to `doesNotUnderstand:` with a `Message` object.
-- **Block** `[:x | … ^v … ]` = lambda + captured `^k` (the method-return continuation). Invoking `^` calls `k`; outer block invocation past method return raises `BlockContext>>cannotReturn:`.
-- **Cascade** `r m1; m2; m3` = `(let ((tmp r)) (st-send tmp 'm1 ()) (st-send tmp 'm2 ()) (st-send tmp 'm3 ()))`.
-- **`ifTrue:ifFalse:` / `whileTrue:`** = ordinary block sends; the runtime intrinsifies them in the JIT path so they compile to native branches (Tier 1 of bytecode expansion already covers this pattern).
-- **`become:`** = swap two object identities everywhere — in SX this is a heap walk, but we restrict to `oneWayBecome:` (cheap: rewrite class field) by default.
-
-## Roadmap
-
-### Phase 1 — tokenizer + parser
-- [x] Tokenizer: identifiers, keywords (`foo:`), binary selectors (`+`, `==`, `,`, `->`, `~=` etc.), numbers (radix `16r1F`; **scaled `1.5s2` deferred**), strings `'…''…'`, characters `$c`, symbols `#foo` `#'foo bar'` `#+`, byte arrays `#[1 2 3]` (open token), literal arrays `#(1 #foo 'x')` (open token), comments `"…"`
-- [x] Parser (expression level): blocks `[:a :b | | t1 t2 | …]`, cascades, message precedence (unary > binary > keyword), assignment, return, statement sequences, literal arrays, byte arrays, paren grouping, method headers (`+ other`, `at:put:`, unary, with temps and body). Class-definition keyword messages parse as ordinary keyword sends — no special-case needed.
-- [x] Parser (chunk-stream level): `st-read-chunks` splits source on `!` (with `!!` doubling) and `st-parse-chunks` runs the Pharo file-in state machine — `methodsFor:` / `class methodsFor:` opens a method batch, an empty chunk closes it. Pragmas `<primitive: …>` (incl. multiple keyword pairs, before or after temps, multiple per method) parsed into the method AST.
-- [x] Unit tests in `lib/smalltalk/tests/parse.sx`
-
-### Phase 2 — object model + sequential eval
-- [x] Class table + bootstrap (`lib/smalltalk/runtime.sx`): canonical hierarchy installed (`Object`, `Behavior`, `ClassDescription`, `Class`, `Metaclass`, `UndefinedObject`, `Boolean`/`True`/`False`, `Magnitude`/`Number`/`Integer`/`SmallInteger`/`Float`/`Character`, `Collection`/`SequenceableCollection`/`ArrayedCollection`/`Array`/`String`/`Symbol`/`OrderedCollection`/`Dictionary`, `BlockClosure`). User class definition via `st-class-define!`, methods via `st-class-add-method!` (stamps `:defining-class` for super), method lookup walks chain, ivars accumulated through superclass chain, native SX value types map to Smalltalk classes via `st-class-of`.
-- [x] `smalltalk-eval-ast` (`lib/smalltalk/eval.sx`): all literal kinds, ident resolution (locals → ivars → class refs), self/super/thisContext, assignment (locals or ivars, mutating), message send, cascade, sequence, and ^return via a sentinel marker (proper continuation-based escape is the Phase 3 showcase). Frames carry a parent chain so blocks close over outer locals. Primitive method tables for SmallInteger/Float, String/Symbol, Boolean, UndefinedObject, Array, BlockClosure (value/value:/whileTrue:/etc.), and class-side `new`/`name`/etc. Also satisfies "30+ tests" — 60 eval tests.
-- [x] Method lookup: walk class → superclass already in `st-method-lookup-walk`; new cached wrapper `st-method-lookup` keys on `(class, selector, side)` and stores `:not-found` for negative results so DNU paths don't re-walk. Cache invalidates on `st-class-define!`, `st-class-add-method!`, `st-class-add-class-method!`, `st-class-remove-method!`, and full bootstrap. Stats helpers `st-method-cache-stats` / `st-method-cache-reset-stats!` for tests + later debugging.
-- [x] `doesNotUnderstand:` fallback. `Message` class added at bootstrap with `selector`/`arguments` ivars and accessor methods. Primitive senders (Number/String/Boolean/Nil/Array/BlockClosure/class-side) now return the `:unhandled` sentinel for unknown selectors; `st-send` builds a `Message` via `st-make-message` and routes through `st-dnu`, which looks up `doesNotUnderstand:` on the receiver's class chain (instance- or class-side as appropriate). User overrides intercept unknowns and see the symbol selector + arguments array in the Message.
-- [x] `super` send. Method invocation captures the defining class on the frame; `st-super-send` walks from `(st-class-superclass defining-class)` (instance- or class-side as appropriate). Falls through primitives → DNU when no method is found. Receiver is preserved as `self`, so ivar mutations stick. Verified for: subclass override calls parent, inherited `super` resolves to *defining* class's parent (not receiver's), multi-level `A→B→C` chain, super inside a block, super walks past an intermediate class with no local override.
-- [x] 30+ tests in `lib/smalltalk/tests/eval.sx` (60 tests, covering literals through user-class method dispatch with cascades and closures)
-
-### Phase 3 — blocks + non-local return (THE SHOWCASE)
-- [ ] Method invocation captures a `^k` (the return continuation) and binds it as the block's escape
-- [ ] `^expr` from inside a block invokes that captured `^k`
-- [ ] `BlockContext>>value`, `value:`, `value:value:`, …, `valueWithArguments:`
-- [ ] `whileTrue:` / `whileTrue` / `whileFalse:` / `whileFalse` as ordinary block sends — runtime intrinsifies the loop in the bytecode JIT
-- [ ] `ifTrue:` / `ifFalse:` / `ifTrue:ifFalse:` as block sends, similarly intrinsified
-- [ ] Escape past returned-from method raises `BlockContext>>cannotReturn:`
-- [ ] Classic programs in `lib/smalltalk/tests/programs/`:
-  - [ ] `eight-queens.st`
-  - [ ] `quicksort.st`
-  - [ ] `mandelbrot.st`
-  - [ ] `life.st` (Conway's Life, glider gun)
-  - [ ] `fibonacci.st` (recursive + memoised)
-- [ ] `lib/smalltalk/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
-
-### Phase 4 — reflection + MOP
-- [ ] `Object>>class`, `class>>name`, `class>>superclass`, `class>>methodDict`, `class>>selectors`
-- [ ] `Object>>perform:` / `perform:with:` / `perform:withArguments:`
-- [ ] `Object>>respondsTo:`, `Object>>isKindOf:`, `Object>>isMemberOf:`
-- [ ] `Behavior>>compile:` — runtime method addition
-- [ ] `Object>>becomeForward:` (one-way become; rewrites the class field of `aReceiver`)
-- [ ] Exceptions: `Exception`, `Error`, `signal`, `signal:`, `on:do:`, `ensure:`, `ifCurtailed:` — built on top of SX `handler-bind`/`raise`
-
-### Phase 5 — collections + numeric tower
-- [ ] `SequenceableCollection`/`OrderedCollection`/`Array`/`String`/`Symbol`
-- [ ] `HashedCollection`/`Set`/`Dictionary`/`IdentityDictionary`
-- [ ] `Stream` hierarchy: `ReadStream`/`WriteStream`/`ReadWriteStream`
-- [ ] `Number` tower: `SmallInteger`/`LargePositiveInteger`/`Float`/`Fraction`
-- [ ] `String>>format:`, `printOn:` for everything
-
-### Phase 6 — SUnit + corpus to 200+
-- [ ] Port SUnit (TestCase, TestSuite, TestResult) — written in SX-Smalltalk, runs in itself
-- [ ] Vendor a slice of Pharo `Kernel-Tests` and `Collections-Tests`
-- [ ] Drive the scoreboard up: aim for 200+ green tests
-- [ ] Stretch: ANSI Smalltalk validator subset
-
-### Phase 7 — speed (optional)
-- [ ] Method-dictionary inline caching (already in CEK as a primitive; just wire selector cache)
-- [ ] Block intrinsification beyond `whileTrue:` / `ifTrue:`
-- [ ] Compare against GNU Smalltalk on the corpus
-
-## Progress log
-
-_Newest first. Agent appends on every commit._
-
-- 2026-04-25: `super` send + 9 tests (`lib/smalltalk/tests/super.sx`). `st-super-send` walks from defining-class's superclass; class-side aware; primitives → DNU fallback. Also fixed top-level `| temps |` parsing in `st-parse` (the absence of which was silently aborting earlier eval/dnu tests — counts go from 274 → 287, with previously-skipped tests now actually running).
-- 2026-04-25: `doesNotUnderstand:` + 12 DNU tests (`lib/smalltalk/tests/dnu.sx`). Bootstrap installs `Message` (with selector/arguments accessors). Primitives signal `:unhandled` instead of erroring; `st-dnu` builds a Message and walks `doesNotUnderstand:` lookup. User Object DNU intercepts unknown sends to native receivers (Number, String, Block) too. 267/267 total.
-- 2026-04-25: method-lookup cache (`st-method-cache` keyed by `class|selector|side`, stores `:not-found` for misses). Invalidation on define/add/remove + bootstrap. `st-class-remove-method!` added. Stats helpers + 10 cache tests; 255/255 total.
-- 2026-04-25: `smalltalk-eval-ast` + 60 eval tests (`lib/smalltalk/eval.sx`, `lib/smalltalk/tests/eval.sx`). Frame chain with mutable locals/ivars (via `dict-set!`), full literal eval, send dispatch (user methods + native primitive tables for Number/String/Boolean/Nil/Array/Block/Class), block closures, while/to:do:, cascades returning last, sentinel-based `^return`. User Point class round-trip works including `+` returning a fresh point. 245/245 total.
-- 2026-04-25: class table + bootstrap (`lib/smalltalk/runtime.sx`, `lib/smalltalk/tests/runtime.sx`). Canonical hierarchy, type→class mapping for native SX values, instance construction, ivar inheritance, method install with `:defining-class` stamp, instance- and class-side method lookup walking the superclass chain. 54 new tests, 185/185 total.
-- 2026-04-25: chunk-stream parser + pragmas + 21 chunk/pragma tests (`lib/smalltalk/tests/parse_chunks.sx`). `st-read-chunks` (with `!!` doubling), `st-parse-chunks` state machine for `methodsFor:` batches incl. class-side. Pragmas with multiple keyword pairs, signed numeric / string / symbol args, in either pragma-then-temps or temps-then-pragma order. 131/131 tests pass.
-- 2026-04-25: expression-level parser + 47 parse tests (`lib/smalltalk/parser.sx`, `lib/smalltalk/tests/parse.sx`). Full message precedence (unary > binary > keyword), cascades, blocks with params/temps, literal/byte arrays, assignment chain, method headers (unary/binary/keyword). Chunk-format `! !` driver deferred to a follow-up box. 110/110 tests pass.
-- 2026-04-25: tokenizer + 63 tests (`lib/smalltalk/tokenizer.sx`, `lib/smalltalk/tests/tokenize.sx`, `lib/smalltalk/test.sh`). All token types covered except scaled decimals `1.5s2` (deferred). `#(` and `#[` emit open tokens; literal-array contents lexed as ordinary tokens for the parser to interpret.
-
-## Blockers
-
-_Shared-file issues that need someone else to fix. Minimal repro only._
-
-- _(none yet)_

scripts/sx-loops-down.sh

@@ -30,7 +30,7 @@ fi
 
 if [ "$CLEAN" = "1" ]; then
   cd "$(dirname "$0")/.."
-  for lang in lua prolog forth erlang haskell js hs smalltalk; do
+  for lang in lua prolog forth erlang haskell js hs; do
     wt="$WORKTREE_BASE/$lang"
     if [ -d "$wt" ]; then
       git worktree remove --force "$wt" 2>/dev/null || rm -rf "$wt"
@@ -39,5 +39,5 @@ if [ "$CLEAN" = "1" ]; then
   done
   git worktree prune
   echo "Worktree branches (loops/<lang>) are preserved. Delete manually if desired:"
-  echo "  git branch -D loops/lua loops/prolog loops/forth loops/erlang loops/haskell loops/js loops/hs loops/smalltalk"
+  echo "  git branch -D loops/lua loops/prolog loops/forth loops/erlang loops/haskell loops/js loops/hs"
 fi

scripts/sx-loops-up.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Spawn 8 claude sessions in tmux, one per language loop.
+# Spawn 7 claude sessions in tmux, one per language loop.
 # Each runs in its own git worktree rooted at /root/rose-ash-loops/<lang>,
 # on branch loops/<lang>. No two loops share a working tree, so there's
 # zero risk of file collisions between languages.
@@ -9,7 +9,7 @@
 #
 # After the script prints done:
 #   tmux a -t sx-loops
-#   Ctrl-B + <window-number> to switch (0=lua ... 7=smalltalk)
+#   Ctrl-B + <window-number> to switch (0=lua ... 6=hs)
 #   Ctrl-B + d to detach (loops keep running, SSH-safe)
 #
 # Stop: ./scripts/sx-loops-down.sh
@@ -38,9 +38,8 @@ declare -A BRIEFING=(
   [haskell]=haskell-loop.md
   [js]=loop.md
   [hs]=hs-loop.md
-  [smalltalk]=smalltalk-loop.md
 )
-ORDER=(lua prolog forth erlang haskell js hs smalltalk)
+ORDER=(lua prolog forth erlang haskell js hs)
 
 mkdir -p "$WORKTREE_BASE"
 
@@ -67,7 +66,7 @@ for lang in "${ORDER[@]:1}"; do
   tmux new-window -t "$SESSION" -n "$lang" -c "$WORKTREE_BASE/$lang"
 done
 
-echo "Starting 8 claude sessions..."
+echo "Starting 7 claude sessions..."
 for lang in "${ORDER[@]}"; do
   tmux send-keys -t "$SESSION:$lang" "claude" C-m
 done
@@ -90,10 +89,10 @@ for lang in "${ORDER[@]}"; do
 done
 
 echo ""
-echo "Done. 8 loops started in tmux session '$SESSION', each in its own worktree."
+echo "Done. 7 loops started in tmux session '$SESSION', each in its own worktree."
 echo ""
 echo "  Attach:    tmux a -t $SESSION"
-echo "  Switch:    Ctrl-B <0..7>  (0=lua 1=prolog 2=forth 3=erlang 4=haskell 5=js 6=hs 7=smalltalk)"
+echo "  Switch:    Ctrl-B <0..6>  (0=lua 1=prolog 2=forth 3=erlang 4=haskell 5=js 6=hs)"
 echo "  List:      Ctrl-B w"
 echo "  Detach:    Ctrl-B d"
 echo "  Stop:      ./scripts/sx-loops-down.sh"