Capstone — Building and Comparing Two Small Programs

One task, one final time, on both chips: find the largest value in a 5-byte array. Unlike cpu8bit1-8's own summing routine, this one uses a real subroutine call — the first time either chip's real hardware stack (cpu8bit1-3, cpu8bit1-7) actually gets exercised by a working program in this course, rather than just described.

The 6502 Version

        LDX #1          ; start comparing from index 1
        LDA ARRAY      ; A = ARRAY[0]
        STA MAX        ; MAX = ARRAY[0] (the starting candidate)
LOOP    CPX #5
        BEQ DONE       ; NEW — branch if equal (complements BNE from cpu8bit1-8)
        LDA ARRAY,X    ; A = the next candidate — zero-page,X (cpu8bit1-4)
        JSR UPDATE_MAX ; NEW — call the subroutine (real stack use, cpu8bit1-3)
        INX
        JMP LOOP
DONE    JMP DONE       ; no HALT on the 6502 (cpu8bit1-8)

; --- Subroutine: UPDATE_MAX ---
; Input: A = candidate. Updates MAX in place if the candidate is bigger.
UPDATE_MAX
        CMP MAX        ; NEW — compare A against MAX (like SBC, but nothing stored)
        BCC SKIP       ; NEW — branch if Carry Clear (A < MAX)
        STA MAX        ; A >= MAX — update it
SKIP    RTS            ; NEW — return, pulling the address JSR pushed

ARRAY   .BYTE 10,50,30,80,20
MAX     .BYTE 0

New here: BEQ (branch if equal — the counterpart to cpu8bit1-8's own BNE), CMP (compares A against a value the same way ADC/SBC would, without storing a result), BCC (branch if Carry is clear), and — for the first time in this course — JSR/RTS, a real subroutine call and return, automatically using the page-1 stack cpu8bit1-3 only described until now.

The Z80 Version

        LD HL, ARRAY
        LD A, (HL)      ; A = ARRAY[0]
        LD (MAX), A     ; MAX = ARRAY[0]
        INC HL
        LD B, 4          ; 4 remaining comparisons
LOOP    LD A, (HL)      ; A = the next candidate — register-indirect (cpu8bit1-7)
        CALL UPDATE_MAX ; NEW — call the subroutine (real stack use, cpu8bit1-7)
        INC HL
        DJNZ LOOP       ; cpu8bit1-8
DONE    JR DONE

; --- Subroutine: UPDATE_MAX ---
; Input: A = candidate. Updates MAX in place if the candidate is bigger.
UPDATE_MAX
        LD C, A         ; save the candidate in C — NOT B, which DJNZ's own loop still needs
        LD A, (MAX)
        CP C            ; NEW — compare A (MAX) against C (candidate)
        JR NC, SKIP     ; NEW — jump if No Carry (MAX >= candidate)
        LD A, C
        LD (MAX), A
SKIP    RET            ; NEW — return, pulling the address CALL pushed

ARRAY   DEFB 10,50,30,80,20
MAX     DEFB 0

New here: CP (compares A against a value, like CMP on the 6502), JR NC (jump if no carry), and — for the first time on this side too — CALL/RET, the Z80's own subroutine call, using its fully flexible 16-bit stack from cpu8bit1-7.

The Real Payoff: Two Opposite Flag Conventions

Both subroutines do the same comparison — yet the 6502's CMP/BCC and the Z80's CP/JR NC read the Carry flag in opposite directions:

On the 6502, Carry set means "no borrow was needed" — the first value was large enough. On the Z80, Carry set means the exact opposite — "a borrow was needed," meaning the first value was too small. Anyone porting comparison logic between the two chips has to consciously flip this reading, or the ported code will silently do the wrong thing while looking completely correct on the page. It's a small, precise, entirely real example of exactly the kind of "same-looking operation, genuinely different behavior" this whole course has been surfacing since cpu8bit1-1.

Chapter Attribution

Hands-On Exercises