SOURCE VIEWER

classic.s

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

DOWNLOAD ORIGINAL ↓

; ======================================================================
; 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