SOURCE VIEWER

parser.s

Original bytes preserved. This is a browser-readable view.

DOWNLOAD ORIGINAL ↓

; ======================================================================
; CS617 chapter01-u32calc-v2 r011 expression engine (application-owned)
; Alex Barragan and ChatGPT (Solcito), 2026-10-24
;
; Iterative shunting-yard, bounded 119 ASCII bytes, eight nested frames.
; One U32 operator path for infix and add/sub/mul/div/mod calls.
; All intermediate values checked; no unary operators. Assignment
; to 26 single-letter registers commits only on full success.
; Entry V9_EVAL: $4=0 success and $15..18 value; else $4=2 overflow,
; 3 syntax, 4 empty, 5 underflow, 6 zero divisor, 7 nesting/stack.
; No mutable accepted-library bytes; all V9 symbols belong to app UA14.
; ======================================================================
V9_PC:       EQU &H2CB0
V9_VCNT:     EQU &H2CB1
V9_OCNT:     EQU &H2CB2
V9_EXPECT:   EQU &H2CB3
V9_NEST:     EQU &H2CB4
V9_START:    EQU &H2CB5
V9_NLEN:     EQU &H2CB6
V9_PENDING:  EQU &H2CB7
V9_CURRENT:  EQU &H2CB8
V9_RIGHT:    EQU &H2CBC  ; four bytes
V9_NAMEBUF:  EQU &H2CC0  ; three case-normalized letters
V9_DMODE:    EQU &H2CC3  ; quotient 0 or remainder 1
V9_VALST:    EQU &H2D00  ; 60 U32 entries, 240 bytes
V9_OPST:     EQU &H2E00  ; 119 operator/parenthesis bytes
; 2E80..2EE7: 26*4 U32 registers; 2EE8..2EEA parser scratch.
; 2E77..2E7F intentionally unused. Cursor begins at 2F20.
V9_REGFILE:  EQU &H2E80
V9_ASSIGN:   EQU &H2EE8  ; FF = expression (no assignment)
V9_STMTPC:   EQU &H2EE9  ; statement lookahead return cursor
V9_REGTMP:   EQU &H2EEA  ; prospective register index 0..25

V9_REG_COLD:
; Only called from V2_COLD. Never clear on MENU or warm BRK.
        PST     UA,&H14
        PRE     IX,V9_REGFILE
        LD      $1,0
        LD      $0,0
V9_REG_CLR:
        ST      $0,(IX+$1)
        AD      $1,$SY
        SBC     $1,104
        JR      C,V9_REG_CLR
        RTN

V9_EVAL:
        PST     UA,&H14
        LD      $0,0
        PRE     IX,V9_PC
        ST      $0,(IX+$SX)
        PRE     IX,V9_VCNT
        ST      $0,(IX+$SX)
        PRE     IX,V9_OCNT
        ST      $0,(IX+$SX)
        PRE     IX,V9_EXPECT
        ST      $0,(IX+$SX)
        PRE     IX,V9_NEST
        ST      $0,(IX+$SX)
; No register is an assignment target until the entire LHS is proven.
        LD      $0,&HFF
        PRE     IX,V9_ASSIGN
        ST      $0,(IX+$SX)
        PRE     IX,V2_LEN
        LD      $0,(IX+$SX)
        AN      $0,$0
        JP      Z,V9_EMPTY
        JP      V9_ASSIGN_CHK

; A single letter followed by optional whitespace and '=' is the ONLY
; assignment LHS. If lookahead fails, rewind and parse an expression.
; In particular 'ans=...' is not an assignment; it becomes syntax.
V9_ASSIGN_CHK:
        CAL     V9_SKIP
        PRE     IX,V9_PC
        LD      $0,(IX+$SX)
        PRE     IX,V9_STMTPC
        ST      $0,(IX+$SX)
        CAL     V9_PEEK
        LD      $3,$0
        AN      $3,&HDF
        SBC     $3,&H41
        JP      C,V9_STMT_BACK
        SBC     $3,&H5B
        JP      NC,V9_STMT_BACK
        SB      $3,&H41
        PRE     IX,V9_REGTMP
        ST      $3,(IX+$SX)
        CAL     V9_ADV
        CAL     V9_SKIP
        CAL     V9_PEEK
        SBC     $0,&H3D
        JP      NZ,V9_STMT_BACK
