name	clean

	page	55,132

	title	'CLEAN --- Filter text file'



;

; CLEAN --- a utility to filter text files.

; This program removes all control codes except

; for line feeds, carriage returns, and form

; feeds, strips off the high bit of all characters,

; and expands tabs.  Can be used to make a Wordstar

; file acceptable for other screen or line editors,

; and vice versa.

;

; version 1.1    10 Dec 83  Blocking/deblocking 

; version 1.0    25 Nov 83

;

; Copyright (c) 1983 by Ray Duncan



cr	equ	0dh		;ASCII carriage return

lf	equ	0ah		;ASCII line feed

ff	equ	0ch		;ASCII form feed

eof	equ	01ah		;End of file marker

tab	equ	09h		;ASCII tab character



command	equ	80h		;buffer for command tail



blksize	equ	1024		;blocking/deblocking size





cseg	segment	para public 'CODE'



	assume	cs:cseg,ds:data,es:data,ss:stack





clean	proc	far		;entry point from PC-DOS



	push	ds		;save DS:0000 for final

	xor	ax,ax		;return to PC-DOS

	push	ax

	mov	ax,data		;make our data segment

	mov	es,ax		;addressable via ES register

	call	infile		;get path and file spec.

				;for input file

	mov	ax,es		;set DS=ES for remainder

	mov	ds,ax		;of program

	jnc	clean1		;jump, got acceptable name

	mov	dx,offset msg4	;missing or illegal filespec,

	jmp	clean9		;print error message and exit.



clean1:	call	outfile		;set up output file name

	call	open_input	;now try to open input file

	jnc	clean2		;jump,opened input ok

	mov	dx,offset msg1	;open of input file failed,

	jmp	clean9		;print error msg and exit.



clean2:

	call	open_output	;try to open output file.

	jnc	clean25		;jump,opened ok

	mov	dx,offset msg2	;open of output file failed,

	jmp	clean9		;print error message and exit.



clean25:			;set up buffers

	call	init_buffs

	call	sign_on		;print ident and file names

 

				;files successfully opened,		

clean3:				;now filter the file.  

	call	get_char	;read 1 character from input.

	and	al,07fh		;strip off the high bit

	cmp	al,20h		;is it a control code?

	jae	clean4		;no,write it to new file	

				;yes it is control code,

	cmp	al,eof		;is it end of file marker?

	je	clean6		;yes,jump to close files.

	cmp	al,tab		;is it a tab command?

	jz	clean5		;yes,jump to special processing.

	cmp	al,cr		;if control code other than

	je	clean35		;tab or end-of-file mark, throw 

	cmp	al,ff		;it away unless it is a 

	je	clean35		;form feed, carriage return,

	cmp	al,lf		;or line feed.

	jne	clean3		

clean35:			;If it is one of those three,

	mov	column,0	;incidentally initialize

	jmp	clean45		;column count for tab processor.



clean4:				;count alphanumeric chars. sent.

	inc	column



clean45:			;write this character to 

	call	put_char	;output file,

	jnc	clean3		;if CY not set, write was

				;ok so go get next char.

clean47:

	call	close_input	;if CY set, disk is full

	call	close_output	;so close files and exit

	mov	dx,offset msg5  ;with error message.

	jmp	clean9



clean5:				;process tab character

	mov	ax,column	;let DX:AX=column count

	cwd

	mov	cx,8		;divide it by eight...

	idiv	cx

	sub	cx,dx		;remainder is in DX.

	add	column,cx	;update column pointer.

clean55:			;8 minus the remainder 

	push	cx		;gives us the number of

	mov	al,20h		;spaces to send out to

	call	put_char	;move to the next tab position

	pop	cx		;restore space count

	jc	clean47		;jump if disk is full

	loop	clean55

	jmp	short clean3	;get next character 



clean6:				;end of file detected,

	call	put_char	;write end-of-file marker,

	jc	clean47		;jump if disk was full

	call	flush_buffs	;write remaining data to disk

	jc	clean47		;if CY set,disk was full

				;otherwise file was written ok	

	call	close_input	;close input and output 

	call	close_output	;files.

	mov	dx,offset msg3	;addr of success message,



