www.pudn.com > c_editor.rar > ED11.A

;	ED11.A	--	Screen and keyboard interface routines for the PC 
; 
;	This is a modified version of the PCIO.A routines included with the 
;		C ware (Desmet) C compiler and included with permission of 
;		C ware 
; 
 
		dseg 
; 
;	CHARACTER ATTRIBUTE EQUATES 
; 
NORMAL	EQU	7 
REVERSE	EQU	112 
BLINK	EQU	128 
INTENSE	EQU	8 
; 
;	ATTRIBUTE SET CODES 
; 
SETNORMAL	EQU	0 
SETREVERSE	EQU	1 
SETINTENSE	EQU	2 
SETFAINT	EQU	3 
SETBLINK	EQU	4 
NOBLINK		EQU	5 
; 
 
;/* control key translations */ 
UP1	EQU	10 
DOWN1	EQU	13 
UP2	EQU	21 
DOWN2	EQU	4 
LEFT1	EQU	25 
RIGHT1	EQU	18 
INS1	EQU	14 
EDIT1	EQU	5 
ESC1	EQU	27 
DEL1	EQU	127 
ZAP1	EQU	26 
ABT1	EQU	24 
SPLT1	EQU	19 
JOIN1	EQU	16 
DTOCH	EQU	1 
GTOCH	EQU	2 
HOME	EQU	6 
DSCROL 	EQU	7 
GOTO	EQU	17 
LSTRT	EQU	11 
LEND	EQU	12 
USCROL	EQU	15 
ERASE	EQU	20 
LFTDEL	EQU	8 
BEGINPL	EQU	200 
ENDPL	EQU	201 
PUTIT	EQU	202 
PICKIT	EQU	203 
RECORD	EQU	204 
REPLAY	EQU	205 
ABSLEFT	EQU	206 
ABSRGHT	EQU	207 
PAGEUP	EQU	208 
PAGEDN	EQU	209 
 
;	the table that is used to make the translation 
 
convert: 
		db	72, UP2			;up_char 
		db	80, DOWN2		;down_char 
		db	75, LEFT1		;left_char 
		db	77, RIGHT1		;right_char 
		db	71, HOME		;home 
		db	79, DEL1	 	;end 
		db	73, USCROL		;pageup_char 
		db	81, DSCROL		;pagedown_char 
		db	82, UP1			;Ins_char 
		db	83, ZAP1		;Del_char 
		db	115, LSTRT		;ctl-left 
		db	116, LEND		;ctl-rgt 
		db	59, ESC1		;F1 
		db	60, EDIT1		;F2 
		db	61, GOTO		;F3 
		db	62, INS1		;F4 
		db	63, ERASE		;F5 
		db	64, ABT1		;F6 
		db	65, BEGINPL		;F7 
		db	66, ENDPL		;F8 
		db	67, PICKIT		;F9 
		db	68, PUTIT		;F10 
		db	120,SPLT1		;alt-1 
		db	121,JOIN1		;alt-2 
		db	122,DTOCH		;alt-3 
		db	123,GTOCH		;alt-4 
		db	130,ABSLEFT		;alt - 
		db	131,ABSRGHT		;alt + 
		db	132,PAGEUP		;ctl-Pg Up 
		db	118,PAGEDN		;ctl-Pg Dn 
		db	0, 255 ; illegal character 
 
;	equates for bios interface. 
 
;	the interrupt and codes for the screen interface interrupt. 
 
video		equ	10h		;interrupt for dealing with screen 
 
mode		equ	0		;code for setting new screen mode 
curtype		equ	1		;code for setting new cursor type 
setcur		equ	2		;code for addressing cursor 
readcur		equ	3		;code for reading cursor location 
readlp		equ	4		;code for reading light pen position 
setpage		equ	5		;code to select active page 
scrollup	equ	6		;code to scroll screen up 
scrolldn	equ	7		;code to scroll screen nown 
readch		equ	8		;code to read a character from screen 
writeach	equ	9		;code to write char and attributes 
writech		equ	10		;code to write character only 
setpal		equ	11		;code to set new setpal or border 
wdot		equ	12		;code to write a dot 
rdot		equ	13		;code to read a dot 
wtty		equ	14		;code to write as if teletype 
state		equ	15		;code to find current screen status 
 
 
 
