parser.s
Original bytes preserved. This is a browser-readable view.
; ======================================================================
; 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