Bugfix in outmdm (output buffer flush)

[kermit-80.git] / mload.asm

	title	'MLOAD MULTI-FILE HEX LOAD UTILITY'\r
;\r
;		*********************************\r
;		*	   MLOAD.ASM		*\r
;		*   Multi-file Hex Load Utility *\r
;		*	   for CP/M		*\r
;		*********************************\r
;\r
;\r
;	Replacement for the cp/m "LOAD" program: this program\r
;	fixes many of the problems associated with the "CP/M"\r
;	load program, and adds many new features.\r
;\r
; ----------------\r
;\r
;	Rev 2.5\r
;	03/10/88\r
;	Property of NightOwl Software, Inc. Fort Atkinson, WI 53538\r
;	Written by Ron Fowler, Nightowl Software, Inc.\r
;\r
; ----------------\r
; Notice: this program is NOT public domain; copyright is retained by\r
; NightOwl Software, Inc. of Fort Atkinson, WI ... All Rights Reserved.\r
;\r
; License is granted for free use and re-distribution this program, as\r
; long as such use and re-distribution is done without profit.\r
;\r
; ----------------\r
;\r
; modification history:\r
;\r
; 2.5	(WOD)	This version corrects a bug that overlayed the first six\r
;		bytes of the CCP.  The error did not show up unless a\r
;		jump to the CCP was done without a warm boot since MLOAD\r
;		used.  This source file has been modified here with\r
;		concurrence of the author of MLOAD, Ron Fowler.\r
;\r
; 2.4	(RGF)	We apologize for this relatively insubstantial update,\r
;		but someone has caused what we consider to be a problem,\r
;		by making changes to the program, and re-releasing under\r
;		the same version number.  The changes in this case were\r
;		conversion of the opcode fields (but not the comments,\r
;		can you believe that??) of every line to upper case! That\r
;		totally invalidated the CRC of the source file, since there\r
;		are now two different MLOAD 2.3's running around.\r
;\r
;		We DO NOT want these stupid mixed upper/lower case changes.\r
;		Someone somewhere has decided that this is the way assembly\r
;		language source should be, and we most VEHEMENTLY disagree.\r
;		It's a pain in the neck to make changes to and we don't\r
;		care to run our programs through conversion programs every\r
;		time we make changes.\r
;\r
;		So ... leave the case of this file AS IS.  Any changes made\r
;		to this program and not co-ordinated through us may very\r
;		well endanger availability of source code when we make\r
;		future updates.  'nuff said		--NightOwl Software\r
;\r
; 2.3	(RGF)	Trivial cosmetic changes\r
; 2.2	(RGF)	Modified copyright notice to show new owner of the\r
;		program.\r
; 2.1	(RGF)	Fixed problem on disk-full when writing output file\r
;		(mload previously didn't error out on a full disk)\r
; 2.0	(RGF)	Added the ability to pre-load a non-hex file, allowing\r
;		mload to be used to load hex file patches (obviating any\r
;		need to use DDT).  The normal mload syntax is preserved.\r
;		the first (and only the first) filespec (after the "=",\r
;		if used) may be non-hex; the filetype must be specified.\r
;		Examples:\r
;\r
;			1)	mload ws.com,wspatch\r
;			2)	mload MEXTEST=MEX112.COM,MXO-US13\r
;			3)	mload ws.ovr,ovrpatch\r
;\r
;		The first example loads WS.COM, overlays it with\r
;		wspatch.hex, and writes the output to WS.COM.  The\r
;		second example loads MEX112.COM, overlays it with\r
;		MXO-US13.HEX, and writes the output file to MEXTEST.COM.\r
;		(note that the second example is the recommended technique,\r
;		since it preserves the original file). The third example\r
;		loads WS.OVR and patches it with the file "OVRPATCH.HEX".\r
;\r
;		Also added this rev: ZCPR2-style du specs are now fully\r
;		supported, for both input and output files.  Thus, the\r
;		following command lines are permissable:\r
;\r
;			b3>mload a4:myfile.com=0:bigfil,b6:patch1,c9:patch2\r
;			a6>mload b5:=c3:mdm717.com,mdmpatch\r
;\r
;		After loading, an additional information line is now printed\r
;		in the statistics report, which displays the true size of the\r
;		saved image (the previous report was technically correct, but\r
;		could result in confusion for certain kinds of files with\r
;		imbedded "DS" and "ORG" statements in the original source code).\r
;\r
; 1.0 - 1.4	(RGF) change log removed to conserve space\r
;\r
;	originally written by ron fowler, fort atkinson, wisconsin\r
;\r
;\r
;\r
; For assembly with asm.com or mac (delete above title line if\r
; assembling with asm.com).\r
;\r
; This program is a replacement for the cp/m "LOAD" program.\r
; Why replace "LOAD"?  well... LOAD.COM has a few deficiencies.\r
; For example, if your hex file's origin is above 100h, LOAD.COM\r
; prepends blank space to the output file to insure it will work\r
; as a CP/M transient.	It cares not if the file is not intended\r
; as a CP/M transient.	it also doesn't like hex records with mixed\r
; load addresses  (for example, one that loads below a previous record --\r
; which is a perfectly legitimate happenstance).  Also, LOAD.COM\r
; can load only one program at a time, and has no provision for\r
; a load bias in the command specification. Finally, there is no\r
; provision for user specification of the output file name.\r
;\r
;\r
; Hence, this program....\r
;\r
;------------------------------------------------------------\r
;\r
; Syntax is as follows:\r
;\r
;	mload [<outnam=] <filename>[,<filename>...] [bias]\r
;\r
; where <outnam> is the (optional!;) output file name (only the drive\r
; spec and primary filename may be specified; the output filetype is\r
; derived exclusively from the 3-byte string at 103h within MLOAD),\r
; <filename> specifies files to load and <bias> is the offset within\r
; the saved image to apply when loading the file.\r
;\r
; MLOAD with no arguments prints a small help message -- this message\r
; is also printed whenever a command line syntax error occurs.\r
;\r
; Filenames may contain drive/user specs, and must not contain wildcards.\r
; Input filenames must be separated by commas, and a space is required\r
; between the last filename and the optional bias.\r
;\r
; A load information summary is printed at the successful conclusion\r
; of the load.	Any errors in loading will generally include the name\r
; of the file in question.\r
;\r
; If no output filename is specified, it will be derived from the first\r
; input filename, with filetype of 'COM', if not otherwise specified\r
; (this default filetype may be patched directly into mload via DDT\r
; (or with MLOAD itself, using a patch file) -- its location is at 103H\r
; in MLOAD.COM). Note that a command line of the form "C:=<FILENAME>"\r
; will place the output file on the "C" drive with the same primary\r
; filename as the input file.\r
;\r
; In its simplest form, MLOAD's syntax is identical to LOAD.COM; thus\r
; there should be no problem in learning to use the new program.  The\r
; only significant difference here is that, under LOAD.COM, all files\r
; are output starting at 100h, even if they originate elsewhere.  MLOAD\r
; outputs starting at the hex file origin (actually, the first hex rec-\r
; ord specifies the output load address).  The bias option may be used\r
; to override this.\r
;\r
; An example should clarify this.  Suppose you have a file that loads\r
; at 1000h.  LOAD.COM would save an output file that begins at 100h and\r
; loads past 1000h (to wherever the program ends).  MLOAD will save an\r
; output file starting from 1000h only.  If, for some reason you need the\r
; file to start at 100h in spite of its 1000h origin (i can think of sev-\r
; eral circumstances where this would be necessary), you'd have to specify\r
; a bias to mload.  thus, using this example, "MLOAD MYFILE 0F00" would do.\r
;\r
; Note that this program re-initializes itself each time it is run.\r
; Thus, if your system supports a direct branch to the tpa (via a zero-length\r
; .COM file, or the ZCPR "GO" command), you may safely re-execute MLOAD.\r
;\r
; Please report any bugs, bug fixes, or enhancements to\r
;\r
;		"FORT FONE FILE FOLDER" rcpm/cbbs\r
;		Fort Atkinson, Wisconsin\r
;		(414) 563-9932 (no ring back)\r
;\r
;				--Ron Fowler\r
;				  03/08/84   updated 1/31/85\r
;\r
;------------------------------------------------------------\r
;\r
; CP/M equates\r
;\r
warmbt	equ	0		;warm boot\r
system	equ	5		;system entry (also top of mem pntr)\r
dfcb	equ	5ch		;default file control block\r
ft	equ	9		;fcb offset to filetype\r
tbuf	equ	80h		;default buffer\r
tpa	equ	100h		;transient program area\r
eof	equ	1ah		;cp/m end-of-file mark\r
fcbsiz	equ	33		;size of file control block\r
;\r
; CP/M system calls\r
;\r
pcharf	equ	2		;print char\r
seldf	equ	14		;select disk drive\r
openf	equ	15		;open file\r
closef	equ	16		;close file\r
fsrchf	equ	17		;search for first\r
fsrchn	equ	18		;search for next\r
erasef	equ	19		;delete file\r
readf	equ	20		;read record\r
writef	equ	21		;write record\r
creatf	equ	22		;create file\r
getdrf	equ	25		;return dflt drive #\r
sdmaf	equ	26		;set dma address\r
gsuser	equ	32		;get/set user #\r
rrand	equ	33		;read random\r
wrand	equ	34		;write random\r
filszf	equ	35		;compute file size\r
srand	equ	36		;set random\r
;\r
; ASCII character constants\r
;\r
cr	equ	13\r
lf	equ	10\r
bel	equ	7\r
tab	equ	9\r
;\r
; without further ado...\r
;\r
	org	tpa\r