;	the interrupt and codes for the keyboard interface. 
 
keyboard	equ	16h		;interrupt 16 to deal with keyboard 
 
cicode		equ	0		;code for reading a character 
cstscode	equ	1		;code for keyboard status 
 
 
 
 
;	caution: must change column number if 40 column mode 
 
crt_cols	equ	80 
 
;	variables available to a C88 program 
 
		public	scr_cols_, scr_rows_ 
		public	scr_mode_,scr_page_,scr_attr_ 
 
scr_cols_:	dw	crt_cols	;current number of columns 
scr_rows_:	dw	25		;current number of rows 
scr_mode_	db	0		;current screen mode 
scr_page_	db	0		;current page 
scr_attr_	db	NORMAL		;current attributes for screen 
					;NORMAL is white letters on black 
 
 
 
		cseg 
 
;	SCR_SETUP_	scr_setup must be called before any use of any 
;			other routine unless the starting mode is 80X25 
;			character mode (3,4 or 7). 
 
;			Usage:	scr_setup(); 
 
		public	scr_setup_ 
scr_setup_:	push	bp 
		mov	ah,state		;get current state 
		int	video 
		mov	scr_mode_,al		;current mode 
		mov	cl,ah			;make cols a word 
		mov	ch,0 
		mov	scr_cols_,cx		;40 or 80 columns 
		mov	scr_page_,bh 
		mov	scr_attr_,NORMAL		;set to white chars on black 
		cmp	al,4			;see if a character mode 
		jc	got_attr 
		cmp	al,7			;7 is for graphics mode 
		jz	got_attr 
		mov	scr_attr_,0		;attribute is zero in graphics 
got_attr:	mov	ah,0			;return int containing mode 
		pop	bp 
		ret 
 
 
 
;	SCR_SETMODE_		set a new screen mode 
 
;				Usage:	scr_setmode(new mode); 
 
		public	scr_setmode_ 
scr_setmode_:	push	bp 
		mov	bp,sp 
		mov	al,[bp+4]	; new mode value 
		mov	ah,mode 
		int	video		; set new mode 
		call	scr_setup_	;remember new values 
		pop	bp 
		ret 
 
 
;	SCR_ROWCOL_		sets cursor at any location. 
 
;				Usage:	scr_rowcol(new row, new column); 
 
		public	scr_rowcol_ 
scr_rowcol_:				; move cursor to x,y 
		push	bp		; save from bios 
		mov	bp,sp 
		mov	dx,[bp+6]	; column 
		mov	ax,[bp+4]	; row 
		mov	dh,al 
		mov	bh,scr_page_	; force page zero 
		mov	ah,setcur	; set cursor location 
		int	video		; call bios 
		pop	bp 
		ret 
 
 
 
;	SCR_CLR_		clear entire screen 
 
;				Usage:	scr_clr(); 
 
		public	scr_clr_ 
scr_clr_:				; clear screen 
 
 
		push	bp		;save from video call 
		mov	al,0		;ask for a clear window 
		xor	cx,cx		;start at 0,0 
		mov	dh,24		;24 is the last line 
		mov	dl,byte scr_cols_	;clear entire width 
		dec	dl		;last column is width-1 
		mov	bh,scr_attr_	;attributes for new blanks 
		mov	ah,scrollup	;ask for a scrollup to clear 
		int	video		;do the clear 
		pop	bp 
		ret 
 
 
 
;	SCR_CLRL_		clear rest of line. 
 
;				Usage:		scr_clrl(); 
 
		public	scr_clrl_		 
scr_clrl_:				; clear rest of line 
		push	bp 
		mov	ah,readcur	;see where we are 
		int	video 
		mov	cl,byte scr_cols_	;calc how many chars left in line 
		sub	cl,dl		;number left 
		mov	ch,0		;number of blanks needed 
		mov	al,' '		;write blanks 
		mov	bl,scr_attr_	;normal attributes 
		mov	ah,writeach	;write the blanks 
		int	video 
		pop	bp 
		ret 
 
 
 
 
 
