6502.org

Code: Select all

filename,	size,	   score
compare.s,	 296 lines, A - fully unit tested.
forth.s,		216 lines, B - untested but looks good after revision/review
hal_mench.s,  171 lines, A - reused code from another project.
interpreter.s, 414 lines, B - untested but looks good after revision/review
io.s,			149 lines, A - fully unit tested.
macros.inc,	182 lines, A- - partially unit tested
math.s,		 387 lines, B - untested but looks good after revision/review
memory.s,	  214 lines, B - untested but looks good after revision/review
primitives.s, 316 lines, F - Unsalvageable code, needs a rewrite.
print.s,		151 lines, A - reused code from another project.
stack.s,		285 lines, A - full unit tested
stubs.s,		208 lines, F - Claude generated place holders no implementation
system.s,	  748 lines, D - Possibly salvageable code, needs work.

Code: Select all

;------------------------------------------------------------------------------
; MOD ( n1 n2 -- rem )
;------------------------------------------------------------------------------
	HEADER "MOD", MOD_CFA, 0, SLASH_CFA
	CODEPTR MOD_CODE
PUBLIC MOD_CODE
	jsr SLASHMOD_CODE
	inx			; Stack: NOS=rem TOS=quot → DROP
	inx
	NEXT
ENDPUBLIC

Code: Select all

;------------------------------------------------------------------------------
; /MOD ( n1 n2 -- rem quot ) signed division
;------------------------------------------------------------------------------
	HEADER "/MOD", SLASHMOD_CFA, 0, UMSLASHMOD_CFA
	CODEPTR SLASHMOD_CODE
PUBLIC SLASHMOD_CODE
	jsr SLASHMOD_IMPL
	NEXT
ENDPUBLIC
.proc SLASHMOD_IMPL
; actual code is here and end in an rts

Code: Select all

;------------------------------------------------------------------------------
; NEXT - Inner interpreter dispatch
;
; Fetches the CFA at IP (Y), advances IP by 2, then jumps through
; the code pointer stored at that CFA.
;
; Register state on entry:
;   Y = IP (points to next CFA cell in current word body)
;   X = PSP
;   A = undefined (will be clobbered)
;
; Cycle cost: ~14 cycles (inlined)
;------------------------------------------------------------------------------
.macro  NEXT
        .a16
        LDA     0,Y             ; A = *IP (fetch CFA of next word)
        INY                     ; IP += 1
        INY                     ; IP += 2  (advance past this cell)
        STA     W               ; W = CFA
        LDA     (W)             ; A = *W (fetch code pointer)
        STA     SCRATCH0
	rts
	JMP     (SCRATCH0)      ; Jump to code
.endmacro

Code: Select all

; CFA used to handle the NEXT at the end of code were testing.
CFA_LIST:
	.word RTS_CFA	
HEADER "RTS", RTS_CFA, 0, 0
CODEPTR RTS_CODE
PUBLIC  RTS_CODE
	PRINTLN rtsmsg
	ldy #CFA_LIST
	rts
ENDPUBLIC
rtsmsg:	.asciiz "In RTS handler"

Code: Select all

math test - enter!
+ test $255 + $1025 (expect 127A) = 127A
- test $1025 - $255 (expect 0DD0) = 0DD0
* test $1025 * $0014 (expect 42E4) = 42E4
UM* test $1025 * $255 High (expect 0025) = 0000
UM* test $1025 * $255 Low (expect A649) = A649
UM/MOD test $000927C0 / $0A (expect EA60) = EA60
UM/MOD test remainder (expect 0000) = 0000
/MOD test $8000 /MOD $0A (expect 0CCC) = 0000
/MOD test remainder (expect 0008) = 0000
NEGATE test $ffe0 (expect 0020) = 0020
NEGATE test $00e0 (expect FF20) = FF20
ABS test $ffe0 (expect 0020) = 0020
ABS test $00e0 (expect 00E0) = 00E0
MAX test $0032 $1032 (expect 1032) = 1032
MIN test $0032 $1032 (expect 0032) = 0032
1+ test $1032 (expect 1033) = 1033
1- test $0537 (expect 0536) = 0536
2* test $0537 (expect 0A6E) = 0A6E
2/ test $0537 (expect 029B) = 029B
math test - exit!

