classic.s
Original bytes preserved. This is a browser-readable view.
; ======================================================================
; CS617 Chapter01 v2 -- integrated historical classical calculator v1
; Alex Barragan and ChatGPT (Sol), 2026-10-26
;
; Behavior reference: accepted Chapter01 r003, frozen unchanged.
; Historical UI: title row 1; blank row 2; [op1][op][op2] row 3;
; result/errors row 4, shared SYS540 underline blink, chained u32 modulo arithmetic.
; App-only adaptation: workspace relocated from 2000h to 2FA8h;
; one common numeric implementation; K540 keyboard instead of old INKEY;
; MENU -> four-choice launcher, BRK -> current active page on warm reentry.
; Historical location/appearance retained; shared SYS540 owns blink timing.
; This is an application transplant, not a byte-identical historical routine.
; No original header/vectors/ROM ID/splash, key scanner or numeric includes.
; Native HD61 assembly and emulator acceptance remain pending.
; ======================================================================
C1_WS_OP1: EQU &H2FA8 ; 4 bytes
C1_WS_OP2: EQU &H2FAC ; 4 bytes
C1_WS_OPER:EQU &H2FB0
C1_WS_STATE:EQU &H2FB1
C1_WS_LEN1:EQU &H2FB2
C1_WS_LEN2:EQU &H2FB3
C1_WS_CUR: EQU &H2FB4
C1_WS_TICK:EQU &H2FB5
C1_WS_SHIFT:EQU &H2FB6 ; historical spare, initialized by CLR_STATE
C1_FMT1: EQU &H2FC8 ; 11 bytes including NUL
C1_FMT2: EQU &H2FD8 ; 11 bytes including NUL
; The V2_COLD path alone initializes this state; selecting [v1] does not.
C1_COLD:
PST UA,&H14
CAL C1_CLR_STATE
RTN
; On MENU/V1 re-entry redraw from persisted state; do not cold-reset.
C1_ENTER:
PST UA,&H14
CAL KBD_INIT
CAL LCD_CLEAR
CAL SYS540_INIT
LD $6,0
PRE IZ,C1_TXT_APP
CAL LCD_PUTZ
CAL C1_RENDER_EXPR
PRE IX,C1_WS_STATE
LD $9,(IX+$SX)
SBC $9,2
JR NZ,C1_NO_RESULT
CAL C1_SHOW_RESULT
C1_NO_RESULT:
CAL C1_DRAW_CURSOR
JP C1_KEY_LOOP
; K540_RAW is nonblocking, allowing the historical underline to blink.
; KBD_EVENT supplies the same common mapping as other clients (incl red-S%).
; This avoids copying the frozen historical scanner and KEYSCAN table.
C1_KEY_LOOP:
CAL SYS540_POLL
AN $18,$18
JR Z,C1_IDLE_KEY
CAL SYS540_TOGGLE
C1_IDLE_KEY:
CAL K540_RAW
AN $17,$17
JR NZ,C1_KEY_READY
JP C1_KEY_LOOP
C1_KEY_READY:
CAL KBD_EVENT
SBC $17,K540_EV_MENU
JP Z,C1_TO_MENU
SBC $17,K540_EV_BRK
JP Z,C1_TO_WARM
SBC $17,K540_EV_CHAR
JP NZ,C1_KEY_LOOP
LD $12,$0
CAL SYS540_HIDE
CAL C1_HANDLE_KEY
CAL C1_RENDER_EXPR
CAL C1_DRAW_CURSOR
JP C1_KEY_LOOP
C1_TO_MENU:
CAL SYS540_STOP
CAL KBD_RESET
JP V2_HOME
C1_TO_WARM:
CAL SYS540_STOP
CAL KBD_RESET
JP V2_WARM
; Extracted r003 key-dispatch, arithmetic, editing, rendering routines follow.
; The C1_* label namespace isolates local application implementation.
C1_HANDLE_KEY:
; Decimal digit '0'..'9'.
SBC $12,&H30
JR C,C1_HK_OTHER
SBC $12,&H3A
JR NC,C1_HK_OTHER
SB $12,&H30
JP C1_APP_DIGIT
C1_HK_OTHER:
SBC $12,&H2B
JR Z,C1_HK_PLUS
SBC $12,&H2D
JR Z,C1_HK_MINUS
SBC $12,&H2A
JR Z,C1_HK_MUL
SBC $12,&H2F
JR Z,C1_HK_DIV
SBC $12,&H25
JR Z,C1_HK_MOD
SBC $12,&H3D
JP Z,C1_EXEC_CALC
SBC $12,&H0D
JP Z,C1_EXEC_CALC
SBC $12,&H08
JP Z,C1_BS_KEY
RTN
C1_HK_PLUS:
LD $12,&H2B
JP C1_SET_OPER
C1_HK_MINUS:
LD $12,&H2D
JP C1_SET_OPER
C1_HK_MUL:
LD $12,&H2A
JP C1_SET_OPER
C1_HK_DIV:
LD $12,&H2F
JP C1_SET_OPER
C1_HK_MOD:
LD $12,&H25
JP C1_SET_OPER
; ======================================================================
; C1_APP_DIGIT
; Input: $12 = numeric digit 0..9
;
; Uses UDECAPP. Leading zeroes are canonicalized:
; blank + 0 -> "0"
; "0" + 0 -> "0"
; "0" + 5 -> "5"
; ======================================================================
C1_APP_DIGIT:
; A digit after a result starts a fresh expression.
PRE IX,C1_WS_STATE
LD $9,(IX+$SX)
SBC $9,2
JR NZ,C1_AD_STATE
CAL C1_CLR_STATE
C1_AD_STATE:
PRE IX,C1_WS_STATE
LD $9,(IX+$SX)
SBC $9,1
JP Z,C1_APP_OP2
; ----------------------------------------------------------------------
; Append to OP1.
; ----------------------------------------------------------------------
C1_APP_OP1:
PRE IX,C1_WS_LEN1
LD $13,(IX+$SX)
; D4 integration guard:
; Canonical u32 decimal input can never exceed 10 digits.
; Once length is already 10, reject the very next digit before UDECAPP.
SBC $13,10
JP NC,C1_MSG_OVER
PRE IX,C1_WS_OP1
LDM $15,(IX+$SX),4
; $14 = 1 iff an existing canonical field currently represents zero.
LD $14,0
AN $13,$13
JR Z,C1_A1_CALL
SBW $0,$0
SBCW $15,$0
JR NZ,C1_A1_CALL
SBCW $17,$0
JR NZ,C1_A1_CALL
LD $14,1
C1_A1_CALL:
LD $5,$12
CAL UDECAPP
AN $4,$4
JP NZ,C1_MSG_OVER
PRE IX,C1_WS_OP1
STM $15,(IX+$SX),4
; Empty or existing zero -> canonical length 1. Otherwise increment.
AN $13,$13
JR Z,C1_A1_LEN1
AN $14,$14
JR NZ,C1_A1_LEN1
AD $13,$SY
JR C1_A1_STLEN
C1_A1_LEN1:
LD $13,1
C1_A1_STLEN:
PRE IX,C1_WS_LEN1
ST $13,(IX+$SX)
CAL C1_CLEAR_ROW3
RTN
; ----------------------------------------------------------------------
; Append to OP2.
; ----------------------------------------------------------------------
C1_APP_OP2:
PRE IX,C1_WS_LEN2
LD $13,(IX+$SX)
; Same D4 10-digit integration guard for OP2.
SBC $13,10
JP NC,C1_MSG_OVER
PRE IX,C1_WS_OP2
LDM $15,(IX+$SX),4
LD $14,0
AN $13,$13
JR Z,C1_A2_CALL
SBW $0,$0
SBCW $15,$0
JR NZ,C1_A2_CALL
SBCW $17,$0
JR NZ,C1_A2_CALL
LD $14,1
C1_A2_CALL:
LD $5,$12
CAL UDECAPP
AN $4,$4
JP NZ,C1_MSG_OVER
PRE IX,C1_WS_OP2
STM $15,(IX+$SX),4
AN $13,$13
JR Z,C1_A2_LEN1
AN $14,$14
JR NZ,C1_A2_LEN1
AD $13,$SY
JR C1_A2_STLEN
C1_A2_LEN1:
LD $13,1
C1_A2_STLEN:
PRE IX,C1_WS_LEN2
ST $13,(IX+$SX)
CAL C1_CLEAR_ROW3
RTN
; ======================================================================
; C1_SET_OPER
; Input: $12 = ASCII operator + - * / %
;
; ENTER_OP1:
; require OP1 nonblank, choose operator, enter OP2
;
; ENTER_OP2:
; replace operator without touching OP2
;
; RESULT:
; chain from current OP1/result, clear OP2, enter OP2
; ======================================================================
C1_SET_OPER:
PRE IX,C1_WS_STATE
LD $9,(IX+$SX)
SBC $9,1
JR Z,C1_SO_REPLACE
SBC $9,2
JR Z,C1_SO_CHAIN
; ENTER_OP1 requires a value.
PRE IX,C1_WS_LEN1
LD $10,(IX+$SX)
AN $10,$10
RTN Z
CAL C1_CLEAR_OP2
C1_SO_STORE:
PRE IX,C1_WS_OPER
ST $12,(IX+$SX)
PRE IX,C1_WS_STATE
LD $10,1
ST $10,(IX+$SX)
CAL C1_CLEAR_ROW3
RTN
C1_SO_REPLACE:
PRE IX,C1_WS_OPER
ST $12,(IX+$SX)
CAL C1_CLEAR_ROW3
RTN
C1_SO_CHAIN:
CAL C1_CLEAR_OP2
JR C1_SO_STORE
; ======================================================================
; C1_EXEC_CALC
; Compute only when OP2 is active and nonblank.
; ======================================================================
C1_EXEC_CALC:
PRE IX,C1_WS_STATE
LD $9,(IX+$SX)
SBC $9,1
RTN NZ
PRE IX,C1_WS_LEN2
LD $9,(IX+$SX)
AN $9,$9
RTN Z
; Load operands into library ABI.
PRE IX,C1_WS_OP1
LDM $15,(IX+$SX),4
PRE IX,C1_WS_OP2
LDM $5,(IX+$SX),4
PRE IX,C1_WS_OPER
LD $9,(IX+$SX)
SBC $9,&H2B
JP Z,C1_DO_ADD
SBC $9,&H2D
JP Z,C1_DO_SUB
SBC $9,&H2A
JP Z,C1_DO_MUL
SBC $9,&H2F
JP Z,C1_DO_DIV
SBC $9,&H25
JP Z,C1_DO_MOD
RTN
C1_DO_ADD:
CAL UADD32
JP C1_EXEC_DONE
C1_DO_SUB:
CAL USUB32
JP C1_EXEC_DONE
C1_DO_MUL:
CAL UMUL32
JP C1_EXEC_DONE
C1_DO_DIV:
CAL C1_CHECK_DIV0
AN $4,$4
JP NZ,C1_MSG_DIV0
CAL UDIV32NZ
JP C1_EXEC_DONE
C1_DO_MOD:
CAL C1_CHECK_DIV0
AN $4,$4
JP NZ,C1_MSG_DIV0
CAL UDIV32NZ
LDM $15,$10,4
JP C1_EXEC_DONE
; Input divisor remains in $5-$8 here.
; Output $4 = 0 nonzero divisor, 1 zero divisor.
C1_CHECK_DIV0:
SBW $0,$0
SBCW $5,$0
JR NZ,C1_CD_NONZERO
SBCW $7,$0
JR NZ,C1_CD_NONZERO
LD $4,1
RTN
C1_CD_NONZERO:
LD $4,0
RTN
C1_EXEC_DONE:
; Save result as new OP1.
PRE IX,C1_WS_OP1
STM $15,(IX+$SX),4
; Format once now: establishes canonical result length and row-3 result text.
PRE IX,C1_FMT1
CAL UFMT32DEC
PRE IX,C1_WS_LEN1
ST $14,(IX+$SX)
; Clear operator/OP2 and enter RESULT state.
CAL C1_CLEAR_OP2
PRE IX,C1_WS_OPER
LD $9,0
ST $9,(IX+$SX)
PRE IX,C1_WS_STATE
LD $9,2
ST $9,(IX+$SX)
CAL C1_SHOW_RESULT
RTN
; ======================================================================
; C1_BS_KEY
;
; Physical BS is treated as calculator backspace/retreat.
; RESULT is editable OP1.
; OP2 empty -> retreat to OP1 and remove operator.
; Otherwise remove one canonical decimal digit using quotient by 10.
; ======================================================================
C1_BS_KEY:
PRE IX,C1_WS_STATE
LD $9,(IX+$SX)
SBC $9,2
JR NZ,C1_DK_STATE
LD $9,0
ST $9,(IX+$SX)
C1_DK_STATE:
PRE IX,C1_WS_STATE
LD $9,(IX+$SX)
SBC $9,1
JP Z,C1_DEL_OP2
JP C1_DEL_OP1
C1_DEL_OP1:
PRE IX,C1_WS_LEN1
LD $9,(IX+$SX)
AN $9,$9
RTN Z
PRE IX,C1_WS_OP1
LDM $15,(IX+$SX),4
LDW $5,10
CAL UDIV3216NZ
PRE IX,C1_WS_OP1
STM $15,(IX+$SX),4
PRE IX,C1_WS_LEN1
LD $9,(IX+$SX)
SB $9,$SY
ST $9,(IX+$SX)
CAL C1_CLEAR_ROW3
RTN
C1_DEL_OP2:
PRE IX,C1_WS_LEN2
LD $9,(IX+$SX)
AN $9,$9
JR Z,C1_DEL_RETREAT
PRE IX,C1_WS_OP2
LDM $15,(IX+$SX),4
LDW $5,10
CAL UDIV3216NZ
PRE IX,C1_WS_OP2
STM $15,(IX+$SX),4
PRE IX,C1_WS_LEN2
LD $9,(IX+$SX)
SB $9,$SY
ST $9,(IX+$SX)
CAL C1_CLEAR_ROW3
RTN
C1_DEL_RETREAT:
PRE IX,C1_WS_OPER
LD $9,0
ST $9,(IX+$SX)
PRE IX,C1_WS_STATE
ST $9,(IX+$SX)
CAL C1_CLEAR_ROW3
RTN
; ======================================================================
; Workspace helpers.
; ======================================================================
C1_CLR_STATE:
PRE IX,C1_WS_OP1
LD $0,0
ST $0,(IX+0)
ST $0,(IX+1)
ST $0,(IX+2)
ST $0,(IX+3)
ST $0,(IX+4)
ST $0,(IX+5)
ST $0,(IX+6)
ST $0,(IX+7)
ST $0,(IX+8)
ST $0,(IX+9)
ST $0,(IX+10)
ST $0,(IX+11)
LD $0,1
ST $0,(IX+12)
LD $0,0
ST $0,(IX+13)
ST $0,(IX+14)
RTN
C1_CLEAR_OP2:
PRE IX,C1_WS_OP2
LD $0,0
ST $0,(IX+0)
ST $0,(IX+1)
ST $0,(IX+2)
ST $0,(IX+3)
PRE IX,C1_WS_LEN2
ST $0,(IX+$SX)
RTN
C1_DRAW_CURSOR:
PRE IX,C1_WS_STATE
LD $9,(IX+$SX)
SBC $9,1
JR Z,C1_DC_OP2
; OP1 / RESULT cursor: row 3, column 1 + LEN1.
PRE IX,C1_WS_LEN1
LD $10,(IX+$SX)
LD $6,&H41
AD $6,$10
JR C1_DC_CHAR
C1_DC_OP2:
; OP2 cursor: row 3, column 17 + LEN2.
PRE IX,C1_WS_LEN2
LD $10,(IX+$SX)
LD $6,&H51
AD $6,$10
C1_DC_CHAR:
LD $16,&H20
CAL SYS540_PLACE
CAL SYS540_SHOW
RTN
; ======================================================================
; DISPLAY
; D2's corrected PUTC loops are retained unchanged.
; D3 moves branding/help out of the application and into a splash.
; ======================================================================
C1_SHOW_TITLE:
LD $6,$SX
PRE IZ,C1_TXT_APP
CAL LCD_PUTZ
RTN
; Prepare decimal buffers only after actual state changes / rendering.
; Blink never calls this routine.
C1_PREP_FIELDS:
PRE IX,C1_WS_LEN1
LD $9,(IX+$SX)
AN $9,$9
JR Z,C1_PF_OP2
PRE IX,C1_WS_OP1
LDM $15,(IX+$SX),4
PRE IX,C1_FMT1
CAL UFMT32DEC
C1_PF_OP2:
PRE IX,C1_WS_LEN2
LD $9,(IX+$SX)
AN $9,$9
RTN Z
PRE IX,C1_WS_OP2
LDM $15,(IX+$SX),4
PRE IX,C1_FMT2
CAL UFMT32DEC
RTN
; Row 3 is always rewritten as exactly 32 characters.
C1_RENDER_EXPR:
CAL C1_PREP_FIELDS
LD $6,&H40
; [ OP1........ ]
LD $16,&H5B
CAL PUTC
PRE IX,C1_WS_LEN1
LD $13,(IX+$SX)
CAL C1_PRINT_FMT1
LD $12,11
SB $12,$13
CAL C1_FILL_SP
LD $16,&H5D
CAL PUTC
; [op]
LD $16,&H5B
CAL PUTC
PRE IX,C1_WS_OPER
LD $16,(IX+$SX)
AN $16,$16
JR NZ,C1_RE_OPCHAR
LD $16,&H20
C1_RE_OPCHAR:
CAL PUTC
LD $16,&H5D
CAL PUTC
; [ OP2........ ]
LD $16,&H5B
CAL PUTC
PRE IX,C1_WS_LEN2
LD $13,(IX+$SX)
CAL C1_PRINT_FMT2
LD $12,11
SB $12,$13
CAL C1_FILL_SP
LD $16,&H5D
CAL PUTC
; Three trailing cells complete the 32-column row.
LD $12,3
CAL C1_FILL_SP
RTN
; Print C1_FMT1 for exactly C1_WS_LEN1 bytes.
C1_PRINT_FMT1:
AN $13,$13
RTN Z
LD $12,0
C1_PF1_LOOP:
SBC $12,$13
RTN NC
PRE IX,C1_FMT1
LD $16,(IX+$12)
CAL PUTC
AD $12,$SY
JR C1_PF1_LOOP
; Print C1_FMT2 for exactly C1_WS_LEN2 bytes.
C1_PRINT_FMT2:
AN $13,$13
RTN Z
LD $12,0
C1_PF2_LOOP:
SBC $12,$13
RTN NC
PRE IX,C1_FMT2
LD $16,(IX+$12)
CAL PUTC
AD $12,$SY
JR C1_PF2_LOOP
; Input $12 = number of spaces.
C1_FILL_SP:
AN $12,$12
RTN Z
LD $16,&H20
CAL PUTC
SB $12,$SY
JR C1_FILL_SP
C1_CLEAR_ROW3:
; Compatibility label retained from D3; D4 status/message row is row 4.
LD $6,&H60
LD $8,32
CAL &H018D
RTN
C1_MSG_OVER:
CAL C1_CLEAR_ROW3
LD $6,&H60
PRE IZ,C1_TXT_OVER
CAL LCD_PUTZ
RTN
C1_MSG_DIV0:
CAL C1_CLEAR_ROW3
LD $6,&H60
PRE IZ,C1_TXT_DIV0
CAL LCD_PUTZ
RTN
; C1_FMT1 and C1_WS_LEN1 already describe the just-computed result.
C1_SHOW_RESULT:
CAL C1_CLEAR_ROW3
LD $6,&H60
PRE IZ,C1_TXT_EQ
CAL LCD_PUTZ
PRE IX,C1_WS_LEN1
LD $13,(IX+$SX)
CAL C1_PRINT_FMT1
RTN
C1_TXT_APP:
DB "CS617 u32 Calculator",0
C1_TXT_OVER:
DB "OVERFLOW",0
C1_TXT_DIV0:
DB "DIVIDE BY ZERO",0
C1_TXT_EQ:
DB "= ",0