;	SCR_SCUP_		scroll text up leaving top line alone. 
 
;				Usage:	scr_scup(); 
 
		public	scr_scup_ 
scr_scup_:			; scroll last line, screen from line 2 to 24 
		mov	ax,scr_cols_	;need last column of screen 
		dec	ax 
		push	ax 
		mov	ax,24		;scroll through last line 
		push	ax 
		xor	ax,ax		;from column 0 
		push	ax 
		inc	ax		;leave top line alone 
		push	ax 
		push	ax		;scroll by 1 
		call	scr_scrup_	;do the scroll 
		add	sp,10		;clear arge 
		ret 
 
 
;	SCR_SCDN_		scroll all but the top line down one. 
 
;				Usage:	scr_scdn(); 
 
		public	scr_scdn_ 
scr_scdn_: 
		mov	ax,scr_cols_	;need last column of screen 
		dec	ax 
		push	ax 
		mov	ax,24		;scroll through last line 
		push	ax 
		xor	ax,ax		;from column 0 
		push	ax 
		inc	ax		;leave top line alone 
		push	ax 
		push	ax		;scroll by 1 
		call	scr_scrdn_	;do the scroll 
		add	sp,10		;clear arge 
		ret 
 
		push	ax 
		xor	ax,ax		;from column 0 
		push	ax 
		inc	ax		;leave top line alone 
		push	ax 
		push	ax		;scroll by 1 
		call	scr_scrup_	;do the scroll 
		add	sp,10		;clear arge 
		ret 
 
;	SCR_SCRUP_		Scroll the screen up. The window is scrolled 
;				up nline lines. A zero nline will clear the 
;				window. Top left of the screen in 0,0. 
 
;			Usage: scr_scrup(nline,fromrow,fromcol,torow,tocol); 
 
		public	scr_scrup_ 
scr_scrup_:	push	bp 
		mov	bp,sp 
		mov	al,[bp+4]	;number of lines 
		mov	ch,[bp+6]	;starting row 
		mov	cl,[bp+8]	;starting column 
		mov	dh,[bp+10]	;ending row 
		mov	dl,[bp+12]	;ending column 
		mov	bh,scr_attr_	;current attribute 
		mov	ah,scrollup 
		int	video		;do the scroll 
		pop	bp 
		ret 
 
 
 
;	SCR_SCRDN_		scroll the screen down. the window is scrolled 
;				down nline lines. A zero nline will clear the 
;				window. Top left of the screen in 0,0. 
 
;			Usage: scr_scrdn(nline,fromrow,fromcol,torow,tocol); 
 
		public	scr_scrdn_ 
scr_scrdn_:	push	bp 
		mov	bp,sp 
		mov	al,[bp+4]	;number of lines 
		mov	ch,[bp+6]	;starting row 
		mov	cl,[bp+8]	;starting column 
		mov	dh,[bp+10]	;ending row 
		mov	dl,[bp+12]	;ending column 
		mov	bh,scr_attr_	;current attribute 
		mov	ah,scrolldn 
		int	video		;do the scroll 
		pop	bp 
		ret 
 
 
 
;	SCR_CO_			write a character to the screen. this 
;				routine increments the cursor position 
;				after writing. normal C88 puts and printf 
;				statements can also be used to write to the 
;				screen. 
 
;				Usage:	scr_co_(character); 
 
		public	scr_co_ 
scr_co_:					; standard console output 
		push	bp 
		mov	bp,sp 
		mov	al,[bp+4]	;character to write 
		push	ax 
		push	ax 
		mov	bh,scr_page_ 
		mov	ah,readcur 
		int	video 
		cmp	dl,crt_cols-1 
		jle	u20 
		mov	dl,crt_cols-1	 
u20:	pop	ax 
		cmp	al,8 
		je	u8 
		cmp	al,0dh 
		je	u9 
		cmp	al,0ah 
		je	u10 
		cmp	al,07h 
		je	u11 
		mov	bh,scr_page_ 
		mov	bl,scr_attr_ 
		mov	ah,writeach		;use write char/attr routine 
		mov	cx,1 
		int video 
		inc	dl 
		cmp	dl,crt_cols 
		jnz	u7 
		dec	dl 
		jmp	u7 
 