;\r
	jmp	begin		;jump over default output filetype\r
;\r
; the default output filetype is located at 103h for easy patching\r
;\r
outtyp:	db	'COM'\r
;\r
begin:	lxi	h,0		;save system stackpointer\r
	dad	sp\r
	shld	spsave\r
	lxi	sp,stack	;load local stack\r
	call	ilprnt		;sign on\r
	db	'MLOAD ver. 2.5   Copyright (C) 1983, 1984, 1985'\r
	db	cr,lf\r
	db	'by NightOwl Software, Inc.'\r
	db	cr,lf,0\r
	call	setup		;initialize\r
main:	call	nxtfil		;parse and read next input file\r
	jc	done		;no more...\r
	call	lodfil		;yep, load it\r
	call	closfl		;close it (in case MP/M or TurboDOS)\r
	jmp	main		;maybe more\r
done:	call	wrtfil		;write the output file\r
;\r
; exit to cp/m\r
;\r
exit:	lxi	d,tbuf		;restore dma address\r
	mvi	c,sdmaf\r
	call	bdos\r
	lda	system+2	;get top of memory pointer\r
	sui	9		;allow for ccp+slop\r
	lxi	h,hiload+1	;highest load address\r
	sub	m		;above ccp?\r
	jc	warmbt		;then warm-boot\r
	lhld	spsave		;nope, ccp still in memory\r
	sphl			;restore its stack\r
	ret			;return to ccp\r
;\r
; load program initialization\r
;\r
setup:	lxi	h,varset	;initialize variables\r
	lxi	d,vars\r
	mvi	b,varlen	;by moving in default values\r
	call	move\r
	lhld	cmdptr		;get first free mem pointer\r
	xchg			;in de\r
	lxi	h,tbuf		;point to command tail bufr\r
	mov	a,m		;get its length\r
	inx	h\r
	ora	a		;does it have any length?\r
	jz	help		;nope, go give usage help\r
	mov	b,a		;yep, get length to b\r
	call	move		;move cmd tail to buffer\r
	xchg			;end of dest to hl\r
	mvi	m,0		;stuff a terminator\r
	inx	h		;point to first free memory\r
	shld	filbuf		;set up file buffer\r
	xchg			;file bufr adrs to de\r
	lhld	system+1	;get top of memory pointer\r
	xra	a		;round system to page boundary\r
	sub	e\r
	mov	c,a		;with result in bc\r
	mov	a,h\r
	sui	9		;allow for ccp\r
	sbb	d\r
	mov	b,a\r
	xchg			;buffer pointer to hl\r
nitmem:	mvi	m,0		;clear buffer\r
	inx	h\r
	dcx	b\r
	mov	a,b\r
	ora	c\r
	jnz	nitmem\r
;\r
; look for a bias specification in command line\r
;\r
	lhld	cmdptr		;point to command buffer-1\r
	dcx	h\r
	call	scanbk		;scan past blanks\r
	ora	a		;no non-blank chars?\r
	jz	help		;then go print help text\r
fndspc:	inx	h		;point to next\r
	mov	a,m		;fetch it\r
	ora	a		;test it\r
	rz			;line ended, return\r
	cpi	' '		;nope, test for blank\r
	jnz	fndspc		;not blank, continue\r
	call	scanbk		;skip blanks\r
	ora	a		;end-of-line?\r
	rz			;return if so\r
;\r
; hl points to bias in command line\r
;\r
	lxi	d,0		;init bias\r
	call	hexdig		;insure a hex digit\r
	jc	synerr		;bad...\r