Code: Select all

HEADER  "ABORT", ABORT_CFA, 0, BYE_CFA
CODEPTR ABORT_CODE
        .proc   ABORT_CODE
        .a16
        .i16
                ; Reset parameter stack
                LDX     #$03FF          ; PSP_INIT

                ; Reset return stack
                LDA     #$01FF          ; RSP_INIT
                TAS

                ; Set STATE = 0 (interpret)
                LDA     UP
                CLC
                ADC     #U_STATE
                STA     SCRATCH0
                STZ     (SCRATCH0)

                ; Jump to QUIT body directly
                ; (can't JSR — return stack was just wiped)
                LDA     #<QUIT_BODY     ; Load address of QUIT's body
                TAY                     ; IP = QUIT body
                NEXT
        .endproc

Code: Select all

;------------------------------------------------------------------------------
; ABORT ( -- ) The ANS Forth standard definition of ABORT should:
; 1. Empty the parameter stack — reset PSP (X register) to its initial value
; 2. Empty the return stack — reset RSP (S register) to its initial value
; 3. Set STATE to 0 — drop back to interpret mode if compiling
; 4. Transfer control to QUIT — restart the outer interpreter loop 
;------------------------------------------------------------------------------
HEADER  "ABORT", ABORT_CFA, 0, BYE_CFA
CODEPTR ABORT_CODE
.proc ABORT_CODE
	ldx PSP_SAVE		; Reset parameter stack to entry point values
	lda RSP_SAVE		; Reset return stack to entry point values
	tas

	lda UP
	sta SCRATCH0
	ldy #U_STATE
	lda #0000
	sta (SCRATCH0),Y	; Set STATE = 0 (interpret)

	ldy #QUIT_BODY		; IP = QUIT body
	NEXT

Code: Select all

Let me study the current WORD_CODE stub carefully first so I understand exactly what it needs to do:
Good — now I have a clear picture of what it needs to do and how broken the current version is.
Let me rewrite it cleanly using stack-relative addressing.

Code: Select all

You're welcome! The stack-relative approach turned out really clean — using the hardware stack as a local variable frame is one of those 65816 features that's easy to overlook but makes a big difference for register-hungry routines like WORD.

Code: Select all

You're right to question it. Let's think through what each does:

QUIT_CFA is a colon definition — it goes through DOCOL, which pushes the current IP onto the return stack before executing. But at startup there is no valid IP to push, so that's a problem.

ABORT_CODE is a machine code primitive that resets both stacks and jumps directly into QUIT_BODY via NEXT — no return stack involvement at all. That's exactly what you want at startup: clean slate, both stacks reset, straight into the interpreter loop.

So yes, FORTH_INIT should jump to ABORT_CODE rather than QUIT_CFA. Let me fix that:

Done. The flow is now:

FORTH_INIT → JMP ABORT_CODE
ABORT_CODE → resets PSP, RSP, STATE, >IN → LDY #<QUIT_BODY → NEXT
QUIT_BODY  → RSP_RESET, STATE=0, then REPL loop
Which is clean all the way through — no colon definitions involved until the interpreter is actually running.

Code: Select all

Done. That TSC/TCD frame technique is elegant — it turns the hardware stack into a local variable frame with named offsets, which is exactly the same pattern we used in WORD_CODE. It would be very useful in other HAL functions too if they ever need more complex local state.

Code: Select all

         rep #%00100000
         sec
         tsc                   ;SP —> .C
         sbc !#sfsiz           ;allocate SFSIZ bytes on stack
         tcs                   ;.C —> SP
         inc                   ;(SP + 1)
         tcd                   ;$00 in logical direct page