;		mov	dl,0 
;		cmp	dh,24 
;		jnz	u6 
 
u1:		mov	ah,setcur 
		mov	bh,0 
		int	video 
		mov	bh,scr_attr_ 
u3:		mov	ax,0601h 
		mov	cx,0 
		mov	dh,24 
		mov	dl,crt_cols 
		dec	dl 
u4:		int	video 
u5:		pop	ax		 
		pop	bp 
		ret 
u6:		inc	dh 
u7:		mov	ah,setcur 
		jmp	u4 
u8:		cmp	dl,0 
		je	u7 
		dec	dl 
		jmp	u7 
u9:		mov	dl,0 
		jmp	u7 
u10:	cmp	dh,24 
		jne	u6 
		jmp	u1 
u11:	jmp	u5		 
; 
;	SCR_CHR_ATTR_	set screen attribute 
; 
;				Usage:  scr_chr_attr_(character); 
; 
		public	scr_chr_attr_ 
scr_chr_attr_: 
		push	bp 
		mov	bp,sp 
		mov	al,[bp+4]	;attribute 
		cmp	al,SETNORMAL 
		je	norset 
		cmp	al,SETREVERSE 
		je	revset 
		cmp	al,SETBLINK 
		je	blnkset 
		cmp	al,SETINTENSE 
		je	intset 
		cmp	al,SETFAINT 
		je	fntset 
		cmp	al,NOBLINK 
		je	blnkres 
attfin:	 
		pop	bp 
		ret 
norset:	mov	al,scr_attr_ 
		and	al,136	;save intensity and blink state 
		or	al,NORMAL 
		mov	scr_attr_,al 
		jmp	attfin 
revset:	mov	al,scr_attr_ 
		and	al,136 
		or	al,REVERSE 
		mov	scr_attr_,al 
		jmp attfin 
blnkset:mov	al,scr_attr_ 
		and	al,INTENSE 
		or	al,NORMAL 
		or	al,BLINK 
		mov	scr_attr_,al 
		jmp	attfin 
blnkres:mov	al,scr_attr_ 
		and	al,INTENSE 
		or	al,NORMAL 
		mov	scr_attr_,al 
		jmp	attfin 
intset:	mov	al,scr_attr_ 
		or	al,INTENSE 
		mov	scr_attr_,al 
		jmp	attfin 
fntset: mov	al,scr_attr_ 
		and	al,247 
		mov	scr_attr_,al 
		jmp	attfin 
 
 
;	SCR_CI_			keyboard input. function and soft keys are 
;				translated. see equates for values. 
 
;				Usage:	character = scr_ci(); 
 
		public	scr_ci_ 
scr_ci_:				;return the next character 
					; translate if necessary 
		push	bp 
		mov	ah,cicode	;ask for a keyboard character 
		int	keyboard 
		CMP	AH,74 
		JE	PLUS_KEY   
		CMP	AH,78 
		JE	MINUS_KEY  
		cmp	al,0 
		jne	not_special 
		mov	bx, offset convert	; convert special key 
ci_loop: 
		cmp	byte[bx],0 
		jz	got_it 
		cmp	ah, byte[bx] 
		je	got_it 
		add	bx,2 
		jmp	ci_loop 
got_it:		inc	bx 
		mov	al,[bx] 
		mov	ah,0 
		pop	bp 
		ret 
not_special:	mov	ah,0 
		pop	bp 
		ret 
 
PLUS_KEY:	MOV	AL,RECORD 
		JMP	not_special 
MINUS_KEY:	MOV	AL,REPLAY 
		JMP	not_special 
	 
 
 
;	SCR_CSTS_		return character if any available. otherwise 
;				return zero. 
 
;				Usage:	character = scr_csts(); 
 
		public	scr_csts_ 
scr_csts_:				;return coded character if any available 
		push	bp 
		mov	ah,cstscode 
		int	keyboard 
		mov	ax,0 
		jz	csts_over 
		call	scr_ci_		;get the coded character 
csts_over:	pop	bp 
		ret