; * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
; *								  *
; *			     D S T A T S			  *
; *								  *
; *	      ZCPR3 Disk/User Statistics Display Utility	  *
; *								  *
; *				 by				  *
; *			     Terry Hazen			  *
; *			21460 Bear Creek Road			  *
; *		      Los Gatos, CA 95030-9429			  *
; *								  *
; *		   Voice.......... (408) 354-7188		  *
; *		   Zee-Machine.... (408) 245-1420		  *
; *		   Ladera Znode... (310) 670-9465		  *
; *								  *
; * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
;
;
; Revision History
; ----------------
;
; 11/11/93	Now displays complete label filenames, making it easier
;   v1.6	to identify labels differing only in filetype.
;			- Terry Hazen
;
; 05/27/93	Fixed a data module number bug causing incorrect file
;   v1.5	sizes for files larger than 512k.
;			- Terry Hazen
;
; 01/16/93	Fixed a bug in directory size calculation with 1k block
;   v1.4	sizes.	Changed 'Disk capacity' message to 'Net disk space'
;		for greater clarity, since the size shown is total disk
;		size minus the directory size.	Added 'Directory size'
;		display.  Help screen filename now displayed correctly
;		under GO.  Added language-dependent text overlay.
;			- Terry Hazen
;
; 07/12/92	Turns off diskmap function when operating under ZSDOS20+
;   v1.3	and gets disk free space using ZSDOS20+ DOS call.
;			- Terry Hazen
;
; 08/10/91	Changed the old 'P' option letter in the option parser
;   v1.2	to 'D' (like the help screen said it should be!)
;			- Terry Hazen
;
; 07/22/91	Changed disk capacity display from maximum (DSM) to net
;   v1.1	capacity (DSM minus the disk directory space).	Added
;		display of maximum disk directory entries.  Added space
;		used to each user area display line.  Added disk free
;		space to Free: summary line.
;			- Terry Hazen
;
; 03/30/91	Initial release.
;   v1.0		- Terry Hazen
;
;=======================================================================
;
; DSTATS displays disk space and user statistics and the disk allocation
; bitmap.  It is for CP/M 2.2 ZCPR3 systems only and won't work with
; Z3PLUS.
;
; DSTATS was written to combine both disk and user statistics displays
; in one 2k utility.  I rename it to DISKMAP and use it to check for
; active user areas on hard disk partitions and to check on current
; disk directory statistics and allocation patterns.
;
; Many of the disk statistics routines in DSTATS are derived from
; DSKMAP10.  Many of the user statistics routines are derived from Gene
; Pizzetta's UMAP10, including the ZRDOS drive byte correction that Gene
; added in UMAP13.
;
;=======================================================================
;
; Revision
;
vers	equ	16
month	equ	11
day	equ	11
year	equ	93
;
; Equates
;
bell	equ	07
cr	equ	13
lf	equ	10
bdos	equ	05h
fcb1	equ	05ch
fcb2	equ	06ch
cmdbuf	equ	80h
;
no	equ	0
yes	equ	not no
off	equ	0
on	equ	0ffh
;
	public	envptr
;
	.request	zslib
	ext	gcomnam,comnam

	.request	z3lib
	ext	z3log

	.request	syslib
	ext	cin,cout,eprint,epstr,phldc,crlf,pfn3
	ext	dparams,blkshf,blkmsk,extent,blkmax,dirmax
;
entry:	jp	start
	db	'Z3ENV'		; ZCPR3 indentifier
	db	1		; Type 1 utility
envptr:	dw	0		; Z3ENV address
;
; Configuration area:
;
; Set to zero to take default lines and columns from the ZCPR3
; environment:
;
lins:	db	0		; Default screen lines for paging
cols:	db	50		; Default screen columns
;
; Default CFG filename and EFCB name buffer
;
cfg:	db	'DSTATS'	; 8 characters
	db	vers/10+'0',vers mod 10+'0'
	db	0		; Termination
;
pause:	db	on		; ON to pause before allocation map
amap:	db	on		; ON to display allocation map
lblflg:	db	'-'		; Label file flag character

