page	74,132
	title	ZIPV - Display directory of ZIP files

; name: 	ZIPV, version 1, 7 March 1989
; copyright:	1989, for personal use only; may not be sold.
; author:	Vernon D. Buerg
;
; syntax:
;		ZIPV [filespec[.ZIP] [/p] [/b] [/c]
; where:
;    /p  pauses the display after a screen full
;    /b  suppresses display of d:\path information for bbs use
;    /c  displays ZIPfile and file comments and extra fields
;
; output:
;    - errorlevel returned:
;	0 - normal completion
;	1 - wrong DOS version
;	2 - no files found
;	3 - some invalid ZIP file(s) encountered
;
; notes:
;    - supports DOS 3 file sharing
;    - requires about 56k of memory, figure 64k for a .COM program
;    - assembled using SLR Systems OPTASM; you figure the JMPs for MASM
;    - handles self-extracting ZIP files (.EXE type)

	.xlist
print	macro	name			; display a field
	mov	dx,offset name
	call	prints
	endm

printl	macro	text			; display a literal
	local	txt,nxt
	mov	dx,offset txt
	call	prints
	jmp	nxt
txt	db	cr,lf,text
	db	stopper
nxt	equ	$
	endm

save	macro	reglist 		; save registers
	irp	reg, <reglist>
	push	reg
	endm
	endm

restore macro	reglist 		; restore registers
	irp	reg, <reglist>
	pop	reg
	endm
	endm
	.list

central_dir	struc			; from APPNOTES.TXT
cd_sig		db	02h,01h,4bh,50h ; signature
cdver_made	db	0,0		; version made by
cdver_ext	db	0,0		; version to extract
cd_flag 	db	0,0		; general purpose bit flag
cd_method	dw	0		; compression method
cd_mod_time	dw	0		; last mod time
cd_mod_date	dw	0		; last mod date
cd_crc		dw	0,0		; crc-32
cd_comp_size	dw	0,0		; compressed size
cd_true_size	dw	0,0		; uncompressed size
cd_flnm_len	dw	0		; filename length
cd_extra_len	dw	0		; extra field length
cd_comment_len	dw	0		; file comment length
cd_disk_start	dw	0		; disk number start
cd_intfile_attr dw	0		; internal file attributes
cd_extfile_attr dw	0,0		; external file attributes
cd_local_offset dw	0,0		; file offset of local header
					; variable length fields follow (boo-hiss)
central_dir	ends

cd_filename	equ	size central_dir; filename (variable size)
cd_extra	equ	size central_dir; extra field (variable size)
cd_comment	equ	size central_dir; file comment (variable size)

central_end	struc			; length 22+n
ce_sig		db	06h,05h,4bh,50h ; signature
ce_disk_number	dw	0		; number of this disk
ce_disk_start	dw	0		; disk number with central dir start
ce_disk_entries dw	0		; entries in central dir on this disk
ce_entries	dw	0		; total entries in central dir
ce_size 	dw	0,0		; size of central dir
ce_offset	dw	0,0		; offset to central dir on this disk
ce_comment_len	dw	0		; length of zipfile comment
					; variable length fields follow (nerts)
central_end	ends

ce_comment	equ	size central_end; zipfile comment (variable size)

dtantry struc				; DOS Data Transfer Area
dtarsvd db	21 dup (0)		;  reserved
dtaattr db	0			;  attribute
dtatime dw	0			;  update time
dtadate dw	0			;  update date
dtasize dw	0,0			;  size bytes (lo,hi)
dtaname db	12 dup (' ')            ;  name and ext
	db	0,13,10,255		;  stopper and print
dtantry ends

	subttl	ZIPV - Mainline routines
	page

cseg	segment public para 'CODE'
	assume	cs:cseg, ds:cseg, ss:cseg, es:cseg
	org	100h

zipv	proc	far
	jmp	start			; skip around data

	subttl	--- constants, equates and data areas
	page

bel	equ	7			; honker
bs	equ	8			; backspace
tab	equ	9			; tabski
lf	equ	10			; Line Feed
cr	equ	13			; la Carriage Return
eof	equ	26			; end of file character
stopper equ	255			; ends print strings

	db	bs,bs,bs,'   '          ; overlay entry jmp for type

usage	db	cr,lf,	 'ZIPV Version 1.07 Copyright (c) 1989 Vernon D. Buerg'
	db	cr,lf,	 'For personal use only. May not be sold.'
	db	cr,lf,lf,'  Usage:  zipv [d:][\path\]filespec[.ZIP]  [/p] [/b] [/c]'
	db	cr,lf
	db	cr,lf,	 '  Where:  /P pauses after each screenful'
	db	cr,lf,	 '          /B suppresses display of d:\path'
	db	cr,lf,	 '          /C displays comments'
	db	cr,lf,stopper,eof

errlvl	db	0			; dos error level returned
opencod db	0			; open code for share
flags	db	255			; find-first return code

options db	0			; command options
b_parm	 equ	1			; /b -bbs display option
p_parm	 equ	2			; /p -pause at screen full
c_parm	 equ	4			; /c - display comments

stkptr	dw	0			; stack pointer upon entry
ce_ptr	dw	0			; offset to central_end dir record
ce_count dw	0			; count of entries in central dir

fileptr dw	filenm			; spot after d:\path
filehdl dw	0			; file handle

ziptitl db	cr,lf,'Archive:  ',stopper

zipname db	13 dup (0),0,stopper	; ZIP file name for heading

;	display lines for verbose

vhdr	db	cr,lf
	db	cr,lf,'Name          Length    Method     SF   Size now  Mod Date    Time    CRC-32 '
dashes	db	cr,lf,'============  ========  ========  ====  ========  =========  ======  ========'
	db	stopper

vline	db	cr,lf
vname	db	14 dup (' ')
vsize	db	'       0  '            ; acutal file size
vstyle	db	'          '            ; compression method
vfactor db	' xx%  '                ; compression factor
vlength db	10 dup (' ')            ; compressed length
vdate	db	'dd '                   ; creation date
 vmonth db	'mmm '
 vyear	db	'yy  '
 vtime	db	'hh:mm   '              ; creation time
 vcrc	db	'xxxxxxxx'              ; crc in hex
	db	stopper
len_vline equ	$-vline 		; length of print line

totsf	dw	0,0			; average stowage factor
totlen	dw	0,0			; total of file lengths
totsize dw	0,0			; total of file sizes
totmbrs dw	0			; total number of files

;	final totals line

vthdr	db	cr,lf,'*total'
 vtmbrs db	'        '
 vtsize db	8 dup (' '),'  '
	db	10 dup (' ')
 vtsf	db	'   %  '
 vtlen	db	8 dup (' ')
	db	cr,lf
	db	stopper
 sign	db	' '

vtotal	db	'*total'
ctitle	db	cr,lf,'Comment:  ',stopper
cextra	db	cr,lf,'Extra:    ',stopper

styles	db	'Stored  '              ; compression method names
	db	'Shrunk  '
	db	'Reduced1'
	db	'Reduced2'
	db	'Reduced3'
	db	'Reduced4'

hundred dw	100			; for computing percentages
months	db	'Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec '
	subttl	--- Mainline
	page

start:
	mov	sp,offset cs:stk_end	; local stack
	mov	stkptr,sp		; save for dos return

	mov	ah,30h			; get dos version
	int	21h			;
	cmp	al,2			; version 2 or later?
	jb	badver			; no, gotta quit
	cmp	al,3			; enough for share?
	jb	dos_okay		; no, open as-is
	mov	opencod,40h		; yes, add read-only

dos_okay:
	mov	bx,paras		; size of program
	mov	ah,4ah			; shrink allocated memory
	int	21h			; setblock function

	mov	di,offset filenm	; clear operands
	mov	cx,offset stk-filenm	;  and work areas
	mov	al,0			;
	rep	stosb			;

	subttl	--- gather command line parameters
	page

getparm:
	mov	si,82h			; Command tail
	sub	cx,cx			;
	or	cl,byte ptr -2[si]	; test parm length
	jz	getparms		; none, return as-is

sw1:	lodsb				; scan for switch
	cmp	al,'/'                  ;
	loopne	sw1			;
	or	cx,cx			; found one?
	jz	getparms		; no, done
	mov	byte ptr -1[si],cr	; yes, stop command line there
	jmp	sw2a			; and check next character

sw2:	lodsb				; Next character
	cmp	al,'/'                  ; Another switch?
	loopne	sw2			;
	jcxz	getparms		;

sw2a:	lodsb				; yes, get letter following
	and	al,0dfh 		; make upper case
	dec	cx			;
	jle	sw3			; missing switch

sw3:	cmp	al,'P'                  ; Pause?
	jne	sw4			;
	or	options,p_parm		;

sw4:	cmp	al,'B'                  ; BBS use
	jne	sw5			;
	or	options,b_parm		;

sw5:	cmp	al,'C'                  ; display Comments?
	jne	sw2			;
	or	options,c_parm		;
	jmp	sw2			; Try for another option

	subttl	--- Gather command operands
	page

;	copy first command line operand as ZIP selection filespec

getparms:
	mov	si,80h			; offset to command line
	sub	cx,cx			; its length
	or	cl,byte ptr [si]	; any operand?
	jnz	parm0			; no,
	print	usage			;  display usage
	jmp	zipv_exit		;   and quit

parm0:	inc	si			; point to operands
parm2:	lodsb				; strip leading blanks
	cmp	al,' '                  ;
	loope	parm2			;

	mov	di,offset filenm	; first operand target
	stosb				;
parm3:	lodsb				; copy filename
	cmp	al,cr			; end of name?
	je	parm4			;
	cmp	al,' '                  ; don't know why this is here
	je	parm4			;
	stosb				;
	loop	parm3			;
parm4:
	mov	si,offset filenm +75	; end of filename stuff
	mov	cx,76			;
	std				;
parm5:
	lodsb				;
	cmp	al,'/'                  ; funny path delimiter?
	je	parm6			;
	cmp	al,'\'                  ; normal path delimiter?
	je	parm6			;
	cmp	al,':'                  ; bumped into drive?
	je	parm6			;
	loop	parm5			;
	dec	si			;
parm6:
	cld				;
	add	si,2			; point to where filename goes
	mov	fileptr,si		; and save for later

;	add default ZIP extension if necessary

	mov	si,fileptr		; start of filespec
	mov	cx,13			;
parm10:
	lodsb				;
	cmp	al,0			; end of name?
	je	parm11			;
	cmp	al,'.'                  ; got extension?
	je	parm12			;
	loop	parm10			;
parm11:
	mov	di,si			; ptr to end of name
	dec	di			;
	mov	ax,'Z.'                 ; default extension
	stosw				;
	mov	ax,'PI'                 ;
	stosw				;
parm12:

	subttl	--- Find matching files
	page
;
;	set up next matching file name

process:
	mov	dx,offset dta		; set local dta for murkers
	mov	ah,1ah			;
	int	21h			;

	mov	dx,offset filenm	; find first matching file
	sub	cx,cx			; normal attribute
	mov	ah,4eh			;
	int	21h			;
	mov	flags,al		; indicate find-first status
	or	ax,ax			; any return code?
	jz	gotfirst		; nope, continue
	jmp	nofiles 		; yup, abort

;	set up next matching file name

gotfirst:
	mov	si,offset dta+30	; point to filename found
	mov	di,fileptr		; and overlay old name
	mov	cx,13			;
gotfirst1:
	lodsb				; next char
	stosb				;
	cmp	al,0			; end of name?
	loopne	gotfirst1		;
	mov	al,0FFh 		; append stoppers
	stosb				;

	mov	si,offset dta+30	; copy filename for heading
	mov	di,offset zipname	;
	mov	cx,13			; asciiz filename
gotfirst2:
	lodsb				; next char
	stosb				;
	cmp	al,0			; end of name?
	loopne	gotfirst2		;
	mov	al,0FFh 		; append stoppers
	stosb				;

process_loop:				; open the file
	mov	dx,offset filenm	; point to d:\path\filename
	mov	ah,3dh			; open function
	mov	al,opencod		; share parameters
	int	21h			; issue open
	jc	open_err1		; oops
	mov	filehdl,ax		; save file handle

	call	posfile 		; position and read central directory

	call	close			; release the ZIP file

	call	dispdir 		; display directory contents

getnext:
	mov	ah,4fh			; get next file name
	int	21h			;
	jc	alldone 		;
	or	ax,ax			;
	jz	gotfirst		;
alldone:
	jmp	zipv_exit		; all done

	subttl	--- Display directory entries
	page

ecount	dw	0			; entries on current disk

dispdir proc	near
	sub	ax,ax			; reset totals counters
	mov	totmbrs,ax		;
	mov	totsize,ax		;
	mov	totsize+2,ax		;
	mov	totlen,ax		;
	mov	totlen+2,ax		;
	mov	totsf,ax		;

;  display titles

	mov	ax,ce_count		; number of entries
	mov	ecount,ax		; save as line counter
	print	ziptitl 		;
	test	options,b_parm		; want short filename?
	jz	dispdir1		; no
	print	zipname 		; show short name
	jmp	dispdir2		;
dispdir1:
	print	filenm			; show full name

;  display comments

dispdir2:
	test	options,c_parm		; want them?
	jz	disp3			; no
	mov	si,ce_ptr		; offset to ce dir
	mov	cx,ce_comment_len[si]	;
	jcxz	disp3			; if none
	print	ctitle			; yes, add heading item
	lea	dx,ce_comment[si]	; point to comment
	mov	ah,40h			; write to file
	mov	bx,1			; using std out
	int	21h			;

disp3:
	print	vhdr			; show headings
	mov	bx,offset cdir		; first header in central directory
dispdir_loop:
	mov	di,offset vname 	; clear print line
	mov	cx,14			;
	mov	al, ' '                 ;
	rep	stosb			;

	call	stowage 		; compute stowage factor

disp_style:
	mov	si,cd_method[bx]	; compression method code
	mov	cl,3			;
	shl	si,cl			; time style length
	add	si,offset styles	; list of method names
	mov	di,offset vstyle	;
	mov	cx,8			;
	rep	movsb			;

disp_crc:
	mov	di,offset vcrc		; format crc-32 value
	mov	ax,cd_crc+2[bx] 	; first word
	call	cvh			;
	mov	ax,cd_crc[bx]		; second word
	call	cvh			;

	mov	ax,cd_mod_time[bx]	; last modified time
	call	gettime 		; format it

	mov	ax,cd_mod_date[bx]	; last modified date
	call	getdate 		; format it

	mov	ax,word ptr cd_true_size[bx]   ; actual file size
	mov	dx,word ptr cd_true_size+2[bx] ; high word
	add	totsize,ax		; accumulate total size
	adc	totsize[2],dx		;
	mov	si,offset vsize 	;
	call	format			;

	mov	ax,word ptr cd_comp_size[bx]   ; compressed file size
	mov	dx,word ptr cd_comp_size+2[bx] ; high word
	add	totlen,ax		; accumulate total length
	adc	totlen[2],dx		;
	mov	si,offset vlength	;
	call	format			;

	mov	cx,cd_flnm_len[bx]	; file name length
	lea	si,cd_filename[bx]	;  and offset
	mov	di,offset vname 	;   to print line
	rep	movsb			;

	inc	totmbrs 		; total files count
	print	vline			; display an entry

;  process extra field

dispdir_extra:
	test	options,c_parm		; want comments?
	jz	dispdir_next		;  no
	mov	cx,cd_extra_len[bx]	; extra field
	jcxz	dispdir_comment 	; if none
	mov	si,cx			; compute offset
	add	si,bx			;  to extra field
	add	si,cd_flnm_len[bx]	;
	print	cextra			;
	lea	dx,cd_comment[si]	; point to comment
	mov	ah,40h			; write to file
	mov	bx,1			; using std out
	int	21h			;

;  display copmment field

dispdir_comment:
	mov	cx,cd_comment_len[bx]	; comment field
	jcxz	dispdir_next		; if none
	mov	si,cx			; compute offset
	add	si,bx			;  to comments
	add	si,cd_flnm_len[bx]	;
	add	si,cd_extra_len[bx]	;
	print	ctitle			;
	lea	dx,cd_comment[si]	; point to comment
	mov	ah,40h			; write to file
	mov	bx,1			; using std out
	int	21h			;

; set-up for next entry

dispdir_next:
	mov	cx,size central_dir	; minimum cd entry size
	add	cx,cd_flnm_len[bx]	;  plus file name length
	add	cx,cd_extra_len[bx]	;   plus extra field length
	add	cx,cd_comment_len[bx]	;    plus comment field length
	add	bx,cx			;     to point to next entry
	dec	ecount			;
	jnz	dispdir_loop		; continue

	page
;
;	display totals for current file

dir_totals:
	print	dashes			; separate totals line

	mov	ax,totsize		; total file sizes
	mov	dx,totsize[2]		; high word
	mov	si,offset vtsize	;
	call	format			;

	mov	ax,totlen		; compressed file size
	mov	dx,totlen[2]		; high word
	mov	si,offset vtlen 	;
	call	format			;

	mov	ax,totmbrs		; count of members
	sub	dx,dx			;
	mov	si,offset vtmbrs-2	;
	call	format			;

	mov	cx,totlen		; compressed file size
	mov	dx,totlen[2]		; high word
	mov	bx,totsize		; actual file size
	mov	ax,totsize[2]		; high word
	call	stow_total		;

	mov	si,offset vtotal	; say *total
	mov	di,offset vthdr+2	;
	mov	cx,6			;
	rep	movsb			;

	print	vthdr			; display totals
	ret				;
dispdir endp

	subttl	--- Position file
	page
;
;	Position to end of ZIP file less central directory size

margin	dw	size central_end	; how far before ce to read

posfile proc	near			;
	mov	margin,size central_end ; how far before ce dir to point

posfile_point:
	mov	bx,filehdl		; get file handle
	mov	cx,dta.dtasize[2]	; high word of size
	mov	dx,dta.dtasize		; low word of size
	sub	dx,margin		; less size of central
	sbb	cx,0			;   directory end record
	jl	posfile_start		; if small file
	mov	ax,4200h		; move to central end directory
	int	21h			; lseek function
	jmp	read_ce 		;

posfile_start:
	mov	ax,dta.dtasize		; use file size
	mov	margin,ax		;  as amount to position
	jmp	posfile_point		;

;  read central-directory-end record

read_ce:
	mov	cx,margin		; how much to read (pos before eof)
	mov	dx,offset cde		; central end dir area
	mov	ah,3fh			;
	int	21h			;
	jc	open_err2		; failed
	cmp	ax,cx			; read it all?
	jne	open_err3		; nope

;  search end of file for cde signature

	mov	bx,offset cde+1 	; point to centerl end dir record
	mov	cx,margin		; look back this far
	sub	cx,size central_end-1	;
	add	bx,cx			;
search_loop:
	mov	si,bx			; next cde byte
	dec	bx			;
	cmp	word ptr [si],4b50h	; check signature
	jne	search_loop1		;
	cmp	word ptr 2[si],0605h	;
	je	read_cd 		; found it
search_loop1:
	loop	search_loop		; continue search
	add	margin,256		; not yet,
	jmp	posfile_point		;  back up some more

; re-position to central-directory

read_cd:
	mov	ce_ptr,si		; save pointer to c_e dir start
	mov	ax,ce_disk_entries[si]	; number of entries
	mov	ce_count,ax		;  and save for later
	mov	dx,ce_offset[si]	; offset to central directory
	mov	cx,ce_offset+2[si]	;
	mov	bx,filehdl		; get file handle
	mov	ax,4200h		; move file pointer
	int	21h			; returns dx:ax position

; read the central directory until end-of-file

	mov	bx,dta.dtasize[2]	; get file size in bx:cx
	mov	cx,dta.dtasize		;  to compute
	sub	cx,ax			;   size of
	sbb	bx,dx			;    central dir to eof
	mov	bx,filehdl		; get file handle
	mov	ah,3fh			; for reading
	mov	dx,offset cdir		; central dir end area
	int	21h			;
	jc	open_err4		; failed
	cmp	ax,cx			; read it all?
	jne	open_err5		; nope

	ret				;
posfile endp

	page
;
;	compute stowage; reduce the size/length to word values

stowage proc	near			; compute stowage factor
	push	bx			; save dir pointer

	mov	cx,word ptr cd_comp_size[bx]	 ; compressed file size
	mov	dx,word ptr cd_comp_size+2[bx]	 ; high word

	mov	ax,word ptr cd_true_size+2[bx]	 ; high word
	mov	bx,word ptr cd_true_size[bx]	 ; actual file size
	mov	si,offset vfactor-5	; target area
	jmp	stow51			;

stow_total:
	push	bx			; entry for totals calculation
	mov	si,offset vtsf-5	; target area

stow51: or	ax,ax			; big number?
	jz	stow52			; nope, can use it
	shr	ax,1			; yup, divide by two
	rcr	bx,1			;
	shr	dx,1			;
	rcr	cx,1			;
	jmp	stow51			;

stow52:
	mov	ax,bx			; low word of actual size
	mov	sign,' '                ;
	cmp	ax,cx			; zip member is larger?
	jb	stow520 		;
	sub	ax,cx			; amount saved
	jmp	stow56			;
stow520:
	sub	ax,cx			;
	neg	ax			;
	mov	sign,'-'                ;
stow56:
	mul	hundred 		; to percentage
	add	ax,50			;
	adc	dx,0			; round up percent
	or	bx,bx			; empty file?
	jnz	stow53			;
	mov	ax,100			;
	jmp	stow54			;

stow53: div	bx			;
stow54: sub	dx,dx			;
	cmp	ax,100			; archive fouled?
	jbe	stow55			;
	sub	ax,ax			;
stow55:
	call	format			;
	mov	al,sign 		; get + or -
	mov	byte ptr [si],al	;
	pop	bx			; restore dir pointer
	ret				; return to caller
stowage endp				;

	subttl	--- subroutines
	page
;
;	close the file

close	proc	near			;
	mov	bx,filehdl		; file handle
	or	bx,bx			; is it open
	jz	close_done		;
	mov	ah,3eh			; close function
	int	21h			;
	sub	bx,bx			;
close_done:
	mov	filehdl,bx		; indicate closed
	ret				;
close	endp				;

	page
;
;	print string like int 21h function 9

pause	db	cr,lf,'... more?$'
backup	db	cr,9 dup (8),'$'
linecnt db	0		; line counter for pause
pagecnt db	23		; lines per screen

prints	proc	near			; dx has offset to string

	test	options,p_parm		; want pausing?
	jz	ps1			; no, skip next

	save	<bx,cx,dx,si>		; save work regs
	mov	al,linecnt		;
	cmp	al,pagecnt		; end of screen?
	jbe	ps0			; not yet
	mov	dx,offset pause 	; yup, say so
	mov	ah,9			;
	int	21h			;
	mov	ah,0			; get a key
	int	16h			;
	mov	dx,offset backup	; over write pause prompt
	mov	ah,9			;
	int	21h			;
	mov	linecnt,0		; reset line counter
ps0:	restore <si,dx,cx,bx>		; restore work regs

ps1:	save	<si,bx,cx>		; save work regs
	mov	si,dx			;
	sub	cx,cx			;
ps2:	lodsb				;
	cmp	al,stopper		; ending hex ff?
	je	ps8			;
	inc	cx			; incr text length
	cmp	al,lf			; another line?
	jne	ps2			;
	inc	linecnt 		;
	jmp	ps2			;

ps8:	mov	ah,40h			; write to file
	mov	bx,1			; using std out
	int	21h			;

ps9:	restore <cx,bx,si>		; recover registers
	ret				;
prints	endp

	page
;
;	format the time

time	record	hour:5,min:6,sec:5	; packed time

gettime proc	near			; format the date
	mov	di,offset vtime 	;
	push	ax			; save date
	and	ax,mask hour		; get hour part
	mov	cl,hour 		; bits to shift
	shr	ax,cl			;
	call	cnvrt1			;
	stosw				;
	mov	al,':'                  ;
	stosb				;

gt3:	pop	ax			; get the time back
	and	ax,mask min		; get min part
	mov	cl,min			; bits to shift
	call	cnvrt			;
	stosw				;
gottime:ret				;
gettime endp

cnvrt	proc	near			; convert to ascii
	shr	ax,cl			;
cnvrt1: aam				; make al into bcd
	or	ax,'00'                 ; and to ascii
	xchg	al,ah			;
cnvrtd: ret				;
cnvrt	endp

	page
;
;	format the date

date	record	yr:7,mo:4,dy:5		; packed date

getdate proc	near			; format the date
	push	bx			; save cd pointer
	or	ax,ax			; is it zero?
	jz	gotdate 		;
	push	ax			; save date
	and	ax,mask yr		; get year part
	mov	cl,yr			; bits to shift
	call	cnvrt			;
	mov	di,offset vyear 	;
	or	al,'8'                  ; adjust for base year
	stosw				;

	pop	bx			; get the date back
	push	bx			; save it
	and	bx,mask mo		; get month part
	mov	cl,mo			; bits to shift
	shr	bx,cl			;
	add	bx,bx			; form month table index
	add	bx,bx			;
	lea	si,word ptr months-4[bx];
	mov	cx,3			;
	mov	di,offset vmonth	;
	rep	movsb			;

	pop	ax			; get the date back
	and	ax,mask dy		; get day part
	mov	cl,dy			; bits to shift
	call	cnvrt			;
	mov	di,offset vdate 	;
	stosw				;
gotdate:				;
	pop	bx			; restore cd pointer
	ret				; back to caller
getdate endp

	page
;
;	 format 4-byte binary into ASCII for display

ddptr	dw	0			;

format	proc	near			; formats a 32 bit integer in dx:ax
	save	<bp,bx,di,si>		;  to ds:si
	mov	ddptr,si		; addr of target field
	mov	di,dx			; routine uses di:si
	mov	si,ax			;
	call	printdd 		;
	restore <si,di,bx,bp>		;
	ret				;

printdd:
	xor	ax,ax			; zero out the
	mov	bx,ax			; working
	mov	bp,ax			; registers.
	mov	cx,32			; # bits of precision
j1:	shl	si,1			;
	rcl	di,1			;
	xchg	bp,ax			;
	call	j6			;
	xchg	bp,ax			;
	xchg	bx,ax			;
	call	j6			;
	xchg	bx,ax			;
	adc	al,0			;
	loop	j1			;
	mov	cx,1710h		;
	mov	ax,bx			;
	call	j2			;
	mov	ax,bp			;
j2:	push	ax			;
	mov	dl,ah			;
	call	j3			;
	pop	dx			;
j3:	mov	dh,dl			;
	shr	dl,1			; move high
	shr	dl,1			;  nibble to
	shr	dl,1			;   the low
	shr	dl,1			;    position
	call	j4			;
	mov	dl,dh			;
j4:	and	dl,0fh			; mask low nibble
	jz	j5			; if not zero
	mov	cl,0			;
j5:	dec	ch			;
	and	cl,ch			;
	or	dl,'0'                  ; fold in ascii zero
	sub	dl,cl			;
	mov	bx,ddptr		;
	mov	[bx],dl 		; ptr to next target field
	inc	ddptr			;
	ret				;

j6:	adc	al,al			;
	daa				;
	xchg	al,ah			;
	adc	al,al			;
	daa				;
	xchg	al,ah			;
	ret				;
format	endp

	page
;
;	convert binary word to two hex characters

hexchar db	'0123456789ABCDEF'      ; for conversion

cvh	proc	near			; convert 16-bit binary word in ax
	save	<bx,cx,dx>		; to hex ASCII string at ds:di
	sub	bx,bx			;
	mov	dx,ax			; save 16-bits

	mov	bl,dh			; third nibble
	mov	cl,4			;
	shr	bl,cl			;
	mov	al,hexchar[bx]		;
	stosb				;

	mov	bl,dh			; last nibble
	and	bl,0fh			;
	mov	al,hexchar[bx]		;
	stosb				;

	mov	bl,dl			; first nibble
	mov	cl,4			;
	sub	bh,bh			;
	shr	bl,cl			; isolate
	mov	al,hexchar[bx]		;
	stosb				;

	mov	bl,dl			; second nibble
	and	bl,0fh			; isolate
	mov	al,hexchar[bx]		;
	stosb				;
	restore <dx,cx,bx>		; restore registers
	ret				; return

cvh	endp

	subttl	--- Errors and exits
	page
;
;	error messages and exits

errmsg	db	cr,lf,"ERROR! ",bel,stopper
errmsg1 db	"Unable to open ",stopper
errmsg2 db	"Reading central end directory: ",stopper
errmsg3 db	"Central end directory incomplete: ",stopper
errmsg4 db	"Reading central directory: ",stopper
errmsg5 db	"Central directory incomplete: ",stopper

open_err1:
	mov	dx,offset errmsg1	; display message
	jmp	zipv_error		;   and quit

open_err2:
	mov	dx,offset errmsg2	; display message
	jmp	zipv_error		;   and quit

open_err3:
	mov	dx,offset errmsg3	; display message
	jmp	zipv_error		;   and quit

open_err4:
	mov	dx,offset errmsg4	; display message
	jmp	zipv_error		;   and quit

open_err5:
	mov	dx,offset errmsg5	; display message
	jmp	zipv_error		;   and quit

nofiles:
	printl	'No file(s) found '     ; display message
	mov	errlvl,2		; set return code
	jmp	zipv_exit		;   and quit

badver:
	printl	"DOS 2.0 or later is required."
	mov	errlvl,1		; set return code
	jmp	zipv_exit		;   and quit

zipv_error:
	mov	sp,cs:stkptr		; insure stack pointer
	mov	errlvl,3		; return error code
	push	dx			;
	print	errmsg			; make some noise
	pop	dx			;
	call	prints			; display error message
	print	filenm			;  with file name
	cmp	flags,255		; processed any files?
	jne	getnext 		; yes, try some more

zipv_exit:
	mov	sp,cs:stkptr		; insure stack pointer
	mov	al,errlvl		; get error level
	mov	ah,4ch			; exit
	int	21h			;

	subttl	--- data areas
	page

filenm	equ	$			; command line filespec supplied

dta	equ	filenm+80		; dos data transfer area

cde	equ	dta+48			; central directory end record
					; with room for 8k of comments
cdir	equ	cde+(size central_end)+(8*1024) ; central directory

stk	equ	cdir+ (52*1024) 	; and what's left as room for comments

stk_end equ	stk+256 		; local stack

paras	equ	(stk_end+256-cseg)/16	; paragraphs in module

zipv	endp
	end	zipv