clean9:				;print message and return

	mov	ah,9		;control to PC-DOS

	int	21h

	ret



clean	endp





infile	proc	near		;process name of input file

				;DS:SI <- addr command line	

	mov	si,offset command

				;ES:DI <- addr filespec buffer

	mov	di,offset input_name

	cld

	lodsb			;any command line present?

	or	al,al		;return error status if not.

	jz	infile4

infile1:         		;scan over leading blanks

	lodsb			;to file name

	cmp	al,cr		;if we hit carriage return

	jz	infile4 	;filename is missing.

	cmp	al,20h		;is this a blank?

	jz	infile1		;if so keep scanning.



infile2: 			;found first char of name,

	stosb			;move last char. to output

				;file name buffer. 

	lodsb			;check next character, found

	cmp	al,cr		;carriage return yet?  	

	je	infile3		;yes,exit with success code

	cmp	al,20h		;is this a blank?

	jne 	infile2		;if not keep moving chars.



infile3: 			;exit with carry =0

	clc			;for success flag

	ret



infile4: 			;exit with carry =1

	stc			;for error flag

	ret

infile  endp 



outfile	proc	near		;set up path and file

	cld			;name for output file.

	mov	cx,64		;length to move

	mov	si,offset input_name  ;source addr

	mov	di,offset output_name ;dest addr

	rep movsb		;transfer the string

	mov	di,offset output_name

outfile1:			;scan string looking for

	mov	al,[di] 	;"." marking start of extension

	or	al,al		;or zero byte marking name end.

	jz	outfile2	;if either is found,jump.

	cmp	al,'.'

	je	outfile2	;bump string pointer, loop

	inc	di		;if neither '.' or zero found.

	jmp	outfile1	

outfile2:			;found zero or '.',force the

				;extension of the output file	

				;to '.CLN'

	mov	si,offset outfile_ext

	mov	cx,5

	rep movsb

	ret			;back to caller

outfile endp



open_input proc near		;open input file

				;DS:DX=addr filename

	mov	dx,offset input_name

	mov	al,0		;AL=0 for read only

	mov	ah,3dh		;function 3dh=open

	int     21h		;handle returned in AX,

	mov	input_handle,ax ;save it for later.

	ret			;CY is set if error

open_input endp



open_output proc near		;open output file

				;DS:DX=addr filename

	mov	dx,offset output_name

	mov	al,1		;AL=1 for write	only

	mov	ah,3ch		;function 3ch=MAKE or

	int	21h		;truncate existing file

				;handle returned in AX

	mov	output_handle,ax;save it for later.

	ret			;return CY=true if error

open_output endp



close_input proc near		;close input file

	mov	bx,input_handle ;BX=handle

	mov	ah,3eh

	int	21h

	ret

close_input endp



close_output proc near		;close output file

	mov	bx,output_handle;BX=handle

	mov	ah,3eh

	int	21h

	ret

close_output endp



get_char proc 	near		;get one character from input buffer

	mov	bx,input_ptr

	cmp	bx,blksize

	jne	get_char1

	call	read_block

	mov	bx,0

get_char1:

	mov	al,[input_buffer bx]

	inc	bx

	mov	input_ptr,bx

	ret

get_char endp	



put_char proc	near		;put one character into output buffer

	mov	bx,output_ptr

	mov	[output_buffer bx],al

	inc	bx

	mov	output_ptr,bx

	cmp	bx,blksize	;buffer full yet?

	jne	put_char1	;no,jump

	call	write_block	;yes,write the block

	ret			;return CY as status code

put_char1:

	clc			;return CY clear for OK status

	ret

put_char endp



read_block proc near

	mov	bx,input_handle ;read first block of input

	mov	cx,blksize

	mov	dx,offset input_buffer

	mov	ah,3fh

	int	21h

	jnc	read_block1	;jump if no error status

	mov	ax,0		;simulate a zero length read if error

read_block1:			

	cmp	ax,blksize	;was full buffer read in?

	je	read_block2	;yes,jump

	mov	bx,ax		;no, store End-of-File mark

	mov	byte ptr [input_buffer bx],eof