;=======================================================================
;
	org	entry+20h	; Start of overlay
;
; Include language-dependent text message module
;
incl	 macro	msg1,n,msg2
	msg1&n&msg2
	 endm
	incl	<include dstats>,%vers,<.txt>
;
	org	z3txt+length	; Start of main program

;=======================================================================
;
; Program start
;
start:	ld	hl,data		; Initialize data area
	ld	de,data+1
	ld	bc,datalen
	ld	(hl),0		; With nulls
	ldir
;
zinit:	ld	ix,(envptr)	; Get environment address in IX
	ld	a,(ix+3)	; First character of ID string
	cp	'Z'
	jr	z,doschk	; Z-system
;
; If not ZCPR3, display error msg using DOS and quit
;
	ld	hl,err00$
	call	lhlhl		; Get offset
	ld	de,z3txt	; Get base
	add	hl,de		; Add it in
	ex	de,hl		; In DE
	ld	c,9		; BDOS print string
	jp	bdos
;
doschk:	ld	hl,fnam		; Put current filename in buffer
	call	gcomnam
	call	dispfn		; Display filename and version
	ld	hl,hlp00$	; Point to vers msg pointer
	call	pstr$
	call	eprint		; Display version number and make new line
	db	vers/10+'0','.',vers mod 10+'0',cr,lf,0
;
	ld	c,12
	call	bdos		; Get DOS ID
	ld	a,l
	cp	30h		; Check for Z3PLUS
	jr	c,doschk0	; Not Z3PLUS
;
	ld	(z3plus),a	; Set Z3PLUS flag
	xor	a
	jr	setm		; Skip option parsing
;
doschk0:ld	c,48
	call	bdos		; Get extended DOS ID
	ld	a,h
	cp	'S'		; ZSDOS?
	jr	nz,parse	; No, continue
;
	ld	a,l		; Get version number
	cp	20h
	jr	c,parse		; 1.x, continue
;
	ld	(z3plus),a	; Skip option parsing
	ld	(xdos),a	; And set free space flag
	xor	a
	jr	setm
;
; Parse for option requests
;
parse:	ld	a,(dcmd)	; Pause option?
	call	parscl
	ld	a,(pause)	; Get default pause flag
	jr	nz,setp		; Option not found
	cpl			; Yes, toggle flag
;
setp:	ld	(pausf),a	; Save pause flag
;
	ld	a,(mcmd)	; Map option?
	call	parscl
	ld	a,(amap)	; Get default map flag
	jr	nz,setm		; Option not found
	cpl			; Yes, toggle flag
;
setm:	ld	(mapf),a	; Save map flag
;
	ld	hl,fcb1+2
	ld	a,'/'		; Help request?
	cp	(hl)
	jp	nz,start1	; No
;
help:	ld	hl,hlp01$
	call	pstr$
	ld	a,(z3plus)
	or	a
	jr	z,pbm		; Not Z3PLUS or banked ZSDOS20+
;
	call	crlf
	jr	synt		; No bitmap under Z3PLUS
;
pbm:	ld	hl,hlp02$
	call	pstr$
	call	albit
;
synt:	ld	hl,hlp04$	; Syntax msg
	call	pstr$
	ld	hl,comnam	; Point to current filename
	call	dispfn		; Display it
;
options:ld	hl,hlp05$	; Dir msg
	call	pstr$
	ld	a,(z3plus)
	or	a
	jp	nz,crlf		; No options under Z3PLUS or ZSDOS20+
;
	ld	hl,hlp06$	; Options msg
	call	pstr$
;
	ld	a,(mcmd)	; Display bitmap option
	call	dash
	ld	a,(mapf)
	call	dont		; Don't msg
	ld	hl,hlp08$	; Display msg
	call	pstr$
	call	albit
;
	call	eprint
	db	'   ',0
	ld	a,(dcmd)	; Paging option
	call	dash
	ld	a,(pausf)
	call	dont
	ld	hl,hlp09$	; Pause msg
	call	pstr$
