conservatory
/
pcs
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pcs/realio.asm

1903 lines
67 KiB
NASM
Raw Permalink Normal View History

Unpack disk3.tgz
2023-05-20 05:57:06 -04:00
; =====> REALIO.ASM
;*****************************************************
;* TIPC Scheme Runtime Support *
;* Real Mode I/O Routines *
;* *
;* (C) Copyright 1985 by Texas *
;* Instruments Incorporated. *
;* All rights reserved. *
;* *
;* Date Written: November 1987 (tc) *
;* Last Modification: *
;*****************************************************
include schemed.equ ;for port defs
include screen.equ
.286c
;
; Local equates
;
RETURN equ 0Dh ; Carriage Return Character
LINEFEED equ 0Ah ; Line Feed Character
DOS equ 021h ; Dos function request
WRITEFILE equ 040h ; Write Fiel function request
DISK_FULL equ -1 ; Disk full error designator
TIPC equ 1 ; Designates machine type as TIPC
TI_CRT equ 049h
IBM_CRT equ 010h
;
; Segment Definitions
;
PGROUP group PROG
DGROUP group DATA
; This stack is used for the standard XLI interface. However, a different
; stack (i.e. PCS's) is used during calls to a graphics driver.
STACK segment word stack 'STACK'
stackstart = $
dw 16 dup (?)
stacksize = $ - stackstart
STACK ends
;
; Data definitions
;
DATA segment byte public 'DATA'
assume DS:DGROUP
datastart = $
callers_ds dw ?
callers_es dw ?
;-----------------------------------------------------------------------------
; Type/Monitor info
;-----------------------------------------------------------------------------
PC_MAKE dw 0
VID_MODE dw 3
MAX_ROWS db DEFAULT_NUM_ROWS
MAX_COLS db DEFAULT_NUM_COLS
CHAR_HGT dw 8
;-----------------------------------------------------------------------------
; Jump table for handler based on op_code
;-----------------------------------------------------------------------------
OP_CODE dw BELL ; 0 - Sound Bell
dw CLEAR ; 1 - Clear Screen
dw BORDER ; 2 - Draw Border
dw SAVE_SCR ; 3 - Save Screen
dw REST_SCR ; 4 - Restore Screen
dw ? ; 5 - was turn cursor on
dw ? ; 6 - was turn cursor off
dw ? ; 7 - was position cursor
dw PUTCHAR ; 8 - Put Character on screen
dw SCROLLUP ; 9 - Scroll Screen Up 1 Line
dw SCROLLDN ; 10 - Scroll Screen Dn 1 Line
dw ? ; 11 - was ega cursor emulation
dw CHGMODE ; 12 - Note Change to Video Mode
dw WSTRING ; 13 - Write string to output port
dw WBLOCK ; 14 - Write string to display
table_len equ $ - OP_CODE
;-----------------------------------------------------------------------------
; XLI Setup
;-----------------------------------------------------------------------------
;;; ----- Equates -----
; offsets into the PSP
term_addr equ 0Ah
fb_addr equ 5Ch
;;; ----- Data structures -----
; file block
file_block label word
dw 4252h
dw 10011b ;flags = sysint,0,0,16-bit,near
dw offset lookup_table, seg lookup_table
dw offset parm_block, seg parm_block
; reserved area of file block
dw 100h ;sysint# (256=%graphics)
dw offset handler, seg handler ;ISR entry point
dw 0,0,0,0,0
; parameter block
parm_block label word ;not used
dw 0
; lookup table
lookup_table label word
db '//' ;not used
; other needed values
psp dw ? ;PSP segment address
psize dw ? ;size of program in paragraphs
xwait dw 2 dup (?) ;XLI wait address
xbye dw 2 dup (?) ;XLI bye address
; ___ __ __
; + -| |- _|_ | -- | __| |__ | | (extra)
map_tab db 0c5h,0b4h,0c3h,0c1h,0c2h,0c4h,0b3h,0d9h,0c0h,0bfh,0dah,0dah
map_tabx equ $
trns_tab db 0dah,0c2h,0c3h,0c5h,0c3h,0c2h,0c2h,0c5h,0c3h,0c5h,0c5h
db 0c2h,0bfh,0c5h,0b4h,0b4h,0c2h,0c2h,0c5h,0c5h,0b4h,0c5h
db 0c3h,0c5h,0c0h,0c1h,0c3h,0c1h,0c5h,0c1h,0c3h,0c5h,0c5h
db 0c5h,0b4h,0c1h,0d9h,0b4h,0c1h,0c5h,0c1h,0c5h,0b4h,0c5h
db 0c3h,0b4h,0c3h,0b4h,0b3h,0c5h,0c5h,0c5h,0c3h,0b4h,0c5h
db 0c2h,0c2h,0c1h,0c1h,0c5h,0c4h,0c2h,0c1h,0c5h,0c5h,0c5h
m14_attr equ $
;33-60 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <
db 1,0,2,2,1,4,2,0,0,3,3,7,3,5,6,2,6,6,5,3,5,2,1,2,2,1,7,3
;61-88 = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X
db 2,6,1,2,2,0,3,0,0,0,3,1,0,4,0,0,1,1,3,0,3,0,2,0,1,3,1,1
;89-116 Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t
db 0,1,0,0,0,3,7,1,5,0,3,4,3,3,3,0,6,6,0,0,2,2,3,2,3,2,3,2
;117-126 u v w x y z { | } ~
db 2,3,3,2,2,2,3,1,0,1
;127-191
db 64 dup (0)
;192-197
db 5,2,0,0,0,4
;198-218
db 20 dup (0)
;219-220
db 2,5
m16_attr equ $
;33-60 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <
db 3,1,4,4,4,7,4,2,2,6,6,11,6,9,9,4,10,10,9,6,9,4,2,4,4,3,10,6
;61-88 = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X
db 5,10,3,4,5,2,5,2,2,2,5,2,2,8,2,2,2,2,5,2,5,2,4,2,2,5,2,2
;89-116 Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t
db 2,2,2,2,2,3,12,2,9,2,6,7,6,6,6,2,10,11,2,2,5,5,6,5,6,5,6,4
;117-126 u v w x y z { | } ~
db 5,5,5,5,5,5,6,2,2,3
db 64 dup (0)
db 7,2,0,0,0,7
db 20 dup (0)
db 2,7
public m18_attr
m18_attr equ $
;33-60 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <
db 2,1,4,4,8,8,4,2,2,6,6,10,9,10,05,4,10,10,10,6,10,4,2,4,4,10,10,6
;61-88 = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X
db 9,06,2,4,4,2,6,2,2,2,6,2,2,8,2,2,2,2,6,2,6,2,4,2,2,6,2,2
;89-116 Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t
db 2,2,2,3,2,3,13,2,10,2,6,8,6,6,6,2,10,12,2,2,5,5,6,5,6,5,6,4
;117-126 u v w x y z { | } ~
db 5,6,6,5,5,5,6,2,2,2
db 64 dup (0)
db 10,4,0,0,0,8
db 20 dup (0)
db 8,8
;
; The following jump table is used wstring to handle control characters
; written to the screen.
;
wn_handle dw wwin_default ;00 - Null character
dw wwin_default ;01 -
dw wwin_default ;02 -
dw wwin_default ;03 -
dw wwin_default ;04 -
dw wwin_default ;05 -
dw wwin_default ;06 -
dw wwin_bell ;07 - Bell
dw wwin_backspace ;08 - Backspace
dw wwin_tab ;09 - Tab
dw wwin_linefeed ;0A - Linefeed
dw wwin_default ;0B -
dw wwin_default ;0C -
dw wwin_creturn ;0C - Carriage Return
;
; The following jump table is used by wstring to handle control characters
; written to disk.
;
ds_handle dw wfil_default ;00 - Null character
dw wfil_default ;01 -
dw wfil_default ;02 -
dw wfil_default ;03 -
dw wfil_default ;04 -
dw wfil_default ;05 -
dw wfil_default ;06 -
dw wfil_default ;07 -
dw wfil_backspace ;08 - Backspace
dw wfil_tab ;09 - Tab
dw wfil_newline ;0A - Linefeed
dw wfil_default ;0B -
dw wfil_default ;0C -
dw wfil_newline ;0D - Carriage Return
last_char db 0dbh
c_col dw 0
c_row dw 0
c_len dw 0
c_nrows dw 0
sav_di dw 0
datasize = $-datastart
DATA ends
page
;-----------------------------------------------------------------------------
;-----------------------------------------------------------------------------
PROG segment byte public 'PROG'
assume CS:PGROUP,DS:DGROUP
progstart = $
;-----------------------------------------------------------------------------
; name HANDLER -- Interface Handler to IO routines
;
; AX will contain error indicator (-1) if error encountered
;
hand_args struc
dw ? ; callers bp
dd ? ; return address (far)
opcode dw ? ; IO operation to perform
hand_args ends
public handler
handler proc far
mov BX,DS ; temp save caller's DS
mov AX,data
mov DS,AX ; establish local data segment
mov callers_ds,bx ; save callers data seg
mov callers_es,es ; and extra seg
mov ES,AX
; Load sub opcode
push bp
mov bp,sp
mov BX,[BP].opcode ; load operation code
pop bp
add BX,BX ; adjust for index into jump table
cmp BX,table_len ; bad op_code?
jae bad_op
; Jump desired IO handler
call OP_CODE[BX]
jmp short hand_ret
bad_op: mov AX,-1
; Return to caller
hand_ret:
push callers_ds
pop ds ; restore caller's data seg
push callers_es
pop es ; restore caller's data seg
ret ; return to caller
handler endp
;************************************************************************
;* Generate a Bell Character *
;* *
;* Purpose: To generate a "bell character" (i.e., make a noise) to *
;* simulate the effect of outputting a bell character *
;* (control-G) in the output stream. *
;* *
;* Calling Sequence: zbell(); *
;* *
;* Input Parameters: None. *
;* *
;* Output Parameters: None. *
;* *
;************************************************************************
public bell
bell proc near
cmp PC_MAKE,TIPC ; If not tipc
jne zbmbell ; then jump
zbwait: mov AH,1 ; Get speaker status
int 48h
jnz zbwait ; wait for bell to turn off
mov AH,2 ; Set speaker frequency
mov CX,1563 ; Value for 1.25MHz/800Hz (system beep)
int 48h
mov AX,000Ah ; Turn speaker on for AL*25-ms. 0Ah = .25-sec
int 48h
xor ax,ax
ret ; return to caller
;
zbmbell: mov BX,080h ; ****Copied from IBM-PC/XT BIOS listing****
in AL,61h
push AX ; Save
beep_cycle: and AL,0FCh ; Turn off timer gate and speaker data
out 61h,AL ; output to control
mov CX,48h ; Half cycle time for TONE
here: loop here ; speaker off
or AL,2 ; Turn speaker on
out 61h,AL
mov CX,48h
here2: loop here2
dec BX ; Decrease cycle count
jnz beep_cycle
pop AX
out 61h,AL
xor ax,ax
ret
bell endp
;************************************************************************
;* Clear a Window *
;************************************************************************
cl_args struc
dw ? ; caller's BP
dw ? ; return address
dd ? ; caller's return address
cl_op dw ? ; clear window op code
cl_row dw ? ; upper left hand corner row number
cl_col dw ? ; upper left hand corner column number
cl_nrows dw ? ; number of rows
cl_len dw ? ; line length (number of characters)
cl_attrib dw ? ; character attributes
cl_args ends
public clear
clear proc near
push BP ; save caller's BP
mov BP,SP
; Put cursor at beginning of next row
c_loop: mov DL,byte ptr [BP].cl_row ; load current row number
mov DH,byte ptr [BP].cl_col ; load starting column number
xor BH,BH ; page number (0 if in graphics mode)
mov AH,02H ; load "put cursor" code
call crt_dsr ; position the cursor
; Write line of blanks at current cursor position
mov AX,0920h ; load write char/attr code + blank (= 20h)
xor BH,BH ; (for IBM-PC BH=display page #)
mov BL,byte ptr [BP].cl_attrib ; load attribute flag
cmp vid_mode,14 ; IBM EGA modes?
jl c_01
cmp BL,87h ; attribute is rv white?
jne c_22
mov AX,09dbh ; use the block character not the blank
and BL,7fh ; strip off the xor bit
c_01: mov CX,[BP].cl_len ; load number of times to write the blank
call crt_dsr ; perform the write
; Increment row number, decrement row count, test, loop
inc [BP].cl_row ; increment row number
dec [BP].cl_nrows ; decrement row count
jg c_loop ; if more rows, loop (jump)
; Return to caller
c_end: pop BP ; restore caller's BP
xor ax,ax ; return status
ret ; return
; clear out the line by writing directly to the graphics planes
c_22:
mov AX,[BP].cl_nrows
mov c_nrows,ax
mov AX,[BP].cl_row ; set AX to the row
mov c_row,AX
mov AX,[BP].cl_col ; add in the starting column
mov c_col,AX
mov AX,[BP].cl_len ; number of columns to blank
mov c_len,AX
call z_ega ; restore counter
jmp c_end ; return
clear endp
;************************************************************************
;* Draw Border *
;************************************************************************
b_args struc
dw ? ; caller's BP
dw ? ; return address
dd ? ; caller's return address
b_opcode dw ? ; border opcode
b_line dw ? ; upper left corner line number
b_col dw ? ; upper left corner column number
b_nlines dw ? ; number of lines
b_ncols dw ? ; number of columns
b_battr dw ? ; border attributes
b_label dw ? ; pointer to label text
b_args ends
public border
border proc near
;;; int 3
push BP ; save caller's BP
mov BP,SP
; output corners
mov BL,byte ptr [BP].b_battr ; load attribute bits
mov DH,byte ptr [BP].b_col ; load left column number
mov DL,byte ptr [BP].b_line ; load left line number
dec DL
dec DH
mov AL,0DAh ; load upper left corner character
call zcorner
inc DH
add DH,byte ptr [BP].b_ncols
mov AL,0BFh ; load upper right corner character
call zcorner
inc DL
add DL,byte ptr [BP].b_nlines
mov AL,0D9h ; load lower right corner character
call zcorner
dec DH
sub DH,byte ptr [BP].b_ncols
mov AL,0C0h ; load lower left corner character
call zcorner
; output sides
mov DH,byte ptr [BP].b_col ; reload upper left column number
mov DL,byte ptr [BP].b_line ; and line number
dec DH ; decrement column number
mov CX,[BP].b_nlines
call zside ; draw the left hand border
mov DH,byte ptr [BP].b_col ; reload upper left column number
mov DL,byte ptr [BP].b_line ; and line number
add DH,byte ptr [BP].b_ncols ; add in line length
mov CX,[BP].b_nlines
call zside ; draw the right hand border
; Output the top of the border
mov DL,byte ptr [BP].b_line ; load upper left row number
dec DL
jl z_no_top ; if row negative, skip write
mov DH,byte ptr [BP].b_col ; load upper left column number
mov CX,[BP].b_ncols
call ztop
; Put the label in the top left corner of the border, if it'll fit
mov BX,[BP].b_label ; get segment of label
cmp BX,0
je z_no_top ; jump, if NULL pointer
mov ES,BX
mov BX,0 ; ES:BX => label
mov DX,[BP].b_ncols ; load window width
xor CX,CX ; zero the character counter
b_loop: cmp byte ptr ES:[BX],0 ; end of string?
je b_eos ; if end of string, jump
inc CX ; increment the character count
inc BX ; increment the character string pointer
cmp CX,DX ; compare to window width
jl b_loop ; if label still shorter than window, loop
b_eos: jcxz z_no_top ; if no label, jump
push CX ; save label length
; Write the label
mov DL,byte ptr [BP].b_line ; load upper left row number
mov DH,byte ptr [BP].b_col ; load upper left column number
dec DL ; decrement row number
xor BH,BH ; IBMism (page 0 for text-mode)
mov AH,02h ; load "put cursor" code
call CRT_DSR ; put cursor in upper left corner of border
pop CX ; restore label's character count
cmp PC_MAKE,TIPC
jne ibm_cblk
mov AH,011h ; load "write block of characters" code
mov DX,ES ; load segment address
mov BX,0 ; load label offset
int TI_CRT ; write the label
jmp short z_no_top
;
ibm_cblk: mov AL,byte ptr [BP].b_col
add AL,CL
cmp AL,MAX_COLS
jle b_sml ; jump if label length is OK
sub AL,MAX_COLS
sub CL,AL ; force label to remain within 80-col screen
b_sml: mov DI,0 ; load label offset
lbl_loop: mov AH,0Eh ; Write ASCII Teletype
mov AL,byte ptr ES:[DI]
mov BL,byte ptr [BP].b_battr ; load attribute bits just in case
xor BH,BH ; page # for alpha mode
push CX
push DI
int IBM_CRT
pop DI
pop CX
inc DI
loop lbl_loop ; DECrement CX and jump if != 0
; Output the bottom of the border
z_no_top:
mov dx,ds
mov es,dx
mov BL,byte ptr [BP].b_battr ; load attribute bits
mov DL,byte ptr [BP].b_line
add DL,byte ptr [BP].b_nlines
mov DH,byte ptr [BP].b_col ; load upper left column number
mov CX,[BP].b_ncols
call ztop
; return to caller
pop BP ; restore caller's BP
xor ax,ax
ret ; return
border endp
;************************************************************************
;* Local Support: Draw a single character at cursor position *
;* *
;* Input Registers: AL - the character to be output *
;* BL - the character attributes for the write *
;* DH - column *
;* DL - row *
;* *
;* Registers Modified: AX,CX,SI,DI *
;************************************************************************
zcorner proc near ; draw a single corner character
cmp DH,MAX_COLS
jae zcornret
cmp DL,MAX_ROWS
jae zcornret
push DX ; save cursor coordinates
push AX ; save character to be output
xor BH,BH ; page number (=0 for graphics mode also)
mov AH,02h ; load "put cursor" code
call CRT_DSR ; position the cursor
; read the character in this screen position
; ** This is tricky 'cause DH/DL are correct but
; ** will be swapped back (to incorrect) by CRT_DSR proc
; ** if using an IBM!!!
cmp PC_MAKE,TIPC
je no_swap
xchg DH,DL
xor BH,BH ; IBM display page
no_swap: mov AH,08h
call CRT_DSR
; see if it's one of the borderline characters
call map_char
mov SI,AX
pop AX ; recover character to be output
cmp SI,0
jl zcornput
; map corner to border character
call map_char
mov DL,map_tabx-map_tab-1
mul DL
add SI,AX
mov AL,trns_tab+[SI]
; output the corner character
zcornput: mov AH,09h ; load "write character/attribute" code
mov CX,1 ; number of characters = 1
xor BH,BH ; Display page for IBM text mode (=0)
call CRT_DSR ; write it to the screen at cursor position
pop DX ; restore cursor coordinates
zcornret: ret ; return
zcorner endp
;************************************************************************
;* Local Support: Draw a border sides *
;* *
;* Input Registers: DH - column *
;* DL - row *
;* CX - number of rows *
;* *
;* Registers Modified: AX,CX,DL *
;************************************************************************
zside proc near
cmp DH,MAX_COLS ; is column within the CRT's boundaries?
jae zsideret ; if not, jump
zside_lp: mov AL,0B3h ; load "|" border character
push CX ; save line count
push DX ; save next cursor position
call zcorner ; output the border character
pop DX ; restore current cursor position
pop CX ; restore line counter
inc DL ; increment the row number
loop zside_lp ; loop until side is drawn
zsideret: ret
zside endp
;************************************************************************
;* Local Support: Draw a border - Top or Bottom *
;* *
;* Input Registers: DH - column *
;* DL - row *
;* CX - number of columns *
;* *
;* Registers Modified: AX,CX *
;************************************************************************
ztop proc near
cmp DL,MAX_ROWS ; is row within the CRT's boundaries?
jae ztopret ; if not, jump
ztop_lp: mov AL,0C4h ; load "-" border character
push CX ; save line count
push DX ; save next cursor position
call zcorner ; output the border character
pop DX ; restore current cursor position
pop CX ; restore line counter
inc DH ; increment the column number
loop ztop_lp ; loop until top/bottom is drawn
ztopret: ret
ztop endp
;************************************************************************
;* Local Support: return character mapping *
;* *
;* Input Registers: AL = character *
;* *
;* Registers Modified: CX,DI *
;************************************************************************
map_char proc near
mov CX,map_tabx-map_tab
mov DI,offset map_tab
repne scasb
mov AX,CX
dec AX
ret
map_char endp
;************************************************************************
;* Save Screen Contents *
;* *
;* Purpose: To save a rectangular region of the CRT in a string data *
;* object. *
;* *
;* Calling Sequence: save_scr(str_reg, ul_row, ul_col, n_rows, ncols) *
;* where str_reg - pointer to string data object *
;* which is to receive the screen *
;* contents *
;* ul_row - row number of the upper left *
;* corner of the region to be *
;* saved *
;* ul_col - column number of the upper left *
;* corner of the region to be *
;* saved *
;* n_rows - number of rows in the region to *
;* be saved *
;* n_cols - number of columns in the region *
;* to be saved *
;************************************************************************
sv_args struc
dw ? ; caller's BP
dw ? ; caller's ES
dw ? ; return address
dd ? ; caller's return address
sv_op dw ? ; save screen opcode
sv_str dw ? ; address of register pointing to string
sv_ulrow dw ? ; upper left hand corner's row number
sv_ulcol dw ? ; upper left hand corner's column number
sv_nrow dw ? ; number of rows
sv_ncol dw ? ; number of columns
sv_args ends
public save_scr
save_scr proc near
;;; int 3
push ES
push BP ; save the caller's BP register
mov BP,SP ; and establish local addressability
; create a pointer to the string object
;;; mov BX,[BP].sv_str ; load address of register
;;; mov DI,[BX].C_disp ; load the string
;;; mov BX,[BX].C_page ; pointer
;;; %LoadPage ES,BX ; load string page's paragraph address
;;; mov ES,pagetabl+[BX] ; load string page's paragraph address
;;; add DI,BLK_OVHD ; advance pointer past string header
mov ES,[BP].sv_str
xor DI,DI ;ES:DI => string
; store number of rows and columns into the first two bytes of the string
mov AL,byte ptr [BP].sv_nrow
stosb
mov AL,byte ptr [BP].sv_ncol
stosb
; adjust number of lines/columns for test conditions
mov AX,[BP].sv_ulrow
add [BP].sv_nrow,AX
mov AX,[BP].sv_ulcol
add [BP].sv_ncol,AX
; loop until all rows processed
mov DL,byte ptr [BP].sv_ulrow
rw_loop: mov DH,byte ptr [BP].sv_ulcol
; position cursor
cl_loop: push DX ; save current position
mov AH,02h ; load "put cursor" function id
xor BH,BH ; IBMism (page number for cursor)
call crt_dsr ; position the cursor
; read character/attributes at current screen position
mov AH,08h ; load "read char/attribute" function id
xor BH,BH ; IBMism (display page #)
call crt_dsr ; read said
;*******
cmp vid_mode,14
jl sav_01 ; not graphics modes
cmp AL,0 ; don't bother with attributes if nul
je sav_01
; cmp AL,07fh ; is it above the first 128 characters ?
; jno sav_00 ; no
cmp AL,0dah
jbe sav_00
; test AL,010h ; look for D0-DF
; je sav_00
xor AL,AL ; set to nul
jmp sav_01
sav_00: call graph_attr ; mode 14 and 16 attribute function
;******
sav_01: stosw ; store char/attr into output string
; increment column number, test, branch
pop DX
inc DH
cmp DH,byte ptr [BP].sv_ncol
jl cl_loop
; increment row number, test, branch
inc DL
cmp DL,byte ptr [BP].sv_nrow
jl rw_loop
; return to caller
pop BP
pop ES
xor ax,ax
ret ; return to caller
save_scr endp
;************************************************************************
;* Restore Screen Contents *
;* *
;* Purpose: To restore a rectangular region of the CRT from a string *
;* data object. *
;* *
;* Calling Sequence: rest_scr(str_reg, ul_row, ul_col) *
;* where str_reg - pointer to string data object *
;* which contains the screen *
;* contents *
;* ul_row - row number of the upper left *
;* corner of the region to be *
;* restored *
;* ul_col - column number of the upper left *
;* corner of the region to be *
;* restored *
;************************************************************************
rs_args struc
rs_nrow dw ? ; number of rows in saved data
rs_ncol dw ? ; number of columns in saved data
rs_BP dw ? ; caller's BP
dw ? ; caller's ES
dw ? ; return address
dd ? ; callers return address
rs_op dw ? ; restore screen opcode
rs_str dw ? ; segment address of string
rs_ulrow dw ? ; upper left hand corner's row number
rs_ulcol dw ? ; upper left hand corner's column number
rs_mrow dw ? ; number of rows in new window
rs_mcol dw ? ; number of columns in new window
rs_args ends
public rest_scr
rest_scr proc near
int 3
push ES
push BP ; save the caller's BP register
sub SP,offset rs_BP
mov BP,SP ; and establish local addressability
; address the string
mov ES,[BP].rs_str
xor SI,SI ; ES:SI => string
; get number of rows and columns from screen object
xor AH,AH
lods byte ptr ES:[SI]
add AX,[BP].rs_ulrow
mov [BP].rs_nrow,AX
xor AH,AH
lods byte ptr ES:[SI]
add AX,[BP].rs_ulcol
mov [BP].rs_ncol,AX
; adjust number of lines/columns for test conditions
mov AX,[BP].rs_ulrow
add [BP].rs_mrow,AX
mov AX,[BP].rs_ulcol
add [BP].rs_mcol,AX
; loop until all rows processed
mov DL,byte ptr [BP].rs_ulrow
xw_loop: mov DH,byte ptr [BP].rs_ulcol
; position cursor
xl_loop: cmp DH,byte ptr [BP].rs_mcol ; column too long for new window?
jge x_long ; if too long, jump
push DX ; save current position
mov AH,02h ; load "put cursor" function id
xor BH,BH ; IBMism (page number/0 in graphic mode)
call crt_dsr ; position the cursor
; read character/attributes at current screen position
lods word ptr ES:[SI] ; fetch the character and attribute
;;;;;;;; cmp AL,20h
;;;;;;;; je x_sp ; if a space skip
mov BL,AH ; and copy attribute to BL
mov AH,09h ; load "write char/attribute" function id
xor BH,BH ; IBMism (page number)
mov CX,1 ; character count = 1
call crt_dsr ; read said
; increment column number, test, branch
x_sp: pop DX ; recover the row/column coordinates
x_more: inc DH ; increment the column number
cmp DH,byte ptr [BP].rs_ncol ; more characters in this row?
jl xl_loop ; if so, jump
; increment row number, test, branch
inc DL ; increment the row number
cmp DL,byte ptr [BP].rs_mrow ; check against new window boundary
jge rs_fin ; if all rows filled, jump
cmp DL,byte ptr [BP].rs_nrow ; check against saved data
jl xw_loop ; if more lines, jump
; return to caller
rs_fin: add SP,offset rs_BP ; deallocate local storage
pop BP ; restore the caller's BP register
pop ES ; restore the caller's ES register
xor ax,ax
ret ; return to caller
;
x_long: inc SI ; increment index into saved screen
inc SI ; buffer
jmp short x_more ; continue processing row
rest_scr endp
;************************************************************************
;* Output Character To Window *
;************************************************************************
pch_args struc
dw ? ; caller's BP
dw ? ; return address
dd ? ; caller's return address
p_op dw ? ; putchar opcode
p_line dw ? ; cursor position - line number
p_col dw ? ; cursor position - column number
p_char dw ? ; character to write
p_attr dw ? ; character's attributes
pch_args ends
public putchar
putchar proc near
push BP ; save caller's BP
mov BP,SP
; position cursor for write
mov DL,byte ptr [BP].p_line ; load line number
mov DH,byte ptr [BP].p_col ; load column number
xor BH,BH ; IBMism
mov AH,02h ; load "put cursor" code
call crt_dsr ; positio the cursor
mov BL,byte ptr [BP].p_attr ; load its attributes
cmp vid_mode,14 ; only attribute for EGA modes is a
jl pchar_1 ; simulated reverse video
mov BH,BL ; save the attribute
and BH,80h ; reverse video?
jz pchar_1 ; zero indicates bit 8 not set
pchar_2: and BL,7fh ; strip off high bit
mov CX,1 ; character count
xor BH,BH ; video page number
mov AL,0dbh ; block character
mov AH,09h
call crt_dsr
or BL,80h ; set xor bit
; write the characters with attributes
pchar_1: mov AL,byte ptr [BP].p_char ; load the character
xor BH,BH ; IBMism
mov CX,1 ; repeat count = 1
mov AH,09h ; load write char/attribute code
call crt_dsr
; return to caller
xor ax,ax
pop BP
ret
putchar endp
;************************************************************************
;* Scroll Window Up one line *
;************************************************************************
su_args struc
dw ? ; caller's BP
dw ? ; return address
dd ? ; caller's return address
su_op dw ? ; scroll opcode
su_line dw ? ; upper left hand corner line number
su_col dw ? ; upper left hand corner column number
su_nline dw ? ; number of lines
su_ncols dw ? ; number of columns
su_attr dw ? ; text attributes (used for blanking)
su_args ends
public scrollup
scrollup proc near
push BP ; save caller's BP
mov BP,SP
; scroll window's text up one line
mov CL,byte ptr [BP].su_nline ; load number of lines
dec CL ; decrease number of lines by one
jz blank1 ; Jump if scrolling 1-line and just blank it
mov CH,byte ptr [BP].su_ncols ; load number of columns
mov DL,byte ptr [BP].su_line ; load upper left line number
mov DH,byte ptr [BP].su_col ; load upper left column number
mov AX,0601h ; load "scroll text" code with no blanking
cmp DGROUP:PC_MAKE,TIPC
je ti_scrl
cmp vid_mode,4 ; Are we in graphics mode?
jl txt_mod ; If we are then fix blank fill attributes
cmp vid_mode,7 ; so that the bar characters don't show up
je txt_mod
xor BH,BH ; zero attribute for fill blanks
jmp short rite_atr
txt_mod: mov BH,byte ptr [BP].su_attr ; Blanked lines' attribute txt mode
rite_atr: xchg CX,DX ; CX=Upper left corner
xchg CH,CL ; Row,column instead of TI's column,row
xchg DH,DL ; ditto
add DX,CX ; DX=Lower right corner
dec DL ; adjust column count (0 is first column)
int IBM_CRT
jmp short z_quit ; IFF IBM is in graphics mode weird char's
; are used for blanks when scrolling. Do
; as TIPC does and "manual" blank 'em.
;
ti_scrl: mov BX,DX ; copy destination coordinates
inc DL ; compute source by incrementing line number
int TI_CRT ; perform block move
; paint the last line of the window with blank of proper attributes
blank1: mov DH,byte ptr [BP].su_col ; load starting column number
mov DL,byte ptr [BP].su_line ; load upper line number
add DL,byte ptr [BP].su_nline ; add the number of lines and
dec DL ; subtract offf one
mov AH,02h ; load "put cursor" code
xor BH,BH ; IBMism
call crt_dsr ; position cursor for write
mov AX,0920h ; load "write char/attr" code, write a blank
mov BL,byte ptr [BP].su_attr ; load attribute bit setting
cmp vid_mode,14 ; ega mode?
jl z_scr01
mov BH,BL
and BH,80h
cmp BH,80h ; reverse video?
jne z_scr01
mov AX,09dbh ; change for block character
and BL,7fh ; strip off xor bit
z_scr01: xor BH,BH ; IBMism
mov CX,[BP].su_ncols ; load line length
call crt_dsr ; write a line of blanks
; return to caller
z_quit: pop BP
xor ax,ax
ret
scrollup endp
;************************************************************************
;* Scroll Window Down one line *
;************************************************************************
sd_args struc
dw ? ; caller's BP
dw ? ; return address
dd ? ; caller's return address
sd_op dw ? ; op code
sd_line dw ? ; upper left hand corner line number
sd_col dw ? ; upper left hand corner column number
sd_nline dw ? ; number of lines
sd_ncols dw ? ; number of columns
sd_attr dw ? ; text attributes (used for blanking)
sd_args ends
scrolldn proc near
push BP ; save caller's BP
mov BP,SP
; scroll window's text down one line
mov CL,byte ptr [BP].sd_nline ; load number of lines
dec CL ; decrease number of lines by one
jz blank ; Jump if scrolling 1-line and just blank it
mov CH,byte ptr [BP].sd_ncols ; load number of columns
mov DL,byte ptr [BP].sd_line ; load upper left line number
mov DH,byte ptr [BP].sd_col ; load upper left column number
mov AX,0701h ; load "scroll text" code with no blanking
cmp DGROUP:PC_MAKE,TIPC
je ti_down
push AX ; else
mov AH,0Fh
int IBM_CRT ; Are we in graphics mode?
cmp AL,4 ; If we are then fix blank fill attributes
jl text_m ; so that the bar characters don't show up
cmp AL,7
je text_m
xor BH,BH ; zero attribute for fill blanks
jmp short wrte_atr
text_m: mov BH,byte ptr [BP].sd_attr ; Blanked lines' attribute txt mode
wrte_atr: pop AX
xchg CX,DX ; CX=Upper left corner
xchg CH,CL ; Row,column instead of TI's column,row
xchg DH,DL ; ditto
add DX,CX ; DX=Lower right corner
dec DL ; adjust column count (0 is first column)
int IBM_CRT
jmp short quit ; IFF IBM is in graphics mode weird char's
; are used for blanks when scrolling. Do
; as TIPC does and "manual" blank 'em.
;
ti_down: mov BX,DX ; copy destination coordinates
inc BL ; compute dest by incrementing line number
int TI_CRT ; perform the block move
; paint the first line of the window with blank of proper attributes
blank: mov DH,byte ptr [BP].sd_col ; load starting column number
mov DL,byte ptr [BP].sd_line ; load upper line number
mov AH,02h ; load the "put cursor" code
xor BH,BH ; IBMism
call crt_dsr ; position cursor for write
mov AX,0920h ; load "write char/attr" code, write a blank
mov BL,byte ptr [BP].sd_attr ; load attribute bit setting
xor BH,BH ; IBMism
mov CX,[BP].sd_ncols ; load line length
call crt_dsr ; write a line of blanks
; return to caller
quit: pop BP ; restore caller's BP
xor ax,ax
ret
scrolldn endp
;****************************************************************************
;* *
;* Change Video Mode *
;* *
;* Purpose: to note changes to video mode. *
;* *
;****************************************************************************
chgvmode struc
dw ? ; caller's BP
dw ? ; return address
dd ? ; caller's return address
chg_op dw ? ; op code
chg_chgt dw ? ; new character height
chg_mode dw ? ; new video mode
chg_rows dw ? ; new max rows for screen
chgvmode ends
public chgmode
chgmode proc near
int 3
push bp
mov bp,sp
mov ax,[bp].chg_mode
mov VID_MODE,ax
mov ax,[bp].chg_chgt
mov CHAR_HGT,ax
mov ax,[bp].chg_rows
mov MAX_ROWS,al
pop bp
xor ax,ax
ret
chgmode endp
;****************************************************************************
;* *
;* WRITE BLOCK OF CHARACTERS *
;* *
;* Purpose: Write a character string to the display *
;* *
;****************************************************************************
wblk_args struc
dw ? ;caller's BP
dw ? ;return address
dd ? ;caller's return address
blk_op dw ? ;op code
blk_len dw ? ;length of block to write
blk_buf db 100 dup (?) ;buffer to write
blk_txt dw ? ;text attributes
blk_cur dw ? ;cursor position
wblk_args ends
public wblock
wblock proc near
int 3
push bp
mov bp,sp
mov ah,02h ;load "put cursor" code
xor bh,bh ;IBMism - page 0 for text mode
mov dx,[bp].blk_cur ;dx = cursor coordinates
call crt_dsr ;position the cursor
mov cx,[bp].blk_len ;cx = number of characters
cmp PC_MAKE,TIPC ;on what flavor PC are we running?
jne blk_ibm ;if an IBM, jump
; Write line to TIPC's screen
mov al,byte ptr [bp].blk_txt ;load text attributes
mov ah,010h ;load "write block w/ attr" code
mov dx,ss ;load segment address
mov bx,bp ;load buffer offset in segment
add bx,blk_buf
int TI_CRT
jmp blk_end
; Write line to IBM's screen
blk_ibm: mov di,bp
add di,blk_buf ;load buffer offset
mov dx,[bp].blk_cur ;reverse row/column coordinates
xchg dl,dh
mov [bp].blk_cur,dx
push cx ; save
jmp short blk_imidl ;jump into middle of loop
blk_iloop:
push cx ;save the character counter
mov dx,[bp].blk_cur ;load the previous cursor coordinates,
inc dl ;increment the column number
mov [bp].blk_cur,dx ;and save new coordinates
xor bh,bh ;page number (0 for graphics mode) IBMism
mov ah,02h ;load "put cursor" code
push di
int IBM_CRT ;position the cursor
pop di
blk_imidl:
mov ah,09h ;load "write char w/ attributes" code
mov al,byte ptr ss:[di] ;load character from buffer
mov BL,byte ptr [bp].blk_txt ;load attribute bits
xor bh,bh ;page # for alpha mode
mov cx,1 ;load repeat count = 1
pop dx ;restore character count
; test to see if we buy anything by using a repeat count
blk_imore:
cmp dx,1 ;more characters to display?
jle blk_ibotm ;if no more characters, jump
cmp al,byte ptr ss:[di]+1 ;is next character the same as previous?
jne blk_ibotm ;if not same character, jump
inc cx ;increment the repeat count
inc di ;increment the output buffer index
inc byte ptr [bp].blk_cur ;increment the cursor position
dec dx ;decrement the character count
jmp blk_imore ;try for another
blk_ibotm:
; output the character(s)
push dx ;save the adjusted character count
push di ;save the output buffer index
int IBM_CRT ;output the char(s)
pop di ;restore the output buffer index
pop cx ;restore character counter
inc di ;increment buffer pointer
loop blk_iloop ;continue 'til all characters output
blk_end:
pop bp ;restore stack
ret ; and return
wblock endp
;****************************************************************************
;* *
;* WRITE CHARACTER STRING *
;* *
;* Purpose: Write a character string to the given port object *
;* *
;****************************************************************************
wstr_args struc
dw ? ; caller's BP
dw ? ; return address
dd ? ; caller's return address
wrt_op dw ? ; op code
;;; wrt_newl dw ? ; newline before writing
wrt_wrap dw ? ; check wrap before writing string
wrt_offs dw ? ; string offset
wrt_seg dw ? ; string segment
wrt_len dw ? ; # characters
wrt_port dw ? ; port object
wstr_args ends
public wstring
wstring proc near
int 3
push bp
mov bp,sp
cmp [bp].wrt_len,0 ;anything to write?
jg wst_10 ; yes, continue
jmp wst_fin
wst_10:
cmp [bp+wrt_wrap],0 ;check wrap before writing?
je wst_15 ; no, continue
xor ax,ax ;ax = wrap indicator (0 = no)
mov bx,[bp+wrt_port].pt_ncols ;bx = line length
cmp bx,0 ;maintaining line length?
je wst_15 ; no, jump
mov cx,[bp+wrt_port].pt_ccol ;cx = current column
cmp cx,1 ;in first column already?
jle wst_15 ; yes, jump
sub bx,cx ;determine space remaining
cmp bx,[bp+wrt_len] ;room left on current line?
jge wst_15 ; yes, jump
inc ax ;set wrap indicator
wst_15:
mov [bp+wrt_wrap],ax ;update wrap indicator
mov bx,[bp+wrt_port].pt_pflgs ;get window flags
test bx,OPEN ;is port open for writing?
jz wst_esc ; no, get outa here
test bx,STRIO ;is port a string?
jnz wst_esc ; yes, return
test bx,WINDOW ;is port a window?
jnz wst_win ; yes, go to window code
jmp wst_fil ; no, go to file code
wst_esc: jmp wst_fin
;*****************************************************************************
; We have a valid window port. Write the string to the display.
;*****************************************************************************
wst_win:
les di,dword ptr [bp+wrt_offs] ;es:di => string buffer
mov bx,[bp+wrt_port].pt_cline ;bx = current line
mov ax,[bp+wrt_port].pt_ccol ;ax = current column
mov dx,[bp+wrt_port].pt_ullin ;dx = upper left line #
cmp [bp+wrt_wrap],0 ;wrap before writing string?
je wwin_start ; no, jump
xor ax,ax ;clear current column
inc bx ;bump current line
cmp bx,[bp+wrt_port].pt_nline ;exceeded number of lines?
jl wwst_w10 ;no, skip scroll
int 3
call scrollit ;scroll the display
wwst_w10:
push ax
push di
push es:[di] ;next character
call isspace ;determine if whitespace
pop di
or ax,ax ;is it?
pop ax
jz wwin_start ; no, jump
inc di
dec [bp+wrt_len] ;decrement string length
jnz wwin_start ;if non-zero, go
mov [bp+wrt_port].pt_cline,bx ;save current cursor line number
mov [bp+wrt_port].pt_ccol,ax ;save current cursor column number
jmp wst_fin ; else return
wwin_start:
mov cx,[bp+wrt_len]
;
; loop through the chars, writing them to the display
;
wwin_loop:
push cx
push di
mov cl,es:[di]
cmp cl,RETURN ;if char = carriage return
;;;;;;;; je wwin_creturn ; then jump
ja wwin_default ;if not control char, jump
xor ch,ch
mov si,cx
shl si,1 ;get index into jump table
jmp [wn_handle+si] ;go to handler
; default character handler
;
wwin_default:
cmp ax,[bp+wrt_port].pt_ncols ;are we in the last column?
jl wwin_linechk ; no, jump
test [bp+wrt_port].pt_wflgs,W_WRAP ;wrap option on?
jnz wwin_scrl ; yes, jump
inc ax ;clip - bump column
jmp wwin_100 ; continue
wwin_linechk:
cmp bx,[bp+wrt_port].pt_nline ;out of lines?
jl wwin_wchar ;no, return
wwin_scrl:
inc bx ;bump current line
xor ax,ax ;clear column
cmp bx,[bp+wrt_port].pt_nline ;exceeded number of lines?
jl wwin_wchar ; no, jump
call scrollit
wwin_wchar:
push ax ;save current column
push bx ;save current line
cmp vid_mode,3
jne wwin_gen
cmp pc_make,1
je wwin_gen
xchg ax,bx
add ax,[bp+wrt_port].pt_ullin
mov ah,80
mul ah
add ax,bx
add ax,[bp+wrt_port].pt_ulcol
shl ax,1
mov si,ax
mov ch,byte ptr [bp+wrt_port].pt_text
push ds
push 0B800h
pop ds
mov [si],cx
pop ds
jmp wwin_nxt
wwin_go:
jmp wwin_loop
wwin_gen:
push [bp+wrt_port].pt_text ;push text character attribute
push es:[di] ;push the character
add ax,[bp+wrt_port].pt_ulcol
push ax ;column number to console
add bx,[bp+wrt_port].pt_ullin
push bx ;line number to console
sub sp,6
call putchar ;display character
add sp,14 ;dump args off stack
wwin_nxt:
pop bx ;restore current line
pop ax ;restore current column
inc ax ;increment current column
wwin_100: mov [bp+wrt_port].pt_cline,bx ;save current cursor line number
wwin_120: mov [bp+wrt_port].pt_ccol,ax ;save current cursor column number
pop di
inc di
pop cx
loop wwin_go
;;;; loop wwin_loop ;if more chars, loop
jmp wst_fin ; else go home
;
; Handlers for special characters (RETURN,LINEFEED,TAB,BACKSPACE)
;
; Carriage return character handler
wwin_creturn:
mov cl,LINEFEED ;fall thru to linefeed handler
; Line Feed character handler
wwin_linefeed:
xor ax,ax ;clear column
inc bx ;bump line number
cmp bx,[bp+wrt_port].pt_nline ;exceeded number of lines?
jl wwin_100 ; no, jump
call scrollit ; yes, scroll
jmp wwin_100
; Backspace character handler
wwin_backspace:
dec AX ;decrement current column
cmp AX,0 ;if column now positive
jge wwin_120 ; then return
xor AX,AX ;cur_col = 0
jmp wwin_120 ;return
; Bell character handler
wwin_bell:
push ax
push bx
call bell ;sound the alarm
pop bx
pop ax
jmp wwin_120 ;and return
; Tab character handler
wwin_tab:
mov cx,ax ;cx = current column
mov dx,8 ;dl = 8
div dl ;ah = (cur_col % 8)
sub dl,ah
add cx,dx
mov ax,cx ;update current column
jmp wwin_120 ;and return
;*****************************************************************************
; We have a valid file port. Write the string to the disk.
;*****************************************************************************
wst_fil:
int 3
xor ax,ax ;clear ax for char later
les di,dword ptr [bp+wrt_offs] ;es:di => string buffer
test [bp+wrt_port].pt_pflgs,BINARY ;binary file?
jnz wfil_start ; yes, skip newline
cmp [bp+wrt_wrap],0 ;wrap before writing string?
je wfil_start ; no, go write chars to disk
mov al,RETURN ; yes, write CR/LF to file
call write_char
xor ax,ax ;set current column to 0
call upd_port ;update port object
mov al,LINEFEED
call write_char
xor ax,ax ;set current column to 0
call upd_port ;update port object
push di
push es:[di]
call isspace ;determine next char whitespace
pop di
or ax,ax ;is it?
jz wfil_start ; no, jump
inc di ;
dec [bp+wrt_len] ;decrement string length
jnz wfil_start ;if non-zero, continue
jmp wst_fin ; else return
wfil_start:
mov cx,[bp+wrt_len]
;
; loop through the chars, writing them to the display
;
wfil_loop:
push cx ;save length
push di ;save index to string
mov cl,es:[di] ;get character just written
cmp cl,RETURN ;test for control char
ja wfil_default ; if not, handle as default case
je wfil_newline ; if return, go handle
xor ch,ch ;clear high byte
mov si,cx ;move char to index reg
shl si,1 ;get index into jump table
jmp [ds_handle+si] ;go to handler
wfil_default:
mov cx,1 ;cx = length
mov bx,[bp+wrt_port].pt_handl ;bx = handle
mov dx,di ;dx = offset
mov ax,es ;ax = segment
call diskout
mov ax,[bp+wrt_port].pt_ccol ;ax = current column
cmp ax,[bp+wrt_port].pt_ncols ;have we exceeded line length
jl wfil_10 ; no, jump
xor ax,ax ;clear current column
jmp wfil_upd ;go update port data
wfil_10: inc ax ;bump current column
wfil_upd: call upd_port
pop di ;restore string index
inc di ;and increment
pop cx ;restore length
loop wfil_loop ;loop if more
wst_fin:
xor ax,ax
pop bp
ret ;return to caller
;
; Handlers for special characters (RETURN,LINEFEED,TAB,BACKSPACE)
;
; Carriage return or linefeed character handler
wfil_newline:
test [bp+wrt_port].pt_pflgs,BINARY ;binary file?
jnz wfil_default ; yes, output char
mov al,RETURN ; no, output cr/lf
call write_char
xor ax,ax ;set current column to 0
call upd_port ;update port object
mov al,LINEFEED
call write_char
xor ax,ax
jmp wfil_upd
; backspace character handler
wfil_backspace:
test [bp+wrt_port].pt_pflgs,BINARY ;binary file?
jnz wfil_10 ;yes, output char
mov al,byte ptr es:[di] ;al = backspace char
call write_char ;write it out
mov ax,[bp+wrt_port].pt_ccol ;ax = current column
dec ax ;decrement it
cmp ax,0
jge wfil_upd
xor ax,ax
jmp wfil_upd
; tab character handler
wfil_tab:
test [bp+wrt_port].pt_pflgs,BINARY ;binary file?
jnz wfil_10 ;yes, jump
mov al,byte ptr es:[di] ;al = tab char
call write_char ;write it out
mov ax,[bp+wrt_port].pt_ccol ;ax = current column
mov cx,ax
mov dx,8
div dl ; ah = (cur_col % 8)
sub dl,ah
add cx,dx
mov ax,cx
jmp wfil_upd
;*****************************************************************************
; Utilty routines for writing characters to display or disk
;*****************************************************************************
;UPD_PORT - update port object
; entry: ax = current column
upd_port proc near
cmp [bp+wrt_port].pt_ncols,0 ;if line length = 0
je upd_05 ; then don't maintain column
mov [bp+wrt_port].pt_ccol,ax ;save current column
upd_05:
mov ax,[bp+wrt_port].pt_bfpos ;get current buffer position
inc ax ;bump the position
cmp ax,256 ;crossed chunk boundary?
jle upd_10 ; no, jump
sub ax,256 ;ax=excess above chunk
inc [bp+wrt_port].pt_chunk ;update chunk number
upd_10: mov [bp+wrt_port].pt_bfpos,ax ;update buffer position
ret
upd_port endp
;WRITE_CHAR - write character to port
; entry: ax = character to write to port
write_char proc near
mov cx,1 ;length
mov bx,[bp+wrt_port].pt_handl ;handle
push ax
mov dx,sp
mov ax,ss
call diskout
pop ax
ret
write_char endp
;DISKOUT - output char(s) to disk
; entry: ax=segment, bx=handle, cx=buffer length, dx=offset
; exit: carry set = error, ax=status
; errors will return to the caller of wstring
diskout proc near
push ds
mov ds,ax
mov ah,WRITEFILE
int DOS ;perform disk write
pop ds
jc diskerr
cmp ax,cx ;everything written?
je diskret ; yes, return
mov ax,DISK_FULL ;note disk full error
jmp derr_ret
diskerr:
int 3
;;;
;;; For some reason, the following doesn't work. Must be a failure by
;;; AI Architects support of Get Extended Error. In the interim, just
;;; use the return value in ax. Returning is easy, just dump local
;;; storage from the stack, pop the callers bp, and return.
;;;
;;; xor bx,bx
;;; mov AH,059h ;GET_EXTENDED_ERROR
;;; int DOS ;Extended error code in AX
derr_ret: mov sp,bp ;dump everything off stack
pop bp ;return to handler, error in ax
diskret:
ret
diskout endp
;ISSPACE - determine if character is whitespace
;
isspace proc near
pop di
pop ax
cmp al,' '
je issp
cmp al,9
jb isntsp
cmp al,13
jbe issp
isntsp: xor ax,ax
issp: jmp di
isspace endp
;Scrollit - local support to scroll window
; entry: ax = column, bx = line
; exit: ax = column, bx = line
scrollit proc near
cmp bx,[bp+wrt_port].pt_nline ;out of lines?
jl scrl_ret ;no, return
push [bp+wrt_port].pt_text
push [bp+wrt_port].pt_ncols
push [bp+wrt_port].pt_nline
push [bp+wrt_port].pt_ulcol
push [bp+wrt_port].pt_ullin
sub sp,6 ;dummy args for scroll
call scrollup ;scroll window up one line
add sp,16 ;dump args off stack
mov bx,[bp+wrt_port].pt_nline ;bx = number of lines
dec bx ;bx = line number
xor ax,ax ;ax = column
scrl_ret:
ret
scrollit endp
wstring endp
;************************************************************************
;* Perform appropriate VIDEO I/O interrupt *
;* Any difference in register definition should be handled by *
;* the caller except where DH,DL contain row,col information. *
;************************************************************************
public crt_dsr
crt_dsr proc near
cmp PC_MAKE,TIPC
jne ibm_dsr
int TI_CRT
ret
ibm_dsr: xchg DH,DL ; Do this now instead of making special checks
int IBM_CRT ; IBM's row,col is diff'rnt from TI's col,row
ret
crt_dsr endp
z_ega proc near
mov AX,0A000h
mov ES,AX ; set ES to the video plane
mov AX,c_row ; set AX to the row
mul char_hgt ; multiply by the character height
mov BX,80 ; multiply by 80 bytes per line
mul BX
add AX,c_col ; add in the starting column
mov sav_di,AX ; save the starting value
xor BX,BX ; use BX as a counter
mov DX,c_len ; number of columns to blank
zc_03: mov CX,DX ; restore counter
mov DI,sav_di ; restore index
mov AH,0fh
xor AX,AX ; clear AX
cld
rep stosb
add sav_di,80 ; next line
inc BX ; increment counter
cmp BX,char_hgt ; done with this row?
jne zc_03
xor BX,BX ; clear counter
dec c_nrows ; decrement row count
jg zc_03 ; if more rows, loop (jump)
ret
z_ega endp
;************************************************************************
;* Graphics Character Attribute *
;* *
;* Purpose: To retrieve the attribute of a character on an IBM screen *
;* in a graphics mode, either 14 or 16. *
;* *
;************************************************************************
public graph_attr
graph_attr proc near
cmp AL,20h ; skip if a space
je grphend
cmp AL,00h ; skip if a null
je grphend
cmp AL,0dbh ; block character?
je grphend
push ES
push SI
push AX ; save character
push DX ; save row and column
xor AH,AH ; clear AH
mov SI,AX ; use SI as an index
sub SI,21h
mov AL,DL ; row
mul char_hgt ; pixels per character
xor BX,BX
mov BL,byte ptr m18_attr[SI] ; default mode 18 adjustment
cmp vid_mode,18 ; are we in mode 18?
je grph_02 ; yes, jump
mov BL,byte ptr m16_attr[SI] ; default mode 16 adjustment
cmp vid_mode,16 ; are we in mode 16?
je grph_02 ; yes, jump
mov BL,byte ptr m14_attr[SI] ; must be mode 14
grph_02:
add AX,BX
mov BX,80 ; 80 bytes per line
mul BX
pop DX ; restore the column
xor DL,DL ; clear the row
xchg DH,DL ; set AX to the row
add AX,DX
mov SI,AX ; put result in SI
mov AX,0a000h ; load in graphics plane
mov ES,AX
xor CX,CX ; clear CX
mov CH,01
mov AH,0
grph_03: call get_val
shl CH,1 ; shift mask one bit to the left
inc AH ; next plane
cmp AH,3
jbe grph_03
pop AX ; retrieve character
mov AH,CL ; set attribute byte
pop SI
pop ES
grphend: ret
graph_attr endp
get_val proc near
push AX ; save AH
mov DX,3ceh ; port addr of sequencer
mov AL,04h ; index to other map mask register
out DX,AL ; set index register
inc DX
xchg AL,AH
out DX,AL ; enable bank
pop AX ; restore AH
mov AL,ES:[SI]
or AL,AL
jz get_end
or CL,CH ; set attribute bit
get_end: ret
get_val endp
; PCTYPE
; Determine type of PC we are running on and initialize screen.
;
; Returns upon exit:
; Machine Type
; 1 for TIPC or Business Pro in TI mode
; FF for IBM-PC
; FE for IBM-PC/XT
; FD for IBM-PC/jr
; FC for IBM-PC/AT or B-P in IBM mode
; F8 for PS2 Model 80
; 0 for undeterminable
; Video Mode
; Character Height
;
pctype proc near
push es ; preserve regs for later
push ds
mov ax,0FC00h ; move paragraph address of copyright
pc_002: mov es,ax ; notice into ES
xor di,di ; Clear DI; 0 is lowest address in ROM @ES:
xor bx,bx ; Flag for "PC_MAKE"
mov cx,40h ; This'll be as far as I go...
mov al,'T' ; look for beginning of "Texas Instruments"
cli ; Stop interrupts - bug in old 8088's
again:
repne scas byte ptr es:[di] ; SEARCH
or cx,cx ; Reach my limit?
jz short pc_005 ; quit if we've exhausted search
cmp byte ptr es:[di],'e' ; make sure this is it
jne again ; use defaults if not found
cmp byte ptr es:[di]+1,'x' ; really make sure this is it
jne again
push ds
mov ds,bx ; 0->DS for addressing low mem.
inc bx ; BX==1 => TIPC
mov ax,ds:word ptr [01A2h] ; If TIPC then what kind?
pop ds ; get DS back
add al,ah ; checkout vector 68 bytes 2 & 3
cmp al,0F0h ; if AL==F0 then TIPC=Business Pro
jne pc_010 ; jump if not a B-P
in al,068h ; Read from port
push ax ; Save for later
and al,0FBh ; Enable CMOS
out 068h,al ; Write back out
mov dx,8296h ; I/O address for B-P's mode byte
in al,dx ; TI or IBM Mode on the B-P?
cmp al,0 ; if not zero then B-P emulates a TIPC
pop ax ; Restore original port value
out 068h,al ; and write back out
jne pc_010 ; jump if TIPC else IBM machine code is
; where it should be.
jmp short pc_007
pc_005: mov ax,es
cmp ah,0FEh ; test for segment offset FE00
jae pc_007 ; two checks made? if so, jump
add ah,2 ; go back and check segment offset
jmp pc_002 ; FE00
pc_007: mov ax,0F000h
mov es,ax
mov al,byte ptr es:0FFFEh ; IBM's machine code is @F000:FFFE
cmp al,0f0h ; Is this suckah an IBM?
jb pc_010 ; Jump if AL is below F0 (BX will be 0)
mov bl,al
pc_010:
sti ; Turn interrups back on
cmp bx,1 ; TIPC?
jne not_ti ; no, jump
; tipc, initialize graphics
mov di,0DF01h
mov es,di ; clear graphics planes
xor di,di
mov byte ptr es:[di],0AAh ; set red palette
mov byte ptr es:[di]+16,0CCh ; set green palette
mov byte ptr es:[di]+32,0F0h ; set blue palette
mov ax,0DF82h
mov es,ax
mov byte ptr es:[di],040h ; turn text on
mov ax,3 ; ax = video mode
; bx = pc type code
mov cx,8 ; cx = character height
jmp pc_020
; ibm, (assumed) get current video mode
not_ti:
push bx ; save pc type code around bios calls
mov ax,0500h ; set active display page (for alpha modes)
int 10h ; bios int
mov ah,15 ; get current video mode
int 10h ; bios int
xor ah,ah ; ax = video mode
pop bx ; bx = pc type code
mov cx,8 ; cx = character height
cmp ax,16 ; if video mode = 16
jle pc_020 ; then
mov cx,14 ; reset character height
pc_020:
pop ds ; restore local data seg
pop es ; es:di addresses transaction buffer
xor di,di
mov PC_MAKE,bx ; put PC_MAKE in transaction buffer
mov VID_MODE,ax ; ditto video mode
mov CHAR_HGT,cx ; ditto char height
ret
pctype endp
page
;-----------------------------------------------------------------------------
; The XLI interface.
;-----------------------------------------------------------------------------
main proc far ;this file's initial entry point
mov AX,data
mov DS,AX
; mov AX,stack ;establish local stack
; mov SS,AX
call pctype ;initialize type/monitor info
mov psp,ES ;save PSP@
mov word ptr ES:fb_addr,offset file_block ;poke file block@
mov word ptr ES:fb_addr+2,seg file_block ;into PSP
mov AX,ES:term_addr ;calc ptrs in PCS to jump to
add AX,3
mov xwait,AX
add AX,3
mov xbye,AX
mov AX,ES:term_addr+2
mov xwait+2,AX
mov xbye+2,AX
mov psize,plen ;calc program size
push psp
push psize
call dword ptr [xwait] ;connect with PCS
; Since this is a XLI SYSINT routine, no XCALL's ever cause a return.
; The only time we return is to terminate.
pop AX
pop AX
call dword ptr [xbye] ;disconnect from PCS
main endp
progsize = $-progstart
plen equ (progsize+datasize+stacksize+100h+10h)/16
PROG ends
end main