hexlp:	mov	a,m		;no.  get next char\r
	inx	h		;skip over it\r
	call	hexdig		;test for hex digit\r
	jnc	digok		;jump if good hex digit\r
	ora	a		;must end on null terminator\r
	jnz	synerr\r
	xchg			;good end, get bias to hl\r
	shld	bias		;stuff it\r
	ret			;done\r
digok:	xchg			;bias to hl\r
	dad	h		;skift left 4 to make room\r
	dad	h		;   for new hex digit\r
	dad	h\r
	dad	h\r
	xchg			;back to de\r
	add	e		;add in new digit\r
	mov	e,a\r
	jnc	hexlp		;jump if no 8-bit ovfl\r
	inr	d		;carry\r
	jmp	hexlp\r
;\r
; parse next input name, and open resultant file\r
;\r
nxtfil:	lhld	cmdptr		;get command line pointer\r
next2:	lxi	d,dfcb		;destination fcb\r
	call	fparse		;parse a filename\r
	cpi	'='		;stopped on output specifier?\r
	jnz	noteq\r
	lda	outnam+2	;insure no name yet specified\r
	cpi	' '\r
	jnz	synerr		;syntax error if already named\r
	lda	outflg		;already been here?\r
	ora	a\r
	jnz	synerr		;can't be here twice\r
	inr	a		;flag that we've been here\r
	sta	outflg\r
	inr	b		;insure no ambiguous output name\r
	dcr	b\r
	jnz	afnerr\r
	inx	h		;skip over '='\r
	push	h		;save cmd line pointer\r
	lxi	h,dfcb-1	;move the name to output name hold\r
	lxi	d,outnam\r
	mvi	b,13		;drive spec too\r
	call	move\r
	pop	h		;restore command line pointer\r
	jmp	next2		;go parse another\r
noteq:	cpi	','		;stopped on comma?\r
	jz	gcomma		;jump if so\r
	mvi	m,0		;nope, insure end of input\r
	jmp	nxt2		;don't advance over fake end\r
gcomma:	inx	h		;skip over comma\r
nxt2:	shld	cmdptr		;save new command line pntr\r
	mov	a,b		;get ambig char count\r
	ora	a		;test it\r
	jnz	afnerr		;allow no ambig characters\r
	sta	bufptr		;force a disk read\r
	lxi	d,dfcb+1	;look at parsed filename\r
	ldax	d\r
	cpi	' '		;blank? (input ended?)\r
	stc			;get carry ready in case so\r
	rz			;return cy if input gone\r
	dcx	d		;nope, point de to start of fcb\r
open2:	push	d		;try to open the file\r
	mvi	c,openf\r
	call	bdos\r
	pop	d\r
	inr	a		;return=0ffh?\r
	jnz	openok		;jump if not\r
;\r
; file not found: if filetype blank, set to 'hex' and try again\r
;\r
	lxi	h,dfcb+ft	;point to file type\r
	mov	a,m		;anything there?\r
	cpi	' '\r
	jnz	fnferr		;yes, so file not found\r
	mvi	m,'H'		;nope, fill in 'hex'\r
	inx	h\r
	mvi	m,'E'\r
	inx	h\r
	mvi	m,'X'\r
	jmp	open2		;go try again\r
;\r
; here after a good file open\r
;\r
openok:	call	hexchk		;is this a hex file?\r
	rz			;if so, all done\r
	lxi	h,comflg	;no, get pointer to flag\r
	mov	a,m		;loading first file?\r
	ora	a\r
	rnz			;if not, ignore type, consider hex\r
	inr	m		;else, set the flag\r
	ret\r
;\r
; load current file\r
;\r
lodfil:	lxi	h,comflg	;loading a com file?\r
	mov	a,m		;get flag\r
	ani	1\r
	jnz	lodcom		;jump if so\r
	lhld	bias		;else get bias on top of stack\r
	push	h\r
;\r
; load a hex record\r
;\r
loadlp:	call	gnb		;get next file byte\r
	sbi	':'		;look for start-record mark\r
	jnz	loadlp		;scan until found\r
	sta	cksum		;got it, init checksum to zero\r
	mov	d,a		;upper byte of rec cnt=0\r
	pop	b		;retrieve bias adrs\r
	push	b		;save it again\r
	call	ghbcks		;get hex byte w/checksum\r
	mov	e,a		;de now has record length\r
	ora	a		;test it\r
	jnz	notend		;jump if len<>0 (not eof rec)\r
	pop	h		;all done\r
	ret\r
notend:	call	ghbcks		;hi byte of rec ld adrs\r
	mov	h,a		;accumulate in hl\r
	call	ghbcks		;get lo byte\r
	mov	l,a		;put lo in l\r
	lda	lodflg		;test load flag\r
	ora	a\r
	cz	lodnit		;not first record, initialize\r
	push	h		;save load address\r
	dad	d		;add in record length\r
	dcx	h		;make highest, not next\r
	lda	hipc		;a new high?\r
	sub	l\r
	lda	hipc+1\r
	sbb	h\r
	jnc	notgt		;jump if not\r
	shld	hipc		;yep, update hipc\r
	push	d		;save reclen\r
	xchg			;load adrs to de\r
	lhld	offset		;get offset to form true memory adrs\r
	dad	d		;add in offset\r
	dad	b		;and bias\r
	shld	hiload		;mark highest true memory load adrs\r
	lda	system+2	;validate against top-mem pointer\r
	cmp	h\r
	jc	memful		;jump if out of memory\r
	pop	d		;restore reclen\r
notgt:	pop	h		;restore load address\r
	dad	b		;add bias to load adrs\r
	push	d		;save record length\r
	push	h\r
	lhld	bytcnt		;add record length to byte count\r
	dad	d\r
	shld	bytcnt\r
	pop	h\r
	xchg\r
	lhld	offset		;calculate true memory adrs\r
	dad	d		;hl=true loading adrs\r
	pop	d		;restore record length\r
	call	ghbcks		;skip unused byte of intel format\r
;\r
; move the record into memory\r
;\r
reclp:	call	ghbcks		;get hex byte\r
	mov	m,a		;store it in buffer\r
	inx	h		;point to next\r
	dcr	e		;count down\r
	jnz	reclp		;until record all read\r
	call	ghbcks		;get checksum byte\r
	jnz	cserr		;final add cksum should sum 0\r
	jmp	loadlp		;good load, go do nxt record\r
;\r
; get next hex byte from input, and\r
; accumulate a checksum\r
;\r
ghbcks:	push	b		;save em all\r
	push	h\r
	push	d\r
	call	hexin		;get hex byte\r
	mov	b,a		;save in b\r
	lxi	h,cksum		;add to checksum\r
	mov	a,m\r
	add	b\r
	mov	m,a\r
	mov	a,b		;get byte back\r
	pop	d		;restore checksum\r
	pop	h		;restore other regs\r
	pop	b\r
	ret\r