;
albit:	ld	hl,hlp03$	; And fall thru
;
; Display message whose pointer is at (HL)
;
pstr$:	push	af		; Save registers
	call	lhlhl		; Get message offset
	ld	de,z3txt
	add	hl,de		; Add in base
	call	epstr		; Display message
	pop	af
	ret
;
dont:	ld	hl,hlp07$	; Don't msg
	or	a
	jr	nz,pstr$
	ret
;
; Display option character and dash
;
dash:	call	cout
	call	eprint
	db	' - ',0
	ret

;-----------------------------------------------------------------------
;
start1:	ld	(stack),sp	; Save system stack pointer
	ld	sp,stack	; Point to local stack
	ld	hl,exit		; Save exit address on stack
	push	hl
;
	ld	a,(cols)	; Check if column value specified
	or	a
	jr	nz,getlin	; Use default value
;
	ld	a,(ix+49)	; Get columns from env
;
getlin:	ld	(col),a		; Save number of columns
	inc	hl
	ld	a,(lins)	; Check if line value specified
	or	a
	jr	nz,elin		; Use default value
;
	ld	a,(ix+51)	; Get text lines from env
;
elin:	ld	(lin),a		; Save number of lines
	sub	12
	ld	(lincnt),a	; Lines for first directory screen
;
	ld	a,(fcb1)	; Check if drive specified
	or	a
	jr	nz,getcd	; Yes
;
	ld	c,25
	call	bdos		; Get current drive
	inc	a		; Yes, make it A=1
	ld	(fcb1),a	; Save it
;
getcd:	ld	de,fcb1
	call	z3log
	ld	a,(fcb1+15)	; Valid directory?
	or	a
	jr	z,parm		; Yes
;
	ld	hl,err01$
	jp	pstr$
;
parm:	call	dparams
	ld	a,(blkshf)
	cp	7		; 3<BSH<7, else non-standard DPB
	jr	nc,baddpb
;
	cp	3
	jr	nc,blks
;
baddpb:	ld	hl,err02$
	jp	pstr$
;
blks:	ld	hl,msg02$	; Drive msg
	call	pstr$
	ld	a,(fcb1)
	add	'@'
	call	cout
	ld	a,':'		; Add colon
	call	cout
	call	crlf		; And new line
	ld	hl,msg03$	; Directory entries msg
	call	pstr$
;
	ld	hl,(dirmax)	; Get max directory entries
	push	hl		; Save it
	call	phldc
	call	crlf		; Add new line
	ld	hl,msg04$	; Directory size message
	call	pstr$
;
	pop	hl		; Restore max directory entries
	ld	b,5		; Divide by 32 to get directory size in k
;
divb:	srl	h
	rr	l
	djnz	divb
;
	ld	(dirsize),hl	; Save directory size
	ld	de,msg05$	; Block size msg
	call	kout		; Display it
;
	ld	a,(blkshf)	; Get BLS
	ld	b,a
	ld	hl,20h		; Initialize register
;
blksz:	add	hl,hl		; Get block size
	djnz	blksz
;
	ld	l,h
	ld	h,0
	ld	de,msg06$	; Net disk space msg
	call	kout		; Display block size
;
	ld	hl,(blkmax)	; Get DSM+1
	call	size		; HL=size in k
	ld	de,(dirsize)	; Get directory size
	or	a
	sbc	hl,de
	ld	(dskcap),hl	; Save disk capacity
	ld	de,msg07$	; Space used msg
	call	kout		; Display disk capacity
;
	ld	a,(z3plus)	; Z3PLUS?
	or	a
	jr	z,getav		; No, do it per CP/M2.2
;
; Get disk free space the Z3PLUS or ZSDOS20+ way...
;
	ld	a,(fcb1)	; Get disk byte (A=1)
	dec	a		; Make it A=0
	ld	e,a
	ld	c,46		; Free space
	call	bdos
;
	ld	a,(xdos)	; Banked ZSDOS20+?
	or	a
	jr	nz,zsdfs	; Yes
