home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Columbia Kermit
/
kermit.zip
/
ccdos
/
ccyibm.asm
< prev
next >
Wrap
Assembly Source File
|
2020-01-01
|
121KB
|
2,631 lines
NAME ccyibm
; File CCYIBM.ASM
; Edit History:
; Mar.21,1991:
; * Add MASM Option /DCGA in serval places. The goal is to make ZUnet-PBX
; can be run in different CCDOS versions(Such as: CCDOS213,LIANXIAN,
; STCDOS,CGA17,etc.) on different video adapers( such as CGA,EGA,VGA
; and MDA).
; In this program Macro Conditions "IFDEF CGA ... ENDIF" and "IFNDEF CGA
; ... ENDIF" are used.
; Option CGA is used only when you want to build a program used in PC/XT
; (CGA or MDA adapter).Maybe it can be used in VGA adapter. [zqf]
; 1990:
; * Program is modified in many places to suit for different CCDOS versions.
; You can check them by indexing 'zqf' or 'CCDOS'. [zqf]
;CHINESE
ifdef MSDOS
include msyibm.dat
else
include ccyibm.dat
endif
code segment public 'code'
extrn beep:near, prtchr:near, outchr:near, sbrk:near, pcwait:near
extrn isfile:near, strlen:near, strcpy:near ; in mssfil
extrn anstty:near,ansini:near,ansrei:near ; in mszibm
extrn anstat:near,anskbi:near,ansdsl:near ; in mszibm
extrn ans52t:near, vsinit:near ; in mszibm
extrn msuinit:near, keybd:near ; in msuibm
extrn tekini:near,tekcls:near,tekemu:near,tekend:near ;in msgibm
extrn tekrint:near
ifdef DEBG
; extrn debgp:near
endif
assume cs:code, ds:datas, es:datas
; do initialization local to this module
; Dynamically allocates 4000 bytes for screen save/restore buffer plus
; 320 to 38400 bytes for screen scroll back buffers. Tries to leave space
; for Command.com before enlarging buffers. [jrd]
lclyini proc near
call msuinit ; initialize keyboard module msuxxx
mov ax,swidth*(slen+1)*2 ; (80 char + 80 attr) * 25 lines
call sbrk ; memory allocation routine (mssker)
;if we get here them we have the lines
mov scrsav,ax ; memory segment for save screens
; screen roll back buffers
mov bx,0ffffh ; ask for all of memory, to get size
mov ah,alloc ; allocate all of memory (must fail)
int dos ; bx has # free paragraphs
mov ax,bx ; ax has copy of number free paragraphs
sub ax,24000D/16 ; space for Command.com copy #2
jbe lclyin1 ; be = not enough for it. [ebb]
cmp ax,(swidth*slen+15)/16 ; minimum roll back space left over?
jbe lclyin1 ; be = not even that much
cmp ax,(swidth*slen*npages+7)/8 ; paragraphs wanted for roll back
jbe lclyin2 ; be = enough but not more than needed
mov ax,(swidth*slen*npages+7)/8 ; limit to our actual needs
jmp short lclyin2 ; ask for all we really want
lclyin1:mov ax,(4*swidth+15)/16 ; use minimum needed paragraphs
lclyin2:mov inipara,ax ; save for later resizing of buffers
mov cl,4 ; convert paragraphs to bytes
shl ax,cl ; for sbrk
call sbrk ; ask for that many bytes
;if we get here them we have the space
mov bwnd.orig,ax ; memory segment, bottom window area
mov twnd.orig,ax ; top. same place for both buffers!
call scrseg ; test running in an Environment
call scrmod ; read video state, get crt_mode
mov ax,low_rgt ; lower right corner of screen
mov al,crt_mode
mov crt_norm,al ; save as normal mode
mov savflg,ax
mov ah,conout ; output a space to set background
mov dl,' ' ; and foreground screen colors
int dos
mov ah,3 ; get current cursor position into dx
mov bh,0
int screen
dec dl ; backup to the space
mov ah,2 ; set cursor
int screen
mov ah,8 ; read current attributes
xor bh,bh ; page 0
int screen
mov scbattr,ah ; save video attributes
mov oldattr,ah ; and here too
mov ax,inipara ; # paragraphs allocated by DOS
mov cl,3 ; 2**3 = 8
shl ax,cl ; paragraphs to words (char + attrib)
xor dx,dx ; clear extended size
mov ch,0
mov cl,byte ptr low_rgt
inc cl ; number of chars per line in buffer
div cx ; ax = number of lines in buffer
mov bwnd.lmax,ax ; max lines per buffer (quotient)
mov twnd.lmax,ax ; max lines per buffer
add cx,cx ; count char and attribute per item
xor dx,dx ; clear extended numerator
mul cx ; ax = effective # bytes per buffer
dec ax ; adjust for counting from zero
mov bwnd.bend,ax ; offset of last byte in buffer
mov twnd.bend,ax ; offset of last byte in buffer
mov bwnd.pp,0 ; offset of first byte in buffer
mov twnd.pp,0 ; offset of first byte in buffer
mov bwnd.lcnt,0 ; number of lines occupied in buffer
mov twnd.lcnt,0 ; number of lines occupied in buffer
call vsinit ; init terminal emulator module MSZ
mov ega_mode,0 ; assume no EGA
mov ax,1200H ; EGA: Bios alternate select
mov bl,10H ; Ask for EGA info
mov bh,0ffH ; Bad info, for testing
mov cl,0fH ; Reserved switch settings
int screen ; EGA, are you there?
cmp cl,0cH ; Test reserved switch settings
jge lclyin3 ; ge = no EGA in use
push es
mov ax,40h ; check Bios 40:87h for ega being
mov es,ax ; the active display adapter
test byte ptr es:[87h],8 ; is ega active?
pop es
jnz lclyin3 ; nz = no
mov ega_mode,1 ; yes, set flag to say so
mov crt_norm,3 ; assume color monitor is attached
cmp bh,0 ; is color mode in effect?
je lclyin3 ; e = yes
mov crt_norm,7 ; else use mode 7 for mono
lclyin3:ret
lclyini endp
scrini proc near ; init screen stuff
call scrseg ; update screen segment tv_seg(s/o)
call scrmod ; get screen mode, low_rgt
mov ah,3 ; get cursor position and type
xor bh,bh ; page 0
int screen
mov lincur,cx ; save cursor type (scan line #'s)
mov ax,low_rgt ; present screen text size
cmp ax,savflg ; vs size of saved screen
jne scrin1 ; ne = different, initialize
jmp scrin3 ; same, skip initialization
; Re-initialize screen buffers
scrin1: mov ax,inipara ; paragraphs allotted to roll back
mov cl,3 ; 2**3 = 8
shl ax,cl ; paragraphs to words (char + attrib)
xor dx,dx ; clear extended size
mov cl,byte ptr low_rgt ; number of chars per line in buffer
inc cl ; chars per line
xor ch,ch ; clear high byte
div cx ; ax = number of lines in buffer
mov bwnd.lmax,ax ; max lines per buffer (quotient)
mov twnd.lmax,ax ; max lines per buffer
add cx,cx ; count char and attribute per item
xor dx,dx ; clear extended numerator
mul cx ; ax = effective # bytes per buffer
dec ax ; adjust for counting from zero
mov bwnd.bend,ax ; offset of last byte in buffer
mov twnd.bend,ax ; offset of last byte in buffer
mov bwnd.pp,0 ; offset of first byte in buffer
mov twnd.pp,0 ; offset of first byte in buffer
mov bwnd.lcnt,0 ; number of lines occupied in buffer
mov twnd.lcnt,0 ; number of lines occupied in buffer
mov ega_mode,0 ; assume no EGA
mov ax,1200H ; EGA: Bios alternate select
mov bl,10H ; Ask for EGA info
mov bh,0ffH ; Bad info, for testing
mov cl,0fH ; Reserved switch settings
int screen ; EGA, are you there?
cmp cl,0cH ; Test reserved switch settings
jge scrin2 ; ge = no EGA in use
push es
mov ax,40h ; check Bios 40:87h for ega being
mov es,ax ; the active display adapter
test byte ptr es:[87h],8 ; is ega active?
pop es
jnz scrin2 ; nz = no
mov ega_mode,1 ; yes, set flag to say so
mov crt_norm,3 ; assume color monitor is attached
cmp bh,0 ; is color mode in effect?
je scrin2 ; e = yes
mov crt_norm,7 ; else use mode 7 for mono
scrin2: mov ah,oldattr ; get init time attributes
mov curattr,ah ; and set nice screen attribute
mov scbattr,ah
mov cursor,0 ; cursor to upper left corner
cmp flags.vtflg,0 ; terminal type of None?
ja scrin3 ; a = no, emulating
mov dh,byte ptr low_rgt+1
inc dh ; bottom
mov dl,0 ; left corner
jmp short scrin5
; Common finish code
scrin3: mov dx,cursor ; use old cursor, if any
cmp flags.vtflg,0 ; emulating?
je scrin4 ; e = no
cmp dh,byte ptr low_rgt+1 ; past logical end of screen?
jbe scrin4 ; be = no, keep going
mov dh,byte ptr low_rgt+1 ; yes, just use lower right corner
scrin4: cmp dl,byte ptr low_rgt ; maybe past right margin
jbe scrin5 ; be = no, use the way it is
mov dl,byte ptr low_rgt
scrin5: mov cursor,dx ; init cursor
mov ah,2 ; set cursor position
xor bh,bh ; page zero
; ---------don't set cursor in CCDOS. Dec.12,1990 [zqf]
IFDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
cmp isccdos,1 ; is in CCDOS ?
je scrin6 ; e = yes, skip
ENDIF
int screen ; set cursor in case it moved
scrin6:
; -----------
test flags1,inited ; have we run yet?
jz scrin7 ; z = no, so no saved screen yet
call restscr ; restore screen[zqf]Dec.13,1990
scrin7: or flags1,inited ; remember we've run already
cmp flags.modflg,1 ; is mode line on and locally owned?
ja scrin10 ; a = host owned, leave intact
cmp flags.vtflg,0 ; emulating a terminal?
jne scrin8 ; ne = yes, can have mode line
or yflags,modoff ; for no emulation say toggled off
cmp trmtyp,0 ; previous terminal type = none?
jne scrin9 ; ne = no. need to clear mode line
jmp scrin10 ; yes, let 25th line be intact
scrin8: cmp flags.modflg,0 ; is mode line disabled?
je scrin9 ; e = yes, clear it
test yflags,modoff ; is mode line toggled off?
jnz scrin9 ; nz = yes, clear the line
call modlin ; turn on mode line
jmp short scrin10
scrin9: call clrmod ; ensure its off
scrin10:cmp flags.vtflg,0 ; current terminal type = None?
je scrin12 ; e = yes, nothing to init
mov al,yflags ; tell emulator we are back
cmp vtclear,0 ; screen need clearing?
jne scrin10a ; yes, do emulator reinit now
cmp vtinited,inited ; inited emulator yet?
je scrin11 ; e = yes
cmp tekflg,0 ; Tek mode still active?
jne scrin12 ; ne = yes, no re-init here
scrin10a:call vtinit ; init it now
mov vtclear,0 ; say screen is clear
jmp short scrin12
scrin11:call ansrei ; reinit the emulator
call ansflg ; and get its flags
scrin12:mov al,flags.vtflg ; current terminal type
mov trmtyp,al ; place to remember it til next time
cmp flags.vtflg,tttek ; Tek mode?
je scrin13 ; e = yes
cmp tekflg,0 ; Tek mode active within DEC stuff?
je scrin14 ; e = no
scrin13:call tekini ; reinit to get graphics screen
scrin14:ret
scrini endp
; Routine to initialize VT102/52/Heath-19 terminal emulator.
vtinit proc near
mov holdscr,0 ; clear holdscreen
cmp flags.vtflg,0 ; doing emulation?
je vtinix ; e = no
cmp tekflg,0 ; Tek mode active?
jne vtini2 ; ne = yes, do it's reinit
or vtinited,inited
call ansflg ; update ansi flags
mov bx,argadr ; Get address of argument block
mov dl,[bx].flgs
and dl,lclecho
and yflags,not lclecho
or yflags,dl
mov al,yflags ; Pass the flags
mov dl,[bx].baudb ; Baud rate code in dl
mov dh,[bx].parity ; Parity code in bits
mov cl,4 ; 0-3 of dh
shl dh,cl
or dh,07H ; Just say 7 data bits
test flags.remflg,d8bit ; eight bit display?
jz vtini1 ; z = no
inc dh ; set low four bits to value 8
vtini1: call ansini ; call startup routine in mszibm
vtinix: clc
ret
vtini2: call tekrint ; reinitialize Tek emulator
clc
ret
vtinit endp
argini proc near ; read passed arguments
mov bx,argadr ; base of argument block
mov al,[bx].flgs ; get flags
and al,capt+emheath+havtt+trnctl+lclecho+modoff+lnwrap
mov yflags,al ; mask for allowable and save
mov al,[bx].prt
mov portno,al ; update port number
mov al,[bx].rows
mov crt_lins,al ; init # of rows and cols
mov ax,[bx].captr
mov captrtn,ax ; buffer capture routine
mov al,[bx].escc
mov esc_ch,al
mov parmsk,0ffh ; parity mask, assume parity = None
cmp [bx].parity,parnon ; is parity None?
je argini1 ; e = yes, keep all 8 bits
mov parmsk,07fh ; else keep lower 7 bits
argini1:ret ; that's it
argini endp
modlin proc near ; turn on mode line
; ************************** Change Connect Mode Line, Oct.8,1990 [zqf].
cmp isccdos, 0 ; if in MS-DOS or CC-DOS ?
je modl0 ; e = in MS-DOS
jmp cmodl0 ; in CC-DOS
; ***
; ******** in MS-DOS below
modl0: mov al,esc_ch
mov modbuf.m_echr,' ' ; first char is initial space
mov modbuf.m_hlp,' ' ; goes here too
cmp al,32 ; printable?
jnb modl1 ; yes, keep going
add al,40h ; made printable
mov modbuf.m_echr,5eh ; caret, note control char
mov modbuf.m_hlp,5eh
modl1: mov modbuf.m_echr+1,al ; fill in character
mov modbuf.m_hlp+1,al
mov bx,argadr ; get argument block
mov al,[bx].baudb ; get baud bits
mov si,offset unkbaud ; assume unknown baud
cmp al,baudnsiz ; too big?
jnb modl2 ; nb = yes, use default
mov cl,size m_baud ; each is 5 bytes long
mul cl
mov ah,0
add ax,offset baudn
mov si,ax
modl2: mov cx,size m_baud ; length of baud space
mov di,offset modbuf.m_baud
push es ; save es
push ds
pop es ; set es to datas segment
cld
rep movsb ; copy in baud rate
mov al,[bx].parity ; get parity code
shl al,1 ; each is 4 bytes long
shl al,1
mov ah,0
add ax,offset parnams ; names of parity settings
mov si,ax
mov cx,4 ; each is 4 long
mov di,offset modbuf.m_par
rep movsb
mov si,offset remmsg ; Assume remote echoing
test yflags,lclecho ; Is remote side echoing?
jz modl4 ; Yes, keep going
mov si,offset lclmsg ; Else it's local echoing.
modl4: mov cx,3 ; size of on/off
mov di,offset modbuf.m_echo
rep movsb
mov al,portno ; communications port
cmp al,' ' ; binary (non-printable)?
jae modl5 ; ae = no, ascii
add al,'0' ; convert to ascii
modl5: mov modbuf.m_prt,al ; fill in port number
mov cx,8 ; blank out terminal id field
mov si,offset mtty ; assume no terminal emulation
mov di,offset modbuf.m_term ; destination
rep movsb ; copy it in
mov modbuf.m_prn,' ' ; assume not printing the screen
mov modbuf.m_prn+1,' '
mov modbuf.m_prn+2,' '
test anspflg,prtscr ; doing a print the screen?
jz modl5a ; z = no
mov modbuf.m_prn,'P' ; yes. display PRN at end of line
mov modbuf.m_prn+1,'R'
mov modbuf.m_prn+2,'N'
modl5a: mov cx,size modfrm ; this is size of mode line
mov si,offset modbuf ; mode line image
pop es
; ****
jmp modwrt
; ******** in CC-DOS below
cmodl0: mov al,esc_ch
mov cmodbuf.cm_echr,' ' ; first char is initial space
mov cmodbuf.cm_hlp,' ' ; goes here too
cmp al,32 ; printable?
jnb cmodl1 ; yes, keep going
add al,40h ; made printable
mov cmodbuf.cm_echr,5eh ; caret, note control char
mov cmodbuf.cm_hlp,5eh
cmodl1: mov cmodbuf.cm_echr+1,al ; fill in character
mov cmodbuf.cm_hlp+1,al
mov bx,argadr ; get argument block
mov al,[bx].baudb ; get baud bits
mov si,offset cunkbaud ; assume unknown baud
cmp al,baudnsiz ; too big?
jnb cmodl2 ; nb = yes, use default
mov cl,size cm_baud ; each is 5 bytes long
mul cl
mov ah,0
add ax,offset baudn
mov si,ax
cmodl2: mov cx,size cm_baud ; length of baud space
mov di,offset cmodbuf.cm_baud
push es ; save es
push ds
pop es ; set es to datas segment
cld
rep movsb ; copy in baud rate
mov al,[bx].parity ; get parity code
shl al,1 ; each is 4 bytes long
shl al,1
mov ah,0
add ax,offset cparnams ; names of parity settings
mov si,ax
mov cx,4 ; each is 4 long
mov di,offset cmodbuf.cm_par
rep movsb
mov si,offset cremmsg ; Assume remote echoing
test yflags,lclecho ; Is remote side echoing?
jz cmodl4 ; Yes, keep going
mov si,offset clclmsg ; Else it's local echoing.
cmodl4: mov cx,4 ; size of on/off
mov di,offset cmodbuf.cm_echo
rep movsb
mov al,portno ; communications port
cmp al,' ' ; binary (non-printable)?
jae cmodl5 ; ae = no, ascii
add al,'0' ; convert to ascii
cmodl5: mov cmodbuf.cm_prt,al ; fill in port number
mov cx,8 ; blank out terminal id field
mov si,offset mtty ; assume no terminal emulation
mov di,offset cmodbuf.cm_term ; destination
rep movsb ; copy it in
mov cmodbuf.cm_prn,' ' ; assume not printing the screen
mov cmodbuf.cm_prn+1,' '
mov cmodbuf.cm_prn+2,' '
test anspflg,prtscr ; doing a print the screen?
jz cmodl5a ; z = no
mov cmodbuf.cm_prn,'P' ; yes. display PRN at end of line
mov cmodbuf.cm_prn+1,'R'
mov cmodbuf.cm_prn+2,'N'
cmodl5a: mov cx,size cmodfrm ; this is size of mode line
mov si,offset cmodbuf ; mode line image
pop es
; ************************** Oct.8,1990 [zqf].
; alternate entry to write an alternate mode line
modwrt: push cx
push si ; save mode line and size
mov ah,3 ; read cursor position
xor bx,bx ; screen page 0
int screen
mov cursor,dx ; save cursor position
call trmatt ; Get terminal attributes
and ah,77h ; omit blinking/bold attributes
mov bh,ah ; get video attribute
mov dx,low_rgt ; right most column
inc dh ; refer to status line
mov ch,dh ; bottom line [dlk]
mov cl,0 ; left col = 0 (first) [dlk]
mov ax,600h ; scroll to clear the line
;**** Modify to suit CCDOS. Sept 5,1990 [zqf]
cmp isccdos,1 ; if in CCDOS ?
jne modl5b ; ne = No, in MS-DOS
mov ax,cx ; in CCDOS
mov bx,dx
call atsclr ; clear mode line in CC-DOS
jmp modl5c
modl5b: int screen ; clear mode line in MS-DOS
modl5c:
;****
mov dh,byte ptr low_rgt+1 ; refer to status line
inc dh
xor dl,dl ; left most column
mov bh,0
mov ah,2 ; set cursor position
int screen
pop si
pop cx ; restore these
cmp cl,crt_cols ; mode line longer than screen?
jbe modl6 ; le = no
mov cl,crt_cols ; else do just one line's worth
dec cx ; don't let screen scroll
modl6: cld
lodsb ; get a byte
mov ah,14 ; write to terminal
mov bh,0 ; page 0
int screen
loop modl6 ; write out entire mode line
cmp flags.vtflg,0 ; emulating?
je modl7 ; e = no
and yflags,not modoff ; update local flags (mode line on)
mov al,yflags ; Yes - update flags also
call ansdsl ; get extras from emulator
modl7: mov dx,cursor
mov ah,2
mov bh,0
int screen ; put cursor back where it belongs
ret
modlin endp
clrmod proc near ; clear mode line
call trmatt ; Get terminal screen attributes
mov bh,al ; Use screen background attribute
mov ax,600h ; blank window
mov dx,low_rgt ; right most column
inc dh ; refer to status line
mov cx,dx ; bottom line [dlk]
xor cl,cl ; left most column
;**** Modify to suit CCDOS. June 25,1990 [zqf]
mov ax,cx
mov bx,dx
call atsclr
; int screen ; clear mode line
;****
or yflags,modoff ; turn on flag
ret
clrmod endp
; Fetch screen attributes from emulator (if emulating). It exists mainly
; so that the reverse video will work. Returns the current mode
; line background attribute in ah, the current screen background in al,
; and the current "cursor" (foreground) attribute in bl. (Note: anstat
; returns status yflags in bh).
trmatt proc near ; Get attributes
cmp flags.vtflg,0 ; emulating?
je trmat1 ; No, just do simple stuff
mov al,yflags ; anstat expects flags byte in al
call anstat ; Fetch emulator status/attributes
ret
trmat1: mov al,scbattr ; Background attributes
mov bl,curattr ; And cursor attribute
mov ah,al ; where modlin needs them
and ah,77h ; get colors part, no blink/bold
rol ah,1 ; reverse them
rol ah,1
rol ah,1
rol ah,1
ret
trmatt endp
; Get byte yflags of terminal emulator passed in AL. Used in mode line
; handling when 25th line is used by the emulator. [jrd]
telmsy proc near
mov yflags,al ; get the updated flags
call ansflg ; and any other emulator info
ret
telmsy endp
;[IU2] This routine updates the ANSI status flags from the emulator,
; and passes the "yflags" byte to the VT100 emulator also.
ansflg proc near
push ax ; save regs
push bx
mov al,yflags
call anstat ; Get status and attributes
mov ansflgs,bh ; Save
test ansflgs,dececho ; does host want us to do local echo?
jz ansflg1 ; z = no, use working default
or yflags,lclecho ; turn on local echoing
ansflg1:pop bx
pop ax
ret
ansflg endp
getflgs proc near ; supply yflags for terminal emulators
mov al,yflags
ret
getflgs endp
term proc near ; terminal mode entry point
mov argadr,ax ; save argument ptr
call argini ; init options from arg address
call scrini ; init screen stuff
mov bx,portval ; port data structure address
mov bx,[bx].flowc ; get flow control chars (bl=xoff)
mov flowon,bh
mov flowoff,bl ; save for later
mov oldsp,sp ; remember stack for i/o failure,
; used by procedure endcon
lp: call prtchr ; char at port?
jmp short lpinp ; yes, go handle
nop ; else look at kbd
lpkbd: mov fairness,0 ; say kbd was examined
call keybd ; call keyboard translator in msu
jnc lp ; nc = no char or have processed it
jmp short quit ; carry set = quit connect mode
lpinp: and al,parmsk ; apply 8/7 bit parity mask
call outtty ; print on terminal
inc fairness ; say read port but not kbd, again
cmp fairness,100 ; this many port reads before kbd?
jb lp ; b = no, read port again
jmp short lpkbd ; yes, let user have a chance too
quit:
call pntflsh ; flush printer buffer
call tekend ; cleanup Tektronix mode [bjh]
mov ah,3 ; get cursor position into dx
xor bh,bh ; page 0
int screen
mov cursor,dx ; save position
cmp flags.vtflg,0 ; terminal type of none?
ja quit1 ; a = yes
test yflags,modoff ; is modeline still toggled off?
jnz quit1 ; nz = yes
call clrmod ; clear it before storing screen
quit1: nop
;******************
call savescr ; save screen in MS-DOS
;*******************
mov ax,0600h ; clear mode line with old attributes
mov bh,oldattr ; attributes
mov dx,low_rgt ; right most column
inc dh ; refer to status line
mov cx,dx ; bottom line [dlk]
xor cl,cl ; left most column
;**** Modify to suit CCDOS. June 25,1990 [zqf]
mov ax,cx
mov bx,dx
call atsclr
; int screen ; clear mode line
;****
mov ah,oldattr ; attributes at init time
mov scbattr,ah ; background = original state
; for ega in non-standard # lines
cmp ega_mode,0 ; ega board active?
je quit2 ; e = no
cmp byte ptr low_rgt+1,23 ; is screen standard length?
je quit2 ; e = yes, so regular cursor set is ok
push es ; turn off ega cursor emulation
mov ax,40h ; byte 40:87H is ega Info byte
mov es,ax
push es:[87h] ; save info byte around call
or byte ptr es:[87h],1 ; set emulation off (low bit = 1)
mov cx,lincur ; cursor shape to set
mov ah,1 ; set the shape
int screen ; back to starting value
pop es:[87h] ; recover original Info byte
pop es ; and our work reg
jmp short quit3 ; skip regular mode cursor setting
quit2: ; for regular sized screen
mov cx,lincur ; cursor type at startup
mov ah,1
int screen ; restore cursor type
quit3: mov ah,2 ; Position cursor
mov bh,0 ; Page 0
mov dx,low_rgt ; bottom line
inc dh ; status line position
xor dl,dl ; left most column
; ---------don't set cursor in CCDOS. Dec.12,1990 [zqf]
IFDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
cmp isccdos,1 ; is in CCDOS ?
je quit4 ; e = yes, skip
ENDIF
int screen ; Do it
quit4:
; -----------
mov al,yflags
and al,not lclecho ; don't copy host's echo flag
mov bx,argadr
mov ah,[bx].flgs ; get user's flag settings
and ah,lclecho ; clear all but local echo bit
or [bx].flgs,al ; update flags in arg block
ret
term endp
; put the character in al to the screen
outtty proc near
cmp flags.vtflg,0 ; emulating a terminal?
jne outnoc ; ne = yes, emulator handles printing
test flags.remflg,d8bit ; keep 8 bits for displays?
jnz outnp9 ; nz = yes, 8 bits if possible
and al,7fh ; remove high bit
outnp9: cmp rxtable+256,0 ; translation turned off?
je outnp7 ; e = yes, no translation
push bx
mov bx,offset rxtable ; address of translate table
xlatb ; new char is in al
pop bx
outnp7: test anspflg,prtscr ; should we be printing?
jz outnop ; no, keep going
call pntchr ; queue char for printer
jnc outnop ; nc = successful print
push ax
call beep ; else make a noise and
call trnprs ; turn off printing
pop ax
outnop: test yflags,capt ; capturing output?
jz outnoc ; no, forget this part
push ax ; save char
call captrtn ; give it captured character
pop ax ; restore character and keep going
outnoc: cmp vtroll,0 ; auto roll back allowed?
jz outnp6 ; z = no, leave screen as is
cmp tekflg,0 ; Tek mode active?
jne outnp6 ; ne = yes, skip screen rolling
cmp bwnd.lcnt,0 ; is screen rolled back? [dlk]
je outnp6 ; e = no
; ---------don't set cursor in CCDOS. Dec.12,1990 [zqf]
IFDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
cmp isccdos,1 ; is in CCDOS ?
je outnpa ; e = yes, skip
ENDIF
call endwnd ; restore screen before writing [dlk]
outnpa:
; -----------
outnp6: cmp flags.vtflg,0 ; emulating a terminal?
jne outnop1 ; ne = yup, go do something smart
test yflags,trnctl ; debug? if so use Bios tty mode
jz outnp4 ; z = no
mov ah,biostty ; Bios tty screen write
cmp al,7fh ; Ascii Del char or greater?
jb outnp1 ; b = no
je outnp0 ; e = Del char
push ax ; save the char
mov al,7eh ; output a tilde for 8th bit
int screen
pop ax ; restore char
and al,7fh ; strip high bit
outnp0: cmp al,7fh ; is char now a DEL?
jne outnp1 ; ne = no
and al,3fH ; strip next highest bit (Del --> '?')
jmp outnp2 ; send, preceded by caret
outnp1: cmp al,' ' ; control char?
jae outnp3 ; ae = no
add al,'A'-1 ; make visible
outnp2: push ax ; save char
mov al,5eh ; caret
int screen ; display it
pop ax ; recover the non-printable char
outnp3: push ax
int screen
pop ax
ret
outnp4: cmp al,bell ; bell (Control G)?
jne outnp5 ; ne = no
jmp beep ; use short beep, avoid char loss
outnp5: mov dl,al ; write without intervention
mov ah,conout
int dos ; else let dos display char
ret
outnop1:cmp flags.vtflg,tttek ; doing Tektronix emulation?
je outnop2 ; e = yes, use Tek emulator
cmp tekflg,0 ; Tek submode active?
jne outnop2 ; ne = yes, use Tek emulator
jmp anstty ; call terminal emulator routine & ret
outnop2:jmp tekemu ; use Tek emulator and return
outtty endp
;[IU2] Here to output character to port with no echo (like escape sequences
; sent by PF keys, responses to requests from the host, etc. It is
; wrong thinking to echo these).
prtbout proc near ; Global routine now
mov ah,al ; This is where outchr expects it
call outchr
jmp endcon ; failure, end connection
nop
clc ; carry clear for success
ret
prtbout endp
;[IU2] Here to output an unsigned 8-bit number (in al) to the port without
; echoing. Used by terminal emulator escape sequence output.
prtnout proc near
mov bl,10 ; Output in base 10
jmp prtno2 ; Ensure at least a zero
prtno1: cmp al,0
jne prtno2 ; Yes - do more digits
ret ; No - return from recursive call
prtno2: mov ah,0 ; Clear previous remainder
div bl ; Divide off a digit
push ax ; Push remainder (in ah) on stack
call prtno1 ; Recur
pop ax ; Pop off a digit
add ah,'0' ; Make it ASCII
call outchr ; send to port
jmp endcon ; failure, end connection
nop
clc ; carry clear for success
ret
prtnout endp
; send the character in al out to the serial port; handle echoing.
; Can send an 8 bit char while displaying only 7 bits locally.
outprt proc near
test yflags,lclecho ; echoing?
jz outpr1 ; z = no, forget it
push ax ; save char
call outtty ; print it
pop ax ; restore
outpr1: mov ah,al ; this is where outchr expects it
call outchr ; output to the port
jmp endcon ; failure, end connection
nop
clc ; carry clear for success
ret
outprt endp
; Jump here to exit Connect mode and execute macros 'TERMINALR' (vtrmac) or
; 'TERMINALS' (vtsmac). Does nothing if macro does not exist.
; Preserves registers except ax. Returns to TELNET caller with 'C' in kbdflg.
vtrmac proc near ; RESET macro
mov ax,offset vtrname ; select macro name
mov vtmacname,ax
mov vtmaclen,vtrlen ; and its length
jmp short vtmacro ; finish in common code
vtrmac endp
vtsmac proc near ; SET macro
mov ax,offset vtsname
mov vtmacname,ax
mov vtmaclen,vtslen
jmp short vtmacro
vtsmac endp
;
; Reference Macro structure for db number of entries (mac names)
; is file table mcctab |-> db length of macroname, excl '$'
; mssset.asm each entry |-> db 'macroname','$'
; where these |-> dw offset of definition string
; are stored.
; Definition string in db length of <string with null>
; buffer macbuf db 'string with trailing null'
;
vtmacro proc near ; common code for macros vtsmac,vtrmac
push bx
push cx
push si
mov bx,offset mcctab ; table of macro names
mov cl,[bx] ; number of names in table
xor ch,ch
jcxz vtmacx ; z = empty table, do nothing
inc bx ; point to length of first name
vtmac2: mov al,[bx] ; length of this name
xor ah,ah
cmp al,vtmaclen ; length same as desired keyword?
jne vtmac3 ; ne = no, search again
mov si,bx
inc si ; point at first char of name
push cx ; save name counter
push di ; save reg
mov cl,vtmaclen ; length of name, excluding '$'
xor ch,ch
mov di,vtmacname ; point at desired macro name
push es ; save reg
push ds
pop es ; make es use datas segment
cld
repe cmpsb ; match strings
pop es ; need current si below
pop cx
pop di ; recover saved regs
je vtmac4 ; e = matched
vtmac3: add bx,ax ; step to next name, add name length
add bx,4 ; + count, dollar sign, def word ptr
loop vtmac2 ; try next name
vtmacx: pop si ; no macro, return to Connect mode
pop cx
pop bx
ret
vtmac4: cmp taklev,maxtak ; room in Take level?
jge vtmacx ; ge = no, exit with no action
inc taklev ; increment take level
add takadr,size takinfo ; make a new Take entry/macro
mov bx,takadr ; point to current macro structure
inc si ; skip dollar sign after name
mov si,[si] ; get definition address
mov [bx].takbuf,si ; address of definition string struc
mov cl,[si] ; length byte of definition
xor ch,ch
mov [bx].takcnt,cx ; number of chars in definition
inc si ; address of definition text proper
mov [bx].takptr,si ; where to read next command char
mov [bx].taktyp,0ffh ; flag as a macro
pop si
pop cx
pop bx
jmp endcon ; exit Connect mode
vtmacro endp
; Error recovery routine used when outchr reports unable to send character
; or when vtmacro requests exiting Connect mode.
; Exit Connect mode cleanly, despite layers of intermediate calls.
endcon proc near
mov kbdflg,'C' ; report 'C' to TERM's caller
mov sp,oldsp ; recover startup stack pointer
; TERM caller's return address is now
; on the top of stack. A longjmp.
jmp quit ; exit Connect mode cleanly
endcon endp
;;; Action routines (verbs) for keyboard translator KEYBD in msuibm.
; These are invoked by a jump instruction. Return carry clear for normal
; processing, return carry set for invoking Quit (kbdflg has transfer char).
uparrw: mov al,'A' ; cursor keys
jmp short comarr
dnarrw: mov al,'B'
jmp short comarr
rtarr: mov al,'C'
test vtemu.vtflgop,vswdir ; writing left to right?
jz comarr ; z = yes
mov al,'D' ; reverse sense of keys
jmp short comarr
lfarr: mov al,'D'
test vtemu.vtflgop,vswdir ; writing left to right?
jz comarr ; z = yes
mov al,'C' ; reverse sense of keys
comarr: push ax ; save final char
mov ttyact,0 ; network, group chars for packet
mov al,escape ; Output an escape
call outprt ; Output, echo permitted
cmp flags.vtflg,tttek ; Tek terminal?
je comar0 ; e = yes, use VT100 codes
cmp flags.vtflg,ttvt100 ; VT100 terminal emulation?
jne comar2 ; No, do VT52/HEATH-19 sequence
comar0: call ansflg ; Update flags all around
mov al,'[' ; Maybe this next?
test ansflgs,decckm ; Cursor key mode reset?
je comar1 ; Yes, output the "["
mov al,'O' ; No, set, use the "O"
comar1: call outprt ; Output it (echo permitted)
comar2: pop ax ; recover final char
mov ttyact,1 ; network, restore tty active flag
call outprt ; Output to port (echo permitted)
ret
pf1: mov al,'P' ; keypad function keys 1-4
jmp short compf
pf2: mov al,'Q'
jmp short compf
pf3: mov al,'R'
jmp short compf
pf4: mov al,'S'
compf: push ax ; save final char
mov ttyact,0 ; network, group chars for packet
mov al,escape ; Output an escape
call prtbout
call ansflg ; get emulator flags
test ansflgs,decanm ; ansi mode?
jz short compf1 ; z = no
mov al,'O' ; send an "O"
call prtbout ; Output it
compf1: pop ax ; Get the saved char back
mov ttyact,1 ; network, restore tty active flag
call prtbout ; Output to port
ret
kp0: mov al,'p' ; keypad numeric keys
jmp short comkp
kp1: mov al,'q'
jmp short comkp
kp2: mov al,'r'
jmp short comkp
kp3: mov al,'s'
jmp short comkp
kp4: mov al,'t'
jmp short comkp
kp5: mov al,'u'
jmp short comkp
kp6: mov al,'v'
jmp short comkp
kp7: mov al,'w'
jmp short comkp
kp8: mov al,'x'
jmp short comkp
kp9: mov al,'y'
jmp short comkp
kpminus:mov al,'m'
jmp short comkp
kpcoma: mov al,'l'
jmp short comkp
kpenter:mov al,'M'
jmp short comkp
kpdot: mov al,'n'
comkp: test ansflgs,deckpam ; keypad application mode active?
jnz comkp3 ; nz = yes, use escape sequences
sub al,40h ; deduct offset to numeric symbols
jmp comkp0 ; and send that single char
comkp3: push ax ; save final char
mov ttyact,0 ; network, group chars for packet
mov al,escape ; Output an escape
call prtbout
mov al,'O' ; Output the "O"
cmp flags.vtflg,ttvt100 ; VT100 mode?
je comkp1 ; e = yes, use "O" code
cmp flags.vtflg,tttek ; Tek terminal
je comkp1 ; e = yes, use VT100 codes
test ansflgs,decanm ; ANSI (alt application keypad) mode?
jnz comkp1 ; nz = yes, use "O"
comkp2: mov al,'?' ; else use "?" instead of "O"
comkp1: call prtbout
pop ax ; recover final char
comkp0: mov ttyact,1 ; network, restore tty active flag
call prtbout ; send it
ret
klogon proc near ; resume logging (if any)
test flags.capflg,logses ; session logging enabled?
jz klogn ; z = no, forget it
or argadr.flgs,capt ; turn on capture flag
or yflags,capt ; set local msy flag as well
call ansflg ; tell emulator
klogn: clc
ret
klogon endp
klogof proc near ; suspend logging (if any)
and argadr.flgs,not capt ; stop capturing
and yflags,not capt ; reset local msy flag as well
call ansflg ; tell emulator
klogo: clc
ret
klogof endp
snull proc near ; send a null byte
mov al,0 ; the null
jmp prtbout ; send without logging and local echo
snull endp
khold: xor holdscr,1 ; toggle Hold screen byte for msx
clc
ret
; general character out for emulator
chrout: cmp flags.vtflg,0 ; emulating?
je chrou5 ; e = no
call anskbi ; Yes, say we had keyboard input
cmp al,cr ; A CR?
jne chrou5 ; No - just output it and return
call ansflg ; Yes - update VT100 flags
test ansflgs,anslnm ; ANSI new-line mode set?
jz chrou5 ; No - just send the cr
call outprt ; Yes - output a carriage-return
mov al,lf ; Followed by a line feed
chrou5: call outprt
ret
; these commands invoke Quit
cdos: mov al,'P' ; Push to DOS
jmp short cmdcom
cstatus:mov al,'S' ; Status
jmp short cmdcom
cquit: mov al,'C' ; Exit Connect mode
jmp short cmdcom
cquery: mov al,'?' ; Help
jmp short cmdcom
chang: mov al,'H' ; Hangup, drop DTR & RTS
jmp short cmdcom
cmdcom: mov kbdflg,al ; pass char to msster.asm via kbdflg
stc ; signal that Quit is needed
ret
dmpscn proc near ; dump screen to file
call savescr ; save screen to buffer
call dumpscr ; do buffer to file
clc ; do not exit Connect mode
ret
dmpscn endp
;[IU2] Routine to toggle VT100/VT52/Heath-19 modes in VT100 emulator.
vtans52 proc near
cmp flags.vtflg,0 ; emulating?
je vtans5 ; e = no
call ans52t ; Call MSZ toggle-it routine
call ansflg ; Update flags
clc ; clear c bit so don't exit Connect
vtans5: ret
vtans52 endp
; Toggle Mode Line
trnmod: cmp flags.modflg,1 ; mode line enabled and owned by us?
jne trnm2 ; ne = no, don't touch it
cmp flags.vtflg,tttek ; Tek mode?
je trnm2 ; yes
cmp tekflg,0 ; Tek submode?
jne trnm2 ; ne = yes, no mode line changes
test yflags,modoff ; mode line already off?
jnz trnm1 ; yes, go turn on
call clrmod ; no, clear mode line here
or yflags,modoff ; turn on flag
call ansflg ; Update flags all around
clc ; clear c bit so don't exit Connect
ret
trnm1: and yflags,not modoff ; Clear flag first
cmp flags.vtflg,0 ; terminal type of none?
ja trnm3
push dx ; scroll screen to save bottom line
mov ah,prstr ; for terminal type none
mov dx,offset crlf
int dos
pop dx
trnm3: call modlin ; Then turn on mode line
call ansflg ; Update flags all around
trnm2: clc
ret
trnprs: push ax ; toggle ^ PrtSc screen to printer
test anspflg,prtscr ; are we currently printing?
jnz trnpr2 ; nz = yes, its on and going off
mov ah,ioctl
mov al,7 ; get output status of printer
push bx
mov bx,4 ; file handle for system printer
int dos
pop bx
jc trnpr1 ; c = printer not ready
cmp al,0ffh ; Ready status?
je trnpr2 ; e = Ready
trnpr1: call beep ; Not Ready, complain
jmp trnpr3 ; and ignore request
trnpr2: xor anspflg,prtscr ; flip the flag
test yflags,modoff ; mode line off?
jnz trnpr3 ; nz = yes
call modlin ; else rewrite mode line
trnpr3: pop ax
clc ; return carry clear (don't quit)
ret
; Print on PRN the char in register al. On success return with C bit clear.
; On failure do procedure pntchk and return its C bit (typically C set).
; Uses buffer dumpbuf (screen dump).
pntchr proc near
push bx ; buffer the character
mov bx,pntptr ; offset of next free byte in buffer
mov [bx],al ; store the character
inc bx ; update pointer
mov pntptr,bx ; save pointer
cmp bx,offset dumpbuf+dumplen ; buffer full yet?
pop bx
jb pntchrx ; b = no, just return
jmp pntflsh ; go flush the buffer
pntchrx:clc ; clear carry bit
ret
pntchr endp
; Flush printer buffer. Return carry clear if success.
; On failure do procedure pntchk and return its C bit (typically C set).
; Uses buffer dumpbuf (screen dump).
pntflsh proc near
cmp pntptr,offset dumpbuf ; any text in buffer?
jne pntfls1 ; ne = yes
ret ; else nothing to do
pntfls1:push ax
push bx
push cx
push dx
mov bx,portval
mov bx,[bx].flowc ; get flow control chars (bl=xoff)
mov flowon,bh
mov flowoff,bl ; save for later
mov al,bl ; get flow control char
cmp al,0 ; flow control active?
je pntfls2 ; e = no, not using xoff
call prtbout ; output xoff (al), no echo
pntfls2:mov ah,write2
mov bx,4 ; file handle for DOS printer PRN
mov cx,pntptr ; next free byte in buffer
mov dx,offset dumpbuf ; start of buffer
mov pntptr,dx ; reset buffer pointer
sub cx,dx ; cx = current byte count
jcxz pntfls3 ; z = empty, do nothing
int dos ; write buffer to printer
pntfls3:pushf ; save carry status bit
mov al,flowon
cmp al,0 ; flow control active?
je pntfls4 ; e = no, not using xon
call prtbout ; output xon (al), no echo
pntfls4:popf
pop dx
pop cx
pop bx
pop ax
jnc pntflsx ; nc = success
call pntchk ; c = error (printer not ready)
pntflsx:ret
pntflsh endp
; Check for PRN (DOS's printer) being ready. If ready, return with C clear
; Otherwise, write Not Ready msg on mode line and return with C bit set.
; N.B. DOS Critical Error will occur here if PRN is not ready. [jrd]
pntchk proc near
push dx
push cx
push ax
mov cx,10 ; ten retries before declaring error
pntchk0:mov ah,ioctl ; get printer status, via DOS
mov al,7 ; status for output
push bx
mov bx,4 ; std handle for DOS system printer
int dos
pop bx
jc pntchk1 ; c = call failed
cmp al,0ffh ; code for Ready?
je pntchk3 ; e = yes, assume printer is ready
pntchk1:push cx ; save counter, just in case
mov ax,100 ; wait 100 millisec
call pcwait
pop cx
loop pntchk0 ; and try a few more times
; get here when printer is not ready
test yflags,modoff ; is mode line off?
jnz pntchk2 ; nz = off, skip msg
push bx
push si
; mov si,offset pntmsg ; say printer not ready
mcmsgsi pntmsg, cpntmsg
mov cx,pntmsgl ; length
cmp isccdos,0
je pntchk11
mov cx,cpntmsgl
pntchk11:
call modwrt ; write alternate mode line
pop si
pop bx
pntchk2:pop ax
pop cx
pop dx
stc ; say printer not ready
ret
pntchk3:pop ax
pop cx
pop dx
clc ; say printer is ready
ret
pntchk endp
;;;;; General screen management routines for IBM PC
; computes screen location to ax, given row and col in [dh,dl], resp.
scrloc proc near
mov al,dh ; get row
mul crt_cols ; multiply by number of columns
add al,dl ; plus current column number
adc ah,0 ; ripple carry
shl ax,1 ; double for attributes
ret
scrloc endp
; Routine to set cursor type. Pass cursor type in al: 0 = No cursor,
; 1 = Underline cursor, 2 = Block cursor. All cursors blink due to hardware.
; Routine frags any ac that video ints frag.
; For EGA boards running in non-25 line mode the cursor emulation is turned
; off during cursor shape changing and restored afterward. It's another
; ega Feature. [jrd]
; Sense crt_mode 18h as Tseng Labs UltraPAK mono board in 132 column mode.
csrtype proc near
push cx ; save the reg
mov ah,1 ; Video fxn for set cursor type
mov cx,0F00H ; Assume no cursor
cmp al,0 ; No cursor?
je csrty2 ; Right - set it and be done with it
cmp crt_mode,7 ; B&W card?
je csrty3 ; Yes - different sizes
cmp crt_mode,18h ; Tseng UltraPAK mono board?
je csrty3 ; e = yes, use mono cursor
mov cx,0607H ; No, use CGA underline cursor
cmp al,2 ; Block?
jne csrty2 ; No - set it now
csrty1: xor ch,ch ; Yes - make it a block
csrty2: cmp ega_mode,0 ; ega board active?
je csrty4 ; e = no
cmp byte ptr low_rgt+1,23 ; standard screen length?
je csrty4 ; e = yes, use regular cursor setting
push es ; EGA. turn off cursor emulation
mov ax,40h ; 40:87h is ega Info byte
mov es,ax
push es:[87h] ; save Info byte around call
or byte ptr es:[87h],1 ; set emulation off (low bit = 1)
mov ah,1 ; Video fxn for set cursor type
int screen
pop es:[87h] ; restore Info byte
pop es ; and our work register
pop cx
ret
csrty4: int screen ; regular cursor shape setting
pop cx
ret
csrty3: mov cx,0B0CH ; Assume B&W underline cursor
cmp al,2 ; Block?
jne csrty2 ; No - set it now
jmp csrty1 ; Yes - make it a block
csrtype endp
; Save the entire screen in a buffer so we can restore and/or dump it.
; Saves regular (80x25) screens to memory buffer scrsav and other sized
; screens to video memory page 1. Resultant save place put into savadr
; (offset then segment) and current low_rgt size info in savflg. Note,
; some Environments (TopView/Windows etc) may not permit use of page 1. [jrd]
savescr proc near
push es
push ds
push ax
push cx
push si
push di
; ****************** if in CC-DOS mode? Nov.1990 [zqf]
cmp isccdos,1 ; if CC-DOS ?
jne savsc0 ; ne = No.
IFNDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
call savccscr ; yes, call CCDOS screen save proc
ENDIF
jmp savsc4 ; return
savsc0:
; **********************
call scrseg ; get screen segment in ax and es:di
push ax ; save screen segment
mov si,0
mov di,scrsav ; place to put screen (memory buff)
mov savadr+2,di ; working seg address for restore
mov savadr,0 ; and no offset for memory buffer
call scrmod ; ascertain video mode and screen
mov ax,low_rgt ; text screen lower right (typ 23,79)
mov savflg,ax ; save it for screen restore
inc al ; number of columns
add ah,2 ; plus status line = number of rows
cmp al,swidth ; same as preset screen space (80)?
ja savsc1 ; a = no, use screen video page 1
cmp ah,slen+1 ; same as preset screen length (24)?
je savsc3 ; e = yes, use our memory buffer
savsc1: mul ah ; times rows = characters on screen
shl ax,1 ; times two for attributes = page 1
mov cx,ax ; cx = working copy of screen size
and cx,000fh ; get lower four bits for offset part
mov savadr,cx ; save offset in this word
mov cl,4
shr ax,cl ; compute number of paragraphs
pop di ; source screen address
push di ; restore again
add di,ax ; add paragraphs, point di to page 1
mov savadr+2,di ; and save segment in this word
savsc3:
mov es,savadr+2 ; segment of storage area
mov di,savadr ; offset of same
mov ax,low_rgt ; lower right of text screen
inc al ; number of columns on screen
add ah,2 ; number of rows on screen
mul ah ; number of characters on the screen
mov cx,ax ; save this in counter cx
call scroff ; turn off screen [dt]
pop ds ; address screen
cld
rep movsw ; save the screen
savsc4:
pop di
pop si
pop cx
pop ax
pop ds ; restore this
call scron ; turn on screen [dt]
pop es
ret
savescr endp
; restore screen from buffer (offset and seg in savadr, text coord in savflg).
; Restores all screen lines. [jrd]
restscr proc near
; ****************** if in CC-DOS mode? Nov.1990 [zqf]
cmp isccdos,1 ; if CC-DOS ?
jne rstscr0 ; ne = No.
IFNDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
call rstccscr ; yes, call CCDOS screen restore proc
ENDIF
ret ; return
rstscr0:
; **********************
push es
mov ax,savflg ; saved low_rgt text screen coord
add ah,2 ; number of screen lines
inc al ; number of screen columns
mul ah ; columns time lines = # characters
mov cx,ax ; save this in counter cx
push cx ; save count
call scrseg ; get address of screen in es:di
call scroff ; turn off screen [dt]
push ds ; save original data segment
mov si,savadr ; offset of storage area
push savadr+2 ; segment of same
pop ds ; put storage segment into ds
cld
rep movsw ; restore data to screen
pop ds ; recover original data segment
call scron ; turn on screen [dt]
pop cx ; recover count
call scrsync ; synch Topview with new screen
pop es
ret
restscr endp
;**************************** used in CC-DOS Nov.28,1990 [zqf]
; SAVCCSCR ---- called by <savescr> of module "ccyibm.asm".
; which save screen char & attr in buffer pointed
; by scrsav in CC-DOS. Nov 28,1990 [zqf]
; All registers are reserved.
;********************************
SAVCCSCR proc near
push ax
push bx
push cx
push dx
push di
push es
mov ax,scrsav ; buffer segment address, offset is zero
mov es,ax
mov di,0
mov savadr+2,es
mov savadr,di
; read current cursor
mov bh,0
mov ah,3
int 10h ; read current cursor pos. & type.
mov curpos,dx ; saved in <curattr>
mov curtyp,cx ;
; save screen
mov bh,0
mov dx,0
savccscr1: mov ah,2
int 10h ; set cursor position <DH,DL>---<row,col>
mov ah,8
int 10h ; read char & attr in current cursor pos.
mov es:[di],ax ; save in scrbuf
inc dl
cmp dl,crt_cols ; crt_cols:number of screen cols (typ 80)
jl savccscr2
mov dl,0
inc dh
cmp dh,crt_lins ; crt_lins:number of rows-1 (typ 24)
jg savccscr3
savccscr2:
inc di
inc di
jmp savccscr1
savccscr3:
pop es
pop di
pop dx
pop cx
pop bx
pop ax
ret
SAVCCSCR endp
;*******************************
;**************************** used in CC-DOS Nov.28,1990 [zqf]
; RSTCCSCR ---- called by <restscr> of module "ccyibm.asm".
; which restore screen char & attr in buffer pointed
; by savadr in CC-DOS. Nov 28,1990 [zqf]
; All registers are reserved.
;********************************
RSTCCSCR proc
push ax
push bx
push cx
push dx
push di
push es
mov ax,savadr+2 ; segment address of buffer
mov es,ax
mov di,savadr ; offset address of buffer
; restore screen
mov bh,0
mov dx,0
rstccscr1:mov ah,2
int 10h ; set cursor position <DH,DL>---<row,col>
mov ax,es:[di] ; restore from scrbuf
mov bl,ah
mov cx,1
mov ah,9
int 10h ; write char & attr in current cursor pos.
inc dl
cmp dl,crt_cols ; crt_cols:number of screen cols (typ 80)
jl rstccscr2
mov dl,0
inc dh
cmp dh,crt_lins ; crt_lins:number of rows-1 (typ 24)
jg rstccscr3
rstccscr2:
inc di
inc di ; adjust pointer
jmp rstccscr1
rstccscr3:
; set original cursor pos &type
mov bh,0
mov cx,curtyp
mov ah,1
int 10h ; build cursor type
mov bh,0
mov dx,curpos
mov ah,2
int 10h ; set original cursor pos.
pop es
pop di
pop dx
pop cx
pop bx
pop ax
ret
RSTCCSCR endp
;********************************
; Save the screen to a buffer and then append buffer to a disk file. [jrd]
; Default filename is Kermit.scn; actual file can be a device too. Filename
; is determined by mssset and is passed as pointer dmpname.
; Dumpscr reads the screen image saved by savescr so call savescr call first.
dumpscr proc near
push ax
push bx
push cx
push dx
mov dmphand,-1 ; preset illegal handle
mov dx,offset dmpname ; name of disk file, from mssset
mov ax,dx ; where isfile wants name ptr
call isfile ; what kind of file is this?
jc dmp5 ; c = no such file, create it
test byte ptr filtst.dta+21,1fh ; file attributes, ok to write?
jnz dmp0 ; nz = no.
mov al,1 ; writing
mov ah,open2 ; open existing file
int dos
jc dmp0 ; c = failure
mov dmphand,ax ; save file handle
mov bx,ax ; need handle here
mov cx,0ffffh ; setup file pointer
mov dx,-1 ; and offset
mov al,2 ; move to eof minus one byte
mov ah,lseek ; seek the end
int dos
jmp dmp1
dmp5: test filtst.fstat,80h ; access problem?
jnz dmp0 ; nz = yes
mov ah,creat2 ; file did not exist
mov cx,20h ; attributes, archive bit
int dos
mov dmphand,ax ; save file handle
jnc dmp1 ; nc = ok
dmp0: mov ah,3 ; get cursor position
xor bx,bx ; page 0
int screen
push dx ; save it
mov dh,byte ptr low_rgt+1 ; go to status line
inc dh
xor dl,dl ; left most column
mov ah,2 ; position cursor
int screen
; mov dx,offset dmperr ; say no can do
mcmsg dmperr, cdmperr
mov ah,prstr
int dos
pop dx ; get original cursor position
mov ah,2 ; position cursor
xor bx,bx ; page 0
int screen
pop dx
pop cx
pop bx
pop ax
clc
ret
dmp1: mov ah,ioctl ; is destination ready for output?
mov al,7 ; test output status
mov bx,dmphand ; handle
int dos
jc dmp0 ; c = error
cmp al,0ffh ; ready?
jne dmp0 ; ne = not ready
push di ; read screen buffer, write lines
push si
push es
mov cl,byte ptr low_rgt+1 ; number of lines - 2
add cl,2 ; number of line on screen
xor ch,ch
mov si,savadr ; offset in storage area
dmp2: push cx ; save outer loop counter
mov es,savadr+2 ; get storage segment
mov di,offset dumpbuf ; data segment memory
mov cl,byte ptr savflg ; number of columns on screen - 1
inc cl ; number of columns on screen
xor ch,ch
dmp3: mov ax,word ptr es:[si] ; read char + attribute
mov byte ptr [di],al ; store just char, don't use es:
inc si ; update pointers
inc si
inc di
loop dmp3 ; do for each column
std ; set scan backward
mov cl,byte ptr savflg ; number of columns on screen - 1
inc cl ; number of columns on screen
xor ch,ch
push es
mov ax,ds
mov es,ax ; set es to data segment for es:di
mov di,offset dumpbuf ; start of line
add di,cx ; plus length of line
dec di ; minus 1 equals end of line
mov al,' ' ; thing to scan over
repe scasb ; scan until non-space
cld ; set direction forward
pop es
jz dmp3a ; z = all spaces
inc cx
inc di
dmp3a: mov word ptr [di+1],0A0Dh ; append cr/lf
add cx,2 ; line count + cr/lf
mov dx,offset dumpbuf ; array to be written
mov bx,dmphand ; need file handle
mov ah,write2 ; write the line
int dos
pop cx ; get line counter again
jc dmp3b ; c = error
loop dmp2 ; do next line
mov dx,offset dumpsep ; put in formfeed/cr/lf
mov cx,3 ; three bytes overall
mov ah,write2 ; write them
dmp3b: mov bx,dmphand ; file handle
int dos
mov ah,close2 ; close the file now
int dos
dmp6: pop es
pop si
pop di
pop dx
pop cx
pop bx
pop ax
clc
ret
dumpscr endp
; Get CRT mode - returns mode in variable crt_mode,
; updates crt_cols and low_rgt.
; For EGA active it looks in Bios work memory 40:84H for number of rows. [jrd]
scrmod proc near
push ax
push dx
mov ah,15 ; Get current video state
int screen
mov crt_mode,al ; Store CRT mode value
mov crt_cols,ah ; store # of cols
mov dl,ah ; # of cols again
mov dh,crt_lins ; and # of rows (constant from msster)
cmp ega_mode,0 ; ega active?
je scrmod4 ; e = no
push es ; yes, permit different lengths
mov ax,40h ; refer to 40:84h for # ega rows
mov es,ax
mov ah,es:[84h] ; get number of rows - 1 (typ 24)
cmp ah,20 ; less than 20 rows?
jb scrmod3 ; b = yes, ignore this length
cmp ah,80 ; more than 80 rows?
ja scrmod3 ; a = yes, ignore this length
mov dh,ah ; use this length
mov crt_lins,dh ; update our working constant
scrmod3:pop es
scrmod4:dec dl ; max text column, count from zero
dec dh ; max text row, count from zero
mov low_rgt,dx ; save away window address
pop dx
pop ax
ret
scrmod endp
; Get screen segment - returns screen segment in ax, and full address in es:di
scrseg proc near
xor di,di ; start at beginning of screen (0,0)
mov ax,0B000H ; Assume B&W card
cmp crt_mode,7 ; Is it?
je scrse1 ; e = yes
cmp crt_mode,18h ; Tseng UltraPAK mono in 132 col?
je scrse1 ; e = yes, use seg B000H
mov ax,0B800H ; No - video memory is here on color
cmp crt_mode,12 ; graphics set?
jb scrse1 ; b = no
cmp crt_mode,18 ; end of ordinary 640x480 graphics
ja scrse1 ; a = no, assume CGA segment
mov ax,0A000H ; graphics
scrse1: mov es,ax ; tell Topview our hardware address needs
mov tv_segs,es ; save our hardware screen address
mov tv_sego,di ; segment and offset form
mov tv_mode,1 ; assume we're running under Topview
mov ah,tvhere ; query Topview for its presence
int screen
mov ax,es ; get its new segment for screen work
cmp ax,tv_segs ; same as hardware?
jne scrse2 ; ne = no, we are being mapped
cmp di,tv_sego ; check this too
jne scrse2 ; ne = no too. Use TV's work buf as screen
mov tv_mode,0 ; else no Topview or no mapping
scrse2: mov tv_segs,es ; save segment
mov tv_sego,di ; and offset
ret
scrseg endp
; Synchronize a Topview provided virtual screen buffer with the image
; seen by the user. Requires cx = number of words written to screen
; (char & attribute bytes) and es:di = ENDING address of screen write.
; Changes ax and di.
scrsync proc near
cmp tv_mode,0 ; Topview mode active?
je scrsyn1 ; e = no, skip DOS call below
sub di,cx ; backup to start byte (cx = words)
sub di,cx ; after storing words to screen
mov ah,tvsynch ; tell Topview we have changed screen
int screen ; so user sees updated screen
scrsyn1:ret
scrsync endp
; The following two routines are used to turn off the display while we
; are reading or writing the screen in one of the color card modes.
; Turn screen off for (known) color card modes only. All regs preserved.
; Includes code for old procedure scrwait. 16 June 1987 [jrd]
scroff proc near
cmp refresh,0 ; slow refresh?
jne scrofx ; ne = no wait
cmp ega_mode,0 ; Extended Graphics Adapter in use?
jne scrofx ; ne = yes, no waiting
cmp tv_mode,0 ; Topview mode?
jne scrofx ; ne = yes, no waiting
cmp crt_mode,7 ; B&W card?
jnb scrofx ; Yes - just return
push ax ; Save ax and dx
push dx
mov dx,crt_status ; CGA: Wait for vertical retrace
scrof1: in al,dx
test al,disp_enb ; display enabled?
jnz scrof1 ; yes, keep waiting
scrof2: in al,dx
test al,disp_enb ; now wait for it to go off
jz scrof2 ; so can have whole cycle
mov dx,crtmset ; Output to CRT mode set port
mov al,25H ; This shuts down the display
out dx,al ; Dumb, but card is too
pop dx ; restore regs
pop ax
scrofx: ret
scroff endp
; Turn screen on for (known) color card modes only
; All registers are preserved.
scron proc near
cmp refresh,0 ; slow refresh?
jne scronx ; ne = no wait
cmp ega_mode,0 ; Extended Graphics Adapter in use?
jne scronx ; ne = yes, no waiting
cmp tv_mode,0 ; Topview mode?
jne scronx ; ne = yes, no waiting
cmp crt_mode,7 ; B&W card?
jnb scronx ; Yes - just return
push ax ; Save ax, dx, and si
push dx
push si
mov al,crt_mode ; Convert crt_mode to a word
xor ah,ah
mov si,ax ; Get it in a usable register
mov al,msets[si] ; Fetch the modeset byte
mov dx,crtmset ; This port
out dx,al ; Flash it back on
pop si ; restore regs
pop dx
pop ax
scronx: ret
scron endp
; Screen clearing routine. [IU]
;
; Call: ax/ coordinates of first screen location to be cleared.
; bx/ coordinates of last location to be cleared.
; Coord: ah = row [0-24], al = column [0-79]. Preserves all registers. [jrd]
atsclr: push ax ; save regs
push cx
push dx
CALL PATSCLR ; CALL PROC TO CLEAR LINE
mov dx,bx ; Compute last screen offset in ax
push ax
call scrmod ; update column length
pop ax ; scrmod zaps ax
push ax
call scrloc ; get screen start address in ax
mov cx,ax ; Save it in cx for a minute
pop dx ; Compute first screen offset in ax
call scrloc
sub cx,ax ; Compute number of locs to clear
add cx,2
sar cx,1 ; Make byte count a word count
jle atscl2 ; If nothing to clear, then vamos
push di ; save regs
push es ; save es
push ax ; save around call
call scrseg ; Get address of screen in ax, es:di
pop ax ; recover displacement
add di,ax ; displacement memory address
mov ah,scbattr ; Use current screen background attr
mov al,' ' ; Use space for fill
mov dl,byte ptr low_rgt ; line length - 1
inc dl ; line length
xor dh,dh
;;;;; cmp cx,dx ; Blanking a line or less??
;;;;; jg atscl1 ; No - make scroff disable display
atscl1:
; call scroff ; Turn screen off if color card
push cx ; save word count for Topview
cld
; rep stosw ; Blit... (excuse PDP-10ese please)
pop cx ; recover word count
; call scrsync ; synch Topview
; call scron ; Turn screen back on if color card
pop es ; Restore segment register
pop di ; And destination index
atscl2: pop dx ; restore regs
pop cx
pop ax
ret
; Screen clearing routine.Ver 2.00 Dec. 15,1989 [ZU]
; (Screen clearing by scroll whole bolck between <ah,al> and <bh,bl>
; Call ax/ corrdinates of upon left location to be cleared.
; <ah,al>--<row,col>
; bx/ corrdinates of down right location to be cleared.
; <bh,bl>--<row,col>
; Cord: ah=row [0-24], al = col [0-79]. Preserves all registers. [zqf]
patsclr proc near
push ax
push bx
push cx
push dx
push si
push di
; check if clear block or a line ?
cmp bh,ah
jg patsclr_b ; le= clear a block more than one line
; clear a block in one line
; read screen mode
patsclr_l:
push ax
push bx
mov ah,15 ;state
int video
mov activepage,bh
; mov cols,ah
pop bx
pop ax
; save current cursor
push ax
push bx
mov bh,activepage
mov ah,readcur
int video
mov currow,dh
mov curcol,dl
mov curtype,cx
pop bx
pop ax
; compute number of chars to clear in cx
push ax
xor cx,cx
mov dx,0
patscl1: cmp bh,ah
jle patscl2
mov dl,80 ;cols
sub dl,al
add cx,dx
xor al,al
inc ah
jmp patscl1
patscl2: cmp bl,al
jl patscl3
sub bl,al
mov bh,0
add cx,bx
inc cx
patscl3: pop ax
cmp cx,0
jle patscl10
; set cursor at start location of clearing area
mov dx,ax
mov bh,activepage
mov ah,setcur
int video
; clear screen < CX__number of chars >
mov al,' ' ;space
mov bh,activepage
mov bl,scbattr
; mov ah,writech ; ????? different with 'writeach'
mov ah,writeach
int video
; restore current cursor
mov dh,currow
mov dl,curcol
mov bh,activepage
mov ah,setcur
int video
patscl10:
pop di
pop si
pop dx
pop cx
pop bx
pop ax
ret
; scroll window at location <ah,al> to <bh,bl>
patsclr_b:
mov cx,ax
mov dx,bx
mov bh,scbattr
mov al,0
mov ah,06h
int video
jmp patscl10
patsclr endp
; Scrolling routines. vtscru scrolls up, vtscrd scrolls down 'scroll'
; rows. The top line is saved in the circular buffer before scrolling up.
; When running under an Environment control number of line positions moved
; to be less than scrolling region. [jrd]
; All registers are preserved.
; Screen-roll down. Move text down one line, for terminal emulator only.
vtscrd: push ax ; Upgraded by [jrd]
push bx
push cx
push dx
mov ah,7 ; scroll down
mov ch,mar_top ; top margin line
mov cl,0 ; left most column
mov dh,mar_bot ; bottom margin line
mov dl,byte ptr low_rgt ; right most column
mov bh,scbattr ; attributes
mov bl,dh
sub bl,ch ; region size - 1 line
mov al,scroll ; number of lines to scroll, from msz
vscrd1: cmp al,bl ; want to scroll more that than?
jbe vscrd2 ; be = no
push ax
mov al,bl ; limit to region-1 for Windows
int screen ; and do in parts
pop ax
sub al,bl ; get remainder
jmp short vscrd1 ; do next part
vscrd2: int screen ; scroll it down
pop dx
pop cx
pop bx
pop ax
ret
; Screen scroll up one line (text moves up) for terminal emulator use.
; When running under an Environment control number of line positions moved
; to be less than scrolling region. [jrd]
vtscru: push ax ; Upgraded by [jrd]
push bx
push cx
push dx
mov cl,scroll ; number of lines to scroll
mov ch,0
cmp cx,0
jnz vscru0
jmp vscru3 ; z = nothing to do
vscru0:
cmp mar_top,0 ; scrolling the top screen line?
ja vscru2 ; a = no. don't save anything
push si
push di
;******** test for CCDOS. Dec.12,1990 [zqf]
IFDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
cmp isccdos,1 ; if CCDOS ?
je vscru1a ; e = yes, in CCDOS, skip
ENDIF
call scroff ; turn off color screen
mov si,tv_sego ; screen offset for es:si
mov bx,offset twnd ; put lines in top window buffer
vscru1: push cx ; save count
call putcirc ; put screen line in circular buffer
pop cx
loop vscru1 ; save 'scroll' number of lines
call scron ; turn on screen again
IFDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
vscru1a:
ENDIF
;********
pop di
pop si ; now scroll the visible screen
vscru2: mov ah,6 ; scroll up
mov dh,mar_bot ; bottom row
mov dl,byte ptr low_rgt ; right most column
mov ch,mar_top ; top row of scrolling region
mov cl,0 ; left most column
mov bh,scbattr ; attributes
mov bl,dh
sub bl,ch ; region size - 1 line
mov al,scroll ; number of lines to scroll, from msz
vscru2a:cmp al,bl ; want to scroll more that than?
jbe vscru2b ; be = no
push ax
mov al,bl ; limit to region - 1 for Windows
;******** test for CCDOS. Dec.12,1990 [zqf]
IFDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
cmp isccdos,1 ; if CCDOS ?
je vscru2c ; e = yes, in CCDOS, skip
ENDIF
int screen ; and do in parts
IFDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
jmp vscru2d ; in MSDOS
vscru2c:
push dx
mov dl,0dh
mov ah,2
int 21h
mov dl,0ah
mov ah,2
int 21h
pop dx
vscru2d:
ENDIF
;********
pop ax
sub al,bl
jmp short vscru2a ; do next part
vscru2b:
;******** test for CCDOS. Dec.12,1990 [zqf]
IFDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
cmp isccdos,1 ; if CCDOS ?
je vscru2e ; e = yes, in CCDOS, skip
ENDIF
int screen ; and do in parts
IFDEF CGA ; Add Option CGA to servered screen.Mar.21,1991 [zqf]
jmp vscru2f ; in MSDOS
vscru2e:
push dx
mov dl,0dh
mov ah,2
int 21h
mov dl,0ah
mov ah,2
int 21h
pop dx
vscru2f:
ENDIF
;********
vscru3: pop dx ; Restore the rest of the regs
pop cx
pop bx
pop ax
ret
;screen text roll up, version for manual scrolling only
mscru: push ax ; Upgraded by [jrd]
push bx
push cx
push dx
push si
push di
cmp bwnd.lcnt,0 ; any lines in bottom window?
je mscru2 ; e = no, so ignore request
call scroff ; turn off color screen
mov bx,offset twnd ; this is where it goes
mov si,tv_sego ; screen offset for es:si
call putcirc ; put screen line in circular buffer
mov ax,601H ; scroll up one line
mov dx,low_rgt ; lower right corner
xor cx,cx ; top row of scrolling region
mov bh,scbattr ; background attributes
int screen ; scroll up that region
mov dx,low_rgt
mov dl,0 ; location is lower left corner
call scrloc ; get count from display start
mov di,ax
push es
mov bx,tv_segs ; get screen's segment into, es:di
mov es,bx ; segment
add di,tv_sego ; destination memory address (es:di)
mov bx,offset bwnd ; source of lines
call getcirc ; get line from circ buf to screen
pop es ; restore es
call scron ; turn on the screen
mscru2: pop di ; Restore the rest of the regs
pop si
pop dx
pop cx
pop bx
pop ax
ret
;screen text scroll down, for manual mode only
mscrd: push ax ; Upgraded by [jrd]
push bx
push cx
push dx
push si
push di
cmp twnd.lcnt,0 ; any lines left in top window?
je mscrd1 ; e = no, ingore request
call scroff ; turn off screen
mov dx,low_rgt ; from screen location, row
mov dl,0 ; starting in col 0
call scrloc ; get offset in display buffer in ax
mov si,tv_sego ; screen offset for es:di
add si,ax ; source addr in display buffer es:si
mov bx,offset bwnd ; buffer to use (bottom window)
call putcirc ; copy bottom screen line to circ buf
mov ax,701H ; scroll down one line
xor cx,cx ; top left corner
mov dx,low_rgt ; bottom right corner
mov bh,scbattr ; attributes
int screen ; scroll it down
push es
mov di,tv_segs ; screen segment
mov es,di
mov di,tv_sego ; screen offset, for es:di
mov bx,offset twnd ; buffer to use (top window)
call getcirc ; copy from circ buf to screen
pop es
call scron ; turn on display again
mscrd1: pop di ; Restore the rest of the regs
pop si
pop dx
pop cx
pop bx
pop ax
ret
; move viewing window down as much as possible (text moves up)
endwnd proc near ; go to end of scrolling text
push cx
mov cx,bwnd.lcnt ; all bottom window lines [dlk]
jmp dnwp0 ; and enter dwnpg
endwnd endp
dnone proc near ; move text up one line [jrd]
push cx
mov cx,1
jmp dnwp0
dnone endp
; scroll viewing window down (text moves up) one page (24 lines)
dnwpg proc near
push cx
mov cl,byte ptr low_rgt+1 ; number of rows, excl status
inc cl ; count from 1, not 0
mov ch,0
dnwp0: ; additional entry point
cmp bwnd.lcnt,cx ; enough lines in bottom line buffer?
jge dnwp1 ; ge = we have that many lines stored
mov cx,bwnd.lcnt ; do as many as we have
dnwp1: jcxz dnwp2 ; z = nothing to do
cmp tekflg,0 ; Tek mode active?
jne dnwp2 ; ne = yes, no scrolling
call mscru ; scroll up text one line
loop dnwp1
dnwp2: pop cx
clc
ret
dnwpg endp
; home viewing window
homwnd proc near
push cx
mov cx,twnd.lcnt ; all top window lines [dlk]
jmp upwp0 ; join upwpg
homwnd endp
upone proc near ; move text down one line [jrd]
push cx
mov cx,1
jmp upwp0
upone endp
; scroll viewing window up (text moves down) a page (24 lines)
upwpg proc near
push cx
mov cl,byte ptr low_rgt+1 ; number of rows, excl status line
inc cl ; count from 1, not 0
mov ch,0
upwp0: ; additional entry point
cmp twnd.lcnt,cx ; enough lines in top line buffer?
jae upwp1 ; ae = at least as many as requested
mov cx,twnd.lcnt ; do only as many as are stored
upwp1: jcxz upwp2 ; z = no lines to scroll
cmp tekflg,0 ; Tek mode active?
jne upwp2 ; ne = yes, no scrolling
call mscrd ; roll down text one line
loop upwp1
upwp2: pop cx
clc
ret
upwpg endp
; Put a line into the circular buffer. Pass the buffer structure in bx.
; Source is tv_segs:si which is the current screen address.
; Rewritten by [jrd]
putcirc proc near
push es
mov cl,crt_cols ; number of columns
xor ch,ch
mov es,[bx].orig ; get segment of memory area
cmp bx,offset bwnd ; bottom buffer?
je putci6 ; e = yes
mov di,twnd.pp ; pick up buffer ptr (offset from es)
add di,cx ; increment to next available slot
add di,cx ; char and attribute
cmp di,twnd.bend ; would line extend beyond buffer?
jb putci1 ; b = not beyond end
mov di,0 ; else start at the beginning
putci1: mov twnd.pp,di ; update ptr
cld ; set direction to forward
push ds ; save regular datas seg reg
mov ds,tv_segs ; use screen segment for ds:si
rep movsw ; copy into buffer
pop ds ; restore regular datas segment
mov cx,twnd.lmax ; line capacity of buffer
dec cx ; minus one work space line
cmp twnd.lcnt,cx ; can we increment line count?
jae putci1b ; ae = no, keep going
inc twnd.lcnt ; else count this line
putci1b:cmp bwnd.lcnt,0 ; any lines in bottom buffer?
je putci2 ; e = no
mov cx,bwnd.pp ; see if we overlap bot buf
cmp cx,twnd.pp ; is this line in bot buf area?
jne putci2 ; ne = no
add cl,crt_cols ; move bottom pointer one slot earlier
adc ch,0
add cl,crt_cols ; words
adc ch,0
cmp cx,bwnd.bend ; beyond end of buffer?
jb putci1a ; b = no
mov cx,0 ; yes, start at beginning of buffer
putci1a:mov bwnd.pp,cx ; new bottom pointer
dec bwnd.lcnt ; one less line in bottom buffer
putci2: pop es
ret
putci6: ; bottom buffer
add cx,cx ; words worth
cmp bwnd.lcnt,0 ; any lines in the buffer yet?
jne putci7 ; ne = yes
mov di,twnd.pp ; get latest used slot of top buff
add di,cx ; where first free (?) slot starts
cmp di,bwnd.bend ; are we now beyond the buffer?
jb putci6a ; b = no
mov di,0 ; yes, start at beginning of buffer
putci6a:add di,cx ; start of second free (?) slot
cmp di,bwnd.bend ; are we now beyond the buffer?
jb putci6b ; b = no
mov di,0 ; yes, start at beginning of buffer
putci6b:mov cx,twnd.lmax ; buffer line capacity
sub cx,twnd.lcnt ; minus number used by top buffer
sub cx,2 ; minus one work slot and one we need
cmp cx,0 ; overused some slots?
jge putci8 ; ge = enough to share
add twnd.lcnt,cx ; steal these from top window beginning
jmp short putci8
putci7: mov es,bwnd.orig ; get segment of memory area
mov di,bwnd.pp ; pick up buffer ptr (offset from es)
cmp di,0 ; would line start before buffer?
jne putci7a ; ne = after start of buffer
mov di,bwnd.bend ; else start at the end minus one slot
inc di
putci7a:sub di,cx
putci8: mov bwnd.pp,di ; update ptr (this is latest used slot)
mov cl,crt_cols
xor ch,ch
cld ; set direction to forward
push ds ; save regular datas seg reg
mov ds,tv_segs ; use screen segment for ds:si
rep movsw ; copy into buffer
pop ds ; restore regular datas segment
mov cx,bwnd.lmax ; line capacity of buffer
cmp bwnd.lcnt,cx ; can we increment line count?
jae putci8b ; ae = no, keep going
inc bwnd.lcnt ; else count this line
putci8b:cmp twnd.lcnt,0 ; any lines in top line buf?
je putci9 ; e = no
mov cx,twnd.pp ; yes, see if we used last top line
cmp cx,bwnd.pp ; where we just wrote
jne putci9 ; not same place, so all is well
dec twnd.lcnt ; one less line in top window
cmp cx,0 ; currently at start of buffer?
jne putci8a ; ne = no
mov cx,twnd.bend ; yes
inc cx
putci8a:sub cl,crt_cols ; back up top window
sbb ch,0
sub cl,crt_cols ; by one line
sbb ch,0
mov twnd.pp,cx ; next place to read
putci9: pop es
ret
putcirc endp
; Get a line from the circular buffer, removing it from the buffer.
; returns with carry on if the buffer is empty.
; Pass the buffer structure in bx.
; Destination preset in es:di which is the current screen address.
; Rewritten by [jrd]
getcirc proc near
cmp [bx].lcnt,0 ; any lines in buffer?
jne getci1 ; ne = yes, ok to take one out
stc ; else set carry
ret
getci1: ; top and bottom window common code
mov cl,crt_cols ; # of chars to copy
xor ch,ch
mov si,[bx].pp ; this is source
push si ; save around calls
push cx ; save around calls
cld ; set direction to forward
push ds ; save original ds
mov ax,[bx].orig ; use seg address of buffer for si
mov ds,ax
rep movsw ; destination = screen at es:di
pop ds ; recover original data segment
pop cx ; recover word count
call scrsync ; synch Topview
pop si ; get ptr again
add cx,cx ; words
cmp bx,offset bwnd ; bottom window?
je getci7 ; e = yes
sub si,cx ; top window, move back
jnc getci6 ; nc = still in buffer, continue
mov si,twnd.bend ; else use end of buffer
sub si,cx ; minus length of a piece
inc si
getci6: mov twnd.pp,si ; update ptr
dec twnd.lcnt ; decrement # of lines in buffer
clc ; make sure no carry
ret
getci7: ; bottom window
add si,cx ; words, move back (bot buf = reverse)
cmp si,bwnd.bend ; still in buffer?
jb getci8 ; b = yes
mov si,0 ; else use beginning of buffer
getci8: mov bwnd.pp,si ; update ptr
dec bwnd.lcnt ; decrement # of lines in buffer
clc ; make sure no carry
ret
getcirc endp
;
; CHKDSP - procedure to check for hardware support of 132 cols [dlk]
;
; Supported hardware: EVA board from Tseng Labs w/132-col kit installed
; Tseng Labs UltraPAK mono/Herc board w/132 column modes.
; Video 7 Vega Deluxe w/ 132X25.COM driver installed [tmk]
; and VGA board, ATI EGA Wonder, Everex ev-659 and fvga-673.
; The routine checks for the presence of a 132-column-capable adapter. If
; one is found, its handler returns the proper video mode in [CX]. The main-
; line code then moves this to [AX] and issues the video interrupt.
;
chgdsp proc near
push es ; save all we use
push ax
push bx
push cx
push dx
push si
push di
mov temp,ax ; save set/reset flag from msz
mov ah,flowoff ; get xoff
cmp ah,0 ; flow control?
je chgds0 ; e = none
call outchr ; send it
nop ; avoid serial port interrupts while
nop ; doing many rep scasb's below
nop
call savescr ; save current screen
mov ax,40 ; wait 40 millisec before video tests
call pcwait ; so don't mix screen and port intrpts
chgds0: call ckteva ; try Tseng Labs EVA
jnc chgds1 ; nc = found
call ckv7vd ; try Video 7 EGA Deluxe and VGA
jnc chgds1 ; nc = found
call ckatiw ; try ATI EGA Wonder
jnc chgds1 ; nc = found
call ckevrx ; try Everex Micro Enhancer Deluxe
jnc chgds1 ; nc = found
call ckevga ; try Everex EVGA-673
jnc chgds1 ; nc = found
jmp chgdsx ; if not, exit
; Perform mode change
chgds1: mov ax,cx ; get returned value in proper reg
int screen ; call the bios
cmp flags.modflg,1 ; is mode line enabled?
jbe chgds2 ; be = yes, and off or locally owned
mov flags.modflg,1 ; remove foreign ownership
chgds2: call scrini ; reset parameters
chgdsx: mov ah,flowon ; get flowon byte
cmp ah,0 ; using flow control?
je chgdsx1 ; e = no
call outchr ; send it
nop
nop
nop
chgdsx1:pop di ; restore what we saved
pop si
pop dx
pop cx
pop bx
pop ax
pop es
ret ; return to caller
chgdsp endp
; Individual tests for various 132-column boards
;
; Tseng LABS EVA and UltraPAK
ckteva: mov ax,0c000h ; seg addr for EVA
mov es,ax ; set into es register
mov di,76h ; offset of board's string
lea si,tsngid ; validation string
mov cx,tsnglen ; length of validiation string
cld
repe cmpsb ; compare strings
je ckteva2 ; e = strings match
mov ax,4d00h ; check for UltraPAK mono driver
int screen
cmp ax,5aa5h ; driver signature?
jne chnoad ; ne = no
mov cx,7 ; default to mono (7) for this board
cmp byte ptr temp,0 ; setting 132 columns?
je ckteva1 ; e = resetting to normal
mov cx,18h ; set to 132 cols (Set Mode 18H)
ckteva1:clc ; carry clear means found
ret
ckteva2: ; an EVA board - check for 132 col kit
cmp byte ptr es:099h,0 ; check 132 col kit installed
je chnoad ; e=0=not installed
jmp catfnd ; do the mode change
chnoad: stc ; indicate adapter not present
ret ; and exit
;
; ATI EGA Wonder
ckatiw: mov ax,0c000h ; seg addr for EGA Wonder
mov es,ax ; set into es register
mov di,012fh ; offset of message in ROM
lea si,atiwid ; offset of message here
mov cx,atilen ; length of validation string
cld
repe cmpsb ; compare strings
jne chnoad ; ne = strings differ
;
catfnd: mov cx,0003h ; prepare to reset video mode
cmp byte ptr temp,0 ; are we setting or resetting?
je ckexit ; e is reset, exit
mov cx,0023h ; set to 132 cols (Set Mode 23H)
ckexit: clc ; carry clear means found
ret
;
; Video 7 Vega Deluxe
ckv7vd: mov ax,0c000h ; seg addr for Vega rom bios
mov es,ax ; set into es register
mov di,002ah ; offset of message in ROM
lea si,vid7id ; offset of message here
mov cx,vid7len
cld
repe cmpsb ; compare strings
je cnv7fn0 ; e = same
mov di,002ah ; offset of ident string
mov si,offset vid7id2 ; Video 7 VGA board
mov cx,vid7len2
repe cmpsb
je cnv7fn2 ; e = found
cnv7fx: jmp chnoad ; ne = strings are different
;
cnv7fn0:test byte ptr es:[03ffeh],1 ; is this a 'Deluxe' Vega?
jz chnoad ; z = nope, can't do it
mov ah,35h ; DOS Get Vector
mov al,10h ; Bios video interrupt
int dos ; get it into es:bx
mov di,bx ; es:bx is returned int 10h entry pnt
sub di,5ah ; back offset to msg in 132X25.COM
lea si,vid7id ; offset of validation message
mov cx,vid7len ; length of validation string
cld
cnv7fn1:repe cmpsb ; Look for repeat of msg by 132X25.COM
jne cnv7fn2 ; if different
mov cl,crt_mode ; prepare to reset video mode
mov ch,0
cmp byte ptr temp,0 ; are we setting or resetting?
je ckexit ; e is reset, exit
mov cx,0000h ; set to 132 cols (old 40x25)
jmp short ckexit ; and exit
cnv7fn2:mov ax,6f00h ; check for VegaBios driver
int screen
cmp bx,'V7' ; Video 7 Bios presence response
jne cnv7fx ; ne = not there
mov ax,6f01h ; al gets monitor type (mono,color,ega)
int screen
mov bx,51h ; presume mono 132x25, page 0
cmp crt_lins,42 ; 43 lines active?
jb cnv7fn2a ; b = no
inc bx ; use bx = 52h for 132x43
cnv7fn2a:
cmp al,10h ; analogue fixed freq (IBM 85xx)?
je cnv7fx ; e = yes, no 132 columns
cmp al,2 ; 1 = mono, 2 = color, above = ega
jb cnv7fn3 ; b = mono or unknown
mov bx,4fh ; presume med res color 132x25
je cnv7fn3 ; e = med res color, al = 2
mov bx,41h ; ega high res 132x25, enhanced mons
cmp crt_lins,42 ; 43 lines active?
jb cnv7fn3 ; b = no
inc bx ; use bx = 42h for 132x43
cnv7fn3:mov ax,6f05h ; set special mode found in bl
cmp byte ptr temp,0 ; resetting to 80 column mode?
jne cnv7fn4 ; ne = no, setting 132x25
mov al,crt_norm ; get normal mode
mov ah,0 ; set mode
cmp crt_lins,42 ; 43 lines active?
jb cnv7fn4 ; b = no
mov bl,40h ; use Video 7 mode 40h 80x43 for color
mov ax,6f05h ; and do special mode set
cnv7fn4:int screen ; special mode is in bl
mov cx,0f00h ; a nop screen bios command
clc
ret
ckevrx: mov ax,0c000h ; seg addr for Everex EV-659
mov es,ax ; set into es register
mov di,0047h ; offset of message in ROM
lea si,evrxid ; offset of message here
mov cx,evrxlen ; length of validation string
cld
repe cmpsb ; compare strings
jne ckfnr2 ; ne = strings differ
mov ah,crt_lins ; we recognize either 44 or 25 rows
cmp ah,43 ; equal to 44-1 rows?
jne ckfnr1 ; ne = no
mov cx,0070h ; Everex extended mode ident
mov bl,09h ; prepare to reset video mode to 80x44
cmp byte ptr temp,0 ; are we setting or resetting?
je ckfnr4 ; e is reset, exit
mov bl,0bh ; 132x44
jmp ckexit
ckfnr1: cmp ah,24 ; equal to 25-1 rows?
je ckfnr3 ; e = yes
ckfnr2: jmp chnoad ; ne = no
ckfnr3: mov cx,0003h ; prepare to reset video mode
cmp byte ptr temp,0 ; are we setting or resetting?
je ckfnr4 ; e is reset, exit
mov cx,0070h ; Everex extended mode ident
mov bl,0ah ; 132x25
ckfnr4: jmp ckexit
ckevga: mov ax,0c000h ; Everex FVGA-673, rom segment
mov es,ax
mov di,76h ; offset in rom for board's id string
lea si,evgid ; id string
mov cx,evglen ; length of id string
cld
repe cmpsb ; do they match?
jne ckevg2 ; ne = no
mov cx,3 ; prepare to reset video mode
cmp byte ptr temp,0 ; setting or resetting mode?
je ckevg1 ; e = resetting, exit
mov cx,0070h ; mode for 132x25
mov bl,0ah ; Everex mode 0ah
ckevg1: clc
ret
ckevg2: stc ; say board not found
ret
; Jumping to this location is like retskp. It assumes the instruction
; after the call is a jmp addr.
RSKP PROC NEAR
pop bp
add bp,3
push bp
ret
RSKP ENDP
; Jumping here is the same as a ret
R PROC NEAR
ret
R ENDP
code ends
if1
%out [End of pass 1]
else
%out [End of assembly]
endif
end