; Recognized assignment. Evaluate RHS first, without changing state.
        PRE     IX,V9_REGTMP
        LD      $0,(IX+$SX)
        PRE     IX,V9_ASSIGN
        ST      $0,(IX+$SX)
        CAL     V9_ADV
        JP      V9_LOOP
V9_STMT_BACK:
        PRE     IX,V9_STMTPC
        LD      $0,(IX+$SX)
        PRE     IX,V9_PC
        ST      $0,(IX+$SX)
V9_LOOP:
        CAL     V9_SKIP
        PRE     IX,V9_EXPECT
        LD      $1,(IX+$SX)
        AN      $1,$1
        JP      Z,V9_ATOM
        JP      V9_AFTER

; Peek byte at PC (0 when EOF). No source modifications.
V9_PEEK:
        PST     UA,&H14
        PRE     IX,V9_PC
        LD      $1,(IX+$SX)
        PRE     IX,V2_LEN
        LD      $2,(IX+$SX)
        SBC     $1,$2
        JP      NC,V9_PEEK_EOF
        PRE     IX,V2_BUF
        LD      $0,(IX+$1)
        RTN
V9_PEEK_EOF:
        LD      $0,0
        RTN
V9_ADV:
        PST     UA,&H14
        PRE     IX,V9_PC
        LD      $1,(IX+$SX)
        AD      $1,$SY
        ST      $1,(IX+$SX)
        RTN
V9_SKIP:
        CAL     V9_PEEK
        SBC     $0,&H20
        JR      Z,V9_WS
        SBC     $0,9
        RTN     NZ
V9_WS:
        CAL     V9_ADV
        JP      V9_SKIP

V9_ATOM:
        CAL     V9_PEEK
        AN      $0,$0
        JP      Z,V9_SYNTAX
        SBC     $0,&H28
        JP      Z,V9_OPEN
        SBC     $0,&H30
        JP      C,V9_ATOM_NAME
        SBC     $0,&H3A
        JP      C,V9_NUMBER
V9_ATOM_NAME:
        LD      $1,$0
        AN      $1,&HDF
        SBC     $1,&H41
        JP      C,V9_SYNTAX
        SBC     $1,&H5B
        JP      NC,V9_SYNTAX
        JP      V9_NAME

; Ordinary parenthesis increases nest count and pushes marker 28h.
V9_OPEN:
        CAL     V9_INC_NEST
        AN      $4,$4
        JP      NZ,V9_RET
        LD      $0,&H28
        CAL     V9_OP_PUSH
        AN      $4,$4
        JP      NZ,V9_RET
        CAL     V9_ADV
        JP      V9_LOOP

V9_INC_NEST:
        PST     UA,&H14
        PRE     IX,V9_NEST
        LD      $1,(IX+$SX)
        SBC     $1,8
        JP      NC,V9_DEPTH
        AD      $1,$SY
        ST      $1,(IX+$SX)
        LD      $4,0
        RTN
V9_DEPTH:
        LD      $4,7
        RTN

V9_DEC_NEST:
        PST     UA,&H14
        PRE     IX,V9_NEST
        LD      $1,(IX+$SX)
        SB      $1,$SY
        ST      $1,(IX+$SX)
        RTN

; Contiguous decimal literal. Reuse qualified decimal parser intact.
V9_NUMBER:
        PST     UA,&H14
        PRE     IX,V9_PC
        LD      $1,(IX+$SX)
        PRE     IX,V9_START
        ST      $1,(IX+$SX)
        LD      $1,0
        PRE     IX,V9_NLEN
        ST      $1,(IX+$SX)
V9_NUM_LOOP:
        CAL     V9_PEEK
        SBC     $0,&H30
        JP      C,V9_NUM_END
        SBC     $0,&H3A
        JP      NC,V9_NUM_END
        PRE     IX,V9_NLEN
        LD      $1,(IX+$SX)
        AD      $1,$SY
        ST      $1,(IX+$SX)
        CAL     V9_ADV
        JP      V9_NUM_LOOP