;
	call	blocks		; Get K in HL
	jr	fre04		; And save it
;
zsdfs:	ld	hl,80h		; Get number of K in HL
	ld	a,(hl)
	inc	hl
	ld	h,(hl)
	ld	l,a
	jr	fre04		; And save it
;
; Get disk free space the CP/M 2.2 way...
;
getav:	ld	c,27
	call	bdos		; Get ALLOC address
	ld	(alloc),hl	; Save it
	ld	b,h		; BC=ALLOC address
	ld	c,l
	ld	hl,(blkmax)	; Get DSM+1
	ld	de,0		; Initialize free block count
;
; At this point, we have:
;	BC=ALLOC address
;	DE=Free block count
;	HL=Max data block number
;
free:	push	bc		; Save alloc map pointer
	ld	a,(bc)		; Get allocation byte
	ld	b,8		; Process 8 blocks
;
fre01:	rla			; Rotate block bit into CARRY
	jr	c,fre02		; Bit=1, block allocated
	inc	de		; Bit=0, block not allocated
;
fre02:	ld	c,a		; Save remaining allocation bits in C
	dec	hl		; Count down number of disk blocks
	ld	a,l
	or	h
	jr	z,fre03		; No more space left
;
	ld	a,c		; Restore remaining allocation bits
	djnz	fre01		; Loop through 8 bits
;
	pop	bc		; Restore alloc map pointer
	inc	bc		; Point to next byte
	jr	free		; Process it
;
fre03:	pop	bc		; Clear stack
	ex	de,hl		; HL=free block count
	call	size		; HL=size in k
;
fre04:	ld	(freesp),hl	; Save free space
	push	hl		; Save a copy
	or	a		; Clear CARRY
	ex	de,hl		; DE=free space
	ld	hl,(dskcap)	; Total space
	sbc	hl,de		; Get disk capacity
	ld	(uspace),hl	; Save it
	ld	de,msg08$	; Remaining space msg
	call	kout		; Display disk capacity
	pop	hl		; HL=free space
	ld	de,msg09$	; Directory useage msg
	call	kout		; Display it
;
; Display directory stats
;
	call	line
	ld	a,'?'		; Replace drive byte in case ZRDOS
	ld	(wcfcb),a	;    zero'd it out (from UMAP13)
;
	ld	de,wcfcb
	ld	c,17		; Search first
	call	bdos
	cp	0ffh
	jr	z,prtit		; Do final display
;
	call	addit		; Add to table
;
dirlp:	ld	de,wcfcb	; Wildcard fcb
	ld	c,18		; Search next
	call	bdos
	cp	0ffh
	jr	z,prtit		; Do final display
;
	call	addit		; Add to table
	jr	dirlp
;
; Display file counts
;
prtit:	ld	b,0		; Start with user 0
	ld	iy,cnttbl	; Point to table (user 0)