read_block2:

	xor	ax,ax		;initialize input buffer pointer

	mov	input_ptr,ax	

	ret

read_block endp



write_block proc near		;write blocked output (blksize bytes)

	mov	dx,offset output_buffer

	mov	cx,blksize

	mov	bx,output_handle

	mov	ah,40h

	int	21h

	xor	bx,bx		;initialize pointer to blocking buffer

	mov	output_ptr,bx

	cmp	ax,blksize	;was correct length written?

	jne	write_block1	;no,disk must be full

	clc			;yes,return CY=0 indicating all OK

	ret

write_block1:			;disk is full, return CY =1

	stc			;as error code

	ret

write_block endp



init_buffs proc near

	call	read_block	;read 1st block of input

	xor	ax,ax		;initialize pointer to output

	mov	output_ptr,ax	;output blocking buffer

	ret

init_buffs endp



flush_buffs proc near		;write any data in output buffer to disk

	mov	cx,output_ptr

	or	cx,cx

	jz	flush_buffs1	;jump,buffer is empty

	mov	bx,output_handle

	mov	dx,offset output_buffer

	mov	ah,40h

	int	21h

	cmp	ax,output_ptr	;was write successful?

	jnz	flush_buffs2	;no,jump

flush_buffs1: 

	clc			;yes,return CY=0 for

	ret			;success flag

flush_buffs2:			;disk was full so write failed,

	stc			;return CY=1 as error flag

	ret

flush_buffs endp



sign_on proc	near		;print sign-on message

	mov	dx,offset msg6	;title...

	mov	ah,9

	int	21h

	mov	dx,offset msg7	;input file:

	mov	ah,9

	int	21h

	mov	dx,offset input_name

	call	pasciiz

	mov	dx,offset msg8	;output file:

	mov	ah,9

	int	21h

	mov	dx,offset output_name

	call	pasciiz

	mov	dx,offset msg9

	mov	ah,9

	int	21h

	ret

sign_on	endp



pasciiz	proc	near		;call DX=offset of ASCIIZ string

	mov	bx,dx		;which will be printed on standard output

pasciiz1:

	mov	dl,[bx]

	or	dl,dl

	jz	pasciiz9

	cmp	dl,'A'

	jb	pasciiz2

	cmp	dl,'Z'

	ja	pasciiz2

	or	dl,20h

pasciiz2:

	mov	ah,2

	int	21h

	inc	bx

	jmp	pasciiz1

pasciiz9:

	ret

pasciiz endp



cseg	ends





data	segment	para public 'DATA'



input_name	db	64 dup (0)	;buffer for input filespec

output_name	db	64 dup (0)	;buffer for output filespec	



input_handle	dw	0		;token returned by PCDOS

output_handle	dw	0		;token returned by PCDOS



input_ptr	dw	0		;pointer to input blocking buffer

output_ptr	dw	0		;pointer to output blocking buffer



outfile_ext	db 	'.CLN',0	;extension for filtered file



column		dw	0		;column count for tab processing



msg1		db	cr,lf

		db	'Cannot find input file.'

		db	cr,lf,'$'



msg2		db	cr,lf

		db	'Failed to open output file.'

		db	cr,lf,'$'



msg3		db	cr,lf

		db	'File processing completed'

		db	cr,lf,'$'



msg4		db	cr,lf

		db	'Missing file name.'

		db	cr,lf,'$'



msg5		db	cr,lf

		db	'Disk is full.'

		db	cr,lf,'$'



msg6		db	cr,lf

		db	'Clean Word Processing File'

		db	cr,lf

		db	'Copyright (c) 1983 Laboratory Microsystems Inc.'

		db	cr,lf,'$'



msg7		db	cr,lf,'Input file:   $'



msg8		db	cr,lf,'Output file:  $'



msg9		db	cr,lf,'$'





input_buffer	db	blksize dup (?)	;buffer for deblocking of data

					;from input file



output_buffer	db	blksize dup (?)	;buffer for blocking of data

					;sent to output file



data 	ends	





stack	segment	para stack 'STACK'

	db	64 dup (?)

stack	ends



	end	clean