V9_NUM_END:
        LDW     $10,V2_BUF
        PRE     IX,V9_START
        LD      $5,(IX+$SX)
        LD      $6,0
        ADW     $10,$5
        PRE     IX,V9_NLEN
        LD      $12,(IX+$SX)
        PRE     IX,$10
        CAL     UPARSE32DEC
        AN      $4,$4
        JP      NZ,V9_NUM_FAIL
        CAL     V9_PUSH
        AN      $4,$4
        JP      NZ,V9_RET
        JP      V9_ATOM_DONE
V9_NUM_FAIL:
        SBC     $4,1
        JP      Z,V9_OVER
        JP      V9_SYNTAX

; One letter means a register. Three letters means a reserved word.
; An identifier >3 letters, or exactly two letters, is syntax.
V9_NAME:
        LD      $3,0
V9_NM_LOOP:
        CAL     V9_PEEK
        LD      $1,$0
        AN      $1,&HDF
        SBC     $1,&H41
        JP      C,V9_NM_END
        SBC     $1,&H5B
        JP      NC,V9_NM_END
        SBC     $3,3
        JP      NC,V9_SYNTAX
        PST     UA,&H14
        PRE     IX,V9_NAMEBUF
        ST      $1,(IX+$3)
        CAL     V9_ADV
        AD      $3,$SY
        JP      V9_NM_LOOP
V9_NM_END:
        SBC     $3,1
        JP      Z,V9_NM_REG
        SBC     $3,3
        JP      NZ,V9_SYNTAX
; Recognize 3-byte reserved names via exact letter tests.
        PRE     IX,V9_NAMEBUF
        LD      $0,(IX+$SX)
        SBC     $0,&H41
        JP      Z,V9_NM_A
        SBC     $0,&H53
        JP      Z,V9_NM_S
        SBC     $0,&H4D
        JP      Z,V9_NM_M
        SBC     $0,&H44
        JP      Z,V9_NM_D
        JP      V9_SYNTAX
V9_NM_REG:
; Register offset = (toupper(letter)-'A')*4. Valid 0..100.
        PRE     IX,V9_NAMEBUF
        LD      $0,(IX+$SX)
        SB      $0,&H41
        BIU     $0
        BIU     $0
        PRE     IX,V9_REGFILE
        LDW     $15,(IX+$0)
        AD      $0,2
        LDW     $17,(IX+$0)
        CAL     V9_PUSH
        AN      $4,$4
        JP      NZ,V9_RET
        JP      V9_ATOM_DONE
V9_NM_A:
        LD      $0,(IX+1)
        SBC     $0,&H4E
        JP      Z,V9_NM_ANS
        SBC     $0,&H44
        JP      NZ,V9_SYNTAX
        LD      $0,(IX+2)
        SBC     $0,&H44
        JP      NZ,V9_SYNTAX
        LD      $0,&H71    ; function add, no comma yet
        JP      V9_NM_FN
V9_NM_ANS:
        LD      $0,(IX+2)
        SBC     $0,&H53
        JP      NZ,V9_SYNTAX
        CAL     V9_PEEK
        LD      $1,$0
        AN      $1,&HDF
        SBC     $1,&H41
        JP      C,V9_ANS_OK
        SBC     $1,&H5B
        JP      C,V9_SYNTAX
V9_ANS_OK:
        PRE     IX,V2_ANS
        LDW     $15,(IX+$SX)
        PRE     IX,V2_ANS+2
        LDW     $17,(IX+$SX)
        CAL     V9_PUSH
        AN      $4,$4
        JP      NZ,V9_RET
        JP      V9_ATOM_DONE
V9_NM_S:
        LD      $0,(IX+1)
        SBC     $0,&H55
        JP      NZ,V9_SYNTAX
        LD      $0,(IX+2)
        SBC     $0,&H42
        JP      NZ,V9_SYNTAX
        LD      $0,&H72
        JP      V9_NM_FN
V9_NM_M:
; MUL/MOD share initial 'M' but have distinct remaining letters.
        LD      $0,(IX+1)
        SBC     $0,&H55
        JP      Z,V9_NM_MUL
        SBC     $0,&H4F
        JP      NZ,V9_SYNTAX
        LD      $0,(IX+2)
        SBC     $0,&H44
        JP      NZ,V9_SYNTAX
        LD      $0,&H75    ; MOD = '%' (same operation as infix)
        JP      V9_NM_FN
