bios.z80

; bios.z80
;
; This file contains the common primitives we use for interfacing
; with CP/M or the ZX Spectrum (48k).
;
; We don't use many primitives, but we do need some facilities from
; the operating system, or the Spectrum ROM:
;
;  Pause for a keypress.
;
;  Clear the screen.
;
;  Output a string.
;
;  Allow the user to enter input
;
;  Pause for a "small delay"
;
; The routines here will work for both systems, and contain the only
; platform-specific code we need.
;

IF SPECTRUM
  MAX_INPUT_LENGTH: EQU 30
ELSE
  MAX_INPUT_LENGTH: EQU 78
ENDIF

;
; Initialization routine for the BIOS, if needed
; {{
bios_init:

IF SPECTRUM
   ld a,2
   call 5633  ; ROM_OPEN_CHANNEL
   call c_chan
   ld a,4
   call 5633  ; ROM_OPEN_CHANNEL

ENDIF
   ret
; }}

;
; Delay for "a short while".
;
; This is used for showing "dots" in the SLEEP command, or when the
; grue is threatening you..
;
; {{
bios_delay:

IF SPECTRUM
   PUSH_ALL
   ld b,4
wait:
   halt
   djnz wait
   POP_ALL
   ret

ELSE
    ; Random values found by experimentation with my own system
    ld hl,0xffff / 8
hl_delay_loop:
    inc hl
    ld de, 0xffff - 10
de_delay_loop:
    inc de
    ld a, d
    or e
    jr nz, de_delay_loop
    ld a,h
    or l
    jr nz, hl_delay_loop
    ret

ENDIF
;; }}



;
; Clear the screen.
;
; {{
bios_clear_screen:

IF SPECTRUM
        PUSH_ALL
        ld a,2
        call 0x1601  ; ROM_OPEN_CHANNEL
        call 0x0DAF  ; ROM_CLS

        ;
        ; The code above will clear the screen, however we use a custom
        ; printing routine which has its own notion of the X,Y / AT
        ; coordinates to use.
        ;
        ; We explicitly reset those here, otherwise the screen will be clear,
        ; but printing will start at whatever spot it finished the previous
        ; time something was output.
        ;
        xor a
        ld hl,atflg
        ld (hl),a
        ld hl, row
        ld (hl),a
        ld hl, col
        ld (hl),a
        POP_ALL
        ret

ELSE
        ld de, cpm_clear_screen_msg
        call bios_output_string
        ret

cpm_clear_screen_msg:
        db 27, "[2J"            ; "clear"
        db 27, "[H"             ; "home"
        db "$"
ENDIF
; }}

;
; Await a keypress.  The pressed-key will be returned in the A-register.
;
; {{
bios_await_keypress:

IF SPECTRUM
       push hl
       ld   hl, 0x5C08   ; LASTK - Set by the Spectrum ROM
       ld   a,255
       ld (hl),a
await_key:
       cp   (hl)
       jr   z,await_key

       ; get the key, and return it.
       ld a,(hl)
       pop hl
       ret
ELSE
       ld c,  0x01
       call 0x0005
       ret
ENDIF
; }}


;
; Output a single character, stored in the E register.
;
; {{
bios_output_character:
        PUSH_ALL
IF SPECTRUM
        ; output the character
        ld a,e
        RST 0x10
ELSE
        ld c, 0x02
        call 0x005
ENDIF
        POP_ALL
        ret
; }}

;
; Output a string, terminated by "$".
;
; The address of the string is stored in DE.
;
; To handle wrapping we process the string character by character,
; this is inefficient, but works fine for this use-case.
;
; {{
bios_output_string:

IF SPECTRUM
   PUSH_ALL
   ld a,4
   call 5633  ; ROM_OPEN_CHANNEL
   POP_ALL
ENDIF

        PUSH_ALL

        ; DE has the string
        ; We'll work on HL, and use BC to keep track of the width
        ; of the string we've printed thus-far
        push de
        pop hl

        ; length will be stored here
print_reset_line:
        ld bc, 0

print_char_loop:
        ; get a character
        ld a,(hl)
        inc hl
        inc bc

        ; end of printing?
        cp '$'
        jr z, end_of_print

        ; linefeed?  Reset our printing width
        cp 0x0d
        jr nz, not_linefeed
         ld e, 0x0d
         call bios_output_character
IF SPECTRUM
ELSE
         ld e, 0x0a
         call bios_output_character
ENDIF
        jr print_reset_line

not_linefeed:
        ; We'll ignore the newline
        cp 0x0a
        jr z, print_char_loop

        ; is it a space?
        cp ' '
        jr nz, print_continues

        ; if our length is bigger than the width we force
        ; a newline, otherwise we keep going
        push af
        push hl
        ld hl, WRAP_LOCATION
        ld a,(hl)
        pop hl
        cp c
        jr c, too_wide
        pop af

print_continues:
        ld e,a
        call bios_output_character
        jr print_char_loop

too_wide:
        pop af

        PUSH_ALL
         ld e, 0x0d
         call bios_output_character
IF SPECTRUM
ELSE
         ld e, 0x0a
         call bios_output_character
ENDIF
        POP_ALL
        jr print_reset_line
end_of_print:
        POP_ALL
        ret
; }}

