Low-level Programming

     LDM #2
     STO A       ; A ← 2
     LDM #10
     STO B       ; B ← 10
     LDD A
     ADD B
     STO C       ; C ← 12
     LDD A
     SUB B
     STO D       ; D ← -8
     END
A:   0
B:   0
C:   0
D:   0

Run it in the simulator (Task 28.01). D ends as −8, which in 8-bit two's complement is 1111 1000.

        LDD A
        CMP #0
        JPE ELSE     ; A = 0, so the condition A <> 0 is False
THEN:   STO B        ; ACC still holds A, so B ← A
        JMP ENDIF
ELSE:   LDD B
        DEC ACC
        STO B        ; B ← B - 1
ENDIF:  END
A:      5
B:      9

The test is not equal, so this time the jump to ELSE uses JPE. CMP does not change ACC, so A is still there for STO B. Try A = 5 and A = 0 in the simulator.

        LDM #1
        STO NUMBER
        LDM #0
        STO TOTAL
        LDM #5
        STO MAX
LOOP:   LDD TOTAL
        ADD NUMBER
        STO TOTAL     ; Total ← Total + Number
        LDD NUMBER
        INC ACC
        STO NUMBER    ; Number ← Number + 1
        CMP MAX
        JPN LOOP      ; UNTIL Number = Max
        END
NUMBER: 0
TOTAL:  0
MAX:    0

Total finishes as 1 + 2 + 3 + 4 = 10: when Number reaches 5 the loop stops before adding it. CMP MAX compares with the contents of MAX (direct), not the number 5 itself.

        LDM #0
        STO COUNT
LOOP:   LDD COUNT
        INC ACC
        STO COUNT       ; Count ← Count + 1
        IN
        STO CHARACTER   ; INPUT Character
        CMP #78         ; 78 is the ASCII code of "N"
        JPN LOOP
        END
COUNT:     0
CHARACTER: 0

Replace the final END with:

        LDD COUNT
        ADD #48         ; digit value → ASCII code ("0" is 48)
        OUT
        END

OUT sends a character, so the count must become the ASCII code of its digit. This works for counts 0–9. For a count of 10 or more you would have to split it into tens and units digits and output each one, exactly as the book says about outputting numbers.

Push each character onto a stack until Enter (ASCII 13) is pressed, then pop them off, so the last character typed comes out first. IX is the stack pointer; COUNT remembers how many characters are on the stack, because nothing can compare IX directly.

        LDM #0
        STO COUNT
        LDR #0          ; IX = 0: stack empty
PUSH:   IN
        CMP #13         ; Enter ends the word
        JPE POP
        STX STACK       ; push: store at STACK + IX
        INC IX
        LDD COUNT
        INC ACC
        STO COUNT
        JMP PUSH
POP:    LDD COUNT
        CMP #0          ; stack empty?
        JPE DONE
        DEC ACC
        STO COUNT
        DEC IX          ; IX back to the top item
        LDX STACK       ; pop: load from STACK + IX
        OUT
        JMP POP
DONE:   END
COUNT:  0
STACK:  0               ; the stack grows from here

Load Task 28.06 in the simulator and type a word: STRESSED comes out as DESSERTS.

• One instruction or data value per line. A line can start with an address (200 LDM #0, always followed by something) or a label (LOOP: OUT), or both. Lines without an address follow on from the line before.
• A line holding just a number is a data value, so a string can be listed one code per line. A data line can also be a label name, which stores that label's address (HEADPTR: QSTART): a pointer.
• Values can be denary 48, binary B0011 or hex &30; immediate operands start with #.
• Relative operands are written [BR] + 10. Set the base register with .BR 200.
• ; starts a comment. .ACC n, .IX n and .BR n set registers before the run; .START a sets where it begins.
• IN takes from the Input box: each key's ASCII code, the same followed by Enter (13), or whole numbers.

        IN
        STO FIRST
        IN
        STO SECOND
        SUB FIRST       ; SECOND - FIRST
        AND #B10000000  ; sign bit set if the result is negative
        CMP #0
        JPN FIRSTBIG
        LDD SECOND
        JMP SHOW
FIRSTBIG: LDD FIRST
SHOW:   OUT
        END
FIRST:  0
SECOND: 0

There is no "jump if greater" instruction, so this looks at the sign bit of SECOND − FIRST (8-bit two's complement). Digits are ASCII codes 48–57, so the difference is small and the sign bit is reliable.

        LDM #57         ; "9"
LOOP:   OUT
        DEC ACC
        CMP #47         ; one below "0"
        JPN LOOP
        END

        LDM #0
        STO COUNT
LOOP:   IN
        CMP #13
        JPE DONE
        LDD COUNT
        INC ACC
        STO COUNT
        JMP LOOP
DONE:   LDD COUNT
        ADD #48
        OUT
        END
COUNT:  0

This is a WHILE loop: it tests before counting, so pressing Enter straight away gives 0. Choose "… then Enter (13) at the end" for the input.

Each bit of ACC is ANDed with the bit in the same position of the contents of the given address; a result bit is 1 only if both bits are 1, and the result is left in ACC.

AND MASK, where MASK: B00001111 (&0F). The mask keeps the low nibble (the digit's value) and clears the 0011 in the high nibble. For example '7' = 0011 0111 AND 0000 1111 = 0000 0111 = 7.

        IN              ; input first digit
        AND MASK        ; convert from ASCII to its digit value
        LSL #4          ; move to upper nibble
        STO RESULT      ; store in location Result
        IN              ; input second digit
        AND MASK        ; convert from ASCII to its digit value
        ADD RESULT      ; combine the two values
        STO RESULT      ; store result
        END             ; end of program
MASK:   B00001111       ; mask to convert from ASCII to digit
RESULT: &00             ; memory location for result

Only ADD can combine the nibbles with this instruction set (there is no OR here). That is safe because the low nibble of RESULT is 0000 after the shift. Keying in 4 then 7 gives 0100 0111 = &47. Load Exam question 1c in the simulator to check.

        LDR #0          ; set index register to zero
LOOP:   LDX STRING      ; load ACC with the character at STRING + IX
        INC IX          ; increment index register
        OUT             ; output character
        CMP #33         ; is this character the ! key?
        JPN LOOP        ; no: jump to beginning of loop
        END             ; end of program
STRING: 72              ; H
        69              ; E
        76              ; L
        80              ; P
        33              ; !

The output is HELP!. The '!' is output before the test, so it appears too.

Load Exam question 2 in the simulator to run it.