CP/M/CPM_CDROM.iso/cpm/programs/bkgrondr/bgiidrv.lbr/K83SCRN.AQM/K83SCRN.ASM

Assembly Source File | 1987-03-22 | 26KB | 1,364 lines

    .title    "K83SCRN.ASM Kaypro '83 screen driver 11/8/86"
    .sbttl    "Copyright (c) 1986  Plu*Perfect Systems"

.remark \==
Source code for CDL/TDL Z80 assembler (AZM.COM).

; production by:
AZM k83scrn
ZLINK
*k83.com=k83scrn.rel
*/locate .prog.=3f80;
*q
ZSID k83.com
m3f80 4500 100
^C
SAVE 5 k83scrn.drv

==\
; revision history:
;
; v 1.1 no scroll on line 24 in cut
;    (changes probably too long to include in '84 driver)
; v 1.0 id imbedded in string, 9/8/86

debug = 0

.ifg DEBUG, [
    bios =\  'Base of bios = ?'
    ]

.remark \===

The first sections of code are generic (except for some terminal equates);
beginning at 'STMRKS' it is terminal-specific.

Particular features of Kaypro '83 code:

1. The video ram is accessed by bank switching.  Active code, including
   stack must be >= 4000h, and interrupts disabled.
2. There's no return-cursor function.  We read the screen, send a
   test character, and find the byte that changed.
3. There's no reverse video, but we create a BLINK attribute to "hilite"
   the cut region by setting bit 7 of the video-ram character.
4. Cursor-movement sequences are all single-byte control characters.

note:    If UNDERSCORE is found at cursor, we convert it to SPACE on
    screen restore.  This isn't good if cursor is sitting on
    a real underscore.
===\

.ifg    DEBUG, [
codloc    =    100h
.phex
.psym
.pabs
consta    =    bios +06h
conin    =    bios +09h
conout    =    bios +0ch
    ]
;
    [
.prel
.ident    SCRK83

consta    =    0
conin    =    0
conout    =    0
outch    =    0
puts    =    0
bwrch    =    0
bflush    =    0
    ]

.xlist
.xsym
.sall
;

; ascii equates
;
NUL    =    00h
BELL    =    07h
BS    =    08h
CR    =    0dh
LF    =    0ah
ESC    =    1bh
SPACE    =    20h
DEL    =    7fh
;
; CUT command characters
;
HOME    =    'H'        ;home the cursor
LOHOME    =    'h'
MARK    =    'X'        ;set a mark
LOMARK    =    'x'
PASTE    =    'P'-'@'        ;paste region at cursor
CANCEL    =    'C'-'@'        ;cancel cut command
;
;
; TERMINAL-SPECIFIC EQUATES
;
; kaypro cursor controls
;
LEFT    =    08H
RIGHT    =    'L'-'@'
UP    =    'K'-'@'
DOWN    =    0AH
;
LEFT8    =    82h        ;kaypro raw keypad arrow values...
RIGHT8    =    83h
UP8    =    80h
DOWN8    =    81h
;
HOMEC    =    1eh        ;home cursor
;
; Kaypro '83 screen parameters
;
NCOLS    =    80
NROWS    =    24
NROW24    =    24        ;# rows excluding status line
;
SCRSIZ    =    NCOLS*NROWS
;
;
loglin    =    128        ;length of logical screen line
vidram    =    3000h        ;base of video ram
bitprt    =    1ch        ; controller port
;
.remark \===
Kaypro '83 video ram is laid out as:

    24 80-char rows
    each row begins 128 bytes after the previous one
3000:    row 0
3080:    row 1
...
    ===\

;=========================

.ifg DEBUG, [
    .loc    codloc
    ]
;
    [
    .loc    .PROG.
    ]
;
;------------------------------------------------------------
;
; id sector - nul-terminated string -  at 3f80h
;
sdid:    .ascii    "Kaypro '83 driver v 1.1"
    db    0            ;NUL terminator
idlen = . - sdid
    ds    80h-idlen        ;total of 80h bytes

;
START:
;
;
; Start of Screen Module.  Assemble to run at 4000h.
;
;***** MODULE ENTRY HEADER
;
; EXTERNAL ADDRESSES, supplied by loader
;
jjcons:    jmp    consta        ;bios constat
jjconi:    jmp    conin        ;bios conin
jjouta:    jmp    outch        ;A to conout, preserving bc,de,hl
jjputs:    jmp    puts        ;hl-string to conout, NUL/bit-7 term.
                ; preserving bc,de,hl
jjbrdc:    jmp    0000        ;buffered read char from cut-swp
jjbwrc:    jmp    bwrch        ;buffered write char to cut-swp
jjbflu:    jmp    bflush        ;flush (write) buffer
;
; INTERNAL ENTRY POINTS
;
savscr:    jmp    savpag        ;save screen
resscr:    jmp    respag        ;restore saved screen
lastnb:    jmp    lstnbl        ;last non-blank char in rows 1-24
dmpchr:    jmp    retnch        ;return next screen char
dmpcur:    jmp    retncu        ;return buffer cursor
dmpatt:    jmp    retnat        ;return next screen attribute
setmrk:    jmp    stmrks        ;set region marks, move cursor
cutrg:    jmp    docut        ;cut region
pastrg:    jmp    dopast        ;paste region
ininpd:    jmp    ininot        ;initialize notepad
putnpd:    jmp    putnch        ;put char to notepad
;
;========================================
; generic
;
ININOT:
;
; Initiate Notepad - clear screen, print banner.
;
    lxi    h,Zbanner
    jr    jjputs
;
;========================================
; generic
;
PUTNCH:
;
; Put char in A  to notepad (screen)
; Convert CR to CRLF, DEL to rubout.
;
    cpi    CR
    lxi    h,Zcrlf        ;convert CR to CR,LF
    jrz    jjputs
    cpi    DEL
    lxi    h,Zrub
    jrz    jjputs
    jr    jjouta

;========================================
; generic
;
RETNCU:
;
; Return buffer cursor as row/col.
;
; ret: D = binary row, E= binary col
;      L =  ascii row, H = ascii col (for shld ...)
;
    lhld    bcursor
;
; Convert offset to col/row.
; exit: D = binary row, E = binary col
;    H = ascii col,  L = ascii row <-- NOTE ORDER
;

off2cr:    mvi    b,0        ;convert to row,col
    lxi    d,-NCOLS
..1:    dad    d
    jrnc    ..2
    inr    b        ;row count++
    jr    ..1
..2:    lxi    d,NCOLS
    dad    d
    mov    a,l        ;col
    mov    e,a        ;binary col in E
    mov    d,b        ;binary row in D
    adi    SPACE        ; + bias
    mov    h,a        ;H = ascii col
    mov    a,b        ;row
    adi    SPACE        ; +bias
    mov    l,a        ;L = ascii row
    ret
;
;========================================
; generic
;
DOPASTE:
;
; Paste the last-cut region onto active screen at the current cursor.
;
; 1. Get previously-cut region from external routine
; 2. Send chars to screen, avoiding boundary overflows.
;
; 'savpag' not needed if terminal supports 'send cursor address'
;
    call    savpag        ;get current screen,
                ;in order to find cursor
    mvi    b,4        ;read 4 data bytes
..0:    push    b
    call    jjbrdc
    pop    b
    djnz    ..0
;
    mov    b,a        ;4th byte is # rows
    push    b
    call    crs2hl        ;current cursor's row/col to hl
    pop    b
;
; loop over rows
;
..rowlp:push    b
    push    h
    mov    e,l        ;e = col no.
    push    d
    call    stcrshl        ;set cursor at h,l
..collp:call    jjbrdc        ;read char from cut-swp
    cpi    CR
    jrz    ..rend
    mov    c,a        ;save char
    pop    d        ;check for off screen
    mov    a,e
    cpi    NCOLS
    inr    e
    push    d        ;row/col to stack
    cc    sendc        ;to conout, unless off edge
    jr    ..collp
;
..rend:    pop    d        ;clear row/col
    pop    h
    pop    b
    inr    h        ;bump row
    mov    a,h        ;check for off bottom of screen
    cpi    NROWS
    jrnc    ..xit
    djnz    ..rowlp
..xit:    xra    a
    ret
;
;========================================
; generic
;
DOCUT:
;
; Cut rectangular region defined by keypresses.
; 1. Parse keypresses to move cursor and mark corners.
;    Highlight region as cursor is moved.
; 2. Send the marked region, row-wise to external routine.
;    Append CR after each row.
;
; Data structure is:
;    size (word)
;    # columns (byte)
;    # rows (byte)
;    row 1
;    CR
;    row 2
;    CR
;    ....
;
.ifg DEBUG, [
;if debugging, put output in cutbuf
    lxi    h,cutbuf    ;set ptr
    shld    dbgptr
    ]
;
    xra    a
    sta    mrkcnt        ;init for next time
;
;
; set ctcols = # cols, ctrows = # rows
; (assumes mark2 is SE of mark1)
;
corners:lded    mark1
    lhld    mark2
    mov    a,h    ;# rows = 1 + mark2row -mark1row
    inr    a
    sub    d
    mov    h,a
    mov    a,l    ;# cols = 1 + mark2col -mark1col
    inr    a
    sub    e
    mov    l,a
    shld    ctcols
;
; cut rectangle [mark1...mark2]  & copy to buffer
; append CR at end of each row
;
    xchg
    push    h        ;mark1
    call    wrpara        ;write parameters
    pop    h        ;mark1
    call    rc2off        ;convert to scr addr
    lda    ctrows        ;get # rows
    mov    b,a
;
; write the cut region to external buffer
;
..rowlp:push    b        ;(+1
    push    h        ;(+2
    lxi    d,buf        ;fetch from screen buffer
    dad    d
;
; write 1 row of cut region to external buffer
;
    lda    ctcols
    mov    b,a        ;b = # cols
;
; write 1 row of cut region to external buffer
;
    lda    ctcols
    mov    b,a        ;b = # cols
;
; buffered write B chars at hl, ascii only
;
..bwrt:    push    b
    push    h
    mov    a,m
    cpi    DEL
    jrnc    ..mksp
    cpi    SPACE        ;convert graphics
    jrnc    ..1
..mksp:    mvi    a,SPACE        ; to space
..1:    mov    c,a
    call    jjbwrch
    pop    h
    pop    b
    inx    h
    djnz    ..bwrt
;
    mvi    c,CR        ;append CR to each row
    call    jjbwrch
;
    pop    h        ;(+1
    pop    b        ;(+0
    lxi    d,NCOLS        ;bump to next row
    dad    d
    djnz    ..rowlp        ; and loop
    jmp    jjbflu        ;flush the write buffer
;
;
; write parameters: size, # cols, # rows to swp file
; de = ctcols
;
wrpara:    mov    b,d        ;# rows
    mvi    d,0
    inr    e        ;+1 for CR
    lxi    h,0        ;accum.
..0:    dad    d
    djnz    ..0
    call    bwhl        ;write word
    lhld    ctcols        ;now #cols, # rows
;
bwhl:    push    h
    mov    c,l
    call    jjbwrch
    pop    h
    mov    c,h
    jmp    jjbwrch
;
;========================================
; generic
;
LSTNBL:
;
; Find last non-blank line (1-24 only) in current scr buffer.
; Graphics and 8-bit characters are considered blanks.
; If B=0ff, save screen first.
;
; ret:    H=row, L=col of last non-blank char in rows 1-24
;
    inr    b
    cz    savpag
    lxi    b,NROW24*100h + NCOLS    ;b=# rows, c=# cols
    lxi    d,buf
    lxi    h,0
..lp:    ldax    d
    cpi    SPACE+1        ;don't count cntl chars or SPACE
    jrc    ..1
    cpi    DEL        ; or DEL or graphics 8-bit
    jrnc    ..1
    shld    savrc
..1:    inx    d
    inr    l
    dcr    c
    jrnz    ..lp        ;loop over cols
    inr    h
    mov    l,c        ;0
    mvi    c,NCOLS
    djnz    ..lp        ;loop over rows
savrc = .+1
    lxi    h,0000        ;hl = last non-blank
    ret

;----------------------------------------
;
xring:    mvi    c,BELL
;
; send C to screen, exit Z, no CY
;
sendc:    mov    a,c

; send A to screen, exit Z, no CY
; (this will scroll, however!)
;
send:    call    jjouta
    xra    a        ;Z, no CY
    ret
;========================================
;
; end of generic code
;
;========================================
; specific
;
STMRKS:
;
; Move cursor and set marks. Return CY clear until exit.
;
; 1. move cursor, until:
; 2. 'X' = set 1st mark
;    turn on hiliting, set mark, keep cursor at mark
; 3. move cursor right/down only
; 4. 'X' = set 2nd mark
;    turn off hiliting, set 2nd mark
;    exit CY (done)
; 5. cntl-C = CANCEL.
;    turn off hilighting, set CY, exit
;
;
    cpi    CANCEL
    jrz    abort
    cpi    LEFT
    jz    goleft
    cpi    LEFT8
    jz    golef8
    cpi    UP
    jz    goup
    cpi    UP8
    jz    goup8
    cpi    RIGHT
    jz    gort
    cpi    RIGHT8
    jz    gort8
    cpi    DOWN
    jz    godn
    cpi    DOWN8
    jz    godn8
    cpi    HOME
    jrz    gohome
    cpi    LOHOME
    jrz    gohome
    cpi    CR
    jrz    ..mrk
    cpi    MARK
    jrz    ..mrk
    cpi    LOMARK
    jrz    ..mrk
    xra    a        ;no action
    ret
..mrk:    lxi    h,mrkcnt    ;if no mark yet set
    mov    a,m
    ora    a
    mvi    m,1
    jrz    mk1        ;..set mark1
    call    mk2        ;else set mark2
mrkxit:    xra    a
    sta    mrkcnt        ;init for next time
    stc            ;CY = all done
    ret
;
abort:    call    normal        ;restore normal video
    mvi    a,CANCEL
    jr    mrkxit
;
;-------------------------------------------
;
; set 1st mark, turn on rev. video, don't move cursor
;
mk1:    call    crs2hl
    shld    mark1
    shld    mark2
    shld    curcol        ;L->curcol,H->currow
;;
;;kaypro '83 doesn't have attributes, omit:
;;    push    h
;;    call    reverse        ;reverse video on (dummy routine)
;
;;    pop    h        ;mark1
;
; Blink the marked char. Cursor may itself be off, or solid.
;
    mvi    a,1        ;blink 1 char
    sta    colct
    sta    rowct
    jmp    showro
;
; set 2nd mark, restore normal video, set CY
;
mk2:    call    normal        ;dummy - restore normal video
    stc            ;CY = all done
    ret
;
;--------------------------------------------
;
; bump row/col  var that tracks actual cursor
; if mark not yet, send cntl char
; ret NZ if mark is set
;
inrsnd:    inr    m        ;next row/col
    call    anymrk
    cz    sendc
;
; nz if a mark has been set
;
anymrk:    lda    mrkcnt
    ora    a
    ret
;
; for H19, etc. that use ESC sequences,
; change these routines to send ESC, then the byte.
;
gohome:    mvi    c,HOMEC        ;convert to video driver's cntl char
    call    anymrk        ;if mark set,
    jnz    xring        ;..error
    mov    h,a        ;set row=col=0
    mov    l,a
    shld    bincol
jjsndc:    jmp    sendc
;
; cursor left and cursor up:
;    send if not at top or left margin
;
golef8:    mvi    a,LEFT        ;convert to 7-bit char
;
goleft:    lxi    h,bincol    ;ck for col ==0
;
zck:    mov    c,a        ;save char in c
    call    anymrk
    rnz
    cmp    m        ;ck col/row == 0
    jz    xring        ;..error
    dcr    m        ;dcr col/row
    jr    jjsndc
;
goup8:    mvi    a,UP        ;7-bit code
goup:    lxi    h,binrow    ;ck for top row and send
    jr    zck
;
; cursor right and cursor down:
;    if mark is not set, move cursor
;    if mark is set, expand region and highlight
;    keep track of cursor location in both cases
;    don't move if it would scroll
;
; move cursor right
;
gort8:    mvi    a,RIGHT        ;convert to 7-bit code
;
gort:    mov    c,a        ;save in c
    lxi    h,bincol
    mvi    a,NCOLS-2
    cmp    m
    jc    xring
    call    inrsnd        ;bump col & send if mrk not set
    rz            ;rtn if mark not yet set
;
;  hilite marked column
;
gort1:    lxi    h,mark2
    inr    m        ;bump 2nd mark-row
    lxi    h,curcol    ;bump col
    inr    m
    mov    l,m
    lda    mark1+1        ;top row
    mov    h,a        ;h=row, l=col for col to hilite
rowct = .+1
    mvi    b,00
;
; loop over each row in cut region
;
..rlp:    push    b
    push    h        ;save binary row/col
    mvi    a,1        ;display 1 char in each row
    call    showhi
    pop    h
    pop    b
    inr    h        ;next row
    djnz    ..rlp
    lxi    h,colct        ;prepare to bump col cnt & exit
    jr    inrmbs
;
; move cursor down
;
godn8:    mvi    a,DOWN        ;7bit code
godn:    mov    c,a        ;save char
    lxi    h,binrow    ;ck if already on bottom row
    mvi    a,NROWS-2
    cmp    m
    jc    xring
    call    inrsnd         ;bump row & send
    rz            ;rtn if mark not yet set
;
;  hilite marked row
;
godn1:    lxi    h,mark2+1    ;row
    inr    m        ;bump 2nd mark-col
    lxi    h,currow    ;bump row
    inr    m
    mov    h,m
    lda    mark1        ;left col
    mov    l,a        ;h=row, l=col for row to hilite
    call    showro        ;display 1 cut row
    lxi    h,rowct        ;bump row cnt
inrmbs:    inr    m        ; and exit
    ret
;
;
.remark \==
For Kaypro '83, write directly to screen,
in order to set blink attribute.

if down:    set cur at next row, left col
        send partial row
        rowcnt++
        BS (back up 1)

if right:    set cur at toprow, next col
        send partial column
        colcnt++
==\
;
; enter: H = binary row, L= binary col
;
showro:
colct = .+1
    mvi    a,00
;
; Fetch A chars at H=binary row, L=binary col from buffer.
; Put chars to screen, setting BLINK attribute.
;
showhi:    push    psw
    call    stvptr        ;set video ram ptr
    call    rc2off
    lxi    d,buf        ;fetch from screen buffer
    dad    d
    pop    psw        ;#chars
    mov    b,a
..lp:    mov    a,m        ;fetch char from buffer
    cpi    SPACE
    jrnz    ..set7
    mvi    a,7fh        ;make displayable 'DEL' char
..set7:    set    7,a        ;set blink bit
    mov    c,a
    push    h
    call    putv        ;put to screen
    pop    h
    inx    h
    djnz    ..lp
    ora    a        ;clear CY
    ret
;
;========================================
; specific
;
RETNCH:
;
; Return next screen char from buffer.
;
; enter:
;    d = row, e = col
;    b = FF ==> read screen
;    c = FF ==> set bufptr
; exit:
;    A = char, CY set if good
;    DE -> row,col of next char, HL -> buf of next char
;    CY clear if out of range
;
; This routine can be called to get successive chars from
; buffer as long as caller preserves hl,de and sets b=c=0.
;
    xra    a
    call    stdump
    rnc
    mov    a,m        ;get char
    inx    h        ;bump bufptr
    ret
;
;========================================
; specific
;
RETNAT:
;
; Return next screen attribute from buffer.
; THIS IS A NUL FUNCTION for Kaypro '83.
;
; enter:
;    d = row, e = col
;    b = FF ==> read screen
;    c = FF ==> set bufptr
; exit:
;    A = attr, CY set if good
;    DE -> row,col of next char, HL -> buf of next char
;    CY clear if out of range
;
    xra    a        ;clear CY
    ret
;
;--------------------
;
; ret:     NC if out of range
;    else hl-> buffer char
;
stdump:    inr    b
    jrnz    ..0
    push    b        ;b == 0ff -> read screen
    push    d
    push    h        ;$$$ missing in k84 !!!
    call    savpag
    pop    h
    pop    d
    pop    b
..0:    inr    c
    jrnz    ..4
;
; enter: D = row, E = col
; set: hl -> buffer address, cy set,    preserve de
; ret:    CY clear if  error (off screen)
;
;conv:
    mov    a,d        ;c == 0ff -> set bufptr
    cpi    NROWS
    jrnc    ..bad
    mov    a,e
    cpi    NCOLS
    jrc    ..ok
..bad:    xra    a        ;out of range , ret NC
    ret
..ok:    lxi    h,buf
    mov    a,d
    lxi    b,NCOLS        ;row*(cols per row)
    inr    a
..lp:    dcr    a
    jrz    ..2
    dad    b
    jr    ..lp
..2:    mvi    d,0        ;+ col #
    dad    d
;
..4:    inx    d        ;bump col
    mov    a,e
    cpi    NCOLS
    rc
    mvi    e,0        ;end of row, set col = 0
    inr    d        ;and bump row
    mov    a,d
    cpi    NROWS
    ret            ;NC if out of range
;
; Set video-ram pointer.
; enter: H=binary row, L=binary col
; set vptr = row*128 + col,     preserves all
;
stvptr:    push    b
    push    d
    push    h
    mov    b,h
    mov    c,l
    lxi    h,0
    lxi    d,128
    inr    b
    jr    ..bot
..lp:    dad    d        ;row*128
..bot:    djnz    ..lp
    dad    b        ; + col (b=0)
    lxi    b,vidram
    dad    b
    shld    vptr
    pop    h
    pop    d
    pop    b
    ret
;
; Initialize for screen save/restore
; enter: A=0  to save(read) screen
;     A=NZ to restore (write) screen
;
iscr:    sta    putflg        ;0=save, 0ff=restore
itop:    lxi    h,buf        ;init buf ptr
    shld    cptr
    lxi    h,vidram    ;int video ram ptr
    shld    vptr
    ret

vptr:    dw    0        ;ptr to video ram char
;
;========================================
; specific
;
SAVPAG:
;
; Save screen to buffer.
;
    xra    a        ;initialize for reading screen
    call    iscr
    call    doscr        ;save screen first
    call    crs2off        ;THEN find screen cursor
    shld    bcursor        ;and save it
    call    off2cr
    sded    bincol        ;save binary col/row
    ret
;
;--------------------
;
doscr:    lxi    b,SCRSIZ
..0:    push    b
    call    vch        ;r/w char
    pop    b
    inx    d        ;bump ptr        USED??
    dcx    b
    mov    a,b
    ora    c
    jrnz    ..0
    ret
;
;========================================
; specific
;
RESPAG:
;
; Restore saved screen from buffer.
;
; Note: this sequence is necessary to be sure that the
; char in the hardware cursor register isn't written back
; to video ram after the new character has been put there.

    lhld    bcursor        ;set the new cursor position FIRST
    push    h
    call    stcrs
    mvi    a,0ffh        ;initialize for writing screen
    call    iscr
    call    doscr        ;put buffer to screen
    pop    h        ;get cursor offset
    push    h
    lxi    d,buf        ;get char at the cursor
    dad    d
    mov    a,m
    call    jjouta        ;send it via conout
    pop    h        ;reset the cursor
;
; Set cursor on screen by direct cursor addressing.
; enter: HL = cursor offset relative to 0000
;
stcrs:    call    off2cr        ;convert from offset to ascii col/row
stcoro:    shld    colrow        ;put ascii col/row into string
    lxi    h,Zcurs        ;send set-cursor string
    jmp    jjputs
;
; Set cursor on screen.
; enter: H=binary row, L = binary col
;
stcrshl:call    rc2off
    jr    stcrs
;
;--------------------
;
; CONVERSION ROUTINES
;
; Get current cursor position to H=binary row, L=binary col
;
crs2hl:    call    crs2off        ;get cursor by re-read of screen
    call    off2cr        ;returns binary in de
    xchg
    ret
;
; convert H=binary row, L=binary col to hl= offset
; (hl =  row*NCOLS + col)
; uses bc,de,hl
;
; note fix from 'convhl' in k84 version !!
;
rc2off:    mov    b,h        ;b=row
    mov    c,l        ;c=col
    lxi    h,0
    inr    b
    lxi    d,NCOLS
    jr    ..bot
..0:    dad    d        ;rows*NCOLS
..bot:    djnz    ..0
    dad    b        ;+ col
    ret
;
;
; Get current screen cursor.
; ret: HL= binary offset from 0000.
;
; (Screen must already be saved into buffer).
; Send a test char via conout.  Read screen and find mismatch.
;
T1CHAR    =    07Eh
T2CHAR    =    07Dh

crs2off:
    lxi    h,0        ;init duplicate count FIRST
    shld    dupcnt
;
; Send a test char to the screen.  If the testchar happens to be the
; char at the cursor, bump dupcnt and repeat the loop.  Sending
; the char again puts it at cursor+1.  Repeat until there's a mismatch.
; By testing the final screen char, we ensure a mismatch will be found.
;
..nxtc:    lda    buf+SCRSIZ-1    ;set test char so it is != last char
    ani    7Fh        ;kill cursor bit
    cpi    T1CHAR        ; on screen
    mvi    a,T1CHAR
    jrnz    ..1
    mvi    a,T2CHAR
..1:    sta    tstchr        ;send test char to screen at cursor
    call    jjouta
;
    call    itop
    lxi    b,SCRSIZ
..lp:    push    b
    lhld    vptr
    shld    orighl
    call    getv        ;get screen char to C
    lhld    cptr        ;compare to buffer char
    mov    a,m
    sta    origc
    shld    origbf
    sub    c        ;hi bit has been killed
    inx    h
    shld    cptr
    pop    b
    jrz    ..same
    adi    (7Fh-SPACE)    ;check for space converted to blink-DEL
    jrnz    ..fnd
..same:    dcx    b
    mov    a,b
    ora    c
    jrnz    ..lp
;
; have a duplicate of testchar at current cursor
    lhld    dupcnt
    inx    h
    shld    dupcnt
    jr    ..nxtc
;
; cursor found by mismatch of buffer char, testchar
;
..fnd:    lxi    h,SCRSIZ    ;offset = scrsize-countleft
    ora    a
    dsbc    b
    lded    dupcnt        ;adjust for any duplicates
    ora    a
    dsbc    d        ;count - dupcnt
..ok:    push    h        ;save offset to cursor loc.

origc = .+1
    mvi    a,00        ;restore original char
    res    7,a
    cpi    '_'        ;in case we picked up the cursor
    jrnz    ..2        ; at a space, put it back to space
    mvi    a,SPACE        ;(not foolproof)
..2:    mov    c,a
origbf = .+1
    lxi    h,0000        ;and correct buffer value too
    mov    m,a
orighl = .+1
    lxi    h,0000        ;to screen
    call    putvhl
    pop    h
    push    h
    call    stcrs        ;put cursor back on screen
    pop    h
    ret            ;hl =cursor offset from 0000
;
tstchr:    db    0        ;test char to find cursor
dupcnt:    dw    0        ;# of duplicates of test char at cursor
;
;--------------------
;
; putflg = 0:  read 1 char from screen, put into buffer
; putflg = NZ: get 1 char from buffer, write to screen
; ret:    c = char, if putflg != 0        ; uses A, HL
;
vch:    lda    putflg
    ora    a
    jrnz    ..put
;
..get:    call    getv        ;get from video ram
    lhld    cptr        ;put into buffer
    mov    m,c
    inx    h
    shld    cptr
    ret
;
..put:    lhld    cptr        ;get char from buffer
    mov    c,m        ; to C
    res    7,c        ;kill any cursor bit
    inx    h
    shld    cptr
;
putv:    lhld    vptr
putvhl:    in    bitprt        ;get port byte
    ori    80h        ;set for bank 1
    di            ;prevent interruption
    out    bitprt        ;switch to bank 1
    mov    m,c        ;put char in C into video ram
putv1:    ani    7fh        ;switch bank 0 back in
    out    bitprt
    ei
;
; Set pointer to next video ram char, adjusting for gap
; at end of each line.
;
..bmpv:    inx    h
    mov    a,l
    cpi    80
    jrz    ..adj
    cpi    128+80
    jrnz    ..sh
..adj:    adi    128-80
    mov    l,a
    jrnc    ..sh
    inr    h
..sh:    shld    vptr
    ret
;
getv:    lhld    vptr
    in    bitprt        ;get port byte
    ori    80h        ;set for bank 1
    di            ;prevent interruption
    out    bitprt        ;switch to bank 1
    mov    c,m        ;get char from video ram
    res    7,c        ;kill blinking
    jr    putv1
;
;******************************************
;
; DATA AREA
;
putflg:    db    0        ;NZ to restore(put) screen from buf
cptr:    dw    0        ;char ptr
;
; cut-region data
;
ctcols:db    0    ;# cols in cut region (excl. CR), A PAIR
ctrows:db    0    ;# rows

;
; mark-region data
;
mrkcnt:    db    0
curcol:    db    0        ;a pair
currow:    db    0
mark1:    dw    0        ;binary row,col of upperleft mark
mark2:    dw    0        ;lower right mark
bincol:    db    0        ;a pair
binrow:    db    0
;
Zrub:    db    BS,SPACE,BS+80H    ;rub-out previous char
;
;****************************************
;
;  TERMINAL-SPECIFIC data
;
; dummy routines - no attrributes for Kaypro '83
;
normal:
reverse:
    RET

;
; Kaypro '83 video strings
;
Zcurs:    .ascii    [1bh]'='    ;set cursor to
colrow:    db    SPACE,SPACE    ; row,col - modified in-line
    db    NUL        ;must have following NUL
;
.ifg DEBUG, [
Zclr:    db    1Ah,NUL        ;kaypro
    ]
;
;================================
;
; JOTPAD BANNER - just 2 lines' worth
;
; 1. Clear screen.
; 2. Remind user of usage, to extent space is available.
;    The editing keys are those supported by the terminal itself.
;
Zbanner:
    db    1ah        ;clear screen KAYPRO-SPECIFIC
;
.ascii    'JOT: <SUSPEND> = exit,  ^Paste'
    db    CR,LF
.ascii    '^X = del. rest of line, ESC E = ins. line, '    ;43
.ascii    'ESC R = del. line'                ;17
;
; NO ROOM FOR THIS !
; if turborom-->
;.ascii    'Cntl-A = insert char.  Cntl-B = delete char.         '
;
Zcrlf:    db    CR,LF+80h

;
.slist
.list
codlen = .-start        ;length of code
.rlist
;
;++++++++++++++++++++++++++++++
.remark \==
Debugging stragegy:
    Assemble screendriver at 100h.
    Load with Z80 debugger.
    Clear ram buffers.
    Set breakpoints as needed.
    Call these test routines and inspect buffers.
==\

.ifg DEBUG, [
dbg0 = .
;
; these emulate the external BGii routines
; using ram buffers for debugging
;
bwrch:    push    h
    lhld    dbgptr        ;put to debug cut buffer
    mov    m,c
    inx    h
    shld    dbgptr
    pop    h
    ret
;
bflush:    ret
;

;bios display-a-string
;    nul/8-bit terminated string at hl
;    preserves bc,de,hl
;
puts:    push    h    ;save hl, outch save bc,de
..0:    mov    a,m
    rlc
    srlr    a    ;shift right logical (register) A
    inx    h
    jrz    ..1
    push    psw
    call    outch
    pop    psw
    jrnc    ..0
..1:    pop    h
    ret
;
; char in A to conout, preserve bc,de,hl
;

outch:    push    b
    push    d
    push    h
    mov    c,a
    call    conout
    pop    h
    pop    d
    pop    b
    ret
;
; Various routines for debugging in ram.
;
TSTACK = 05000h        ;test stack, above bank-switching

tdump:    lxi    b,0ffffh    ;fetch scr, set ptr
    lxi    d,0        ;from row 0,col 0
    call    dmpchr
;
tdump2:    lxi    b,0
    call    dmpchr
;
tdump3:    lxi    d,100h + 0
    lxi    b,00ffh
    call    dmpchr
;
tdump4:    lxi    d,3000h        ;out of range test
    lxi    b,00ffh
    call    dmpchr
    rst    7
;
;
clear:    lxi    h,Zclr        ;clear screen
    call    jjputs
    rst    7
;
flood:    lxi    h,Zflood    ;write to screen
    call    jjputs
    rst    7
Zflood:    .ascii    '=======TESTING======='
    db    0
;
tsave:    lxi    sp,TSTACK    ;save screen
    call    savscr
    rst    7

trest:    lxi    sp,TSTACK    ;restore screen
    call    resscr
    rst    7

tmark:    lxi    sp,TSTACK    ;set a mark
    call    savscr
    call    sttop        ;so debugger doesn't scroll screen
..0:    call    conin
    call    setmrk
    jnc    ..0
;    rst    7
    nop
;
tcut:    lxi    h,cutbuf        ;clear buffer
    mvi    m,0
    lxi    d,cutbuf+1
    lxi    b,2*80h
    ldir
    call    cutrg            ;cut region
    call    setbot            ;put cursor out of way
    rst    7

; place cursor nerar bottom or top
;
setbot:    lxi    h,100h*(20h+18) +20h
    jr    sttop1
sttop:    lxi    h,2020h
sttop1:    shld    colrow
    lxi    h,Zcurs        ;send set-cursor string
    jmp    jjputs
;
dbgptr:    dw    0
.slist
.list
dbglen = . - dbg0
.rlist
    ]
;++++++++++++++++++++++++++++++
;
.list

; SCREEN BUFFER STRUCTURE
;
; The rest of the 4K block is available
; for the screen image and other data.

xbreq    =    2 + NROWS*NCOLS
;

.ifg    DEBUG, [
;
; put buffer on even byte ( for attributes)
bstart    =    start + 800h    ;make some room
    ]
;
    [
; put buffer at end of 4K area, to just fit
bstart    =    (start + 400h) + (3*400h-xbreq)

short =    start+codlen-bstart
xfree = - short

.ifg (short), [
    .prntx    '[07]Code overflows buffer!'
    ]

    ]

;
; addresses:
;
bcursor =    bstart        ;cursor location in saved screen
buf    =    bcursor+2    ;start of screen buffer
;
;buffer uses (24 lines x 80 chars)
;
bufend    =    buf + NROWS*NCOLS

;
.ifg DEBUG, [
;
; put cutbuffer in ram for debugging
;
datcut    =    bstart+10h+3*400h
cutbuf    =    datcut
    ]

.xlist
    .end    jjcons
xi    h,100h*(20h+18) +20h
    jr    sttop1
sttop:    lxi    h,2020h
sttop1:    shld    c