V9_NM_MUL:
        LD      $0,(IX+2)
        SBC     $0,&H4C
        JP      NZ,V9_SYNTAX
        LD      $0,&H73    ; MUL = '*'
        JP      V9_NM_FN
V9_NM_D:
; DIV is the only accepted function name beginning with 'D'.
        LD      $0,(IX+1)
        SBC     $0,&H49
        JP      NZ,V9_SYNTAX
        LD      $0,(IX+2)
        SBC     $0,&H56
        JP      NZ,V9_SYNTAX
        LD      $0,&H74
V9_NM_FN:
        PRE     IX,V9_PENDING
        ST      $0,(IX+$SX)
        CAL     V9_SKIP
        SBC     $0,&H28
        JP      NZ,V9_SYNTAX
        CAL     V9_INC_NEST
        AN      $4,$4
        JP      NZ,V9_RET
        PRE     IX,V9_PENDING
        LD      $0,(IX+$SX)
        CAL     V9_OP_PUSH
        AN      $4,$4
        JP      NZ,V9_RET
        CAL     V9_ADV
        JP      V9_LOOP
V9_ATOM_DONE:
        LD      $0,1
        PRE     IX,V9_EXPECT
        ST      $0,(IX+$SX)
        JP      V9_LOOP

; After one operand, only operator, comma, close paren, or EOF is legal.
V9_AFTER:
        CAL     V9_PEEK
        AN      $0,$0
        JP      Z,V9_FINISH
        SBC     $0,&H29
        JP      Z,V9_CLOSE
        SBC     $0,&H2C
        JP      Z,V9_COMMA
        SBC     $0,&H2B
        JP      Z,V9_OPERATOR
        SBC     $0,&H2D
        JP      Z,V9_OPERATOR
        SBC     $0,&H2A
        JP      Z,V9_OPERATOR
        SBC     $0,&H2F
        JP      Z,V9_OPERATOR
        SBC     $0,&H25
        JP      Z,V9_OPERATOR
        JP      V9_SYNTAX
V9_OPERATOR:
        PRE     IX,V9_PENDING
        ST      $0,(IX+$SX)
V9_OP_COMPARE:
        CAL     V9_OP_TOP
        AN      $0,$0
        JP      Z,V9_OP_STORE
        SBC     $0,&H28
        JP      Z,V9_OP_STORE
        SBC     $0,&H70
        JP      NC,V9_OP_STORE
; Incoming high precedence leaves stacked low-precedence operations alone.
        LD      $1,$0
        SBC     $1,&H2B
        JP      Z,V9_OP_LOW
        SBC     $1,&H2D
        JP      Z,V9_OP_LOW
        JP      V9_OP_APPLY
V9_OP_LOW:
        PRE     IX,V9_PENDING
        LD      $0,(IX+$SX)
        SBC     $0,&H2A
        JP      Z,V9_OP_STORE
        SBC     $0,&H2F
        JP      Z,V9_OP_STORE
        SBC     $0,&H25
        JP      Z,V9_OP_STORE
V9_OP_APPLY:
        CAL     V9_APPLY
        AN      $4,$4
        JP      NZ,V9_RET
        JP      V9_OP_COMPARE
V9_OP_STORE:
        PRE     IX,V9_PENDING
        LD      $0,(IX+$SX)
        CAL     V9_OP_PUSH
        AN      $4,$4
        JP      NZ,V9_RET
        CAL     V9_ADV
        LD      $0,0
        PRE     IX,V9_EXPECT
        ST      $0,(IX+$SX)
        JP      V9_LOOP

; Comma reduces within the current FUNCTION frame, and marks one comma.
V9_COMMA:
        CAL     V9_REDUCE
        AN      $4,$4
        JP      NZ,V9_RET
        CAL     V9_OP_TOP
        SBC     $0,&H71
        JP      C,V9_SYNTAX
        SBC     $0,&H76
        JP      NC,V9_SYNTAX
; Mark exactly one comma on the opening function marker.
        AD      $0,8
        CAL     V9_OP_SET
        CAL     V9_ADV
        LD      $0,0
        PRE     IX,V9_EXPECT
        ST      $0,(IX+$SX)
        JP      V9_LOOP