;
; Prompt the user for a line of input.
;
; The way this works is you pass the address of a region of memory,
; in the DE register.  The first byte is the length of the buffer.
;
; On return the second byte of the buffer will be populated by the
; amount of text which was read, then the input itself:
;
; DE points to the memory buffer;
;
;  0x00 - buffer size
;  0x01 - read-length
;  0x02 ... char..
; {{
bios_read_input:
IF SPECTRUM
        PUSH_ALL

        ; Move the cursor to the bottom of the screen, and display the prompt
        PUSH_ALL
        call move_to_bottom
        ld e, ">"
        call bios_output_character
        POP_ALL

        push de
        pop  hl   ; buffer -> hl

        inc hl    ; skip to the returned size
        inc de

        xor a
        ld (hl),a  ; size is now zero
        inc hl     ; point to the start of the character buffer

read_input_again:
        ; read a char
        call bios_await_keypress

        ; return?  Then we're done
        cp 13
        jp z, read_input_over

        ; delete?  remove the last character
        cp 12
        jr z, backspace

        ; escape? trash the input and start again.
        cp 7
        jr z, reset_line

        ; too many characters?
        push de
        push af
          ld a,(de)                  ; get the count of characters we've entered
          cp MAX_INPUT_LENGTH        ; ignore input if too long
          jr nc,too_many_characters
          jr z, too_many_characters
        pop af
        pop de
        jr continue_input

too_many_characters:
        ; too many characters, cleanup stack and ignore the character
        pop af
        pop de
        jr read_input_again

continue_input:

        ; display the new character
        push de
        ld e,a
        call bios_output_character
        pop de

        ; add the character to the buffer
        ld (hl),a
        inc hl

        ; increase the input count
        ld a,(de)
        inc a
        ld (de),a

        ; repeat
        jr read_input_again

backspace:
        ; remove size of the line by one
        ; unless it was empty
        ld a,(de)
        cp 0
        jr z, read_input_again
        dec a
        ld (de),a

        ; remove character
        dec hl
        ld (hl), 0x00

        PUSH_ALL

        ; move cursor to start
        call move_to_bottom

        ; output spaces - to overwrite what was previously input
        ;
        ; NOTE: We assume our input was a single line.
        ld b, MAX_INPUT_LENGTH+1
        ld e, " "
spaces:
        call bios_output_character
        djnz spaces

        ; move to the bottom, and show the prompt again
        call move_to_bottom

        ; show the prompt
        ld e, ">"
        call bios_output_character
        POP_ALL

        ; save registers
        push hl
        push de
        push bc

        ; is the input line empty?  If so return,
        ; cleaning up the stack.
        ld a,(de)
        cp 0
        jr nz, non_empty
           pop bc
           pop de
           pop hl
           jr read_input_again
non_empty:
        ; OK we're gonna show the input the user
        ; entered.
        ld b,a
        push de
        pop hl
        inc hl
loopy:
        ld e,(hl)
        call bios_output_character
        inc hl
        djnz loopy
        pop bc
        pop de
        pop hl
        jp read_input_again

reset_line:
        ; clear the screen, and restart the input process
        call bios_clear_screen
        POP_ALL
        jp bios_read_input

read_input_over:
        ; move the cursor to the top of the screen, and
        ; prepare for output again.
        call bios_clear_screen

        POP_ALL
        ret

move_to_bottom:
        ld a,22          ; AT code.
        rst 16           ; Set the cursor-coord
        ld a,21          ; vertical coord.
        rst 16           ; set the vertical coord
        xor a            ; horizontal position.
        rst 16           ; set the horizontal coord.
        ret
ELSE
        push de
        ld de, prompt_message
        call bios_output_string
        pop de
        ld c, 0x0A
        call 0x005
        ret
prompt_message:
        db 0x0a, 0x0d,">$"
ENDIF
; }}