;\r
; routine to get next byte from input...forms\r
; byte from two ascii hex characters\r
;\r
hexin:	call	gnb		;get next input file byte\r
	call	hexval		;convert to binary w/validation\r
	rlc			;move into ms nybble\r
	rlc\r
	rlc\r
	rlc\r
	ani	0f0h		;kill possible garbage\r
	push	psw		;save it\r
	call	gnb		;get next byte\r
	call	hexval		;convert it, w/validation\r
	pop	b		;get back first\r
	ora	b		;or in second\r
	ret			;good byte in a\r
;\r
; gnb - utility subroutine to get next\r
;	byte from disk file\r
gnb:	push	h		;save all regs\r
	push	d\r
	push	b\r
	lda	bufptr		;get input bufr pointer\r
	ani	7fh		;wound back to 0?\r
	jz	diskrd		;go read sector if so\r
gnb1:	mvi	d,0		;else form 16 bit offset\r
	mov	e,a\r
	lxi	h,tbuf		;from tbuf\r
	dad	d		;add in offset\r
	mov	a,m		;get next byte\r
	cpi	eof		;end of file?\r
	jz	eoferr		;error if so\r
	lxi	h,bufptr	;else bump buf ptr\r
	inr	m\r
	ora	a		;return carry clear\r
	pop	b		;restore and return\r
	pop	d\r
	pop	h\r
	ret\r
;\r
; read next sector from disk\r
;\r
diskrd:	mvi	c,readf		;bdos "READ SEC" function\r
	lxi	d,dfcb\r
	call	bdos		;read sector\r
	ora	a\r
	jnz	eoferr		;error if phys end of file\r
	sta	bufptr		;store 0 as new buf ptr\r
	jmp	gnb1		;go re-join gnb code\r
;\r
; load a com file\r
;\r
lodcom:	inr	m		;bump the comfile flag\r
	lxi	h,tpa		;set origin\r
	call	lodnit		;and initialize\r
	xchg			;load address in de\r
	lhld	bias		;add in bias\r
	dad	d\r
	xchg\r
	lhld	offset		;and offset\r
	dad	d\r
	xchg			;de has absolute mem adrs of load\r
;\r
comlp:	lxi	h,128		;calculate next dma\r
	dad	d\r
	lda	system+2	;check for space\r
	cmp	h\r
	jc	memful		;jump if none\r
	push	h		;else save next dma\r
	push	d		;and this dma\r
	mvi	c,sdmaf		;set this dma\r
	call	bdos\r
	lxi	d,dfcb		;read next record\r
	mvi	c,readf\r
	call	bdos\r
	pop	h		;recall this dma\r
	pop	d		;de=next dma\r
	ora	a		;end of read?\r
	jnz	lodend		;jump if so\r
	lhld	comsiz		;no, advance com byte count\r
	lxi	b,128\r
	dad	b\r
	shld	comsiz\r
	jmp	comlp		;continue\r
;\r
lodend:	dcx	h		;one less byte is highest\r
	shld	hiload		;set a new high\r
	lhld	comsiz		;hi pc=bytecount+100h\r
	lxi	d,tpa\r
	dad	d\r
	xchg			;to de\r
	lhld	bias		;add in bias\r
	dad	d\r
	shld	hipc\r
	lxi	d,tbuf		;reset dma for hex files\r
	mvi	c,sdmaf\r
	call	bdos\r
	ret\r
;\r
; write output file\r
;\r
wrtfil:	lxi	d,dfcb		;point to fcb\r
	push	d		;save 2 copies of pointer\r
	push	d\r
	call	nitfcb		;initialize output fcb\r
	lxi	h,outnam	;move output name in\r
	dcx	d		;point to user # (prior to fcb)\r
	mvi	b,10		;move user, drive, primary name\r
	call	move\r
	mov	a,m		;output type blank?\r
	cpi	' '\r
	jnz	wrtnb		;jump if not\r
	lxi	h,outtyp	;yes, move dflt output filetype in\r
wrtnb:	mvi	b,3\r
	call	move\r
	pop	d		;restore fcb pointer\r
	mvi	c,erasef	;erase any existing file\r
	call	bdos\r
	pop	d		;restore fcb pointer\r
	mvi	c,creatf	;create a new file\r
	call	bdos\r
	inr	a		;good create?\r
	jz	dirful		;goto directory full error if not\r
	lhld	hiload		;yep, get top of bufr pntr\r
	xchg			;in de\r
	lhld	filbuf		;get start of bufr adrs\r
	mov	a,e		;calculate output file size\r
	sub	l\r
	mov	c,a		;with result in bc\r
	mov	a,d\r
	sbb	h\r
	mov	b,a\r
	mov	a,b		;test length\r
	ora	c\r
	jz	loderr		;nothing to write???\r
	lxi	d,dfcb		;get fcb pointer\r
wrlp:	push	b		;save count\r
	push	d		;and fcb pointer\r
	xchg			;get memory pointer to de\r
	lxi	h,128		;add in sector length for next pass\r
	dad	d\r
	xthl			;save next dma\r
	push	h		;above fcb\r
	mvi	c,sdmaf		;set transfer address\r
	call	bdos\r
	pop	d		;fetch fcb pointer\r
	push	d		;save it again\r
	mvi	c,writef	;write a sector\r
	call	bdos\r
	ora	a		;test result\r
	jnz	dskful		;disk full error...\r
	lhld	reccnt		;no,increment count of records\r
	inx	h\r
	shld	reccnt\r
	pop	d		;restore fcb pointer\r
	pop	h		;and memory write pointer\r
	pop	b		;and count\r
	mov	a,c		;subtract 128 (sec size) from count\r
	sui	128\r
	mov	c,a\r
	jnc	wrlp		;jump if some left\r
	mov	a,b		;hi-order borrow\r
	sui	1		;do it (can't "DCR B", doesn't affect cy)\r
	mov	b,a		;restore\r
	jnc	wrlp		;jump if more left\r
	call	closfl		;close output file\r
;\r
; report statistics to console\r
;\r
	call	ilprnt\r
	db	'Loaded ',0\r
	lhld	bytcnt		;print # bytes\r
	call	decout\r
	call	ilprnt\r
	db	' bytes (',0\r
	call	hexout\r
	call	ilprnt\r
	db	'H)',0\r
	call	ilprnt\r
	db	' to file %',0\r
	lda	comflg		;did we load a comfile too?\r
	ora	a\r
	jz	notcom		;jump if not\r
	call	ilprnt\r
	db	cr,lf,'Over a ',0\r
	lhld	comsiz\r
	call	decout\r
	call	ilprnt\r
	db	' byte binary file',0\r