;
prtlp:	ld	a,(iy+11)	; Any entries?
	or	(iy+12)
	jp	z,prtlp1	; (nope, don't print it)
;
	call	twosp
	ld	a,(fcb1)
	add	'@'
	call	cout
;
	ld	a,b		; Display user number
	push	bc
	ld	b,'0'-1
	cp	10
	jr	nc,prusr1
;
	push	af
	ld	a,'0'
	call	cout
	pop	af
	jr	prusrd
;
prusr1:	inc	b
	sub	10
	jr	nc,prusr1
;
	add	a,10
	ld	c,a
	ld	a,b
	call	cout
	ld	a,c
;
prusrd:	add	a,'0'
	call	cout
	pop	bc
;
	ld	a,':'
	call	cout
;
	push	bc
	ld	a,(iy)		; Check for label file
	or	a
	jr	nz,dfn		; Display filename
;
	ld	b,12 		; No file, pad with spaces
	call	spcs
	jr	lfpdun
;
dfn:	push	iy		; Table entry pointer in DE
	pop	de
	call	pfn3
;
lfpdun:	pop	bc
	ld	a,' '
	call	cout
	ld	l,(iy+13)	; Display number of files
	ld	h,(iy+14)
	call	phldc
;
	call	foursp
	ld	l,(iy+11)	; Display number of entries
	ld	h,(iy+12)
	call	phldc
;
	call	foursp
	ld	l,(iy+15)	; Display space used
	ld	h,(iy+16)
	ld	de,msg14$	; No trailing msg
	call	kout
	call	pagchk
;
prtlp1:	ld	de,19		; Increment table pointer to next user
	add	iy,de
;
	inc	b		; Increment user number
	ld	a,b
	cp	32		; Last user?
	jp	c,prtlp		; No, loop
;
; Display Totals: header
;
totals:	call	line
	call	pagchk
	ld	hl,msg10$	; Totals msg
	call	pstr$
	ld	b,10
	call	spcs
	ld	hl,(filcnt)	; Display total files
	call	phldc
	call	foursp
;
atlast:	ld	hl,(entcnt)	; Display total entries
	call	phldc
	push	hl		; Save total entries
;
	call	foursp
	ld	hl,(uspace)	; Display total space used
	ld	de,msg11$	; Free msg
	call	kout
;
	ld	b,21
	call	spcs		; Space over to free entries
	ld	hl,(dirmax)	; Get maximum directory entries
	or	a		; Clear CARRY
	pop	de		; DE=total entries
	sbc	hl,de		; Calculate remaining entries
	call	phldc		; And display it
	call	foursp		; Space over to free space
	ld	hl,(freesp)
	ld	de,msg14$	; No trailing msg
	call	kout		; And display it
;
; Display allocation bitmap
;
	ld	a,(z3plus)	; Quit now if Z3PLUS
	or	a
	ret	nz
;
	ld	a,(mapf)	; Display alloc map?
	or	a
	ret	z		; No
;
	call	crlf
	call	crlf
;
	ld	a,(pausf)	; Pause?
	or	a
	jr	z,domap		; No
;
	ld	hl,msg12$	; Alloc map msg
	call	pstr$
	call	cin
	call	eprint		; Restore cursor
	db	cr,0
	cp	3
	ret	z		; Quit if ^C
;
domap:	ld	bc,(alloc)	; BC=ALLOC address
	ld	hl,(blkmax)	; Get DSM+1
	call	initlin		; Initialize line and column counts
;
; At this point, we have:
;	BC=ALLOC address
;	DE=Line and column
;	HL=Max data block number
;
map:	push	bc		; Save alloc map pointer
	ld	a,(bc)		; Get allocation byte
	ld	b,8		; Process 8 blocks
;
map01:	rla			; Rotate block bit into CARRY
	ld	c,a		; Save remaining allocation bits in C
	jr	c,map02
;
	call	out0		; Bit=0, display non-allocated block
	jr	map03
;
map02:	call	out1		; Bit=1, display allocated block
;
map03:	dec	hl		; Count down number of disk blocks
	ld	a,l
	or	h
	jr	z,exit		; Done
;
	call	chklc		; Check line and column numbers
	ld	a,c		; Restore remaining allocation bits
	djnz	map01		; Loop through 8 bits
;
	pop	bc		; Restore alloc map pointer
	inc	bc		; Point to next byte
	jr	map		; Process it
;
; Main exit
;
exit:	call	crlf
	ld	sp,(stack)
	ret

;-----------------------------------------------------------------------
;
; Subroutines
;
; Get contents of hl in hl
;
lhlhl:	ld	a,(hl)		; Get record number
	inc	hl
	ld	h,(hl)
	ld	l,a
	ret
;
; Display filename pointed to by HL, quitting at first space
;
dispfn:	ld	b,8
;
fnlp:	ld	a,(hl)		; Display filename
	inc	hl
	cp	' '
	ret	z		; Quit at first space
;
	call	cout
	djnz	fnlp		; Quit after b characters
	ret
;
; Add file to counts
;
addit:	add	a		; Point to file entry
	add	a
	add	a
	add	a
	add	a
	ld	e,a
	ld	d,0
	ld	ix,cmdbuf
	add	ix,de		; IX points to file entry in cmdbuf
	ld	a,(ix)
	cp	0e5h		; Deleted file?
	ret	z		; (yes, skip it)
;
	ld	de,19		; 16-byte table entries
	ld	iy,cnttbl	; IY points to table
	cp	0		; User 0?
	jr	z,addusr	; (yes, no offset needed)
;
	cp	32		; User above 31?
	jr	nc,addend	; (yes, skip it)
;
	ld	b,a		; Move user to B as counter
;
addlp:	add	iy,de		; Calculate offset
	djnz	addlp
;
addusr:	ld	a,(extent)	; Get extent mask
	inc	a		; EXM+1
	ld	c,a		; Save it in C
;
	ld	a,(ix+12)	; Get extent
	ld	b,a		; Save it in B
	cp	c		; Compare with EXM+1
	jr	nc,chksiz	; Not first extent, don't count it
;
	ld	a,(ix+14)	; Get data module number
	or	a
	jr	nz,chksiz	; Not first, don't count it
;
	ld	l,(iy+13)	; Get file count into HL
	ld	h,(iy+14)
	inc	hl		; Increment it
	ld	(iy+13),l	; And store it back
	ld	(iy+14),h
;
chksiz:	ld	hl,0		; Initialize HL
	ld	de,128		; Number of records in full extent
	ld	a,b		; Get extent
	dec	c		; C=EXM
	and	c		; Get number of full extents/entry
	jr	z,chk0
;
	ld	b,a		; Set count
;
reclp:	add	hl,de
	djnz	reclp
;
chk0:	ld	a,(ix+15)	; Get record count
	call	aahl		; Add it in
	ex	de,hl		; Record count in DE
	ld	c,0
	call	blocks0		; Convert to K in HL
	ld	e,(iy+15)	; Get space used
	ld	d,(iy+16)
	add	hl,de		; Add in extent size
	ld	(iy+15),l	; Save incremented space used
	ld	(iy+16),h
;
addend:ld	l,(iy+11)	; Get entry count into HL
	ld	h,(iy+12)
	inc	hl		; Increment it
	ld	(iy+11),l	; And store it back
	ld	(iy+12),h
;
	ld	hl,(entcnt)	; Increment entry total
	inc	hl
	ld	(entcnt),hl
;
	ld	a,(ix+14)	; Check data module
	or	a
	ret	nz		; Not first data module
;
chkext:	ld	a,(extent)	; Get extent mask
	inc	a		; Increment it
	ld	c,a		; And store it in C
	ld	a,(ix+12)	; Get extent
	cp	c		; Compare to extent mask (+1) in C
	ret	nc		; Not first extent
;
	push	ix
	pop	hl
	inc	hl		; Point to filename
	ld	a,(lblflg)	; Get label file flag
	cp	(hl)
	jr	nz,nolab	; Not label
;
	push	iy
	pop	de		; Point to destination in table
	ld	bc,11
	ldir
;
nolab:	ld	hl,(filcnt)	; Increment file total
	inc	hl
	ld	(filcnt),hl
	ret
;
; Add A to HL
;
aahl:	add	a,l
	ld	l,a
	ret	nc
	inc	h
	ret
;
; Calculate number of blocks from number of records
;    HL=pointer to 24 bit number of 128 byte records
;
blocks:	ld	e,(hl)		; Get low byte in E
	inc	hl
	ld	d,(hl)		; Get middle byte in D
	inc	hl
	ld	c,(hl)		; Get high byte in C
;
; C, DE = 24 bit size, in 128 byte records (high byte in C)
;
blocks0:ld	hl,(blkmsk)	; Get block mask
	ld	h,0		; Only one byte
	add	hl,de		; Round to next block
;
; Number of blocks:  Shift HL right blkshf times
;
	ld	a,(blkshf)	; Block shift factor
	ld	b,a
;
; Shift C and HL right B times
;
shift:	srl	c		; Shift hi byte right, 0 fill
	rr	h		; Roll mid byte with carry from hi byte
	rr	l		; Roll lo byte with carry from mid byte
	djnz	shift		; Repeat until count is zero
;
; Convert number of blocks in HL to size in k in HL
;
size:	ld	a,(blkshf)	; Get BSH
	sub	3		; Convert to block size
	ld	b,a
	or	a		; Done if 1k blocks
	ret	z
;
incbsz:	add	hl,hl
	djnz	incbsz
	ret
;
; Display size in k, new line and trailing message with pointer in DE
;
kout:	call	phldc
	push	de
	ld	hl,msg13$
	call	pstr$
	pop	hl		; HL=trailing msg pointer
	jp	pstr$
;
; Display allocated and unallocated blocks as '0' and '1'
;
out1:	ld	a,'1'
	jr	out00
;
out0:	ld	a,'0'
;
out00:	jp	cout
;
; Check line and column numbers and format screen accordingly
;
chklc:	dec	d		; Decrement column count
	ret	nz
;
	call	initcol		; Initialize COL value
	call	crlf		; And start new line
	dec	e		; Decrement line count
	ret	nz
;
	call	more		; Pause
	jp	z,exit		; Quit if ^C
;
	call	crlf		; Leave [More] as marker
;
initlin:ld	a,(lin)		; Get number of screen lines
;
savlin:	ld	e,a		; Save remaining lines and fall thru
;
initcol:ld	a,(col)		; Get number of screen columns
	sub	2		; Don't display in last column
	ld	d,a
	ret
;
; Page end - quit with ^C
;
more:	push	hl
	ld	hl,msg00$
	call	pstr$
	pop	hl
	call	cin		; Wait for key
	cp	3		; ^C
	ret
;
; Increment line counter and check for screen fill
;
pagchk:	ld	hl,lincnt	; Decrement line counter
	dec	(hl)
	ret	nz		; (not end of screen)
;
	call	more		; Pause
	jp	z,exit		; Quit if ^C
;
	ld	hl,msg01$	; Else wipe out [More] msg
	call	pstr$
;
	ld	a,(lin)		; Reset line counter
	ld	(lincnt),a
	ret
;
; Display spaces, saving BC
;
foursp:	push	bc
	ld	b,4
	jr	sps
;
twosp:	push	bc
	ld	b,2
sps:	call	spcs
	pop	bc
	ret
;
spcs:	ld	a,' '
;
bout:	call	cout
	djnz	bout
	ret
;
; Display dashed line
;
line:	call	twosp
	ld	b,41
	ld	a,'-'
	call	bout
	jp	crlf		; Finish off with new line
;
; Parse fcb for options
;
parscl:	ld	hl,fcb1+1
	ld	bc,20
	cpir
	ret
;
; Wildcarded file control block for Search First and Search Next
;
	db	'WCFCB>>'
;		 dnnnnnnnnttte	u  m r
wcfcb:	db	'?????????????',0,'?'
;
; Uninitialized data area
;
	dseg
	ds	48		; Local stack
stack:	ds	2		; System stack pointer
;
data:
alloc:	ds	2		; Address of allocation vectors
dirsize:ds	2		; Directory size
dskcap:	ds	2		; Disk capacity (max-dir)
freesp:	ds	2		; Disk free space
lin:	ds	1		; Lines for alloc map display
col:	ds	1		; Columns for alloc map display
z3plus:	ds	1		; ON if running under Z3PLUS
xdos:	ds	1		; ON if running under banked ZSDOS20+
mapf:	ds	1		; ON to display alloc map
pausf:	ds	1		; ON to pause before alloc map display
lincnt:	ds	1		; Current line count
filcnt:	ds	2		; Current file total
entcnt:	ds	2		; Current entry total
sizfcb:	ds	36		; Filesize fcb
uspace:	ds	2		; Disk space used
;
; Table with a 19 byte entry for each user area:
;	DB	'-label     '	; 11 byte label filename
;	DW	Number of directory entries
;	DW	Number of files
;	DW	Space used
;	DS	2		; Spare
;
cnttbl:	ds	32*19		; 32 users * 19 bytes @
datalen	equ	$-data

	end