title File Compare Routine for MSDOS 2.0
;-----------------------------------------------------------------------;
; Revision History: ;
; ;
; V1.0 Rev. 0 10/27/82 M.A.Ulloa ;
; ;
; Rev. 1 10/28/82 M.A.Ulloa ;
; Changed switch names and added binary compare using the ;
; -b switch. ;
; ;
; Rev. 1 11/4/82 A.R. Reynolds ;
; Messages in separate module ;
; Also added header for MSVER ;
; ;
; Rev. 2 11/29/82 M.A. Ulloa ;
; Corrected sysntex problem with references to [base...] ;
; ;
; Rev. 3 01/03/83 M.A. Ulloa ;
; Stack is right size now. ;
; ;
;-----------------------------------------------------------------------;
FALSE equ 0
TRUE equ 0ffh
buf_size equ 4096 ;buffer size
;-----------------------------------------------------------------------;
; Description ;
; ;
; FC [-# -b -w -c] <file1> <file2> ;
; ;
; Options: ;
; ;
; -# were # is a number from 1 to 9, how many lines have to ;
; before the end of an area of difference ends. ;
; ;
; -b will force a binary comparation of both files. ;
; ;
; -w will cause all spaces and tabs to be compressed to a single ;
; space before comparing. All leading and trailing spaces and/or tabs ;
; in a line are ignored. ;
; ;
; -c will cause FC to ignore the case of the letters. ;
; ;
; Algorithm for text compare: (The one for binary comp. is trivial) ;
; ;
; The files are read into two separate buffers and the ;
; comparation starts. If two lines are found to be different in the ;
; two buffers, say line i of buffer A and line j of buffer B differ. ;
; The program will try to match line i with line j+1, then with line ;
; j+2 and so on, if the end of buffer is reached the program will ;
; recompact the buffer and try to read more lines into the buffer, if ;
; no more lines can be read because either the buffer is full, or the ;
; end of file was reached, then it will revert and try to match line ;
; j of buffer B to line i+1, i+2 and so on of buffer A. If an end of ;
; buffer is found, it tries to refill it as before. If no matches are ;
; found, then it will try to match line i+1 of buffer A to line j+1, ;
; j+2, j+3, .... of buffer B, if still no matches are found, it reverts ;
; again and tries to match line j+1 of buffer B with lines i+2, i+3,... ;
; of buffer A. And so on till a match is found. ;
; ;
; Once a match is found it continues chcking pairs of lines till ;
; the specified number are matched (option #, 3 by default), and then ;
; it prints the differing area in both files, each followed by the ;
; first line matched. ;
; ;
; If no match is found (the difference is bigger than the buffer) ;
; a "files different" message is printed. ;
; ;
; If one of the files finishes before another the remaining ;
; portion of the file (plus any ongoing difference) is printed out. ;
; ;
;-----------------------------------------------------------------------;
subttl Debug Macros
page
m_debug macro str
local a,b
jmp short b
a db str,0dh,0ah,"$"
b: pushf
push dx
mov dx,offset code:a
push ds
push cs
pop ds
push ax
mov ah,9h
int 21h
pop ax
pop ds
pop dx
popf
endm
m_bname macro
local a0,a1,a2,b1,b2
jmp short a0
b1 db "------ buffer 1",0dh,0ah,"$"
b2 db "------ buffer 2",0dh,0ah,"$"
a0: pushf
push dx
cmp bx,offset dg:buf1
je a1
mov dx,offset code:b2
jmp short a2
a1: mov dx,offset code:b1
a2: push ds
push cs
pop ds
push ax
mov ah,9h
int 21h
pop ax
pop ds
pop dx
popf
endm
page
.SALL
.XLIST
include dossym.asm
.LIST
subttl General Definitions
page
CR equ 0dh
LF equ 0ah
;-----------------------------------------------------------------------;
; Offsets to buffer structure
; For text comparations:
fname equ 0 ;file name ptr
fname_len equ 2 ;file name length
handle equ 4 ;handle
curr equ 6 ;current line ptr
lst_curr equ 8 ;last current line ptr
fst_sinc equ 10 ;first line towards a sinc ptr
fst_nosinc equ 12 ;first line out of sinc ptr
dat_end equ 14 ;ptr to last char of the buffer
buf_end equ 16 ;pointer to the end of the buffer
buf equ 18 ;pointer to the buffer
; For binary comparations:
by_read equ 6 ;bytes read into buffer
;-----------------------------------------------------------------------;
code segment word
code ends
const segment public word
const ends
data segment word
data ends
dg group code,const,data
subttl Constants Area
page
const segment public word
make db "MAUlloa/Microsoft/V10"
rev db "2"
;----- CAREFULL WITH PRESERVING THE ORDER OF THE TABLE -----
opt_tbl equ $ ;option table
flg_b db FALSE
flg_c db FALSE
flg_s db FALSE
flg_w db FALSE
;-----------------------------------------------------------
ib_first1 db FALSE ;flags used when comparing lines
ib_first2 db FALSE ; while in ignore white mode.
m_num dw 3 ;lines that have to match before
; reporting a match
mtch_cntr dw 0 ;matches towards a sinc
mode db FALSE ;If false then trying to match a line
; from buf1 to lines in buf2. If true
; then viceversa.
sinc db TRUE ;Sinc flag, start IN SINC
bend db 0 ;binary end of file flag, 0= none yet,
; 1= file 1 ended, 2= file 2 ended
base dd 0 ;base address of files for binary
; comparations
bhead_flg db false ;true if heading for binary comp.
; has been printed already.
;-----------------------------------------------------------
bp_buf equ $ ;binary compare difference template
bp_buf1 db 8 dup(' ') ;file address
db 3 dup(' ')
bp_buf2 db 2 dup(' ') ;byte of file 1
db 3 dup(' ')
bp_buf3 db 2 dup(' ') ;byte of file 1
db CR,LF
bp_buf_len equ $ - bp_buf ;length of template
;-----------------------------------------------------------
EXTRN vers_err:byte,opt_err:byte,opt_e:byte,crlf:byte,opt_err_len:byte
EXTRN bhead_len:byte
EXTRN found_err_pre:byte,found_err_pre_len:byte
EXTRN found_err_post:byte,found_err_post_len:byte
EXTRN read_err_pre:byte,read_err_pre_len:byte
EXTRN read_err_post:byte,read_err_post_len:byte
EXTRN file_err:byte,file_err_len:byte
EXTRN bf1ne:byte,bf1ne_len:byte,bf2ne:byte,bf2ne_len:byte,bhead:byte
EXTRN int_err:byte,int_err_len:byte,dif_err:byte,dif_err_len:byte
EXTRN args_err:byte,args_err_len:byte,fname_sep:byte,fname_sep_len:byte
EXTRN diff_sep:byte,diff_sep_len:byte
const ends
subttl Data Area
page
data segment word
com_buf db 128 dup(?) ;command line buffer
;----- Buffer structures
buf1 dw 11 dup(?)
buf2 dw 11 dup(?)
; two extra for guard in case of need to insert a CR,LF pair
b1 db buf_size dup(?)
end_b1 db 2 dup(?)
b2 db buf_size dup(?)
end_b2 db 2 dup(?)
data ends
subttl MAIN Routine
page
code segment
assume cs:dg,ds:nothing,es:nothing,ss:stack
start:
jmp short FCSTRT
;-----------------------------------------------------------------------;
; Check version number
HEADER DB "Vers 1.00"
FCSTRT:
;Code to print header
; PUSH DS
; push cs
; pop ds
; MOV DX,OFFSET DG:HEADER
; mov ah,std_con_string_output
; int 21h
; POP DS
mov ah,get_version
int 21h
cmp al,2
jge vers_ok
mov dx,offset dg:vers_err
mov ah,std_con_string_output
int 21h
push es ;bad vers, exit a la 1.x
xor ax,ax
push ax
badvex proc far
ret
badvex endp
vers_ok:
push cs
pop es
assume es:dg
;-----------------------------------------------------------------------;
; Copy command line
mov si,80h ;command line address
cld
lodsb ;get char count
mov cl,al
xor ch,ch
inc cx ;include the CR
mov di,offset dg:com_buf
cld
rep movsb
push cs
pop ds
assume ds:dg
;-----------------------------------------------------------------------;
; Initialize buffer structures
mov bx,offset dg:buf1
mov word ptr [bx].buf,offset dg:b1
mov word ptr [bx].buf_end,offset dg:end_b1
mov bx,offset dg:buf2
mov word ptr [bx].buf,offset dg:b2
mov word ptr [bx].buf_end,offset dg:end_b2
;-----------------------------------------------------------------------;
; Process options
mov ah,char_oper
mov al,0
int 21h ;get switch character
mov si,offset dg:com_buf
cont_opt:
call kill_bl
jc bad_args ;arguments missing
cmp al,dl ;switch character?
jne get_file ;no, process file names
cld
lodsb ;get option
call make_caps ;capitalize option
mov bx,offset dg:opt_tbl
cmp al,'B'
je b_opt
cmp al,'C'
je c_opt
cmp al,'S'
je s_opt
cmp al,'W'
je w_opt
cmp al,'1' ;a number option?
jb bad_opt
cmp al,'9'
ja bad_opt
and al,0fh ;a number option, convert to binary
xor ah,ah ;zero high nibble
mov [m_num],ax
jmp short cont_opt
bad_opt: ;a bad option:
push dx ; save switch character
mov [opt_e],al ; option in error
mov dx,offset dg:opt_err
mov cl,opt_err_len
call prt_err ; print error message
pop dx
jmp short cont_opt ; process rest of options
b_opt:
mov di,0
jmp short opt_dispatch
c_opt:
mov di,1
jmp short opt_dispatch
s_opt:
mov di,2
jmp short opt_dispatch
w_opt:
mov di,3
opt_dispatch:
mov byte ptr dg:[bx+di],TRUE ;set the corresponding flag
jmp short cont_opt
bad_args:
mov dx,offset dg:args_err
mov cl,args_err_len
jmp an_err
;-----------------------------------------------------------------------;
; Get the file names
get_file:
dec si ;adjust pointer
call find_nonb ;find first non blank in com. buffer
jc bad_args ;file (or files) missing
mov byte ptr [di],0 ;nul terminate
mov dx,si ;pointer to file name
mov bx,offset dg:buf1
mov word ptr [bx].fname,dx ;save pointer to file name
mov word ptr [bx].fname_len,cx ;file name length
mov ah,open
mov al,0 ;open for reading
int 21h
jc bad_file
mov word ptr [bx].handle,ax ;save the handle
mov si,di
inc si ;point past the nul
call kill_bl ;find other file name
jc bad_args ;a CR found: file name missing
dec si ;adjust pointer
call find_nonb
mov byte ptr [di],0 ;nul terminate the file name
mov dx,si
mov bx,offset dg:buf2
mov word ptr [bx].fname,dx ;save pointer to file name
mov word ptr [bx].fname_len,cx ;file name length
mov ah,open
mov al,0 ;open for reading
int 21h
jc bad_file
mov word ptr [bx].handle,ax ;save the handle
jmp short go_compare
bad_file:
cmp ax,error_file_not_found
je sj01
mov dx,offset dg:int_err
mov cl,int_err_len
jmp short an_err
sj01:
push cx ;save file name length
mov dx,offset dg:found_err_pre
mov cl,found_err_pre_len
call prt_err
pop cx
mov dx,si ;pointer to file name length
call prt_err
mov dx,offset dg:found_err_post
mov cl,found_err_post_len
an_err:
call prt_err
mov al,-1 ;return an error code
mov ah,exit
int 21h
;-----------------------------------------------------------------------;
; CHECK COMPARE MODE
go_compare:
cmp [flg_b],true ;do we do a binary comparation?
je bin_compare
jmp txt_compare
subttl Binary Compare Routine
page
;-----------------------------------------------------------------------;
; COMPARE BUFFERS IN BINARY MODE
bin_compare:
;----- Fill in the buffers
mov bx,offset dg:buf1 ;pointer to buffer structure
mov dx,word ptr[bx].buf ;pointer to buffer
mov si,dx ;save for latter comparation
call read_dat ;read into buffer
jc bad_datj ;an error
mov word ptr[bx].by_read,AX ;save ammount read
push ax ;save for now
mov bx,offset dg:buf2 ;pointer to buffer structure
mov dx,word ptr[bx].buf ;pointer to buffer
mov di,dx ;save for comparation
call read_dat ;read into buffer
bad_datj: jc bad_dat ;an error
mov word ptr[bx].by_read,AX ;save ammount read
pop cx ;restore byte count of buffer1
cmp ax,cx ;compare byte counts
ja morein_b2
jb morein_b1
or ax,ax ;the same ammount, is it 0?
jne go_bcomp ;no,compare
jmp go_quit ;yes, all done....
morein_b2:
mov [bend],1 ;file 1 ended
jmp short go_bcomp
morein_b1:
mov [bend],2 ;file 2 ended
mov cx,ax
;----- Compare data in buffers
go_bcomp:
mov ax,word ptr [base] ;load base addrs. to AX,BX pair
mov bx,word ptr [base+2]
add bx,cx ;add to base num. of bytes to
adc ax,0 ; compare.
mov word ptr [base],ax ;save total
mov word ptr [base+2],bx
next_bcomp:
cld
jcxz end_check
repz cmpsb ;compare both buffers
jz end_check ;all bytes match
push cx ;save count so far
push ax
push bx
inc cx
sub bx,cx ;get file address of bytes that
sbb ax,0 ; are different.
call prt_bdif ;print difference
pop bx
pop ax
pop cx ;restore on-going comparation count
jmp short next_bcomp
bnot_yet:
jmp bin_compare
end_check:
cmp [bend],0 ;have any file ended yet?
je bnot_yet ;no, read in more data
cmp [bend],1 ;yes, was it file 1?
je bf1_ended ;yes, data left in file 2
mov dx,offset dg:bf1ne
mov cl,bf1ne_len
jmp short bend_mes
bf1_ended:
mov dx,offset dg:bf2ne
mov cl,bf2ne_len
bend_mes:
xor ch,ch
call prout
jmp go_quit
subttl Text Compare Routine
page
;-----------------------------------------------------------------------;
; Fill in the buffers
bad_dat:
mov dx,offset dg:file_err
mov cl,file_err_len
jmp an_err
txt_compare:
mov bx,offset dg:buf1
mov dx,word ptr [bx].buf
mov word ptr [bx].fst_nosinc,dx
mov word ptr [bx].curr,dx
call fill_buffer
jc bad_dat
mov bx,offset dg:buf2
mov dx,word ptr [bx].buf
mov word ptr [bx].fst_nosinc,dx
mov word ptr [bx].curr,dx
call fill_buffer
jc bad_dat
;-----------------------------------------------------------------------;
; COMPARE BUFFERS IN TEXT MODE
another_line:
call go_match ;try to match both current lines
jc sj02 ;a match
jmp no_match ;no match, continue....
sj02:
cmp byte ptr[sinc],true ;are we in SINC?
je sj04
mov ax,[mtch_cntr]
or ax,ax ;first line of a possible SINC?
jnz sj03
mov bx,offset dg:buf1
mov word ptr [bx].fst_sinc,si ;yes, save curr line buffer 1
mov bx,offset dg:buf2
mov word ptr [bx].fst_sinc,di ;save curr line buffer 2
sj03:
inc ax ;increment match counter
mov [mtch_cntr],ax ;save number of matches
cmp m_num,ax ;enough lines matched for a SINC?
jne sj04 ;not yet, match some more
mov [sinc],true ;yes, flag we are now in sinc
call print_diff ;print mismatched lines
;-----------------------------------------------------------------------;
; Advance current line pointer in both buffers
sj04:
mov bx,offset dg:buf1
call adv_b
jnc sj05
jmp no_more1
sj05:
mov word ptr[bx].curr,si
mov bx,offset dg:buf2
call adv_b
jnc sj051
jmp no_more2
sj051:
mov word ptr[bx].curr,si
jmp another_line ;continue matching
;-----------------------------------------------------------------------;
; Process a mismatch
no_match:
cmp [sinc],true ;are we in SINC?
jne sj06
mov [sinc],false ;not any more....
mov bx,offset dg:buf1
mov word ptr [bx].fst_nosinc,si ;save current lines
mov word ptr [bx].lst_curr,si
mov bx,offset dg:buf2
mov word ptr [bx].fst_nosinc,di
mov word ptr [bx].lst_curr,di
sj06:
mov [mtch_cntr],0 ;reset match counter
cmp [mode],true
je sj09
;----- MODE A -----
mov bx,offset dg:buf2
call adv_b ;get next line in buffer (or file)
jc sj08 ;no more lines in buffer
sj07:
mov word ptr [bx].curr,si
jmp another_line
sj08:
mov [mode],true ;change mode
mov si,word ptr [bx].lst_curr
mov word ptr [bx].curr,si
mov bx,offset dg:buf1
mov si,word ptr [bx].lst_curr
mov word ptr [bx].curr,si
call adv_b ;get next line
jc no_more1 ;no more lines fit in buffer 1
mov word ptr [bx].lst_curr,si
jmp short sj10
;----- MODE B -----
sj09:
mov bx,offset dg:buf1
call adv_b ;get next line in buffer (or file)
jc sj11 ;no more lines in buffer
sj10:
mov word ptr [bx].curr,si
jmp another_line
sj11:
mov [mode],false
mov si,word ptr [bx].lst_curr
mov word ptr [bx].curr,si
mov bx,offset dg:buf2
mov si,word ptr [bx].lst_curr
mov word ptr [bx].curr,si
call adv_b ;get next line
jc no_more2 ;no more lines fit in buffer 2
mov word ptr [bx].lst_curr,si
jmp sj07
;-----------------------------------------------------------------------;
; Process end of files
no_more1:
cmp ax,0 ;end of file reached?
jz xj1
jmp dif_files ;no, difference was too big
xj1:
cmp [sinc],true ;file1 ended, are we in SINC?
je xj3
jmp no_sinc
xj3:
mov bx,offset dg:buf2
call adv_b ;advance current line in buf2
jnc xj5
jmp go_quit ;file2 ended too, terminate prog.
xj5:
;----- File 1 ended but NOT file 2
mov bx,offset dg:buf1
call print_head
mov bx,offset dg:buf2
call print_head
call print_all ;print the rest of file2
jmp go_quit
no_more2:
cmp ax,0 ;end of file reached?
jz xj2
jmp dif_files ;no, difference was too big
xj2:
cmp [sinc],true ;file1 ended, are we in SINC?
je xj4
jmp no_sinc
xj4:
mov bx,offset dg:buf1
call adv_b ;advance current line in buf2
jnc xj6
jmp go_quit ;file2 ended too, terminate prog.
xj6:
;----- File 2 ended but NOT file 1
mov bx,offset dg:buf1
call print_head
call print_all ;print the rest of file1
mov bx,offset dg:buf2
call print_head
jmp go_quit
no_sinc:
mov bx,offset dg:buf1
call print_head
call print_all
mov bx,offset dg:buf2
call print_head
call print_all
jmp go_quit
dif_files:
mov dx,offset dg:dif_err
mov cl,dif_err_len
jmp an_err
go_quit:
mov al,0
mov ah,exit
int 21h
subttl Subroutines: make caps
page
;-----------------------------------------------------------------------;
; CAPIALIZES THE CHARACTER IN AL ;
; ;
; entry: ;
; AL has the character to Capitalize ;
; ;
; exit: ;
; AL has the capitalized character ;
; ;
; Called from MAIN and go_match ;
;-----------------------------------------------------------------------;
make_caps:
cmp al,'a'
jb sa1
cmp al,'z'
jg sa1
and al,0dfh
sa1: ret
subttl Subroutines: kill_bl
page
;-----------------------------------------------------------------------;
; Get rid of blanks in command line. ;
; ;
; entry: ;
; SI points to the first character on the line to scan. ;
; ;
; exit: ;
; SI points to the next char after the first non-blank ;
; char found. ;
; Carry Set if a CR found ;
; ;
; modifies: ;
; SI and AX ;
; ;
; Called from MAIN ;
;-----------------------------------------------------------------------;
kill_bl:
cld ;increment
sb1: lodsb ;get rid of blanks
cmp al,' '
je sb1
cmp al,9
je sb1
cmp al,CR
clc ;assume not a CR
jne sb2
stc ;a CR found, set carry
sb2: ret
subttl Subroutines: find_nonb
page
;-----------------------------------------------------------------------;
; Find the first non-blank in a line ;
; ;
; entry: ;
; SI points to the line buffer ;
; ;
; exit: ;
; DI pointer to the first blank found (incl. CR) ;
; CX character count of non-blanks ;
; Carry Set if a CR was found ;
; ;
; modifies: ;
; AX ;
; ;
; Called from MAIN ;
;-----------------------------------------------------------------------;
find_nonb:
push si ;save pointer
xor cx,cx ;zero character count
cld
sc1:
lodsb
cmp al,' '
je sc2
cmp al,9
je sc2
cmp al,CR
je sc2
inc cx ;inc character count
jmp short sc1
sc2:
dec si
mov di,si
pop si
cmp al,CR
jne sc3
stc
ret
sc3:
clc
ret
subttl Subroutines: prt_bdif
page
;-----------------------------------------------------------------------;
; Print a binary difference ;
; ;
; entry: ;
; AX,BX file address of diference ;
; SI pointer to one past byte in buffer1 ;
; DI pointer to one past byte in buffer2 ;
; ;
; modifies: ;
; AX, DX and CX ;
; ;
; called from bin_compare ;
;-----------------------------------------------------------------------;
prt_bdif:
cmp [bhead_flg],true ;have we peinted head yet?
je bhead_ok
mov [bhead_flg],true ;no, set flag
push ax ;print heading
mov dx,offset dg:bhead
mov cl,bhead_len
xor ch,ch
call prout
pop ax
bhead_ok:
mov dx,di ;conver file address
mov di,offset dg:bp_buf1
push ax
mov al,ah
call bin2hex
pop ax
call bin2hex
mov al,bh
call bin2hex
mov al,bl
call bin2hex
mov di,offset dg:bp_buf2 ;convert byte from file 1
mov al, byte ptr[si-1]
call bin2hex
mov di,offset dg:bp_buf3 ;convert byte from file 2
push si
mov si,dx
mov al, byte ptr[si-1]
pop si
call bin2hex
mov di,dx ;print result
mov dx,offset dg:bp_buf
mov cx,bp_buf_len
call prout
ret
subttl Subroutines: bin2hex
page
;-----------------------------------------------------------------------;
; Binary to ASCII hex conversion ;
; ;
; entry: ;
; AL byte to convert ;
; DI pointer to were the two result ASCII bytes should go ;
; ;
; exit: ;
; DI points to one past were the last result byte whent ;
; ;
; modifies: ;
; AH and CL ;
; ;
; Called from prt_bdif ;
;-----------------------------------------------------------------------;
bin2hex:
mov cl,4
ror ax,cl ;get the high nibble
and al,0fh ;mask of high nible
call pt_hex
rol ax,cl ;get the low nibble
and al,0fh ;mask....
pt_hex:
cmp al,0ah ;is it past an A ?
jae pasta
add al,30h
jmp short put_hex
pasta:
add al,37h
put_hex:
stosb ;place in buffer
ret
subttl Subroutines: go_match
page
;-----------------------------------------------------------------------;
; Match current lines ;
; ;
; exit: ;
; Carry set if the match reset otherwise ;
; SI Current line of buff1 ;
; DI Current line of buff2 ;
; ;
; ;
; modifies: ;
; AX,BX,CX,DX and BP ;
; ;
; Called from txt_compare ;
;-----------------------------------------------------------------------;
go_match:
mov bx,offset dg:buf1
mov si,word ptr[bx].curr
push si
mov bp,si ;save line pointer
call find_eol
mov dx,cx ;save length of line
mov bx,offset dg:buf2
mov si,word ptr[bx].curr
push si
mov di,si
call find_eol
cmp cx,dx ;compare lengths
jne sd1 ;they do not match
mov si,bp ;restore line pointer
jcxz sd4 ;both length = 0, they match
push cx ;save the length
cld
repz cmpsb ;compare strings
pop cx ;restore the length
jz sd4 ;they match
sd1:
cmp [flg_w],true ;do we ignore multiple whites?
je ib_compare ;yes, go compare
cmp [flg_c],true ;do we ignore case differences?
je ic_compare ;yes, go compare
sd3:
clc ;they don't match
jmp short sd5
sd4:
stc
sd5:
pop di ;curr2
pop si ;curr1
ret
page
;-----------------------------------------------------------------------;
; Compare ignoring case differences.
ic_compare:
pop di ;get pointer to lines
pop si
push si ;re-save pointers
push di
sd8:
mov al,byte ptr [si] ;get next char. of first line
call make_caps
mov bl,al ;save capitalized char
mov al,byte ptr [di] ;get next chra. of second line
call make_caps
cmp al,bl
jne sd3 ;they do not match....
inc si ;advance pointers
inc di
loop sd8 ;loop for the line lengths
jmp short sd4 ;they match
page
;-----------------------------------------------------------------------;
; Compare compressing whites and ignoring case differences if
; desired too.
ib_compare:
mov [ib_first1],true ;we start by the first char in the
mov [ib_first2],true ; in the lines.
pop di ;get pointer to lines
pop si
push si ;re-save pointers
push di
sd9:
mov al,byte ptr [si] ;get next char. of first line
call isa_white ;is it a white?
jnc sd12 ;no, compare....
sd10:
mov al,byte ptr [si+1] ;peek to next,
call isa_white ; it is a white too?
jnc sd11
inc si ; yes,
jmp short sd10 ; compress all whites to a blank
sd11:
cmp [ib_first1],true ;is this the first char. of the line?
jne sd111 ;no, it stays a white
inc si ;ignore the white
jmp short sd12
sd111:
cmp al,CR ;is this the last char. of the line
jne sd112 ;no, it stays a white
inc si ;yes, ignore the whites
jmp short sd12
sd112:
mov al,' ' ;no more whites found
sd12:
cmp [ib_first1],true ;is this the first char. of the line?
jne sd121 ;no, continue
mov [ib_first1],false ;yes, reset the flag
sd121:
cmp [flg_c],true ;do we ignore case?
jne sd122 ;no,....
call make_caps
sd122:
mov bl,al ;save char
mov al,byte ptr [di] ;get next chra. of second line
call isa_white
jnc sd15
sd13:
mov al,byte ptr [di+1] ;peek to next as before
call isa_white
jnc sd14
inc di
jmp short sd13
sd14:
cmp [ib_first2],true ;is this the first char. of the line?
jne sd141 ;no, it stays a white
inc di ;ignore the white
jmp short sd15
sd141:
cmp al,CR ;is this the last char. of the line
jne sd142 ;no, it stays a white
inc si ;yes, ignore the whites
jmp short sd15
sd142:
mov al,' '
sd15:
cmp [ib_first2],true ;is this the first char. of the line?
jne sd151 ;no, continue
mov [ib_first2],false ;yes, reset the flag
sd151:
cmp [flg_c],true ;do we ignore case?
jne sd152 ;no,....
call make_caps
sd152:
cmp al,bl
je sd153
jmp sd3 ;they do not match....
sd153:
cmp al,CR ;have we reached the end?
jne sd154 ;no, continue....
jmp sd4 ;yes, they match
sd154:
inc si ;no, advance pointers
inc di
jmp sd9 ;loop for the line lengths
isa_white:
cmp al,' ' ;is it a space?
je sdx1
cmp al,09h ;is it a tab?
je sdx1
clc ;if not a white return with carry clear
ret
sdx1:
stc ;is a white return with carry set
ret
page
;-----------------------------------------------------------------------;
find_eol:
xor cx,cx ;zero count
cld
sd6:
lodsb
cmp al,CR
je sd7
inc cx
jmp short sd6
sd7:
ret
subttl Subroutines: adv_b
page
;-----------------------------------------------------------------------;
; Get the next line in the buffer ;
; ;
; It will attempt to get the next current line from the buffer ;
; if it fails, it will force a refill, and if some data is read in ;
; then it will return the next current line. ;
; ;
; entry: ;
; BX pointer to buffer structure ;
; ;
; exit: ;
; SI pointer to next line (if any) ;
; Carry set if no more lines available. If carry set then: ;
; AX End Code: 0 = end of file reached ;
; 1 = no room in buffer for a line ;
; ;
; modifies: ;
; CX,DX and DI ;
; ;
; Called from txt_compare ;
;-----------------------------------------------------------------------;
adv_b:
call get_nextl
jc se1
ret
se1:
call refill
jnc se0
ret
se0:
call get_nextl
ret
subttl Subroutines: get_nextl
page
;-----------------------------------------------------------------------;
; Returns the next line in a buffer ;
; (next from current or next from pointer) ;
; ;
; entry: ;
; BX pointer to buffer structure ;
; (SI pointer to line, if calling get_next) ;
; ;
; exit: ;
; SI pointer to next line ;
; Carry set if no more lines available ;
; ;
; modifies: ;
; DI and CX ;
; ;
; Called from adv_b and print_diff (in the case of get_next) ;
;-----------------------------------------------------------------------;
get_nextl:
mov si,word ptr [bx].curr
get_next:
mov cx,word ptr [bx].dat_end
sub cx,si
mov di,si
mov al,LF
cld
repnz scasb
mov si,di ;pointer to next line
jnz se2 ;not found
clc
ret
se2:
inc si ;point past the LF
stc
ret
subttl Subroutines: refill
page
;-----------------------------------------------------------------------;
; Refill a buffer ;
; ;
; It will refill a buffer with data from the corresponding ;
; file. It will first recompact the buffer to make room for the new ;
; data. If in SINC then it will move the current line to the top of ;
; the buffer, and read the data from the end of this line till the ;
; end of the buffer. ;
; If NOT in SINC then it will recompact the buffer by moving ;
; all lines between the first to go out of SINC till the current line ;
; to the top of the buffer, and then reading data after the current ;
; line. ;
; When recompacting the buffer it relocates all pointers to ;
; point to the new locations of the respective lines. ;
; Some of the pointers may be pointing to meaningless locations ;
; before the relocation, and consecuently they will be pointing to ;
; even less meaningfull locations after relocation. ;
; After reading the data it normalizes the buffer to make sure ;
; that no partially full lines are present at the end of the buffer. If ;
; after recompacting and reading some character it is found that the ;
; characters read do not constitute a full line, then it will return ;
; with an error code. It will also return with an error code if it ;
; attempts to read past the end of file. ;
; ;
; entry: ;
; BX pointer to buffer structure ;
; ;
; exit: ;
; Carry set if no chars read into the buffer. If carry set then: ;
; AX End Code: 0 = end of file reached ;
; 1 = no room in the buffer for a line ;
; ;
; modifies: ;
; CX,DX,SI and DI ;
; ;
; Called from adv_b ;
;-----------------------------------------------------------------------;
refill:
;----- Calculate ammount to move & pointer relocation factor.
cmp [sinc],true
jne sf1
mov si,word ptr [bx].curr
jmp short sf2
sf1:
mov si,word ptr [bx].fst_nosinc
sf2:
mov di,word ptr [bx].buf
mov cx,word ptr [bx].dat_end
mov dx,si ;calculate pointer relocation factor
sub dx,di ;DX = factor
jz sf3 ;no room in buffer
sub cx,si ;calculate ammount of data to move
inc cx ;CX = ammount
;----- Move data
cld ;auto decrement
rep movsb
;----- Relocate pointers
sub word ptr [bx].curr,dx
sub word ptr [bx].lst_curr,dx
sub word ptr [bx].fst_sinc,dx
sub word ptr [bx].fst_nosinc,dx
sub word ptr [bx].dat_end,dx
sf3:
mov dx,word ptr [bx].dat_end
inc dx ;empty part starts here
;----- fill the buffer
call fill_buffer
ret
subttl Subroutines: fill_buffer
page
;-----------------------------------------------------------------------;
; Fill the data buffers ;
; ;
; It will fill the buffer from the pointer to the end of buffer ;
; and normalize the buffer. ;
; ;
; entry: ;
; BX pointer to buffer structure ;
; DX pointer to buffer (or part of buffer) ;
; ;
; exit: ;
; Carry set if no chars read into the buffer. If carry set then: ;
; AX End Code: 0 = end of file reached ;
; 1 = no room in the buffer for a line ;
; ;
; modifies: ;
; AX,CX,DX and DI ;
; ;
; Called from txt_compare and refill ;
;-----------------------------------------------------------------------;
fill_buffer:
push bx
call read_dat ;get data
jc bad_read
or ax,ax ;zero chars read?
jz rd_past_eof
call nor_buf
mov di,cx ;save normalized char. count
mov bp,dx ;save data end for now
;----- seek for old partial line
or ax,ax ;is the seek value = 0 ?
jz sg1 ;yes, do not seek
mov dx,ax
neg dx
mov cx,-1
mov al,1 ;seek from current position
mov ah,lseek
int 21h
jc bad_read ;error mesage (BX already in stack)
sg1:
mov cx,di ;restore normalized char count.
or cx,cx ;char count = 0 due to normalization?
jz no_room
pop bx
mov word ptr [bx].dat_end,bp
clc
ret
bad_read:
mov dx,offset dg:read_err_pre
mov cl,read_err_pre_len
call prt_err ;print error message
pop bx
mov dx,word ptr[bx].fname
mov cx,word ptr[bx].fname_len
call prt_err ;print file name
mov dx,offset dg:read_err_post
mov cl,read_err_post_len
jmp an_err
no_room:
mov ax,1
jmp short sg2
rd_past_eof:
xor ax,ax
sg2:
pop bx
stc
ret
subttl Subroutines: read_dat
page
;-----------------------------------------------------------------------;
; ;
; entry: ;
; DX pointer to data area (buffer or part of buffer) ;
; ;
; exit: ;
; AX character count or error code (from DOS read) ;
; Carry set if error condition ;
; ;
; modifies: ;
; BX and CX ;
; ;
; Called from fill_buffer, print_all and bin_compare ;
;-----------------------------------------------------------------------;
read_dat:
mov cx,word ptr [bx].buf_end
mov bx,word ptr [bx].handle
sub cx,dx ;ammount to read to buff1
mov ah,read
int 21h
ret
subttl Subroutines: nor_buf
page
;-----------------------------------------------------------------------;
; Normalize buffers so they do not have partially full ;
; lines at the end. If character count is less than the buffer size ;
; then it checks that the last line is terminated by a CR,LF pair. ;
; If it is not it inserts a CR,LF at the end. It returns a seek value ;
; for the buffer corresponding to the number of characters in the ;
; incomplete line at the end of the buffer (if any). This can be used ;
; to start reading from the beggining of the incomplete line on next ;
; time the buffer is loaded. ;
; ;
; ENTRY: ;
; DX buffer pointer ;
; AX character count read ;
; CX character count requested ;
; ;
; EXIT: ;
; DX pointer to last char in buffer (normalized) ;
; CX character count (normalized) ;
; AX seek value ;
; ;
; MODIFIES: ;
; DI ;
; ;
; Called from fill_buffer ;
;-----------------------------------------------------------------------;
nor_buf:
mov di,dx
add di,ax
dec di ;points to last char in buffer
cmp ax,cx ;were all chars. requested read?
je sm7 ;yes, buffer full
cmp byte ptr[di],1ah ;terminated with a ^Z ?
jne sm1
dec di ;point to previous character
dec ax ;decrement character count
sm1: cmp byte ptr[di],lf ;is last char a LF?
je sm6
cmp byte ptr[di],cr ;is it a CR then?
je sm5
add ax,2 ;two more chars in buffer
inc di
sm2: mov byte ptr[di],cr
sm3: inc di
mov byte ptr[di],lf
sm4: mov cx,ax ;new character count
mov dx,di ;pointer to last char
xor ax,ax ;seek = 0
ret
sm5:
inc ax ;one more char in buffer
jmp short sm3
sm6:
cmp byte ptr[di-1],cr ;is previous char a CR?
je sm4
inc ax ;no, one more char in buffer
jmp short sm2
sm7:
push ax ;save char count
mov cx,ax
mov al,LF
std
repnz scasb ;search for last LF
pop ax ;restore char count
jnz bad_line ;none found, line too big
inc di ;point to last LF
mov dx,di
inc cx ;ammount of chars in buffer
sub ax,cx ;seek value
ret
bad_line: ;full line not possible, return
mov dx,di ; with AX=count, CX=0 and DX=
ret ; old last char in buffer pointer.
subttl Subroutines: print_diff
page
;-----------------------------------------------------------------------;
; print the difference between buffers ;
; ;
; It will print the mismatched lines. First it prints a heading ;
; with the first file name, then the lines that differ from file 1, ;
; then a heading with the second file name, and then the lines that ;
; differ in file 2 . ;
; The lines that differ are considered to start from fst_nosinc ;
; till fst_sinc. ;
; ;
; Called from txt_compare ;
;-----------------------------------------------------------------------;
print_diff:
mov bx,offset dg:buf1
call print_head ;print heading for file 1
mov dx,word ptr [bx].fst_nosinc
mov si,word ptr [bx].fst_sinc
call get_next ;get pointer to next line
mov cx,si
sub cx,dx ;get character count
call prout
mov bx,offset dg:buf2
call print_head ;print heading for file 1
mov dx,word ptr [bx].fst_nosinc
mov si,word ptr [bx].fst_sinc
call get_next ;get pointer to next line
mov cx,si
sub cx,dx ;get character count
call prout
mov dx,offset dg:diff_sep
mov cl,diff_sep_len
xor ch,ch
call prout ;print difference separator
ret
subttl Subroutines: print_head
page
;-----------------------------------------------------------------------;
; Print heading for difference ;
; ;
; entry: ;
; BX pointer to buffer structure ;
; ;
; modifies: ;
; AX,CX and DX ;
; ;
; Called from txt_compare and print_diff ;
;-----------------------------------------------------------------------;
print_head:
mov dx,offset dg:fname_sep
mov cl,fname_sep_len
xor ch,ch
call prout
mov dx,word ptr [bx].fname
mov cx,word ptr [bx].fname_len
call prout
mov dx,offset dg:CRLF
mov cx,2
call prout
ret
subttl Subroutines: print_all
page
;-----------------------------------------------------------------------;
; Print the rest of a file ;
; ;
; If in SINC it will print the file from the fst_nosinc line ;
; till the end of the file. If NOT in SINC then it will print from ;
; the current line of the buffer to the end of the file. ;
; ;
; entry: ;
; BX pointer to buffer structure ;
; ;
; modifies: ;
; AX,CX and DX ;
; ;
; Called from txt_compare ;
;-----------------------------------------------------------------------;
print_all:
cmp [sinc],true ;are we in SINC?
jne so1
mov dx,word ptr [bx].curr
jmp short so2
so1:
mov dx,word ptr [bx].fst_nosinc
so2:
mov cx,word ptr [bx].dat_end
inc cx
prt_again:
sub cx,dx ;ammount of data to write
call prout ;write it out
;----- Read more data to the buffer
push bx ;save pointer to buffer struct
mov dx,word ptr [bx].buf
call read_dat
jnc so3
jmp bad_read ;print error (BX in stack)
so3:
or ax,ax ;zero chars read?
jne so4
pop bx ;all done writting
ret
so4:
pop bx
mov cx,word ptr [bx].buf_end
jmp short prt_again ;print next buffer full
subttl Subroutines: prout and prt_err
page
;-----------------------------------------------------------------------;
; ;
;-----------------------------------------------------------------------;
prout:
push bx
mov bx,stdout
mov ah,write
int 21h
pop bx
ret
;-----------------------------------------------------------------------;
; ;
;-----------------------------------------------------------------------;
prt_err:
push bx
xor ch,ch
jcxz retpbx
mov bx,stderr
mov ah,write
int 21h
retpbx:
pop bx
ret
code ends
page
stack segment stack
dw 128 dup(?)
stack ends
end start
�����������������������������������������������������������