V9_CLOSE:
        CAL     V9_REDUCE
        AN      $4,$4
        JP      NZ,V9_RET
        CAL     V9_OP_TOP
        AN      $0,$0
        JP      Z,V9_SYNTAX
        SBC     $0,&H28
        JP      Z,V9_CLOSE_GRP
        SBC     $0,&H79
        JP      C,V9_SYNTAX
        SBC     $0,&H7E
        JP      NC,V9_SYNTAX
; Pop marked function marker, convert into arithmetic operation,
; dispatch on two values via the same V9_APPLY path as infix.
        CAL     V9_OP_POP
        SB      $0,&H78    ; 1=add 2=sub 3=mul 4=div 5=mod
        SBC     $0,1
        JP      Z,V9_FN_ADD
        SBC     $0,2
        JP      Z,V9_FN_SUB
        SBC     $0,3
        JP      Z,V9_FN_MUL
        SBC     $0,4
        JP      Z,V9_FN_DIV
        LD      $0,&H25
        JP      V9_FN_CALL
V9_FN_ADD:
        LD      $0,&H2B
        JP      V9_FN_CALL
V9_FN_SUB:
        LD      $0,&H2D
        JP      V9_FN_CALL
V9_FN_MUL:
        LD      $0,&H2A
        JP      V9_FN_CALL
V9_FN_DIV:
        LD      $0,&H2F
V9_FN_CALL:
        CAL     V9_OP_PUSH
        AN      $4,$4
        JP      NZ,V9_RET
        CAL     V9_APPLY
        AN      $4,$4
        JP      NZ,V9_RET
        JP      V9_CLOSE_DONE
V9_CLOSE_GRP:
        CAL     V9_OP_POP
V9_CLOSE_DONE:
        CAL     V9_DEC_NEST
        CAL     V9_ADV
        JP      V9_LOOP

; Reduce all real operators until '(' / function marker or empty.
V9_REDUCE:
        CAL     V9_OP_TOP
        AN      $0,$0
        JP      Z,V9_RED_OK
        SBC     $0,&H28
        JP      Z,V9_RED_OK
        SBC     $0,&H70
        JP      NC,V9_RED_OK
        CAL     V9_APPLY
        AN      $4,$4
        RTN     NZ
        JP      V9_REDUCE
V9_RED_OK:
        LD      $4,0
        RTN
V9_FINISH:
        CAL     V9_REDUCE
        AN      $4,$4
        JP      NZ,V9_RET
        PRE     IX,V9_OCNT
        LD      $0,(IX+$SX)
        AN      $0,$0
        JP      NZ,V9_SYNTAX
        PRE     IX,V9_VCNT
        LD      $0,(IX+$SX)
        SBC     $0,1
        JP      NZ,V9_SYNTAX
        CAL     V9_POP
        AN      $4,$4
        RTN     NZ
; Atomic register update occurs here, AFTER all syntax and arithmetic
; validation and after retrieving the one final stack value. V2_COMMIT
; commits read-only ans only upon success from this same entry.
        PRE     IX,V9_ASSIGN
        LD      $0,(IX+$SX)
        SBC     $0,&HFF
        RTN     Z
        BIU     $0
        BIU     $0
        PRE     IX,V9_REGFILE
        STW     $15,(IX+$0)
        AD      $0,2
        STW     $17,(IX+$0)
        LD      $4,0
        RTN

; Value stack (MAX 60 entries, each little-endian four bytes).
V9_PUSH:
        PST     UA,&H14
        PRE     IX,V9_VCNT
        LD      $0,(IX+$SX)
        SBC     $0,60
        JP      NC,V9_DEPTH
        LD      $1,$0
        AD      $1,$SY
        ST      $1,(IX+$SX)
        BIU     $0
        BIU     $0
        PRE     IX,V9_VALST
        STW     $15,(IX+$0)
        AD      $0,2
        STW     $17,(IX+$0)
        LD      $4,0
        RTN
V9_POP:
        PST     UA,&H14
        PRE     IX,V9_VCNT
        LD      $0,(IX+$SX)
        AN      $0,$0
        JP      Z,V9_POP_ERR
        SB      $0,$SY
        ST      $0,(IX+$SX)
        BIU     $0
        BIU     $0
        PRE     IX,V9_VALST
        LDW     $15,(IX+$0)
        AD      $0,2
        LDW     $17,(IX+$0)
        LD      $4,0
        RTN