notcom:	call	ilprnt\r
	db	cr,lf,'Start address: ',0\r
	lhld	lodadr		;print loading address\r
	call	hexout\r
	call	ilprnt\r
	db	'H  Ending address: ',0\r
	lhld	hipc		;print ending load address\r
	call	hexout\r
	call	ilprnt\r
	db	'H  Bias: ',0\r
	lhld	bias\r
	call	hexout\r
	call	ilprnt\r
	db	'H',cr,lf,0\r
	call	ilprnt\r
	db	'Saved image size: ',0\r
	lhld	reccnt		;get count of image records\r
	push	h		;save it\r
	mvi	b,7		;convert to bytes\r
xlp:	dad	h\r
	dcr	b\r
	jnz	xlp\r
	call	decout		;print it\r
	call	ilprnt\r
	db	' bytes (',0\r
	call	hexout		;now in hex\r
	call	ilprnt\r
	db	'H, - ',0\r
	pop	h		;recall record count\r
	call	decout		;print it\r
	call	ilprnt\r
	db	' records)',cr,lf,0\r
	lhld	lodadr		;fetch loading address\r
	mov	a,l		;test if =tpa\r
	ora	a\r
	jnz	nottpa		;tpa always on page boundary\r
	mov	a,h		;lo ok, test hi\r
	cpi	(tpa shr 8) and	0ffh\r
	rz			;return if tpa\r
nottpa:	call	ilprnt		;not, so print warning msg\r
	db	cr,lf,bel\r
	db	'++ Warning: program origin NOT at 100H ++'\r
	db	cr,lf,0\r
	ret			;done\r
;\r
;	***********************\r
;	* utility subroutines *\r
;	***********************\r
;\r
;\r
; routine to close any open file\r
;\r
closfl:	lxi	d,dfcb\r
	mvi	c,closef\r
	call	bdos\r
	inr	a		;test close result\r
	jz	clserr		;jump if error\r
	ret\r
;\r
; print message in-line with code\r
;\r
ilprnt:	xthl			;message pntr to hl\r
	call	prathl		;print it\r
	xthl			;restore and return\r
	ret\r
;\r
; print msg pointed to by hl until null.  expand\r
; '%' char to current filename.\r
;\r
prathl:	mov	a,m		;fetch char\r
	inx	h		;point to next\r
	ora	a		;terminator?\r
	rz			;then done\r
	cpi	'%'		;want filename?\r
	jz	prtfn		;go do it if so\r
	call	type		;nope, just print char\r
	jmp	prathl		;continue\r
;\r
prtfn:	push	h		;save pointer\r
	push	b\r
	lda	dfcb		;fetch dr field of dfcb\r
	ora	a		;default drive?\r
	jnz	prndf		;jump if not\r
	call	getdsk		;get logged-in drive #\r
	inr	a		;make it one-relative (as in fcb)\r
prndf:	adi	'A'-1		;make drive name printable\r
	call	type		;print it\r
	lda	dfcb-1		;get user #\r
	cpi	0ffh		;null?\r
	cz	getusr		;iff so, get current user\r
	mov	l,a		;to hl\r
	mvi	h,0\r
	call	decout		;print it\r
	mvi	a,':'		;drive names followed by colon\r
	call	type\r
	lxi	h,dfcb+1	;setup for name\r
	mvi	b,8		;print up to 8\r
	call	prtnam\r
	mvi	a,'.'		;print dot\r
	call	type\r
	mvi	b,3		;print filetype field\r
	call	prtnam\r
	pop	b\r
	pop	h		;restore and continue\r
	jmp	prathl\r
;\r
; print file name .HL max length in b.	don't print spaces\r
;\r
prtnam:	mov	a,m		;fetch a char\r
	cpi	' '		;blank?\r
	jz	pwind		;go wind if so\r
	inx	h		;nope, move to next\r
	call	type		;print it\r
	dcr	b		;count down\r
	jnz	prtnam		;continue\r
	ret\r
pwind:	inx	h		;skip remainder of blank name\r
	dcr	b\r
	jnz	pwind\r
	ret\r
;\r
; print HL in decimal on console\r
;\r
decout:	push	h		;save everybody\r
	push	d\r
	push	b\r
	lxi	b,-10		;conversion radix\r
	lxi	d,-1\r
declp:	dad	b\r
	inx	d\r
	jc	declp\r
	lxi	b,10\r
	dad	b\r
	xchg\r
	mov	a,h\r
	ora	l\r
	cnz	decout		;this is recursive\r
	mov	a,e\r
	adi	'0'\r
	call	type\r
	pop	b\r
	pop	d\r
	pop	h\r
	ret\r
;\r
; newline on console\r
;\r
crlf:	mvi	a,cr\r
	call	type\r
	mvi	a,lf\r
	jmp	type\r
;\r
; print hl on console in hex\r
;\r
hexout:	mov	a,h		;get hi\r
	call	hexbyt		;print it\r
	mov	a,l		;get lo, fall into hexbyt\r
;\r
; type accumulator on console in hex\r
;\r
hexbyt:	push	psw		;save byte\r
	rar			;get ms nybble..\r
	rar			;..into lo 4 bits\r
	rar\r
	rar\r
	call	nybble\r
	pop	psw		;get back byte\r
nybble:	ani	0fh		;mask ms nybble\r
	adi	90h		;add offset\r
	daa			;decimal adjust a-reg\r
	aci	40h		;add offset\r
	daa			;fall into type\r
;\r
; type char in a on console\r
;\r
type:	push	h		;save all\r
	push	d\r
	push	b\r
	mov	e,a		;cp/m outputs from e\r
	mvi	c,pcharf\r
	call	bdos\r
	pop	b\r
	pop	d\r
	pop	h\r
	ret\r
;\r
; move: from @hl to @de, count in b\r
;\r
move:	inr	b		;up one\r
movlp:	dcr	b		;count down\r
	rz			;return if done\r
	mov	a,m		;not done, continue\r
	stax	d\r
	inx	h		;pointers=pointers+1\r
	inx	d\r
	jmp	movlp\r
;\r
; scan to first non-blank char in string @hl\r
;\r
scanbk:	inx	h		;next\r
	mov	a,m		;fetch it\r
	cpi	' '\r
	jz	scanbk\r
	ret\r
;\r
; get hex digit and validate\r
;\r
hexval:	call	hexdig		;get hex digit\r
	jc	formerr		;jump if bad\r
	ret\r
