Capstone — Writing a Complete LC-3 Program

Nine chapters have each built one working piece of LC-3 — the fetch-decode-execute cycle, addressing modes, registers and condition codes, the instruction encodings, branching, subroutines and the stack, TRAP-based I/O, and finally the assembler mechanics that turn all of it into bits. This capstone combines every one of those pieces into a single, real, working program: a vowel counter that reads a short line of typed lowercase letters, counts how many are vowels, and prints the result.

The Program

Reads up to 8 characters from the keyboard (stopping early if Enter is pressed), echoing each one as it's typed. Once input stops, it walks back through what was typed, uses a subroutine to test each character, and prints the final vowel count as a single digit.

        .ORIG x3000

; === Vowel Counter ===
        AND R3, R3, #0       ; R3 = number of characters read so far = 0
        LEA R4, BUFFER      ; R4 = pointer to the next free buffer slot

READLOOP
        TRAP x20            ; GETC — read one character into R0 (no echo)
        ADD R1, R0, #-13     ; is it Enter (ASCII 13)?
        BRz READDONE        ; if so, stop reading

        TRAP x21            ; OUT — echo the character back to the screen
        STR R0, R4, #0      ; store the character into the buffer
        ADD R4, R4, #1      ; advance the buffer pointer
        ADD R3, R3, #1      ; count++

        ADD R1, R3, #-8     ; is the buffer full (8 characters)?
        BRz READDONE        ; if so, stop reading
        BRnzp READLOOP

READDONE
        AND R2, R2, #0       ; R2 = vowel count = 0
        LEA R4, BUFFER      ; R4 = pointer, reset to the start of the buffer
        ADD R3, R3, #0      ; refresh condition codes on R3 (assembly1-4 discipline)
        BRz PRINTRESULT     ; nothing was typed at all — skip straight to printing 0

COUNTLOOP
        LDR R0, R4, #0      ; load the next character from the buffer
        JSR ISVOWEL          ; R0 in, R0 out: 1 if vowel, else 0
        ADD R2, R2, R0       ; vowel count += result
        ADD R4, R4, #1      ; advance the pointer
        ADD R3, R3, #-1     ; remaining--
        BRp COUNTLOOP       ; loop while characters remain

PRINTRESULT
        LEA R0, MSG
        TRAP x22            ; PUTS — "Vowels found: "
        LD  R1, ASCII0       ; '0' won't fit as a 5-bit immediate (assembly1-5) — load it from memory
        ADD R0, R2, R1       ; R0 = vowel count + '0' = the correct ASCII digit
        TRAP x21            ; OUT — print the digit
        AND R0, R0, #0
        ADD R0, R0, #10      ; x0A newline — 10 DOES fit as a 5-bit immediate, no memory constant needed
        TRAP x21            ; OUT — print the newline
        TRAP x25            ; HALT

; --- Subroutine: ISVOWEL ---
; Input: R0 = a character. Output: R0 = 1 if a lowercase vowel, else 0. Clobbers R1.
; Uses assembly1-5's own NOT-then-add-1 idiom to negate a value, since LC-3
; has no direct "compare register to register" instruction — only ADD.
ISVOWEL
        LD  R1, VOWEL_A
        NOT R1, R1
        ADD R1, R1, #1       ; R1 = -'a' (two's complement negation)
        ADD R1, R0, R1       ; R1 = R0 - 'a'
        BRz ISVOWEL_YES

        LD  R1, VOWEL_E
        NOT R1, R1
        ADD R1, R1, #1
        ADD R1, R0, R1
        BRz ISVOWEL_YES

        LD  R1, VOWEL_I
        NOT R1, R1
        ADD R1, R1, #1
        ADD R1, R0, R1
        BRz ISVOWEL_YES

        LD  R1, VOWEL_O
        NOT R1, R1
        ADD R1, R1, #1
        ADD R1, R0, R1
        BRz ISVOWEL_YES

        LD  R1, VOWEL_U
        NOT R1, R1
        ADD R1, R1, #1
        ADD R1, R0, R1
        BRz ISVOWEL_YES

        AND R0, R0, #0       ; not a vowel
        RET

ISVOWEL_YES
        AND R0, R0, #0
        ADD R0, R0, #1
        RET

BUFFER    .BLKW #8
MSG       .STRINGZ "Vowels found: "
ASCII0    .FILL x0030
VOWEL_A  .FILL x0061
VOWEL_E  .FILL x0065
VOWEL_I  .FILL x0069
VOWEL_O  .FILL x006F
VOWEL_U  .FILL x0075

        .END

Chapter Attribution

Hands-On Exercises