V9_POP_ERR:
        LD      $4,3
        RTN

; Operator stack (MAX 119 entries). All routines keep UA=14.
V9_OP_PUSH:
        PST     UA,&H14
        LD      $3,$0
        PRE     IX,V9_OCNT
        LD      $1,(IX+$SX)
        SBC     $1,119
        JP      NC,V9_DEPTH
        LD      $2,$1
        AD      $1,$SY
        ST      $1,(IX+$SX)
        PRE     IX,V9_OPST
        ST      $3,(IX+$2)
        LD      $4,0
        RTN
V9_OP_TOP:
        PST     UA,&H14
        PRE     IX,V9_OCNT
        LD      $1,(IX+$SX)
        AN      $1,$1
        JP      Z,V9_OP_EMPTY
        SB      $1,$SY
        PRE     IX,V9_OPST
        LD      $0,(IX+$1)
        RTN
V9_OP_EMPTY:
        LD      $0,0
        RTN
V9_OP_SET:
        PST     UA,&H14
        PRE     IX,V9_OCNT
        LD      $1,(IX+$SX)
        SB      $1,$SY
        PRE     IX,V9_OPST
        ST      $0,(IX+$1)
        RTN
V9_OP_POP:
        PST     UA,&H14
        PRE     IX,V9_OCNT
        LD      $1,(IX+$SX)
        SB      $1,$SY
        ST      $1,(IX+$SX)
        PRE     IX,V9_OPST
        LD      $0,(IX+$1)
        RTN

; Single transactional arithmetic dispatch for every operator source.
V9_APPLY:
        CAL     V9_OP_POP
        PRE     IX,V9_CURRENT
        ST      $0,(IX+$SX)
        CAL     V9_POP
        AN      $4,$4
        RTN     NZ
        PRE     IX,V9_RIGHT
        STW     $15,(IX+$SX)
        PRE     IX,V9_RIGHT+2
        STW     $17,(IX+$SX)
        CAL     V9_POP
        AN      $4,$4
        RTN     NZ
        PRE     IX,V9_RIGHT
        LDW     $5,(IX+$SX)
        PRE     IX,V9_RIGHT+2
        LDW     $7,(IX+$SX)
        PRE     IX,V9_CURRENT
        LD      $0,(IX+$SX)
        SBC     $0,&H2B
        JP      Z,V9_DO_ADD
        SBC     $0,&H2D
        JP      Z,V9_DO_SUB
        SBC     $0,&H2A
        JP      Z,V9_DO_MUL
        SBC     $0,&H2F
        JP      Z,V9_DO_DIV
        SBC     $0,&H25
        JP      Z,V9_DO_MOD
        LD      $4,3
        RTN
V9_DO_ADD:
        CAL     UADD32CHK
        AN      $4,$4
        JP      Z,V9_OP_OK
        LD      $4,2
        RTN
V9_DO_SUB:
        CAL     USUB32CHK
        AN      $4,$4
        JP      Z,V9_OP_OK
        LD      $4,5
        RTN
V9_DO_MUL:
        CAL     UMUL32CHK
        AN      $4,$4
        JP      Z,V9_OP_OK
        LD      $4,2
        RTN
V9_DO_DIV:
        LD      $3,0
        JP      V9_DO_DMOD
V9_DO_MOD:
        LD      $3,1
V9_DO_DMOD:
; Guaranteed literal zero test: never compare to $SZ's RAM register.
        PRE     IX,V9_DMODE
        ST      $3,(IX+$SX)
        LD      $0,$5
        OR      $0,$6
        OR      $0,$7
        OR      $0,$8
        AN      $0,$0
        JP      Z,V9_ZERO_DIV
        CAL     UDIV32NZ
        PRE     IX,V9_DMODE
        LD      $0,(IX+$SX)
        AN      $0,$0
        JP      Z,V9_OP_OK
        LDM     $15,$10,4
V9_OP_OK:
        CAL     V9_PUSH
        RTN
V9_ZERO_DIV:
        LD      $4,6
        RTN

V9_SYNTAX:
        LD      $4,3
V9_RET:
        RTN
V9_EMPTY:
        LD      $4,4
        RTN
V9_OVER:
        LD      $4,2
        RTN