;\r
; get hex digit, return cy=1 if bad digit\r
;\r
hexdig:	cpi	'0'		;lo boundary test\r
	rc			;bad already?\r
	cpi	'9'+1		;no, test hi\r
	jc	hexcvt		;jump if numeric\r
	cpi	'A'		;test alpha\r
	rc			;bad?\r
	cpi	'F'+1		;no, upper alpha bound\r
	cmc			;pervert carry\r
	rc			;bad?\r
	sui	7		;no, adjust to 0-f\r
hexcvt:	ani	0fh		;make it binary\r
	ret\r
;\r
;	******************\r
;	* error handlers *\r
;	******************\r
;\r
synerr:	call	crlf\r
	call	ilprnt\r
	db	'      Command line syntax error',cr,lf,cr,lf,0\r
	jmp	help		;give help msg too\r
;\r
afnerr:	call	errxit		;exit with message\r
	db	'Ambiguous file name: % not allowed.',0\r
;\r
fnferr:	call	errxit\r
	db	'File % not found.',0\r
;\r
dskful:	call	errxit\r
	db	'Disk full.',0\r
;\r
dirful:	call	errxit\r
	db	'Directory full.',0\r
;\r
eoferr:	call	errxit\r
	db	'Premature end-of-file in %',0\r
;\r
cserr:	call	errxit\r
	db	'Checksum error in %',0\r
;\r
clserr:	call	errxit\r
	db	'Can''t close %',0\r
;\r
memful:	call	errxit\r
	db	'Memory full while loading %',0\r
;\r
formerr:call	errxit\r
	db	'Format error in file %',0\r
;\r
loderr:	call	errxit\r
	db	'Writing %, nothing loaded',0\r
;\r
help:	call	errxit		;print help text\r
	db	'MLOAD syntax:',cr,lf,cr,lf\r
	db	'MLOAD [<OUTFIL>=] <FILE1>[,<FILE2>...] [<BIAS>]',cr,lf\r
	db	tab,'    (brackets denote optional items)',cr,lf,cr,lf\r
	db	tab,'<OUTFIL> is the optional output filename',cr,lf\r
	db	tab,'<FILEn>  are input file(s)',cr,lf\r
	db	tab,'<BIAS>   is a hex load offset within the output file'\r
	db	cr,lf,cr,lf\r
	db	tab,'<FILE1> may be an optional non-HEX file to be patched',cr,lf\r
	db	tab,'by subsequently named HEX files (specifying',cr,lf\r
	db	tab,'The filetype enables this function).'\r
	db	cr,lf,cr,lf\r
	db	'Note that ZCPR2-style drive/user notation may be used in all'\r
	db	cr,lf\r
	db	'file specifications (e.g., "B3:MYFILE.COM, "A14:MDM7.HEX").'\r
	db	cr,lf,0\r
;\r
; general error handler\r
;\r
errxit:	call	crlf		;new line\r
	pop	h		;fetch error msg pointer\r
	call	prathl		;print it\r
	call	crlf\r
	jmp	exit		;done\r
