RomWBW/Source/BPBIOS/ZCPR33/zcpr33n.z80


								; PROGRAM:	ZCPR

								; VERSION:	3.3

								; DERIVATION:	ZCPR30

								; AUTHOR:	Jay Sage

								; DATE:		May 28, 1987


								; ZCPR33 is copyright 1987 by Echelon, Inc.  All rights reserved.  End-user

								; distribution and duplication permitted for non-commercial purposes only.

								; Any commercial use of ZCPR33, defined as any situation where the duplicator

								; recieves revenue by duplicating or distributing ZCPR33 by itself or in

								; conjunction with any hardware or software product, is expressly prohibited

								; unless authorized in writing by Echelon.

								;

								; Echelon specifically disclaims any warranties, expressed or implied,

								; including but not limited to implied warranties of merchantability and

								; fitness for a particular purpose.  In no event will Echelon be liable for

								; any loss of profit or any other commercial damage, including but not limited

								; to special, incidental, consequential, or other damages.

								;

								; Echelon can be contacted at:

								;      Echelon, Inc.

								;      885 N. San Antonio Road

								;      Los Altos, California  USA  94022

								;      (415) 948-3820


								;-----------------------------------------------------------------------------

								;

								;		   A C K N O W L E D G M E N T S

								;

								;-----------------------------------------------------------------------------


								; Many people have played a role in the development of ZCPR in general and

								; ZCPR33 in particular.  It all started when "The CCP Group," including

								; Richard Conn, Ron Fowler, Keith Petersen, Frank Wancho, Charlie Strom, and

								; Bob Mathias decided that by rewriting the CP/M command processor to take

								; advantage of Zilog-specific opcodes they could save enough code to enhance

								; some of the features.   Richard Conn then extended that development through

								; ZCPR2 to ZCPR3 (3.0).  Just a little over two years ago, I took the first

								; step to enhance ZCPR3 by making it get the maximum drive and user values

								; from the environment instead of hard coding them in.   This version was

								; distributed privately as ZCPR31.  Along the way to what is now ZCPR

								; version 3.3 a number of others have made valuable contributions: Steve

								; Kitahata, Michael Bate, Bruce Morgen, Roger Warren, Dreas Nielsen, Bob Freed,

								; Al Hawley, Howard Goldstein, and many others who have stimulated developments

								; by pointing out problems or asking questions.


								; I would like particularly to acknowledge two people who have played a very

								; significant role in these developments.  One is Al Hawley.  He introduced

								; the idea of having the DUOK flag in the environment control how the CPR

								; would respond to the DU: form of directory reference.  He also originated

								; the idea of using the high bit of the first character of each command name

								; to control whether or not it would be wheel restricted.  Finally, he

								; contributed the basic structure of the highly efficient, elegant, and more

								; general number evaluation routines in the code.


								; My biggest debt of gratitude is to Howard Goldstein.  His role in the

								; development of ZCPR33 goes back about a year, when he contributed the first

								; correct implementation of the minpath feature.  More recently, during the

								; period of intense development since Echelon expressed its interest in my

								; writing the official 3.3 version, he and I have shared an especially

								; enjoyable and fruitful relationship.  Most of the newest ideas have been

								; worked out jointly, and Howard has done a great deal to keep my code and

								; concepts on track.  He discovered many ways to pare the code down and, more

								; importantly, uncovered numerous subtle bugs.  He recoded the SAVE command

								; to make it more compact and reliable.

								;

								;						Jay Sage

								;						May 28,1987


								;-----------------------------------------------------------------------------

								;

								;		U S E R    C O N F I G U R A T I O N

								;

								;-----------------------------------------------------------------------------


								; The following MACLIB statements load all the user-selected equates

								; which are used to customize ZCPR33 for the user's working environment.

								; NOTE -- TRUE & FALSE are defined in Z3BASE.


								memtop	equ	0FFE0H - 1	; Reserve memory above this for HBIOS

								base	equ	0


									maclib	z3basen.lib

									maclib	z33hdr.lib


								; Check that the configuration includes the required facilities


								; A ZCPR33 system is assumed to include certain minimal features, including

								; an external file control block, external path, shell stack, message buffer,

								; external environment descriptor, multiple command line, and external stack.

								; If wheel checking is enabled in the Z33HDR.LIB file, then there must be

								; an address defined for the wheel byte in the Z3BASE.LIB file.


								errflag	defl	extfcb eq 0			; External command FCB

								errflag	defl	errflag or [ expath eq 0 ]	; Symbolic path

								errflag	defl	errflag or [ shstk  eq 0 ]	; Shell stack

								errflag	defl	errflag or [ z3msg  eq 0 ]	; Message buffer

								errflag	defl	errflag or [ z3env  eq 0 ]	; Environment descriptor

								errflag	defl	errflag or [ z3cl   eq 0 ]	; Multiple command line

								errflag	defl	errflag or [ extstk eq 0 ]	; External stack

									 if	wheel or wdu or wpass or wprefix or whldir

								errflag	defl	errflag or [ z3whl  eq 0 ]	; Wheel byte

									 endif	;wheel or wdu or wpass or wprefix or whldir


									 if	errflag


									*** NOT ALL REQUIRED ZCPR3 FACILITIES ARE SUPPORTED ***


									 else	; go ahead with the assembly


								;-----------------------------------------------------------------------------

								;

								;		D E F I N I T I O N S    S E C T I O N

								;

								;-----------------------------------------------------------------------------


								; ----------   Macro definitions


									maclib	z33mac.lib		; Library of macros for ZCPR33


								; ----------   ASCII definitions


								ctrlc	equ	03h

								bell	equ	07h

								tab	equ	09h

								lf	equ	0ah

								cr	equ	0dh


								; ----------   Operating system addresses


								wboot	equ	base+0000h	; CP/M warm boot address

								udflag	equ	base+0004h	; User number in high nybble, disk in low

								bdos	equ	base+0005h	; BDOS function call entry point

								tfcb	equ	base+005ch	; Default FCB buffer

								tfcb2	equ	tfcb+16		; 2nd FCB

								tbuff	equ	base+0080h	; Default disk I/O buffer

								tpa	equ	base+0100h	; Base of TPA

								;bios	equ	ccp+0800h+0e00h	; BIOS location


								; ----------   Error codes


								; ZCPR33 uses the error byte at the beginning of the message buffer as a flag

								; to show what kind of error occurred.  Advanced error handlers will be able

								; to help the user further by suggesting the possible cause of the error.

								; Error code 6 for an ECP error is determined by the code and cannot be

								; changed (without increasing code length).


								ecduchg		equ	1	; Directory change error -- attempt to change

												; ..logged directory when under control of

												; ..wheel byte and wheel is off


								ecbaddir	equ	2	; Bad directory specification -- logging of

												; ..user number beyond legal range,

												; ..nonexistent named directory


								ecbadpass	equ	3	; Bad password -- incorrect password entered


								ecbadcmd	equ	5	; Bad command form -- wildcard or file type

												; ..present in command verb


								ececperr	equ	6	; ECP error --  command could not be executed

												; ..by ECP, error handling was forced by a

												; ..transient for its own reasons

												; (DO NOT CHANGE FROM 6)


								ecnocmd		equ	7	; Command file not found -- command that skips

												; ..ECP could not be executed, GET could not

												; ..find file to load


								ecambig		equ	8	; Ambiguous file specification where not

												; ..allowed (SAVE, GET, REN)


								ecbadnum	equ	9	; Bad numerical value -- not a number where

												; ..number expected, number out of range


								ecnofile	equ	10	; File not found -- REN, TYPE, LIST could not

												; ..find a specified file


								ecdiskfull	equ	11	; Disk directory or data area full


								ectpafull	equ	12	; TPA overflow error


								; ----------   Multiple command line equates


								; The multiple command line buffer is located in a protected area in memory so

								; that it is not overwritten during warm boots.  It includes some pointers so

								; that when ZCPR33 starts it can tell where to start reading the command line.

								; BUFSIZ and CHRCNT are not used by ZCPR33 but are provided so that the BDOS

								; line input function can be used to read in a command line.


								nxtchr	equ	z3cl		; Address where pointer to next command to

												; ..process is kept

								bufsiz	equ	z3cl+2		; Address where size of buffer is kept

								chrcnt	equ	z3cl+3		; Address where length of string actually in

												; ..the buffer is kept (not always reliable)

								cmdlin	equ	z3cl+4		; Address of beginning of command line buffer

								buflen	equ	z3cls		; Length of command line buffer


								; ----------   Command file control block


								; In ZCPR33 the file control block for commands must be located in protected

								; memory.  This not only frees up valuable space in the command processor for

								; code but also makes it possible for programs to determine by what name they

								; were invoked.


								cmdfcb	equ	extfcb


								; ----------   External CPR stack


								stack	equ	extstk+48	; Set top-of-stack address

								pwlin	equ	extstk		; Place line at bottom of stack


								; ----------  Environment


								quietfl	equ	z3env+28h	; Quiet flag

								maxdrenv equ	z3env+2ch	; Maximum drive value

								maxusrenv equ	z3env+2dh	; Maximum user value

								duokfl	equ	z3env+2eh	; Flag indicating acceptance of DU: form

								crttxt0	equ	z3env+33h	; Address of number of lines of text on the

												; ..screen of CRT0


								; ----------  Message buffer


								ecflag		equ	z3msg		; Error return code flag

								ifptrfl		equ	z3msg+1		; Pointer to current IF level

								ifstatfl 	equ	z3msg+2		; Flow control status byte

								cmdstatfl	equ	z3msg+3		; Command status flag

								cmdptr		equ	z3msg+4		; Pointer to currently running command

								zexinpfl	equ	z3msg+7		; ZEX input status/control flag

								zexrunfl	equ	z3msg+8		; ZEX running flag

								errcmd		equ	z3msg+10h	; Error handling command line

								xsubflag	equ	z3msg+2ch	; XSUB input redirection flag

								subflag		equ	z3msg+2dh	; Submit running flag

								curusr		equ	z3msg+2eh	; Currently logged user

								curdr		equ	z3msg+2fh	; Currently logged drive


								;-----------------------------------------------------------------------------

								;

								;		C O D E    M O D U L E S    S E C T I O N

								;

								;-----------------------------------------------------------------------------


									page


								; ZCPR33-1.Z80


								;=============================================================================

								;

								;    E N T R Y    P O I N T S    A N D    H E A D E R    S T R U C T U R E

								;

								;=============================================================================


									 if	not rel		; If generating absolute code

									org	ccp

									 else

									common /_BIOS_/

								bios	equ	$

									cseg

									 endif	;not rel


								; ENTRY POINTS INTO ZCPR33

								;

								; For compatibility with CP/M, two entry points are provided here.  In

								; standard CP/M if the code is entered from the first entry point, then the

								; command in the resident command buffer is executed; if entered from the

								; second entry point, the command line is flushed.  With ZCPR33 and its

								; multiple command line buffer, these two entry points function identically

								; and go to the same address.

								;

								; We have kept the entry points in their standard locations but have used a

								; relative jump for the second entry point and replaced the last byte with the

								; version number.  In this way the version number occupies a position that

								; would otherwise contain the page number at which the CPR runs.  It will

								; always be possible, therefore, to distinguish ZCPR33 and later versions

								; from other command processors.  The first jump is kept as an absolute jump

								; so that 1) the code will be compatible with Z-COM and Z3-DOT-COM and 2) the

								; execution address of a CPR module can always be determined.


								entry:

									jp	zcpr


									jr	zcpr


								version:

									defb	33h		; Version ID squeezed in here (offset = 5)


								;-----------------------------------------------------------------------------


								; Configuration information


								options:			; (offset = 6)

								  optflag badduecp,rootonly,ndrenv,fcpenv,rcpenv,inclenv,aduenv,duenv

								  optflag highuser,drvprefix,scancur,incldir,incldu,dufirst,accptdir,accptdu

								  optflag no,pwcheck,pwnoecho,wdu,wpass,wprefix,fastecp,skippath


								attdir	defl	[ comatt eq 80h ] or [ comatt eq 01h ] or [ not attchk ]

								attsys	defl	[ comatt eq 00h ] or [ comatt eq 01h ] or [ not attchk ]

								subquiet defl	[ subnoise eq 1 ]

								subecho	defl	[ subnoise gt 1 ]


								  optflag shellif,attsys,attdir,attchk,subecho,subquiet,subclue,subon


								; Byte with information about the alternate colon option.  If the byte is

								; zero, the option is not supported.  Otherwise the byte contains the

								; prefix character that serves as an alias for a colon prefix.  Offset = 10.


									 if	altcolon

									defb	altchar

									 else

									defb	0

									 endif	;altcolon


								; Byte with information about the FASTECP implementation (option bit above

								; indicates whether the feature is enabled at all).  If no character appears

								; here (zero byte), then only a leading space can be used.  Otherwise, the

								; first seven bits contain the character, and the high bit, if set, indicates

								; that ONLY this character will be recognized and not a space.  Offset = 11.


									 if	fastecp and altspace

									 if	altonly

									defb	ecpchar + 80h

									 else	;not altonly

									defb	ecpchar

									 endif	;altonly

									 else	;no alternate character

									defb	0

									 endif	;fastecp and altspace


									defb	0,0,0,0			; Space reserved for expansion


								;-----------------------------------------------------------------------------


								; Entry points to file name parsing code.


								; Entry point REPARSE.  A call to this point can be used to parse a command

								; line tail into the default file control blocks at 5CH and 6CH.  Each time

								; the parser is called it leaves the starting address of the second token in

								; the PARESPTR address below so that successive calls to the routine reparse

								; the command tail one token later.  A program can load its own pointer into

								; PARSEPTR as well.  Offset = 16 (10h).


								reparse:

								parseptr equ	$+1		; Pointer for in-the-code modification

									ld	hl,0

									jp	parsetail


								; Entry point SCAN.  A call to this point can be used to parse a single token

								; pointed to by HL into the FCB pointed to by DE.  Offset 22 (16h).


								scan:

									jp	scanner


								;-----------------------------------------------------------------------------


								; BUFFERS

								;

								; In this area various data items are kept.  First comes the list of commands

								; supported by ZCPR33; then comes the name of the extended command processor

								; (ECP).  By putting these items here, an 'H' command in the RCP or a utility

								; like SHOW.COM can find this information and report it to the user.


								; ----------   RESIDENT COMMAND TABLE


								; The command table entry is structured as follows:  First there is a byte

								; which indicates the number of characters in each command.  Then there is a

								; series of entries comprising the name of a command followed by the address

								; of the entry point to the code for carrying out that command.  Finally,

								; there is a null byte (00h) to mark the end of the table.  Offset = 25 (19h).


								cmdtbl:

									defb	cmdsize		; Length of command names

									ctable			; Define table via macro in Z33HDR.LIB

									defb	0		; End of table


								; ----------  NAME FOR EXTENDED COMMAND PROCESSOR


								; The name of the extended command processor is placed here after the command

								; table so that utilities like SHOW or an RCP 'H' command can find it.


								ecpfcb:

									ecpname			; From Z33HDR.LIB


								; ----------   FILE TYPE FOR TRANSIENT COMMANDS (usually COM)


								; This file type also applies to the extended command processor name.


								commsg:

									comtyp			; From Z33HDR.LIB


								; ----------   SUBMIT FILE CONTROL BLOCK


									 if	subon		; If submit facility enabled ...


								subfcb:

									defb	subdrv-'A'+1	; Explicit drive for submit file

									defb	'$$$     '	; File name

									subtyp			; From Z33HDR.LIB

									defb	0		; Extent number

									defb	0		; S1 (user number 0)

								subfs2:

									defs	1		; S2

								subfrc:

									defs	1		; Record count

									defs	16		; Disk group map

								subfcr:

									defs	1		; Current record number


									 endif	; subon


								; End ZCPR33-1.Z80


									page


								; ZCPR33-2.Z80


								;=============================================================================

								;

								;	C O M M A N D    L I N E    P R O C E S S I N G    C O D E

								;

								;=============================================================================


								; MAIN ENTRY POINT TO CPR


								; This is the main entry point to the command processor.  On entry the C

								; register must contain the value of the user/drive to be used as the current

								; directory.


								zcpr:

									ld	sp,stack	; Reset stack


									 if	pwnoecho

									ld	a,0c3h		; Reenable BIOS conout routine

									ld	(bios+0ch),a	; ..after a warmboot

									 endif	;pwnoecho


									ld	b,0fh		; Keep nibble mask in B


								; If the HIGHUSER option is enabled, we compare the user/drive in the login

								; byte in C to the values stored in the message buffer.  If, ignoring bit 4

								; of the user number, they match, then we remain in the current area, which

								; may be a user area above 15.


									 if	highuser


									ld	a,c		; Copy user/drive byte to A

									and	b		; Isolate drive

									ld	d,a		; ..and move to D

									ld	a,c		; Get full byte back

									swap			; Swap nibbles

									and	b		; Isolate user number

									ld	e,a		; ..and move to E

									ld	hl,(curusr)	; Get old curdr/curusr into HL

									sbc	hl,de		; Subtract new values from old (carry is clear)

									ex	de,hl		; Switch new values into HL, diff into DE

									ld	a,d		; Combine two parts of difference

									or	e

									and	b		; Ignore bit for high user numbers

									jr	z,zcpr1		; Skip update if no change in DU

									ld	(curusr),hl	; Update values of current drive and user

								zcpr1:


									 else	;not highuser


									ld	a,c		; Copy user/drive byte to A

									and	b		; Isolate drive

									ld	h,a		; ..and move to H

									ld	a,c		; Get full byte back

									swap			; Swap nibbles

									and	b		; Isolate user number

									ld	l,a		; ..and move to L

									ld	(curusr),hl	; ..and save them


									 endif	;highuser


								; This block of code is executed when submit processing is enabled.  We log

								; into user area 0, where the submit file is kept, and we search the

								; designated drive for the file.  The result is kept in SUBFLAG.  This code

								; only has to be executed on reentry to the command processor at the main

								; entry point.  Commands that do not reboot but simply return to the CPR will

								; execute without the disk reset and file search required here.  Ron Fowler

								; pointed out a shortcut based on the fact that after a disk reset, the A

								; regiser contains a value of 0 if there is no file on drive A with a '$' in

								; the file name and 0FFH if there is such a file.  Thus if A = 0, there can

								; be no '$$$.SUB' file on drive A.  This trick is, unfortunately, not reliable

								; under some versions of ZRDOS.  Therefore, an option has been included to

								; use or not use this shortcut.


									 if	subon		; If submit facility enabled ..


									call	defltdma	; Set DMA address to 80H

									ld	a,0		; Log into user area 0

									call	setuser

									ld	c,0dh		; Reset disk system (returns 0FFH if a $$$.SUB

									call	bdossave	; ..file might exist in user 0)

									ld	de,subfcb	; Point to submit file FCB with explicit drive


									 if	subclue

									call	nz,srchfst	; Search only if flag says it could exist

									 else	;not subclue

									call	srchfst		; Search for the file unconditionally

									 endif	;subclue


									ld	(subflag),a	; Set flag for result (0 = no $$$.SUB)


									 else	;not subon


									ld	c,0dh		; Reset disk system

									call	bdossave


									 endif	; subon


									jr	nextcmd		; Go to entry point for processing next command


								;-----------------------------------------------------------------------------


								; NEW COMMAND LINE ENTRY POINT


								; This entry point is used when ZCPR33 finds the command line empty.  A call to

								; READBUF gets the next command line from the following possible sources in

								; this order:

								;	1) a running ZEX script

								;	2) the submit file $$$.SUB (if enabled)

								;	3) the shell stack

								;	4) the user

								; If the line comes from the shell stack, then the shell bit in the command

								; status flag is set.


								restart:

									ld	sp,stack	; Reset stack

									xor	a

									ld	(cmdstatfl),a	; Reset ZCPR3 command status flag

									inc	a		; Set ZEX message byte to 1 to

									ld	(zexinpfl),a	; ..indicate command prompt

									 if	subon

									ld	(xsubflag),a	; Ditto for XSUB flag

									 endif	;subon

									ld	hl,cmdlin	; HL --> beginning of command line buffer

									ld	(nxtchr),hl	; Save as pointer to next character to process

									ld	(hl),0		; Zero out command line (in case of warm boot)

									push	hl		; Save pointer to command line

									call	readbuf		; Input command line (ZEX, submit, shell,

												; ..or user)

									pop	hl		; Get back pointer to command line

									ld	a,(hl)		; Check for comment line

									cp	comment		; Begins with comment character?

									jr	z,restart	; If so, go back for another line

												; Otherwise, fall through


								;-----------------------------------------------------------------------------


								; COMMAND CONTINUATION PROCESSING ENTRY POINT


								; This is the entry point for continuing the processing of an existing command

								; line.  The current drive and user values as known to the CPR are combined

								; and made into the user/drive byte that CP/M keeps at location 0004.  If the

								; HIGHUSER option is enabled, the user number for this byte is forced to be

								; in the range 0..15.  Next the command status flag is processed.  The error

								; and ECP bits in the actual flag are reset, and the original flag is checked

								; for an ECP error return (both ECP bit and error bit set).  In that case,

								; control is transferred to the error handler.


								nextcmd:

									ld	hl,(curusr)	; Get currently logged drive and user

									ld	a,l		; Work on user number

									 if	 highuser

									and	0fh		; Keep value modulo 16

									 endif	;highuser

									swap			; Get user into high nibble

									or	h		; ..and drive into low nibble

									ld	(udflag),a	; Set user/disk flag in page 0


									ld	a,2		; Turn ZEX input redirection off

									ld	(zexinpfl),a

									 if	subon

									ld	(xsubflag),a	; Turn off XSUB input redirection

									 endif	;subon


									ld	hl,cmdstatfl	; Point to the command status flag (CSF)

									ld	a,(hl)		; Get a copy into register A

									res	1,(hl)		; Reset the actual error bit

									res	2,(hl)		; Reset the actual ECP bit

									and	110b		; Select ECP and error bits in original flag

									cp	110b		; Test for an ECP error

									jp	z,error		; Process ECP error with error handler


								nextcmd1:

									ld	sp,stack	; Reset stack

									call	logcurrent	; Return to default directory

									ld	hl,(nxtchr)	; Point to first character of next command

									push	hl		; Save pointer to next character to process


								; We have to capitalize the command line each time because an alias or other

								; command line generator may have stuck some new text in.  The code is shorter

								; if we simply capitalize the entire command rather than trying to capitalize

								; only the one command we are about to execute.


								capbuf:				; Capitalize the command line

									ld	a,(hl)		; Get character

									call	ucase		; Convert to upper case

									ld	(hl),a		; Put it back

									inc	hl		; Point to next one

									or	a		; See if end of line (marked with null)

									jr	nz,capbuf	; If not, loop back


									pop	hl		; Restore pointer to next character to process


								nextcmd3:


								; ZCPR33 provides a convenience feature to make it easier to enter a leading

								; colon to force the current directory to be scanned and to make the CPR skip

								; resident commands.  If ALTCOLON is active, an alternate character can be

								; entered as the first character of a command.  The default (and recommended)

								; alternative character is the period (it could not have any other meaning

								; here).  If FASTECP (see below) is not enabled or if ALTONLY is enabled,

								; leading spaces on the command line are skipped before looking for the

								; alternate character for the colon


									 if	[ not fastecp ] or [ fastecp and altonly ]

									call	sksp

									 endif	;[ not fastecp ] or [ fastecp and altonly ]


									 if	altcolon	; If allowing alias character for leading colon

												; Set B = ':' and C = alias character ('.')

									ld	bc,':' shl 8 + altchar

									ld	a,(hl)		; Get first character in new command line

									cp	c		; If first character is ALTCHAR, treat as ':'

									jr	nz,nextcmd3a	; Branch if not '.'

									ld	(hl),b		; Else replace with colon

								nextcmd3a:

									 endif	;altcolon


								; ZCPR33 supports three new options that can speed up command processing.

								; FASTECP allows commands with a leading space to bypass the search for

								; resident commands or transient commands (COM files) along the path and go

								; directly to the extended command processor.  With SKIPPATH enabled, when

								; a command is prefixed by an explicit directory specification (but not a

								; lone colon), searching of the path and invocation of the ECP are disabled.

								; If the command is not found in the specified directory, the error handler

								; is invoked immediately.  Finally, if BADDUECP is enabled, when an attempt

								; is made to log into an invalid directory, the command is sent directly to

								; the ECP, which can provide special handling.  To implement these three

								; features, the first actual character of the command line is saved as a

								; flag in FIRSTCHAR.  My apologies for the complexity of these nested

								; conditionals.


									 if	fastecp or skippath or badduecp


										; With FASTECP we store the first actual

										; ..character and then skip over spaces (unless ALTONLY is

										; ..enabled, in which case we skipped spaces above)


									 if	fastecp


									 if	altspace	; If allowing alias character for leading space

												; Set B = ' ' and C = alias character ('/')

									ld	bc,' ' shl 8 + ecpchar

									ld	a,(hl)		; Get first character in new command line

									cp	c		; If first character is ECPCHAR treat as ' '

									jr	nz,nextcmd3b	; Branch if not '/' (alternate character)

									ld	(hl),b		; Else replace with space

								nextcmd3b:

									 endif	;altspace


									ld	a,(hl)		; Get first character in command line

									ld	(firstchar),a	; Save it in flag

									call	sksp		; Then skip leading spaces

									 endif	;fastecp


										; With SKIPPATH but not FASTECP we store the first

										; ..character of the command (spaces were skipped above)


									 if	[ not fastecp ] and skippath

									ld	(firstchar),a	; Store first nonspace character

									 endif	;[ not fastecp ] and skippath


										; With only BADDUECP (and neither SKIPPATH nor FASTECP)

										; ..we store a null in the FIRSTCHAR flag


									 if	[ not fastecp ] and [ not skippath ]

									xor	a

									ld	(firstchar),a

									 endif	;[ not fastecp ] and [ not skippath ]


									 endif	;fastecp or skippath or badduecp


								; Resume processing of the command line


									or	a		; Now at end of line?

									jr	z,restart	; If so, get a new command line

									cp	ctrlc		; Flush ^C to prevent error-handler

									jr	z,restart	; ..invocation on warm boots


									cp	cmdsep		; Is it a command separator?

									jr	nz,nextcmd4	; If not, skip ahead to process the command

									inc	hl		; If it is, skip over it

									jr	nextcmd3	; ..and process next command


								nextcmd4:


								; Unless we are now running the external error handler, the following code

								; saves the address of the current command in Z3MSG+4 for use by programs

								; to determine the command line with which they were invoked.


									ld	a,(cmdstatfl)	; Get command status flag

									bit	1,a		; Test for error handler invocation

									jr	nz,nextcmd5	; If so, skip over next instruction

									ld	(cmdptr),hl


								nextcmd5:

									call	parser		; Parse entire command line, then look for

												; ..the command


								;=============================================================================


								;		C O M M A N D    S E A R C H    C O D E


								;=============================================================================


								; CODE FOR FINDING AND RUNNING THE COMMAND


								; Here is the code for running a command.  Commands are searched for and

								; processed in the following order:

								;

								;	1) flow control package (FCP) commands and IF state testing

								;	2) resident command package (RCP)

								;	3) command processor (CPR)

								;	4) transient (COM file or extended command processor)

								;	5) external error handler

								;	6) internal error message and processing

								;

								; Special notes:

								;

								;    a)	If the current command is a shell command, special handling of flow

								; 	control is required.  If SHELLIF is enabled so that flow commands are

								;	allowed in shell alias scripts, then we reset the flow state to its

								;	initial condition (none) with each shell invocation (and after each

								;	command is run, we reset the shell bit in the code after CALLPROG).

								;	In this case shells will run regardless of flow state, and residual

								;	conditionals from the last running of the shell are flushed.  Each

								;	shell input sequence begins afresh.  On the other hand, if SHELLIF is

								;	off, flow control commands inside a shell script must be flushed so

								;	that they do not interfere with user entered commands.

								;    b)	Directory prefixes are ignored for flow commands, since all flow control

								;	processing must pass through the FCP (the command must run even when

								;	the current flow state is false).

								;    c)	If the command is not found in the FCP, then the current flow state is

								;	tested.  If it is false, the command is flushed and the code branches

								;	back to get the next command.

								;    d)	If the command had a directory prefix (a colon alone is sufficient),

								;	then steps #2 and #3 are skipped over,and the command is processed

								;	immediately as a transient program.

								;    e)	In ZCPR33, unlike ZCPR30, RCP commands are scanned before CPR commands.

								;	This has been done so that more powerful RCP commands can supercede

								;	CPR commands.

								;    f)	If the SKIPPATH option is enabled, when an explicit directory is

								;	specified with a command (but not just a colon), searching of the path

								;	is bypassed.  If the FASTECP option is enabled, commands with leading

								;	spaces are sent directly to the ECP for processing.

								;    g)	If no external command can be found, ZCPR33 performs extensive error

								;	handling.  If the command error occurred while looking for a shell

								;	program, then the shell stack is popped.  Otherwise, ZCPR33 tries to

								;	invoke an external, user-specified error handling command line.  If

								;	none was specified or if the error handler invoked by that command

								;	line cannot be found, the internal error message (step #6) is displayed.


								;-----------------------------------------------------------------------------


								runcmd:

									 if	shellif		; If shells reininitialize flow control...

									ld	a,(cmdstatfl)	; Get command status flag

									bit	0,a		; Shell bit set?

									jr	z,fcpcmd	; If not a shell, process command

									xor	a		; Otherwise, shell is running, so

									ld	(ifptrfl),a	; ..reinitialize the IF system and continue

									 endif	;shellif


								; ---------- Module <<1>>: Flow Control Processing


								; An option is supported here to allow the address of the FCP to be obtained

								; from the environment descriptor.  This is logically consistent with the

								; pholosopy of the Z-System and is useful when one wants to have a single block

								; of FCP/RCP memory that can be allocated dynamically between FCP and RCP

								; functions.


								fcpcmd:


									 if	fcp ne 0	; Omit code if FCP not implemented


									 if	fcpenv		; If getting FCP address from Z3ENV


									ld	e,12h		; Offset in Z3ENV to FCP address

									call	pkgoff		; Set HL to FCP+5

									jr	z,runcmd1	; Skip if no FCP present


									 else	; using fixed FCP address


									ld	hl,fcp+5	; Get address from Z3BASE.LIB


									 endif	;fcpenv


								; If flow control processing is not allowed in shell aliases (scripts running

								; as shell commands), then we have to make sure that we flush any flow control

								; commmands, otherwise the CPR will attempt to execute them as transients,

								; with dire consequences.  In the code below we check the shell bit.  If it

								; is not set, we proceed normally.  If it is set, we scan for flow commands

								; and then jump past the flow testing to RUNFCP2, where the code will flush

								; the command if it was a flow command and execute it unconditionally if not.


									 if	not shellif

									ld	a,(cmdstatfl)	; Get command status flag

									bit	0,a		; If shell bit not set,

									jr	z,runfcp1	; ..we do normal processing

									call	cmdscan		; Otherwise, check for flow command

									jr	runfcp2		; ..and flush if so using code below

									 endif	;not shellif


								runfcp1:

									call	cmdscan		; Scan command table in the module

									jr	z,callprog	; Run if found (with no leading CRLF)


								; This is where we test the current IF state.  If it is false, we skip this

								; command.


									call	iftest		; Check current IF status


								runfcp2:			; If false, skip this command and go on to next

									 if	drvprefix	; If DRVPREFIX we can use code below

									jr	z,jpnextcmd	; ..to save a byte

									 else			; Otherwise, we have to do an

									jp	z,nextcmd	; ..absolute jump

									 endif	;drvprefix


									 endif	;fcp ne 0


								runcmd1:

									 if	fastecp or badduecp

									ld	a,(firstchar)	; If FIRSTCHAR flag set for ECP invocation,

									cp	' '		; ..then go straight to transient processing

									jr	z,com

									 endif	;fastecp or badduecp


								colon	equ	$+1		; Flag for in-the-code modification

									ld	a,0		; If command had a directory prefix (even just

									or	a		; ..a colon) then skip over resident commands

									jr	nz,comdir


								; ---------- Module <<2>>: RCP Processing


								; An option is supported here to allow the address of the RCP to be obtained

								; from the environment descriptor.  This is logically consistent with the

								; pholosopy of the Z-System and is useful when one wants to have a single block

								; of FCP/RCP memory that can be allocated dynamically between FCP and RCP

								; functions.


									 if	rcp ne 0	; Omit code if RCP not implemented


								rcpcmd:


									 if	rcpenv		; If getting address of rcp from Z3ENV


									ld	e,0ch		; Offset in Z3ENV to RCP address

									call	pkgoff		; Set HL to address of RCP+5

									jr	z,cprcmd	; Skip if no RCP


									 else	; using fixed RCP address


									ld	hl,rcp+5	; Get address from Z3BASE.LIB


									 endif	; rcpenv


									call	cmdscan		; Check for command in RCP

									jr	z,callproglf	; If so, run it (with leading CRLF)


									 endif	;rcp ne 0


								; ---------- Module <<3>>: CPR-Resident Command Processing


								cprcmd:


									ld	hl,cmdtbl	; Point to CPR-resident command table

									call	cmdscan		; ..and scan for the command

									jr	z,callprog	; If found, run it (with no leading CRLF)


								; ---------- Module <<4>>: Transient Command Processing


								comdir:				; Test for DU: or DIR: only (directory change)


									 if	drvprefix


									ld	a,(cmdfcb+1)	; Any command name?

									cp	' '

									jr	nz,com		; If so, must be transient or error


										; Entry point for change of directory only


									 if	wdu		; If controlled by wheel..


									ld	a,(z3whl)	; Get wheel byte

									or	a		; If wheel on, go on ahead

									jr	nz,comdir1


									 if	badduecp

									ld	(colon),a	; Pretend there is no colon

									ld	a,' '		; Force invocation of ECP

									ld	(firstchar),a

									jr	com

									 else	;not badduecp

									ld	a,ecduchg

									jr	z,error

									 endif	;badduecp


									 endif	; wdu


								comdir1:

									ld	hl,(tempusr)	; Get temporary drive and user bytes


									 if	not highuser	; If only users 0..15 can be logged

									ld	a,l		; Get user number and

									cp	16		; ..make sure not above 15

									jr	nc,baddirerr	; If out of range, invoke error handling

									 endif	;not highuser


									dec	h		; Shift drive to range 0..15

									ld	(curusr),hl	; Make the temporary DU into the current DU

									call	logcurrent	; Log into the new current directory

								jpnextcmd:

									jp	nextcmd		; Resume command line processing


									 else	;not drvprefix


									 if	badduecp

									xor	a		; Pretend there is no colon

									ld	(colon),a

									ld	a,' '		; Force invocation of ECP

									ld	(firstchar),a

									 else	;not badduecp

									ld	a,ecduchg

									jr	z,error

									 endif	;badduecp


									 endif	;drvprefix


								com:				; Process transient command


									ld	a,(cmdstatfl)	; Check command status flag to see if

									and	2		; ..error handler is running

									ld	(zexinpfl),a	; Store result in ZEX control flag (2 will turn

												; ..ZEX input redirection off (0 = on)

									 if	subon

									ld	(xsubflag),a	; Turn off XSUB input redirection also

									 endif	;subon


									ld	hl,tpa		; Set default execution/load address

									ld	a,3		; Dynamically load type-3 and above ENVs

									call	mload		; Load memory with file specified in cmd line

									ld	a,(cmdstatfl)	; Check command status flag to see if

									and	100b		; ..ECP running (and suppress leading CRLF)


								; CALLPROG is the entry point for the execution of the loaded program.  At

								; alternate entry point CALLPROGLF if the zero flag is set, a CRLF is sent to

								; the console before running the program.


								callproglf:

									call	z,crlf		; Leading new line


								callprog:

										; Copy command tail into TBUFF


								tailsv	equ	$+1		; Pointer for in-the-code modification

									ld	hl,0		; Address of first character of command tail

									ld	de,tbuff	; Point to TBUFF

									push	de		; Save pointer

									ld	bc,7e00h	; C=0 (byte counter) and B=7E (max bytes)

									inc	de		; Point to first char

								tail:

									ld	a,(hl)		; Get character from tail

									call	tsteol		; Check for EOL

									jr	z,tail1		; Jump if we are done

									ld	(de),a		; Put character into TBUFF

									inc	hl		; Advance pointers

									inc	de

									inc	c		; Increment character count

									djnz	tail		; If room for more characters, continue

									call	print		; Display overflow message

									db	bell		; ..ring bell

									db	'Ovf','l'+80h	; ..then continue anyway

								tail1:

									xor	a		; Store ending zero

									ld	(de),a

									pop	hl		; Get back pointer to character count byte

									ld	(hl),c		; Store the count


								; Run loaded transient program


									call	defltdma	; Set DMA to 0080h standard value


								; Perform automatic installation of Z3 programs (unless type-2 environment)


									ld	hl,(execadr)	; Get current execution address

									call	z3chk		; See if file is a Z3 program

									jr	nz,noinstall	; Branch if not


									cp	2		; If type-2 (internal) environment

									jr	z,noinstall	; ..do not perform installation


									inc	hl		; Advance to place for ENV address

									ld	(hl),low z3env	; Put in low byte of environment address

									inc	hl

									ld	(hl),high z3env	; Put in high byte


								noinstall:


								; Execution of the program occurs here by calling it as a subroutine


									ld	hl,z3env	; Pass environment address to program in HL

								execadr	equ	$+1		; Pointer for in-line code modification

									call	0		; Call transient


								; Return from execution


									 if	shellif		; If flow processing allowed in shells...

									ld	hl,cmdstatfl	; Reset the shell bit in the command status

									res	0,(hl)		; ..flag so multiple-command shells will work

									 endif	;shellif


												; Continue command processing

									 if	drvprefix	; If DRVPREFIX we can save a byte by

									jr	jpnextcmd	; ..doing a two-step relative jump

									 else			; Otherwise, we just have to do

									jp	nextcmd		; ..the absolute jump

									 endif	;drvprefix


								; ---------- Module <<5>>: External Error Handler Processing


								baddirerr:

									ld	a,ecbaddir	; Error code for bad directory specification


								error:


								; If we are returning from an external command to process an error, we want

								; to leave the error return code as it was set by the transient program.


									ld	hl,cmdstatfl	; Point to command status flag

									bit	3,(hl)		; Check transient error flag bit

									jr	nz,error1	; If set, leave error code as set externally

									ld	(ecflag),a	; Otherwise, save error code from A register


								error1:

									res	2,(hl)		; Reset the ECP bit to prevent recursion of

												; ..error handler by programs that don't

												; ..clear the bit

									bit	0,(hl)		; Was error in attempting to run a shell?

									jr	nz,errsh	; If so, pop shell stack


								; The following code is included to avoid a catastrophic infinite loop when

								; the external error handler cannot be found.  After one unsuccessful try,

								; the internal code is invoked.


									bit	1,(hl)		; Was an error handler already called?

									jr	nz,errintrnl	; If so, use internal error handler


								; If the current IF state is false, we would like to ignore the error and just

								; go on with the next command.  Unfortunately, for some errors (e.g., a bad

								; command format such as a command with a wildcard character) the error handler

								; is invoked before the pointer in the multiple command line buffer is set up

								; to the next command.  In that case, we fall into an infinite loop.  We also

								; must not allow the external error handler to run, since it will not run and

								; we will again fall into an infinite loop.  The present code is not so bad, of

								; course, since even a command in a false part of a command sequence should not

								; have a true error in it.  We have already put in code to bypass password

								; checking during a false IF state, since a command with a password is not an

								; invalid command.


									 if	fcp ne 0

									call	iftest		; If we are in a false IF state, external

									jr	z,errintrnl	; ..handler will not run, so use built-in

									 endif	;fcp ne 0


									set	1,(hl)		; Set command status flag for error invocation

									ld	hl,errcmd	; Point to error handler command line

									ld	a,(hl)		; Check first byte for presence of an

									or	a		; ..error command line

									jr	z,errintrnl	; If no error handler, use built-in one

									ld	(nxtchr),hl	; Else, use error command line as next command

									jp	nextcmd1	; Run command without resetting status flag


								; ---------- Module <<6>>: Resident Error Handler Code


								; If the error is with the invocation of a shell command, we pop the bad shell

								; command off the stack to prevent recursion of the error.  We then use the

								; the internal error handler to echo the bad shell command.


								errsh:


									ld	de,shstk	; Point to current entry in shell stack

									ld	hl,shstk+shsize	; Point to next entry in stack

									ld	bc,[shstks-1]*shsize	; Bytes to move

									ldir			; Pop the stack

									xor	a		; Clear the last entry position

									ld	(de),a


								errintrnl:

									 if	subon

									call	subkil		; Terminate active submit file if any

									 endif	;subon


									call	crlf		; New line

									ld	hl,(cmdptr)	; Point to beginning of bad command

									call	printhl		; Echo it to console

									call	print		; Print '?'

									defb	'?'+80h

									jp	restart		; Restart CPR


								; End ZCPR33-2.Z80


									page


								; ZCPR33-3.Z80


								;=============================================================================

								;

								;	   C O M M A N D    L I N E     P A R S I N G    C O D E

								;

								;=============================================================================


								; This code parses the command line pointed to by HL.  The command verb is

								; parsed, placing the requested program name into the command file control

								; block.  The drive and user bytes are set.  If an explicit DU or DIR was

								; given, the COLON flag is set so that the processor knows about this later

								; when the command search path is built.


								parser:


									ld	de,cmdfcb	; Point to the command FCB

									push	de

									call	initfcb		; Initialize the FCB

									pop	de

									ld	(duerrflag),a	; Store zero (INITFCB ends with A=0) into flag

									call	scanner		; Parse first token on command line into FCB

									jr	nz,badcmd	; Invoke error handler if '?' in command


								duerrflag equ	$+1		; Pointer for in-the-code modification

									ld	a,0		; See if bad DU/DIR specified with command verb

									or	a


									 if	badduecp

									jr	z,parser1	; If DU/DIR is OK, skip ahead

									ld	a,(cmdstatfl)	; If ECP already running

									bit	2,a		; ..skip ahead

									jr	nz,parser1

									ld	a,(cmdfcb+1)	; If not a directory change command

									sub	' '		; ..invoke error handler

									jr	nz,baddirerr

												; If bad directory change attempt,

									ld	(tmpcolon),a	; ..pretend there is no colon (A=0)

									ld	a,' '		; ..and force immediate ECP invocation

									ld	(firstchar),a	; ..when command is processed

									 else			; If errors not processed by ECP then

									jr	nz,baddirerr	; ..invoke error handler

									 endif	; badduecp


								parser1:

									ld	de,cmdfcb+9	; Make sure no explicit file type was given

									ld	a,(de)		; Get first character of file type

									cp	' '		; Must be blank

								badcmd:

									ld	a,ecbadcmd	; Error code for illegal command form

									jr	nz,error	; If not, invoke error handler


									push	hl		; Save pointer to next byte of command

									ld	hl,commsg	; Place default file type (COM) into FCB

									ld	bc,3

									ldir

									pop	hl		; Get command line pointer back


								; The following block of code is arranged so that the COLON flag is set only

								; when an explicit directory specification is detected in the command verb.

								; Other parses also change the TMPCOLON flag, but only when passing here does

								; the flag get transferred to COLON.


								tmpcolon equ	$+1		; Pointer for in-the-code modification

									ld	a,0		; ..by SCANNER routine

									ld	(colon),a	; If explicit DU/DIR, set COLON flag


								; Find the end of this command and set up the pointer to the next command.


									push	hl		; Save command line pointer

									dec	hl		; Adjust for preincrementing below

								parser2:			; Find end of this command

									inc	hl		; Point to next character

									ld	a,(hl)		; ..and get it

									call	tsteol		; Test for end of command

									jr	nz,parser2	; Keep looping if not


									ld	(nxtchr),hl	; Set pointer to next command

									pop	hl		; Get back pointer to current command tail


								; This block of code parses two tokens in the command line into the two

								; default FCBs at 5Ch and 6Ch.  It also sets a pointer to the command tail

								; for later copying into the command tail buffer at 80h.  This code is used

								; first when attempting to parse a normal command line and possibly again

								; later when the entire user's command is treated as a tail to the extended

								; command processor.  The resident JUMP and SAVE commands use it also, and

								; the entry point is available at location CCP+9 for use by other programs.


								parsetail:

									ld	(tailsv),hl	; Save pointer to command tail


												; Process first token


									ld	de,tfcb		; Point to first default FCB

									push	de		; Save pointer while initializing

									call	initfcb		; Initialize both default FCBs

									pop	de

									call	sksp		; Skip over spaces in command line

									call	nz,scanner	; If not end of line, parse the token

												; ..into first FCB

									ld	(parseptr),hl	; Save pointer to second token for reparsing


												; Process second token


									call	sksp		; Skip over spaces

									ret	z		; Done if end of line or end of command

									ld	de,tfcb2	; Point to second default FCB

												; ..and fall through to SCANNER routine


								;-----------------------------------------------------------------------------


								; This routine processes a command line token pointed to by HL.  It attempts

								; to interpret the token according to the form [DU:|DIR:]NAME.TYP and places

								; the corresponding values into the FCB pointed to by DE.  On exit, HL points

								; to the delimiter encountered at the end of the token.  The Z flag is set if

								; a wild card was detected in the token.


								scanner:

									xor	a		; Initialize various flags

									ld	(tmpcolon),a	; Set no colon

									ld	bc,(curusr)	; Get current drive and user into BC

									inc	b		; Shift drive range from 0..15 to 1..16

									ld	(tempusr),bc	; Initialize temporary DU


									call	scanfld8	; Extract possible file name

									cp	':'		; Was terminating character a colon?

									jr	nz,scantype	; If not, go on to extract file type

									ld	(tmpcolon),a	; Otherwise, set colon and process DU/DIR

									inc	hl		; Point to character after colon


								; Code for resolving directory specifications (macro RESOLVE is defined in

								; Z33MAC.LIB).  RESOLVE returns with a nonzero value and a NZ flag setting

								; if the DU/DIR specification cannot be resolved.  There are quite a few

								; possibilities here.


										; Case where both forms are accepted


									 if	accptdir and accptdu

									 if	dufirst

									resolve	du,dir		; Check DU: form before DIR: form

									 else

									resolve	dir,du		; Check DIR: form before DU: form

									 endif	;dufirst

									 endif	;accptdir and accptdu


										; Cases of only one form accepted


									 if	accptdu and not accptdir

									resolve	du,		; Check only DU: form

									 endif	;accptdu and not accptdir


									 if	accptdir and not accptdu

									resolve dir,		; Check only DIR: form

									 endif	;accptdir and not accptdu


										; Case of neither form accepted


									 if	not accptdir and not accptdu

									push	hl		; Save pointer to command string

									inc	de		; Point to first character of name

									ld	a,(de)		; Get it

									dec	de		; Restore the pointer

									sub	' '		; If no name is there, A=0 and Z flag set

									 endif	;not accptdir and not accptdu


									push	de		; Save pointer to FCB again

									push	af		; Save bad directory flag

									ld	a,(tempdr)	; Set designated drive

									ld	(de),a		; ..into FCB

									inc	de		; Point to file name field

									call	ifcb		; Perform partial init (set user code)

									pop	af		; Get bad directory flag back

									ld	(duerrflag),a	; Save flag in parser code

									jr	z,scanner1	; Branch if valid directory specified

									dec	de		; Back up to record count byte

									dec	de

									ld	(de),a		; Store error flag there (NZ if error)

								scanner1:

									pop	de		; Get FCB pointer back

									pop	hl		; Restore pointer to command string

									call	scanfld8	; Scan for file name


								; This code processes the file type specification in the token


								scantype:

									ld	a,(hl)		; Get ending character of file name field

									ex	de,hl		; Switch FCB pointer into HL

									ld	bc,8		; Offset to file type field

									add	hl,bc

									ex	de,hl		; Switch pointers back


									ld	b,3		; Maximum characters in file type

									cp	'.'		; See if file type specified

									jr	nz,scantype2	; If not, skip over file type parsing


									inc	hl		; Point to character after '.'

									push	de		; Save pointer to FCB file type

									call	scanfield	; Parse file type into FCB

									pop	de


								scantype2:

									ex	de,hl		; Swap pointers again

									ld	bc,5		; Offset from file type to S1 field in FCB

									add	hl,bc

									ex	de,hl		; Swap pointers back

									ld	a,(tempusr)	; Get specified user number

									ld	(de),a		; ..and store in S1 byte of FCB


								scan3:				; Skip to space character, character after an

												; ..equal sign, or to end of command

									ld	a,(hl)		; Get next character

									cp	' '+1		; Done if less than space

									jr	c,scan4

									call	tsteol		; Done if end of line or end of command

									jr	z,scan4

									inc	hl		; Skip on to next character

									cp	'='		; If not equal sign

									jr	nz,scan3	; ..keep scanning


								scan4:				; Set zero flag if '?' in filename.typ


								qmcnt	equ	$+1		; Pointer for in-the-code modification

									ld	a,0		; Number of question marks

									or	a		; Set zero flag

									ret


								; This routine invokes SCANFIELD for a file name field.  It initializes the

								; question mark count and preserves the FCB pointer.


								scanfld8:

									xor	a		; Initialize question mark count

									ld	(qmcnt),a

									push	de		; Save pointer to FCB

									ld	b,8		; Scan up to 8 characters

									call	scanfield

									pop	de		; Restore pointer to FCB

									ret


								; This routine scans a command-line token pointed to by HL for a field whose

								; maximum length is given by the contents of the B register.  The result is

								; placed into the FCB buffer pointed to by DE.  The FCB must have had its name

								; and type fields initialized before this routine is called.  Wild cards of

								; '?' and '*' are expanded.  On exit, HL points to the terminating delimiter.


								scanfield:

									call	sdelm		; Done if delimiter encountered

									ret	z

									inc	de		; Point to next byte in FCB

									cp	'*'		; Is character a wild card?

									jr	nz,scanfld1	; Continue if not


									ld	a,'?'		; Process '*' by filling with '?'s

									ld	(de),a

									call	qcountinc	; Increment count of question marks

									jr	scanfld2	; Skip so HL pointer left on '*'


								scanfld1:			; Not wildcard character '*'

									ld	(de),a		; Store character in FCB

									inc	hl		; Point to next character in command line

									cp	'?'		; Check for question mark (wild)

									call	z,qcountinc	; Increment question mark count

								scanfld2:

									djnz	scanfield	; Decrement char count until limit reached

								scanfld3:

									call	sdelm		; Skip until delimiter

									ret	z		; Zero flag set if delimiter found

									inc	hl		; Pt to next char in command line

									jr	scanfld3


								; Subroutine to increment the count of question mark characters in the

								; parsed file name.


								qcountinc:

									push	hl

									ld	hl,qmcnt	; Point to count

									inc	(hl)		; Increment it

									pop	hl

									ret


								;-----------------------------------------------------------------------------


								; Validate the password pointed to by HL.  Prompt user for password entry

								; and return zero if it is correct.


									 if	pwcheck


								passck:

									push	hl		; Save pointer to password

									call	print		; Prompt user

									defb	cr,lf,'PW?',' '+80h

									ld	hl,pwlin	; Set up buffer for user input

									ld	bc,90ah		; Set 0ah (BDOS readln function) in C

									ld	(hl),b		; ..and 9 (max character count) in B

									ex	de,hl		; Switch buffer pointer to DE


									 if	pwnoecho

									ld	a,0c9h		; Disable BIOS conout routine to

									ld	(bios+0ch),a	; ..suppress password echoing

									call	bdossave	; Get user input

									ld	a,0c3h		; Reenable BIOS conout routine

									ld	(bios+0ch),a

									 else	;not pwnoecho

									call	bdossave	; Get user input

									 endif	;pwnoecho


									ex	de,hl		; Restore pointer to HL

									inc	hl		; Point to count of characters entered

									ld	a,(hl)		; Get character count

									inc	hl		; Point to first character

									push	hl		; Save pointer while marking end of input

									call	addah		; Advance HL to just past last character

									ld	(hl),' '	; Place space there

									pop	de		; Restore pointer to beginning of user input

									pop	hl		; Restore pointer to password from NDR

									ld	b,8		; Maximum characters to compare

								pwck:

									ld	a,(de)		; Get next user character

									call	ucase		; Capitalize it

									cp	(hl)		; Compare to NDR

									ret	nz		; No match

									cp	' '		; If last user character matched space in

									ret	z		; ..NDR, then we have a complete match

									inc	hl		; If not done, point to next characters

									inc	de

									djnz	pwck		; (flags not affected by DJNZ)

									xor	a		; Set zero flag and

									ret			; ..return Z to show success


									 endif	; pwcheck


								;-----------------------------------------------------------------------------


								; This code attempts to interpret the token in the FCB pointed to by register

								; pair DE as a DIR (named directory) prefix.  If it is successful, the drive

								; and user values are stored in TEMPDR and TEMPUSR, the zero flag is set, and

								; a value of zero is returned in register A.

								;

								; If the named directory is found to be password restricted, then the user is

								; asked for the password (unless the directory is the one currently logged or

								; the current IF state is false).  If an incorrect password is entered, the

								; error handler is generally invoked directly.  The exception to this is when

								; the transient program bit is set in the command status flag (this bit would

								; be set by a non-CPR program that calls REPARSE).  In this case the default

								; directory is returned, the zero flag is reset, and a nonzero value in

								; returned in register A to show a bad directory.  In addition, the code in

								; SCANNER will set record-count byte in the FCB to a nonzero value so that

								; the calling program can detect the error.  [Note: if DU processing is also

								; allowed and it follows DIR processing, DUSCAN will also be called.  Unless

								; there is a passworded directory with a DU form, this will cause no trouble.]


									 if	accptdir


								dirscan:


								; If the DU form is not allowed, we have to detect a colon-only condition here.

								; Otherwise DUSCAN will take care of it.


									inc	de		; Point to first byte of directory form


									 if	not accptdu

									ld	a,(de)		; Get first character of directory

									sub	' '		; If it is a blank space

									ret	z		; ..we have a successful directory resolution

									 endif	;not accptdu


									ex	de,hl		; Switch pointer to FCB to HL


									 if	ndrenv		; If getting NDR address for Z3ENV

									ld	e,15h		; Offset to NDR address

									push	hl		; Preserve pointer to FCB

									call	pkgoff		; Get NDR address from ENV into DE

									pop	hl

									jr	z,direrr	; Branch if no NDR implemented

									 else	; using fixed address of NDR buffer

									ld	de,z3ndir	; Point to first entry in NDR

									 endif	; ndrenv


								dirscan1:

									ld	a,(de)		; Get next character

									or	a		; Zero if end of NDR

									jr	z,direrr

									inc	de		; Point to name of directory

									inc	de

									push	hl		; Save pointer to name we are looking for

									push	de		; Save pointer to NDR entry

									ld	b,8		; Number of characters to compare


								dirscan2:

									ld	a,(de)

									cp	(hl)

									jr	nz,dirscan3	; If no match, quit and go on to next DIR

									inc	hl		; Point to next characters to compare

									inc	de

									djnz	dirscan2	; Count down


								dirscan3:

									pop	de		; Restore pointers

									pop	hl

									jr	z,dirscan4	; Branch if we have good match


									ex	de,hl		; Advance to next entry in NDR

									ld	bc,16		; 8 bytes for name + 8 bytes for password

									add	hl,bc

									ex	de,hl

									jr	dirscan1	; Continue comparing


								; If ACCPTDU is enabled, we can share similar code in DUSCAN and do not need

								; the code here.


									 if	not accptdu

								direrr:				; No match found

									dec	a

									ret

									 endif	;not accptdu


								dirscan4:			; Match found

									ex	de,hl		; Switch pointer to NDR entry into HL

									push	hl		; ..and save it for later

									dec	hl		; Point to user corresponding to the DIR

									ld	c,(hl)		; Get user value into C

									dec	hl		; Point to drive

									ld	b,(hl)		; Get it into B


									 if	pwcheck


									ld	hl,(curusr)	; Get current drive/user into HL

									inc	h		; Shift drive to range 1..16

									xor	a		; Clear carry flag

									sbc	hl,bc		; Compare

									pop	hl		; Restore pointer to NDR entry

									jr	z,setdu		; If same, accept values without PW checking


								; If WPASS is set, then password checking is bypassed when the wheel byte is

								; set.


									 if	wpass

									ld	a,(z3whl)	; Get wheel byte

									or	a		; If wheel byte set

									jr	nz,setdu	; ..skip checking passwords

									 endif	;wpass


								; This code is a bit tricky.  We do not want to be asked for passwords for

								; named directory references in commands when the current IF state is false.

								; So, first we check to see if there is a password on the directory.  If not,

								; we proceed to set the temporary DU to the specified directory.  If there is

								; a password, we check the current IF state.  If it is false, we do not check

								; passwords and pretend there was no password.  However, we leave the current

								; directory in effect.  This will work properly in all but one rare

								; circumstance.  When the command is an 'OR' command with a reference to a

								; passworded named directory (e.g., "OR EXIST SECRET:FN.FT"), the password

								; will not be requested and the current directory will be used instead of the

								; specified one.


									push	bc		; Save requested drive/user

									ld	bc,8		; Point to password in NDR

									add	hl,bc

									ld	a,(hl)		; Get first character of password

									cp	' '		; Is there a password?


									 if	fcp eq 0	; If FCP not implemented ...


									call	nz,passck	; Perform password checking if pw present


									 else	;fcp ne 0	; FCP implemented ...


									jr	z,dirscan5	; If no pw, skip ahead

									call	iftest		; Otherwise, test current IF state

									pop	bc		; Restore BC in case we return now

									ret	z		; If false IF in effect, fake success without

												; ..checking password (but TEMPDR/TEMPUSR not

												; ..set)

									push	bc		; Otherwise, save BC again

									call	passck		; Perform password checking


									 endif	;fcp eq 0


								dirscan5:

									pop	bc		; Restore requested drive/user

									jr	z,setdu		; If not bad password, set it up

									ld	a,(cmdstatfl)	; See if external invocation (disable

									bit	3,a		; ..error handling if so)

									ret	nz		; Return NZ to show bad directory

									ld	a,ecbadpass	; Error code for bad password

									jp	error


									 else	;not pwcheck


									pop	hl		; Clean up stack

									 if	accptdu		; If we cannot fall through, branch

									jr	setdu

									 endif	;accptdu


									 endif	;pwcheck


									 if	not accptdu	; If NOT ACCPTDU, we have to supply code here

								setdu:

									ld	(tempusr),bc

									xor	a		; Set Z to flag success

									ret

									 endif	;not accptdu


									 endif	;accptdir


								;-----------------------------------------------------------------------------


								; This code attempts to interpret the token in the FCB pointed to by register

								; pair DE as a DU (drive/user) prefix.  If it is successful, the drive and

								; user values are stored in TEMPDR and TEMPUSR, the zero flag is set, and a

								; value of zero is returned in register A.  Otherwise the zero flag is reset

								; and a nonzero value is returned in register A.

								;

								; The ADUENV option allows acceptance of the DU form to be controlled by the

								; DUOK flag in the environment descriptor.  An additional feature of this code

								; when the ADUENV option is enabled is that a DU value is always accepted,

								; even if DUOK is off and even if it is outside the normally allowed range,

								; if it corresponds to a named directory with no password.  The currently

								; logged directory is unconditionally acceptable (if you got there once, you

								; can stay as long as you like without further hassles).


									 if	accptdu		; Allow DU: form


								direrr:				; This code may do double duty for DIRSCAN

												; ..above

								duerr:

									xor	a		; Return NZ to show failure

									dec	a

									ret


								duscan:

									ex	de,hl		; Switch FCB pointer to HL

									inc	hl		; Point to first byte of file name in FCB


									ld	bc,(curusr)	; Preset C to current user, B to current drive

									ld	a,(hl)		; Get possible drive specification

									sub	'A'		; Otherwise convert to number 0..15

									jr	c,duscan1	; If < 0, leave B as is

									cp	16

									jr	nc,duscan1	; If > 15, leave B as is

									ld	b,a		; Otherwise use value given

									inc	hl		; ..and point to next character


								duscan1:

									inc	b		; Shift drive to range 1..16

									ld	a,(hl)		; Get possible user specification

									cp	' '

									jr	z,duscan2	; If none present, leave C as is

									push	bc		; Save DU values in BC

									call	decimal1	; Get specified decimal user number into BC

									pop	hl		; Restore values to HL

									jr	c,duerr		; Return NZ if invalid decimal conversion

									ld	a,b		; Get high byte of result

									or	a		; Make sure it is zero

									ret	nz		; If not, return NZ to show bad user number

									ld	b,h		; DU value is now in BC


								; If the specified directory is the currently logged directory, accept it

								; even if it is out of range and/or password protected.


								duscan2:

									ld	hl,(curusr)	; Get current drive/user into HL

									inc	h		; Shift drive to range 1..16

									xor	a		; Clear carry flag

									sbc	hl,bc		; Compare values

									jr	z,setdu


								; If the specified DU corresponds to a named directory with no password, or

								; if WPASS is enabled so that password checking is not performed when the

								; wheel byte is set, then accept it.


									 if	z3ndir ne 0


									call	du2dir		; See if there is a matching named directory

									jr	z,duscan3	; If not, skip on


									 if	pwcheck		; If passwords are being checked...


									 if	wpass

									ld	a,(z3whl)	; Get wheel byte

									or	a		; If wheel byte set, skip checking passwords

									jr	nz,setdu	; ..and accept the DU values

									 endif	;wpass


									ld	de,9		; Advance to password

									add	hl,de

									ld	a,(hl)		; Get first character of password

									cp	' '

									jr	z,setdu		; If none, we have a valid DU


									 else	;not pwcheck


									jr	setdu		; Set the DU


									 endif	;pwcheck


									 endif	;z3ndir ne 0


								duscan3:

									 if	aduenv		; Check DUOK flag in ENV

									ld	a,(duokfl)	; Get flag

									or	a		; If DU not accepted

									jr	z,duerr		; ..skip over the DU scan

									 endif	;aduenv


									 if	duenv		; If getting max drive and user from ENV

									ld	hl,(maxdrenv)	; Get max drive into L and max user into H

									ld	a,l		; Test drive value

									cp	b

									jr	c,duerr

									ld	a,h		; Test user value

									cp	c

									jr	c,duerr

									 else			; Using fixed values of max DU

									ld	a,maxdisk

									cp	b

									jr	c,duerr

									ld	a,maxusr

									cp	c

									jr	c,duerr

									 endif	;duenv


								setdu:

									ld	(tempusr),bc

									xor	a		; Set Z to flag success

									ret


									 endif	; accptdu


								; End ZCPR33-3.Z80


									page


								; ZCPR33-4.Z80


								;=============================================================================

								;

								;	G E N E R A L    S U B R O U T I N E S    S E C T I O N

								;

								;=============================================================================


								;-----------------------------------------------------------------------------

								;

								;	CHARACTER I/O BDOS ROUTINES

								;

								;-----------------------------------------------------------------------------


								; Get uppercase character from console (with ^S processing).  Registers B,

								; D, H, and L are preserved.  The character is returned in A.


								conin:

									ld	c,1		; BDOS conin function

									call	bdossave

												; Fall through to UCASE


								;--------------------


								; Convert character in A to upper case.  All registers except A are preserved.


								ucase:

									and	7fh		; Mask out msb

									cp	61h		; Less than lower-case 'a'?

									ret	c		; If so, return

									cp	7bh		; Greater than lower-case 'z'?

									ret	nc		; If so, return

									and	5fh		; Otherwise capitalize

									ret


								;----------------------------------------


								; Output CRLF


								crlf:

									call	print

									db	cr

									db	lf or 80h

									ret


								;----------------------------------------


								; Output character in A to the console.  All registers are preserved.


								conout:

									push	de

									push	bc

									ld	c,2		; BDOS conout function

								output:				; Entry point for LCOUT below

									ld	e,a

									call	bdossave

									pop	bc

									pop	de

									ret


								;----------------------------------------


								; Print the character string immediately following the call to this routine.

								; The string terminates with a character whose high bit is set or with a null.

								; At entry point PRINTC the string is automatically preceded by a

								; carriage-return-linefeed sequence.  All registers are preserved except A.


								printc:

									call	crlf		; New line


								print:

									ex	(sp),hl		; Get pointer to string

									call	printhl		; Print string

									ex	(sp),hl		; Restore HL and set return address

									ret


								;----------------------------------------


								; Print the character string pointed to by HL.  Terminate on character with

								; the high bit set or on a null character.  On return HL points to the byte

								; after the last character displayed.  All other registers except A are

								; preserved.


								printhl:

									ld	a,(hl)		; Get a character

									inc	hl		; Point to next byte

									or	a		; End of string null?

									ret	z

									push	af		; Save flags

									and	7fh		; Mask out msb

									call	conout		; Print character

									pop	af		; Get flags

									ret	m		; String terminated by msb set

									jr	printhl


								;-----------------------------------------------------------------------------

								;

								;	FILE I/O BDOS ROUTINES

								;

								;-----------------------------------------------------------------------------


								; Read a record from a file to be listed or typed


									 if	lton		; Only needed for LIST and TYPE functions


								readf:

									ld	de,tfcb

									jr	read


									 endif	; lton


								;----------------------------------------


								; Read a record from the command file named in CMDFCB


								readcmd:

									ld	de,cmdfcb


								; Read a record from file whose FCB is pointed to by DE


								read:

									ld	c,14h		; Read-sequential function

												; Fall through to BDOSSAVE


								;--------------------


								; Call BDOS for read and write operations.  The flags are set appropriately.

								; The BC, DE, and HL registers are preserved.


								bdossave:

									putreg

									call	bdos

									getreg

									or	a		; Set flags

								note:				; This return is used for NOTE command, too

									ret


								;-----------------------------------------------------------------------------

								;

								;	MISCELLANEOUS BDOS ROUTINES

								;

								;-----------------------------------------------------------------------------


								; Set DMA address.  At the entry point DEFLTDMA the address is set to the

								; default value of 80H.  At the entry point DMASET it is set to the value

								; passed in the DE registers.


								defltdma:

									ld	de,tbuff

								dmaset:

									ld	c,1ah

									jr	bdossave


								;----------------------------------------


								; Log in the drive value passed in the A register (A=0).


								setdrive:

									ld	e,a

									ld	c,0eh

									jr	bdossave


								;----------------------------------------


								; Open a file.  At entry point OPENCMD the file is the one specified in

								; CMDFCB, and the current record is set to zero.  At entry point OPEN

								; the file whose FCB is pointed to by DE is used.


								opencmd:

									xor	a		; Set current record to 0

									ld	(cmdfcb+32),a

									ld	de,cmdfcb	; Command file control block

												; Fall through to open


								open:

									ld	c,0fh		; BDOS open function

												; Fall through to BDOSTEST


								;--------------------


								; Invoke BDOS for disk functions.  This routine increments the return code in

								; register A so that the zero flag is set if there was an error.  Registers

								; BC, DE, and HL are preserved.


								bdostest:

									call	bdossave

									inc	a		; Set zero flag for error return

									ret


								;----------------------------------------


								; Close file whose FCB is pointed to by DE.


									 if	saveon or subon

								close:

									ld	c,10h

									jr	bdostest

									 endif	;saveon or subon


								;----------------------------------------


								; Search for first matching file.  At entry point SRCHFST1 the first default FCB

								; is used.  At entry point SRCHFST the FCB pointed to by DE is used.


									 if	diron or eraon or renon or saveon

								srchfst1:

									ld	de,tfcb		; Use first default FCB

									 endif	;diron or eraon or renon or saveon


								srchfst:

									ld	c,11h

									jr	bdostest


								;-----------------------------------------------------------------------------


								; Search for next matching file whose FCB is pointed to by DE.


									 if	diron or eraon	; Only needed by DIR and ERA functions

								srchnxt:

									ld	c,12h

									jr	bdostest

									 endif	; diron or eraon


								;-----------------------------------------------------------------------------


								; Kill any submit file that is executing.


									 if	subon


								subkil:

									ld	hl,subflag	; Check for submit file in execution

									ld	a,(hl)

									or	a		; 0=no

									ret	z		; If none executing, return now

												; Kill submit file

									xor	a

									ld	(hl),a		; Zero submit flag

									call	setuser		; Log in user 0

									ld	de,subfcb	; Delete submit file

												; ..by falling through to delete routine


									 endif	; subon


								;--------------------


								; Delete file whose FCB is pointed to by DE.


									 if	eraon or renon or saveon or subon

								delete:

									ld	c,13h

									jr	bdossave

									 endif	;eraon or renon or saveon or subon


								;-----------------------------------------------------------------------------


								; Get and set user number.  Registers B, D, H, and L are preserved.  Register

								; E is also preserved at entry point SETUSER1.


								getuser:

									ld	a,0ffh		; Get current user number

								setuser:

									ld	e,a		; User number in E

								setuser1:

									ld	c,20h		; Get/Set BDOS function

									jr	bdossave


								;-----------------------------------------------------------------------------

								;

								;	GENERAL UTILITY ROUTINES

								;

								;-----------------------------------------------------------------------------


								; This subroutine checks to see if a program loaded at an address given by HL

								; has a Z3ENV header.  If the header is not present, the zero flag is reset.

								; If it is present, the zero flag is set, and on return HL points to the

								; environment-type byte and A contains that byte.


								z3chk:

									ld	de,z3env+3	; Point to 'Z3ENV' string in ENV

									inc	hl		; Advance three bytes to possible program

									inc	hl		; ..header

									inc	hl

									ld	b,5		; Characters to compare

								z3chk1:				; Check for Z3 ID header

									ld	a,(de)		; Get character from ENV descriptor

									cp	(hl)		; Compare it to loaded file

									ret	nz		; Quit now if mismatch

									inc	hl		; If same, advance to next characters

									inc	de		; ..and continue comparing

									djnz	z3chk1		; (flags not affected by DJNZ)

									ld	a,(hl)		; Return the environment type in A

									ret			; Return Z if all 5 characters match


								;----------------------------------------


								; Subroutine to skip over spaces in the buffer pointed to by HL.  On return,

								; the zero flag is set if we encountered the end of the line or a command

								; separator character.


								sksp:

									ld	a,(hl)		; Get next character

									inc	hl		; Point to the following character

									cp	' '		; Space?

									jr	z,sksp		; If so, keep skipping

									dec	hl		; Back up to non-space

												; ..and fall through


								;--------------------


								; Subroutine to check if character is the command separator or marks the end

								; of the line.


								tsteol:

									or	a		; End of command line?

									ret	z		; Return with zero flag set

									cp	cmdsep		; Command separator?

									ret			; Return with flag set appropriately


								;----------------------------------------


								; Initialize complete FCB pointed to by DE


								initfcb:

									xor	a

									ld	(de),a		; Set default disk (dn byte is 0)

									inc	de		; Point to file name field

									call	ifcb		; Fill 1st part of FCB

												; Fall through to IFCB to run again


								;--------------------


								; Initialize part of FCB whose file name field is pointed to by DE on entry.

								; The file name and type are set to space characters; the EX, S2, RC, and the

								; following CR (current record ) or DN (disk number) fields are set to zero.

								; The S1 byte is set to the current user number.  On exit, DE points to the

								; byte at offset 17 in the FCB (two bytes past the record count byte).


								ifcb:

									ld	b,11		; Store 11 spaces for file name and type

									ld	a,' '

									call	fill

									xor	a

									ld	(de),a		; Set extent byte to zero

									inc	de

									ld	a,(curusr)

									ld	(de),a		; Set S1 byte to current user

									inc	de

									ld	b,3		; Store 3 zeroes

									xor	a		; Fall thru to fill


								;--------------------


								; Fill memory pointed to by DE with character in A for B bytes


								fill:

									ld	(de),a		; Fill with byte in A

									inc	de		; Point to next

									djnz	fill

									ret


								;----------------------------------------


								; Subroutine to display the 'no file' error message for the built-in

								; commands DIR, ERA, LIST, TYPE, and/or REN.


									 if	diron or eraon


								prnnf:

									call	printc		; No file message

									defb	'No Fil','e'+80h

									ret

									 endif ; diron or eraon


								;----------------------------------------


								; Calculate address of command table in package from Z3ENV.  On entry, E

								; contains the offset to the address of the package in the environment.  On

								; exit, DE points to the beginning of the package and HL points to the fifth

								; byte (where the command table starts in the RCP and FCP modules).  The zero

								; flag is set on return if the package is not supported.


									 if	fcpenv or rcpenv or ndrenv

								pkgoff:

									ld	hl,z3env	; Point to beginning of ENV descriptor

									ld	d,0		; Make DE have offset

									add	hl,de		; ..and add it

									ld	a,(hl)		; Get low byte of package address

									inc	hl		; Point to high byte

									ld	h,(hl)		; ..and get it

									ld	l,a		; Move full address into HL

									or	h		; Set zero flag if no package

									ld	de,5		; Offset to start of table

									ex	de,hl		; Preserve start address of package in DE

									add	hl,de		; Pointer to 5th byte of package in HL

									ret			; Return with zero flag set appropriately


									 endif	;fcpenv or rcpenv or ndrenv


								;----------------------------------------


								; This subroutine checks to see if we are in a false IF state.  If that is

								; the case, the routine returns with the zero flag set.  If there is not active

								; IF state or if it is true, then the zero flag is reset.


									 if	fcp ne 0	; Omit code if FCP not implemented


								iftest:

									ld	bc,(ifptrfl)	; Current IF pointer into C, IF status into B

									ld	a,c		; See if any IF in effect

									or	a

									jr	z,iftest1	; Branch if no IF state is active

									and	b		; Mask the current IF status

									ret

								iftest1:

									dec	a		; Reset the zero flag

									ret


									 endif	;fcp ne 0


								;----------------------------------------


								; Print the command prompt with DU and/or DIR (but without any trailing

								; character).  This is also the code in which the current drive and user

								; will be stored.  The conditional assemblies are somewhat involved because

								; of the possibilities of either or both of the DU or DIR forms being omitted

								; from the prompt.


								prompt:

									call	crlf


									 if	incldu		; If drive/user in prompt


									ld	hl,(curusr)	; Get current drive/user into HL


								; If INCLENV is enabled, the drive and user (DU) will be included in the

								; prompt based on the state of the DUOK flag in the environment.  If INCLENV

								; is disabled, the DU form will always be included if INCLDU is on.


									 if	inclenv

									ld	a,(duokfl)	; If ENV disallows DU,

									or	a		; ..then don't show it in

									jr	z,prompt2	; ..the prompt, either

									 endif	;inclenv


									ld	a,h		; Get current drive

									add	a,'A'		; Convert to ascii A-P

									call	conout

									ld	a,l		; Get current user


									 if	supres		; If suppressing user # report for user 0

									or	a

									jr	z,prompt2

									 endif


									cp	10		; User < 10?

									jr	c,prompt1


									 if	highuser	; If allowing users 16..31


									ld	c,'0'-1

								prompt0:

									inc	c

									sub	10

									jr	nc,prompt0

									add	a,10

									ld	b,a

									ld	a,c

									call	conout

									ld	a,b


									 else	;using only standard user numbers 0..15


									sub	10		; Subtract 10 from user number

									push	af		; Save low digit

									call	print		; Display a '1' for tens digit

									defb	'1' or 80h

									pop	af


									 endif	;highuser


								prompt1:

									add	a,'0'		; Output 1's digit (convert to ascii)

									call	conout

								prompt2:

									 endif	; incldu


												; Display named directory


									 if	incldir


									 if	incldu

									ld	b,h		; Copy drive/user from HL to BC

									ld	c,l		; ..(saves a byte)

									 else

									ld	bc,(curusr)	; Get current drive and user into BC

									 endif	;incldu


									inc	b		; Switch drive to range 1..16

									call	du2dir		; See if there is a corresponding DIR form

									ret	z		; If not, return now


									 if	incldu		; Separate DU and DIR with colon


									 if	inclenv

									ld	a,(duokfl)	; If not displaying DU, then

									or	a		; ..don't send separator, either

									ld	a,':'		; Make the separator

									call	nz,conout	; ..and send if permitted

									 else

									call	print		; Put in colon separator

									defb	':' or 80h

									 endif	;inclenv


									 endif	; incldu


									ld	b,8		; Max of 8 chars in DIR name

								prompt3:

									inc	hl		; Point to next character in DIR name

									ld	a,(hl)		; ..and get it

									cp	' '		; Done if space

									ret	z

									call	conout		; Print character

									djnz	prompt3		; Count down


									 endif	; incldir


									ret


								;-----------------------------------------------------------------------------


								; Subroutine to convert DU value in BC into pointer to a matching entry in

								; the NDR.  If there is no match, the routine returns with the zero flag set.

								; If a match is found, the zero flag is reset, and the code returns with HL

								; pointing to the byte before the directory name.


									 if	z3ndir ne 0


								du2dir:


									 if	ndrenv		; If getting NDR address from environment

									ld	e,15h		; Offset to NDR in Z3ENV

									call	pkgoff		; Get address of NDR into DE

									ex	de,hl		; ..and switch into HL

									ret	z		; If no NDR, return with zero flag set

									jr	du2dir2

									 else

									ld	hl,z3ndir-17	; Scan directory for match

									 endif	;ndrenv


								du2dir1:			; Advance to next entry in NDR

									ld	de,16+1		; Skip user (1 byte) and name/pw (16 bytes)

									add	hl,de


								du2dir2:

									ld	a,(hl)		; End of NDR?

									or	a

									ret	z		; If so, return with zero flag set


									inc	hl		; Point to user number in NDR entry

									cp	b		; Compare drive values

									jr	nz,du2dir1	; If mismatch, back for another try

									ld	a,(hl)		; Get user number

									sub	c		; ..and compare

									jr	nz,du2dir1	; If mismatch, back for another try

									dec	a		; Force NZ to show successful match

									ret


									 endif	;z3ndir ne 0


								;-----------------------------------------------------------------------------


								; This routine gets the next line of input for the command buffer.  The

								; following order of priority is followed:

								;	If ZEX is active, the next line is obtained from ZEX

								;	If a submit file is running, its last record provides the input

								;	If there is a command line on the shell stack, use it

								;	Finally, if none of the above, the input is obtained from the user


								readbuf:


									ld	a,(zexrunfl)	; Get ZEX-running flag

									or	a

									jr	nz,userinput	; If ZEX running, go directly to user input


									 if	subon		; If submit facility is enabled, check for it


									ld	a,(subflag)	; Test for submit file running

									or	a

									jr	z,shellinput	; If not, go on to possible shell input


									xor	a		; Log into user 0

									call	setuser

									call	defltdma	; Initialize DMA pointer

									ld	de,subfcb	; Point to submit file FCB

									call	open		; Try to open file

									jr	z,readbuf1	; Branch if open failed


									ld	hl,subfrc	; Point to record count in submit FCB

									ld	a,(hl)		; Get the number of records in file

									dec	a		; Reduce to number of last record

									ld	(subfcr),a	; ..and put into current record field

									call	read		; Attempt to read submit file

									jr	nz,readbuf1	; Branch if read failed


									dec	(hl)		; Reduce file record cound

									dec	hl		; Point to S2 byte of FCB (yes, this is req'd!)

									ld	(hl),a		; Stuff a zero in there (A=0 from call to READ)

									call	close		; Close the submit file one record smaller

									jr	z,readbuf1	; Branch if close failed


								; Now we copy the line read from the file into the multiple command line

								; buffer


									ld	de,chrcnt	; Point to command length byte in command buffer

									ld	hl,tbuff	; Point to sector read in from submit file


									 if	buflen gt 7fh	; If command line buffer is longer than record,

									ld	bc,80h		; ..then copy entire record from $$$.SUB file

									 else	;buflen le 7fh	; Otherwise copy only enough to fill

									ld	bc,buflen+1	; ..the command line buffer

									 endif	;buflen gt 7fh


									ldir			; Transfer line from submit file to buffer


								; We now deal with various options that control the display of commands fed

								; to the command processor from a submit file.


									 if	subnoise gt 0	; If subnoise = 0 we omit all this display code


									 if	subnoise eq 1	; If subnoise = 1 we follow the quiet flag

									ld	a,(quietfl)

									or	a

									jr	nz,readbuf0	; If quiet, skip echoing the command

									 endif	;subnoise eq 1


									call	prompt		; Print prompt

									call	print		; Print submit prompt trailer

									defb	sprmpt or 80h

									ld	hl,cmdlin	; Print command line

									call	printhl


									 endif	;subnoise gt 0


								readbuf0:

									call	break		; Check for abort (any char)

									ret	nz		; If no ^C, return to caller and run


								readbuf1:

									call	subkil		; Kill submit file and abort

									jp	restart		; Restart CPR


									 endif	; subon


								shellinput:

									ld	hl,shstk	; Point to shell stack

									ld	a,(hl)		; Check first byte

									cp	' '+1		; See if any entry

									jr	c,userinput	; Get user input if none


									ld	de,cmdlin	; Point to first character of command line

									ld	bc,shsize	; Copy shell line into command line buffer

									ldir			; Do copy

									ex	de,hl		; HL points to end of line

									ld	a,1		; Set command status flag to show

									ld	(cmdstatfl),a	; ..that a shell has been invoked

									jr	readbuf3	; Store ending zero and exit


								userinput:

									call	prompt		; Print prompt

									call	print		; Print prompt trailer

									defb	cprmpt or 80h

									ld	c,0ah		; Read command line from user

									ld	de,bufsiz	; Point to buffer size byte of command line

									call	bdos


												; Store null at end of line


									ld	hl,chrcnt	; Point to character count

									ld	a,(hl)		; ..and get its value

									inc	hl		; Point to first character of command line

									call	addah		; Make pointer to byte past end of command line

								readbuf3:

									ld	(hl),0		; Store ending zero

									ret


								;-----------------------------------------------------------------------------


								; Check for any character from the user console.  Return with the character

								; in A.  If the character is a control-C, then the zero flag will be set.


									 if	subon or diron or eraon or lton


								break:

									ld	c,0bh		; BDOS console status function

									call	bdossave	; Call BDOS and set flags

									call	nz,conin	; Get input character if there is one

									cp	'C'-'@'		; Check for abort

									ret


									 endif	; subon or diron or eraon or lton


								;-----------------------------------------------------------------------------


								; Add A to HL (HL=HL+A)


								addah:

									add	a,l

									ld	l,a

									ret	nc

									inc	h

									ret


								;-----------------------------------------------------------------------------


								; The routine NUMBER evaluates a string in the first FCB as either a decimal

								; or, if terminated with the NUMBASE hexadecimal marker, a HEX number.  If the

								; conversion is successful, the value is returned as a 16-bit quantity in BC.

								; If an invalid character is encountered in the string, the routine returns

								; with the carry flag set and HL pointing to the offending character.


									 if	saveon


								number:

									ld	hl,tfcb+8	; Set pointer to end of number string

									ld	bc,8		; Number of characters to scan

									ld	a,numbase	; Scan for HEX identifier

									cpdr			; Do the search

									jr	nz,decimal	; Branch if HEX identifier not found


									inc	hl		; Point to HEX marker

									ld	(hl),' '	; Replace HEX marker with valid terminator

												; ..and fall through to HEXNUM


									 endif	;saveon


								;----------------------------------------


								; At this entry point the character string in the first default FCB is

								; converted as a hexadecimal number (there must NOT be a HEX marker).


								hexnum:

									ld	hl,tfcb+1	; Point to string in first FCB


								; At this entry point the character string pointed to by HL is converted

								; as a hexadecimal number (there must be NO HEX marker at the end).


								hexnum1:

									ld	de,16		; HEX radix base

									jr	radbin		; Invoke the generalized conversion routine


								;----------------------------------------


								; This entry point performs decimal conversion of the string in the first

								; default FCB.


								decimal:

									ld	hl,tfcb+1	; Set pointer to number string


								; This entry point performs decimal conversion of the string pointed to

								; by HL.


								decimal1:

									ld	de,10		; Decimal radix base

												; Fall through to generalized

												; ..radix conversion routine


								; This routine converts the string pointed to by HL using the radix passed in

								; DE.  If the conversion is successful, the value is returned in BC.  HL points

								; to the character that terminated the number, and A contains that character.

								; If an invalid character is encountered, the routine returns with the carry

								; flag set, and HL points to the offending character.


								radbin:

									ld	bc,0		; Initialize result

								radbin1:

									or	a		; Make sure carry is reset

									call	sdelm		; Test for delimiter (returns Z if delimiter)

									ret	z		; Return if delimiter encountered


									sub	'0'		; See if less than '0'

									ret	c		; Return with carry set if so

									cp	10		; See if in range '0'..'9'

									jr	c,radbin2	; Branch if it is valid

									cp	'A'-'0'		; Bad character if < 'A'

									ret	c		; ..so we return with carry set

									sub	7		; Convert to range 10..15

								radbin2:

									cp	e		; Compare to radix in E

									ccf			; Carry should be set; this will clear it

									ret	c		; If carry now set, we have an error


									inc	hl		; Point to next character

									push	bc		; Push the result we are forming onto the stack

									ex	(sp),hl		; Now HL=result, (sp)=source pointer

									call	mpy16		; HLBC = previous$result * radix

									ld	h,0		; Discard high 16 bits and

									ld	l,a		; ..move current digit into HL

									add	hl,bc		; Form new result

									ld	c,l		; Move it into BC

									ld	b,h

									pop	hl		; Get string pointer back

									jr	radbin1		; Loop until delimiter


								;-----------------------------------------------------------------------------


								; This routine multiplies the 16-bit values in DE and HL and returns the

								; 32-bit result in HLBC (HL has high 16 bits; BC has low 16 bits).  Register

								; pair AF is preserved.


								mpy16:

									ex	af,af'		; Save AF

									ld	a,h		; Transfer factor in HL to A and C

									ld	c,l

									ld	hl,0		; Initialize product

									ld	b,16		; Set bit counter

									rra			; Shift AC right so first multiplier bit

									rr	c		; ..is in carry flag

								mp161:

									jr	nc,mp162 	; If carry not set, skip the addition

									add	hl,de		; Add multiplicand

								mp162:

									rr	h		; Rotate HL right, low bit into carry

									rr	l

									rra			; Continue rotating through AC, with

									rr	c		; ..next multiplier bit moving into carry

									djnz	mp161		; Loop through 16 bits


									ld	b,a		; Move A to B so result is in HLBC

									ex	af,af'		; Restore original AF registers

									ret


								;-----------------------------------------------------------------------------


								; This routine checks for a delimiter character pointed to by HL.  It returns

								; with the character in A and the zero flag set if it is a delimiter.  All

								; registers are preserved except A.


								sdelm:

									ld	a,(hl)		; Get the character

									exx			; Use alternate register set (shorter code)

									ld	hl,deldat	; Point to delimiter list

									ld	bc,delend-deldat; Length of delimiter list

									cpir			; Scan for match

									exx			; Restore registers

									ret			; Returns Z if delimiter


								deldat:				; List of delimiter characters

									db	' '

									db	'='

									db	'_'

									db	'.'

									db	':'

									db	';'

									db	'<'

									db	'>'

									db	','

									db	0

									 if	cmdsep ne ';'

									db	cmdsep

									 endif	;cmdsep ne ';'

								delend:


								;-----------------------------------------------------------------------------


								; Log into DU contained in FCB pointed to by DE.  Registers DE are preserved;

								; all others are changed.  Explicit values for the temporary drive and user

								; are extracted from the FCB.  If the record-count byte has an FF in it, that

								; is a signal that the directory specification was invalid.  We then invoke

								; the error handler.


									 if	diron or eraon or lton or renon or saveon


								fcblog:

									push	de		; Save pointer to FCB

									ex	de,hl

									ld	a,(hl)		; Get drive

									ld	bc,13		; Offset to S1 field

									add	hl,bc

									ld	c,(hl)		; Get user into C

									or	a		; See if drive value was 0

									jr	nz,fcblog1	; If not, branch ahead

									ld	a,(curdr)	; Otherwise substitute current drive

									inc	a		; ..shifted to range 1..16

								fcblog1:

									ld	b,a		; Get drive into B

									ld	(tempusr),bc	; Set up temporary DU values

									call	logtemp		; ..and log into it

									pop	de		; Restore pointer to FCB


								; Now check to make sure that the directory specification was valid.


									inc	hl		; Advance pointer to record-count byte

									inc	hl

									ld	a,(hl)		; See if it is nonzero

									or	a

									jp	nz,baddirerr	; If so, invoke error handler


									ret			; Otherwise return


									 endif	;diron or eraon or lton or renon or saveon


								;-----------------------------------------------------------------------------


								; Log into the temporary directory.  Registers B, H, and L are preserved.


								logtemp:

									ld	de,(tempusr)	; Set D = tempdr, E = tempusr

									call	setuser1	; Register D is preserved during this call

									ld	a,d		; Move drive into A

									dec	a		; Adjust for drive range 0..15

									jp	setdrive	; Log in new drive and return


								;-----------------------------------------------------------------------------


								; This routine scans the command table pointed to by HL for the command name

								; stored in the command FCB.  If the command is not found, the routine returns

								; with the zero flag reset.  If the command is found, the address vector is

								; stored in EXECADR and the zero flag is set.


								cmdscan:

									ld	b,(hl)		; Get length of each command

									inc	hl		; Point to first command name


								scannext:

									ld	a,(hl)		; Check for end of table

									or	a

									jr	z,scanend	; Branch if end


									ld	de,cmdfcb+1	; Point to name of requested command

									push	bc		; Save size of commands in table


									 if	wheel

												; Ignore commands with high bit set in first

												; ..char of command name if wheel is false

									ld	a,(z3whl)	; Get the wheel byte

									or	a

									ld	c,0ffh		; Make a mask that passes all characters

									jr	z,scancmp	; Use this mask if wheel not set


									 endif	; wheel


									ld	c,7fh		; Use mask to block high bit if wheel set

												; ..or not in use


								scancmp:

									ld	a,(de)		; Compare against table entry


									xor	(hl)

									and	c		; Mask high bit of comparison

									jr	nz,scanskip	; No match, so skip rest of command name


									inc	de		; Advance to next characters to compare

									inc	hl

									res	7,c		; Mask out high bit on characters after first

									djnz	scancmp		; Count down


									ld	a,(de)		; See if next character in input command

									cp	' '		; ..is a space

									jr	nz,scanbad	; If not, user command is longer than commands

												; ..in the command table


												; Matching command found


									pop	bc		; Clear stack

									ld	a,(hl)		; Get address from table into HL

									inc	hl

									ld	h,(hl)

									ld	l,a

									ld	(execadr),hl	; Set execution address

									xor	a		; Set zero flag to show that command found

									ret


								scanskip:

									inc	hl		; Skip to next command table entry

									djnz	scanskip


								scanbad:

									pop	bc		; Get back size of each command

									inc	hl		; Skip over address vector

									inc	hl

									jr	scannext	; Try scanning next entry in table


								scanend:

									xor	a		; Reset zero flag to show

									dec	a		; ..that command was not found

									ret


								; End ZCPR33-4.Z80


									page


								; ZCPR33-5.Z80


								;=============================================================================

								;

								;		R E S I D E N T    C O M M A N D    C O D E

								;

								;=============================================================================


								; Command:	DIR

								; Function:	To display a directory of the files on disk

								; Forms:

								;	DIR <afn>	Displays the DIR-attribute files

								;	DIR		Same as DIR *.*

								;	DIR <afn> S	Displays the SYS-attribute files

								;	DIR /S		Same as DIR *.* S

								;	DIR <afn> A	Display both DIR and SYS files

								;	DIR /A		Same as DIR *.* A


									 if	diron


								dir:

									ld	de,tfcb		; Point to target FCB

									push	de		; ..and save the pointer for later

									inc	de		; Point to file name

									ld	a,(de)		; Get first character


									 if	slashfl		; If allowing "DIR /S" and "DIR /A" formats

									cp	'/'		; If name does not start with '/'

									jr	nz,dir1		; ..branch and process normally

									inc	de		; Point to second character

									ld	a,(de)		; Get option character after slash

									ld	(tfcb2+1),a	; ..and put it into second FCB

									dec	de		; Back to first character

									ld	a,' '		; Simulate empty FCB

									 endif	;slashfl


								dir1:

									cp	' '		; If space, make all wild

									jr	nz,dir2

									ld	b,11

									ld	a,'?'

									call	fill


								dir2:

									pop	de		; Restore pointer to FCB

									call	fcblog		; Log in the specified directory


									 if	whldir

									ld	a,(z3whl)	; Check wheel status

									or	a		; If not set, then ignore options

									jr	z,dir2a

									 endif	;whldir


									ld	a,(tfcb2+1)	; Check for any option letter

									ld	b,1		; Flag for both DIR and SYS files

									cp	allchar		; See if all (SYS and DIR) option letter

									jr	z,dirpr		; Branch if so

									dec	b		; B = 0 for SYS files only

									cp	syschar		; See if SYS-only option letter

									jr	z,dirpr		; Branch if so

								dir2a:

									ld	b,80h		; Flag for DIR-only selection

												; Drop into DIRPR to print directory


									 endif	; diron


								;--------------------


								; Directory display routine


								; On entry, if attribute checking is required, the B register is

								; set as follows:

								;	00H for SYS files only

								;	80H for DIR files only

								;	01H for both


									 if	diron or eraon


								dirpr:

									 if	diron		; Attribute checking needed only for DIR

									ld	a,b		; Get flag

									ld	(systst),a	; Set system test flag

									 endif


									ld	e,0		; Set column counter to zero

									push	de		; Save column counter (E)

									call	srchfst1	; Search for specified file (first occurrence)

									jr	nz,dir3

									call	prnnf		; Print no-file message

									pop	de		; Restore DE

									xor	a		; Set Z to show no files found

									ret


								; Entry selection loop.  On entering this code, A contains the offset in the

								; directory block as returned by the search-first or search-next call.


								dir3:

									 if	diron		; Attribute checking needed only for DIR cmd


									call	getsbit		; Get and test for type of files

									jr	z,dir6


									 else	;not diron


									dec	a		; Adjust returned value from 1..4 to 0..3

									rrca			; Multiply by 32 to convert number to

									rrca			; ..offset into TBUFF

									rrca

									ld	c,a		; C = offset to entry in TBUFF


									 endif	;diron


									pop	de		; Restore count of

									ld	a,e		; ..entries displayed

									inc	e		; Increment entry counter

									push	de		; Save it

									and	03h		; Output CRLF if 4 entries printed in line

									jr	nz,dir4

									call	crlf		; New line

									jr	dir5

								dir4:

									call	print


									 if	wide


									defb	'  '		; 2 spaces

									defb	fence		; Then fence char

									defb	' ',' '+80h	; Then 2 more spaces


									 else	;not wide


									defb	' '		; Space

									defb	fence		; Then fence char

									defb	' '+80h		; Then space


									 endif	; wide


								dir5:

									ld	a,1

									call	dirptr		; HL now points to 1st byte of file name

									call	prfn		; Print file name

								dir6:

									call	break		; Check for abort

									jr	z,dir7

									call	srchnxt		; Search for next file

									jr	nz,dir3		; Continue if file found


								dir7:

									pop	de		; Restore stack

									dec	a		; Set NZ flag

									ret


									 endif	; diron or eraon


								;-----------------------------------------------------------------------------


									 if	diron or attchk or eraon


								; This routine returns a pointer in HL to the directory entry in TBUFF that

								; corresponds to the offset specified in registers C (file offset) and C

								; (byte offset within entry).


								dirptr:

									ld	hl,tbuff

									add	a,c		; Add the two offset contributions

									call	addah		; Set pointer to desired byte

									ld	a,(hl)		; Get the desired byte

									ret


									 endif	; diron or attchk or eraon


								;-----------------------------------------------------------------------------


								; Test File in FCB for existence, ask user to delete if so, and abort if he

								;  choses not to


									 if	saveon or renon


								extest:

									ld	de,tfcb		; Point to FCB

									push	de		; ..and save it for later

									call	fcblog		; Log into specified directory

									call	srchfst1	; Look for specified file

									pop	de		; Restore pointer

									ret	z		; OK if not found, so return

									call	printc

									 if	bellfl

									defb	bell

									 endif	;bellfl

									defb	'Erase',' '+80h

									ld	hl,tfcb+1	; Point to file name field

									call	prfn		; Print it

									call	print		; Add question mark

									defb	'?' or 80h

									call	conin		; Get user response

									cp	'Y'		; Test for permission to erase file

									jp	nz,restart	; If not, flush the entire command line

									jp	delete		; Delete the file


									 endif	; saveon or renon


								;-----------------------------------------------------------------------------


								; Print file name pointed to by HL


									 if	diron or renon or saveon


								prfn:

									ld	b,8		; Display 8 characters in name

									call	prfn1

									call	print		; Put in dot

									defb	'.' or 80h

									ld	b,3		; Display 3 characters in type

								prfn1:

									ld	a,(hl)		; Get character

									inc	hl		; Point to next

									call	conout		; Print character

									djnz	prfn1		; Loop through them all

									ret


									 endif	;diron or renon or saveon


								;-----------------------------------------------------------------------------


								; This routine returns NZ if the file has the required attributes and Z if

								; it does not.  It works by performing the 'exclusive or' of the mask passed

								; in register A and the filename attribute obtained by masking out all but

								; the highest bit of the character.  For the 'both' case, setting any bit

								; in the mask other than bit 7 will guarantee a nonzero result.

								;

								;	File name: : X 0 0 0  0 0 0 0	(After 80H mask, X=1 if SYS, 0 if DIR)

								;

								;	SYS-ONLY   : 0 0 0 0  0 0 0 0	(XOR gives 00H if X=0 and 80H if X=1)

								;	DIR-ONLY   : 1 0 0 0  0 0 0 0	(XOR gives 80H if X=0 and 00H if X=1)

								;	BOTH	   : 0 0 0 0  0 0 0 1	(XOR gives 01H if X=0 and 81H if X=1)


									 if	diron or attchk


								getsbit:

									dec	a		; Adjust to returned value from 1..4 to 0..3

									rrca			; Multiply by 32 to convert number to

									rrca			; ..offset into TBUFF

									rrca

									ld	c,a		; Save offset in TBUFF in C

									ld	a,10		; Add 10 to point to SYS attribute bit

									call	dirptr		; A = SYS byte

									and	80h		; Look only at attribute bit

								systst	equ	$+1		; In-the-code variable

									xor	0		; If SYSTST=0, SYS only; if SYSTST=80H, DIR

												; ..only; if SYSTST=1, both SYS and DIR

									ret			; NZ if OK, Z if not OK


									 endif	;diron or attchk


								;-----------------------------------------------------------------------------


								; Command:	REN

								; Function:	To change the name of an existing file

								; Forms:	REN <New UFN>=<Old UFN>

								; Notes:	If either file spec is ambiguous, or if the source file does

								;		not exist, the error handler will be entered.  If a file with

								;		the new name already exists, the user is prompted for deletion

								;		and ZEX is turned off during the prompt.


									 if	renon


								ren:

									ld	hl,tfcb		; Check for ambiguity in first file name

									call	ambchk

									call	fcblog		; Login to fcb

									ld	hl,tfcb2	; Check for ambiguity in second file name

									call	ambchk

									xor	a		; Use current drive for 2nd file

									ld	(de),a

									call	srchfst		; Check for old file's existence

									jr	nz,ren0a	; Branch if file exists

								jpnofile:

									ld	a,ecnofile	; Set error code for file not found

									jp	error		; ..and invoke error handler

								ren0a:

									call	extest		; Test for file existence and return if not

									ld	b,12		; Exchange new and old file names

									push	de		; Save pointer to FCB

									ld	hl,tfcb2	; Point to FCB for old file name

								ren0:

									ld	a,(de)		; Get character of old name

									ld	c,a		; ..into C register

									ld	a,(hl)		; Get character of new name

									ld	(de),a		; ..into place in old name

									ld	(hl),c		; Put character of old name into new name

									inc	hl		; Advance pointers

									inc	de

									djnz	ren0


								; Perform rename function


									pop	de		; Restore pointer to FCB

									ld	c,17h		; BDOS rename function

									jp	bdostest


									 endif	;renon


								;-----------------------------------------------------------------------------


								; Command:	ERA

								; Function:	Erase files

								; Forms:

								;	ERA <afn>	Erase specified files and dislay their names

								;	ERA <afn> I	Display names of files to be erased and prompt for

								;			inspection before erase is performed. (Character 'I'

								;			is defined by INSPCH in Z33HDR.LIB; if it is ' ', then

								;			any character triggers inspection.)


									 if	eraon


								era:

									 if	inspfl and eraok; 'I' flag and verification enabled?

									ld	a,(tfcb2+1)	; Get flag, if any, entered by user

									ld	(eraflg),a	; Save it in code below

									 endif	;erav and eraok


									ld	de,tfcb		; Point to target FCB

									call	fcblog		; ..and log into the specified directory


									 if	diron or attchk	; Attribute checking only in these cases

									ld	b,1		; Display all matching files

									 endif	;diron or attchk


									call	dirpr		; Print directory of erased files

									ret	z		; Abort if no files


									 if	eraok		; Print prompt


									 if	inspfl		; Test verify flag


								eraflg	equ	$+1		; Address of flag (in-the-code modification)

									ld	a,0

									cp	inspch		; Is it an inspect option?


									 if	inspch ne ' '	; If an explicit inspect character is specified

									jr	nz,era2		; ..skip prompt if it is not that character

									 else			; If INSPCH is the space character

									jr	z,era2		; ..then skip prompt only if FCB has a space

									 endif	;inspch ne ' '


									 endif	;inspfl


									call	printc

									defb	'OK to Erase','?'+80h

									call	conin		; Get reply

									cp	'Y'		; Yes?

									ret	nz		; Abort if not


									 endif	; eraok


								era2:

									ld	de,tfcb

									jp	delete		; Delete files and return


									 endif			; Eraon


								;-----------------------------------------------------------------------------


								; Command:	LIST

								; Function:	Print out specified file on the LST: device

								; Forms:	LIST <ufn>	Print file (No Paging)

								; Notes:	The flags which apply to TYPE do not take effect with LIST


									 if	lton


								list:

									ld	a,0ffh		; Turn on printer flag

									jr	type0


								;-----------------------------------------------------------------------------


								; Command:	TYPE

								; Function:	Print out specified file on the CON: Device

								; Forms:	TYPE <ufn>	Print file with default paging option

								;		TYPE <ufn> P	Print file with paging option reversed


								type:

									xor	a		; Turn off printer flag


								; Common entry point for LIST and TYPE functions


								type0:

									ld	(prflg),a	; Set printer/console flag

									ld	a,(tfcb2+1)	; Check for user page toggle ('P') option

									ld	(pgflg),a	; Save it as a flag in code below

									ld	hl,tfcb		; Point to target file FCB

									call	ambchk		; Check for ambiguous file spec (vectors to

												; ..error handler if so)

									call	fcblog		; Log into specified directory

									call	open		; Open the file


									 if	renon		; If REN on, share code

									jr	z,jpnofile

									 else	;not renon	; Otherwise repeat code here

									ld	a,ecnofile

									jp	z,error

									 endif	;renon


									call	crlf		; New line

									ld	a,(crttxt0)	; Set line count using value from the

												; ..environment for CRT0

									inc	a		; One extra the first time through

									ld	(pagcnt),a

									ld	bc,080h		; Set character position and tab count

												; (B = 0 = tab, C = 080h = char position)


								; Main loop for loading next block


								type2:

									ld	a,c		; Get character count

									cp	80h		; If not end of disk record

									jr	c,type3		; ..then skip


									call	readf		; Read next record of file

									ret	nz		; Quit if end of file


									ld	c,0		; Reset character count

									ld	hl,tbuff	; Point to first character


								; Main loop for printing characters in TBUFF


								type3:

									ld	a,(hl)		; Get next character

									and	7fh		; Mask out MSB

									cp	1ah		; Check for end of file (^z)

									ret	z		; Quit if so


								; Output character to CON: or LST: device with tabulation


									cp	cr		; If carriage return,

									jr	z,type4		; ..branch to reset tab count

									cp	lf		; If line feed, then output

									jr	z,type4a	; ..with no change in tab count

									cp	tab		; If tab

									jr	z,type5		; ..expand to spaces


								; Output character and increment character count


									call	lcout		; Output character

									inc	b		; Increment tab count

									jr	type6


								; Output CR and reset tab count


								type4:

									ld	b,0		; Reset tab counter


								; Output LF and leave tab count as is


								type4a:

									call	lcout		; Output <cr> or <lf>

									jr	type6


								; Process tab character


								type5:

									ld	a,' '		; Space

									call	lcout

									inc	b		; Increment tab count

									ld	a,b

									and	7

									jr	nz,type5	; Loop until column = n * 8 + 7


								; Continue processing


								type6:

									inc	c		; Increment character count

									inc	hl		; Point to next character

									push	bc

									call	break		; Check for user abort

									pop	bc

									ret	z		; Quit if so

									jr	type2		; Else back for more


								;--------------------


								; Output character in A to console or list device depending on a flag.

								; Registers are preserved.  This code is used only by the LIST and TYPE

								; commands.


								lcout:

									push	af		; Save character

								prflg	equ	$+1		; Pointer for in-the-code modification

									ld	a,0		; ..to determine destination (CON or LST)

									or	a		; Z=type, NZ=list

									jr	z,lc1


												; Output to list device


									pop	af		; Get character back

									push	de

									push	bc

									ld	c,5		; LISTOUT function

									jp	output


												; Output to console with paging


								lc1:

									pop	af		; Get character back

									push	af		; Save it again for page check

									call	conout		; Output to console

									pop	af		; Get character back again

									cp	lf		; Check for new line (paging)

									ret	nz		; If not new line, we are done


												; Paging routines


								pager:

									push	hl

									ld	hl,pagcnt	; Decrement lines remaining on screen

									dec	(hl)

									jr	nz,pager1	; Jump if not end of page


												; New page

									ld	a,(crttxt0)	; Get full page count from environment

									ld	(hl),a		; Reset count to a full page

								pgflg	equ	$+1		; Pointer to in-the-code buffer pgflg

									ld	a,0

									cp	pagech		; Page default override option wanted?


									 if	pagech ne ' '	; If using explicit character for page toggle


									 if	pagefl		; If paging is default

									jr	z,pager1	; ..PAGECH means no paging

									 else			; If paging not default

									jr	nz,pager1	; ..PAGECH means please paginate

									 endif	;pagefl


									 else			; Any character toggles paging


									 if	pagefl		; If paging is default

									jr	nz,pager1	; ..any character means no paging

									 else			; If paging not default

									jr	z,pager1	; ..any character means please paginate

									 endif	;pagefl


									 endif	;pagech ne ' '


												; End of page

									push	bc

									call	bios+9		; Wait for user input (BIOS console input)

									pop	bc

									cp	'C'-'@'		; Did user enter control-c?

									jp	z,nextcmd	; If so, terminate this command


								pager1:

									pop	hl		; Restore HL

									ret


									 endif	; lton


								;-----------------------------------------------------------------------------


								; Command: SAVE

								; Function:  To save the contents of the TPA onto disk as a file

								; Forms:

								;	SAVE <Number of Pages> <ufn>

								;		Save specified number of pages (starting at 100H) from TPA

								;		into specified file

								;

								;	SAVE <Number of Sectors> <ufn> <S>

								;		Like SAVE above, but numeric argument specifies

								;		number of sectors rather than pages


									 if	saveon


								; Entry point for SAVE command


								save:

									call	number		; Extract number from command line

									jr	c,badnumber	; Invoke error handler if bad number

									push	bc		; Save the number

									call	reparse		; Reparse tail after number of sectors/pages

									pop	hl		; Get sector/page count back into HL

									ld	a,(tfcb2+1)	; Check sector flag in second FCB

									cp	sectch


									 if	sectch ne ' '	; If using a specific character, then jump

									jr	z,save0		; ..if it is that character

									 else			; If allowing any character (SECTCH=' ')

									jr	nz,save0	; ..jump if it is anything other than space

									 endif	;sectch ne ' '


									add	hl,hl		; Double page count to get sector count

								save0:

									ld	a,1		; Maximum allowed value in H

									cp	h		; Make sure sector count < 512 (64K)

									jr	c,badnumber	; If >511, invoke error handler


									push	hl		; Save sector count

									ld	hl,tfcb

									call	ambchk		; Check for ambiguous file spec (vectors to

												; ..error handler if so)


									call	extest		; Test for existence of file and abort if so

									ld	c,16h		; BDOS make file function

									call	bdostest

									jr	z,save3		; Branch if error in creating file


									pop	bc		; Get sector count into BC

									ld	hl,tpa-80h	; Set pointer to one record before TPA


								save1:

									ld	a,b		; Check for BC = 0

									or	c

									dec	bc		; Count down on sectors (flags unchanged,

												; ..B=0FFH if all records written successfully)

									jr	z,save2		; If BC=0, save is done so branch


									push	bc		; Save sector count

									ld	de,80h		; Advance address by one record

									add	hl,de

									push	hl		; Save address on stack

									ex	de,hl		; Put address into DE for BDOS call

									call	dmaset		; Set DMA address for write

									ld	de,tfcb		; Write sector

									ld	c,15h		; BDOS write sector function

									call	bdossave

									pop	hl		; Get address back into HL

									pop	bc		; Get sector count back into BC

									jr	z,save1		; If write successful, go back for more


									ld	b,0		; B=0 if write failed


								save2:

									call	close		; Close file even if last write failed

									and	b		; Combine close return code with

												; ..write success flag

									ret	nz		; Return if all ok


								save3:				; Disk must be full

									ld	a,ecdiskfull	; Disk full error code

									jr	jperror


									 endif	; saveon


								;-----------------------------------------------------------------------------


									 if	lton or	saveon or renon or geton


								; Check file control block pointed to by HL for any wildcard characters ('?').

								; Return to calling program if none found.  Otherwise branch to error handler.

								; The routine also treats an empty file name as ambiguous.


								ambchk:

									push	hl		; Save pointer to FCB

									inc	hl		; Point to first character in file name

									ld	a,(hl)		; See if first character is a space

									cp	' '

									jr	z,ambchk1	; If so, branch to error return


									ld	a,'?'		; Set up for scan for question mark

									ld	bc,11		; Scan 11 characters

									cpir

									pop	de		; Restore pointer to FCB in DE

									ret	nz		; Return if no '?' found

								ambchk1:

									ld	a,ecambig	; Error code for ambiguous file name

									jr	jperror


									 endif	;lton or renon or saveon or geton


									 if	lton or renon or saveon or geton or jumpon


								badnumber:

									ld	a,ecbadnum	; Error code for bad number value

								jperror:			; Local entry point for relative jump

									jp	error		; ..to go to error handler


									 endif	;lton or renon or saveon or geton or jumpon


								;-----------------------------------------------------------------------------


								; Command:	JUMP

								; Function:	To execute a program already loaded into some specified memory

								;		address

								; Forms:	JUMP <adr> <tail>

								;		The address is in hex; the tail will be parsed as usual


									 if	jumpon


								jump:

									call	hexnum		; Get load address into BC

									jr	c,badnumber	; If bad number, invoke error handling

									push	bc		; ..and save it

									call	reparse		; Reparse tail after address value

									pop	hl		; Restore execution address to HL

									jr	getproglf	; Perform call via code below


									 endif	;jumpon


								;-----------------------------------------------------------------------------


								; Command:	GO

								; Function:	To Call the program in the TPA without loading

								;		loading from disk. Same as JUMP 100H, but much

								;		more convenient, especially when used with

								;		parameters for programs like STAT. Also can be

								;		allowed on remote-access systems with no problems.

								;

								;Form:		GO <tail>


									 if	goon


								go:

									ld	hl,tpa		; Set up TPA as the execution address


									 endif	; goon


									 if	jumpon or goon	; Common code


								getproglf:

									ld	(execadr),hl

									xor	a		; Set zero flag to enable leading CRLF

									jp	callproglf	; Perform call (with leading CRLF)


									 endif	;jumpon or goon


								;-----------------------------------------------------------------------------


								; Command:	GET

								; Function:	To load the specified file from disk to the specified address

								; Forms:	GET <adr> <ufn>

								;		Loads the specified file to the specified hexadecimal address

								;		Note that the normal file search path is used to find the file.

								;		If SCANCUR is off, the file may not be found in the current

								;		directory unless a colon is included in the file spec.


									 if	geton


								get:


								; TMPCOLON was set when the file name was parsed.  We use that as the colon

								; flag so that the file will be loaded from a directory just as if it had

								; been entered as the command name.


									 if	drvprefix and [not scancur]

									ld	a,(tmpcolon)	; Allow GET to load from specified

									ld	(colon),a	; directory

									 endif	;drvprefix and [not scancur]


									ld	hl,tfcb2	; Copy TFCB2 to CMDFCB for load

									push	hl

									ld	de,cmdfcb

									ld	bc,14

									ldir

									pop	hl

									call	ambchk		; Make sure file is not ambiguous (vectors

												; ..to error handler if so)


								; If GET fails to find the specified file along the search path, we do not

								; want the ECP to be engaged.  To prevent that, we fool the command processor

								; by telling it that the ECP is already engaged.


									ld	hl,cmdstatfl	; Point to command status flag

									set	2,(hl)		; Turn on ECP flag to prevent use of ECP

									call	hexnum		; Get load address into BC

									jr	c,badnumber	; If invalid number, invoke error handler


									 if	not fullget

									ld	a,b		; If trying to load into base page

									or	a		; ..treat as error

									jr	z,badnumber

									 endif	;not fullget


									ld	h,b		; Move address into HL

									ld	l,c

									ld	a,0ffh		; Disable dynamic loading

												; Fall through to mload


									 endif	; geton


								; End ZCPR33-5.Z80


									page


								; ZCPR33-6.Z80


								;=============================================================================

								;

								;   P A T H    S E A R C H    A N D    F I L E    L O A D I N G    C O D E

								;

								;=============================================================================


								; This block of code loads a file into memory.  The normal address at which

								; loading is to begin is passed to the routine in the HL register.  The name

								; of the file to load is passed in the command file control block.

								;

								; This code supports an advanced option that loads files to a dynamic address

								; specified in the header to the file using a new type-3 environment.  In a

								; type-3 environment, the execution/load address is stored in the word

								; following the environment descriptor address.  A value is passed to MLOAD in

								; the A register that controls this dynamic loading mechanism.  The value

								; specifies the lowest environment type value for which dynamic loading will

								; be performed.  This value will be 3 when MLOAD is called for normal COM file

								; execution and will be 0FFH when chained to from the GET command.  In the

								; latter case, the user-specified load address must be used.

								;

								; MLOAD guards against loading a file over the operating system.  It computes

								; the lower of the following two addresses: 1) the CPR entry point; 2) the

								; bottom of protected memory as indicated by the DOS entry address stored at

								; address 0006H.  If the load would exceed this limit, error handling is

								; engaged (except for the GET command when FULLGET is enabled).


								mload:

									ld	(envtype),a	; Set up in-the-code modification below

									ld	(execadr),hl	; Set up execution/load address

									call	defltdma	; Set DMA address to 80H for file searches


								; This code sets the attributes of COM files which are acceptable.  If both

								; SYS and DIR type files are acceptable, there is no need to include this code,

								; and ATTCHK can be set to false.


									 if	attchk		; Only if attribute checking enabled

									ld	a,comatt	; Attributes specified in Z33HDR.LIB

									ld	(systst),a	; Set flag

									 endif	;attchk


								;-----------------------------------------------------------------------------


								; PATH BUILDING CODE


								; In ZCPR33 the minpath feature, optional in ZCPR30, is always used.  To

								; minimize the size of the CPR code, however, there is an option to place the

								; minpath in an external buffer (outside the CPR).  If the path is short

								; enough, the minpath can be placed at the bottom of the system stack.


									ld	de,path		; Point to first element in user's symbolic path

									ld	hl,mpath	; Point to minpath buffer

									xor	a

									ld	(hl),a		; Initialize to empty minpath


								; If DRVPREFIX is enabled, the CPR will recognize an explicit directory

								; reference in a command.  The first element of the path will then be this

								; explicit directory.  If no explicit directory was given in the command,

								; then no entry is made into the search path.  If the WPREFIX option is

								; on, explicit directory prefixes will be recognized only when the wheel

								; byte is on.


									 if	drvprefix	; Pay attention to du:com prefix?


									ld	a,(colon)	; See if colon was present in command

									or	a

									jr	z,makepath2	; If not, skip ahead


									 if	wprefix

									ld	a,(z3whl)	; See if wheel byte is on

									or	a

									jr	z,makepath2	; If not, skip ahead

									 endif	;wprefix


									ld	a,(cmdfcb)	; Get drive from command FCB

									ld	(hl),a		; Put drive into minpath

									inc	hl		; Advance pointer

									ld	a,(cmdfcb+13)	; Get user number from command FCB

									ld	(hl),a		; Put it into minpath

									inc	hl		; Advance pointer to next path element

									xor	a		; A=0

									ld	(hl),a		; Store ending 0 in mpath

								makepath2:

									 endif	; drvprefix


								; If SCANCUR is enabled in Z33HDR.LIB, then we always include the current

								; directory automatically, even without a '$$' element in the user's path.

								; If WPREFIX is enabled, however, we do not want to allow the current

								; directory to be included, but we must make sure that it is included in

								; the building of the root path, in case the user's symbolic path is empty.


									 if	scancur		; Scan current directory at all times?


									ld	bc,(curusr)	; C = current user, B = current drive

									inc	b		; Set drive to range 1..16


									 if	wprefix


									ld	a,(z3whl)	; See if wheel byte is on

									or	a

									jr	nz,addpath	; If it is, add element to path; if not,

												; ..fall through to MAKEPATH3

									 else	;not wprefix


									jr	addpath		; Begin loop of placing entries into mpath


									 endif	;wprefix


									 else	;not scancur


								; If SCANCUR is off and ROOTONLY is in effect, we have to make sure that some

								; directory values are put into the root path in the case where the user's

								; path is completely empty.  To do so, we preset BC for directory A0.


									 if	rootonly

									ld	bc,0100h	; Setup for drive A (B=1), user 0 (C=0)

									 endif	;rootonly


									 endif	;scancur


								; Convert symbolic entries in user's path into absolute DU values in minpath.

								; Entries are read one-by-one from the symbolic path.  If the 'current' drive

								; or user indicator is present (default symbol is '$'), then the current

								; drive or user value is fetched.  Otherwise the explicit binary value from the

								; path is used.  After each absolute DU value is formed, the minpath as it

								; exists so far is scanned to see if this DU value is already there.  If it is

								; not, then the DU value is appended to the path.  Otherwise it is ignored.


								makepath3:

									ld	a,(de)		; Get next symbolic path entry

									or	a		; If 0, we are at end of path

									jr	z,makepath6


									ld	bc,(curusr)	; C = current user, B = current drive

									inc	b		; Set drive to range 1..16

									cp	curind		; Check for current drive symbol (default '$')

									jr	z,makepath4	; If so, leave current drive in B

									ld	b,a		; Else move specified drive into B

								makepath4:

									inc	de		; Point to user value in symbolic path

									ld	a,(de)		; Get user

									inc	de		; Point to next element in symbolic path

									cp	curind		; Check for current user symbol (default '$')

									jr	z,makepath5	; If so, leave current drive in C

									ld	c,a		; Else move specified user into C

								makepath5:


								; At this point in the code we have a potential path element in BC.  We first

								; have to scan the minpath we have so far to see if that element is already

								; there.  In that case we ignore it; otherwise we add it to the end of the path.


								addpath:

											; Skip path if directory given explicitly


									 if	skippath


									 if	wprefix

									ld	a,(z3whl)	; See if wheel byte is on

									or	a

									call	nz,skipchk	; If not, fall through

									 else	;not wprefix

									call	skipchk		; See if path should be skipped

									 endif	;wprefix


									jr	nz,makepath3	; If so, branch out of ADDPATH


									 endif	;skippath


									ld	hl,mpath	; Point to beginning of minpath


								addpath1:			; Point of reentry

									ld	a,(hl)		; Get drive value

									or	a		; Check for end of minpath

									jr	z,addpath2	; If end, jump and add BC to minpath


									inc	hl		; Increment pointer to user

									cp	b		; Check for drive match

									ld	a,(hl)		; Get user from minpath

									inc	hl		; Point to next minpath entry

									jr	nz,addpath1	; If drive was different, loop back again

									cp	c		; Check for user match

									jr	nz,addpath1	; If user is different, loop back again

									jr	makepath3	; Branch if we have a duplicate


								; We have a new DU; add it to minpath


								addpath2:

									ld	(hl),b		; Store drive

									inc	hl

									ld	(hl),c		; Store user

									inc	hl

									ld	(hl),0		; Store ending 0

									jr	makepath3	; Continue scanning user's path


								; If the ECP facility is set up to use the root directory, then create a

								; root path.  BC presently contains the proper DU.


								makepath6:


									 if	rootonly

									ld	hl,rootpth	; Point to special path to contain root

									ld	(hl),b		; Store disk

									inc	hl

									ld	(hl),c		; Store user

									 endif	;rootonly


								;-----------------------------------------------------------------------------


								; This is the code for loading the specified file by searching the minpath.


									xor	a		; Always use current disk specification in the

									ld	(cmdfcb),a	; ..command FCB


								mload1:


									ld	hl,mpath	; Point to beginning of minpath


								mload2:


								; Either the FASTECP or BADDUECP option may have set FIRSTCHAR to a space

								; character as a signal to go directly to extended command processing.  If

								; neither option is enabled but SKIPPATH is, then the FIRSTCHAR data is

								; stored in the routine below where path skipping is implemented.


									 if	fastecp or badduecp


									ld	a,(cmdstatfl)	; If ECP is running

									bit	2,a		; ..we branch to look for ECP along path

									jr	nz,mload2a

								firstchar equ	$+1		; Pointer for in-the-code modification

									ld	a,0

									cp	' '		; Was command invoked with leading space?

									jr	z,ecprun	; If so, go directly to ECP code


									 endif	;fastecp or badduecp


								mload2a:

									ld	a,(hl)		; Get drive from path

									or	a		; If end of path, command not found

									jr	nz,mload3	; If not end of path, skip over ECP code


								;-----------------------------------------------------------------------------


								; EXTENDED COMMAND PROCESSING


								; At this point we have exhausted the search path.  We now engage the

								; extended command processor.


								ecprun:

									 if	skippath

									call	skipchk		; See if path should be skipped

									jr	nz,jnzerror	; If so, invoke error handler

									 endif	;skippath


									ld	hl,cmdstatfl	; Point to command status flag

									ld	a,(hl)		; ..and get value

									and	110b		; Isolate ECP and error handler bits

								jnzerror:			; If either is set,

									ld	a,ecnocmd	; Error code for command not found

									jp	nz,error	; ..process as an error


									set	2,(hl)		; Set ECP bit


									ld	hl,ecpfcb	; Copy name of ECP to command FCB

									ld	de,cmdfcb

									ld	bc,12		; Only 12 bytes required

									ldir


									ld	hl,(cmdptr)	; Get pointer to current command line

									call	parsetail	; Parse entire command as the command tail


									 if	rootonly	; Look for ECP in root directory only

									ld	hl,rootpth	; Point to path containing root directory only

									jr	mload2		; Search for command

									 else	; not rootonly

									jr	mload1		; Search the entire minpath for the ECP

									 endif	; rootonly


								;-----------------------------------------------------------------------------


								mload3:

									ld	b,a		; Drive into B

									inc	hl		; Point to user number

									ld	c,(hl)		; User into C

									ld	(tempusr),bc	; Save the values

									inc	hl		; Point to next entry in path

									call	logtemp		; Log in path-specified user/drive


									 if	attchk		; If allowing execution only of COM files with

												; ..specific attributes


									ld	de,cmdfcb	; Point to command FCB

									call	srchfst		; Look for directory entry for file

									jr	z,mload2a	; Continue path search if file not found

									push	hl		; Save path pointer

									call	getsbit		; Check system attribute bit

									pop	hl		; Restore path pointer

									jr	z,mload2a	; Continue if attributes do not match

									call	opencmd		; Open file for input

									jr	z,mload2a	; If open failed, back to next path element


									 else	;not attchk


									call	opencmd		; Open file for input

									jr	z,mload2a	; If open failed, back to next path element


									 endif	; attchk


									call	readcmd		; Read first record into default DMA address

									jr	nz,mload5	; Branch if zero-length file

									xor	a		; Set file current record back to zero

									ld	(cmdfcb+20h),a

									ld	hl,80h		; Pointer to start of code

									call	z3chk

									jr	nz,mload3a	; If not Z3 file, branch


								; The following test is modified by earlier code.  For normal COM file loading,

								; a 3 is inserted for the minimum environment type for dynamic load address

								; determination.  For the GET command, where the user-specified address should

								; be used, a value of 0FFH is put in here so the carry flag will always be set.


								envtype	equ	$+1		; Pointer for in-the-code modification

									cp	3		; See if no higher than a type-3 environment

									jr	c,mload3a	; If higher than type 3, branch


									inc	hl		; Advance to load address word

									inc	hl

									inc	hl

									ld	a,(hl)		; Get load address into HL

									inc	hl

									ld	h,(hl)

									ld	l,a

									ld	(execadr),hl	; Set new execution/load address


								mload3a:

									ld	hl,(execadr)	; Get initial loading address


								; Load the file, making sure neither CPR nor protected memory is overwritten


								mload4:

									 if	fullget

									ld	a,(envtype)	; If ENVTYPE is FF (from GET command)

									inc	a		; ..then skip memory limit checking

									jr	z,mload4b

									 endif	;fullget


									 if	rel

									ld	bc,entry	; We have to use a relocatable form to get

									dec	b		; ..highest page below the CPR

									 else	;not rel

									ld	b,high entry - 1 ; We can use shorter code for absolute form

									 endif	;rel


									ld	a,(0007h)	; Get highest page below

									dec	a		; ..protected memory

									cp	b		; If A is lower value,

									jr	c,mload4a	; ..branch

									ld	a,b		; Otherwise use lower value in B

								mload4a:

									cp	h		; Are we going to overwrite protected memory?

									ld	a,ectpafull	; Get ready with TPA overflow error code

									jp	c,error		; Error if about to overwrite protected memory

								mload4b:

									push	hl		; Save this load address

									ex	de,hl		; Set DMA address

									call	dmaset

									call	readcmd

									pop	hl		; Get last load address back

									jr	nz,mload5	; Read error or eof?

									ld	de,128		; Increment load address by 128

									add	hl,de

									jr	mload4		; Continue loading


								; In case a program would like to find out in what directory the command

								; processor found the program, temporary DU is stored in bytes 13 (user) and

								; 14 (drive) in the command FCB.


								mload5:


								tempusr	equ	$+1		; Pointers for in-the-code modification

								tempdr	equ	$+2

									ld	hl,0

									ld	(cmdfcb+13),hl


								logcurrent:			; Return to original logged directory

									ld	hl,(curusr)	; Set L = current user, H = current drive

									ld	a,h

									call	setdrive	; Login current drive

									ld	a,l

									jp	setuser		; Log in new user and return from MLOAD


								;----------------------------------------


								; This routine checks to see if building the path or running the ECP should

								; be skipped.  If there is a colon in the command (an explicit directory

								; given) but it was not a lone colon (indicating desire to skip resident

								; commands), then the routine returns with the zero flag reset.


									 if	skippath


								skipchk:

									ld	a,(colon)	; Was there a colon in the command?

									or	a

									ret	z		; Return with zero flag set if not


									 if	fastecp or badduecp

									ld	a,(firstchar)	; See if the first character was the colon

									 else

								firstchar equ	$+1		; Put data here if other two options are

									ld	a,0		; ..false (in-the-code modification)

									 endif	;fastecp or badduecp


									cp	':'

									ret			; Return: Z if lone colon, NZ otherwise


									 endif	;skippath


								; End ZCPR33-6.Z80


									page


								;-----------------------------------------------------------------------------

								;

								;		D A T A    A R E A    D E F I N I T I O N S

								;

								;-----------------------------------------------------------------------------


								; ----------   Page line count buffer


									 if	lton		; Needed only if TYPE command included


								pagcnt:

									defs	1		; Lines left on page (filled in by code)


									 endif	;lton


								; ---------- Minpath/Rootpth buffers


									 if	extmpath


								mpath	equ	extmpathadr	; Assign external minpath address


									 else


								mpath:

									 if	drvprefix

									defs	2		; Two bytes for specified DU

									 endif


									 if	scancur

									defs	2		; Two bytes for current DU

									 endif


									defs	2 * expaths	; Space for path from path buffer


									defs	1		; One byte for ending null


									 endif	; not extmpath


									 if	rootonly

								rootpth:

									defs	2		; Special path for root dir only

									defb	0		; End of path

									 endif	; rootonly


								;-----------------------------------------------------------------------------


								; The following will cause an error message to appear if

								; the size of ZCPR33 is over 2K bytes.


									 if	[ $ - entry ] gt 800h

									*** ZCPR33 IS LARGER THAN 2K BYTES ***

									 endif


									 endif	;errflag


									end	; ZCPR33