;\r
; initialize load parameters\r
;\r
lodnit:	mvi	a,1		;first record, set load flag\r
	sta	lodflg\r
	shld	lodadr		;save load address\r
	shld	hipc		;and hi load\r
	push	d		;save record length\r
	xchg			;de=load address\r
	lhld	filbuf		;get address of file buffer\r
	mov	a,l		;subtract load adrs from file buffer\r
	sub	e\r
	mov	l,a\r
	mov	a,h\r
	sbb	d\r
	mov	h,a\r
	shld	offset		;save as load offset\r
	push	d		;save load address on stack\r
	push	b		;save bias\r
	lxi	d,outnam+2	;check output filename\r
	ldax	d		;(first char)\r
	cpi	' '\r
	jnz	namskp		;jump if so\r
	lxi	h,dfcb+1	;get first name pointer\r
	mvi	b,8		;(don't include drive spec)\r
	call	move\r
;\r
; check for outflg=1 (presence of an "=").  note that the\r
; filename may well be blank, and yet outflg <>0, for example\r
; in the case of "A:=<FILENAME>" or "C4:=<FILENAME>". in\r
; this case, we want to remember the drive/user specified, but\r
; use the first input file to form the output name. otherwise,\r
; we use the current drive/user.\r
;\r
	lda	outflg		;was there an "="?\r
	ora	a\r
	jnz	namskp		;jump if so\r
	lxi	h,outnam	;get destination pointer\r
	call	getusr		;get current user #\r
	mov	m,a\r
	inx	h		;point to drive\r
	call	getdsk		;get it\r
	inr	a		;fcb's drive is 1-relative\r
	mov	m,a\r
namskp:	mvi	a,1		;insure "=" cannot occur anymore\r
	sta	outflg\r
	pop	b		;restore bias\r
	pop	h		;load address to hl\r
	pop	d		;restore record length\r
	ret\r
;\r
;	*********************************\r
;	* file name parsing subroutines *\r
;	*********************************\r
;\r
; credit where credit's due:\r
; --------------------------\r
; these routines were lifted from bob van valzah's\r
; "FAST" program.\r
;\r
;\r
;\r
;	*********************************\r
;	* file name parsing subroutines *\r
;	*********************************\r
;\r
;\r
; getfn gets a file name from text pointed to by reg hl into\r
; an fcb pointed to by reg de.	leading delimeters are\r
; ignored. allows drive spec of the form <du:> (drive/user).\r
; this routine formats all 33 bytes of the fcb (but not ran rec).\r
;\r
; entry de	first byte of fcb\r
; exit b=# of '?' in name\r
; fcb-1= user # parsed (if specified) or 255\r
;\r
;\r
fparse:	call	nitfcb		;init 1st half of fcb\r
	call	gstart		;scan to first character of name\r
	call	getdrv		;get drive/user spec. if present\r
	mov	a,b		;get user # or 255\r
	cpi	0ffh		;255?\r
	jz	fpars1		;jump if so\r
	dcx	d		;back up to byte preceeding fcb\r
	dcx	d\r
	stax	d		;stuff user #\r
	inx	d		;onward\r
	inx	d\r
fpars1:	call	getps		;get primary and secondary name\r
	ret\r
;\r
; nitfcb fills the fcb with dflt info - 0 in drive field\r
; all-blank in name field, and 0 in ex,s1,s2,rc, disk\r
; allocation map, and random record # fields\r
;\r
nitfcb:	push	h\r
	push	d\r
	call	getusr		;init user field\r
	pop	d\r
	pop	h\r
	push	d		;save fcb loc\r
	dcx	d\r
	stax	d		;init user # to currnt user #\r
	inx	d\r
	xchg			;move it to hl\r
	mvi	m,0		;drive=default\r
	inx	h		;bump to name field\r
	mvi	b,11		;zap all of name fld\r
nitlp:	mvi	m,' '\r
	inx	h\r
	dcr	b\r
	jnz	nitlp\r
	mvi	b,33-11		;zero others, up to nr field\r
zlp:	mvi	m,0\r
	inx	h\r
	dcr	b\r
	jnz	zlp\r
	xchg			;restore hl\r
	pop	d		;restore fcb pointer\r
	ret\r
;\r
; gstart advances the text pointer (reg hl) to the first\r
; non delimiter character (i.e. ignores blanks).  returns a\r
; flag if end of line (00h or ';') is found while scaning.\r
; exit	hl	pointing to first non delimiter\r
;	a	clobbered\r
;	zero	set if end of line was found\r
;\r
gstart:	call	getch		;see if pointing to delim?\r
	rnz			;nope - return\r
	ora	a		;physical end?\r
	rz			;yes - return w/flag\r
	inx	h		;nope - move over it\r
	jmp	gstart		;and try next char\r
;\r
; getdrv checks for the presence of a du: spec at the text\r
; pointer, and if present formats drive into fcb and returns\r
; user # in b.\r
;\r
; entry hl	text pointer\r
;	de	pointer to first byte of fcb\r
; exit	hl	possibly updated text pointer\r
;	de	pointer to second (primary name) byte of fcb\r
;	b	user # if specified or 0ffh\r
;\r
getdrv:	mvi	b,0ffh		;default no user #\r
	push	h		;save text pointer\r
dscan:	call	getch		;get next char\r
	inx	h		;skip pointer over it\r
	jnz	dscan		;scan until delimiter\r
	cpi	':'		;delimiter a colon?\r
	inx	d		;skip dr field in fcb in case not\r
	pop	h		;and restore text pointer\r
	rnz			;return if no du: spec\r
	mov	a,m		;got one, get first char\r
	call	cvtuc		;may be drive name, cvt to upper case\r
	cpi	'A'		;alpha?\r
	jc	isnum		;jump to get user # if not\r
	sui	'A'-1		;yes, convert from ascii to #\r
	dcx	d		;back up fcb pointer to dr field\r
	stax	d		;store drive # into fcb\r
	inx	d		;pass pointer over drv\r
	inx	h		;skip drive spec in text\r
isnum:	mov	a,m		;fetch next\r
	inx	h\r
	cpi	':'		;du delimiter?\r
	rz			;done then\r
	dcx	h		;nope, back up text pointer\r
	mvi	b,0		;got a digit, init user value\r
uloop:	mov	a,b		;get accumulated user #\r
	add	a		;* 10 for new digit\r
	add	a\r
	add	b\r
	add	a\r
	mov	b,a		;back to b\r
	mov	a,m		;get text char\r
	sui	'0'		;make binary\r
	add	b		;add to user #\r
	mov	b,a		;updated user #\r
	inx	h		;skip over it\r
	mov	a,m		;get next\r
	cpi	':'		;end of spec?\r
	jnz	uloop		;jump if not\r
	inx	h		;yep, return txt pointer past du:\r
	ret\r
;\r
; getps gets the primary and secondary names into the fcb.\r
; entry hl	text pointer\r
; exit	hl	character following secondary name (if present)\r
;\r
getps:	mvi	c,8		;max length of primary name\r
	mvi	b,0		;init count of '?'\r
	call	getnam		;pack primary name into fcb\r
	mov	a,m		;see if terminated by a period\r
	cpi	'.'\r
	rnz			;nope - secondary name not given\r
				;return default (blanks)\r
	inx	h		;yup - move text pointer over period\r
ftpoint:mov	a,c		;yup - update fcb pointer to secondary\r
	ora	a\r
	jz	getft\r
	inx	d\r
	dcr	c\r
	jmp	ftpoint\r
getft:	mvi	c,3		;max length of secondary name\r
	call	getnam		;pack secondary name into fcb\r
	ret\r
;\r
; getnam copies a name from the text pointer into the fcb for\r
; a given maximum length or until a delimiter is found, which\r
; ever occurs first.  if more than the maximum number of\r
; characters is present, character are ignored until a\r
; a delimiter is found.\r
; entry hl	first character of name to be scanned\r
;	de	pointer into fcb name field\r
;	c	maximum length\r
; exit	hl	pointing to terminating delimiter\r
;	de	next empty byte in fcb name field\r
;	c	max length - number of characters transfered\r
;\r
getnam:	call	getch		;are we pointing to a delimiter yet?\r
	rz			;if so, name is transfered\r
	inx	h		;if not, move over character\r
	cpi	'*'		;ambigious file reference?\r
	jz	ambig		;if so, fill the rest of field with '?'\r
	cpi	'?'		;afn reference?\r
	jnz	notqm		;skip if not\r
	inr	b		;else bump afn count\r
notqm:	call	cvtuc		;if not, convert to upper case\r
	stax	d		;and copy into name field\r
	inx	d		;increment name field pointer\r
	dcr	c		;if name field full?\r
	jnz	getnam		;nope - keep filling\r
	jmp	getdel		;yup - ignore until delimiter\r
ambig:	mvi	a,'?'		;fill character for wild card match\r
fillq:	stax	d		;fill until field is full\r
	inx	d\r
	inr	b		;increment count of '?'\r
	dcr	c\r
	jnz	fillq		;fall thru to ingore rest of name\r
getdel:	call	getch		;pointing to a delimiter?\r
	rz			;yup - all done\r
	inx	h		;nope - ignore antoher one\r
	jmp	getdel\r
;\r
; getch gets the character pointed to by the text pointer\r
; and sets the zero flag if it is a delimiter.\r
; entry hl	text pointer\r
; exit	hl	preserved\r
;	a	character at text pointer\r
;	z	set if a delimiter\r
;\r
getch:	mov	a,m		;get the character, test for delim\r
;\r
; global entry: test char in a for filename delimiter\r
;\r
fndelm:	cpi	'/'\r
	rz\r
	cpi	'.'\r
	rz\r
	cpi	','\r
	rz\r
	cpi	' '\r
	rz\r
	cpi	':'\r
	rz\r
	cpi	'='\r
	rz\r
	ora	a		;set zero flag on end of text\r
	ret\r
;\r
; bdos entry: preserves bc, de.  if system call is a file\r
;	      function, this routine logs into the drive/\r
;	      user area specified, then logs back after\r
;	      the call.\r
;\r
bdos:	call	filfck		;check for a file function\r
	jnz	bdos1		;jump if not a file function\r
	call	getdu		;get drive/user\r
	shld	savedu\r
	ldax	d		;get fcb's drive\r
	sta	fcbdrv		;save it\r
	dcr	a		;make 0-relative\r
	jm	bdos0		;if not default drive, jump\r
	mov	h,a		;copy to h\r
bdos0:	xra	a		;set fcb to default\r
	stax	d\r
	dcx	d		;get fcb's user #\r
	ldax	d\r
	mov	l,a\r
	inx	d		;restore de\r
	call	setdu		;set fcb's user\r
;\r
; note that unspecified user # (value=0ffh) becomes\r
; a getusr call, preventing ambiguity.\r
;\r
	call	bdos1		;do user's system call\r
	push	psw		;save result\r
	push	h\r
	lda	fcbdrv		;restore fcb's drive\r
	stax	d\r
	lhld	savedu		;restore prior drive/user\r
	call	setdu\r
	pop	h		;restore bdos result registers\r
	pop	psw\r
	ret\r
;\r
; local variables for bdos replacement routine\r
;\r
savedu:	dw	0		;saved drive,user\r
fcbdrv:	db	0		;fcb's drive\r
dmadr:	dw	80h		;current dma adrs\r
;\r
bdos1:	push	d\r
	push	b\r
	mov	a,c		;doing setdma?\r
	cpi	sdmaf\r
	jnz	bdos1a		;jump if not\r
	xchg			;yep, keep a record of dma addresses\r
	shld	dmadr\r
	xchg\r
bdos1a:	call	system\r
	pop	b\r
	pop	d\r
	ret\r
;\r
; get drive, user: h=drv, l=user\r
;\r
getdu:	push	b		;don't modify bc\r
	push	d\r
	mvi	c,gsuser	;get user #\r
	mvi	e,0ffh\r
	call	bdos1\r
	push	psw		;save it\r
	mvi	c,getdrf	;get drive\r
	call	bdos1\r
	mov	h,a		;drive returned in h\r
	pop	psw\r
	mov	l,a		;user in l\r
	pop	d\r
	pop	b		;restore caller's bc\r
	ret\r
;\r
; set drive, user: h=drv, l=user\r
;\r
setdu:	push	b		;don't modify bc\r
	push	d\r
	push	h		;save info\r
	mov	e,h		;drive to e\r
	mvi	c,seldf		;set it\r
	call	bdos1\r
	pop	h		;recall info\r
	push	h\r
	mov	e,l		;user # to e\r
	mvi	c,gsuser\r
	call	bdos1		;set it\r
	pop	h\r
	pop	d\r
	pop	b\r
	ret\r
;\r
; check for file-function: open, close, read random, write\r
;	random, read sequential, write sequential.\r
;\r
filfck:	mov	a,c		;get function #\r
	cpi	openf\r
	rz\r
	rc			;ignore lower function #'s\r
	cpi	closef		;(they're not file-related)\r
	rz\r
	cpi	readf\r
	rz\r
	cpi	writef\r
	rz\r
	cpi	rrand\r
	rz\r
	cpi	wrand\r
	rz\r
	cpi	fsrchf\r
	rz\r
	cpi	fsrchn\r
	rz\r
	cpi	erasef\r
	rz\r
	cpi	creatf\r
	rz\r
	cpi	filszf\r
	rz\r
	cpi	srand\r
	ret\r
;\r
; convert char to upper case\r
;\r
cvtuc:	cpi	'a'		;check lo bound\r
	rc\r
	cpi	'z'+1		;check hi\r
	rnc\r
	sui	20h		;convert\r
	ret\r
;\r
; check for hex filetype in fcb name\r
;\r
hexchk:	push	h\r
	push	d\r
	push	b\r
	mvi	b,3		;type is 3 chars\r
	lxi	d,dfcb+9	;point de to type field\r
	lxi	h,hextyp	;point hl to "COM"\r
hexlop:	ldax	d\r
	ani	7fh		;ignore attributes\r
	cmp	m\r
	inx	h\r
	inx	d\r
	jnz	hexit		;jump if not com\r
	dcr	b\r
	jnz	hexlop\r
hexit:	pop	b		;z reg has result\r
	pop	d\r
	pop	h\r
	ret\r
;\r
hextyp:	db	'HEX'\r
;\r
; routine to return user # without disturbing registers\r
;\r
getusr:	push	h\r
	push	d\r
	push	b\r
	mvi	c,gsuser\r
	mvi	e,0ffh\r
	call	bdos\r
	pop	b\r
	pop	d\r
	pop	h\r
	ret\r
;\r
; routine to return drive # without disturbing registers\r
;\r
getdsk:	push	h\r
	push	d\r
	push	b\r
	mvi	c,getdrf\r
	call	bdos\r
	pop	b\r
	pop	d\r
	pop	h\r
	ret\r
;\r
; these are the initial values of the variables, and\r
; are moved into the variables area by the setup routine.\r
; if you add variables, be sure to add their intial value\r
; into this table in the order corresponding to their\r
; occurance in the variables section.\r
;\r
varset:	dw	0			;bias\r
	dw	0			;hiload\r
	dw	0			;hipc\r
	db	0			;cksum\r
	dw	cmdbuf			;cmdptr\r
	db	0			;bufptr\r
	db	0			;lodflg\r
	dw	cmdbuf			;filbuf\r
	dw	0			;offset\r
	dw	0			;lodadr\r
	db	0,0,'           '	;outnam\r
	dw	0			;reccnt\r
	dw	0			;bytcnt\r
	db	0			;comflg\r
	dw	0			;comsiz\r
	db	0			;outflg\r
;\r
varlen	equ	$-varset	;define length of init table\r
;\r
; working variables\r
;\r
vars	equ	$		;define variables area start\r
;\r
bias:	ds	2		;load offset\r
hiload:	ds	2		;highest true load address\r
hipc:	ds	2		;highest pc\r
cksum:	ds	1		;record checksum\r
cmdptr:	ds	2		;command line pointer\r
bufptr:	ds	1		;input buffer pointer\r
lodflg:	ds	1		;something-loaded flag\r
filbuf:	ds	2		;file buffer location\r
offset:	ds	2		;load offset into buffer\r
lodadr:	ds	2		;load address\r
outnam:	ds	13		;output drive+name\r
reccnt:	ds	2		;output file record count\r
bytcnt:	ds	2		;output file bytes loaded  count\r
comflg:	ds	1		;flags com file encountered\r
comsiz:	ds	2		;size of a loaded com file\r
outflg:	ds	1		;flags an "=" present in cmd line\r
;\r
; end of working variables\r
;\r
;\r
;\r
; stack stuff\r
;\r
spsave:	ds	2		;system stack pntr save\r
;\r
;\r
	ds	100		;50-level stack\r
;\r
stack	equ	$\r
cmdbuf	equ	$		;command buffer location\r
;\r
;\r
	end\r