;
;	Hacks to match MacOS (most recent first):
;
;	<Sys7.1>	  8/3/92	Reverted <SM3> by changing pascalRegs back to interruptRegs (i.e. not
;							saving a2/a3/d3).
;				  9/2/94	SuperMario ROM source dump (header preserved below)
;

;
;	File:		ExternalMakeFSSpec.a
;
;	Contains:	Code to perform emulation of the MakeFSSpec call
;				for external file systems that don't support it
;				themselves.
;
;				This file can be assembled into code that relies on an a6 stack
;				and QMgr.a-style queueing or into a simple subroutine for glue
;				libraries.  -d MakeGlue=0 should be used in system builds and
;				-d MakeGlue=1 for glue library builds.
;
;	Written by:	Dave Feldman
;
;	Copyright:	© 1990-1991, 1993 by Apple Computer, Inc., all rights reserved.
;
;	Change History (most recent first):
;
;	   <SM3>	  6/9/93	pdw		Changed register saving from interruptRegs to pascalRegs in
;									myCompletionRoutine because it can be called from pascal (as it
;									is when FileShare is running).  Fixes a FileShare crash that
;									appears when doing async I/O.
;		 <4>	 9/13/91	JSM		Cleanup header.
;		 <3>	 3/17/91	dnf		ppd, #dnf-0013: Use the result code from ioResult(a0) instead of
;									from d0 to be extra-clean on async calls.
;		 <2>	 9/22/90	dnf		Put real code in here
;		 <1>	  8/7/90	dnf		first checked in
;
;

	LOAD		'StandardEqu.d'
	include		'FileMgrPrivate.a'

; Get inspired and move these somewhere
fsSpecNameLength	equ		63
pathSeparator		equ		':'				; a colon character
	
; Values for d3.b during parsing
moreSegments		equ		0			; also implies a colon-terminated segment
finalSegmentColon	equ		1			; no more segments; path ended with a colon
finalSegmentNoColon	equ		-1			; no more segments; path didn't end with a colon

; For patch or ROM builds we need to include an i/o bottleneck to handle async calls.
; The bottleneck code assumes QMgr.a-style queueing.

		if not(MakeGlue) then
	
		include		'QMgrEqu.a'

;________________________________________________________________________________
;
; Routine:	myBottleNeckIO
;
; Input: 	a0 points to param block
; Output: 	d0 contains result code
;			a1 trash
;
; Function:		Make traps which do I/O and do the right thing with completion
;				routines.
;________________________________________________________________________________
; 
BottleNeckRegs		reg		d1-d7/a1-a5			; async could trash any regs

BottleNeckLocals	record	0, increment
hasContinued		ds.b	1					; flag byte to watch stack depth
				align	2
Lsize			equ		*-BottleNeckLocals
				endr

myBottleNeckIO		proc
	import			GetQMRecPtr
	entry			myCompletionRoutine
	export			myContCompatThread			; should be entry, but patch linker is dumb
	export			myContAppThread				; should be entry, but patch linker is dumb
	movem.l			BottleNeckRegs, -(a6)		; save our regs on hfs stack
	with			BottleNeckLocals
	subq.w			#Lsize, a6

	bclr.b			#0, hasContinued(a6)		; initialize completion routine flag
	lea.l			myCompletionRoutine, a1		; get our ioCompletion routine address
	move.l			a1, ioCompletion(a0)		; and install it into the param block	

	move.w			#fsCompatQType, d2			; our queue type/refnum
	bsr				GetQMRecPtr					; a1 = ptr(QMRec)
	move.l			a6, QMRec.curStack(a1)		; save current alt stack pointer
	; •• do high water mark checking here
	
	btst.b			#asyncCall, QMRec.qmFlags(a1)	; is this call async?	

	rts											; return to specific trap handling routine

; Some drivers have the nasty habit of calling their completion routines before returning
; from the trap that called them.  This might lead to unbounded stack buildup from 
; successive calls.  To solve this we have a bit (in hasContinued) which is set both
; in the completion routine and after the trap.  

; Case 1: The completion routine is called before we return from the trap.  In this case
; we just cruise back to the driver, since we'll get control again when the driver
; rts's from our trap.  When that happens we can just continue our call.

; Case 2: We get returned to before the completion routine is run (truly asynchronous).  
; We rts to the app (giving back the async time) and we know we'll get control again
; at the completion routine.  When we continue from here we need to save the 
; appropriate interrupt registers.

; This little scheme is, of course, a critical section, but we're single threaded right now,
; so it doesn't matter.

myCompletionRoutine:
	move.w			#fsCompatQType, d2		; our queue type/refnum
	bsr				GetQMRecPtr				; a1 = ptr(QMRec)
	move.l			a6, -(sp)				; save a6 for a sec
	movea.l			QMRec.curStack(a1), a6	; get our a6 back
	bset.b			#0, hasContinued(a6)	; mark that we've been back
	movea.l			(sp)+, a6				; restore a6			
	beq.s			anRTSInstruction		; if we haven't returned from the trap, rts to driver

	movem.l			interruptRegs, -(sp)	; save all regs that pascal callers need saved	<LW2>pdw <Sys7.1>
	pea				restoreInterruptRegs	; and get in the chain to restore them later	<LW2>pdw <Sys7.1>
				
myContCompatThread:
	move.w			#fsCompatQType, d2		; our queue type/refnum
	bsr				GetQMRecPtr				; a1 = ptr(QMRec)
	movea.l			QMRec.curStack(a1), a6	; restore alt stack pointer
	adda.w			#Lsize, a6				; clear off the locals
	movem.l			(a6)+, BottleNeckRegs	; restore compatibility layer thread registers	
	move.l			(a6)+, -(sp)			; push compatibility layer thread return address
	move.w			ioResult(a0),d0			; set the ol' status register						<3>
anRTSInstruction:
	rts										; and return to caller

myContAppThread:		
	; •• we're ignoring the possibility of immediate errors
	bset.b			#0, hasContinued(a6)	; mark that we've returned 
	bne.s			myContCompatThread		; if we already ran the completion routine, then
											; continue without saving registers
	rts										; return async time to application

restoreInterruptRegs:						;												<LW2>pdw <Sys7.1>
	movem.l			(sp)+, interruptRegs	; restore the regs that we saved last time through <Sys7.1>
	rts										; back to the app thread
	endproc

;________________________________________________________________________________
;
; Routine:	DoAnA060Trap
;
; Input:	a0 - paramblock
;			d0 - HFSDispatch selector
;
; Output:	a0 - paramblock
;			d0 - result code
;
; Function:	Fire off an a060 call
;
; Note: After myBottleNeckIO, Z = 1 -> async, Z = 0 -> sync.
;________________________________________________________________________________
DoAnA060Trap:	proc
				move.l		(sp)+, -(a6)	; save  thread ret addr on a6
				bsr			myBottleNeckIO	; do common set up
				bne.s		@1				; zero flag set if async
				_HFSDispatch				; sync trap 
				jmp			myContCompatThread; keep going with this call
@1:				_HFSDispatch	async			; async trap
				jmp			myContAppThread	; keep going, but give async time to app
				endproc
				
; Macro for generating code that executes a synchronous or asynchronous trap 
; based on the value of the zero flag.  Zero set = async, zero clear = sync.
				macro
				doSomeTrap	&theTrap
				move.l		(sp)+, -(a6)	; save desktop thread ret addr on a6
				bsr			myBottleNeckIO	; do common set up
				bne.s		@1				; zero flag set if async
				_&theTrap					; sync trap 
				jmp			myContCompatThread; keep going with this desktop call
@1:				_&theTrap	async			; async trap
				jmp			myContAppThread	; keep going, but give async time to app
				endm

doGetCatInfo:	proc
				move.w		#selectGetCatInfo, d0
				jmp			DoAnA060Trap
				endproc
				
doGetWDInfo:	proc
				move.w		#selectGetWDInfo, d0
				jmp			DoAnA060Trap
				endproc
				
doGetVolInfo:	proc
				doSomeTrap		GetVolInfo
				endproc

doHGetVol:		proc
				doSomeTrap		HGetVol
				endproc
				
				macro
				go_GetCatInfo
				bsr	doGetCatInfo
				endm

				macro
				go_GetWDInfo
				bsr	doGetWDInfo
				endm

				macro
				go_GetVolInfo
				bsr	doGetVolInfo
				endm

				macro
				go_HGetVol
				bsr	doHGetVol
				endm
				
; For glue we can go straight to traps	
				else

				macro
				go_GetCatInfo
				_GetCatInfo
				endm

				macro
				go_GetWDInfo
				_GetWDInfo
				endm

				macro
				go_GetVolInfo
				_GetVolInfo
				endm

				macro
				go_HGetVol
				_HGetVol
				endm
				endif
				
;________________________________________________________________________________
;
; Routine:	ResetPathnameParser
;
; Input:	a4 - caller's param block (uses ioNamePtr)
;
; Output:	d1.l - number of characters in string (could be zero)
;			a1   - pointer to first character in string (or nil)
;
; Function:	Set registers used by parser to cause it to start at the beginning
;			of the string when it is next called.
;________________________________________________________________________________
ResetPathnameParser:	proc

		moveq.l	#0, d1								; clear high bytes
		move.l	ioNamePtr(a4), d0					; grab pathname pointer and set ccr's
		movea.l	d0, a1								; move to a1 even if it's nil
		beq.s	@Exit
		move.b	(a1)+, d1							; get the length and point at 1st char
@Exit:
		rts
		endproc
			
;________________________________________________________________________________
;
; Routine:	ParseNextSegment
;
; Input:	a1 - current location along pathname string 
;			a2 - pointer to FSSpec under construction
;
;			d1.w - characters remaining in string in front of a1
;
; Output:	a1 - update to new position along pathname string
;			a2 - pointer to FSSpec under construction
;
;			d0.w - error code (negative)
;			d1.w - characters remaining in string in front of a1
;			
;			d3.l - stuff
;				0 	moreSegments		implies a colon-terminated segment
;				1	finalSegmentColon	no more segments; path ended with a colon
;				-1	finalSegmentNoColon	no more segments; path didn't end with a colon
;
;			Z
;				set - saw an empty segment
;				clear - saw a non-empty segment or an error occurred
;
;			N
;				set - error code in d0
;				clear - success
;
; Function:	
;			Parse through the characters at (a1) and copy the
;			next leaf (i.e. file/directory) name into FSSpec.name.
;
;			Use the Z flag to indicate the presense of a '::' in the path
;
; Input: 
;	if d1 > 0 then
;		a1 must point to the first character in the new segment
;	
;________________________________________________________________________________
; ParseNextSegmentRegs	reg		a0
ParseNextSegment:	proc
	
		move.l		a0, -(sp)					; save one register
		move.w		d2, -(sp)					; only low word
		
		moveq.l		#0, d0						; no chars in this segment yet
		lea.l		FSSpec.name+1(a2), a0		; address of 1st char in leaf name buffer
		
		subq.b		#1, d1						; subtract one for dbra
		cmp.b		#pathSeparator, (a1)		; is this a colon?
		beq.s		@DoubleColon				; that means there's been 2 in a row

@Loop:
		move.b		(a1)+, d2					; get the next character
		cmp.b		#pathSeparator, d2			; is this a colon?
		beq.s		@SingleColon				; if so, we've got a whole segment

		addq.b		#1, d0						; count the character
		cmp.b		#fsSpecNameLength, d0		; are we overflowing FSSpec.name?
		bhs.s		@Overflow					; we overflowed, run for our lives...

		move.b		d2, (a0)+					; copy the char into leaf buffer

		dbra		d1, @Loop					; while more characters keep going

		moveq.l		#finalSegmentNoColon, d3	; we fell off the end, implying no colon there
		bra.s		@Success
		
@DoubleColon:
		addq.l		#1, a1						; skip past the colon	
@SingleColon:
		moveq.l		#moreSegments, d3			; pretend we have more
		tst.w		d1							; was the colon also the last character?
		bne.s		@Success					; if not, keep going
		moveq.l		#finalSegmentColon, d3		; indicate our fate (done, with a colon)

@Success:
		move.b		d0, FSSpec.name(a2)			; turn FSSpec.name into a PString
@Exit:
		move.w		(sp)+, d2					; restore low word
		movea.l		(sp)+, a0					; restore one register
		tst.w		d0							; Z if empty string, N if error
		rts

@Overflow:
		moveq.l		#bdNamErr, d0				; bummer - too many characters in file name
		bra.s		@Exit
		endproc
		
;________________________________________________________________________________
;
; Routine:	DetermineVolume
;
; Input:
;			a1 - beginning of pathname (or nil)
;			a2 - pointer to FSSpec under construction
;			a4 - caller's param block (uses ioVRefNum and ioDirID)
;
;			d1 - # of characters in string (could be zero)
; Output:
;			FSSpec.vRefNum contains volume reference number
;
;			d1.w - number of characters left in pathname
;			d4.l - dirID of selected directory
;			a1   - place to start parsing pathname from
;			a2   - pointer to FSSpec under construction
;			a4   - caller's param block (uses ioVRefNum and ioDirID)
;
; Function:	Parse up ioVRefnum, ioNamePtr and ioDir to find the volume/directory
;			pair.  Set the FSSpec to describe the vol/dir pair, and return the 
;			dirID of the directory in question in d4.
;
;			Handle all of the no-path-to-parse cases here:
;				no vRef, dirID or path
;				just a vRef
;				just a wdRef
;				just a vRef+dirID
;				a colon for a pathname
;				
;________________________________________________________________________________
DetermineVolume:		proc
@DetermineVolumeRegs:	reg	d2/a0/a3
		movem.l	@DetermineVolumeRegs, -(a6)
		suba.w	#ioHVQElSize, a6					; allocate a volume param block on a6
		move.l	a6, a0								; leave pb in a0	

; Check to see if there is a non-nil, non-zero length pathname
		moveq.l	#finalSegmentColon, d3				; assume we have nothing to parse
		tst.b	d1									; do we have a nil ptr or zero length name?
		beq.s	@UseVRefAndDirID					; if so, go use vRef+dirID

		bsr		ParseNextSegment					; parse next segment into FSSpec.name
		bmi.s	@Exit								; can't party if the parser don't want to
		beq.s	@UseVRefAndDirID					; initial colon implies vRef+dirID
		
		tst.l	d3									; check parser results
		bpl.s	@VolumeNamePresent					; if it ended with a colon, it's a vol name
		
; We've got a special case - the pathname is a solo cname.  Reset the path parser
; so that we'll see it again.
		bsr		ResetPathnameParser
		moveq.l	#moreSegments, d3					; make sure they look at this again
		bra.s	@UseVRefAndDirID					; and go use the vRef and dirID fields

@VolumeNamePresent:
		clr.w	ioVRefNum(a0)						; use pathname, please
		move.w	#-1, ioFDirIndex(a0)				; use pathname, please
		
		lea.l	FSSpec.name(a2), a3					; get the address of the just-parsed segment
		move.l	a3, ioNamePtr(a0)					; use caller's pathname

		; slam a colon on because HFS sucks rocks

		addq.b	#1,d0								; add a colon on to the end
		cmp.b	#fsSpecNameLength,d0				; ooops! no space
		bhs.s	@BadNameError
		move.b	d0, (a3)							; jam the longer length
		move.b	#pathSeparator, (a3, d0.w)			; put in the lovely separator for the pleasure of Dirks

		go_GetVolInfo
		bne.s	@Exit								; run away
		move.w	ioVRefNum(a0), FSSpec.vRefNum(a2)	; this is the volume
		move.l	#fsRtDirID, d4						; use the root if we need to keep going
		bra.s	@Exit								; and we're done

; We don't have a volume name ('cause the path starts with a colon, the path is a
; solo file/directory name, or there's no path), so use the ioVRefNum and ioDirID
; fields to establish the volume and directory to start parsing from.
@UseVRefAndDirID:
		clr.l	ioNamePtr(a0)						; we don't need the name here	
		move.w	ioVRefNum(a4), ioVRefNum(a0)		; use caller's vRef/WDRef
		beq.s	@HandleDefaultCase					; GetWDInfo has no clue about default directories
		
		clr.w	ioWDIndex(a0)						; no indexing, please
		clr.l	ioWDProcID(a0)						; any proc ID will do
		clr.w	ioWDVRefNum(a0)						; any volume will do
		go_GetWDInfo
		bne.s	@Exit								; punt on errors
		bra.s	@GotVolAndDir

@HandleDefaultCase:
		go_HGetVol
		bne.s	@Exit
		
@GotVolAndDir:
		move.w	ioWDVRefNum(a0), FSSpec.vRefNum(a2)	; use the volume from GetWDInfo
		move.l	ioDirID(a4), d4						; are we overriding with the user's dirID?
		bne.s	@Exit								; if so, stop thinking now
		move.l	ioWDDirID(a0), d4					; use dirID from vRef/wdRef or pathname		
@Exit:
		adda.w	#ioHVQElSize, a6					; deallocate volume param block on a6		
		movem.l	(a6)+, @DetermineVolumeRegs
		tst.w	d0
		rts

@BadNameError:
		moveq.l		#bdNamErr, d0				; bummer - too many characters in file name
		bra.s		@Exit
		endproc

;________________________________________________________________________________
;
; Routine:	CorrectCapitals
;
; Input:	a2 - pointer to FSSpec with leaf name
;
; Output:	a2 - FSSpec has correct (same-as-catalog) spelling of leaf name
;			d0 - result code
;
; Function:	Replace the leaf name in FSSpec.name(a2) with the spelling as it
;			is stored in the catalog.
;________________________________________________________________________________
CorrectCapitalsRegs	reg	a0/a1
CorrectCapitals		proc
		move.l		(sp)+, -(a6)					; ret addr to local stack
		movem.l		CorrectCapitalsRegs, -(a6)
		suba.w		#ioHVQElSize, a6				; allocate a pb
		movea.l		a6, a0
		suba.w		#256, a6						; max name length is 256 bytes
		movea.l		a6, a1							; a1 = ptr(name buffer)
		
		move.l		a1, ioFileName(a0)				; provide space for name output
		move.w		FSSpec.vRefNum(a2), ioVRefNum(a0)	; use the right volume
		move.l		FSSpec.parID(a2), d0			; get parent directory
		cmp.l		#fsRtParID, d0					; are we looking for the root's name?
		beq.s		@RootName
		
		move.w		#1, ioFDirIndex(a0)				; start indexing at 1
		move.l		d0, ioDirID(a0)					; use the right directory
		
@IndexLoop:
		go_GetCatInfo
		bne.s		@Exit							; punt on errors

		move.l		a0,-(sp)						; stash regs
		move.l		a1,-(sp)
		lea			FSSpec.name(a2), a0				; point to source name
		moveq.l		#0, d0							; clear everything
		move.b		(a0)+, d0						; length of caller's string
		swap		d0								; up high where _RelString likes it
		move.b		(a1)+, d0						; length of catalog's string
		_FSRelString								; compare 'em
		movea.l		(sp)+, a1						; restore regs
		movea.l		(sp)+, a0
		beq.s		@Hit							; cruise when they match
		add.w		#1, ioFDirIndex(a0)				; check out the next one
		move.l		FSSpec.parID(a2), ioDirID(a0)	; use the right directory
		bra.s		@IndexLoop

; GetCatInfo seems to not want to return info about the root directory when asked for 
; the first item (indexed) in fsRtParID.  Thus, we hack.
@RootName:
		clr.w		ioVolIndex(a0)					; no indexing for us
		go_GetVolInfo
		bne.s		@Exit

@Hit:
		moveq.l		#0, d0							; clear everything
		lea.l		FSSpec.name(a2),a0				; a0 target FSSpec
		move.b		(a1), d0						; get length of catalog-spelled name
		cmp.b		#63, d0							; a massive MFS name?
		bls.s		@1								; if length <= 63, we've enough room
		moveq.l		#63, d0							; sorry; you only get the 1st 63 chars
@1:
		move.b		d0, (a1)						; set clipped string length back into source
@loop:
		move.b		(a1)+, (a0)+					; set chars into FSSpec.name
		dbra		d0, @loop
		
		moveq.l		#noErr, d0						; yay! 
@Exit:
		adda.w		#ioHVQElSize+256,a6				; deallocate the pb and name buffer
		movem.l		(a6)+, CorrectCapitalsRegs
		move.l		(a6)+, -(sp)					; ret addr back
		tst.w		d0
		rts
		endproc
;________________________________________________________________________________
;
; Routine:	ExternalMakeFSSpec
;
; Input:	a0	- caller's param block (uses ioVRefNum, ioNamePtr, ioDirID and ioMisc)
;
; Output:	FSSpec (pointed to by ioMisc) is properly set
;			d0  - result code
;
; Function:	Parse up ioVRefnum, ioNamePtr and ioDir to make an FSSpec
;
; register usage:
;	a0 - our working parameter block
;	a1 - current place along the caller's pathname
;	a2 - FSSpec record
;	a4 - caller's param block
;	d1 - characters left in pathname in front of a1
;
; Assumes that suitably big a6 (≈800 bytes) is set up (presumably the compatibility layer)
; This routine follows all of the conventions to be called in the compatibility layer 
; but would also run fine as glue if someone aims a6 at a stack.
;________________________________________________________________________________
ExternalMakeFSSpecRegs	reg	a2-a4/d3-d4
ExternalMakeFSSpec:	proc	export

		move.l	(sp)+, -(a6)						; we do i/o
		movem.l	ExternalMakeFSSpecRegs, -(a6)
		movea.l	a0, a4								; save caller's pb pointer in a safe reg
		sub.w	#ioHVQElSize, a6					; allocate a (big) param block on a6
		movea.l	a6, a0								; keep a pointer to it around in a0

		move.l	ioFSSpecPtr(a4), a2					; a2 = ptr(Caller's FSSpec record)
		lea.l	FSSpec.name(a2), a3					; use FSSpec.name for path segment name storage
		move.l	a3, ioNamePtr(a0)					; have 
		bsr		ResetPathnameParser					; get ready to parse pathname

		bsr		DetermineVolume						; go get the volume and directory established
		bne		@ErrorExit

		move.w	FSSpec.vRefNum(a2), ioVRefNum(a0)	; we know the volume now

@DirIDButNoCatInfo:
		move.l	d4, ioDirID(a0)						; remember this so we can recognize our parents
		tst.l	d3									; check result of last parse
		bne.s	@GetCatInfoByDirID					; no more segments? Get the name and par of this dir
		
@ParseSegments:
		bsr		ParseNextSegment					; using a1/d1 return next segment
		bmi		@ErrorExit							; splitsville if the parser won't dance
		beq.s	@DoubleColon						; handle double colon case

		clr.w	ioFDirIndex(a0)						; use dirID and name, please
		go_GetCatInfo								; look and see if we can find anything

		; There are two reasons that the following code rejects files when a colon is present:
		;	1) a file in the middle of a path is an error, and its ioDirID is not a dirID
		;	2) a file at the end of a colon-terminated path is an error, too (Bill B. sez)

		bne.s	@WeLikeItFine						; an error happened, so we can’t be picky
		btst.b	#ioDirFlg, ioFlAttrib(a0)			; was the thing we found a directory?
		bne.s	@WeLikeItFine						; yes, and we’re always happy to find directories
		tst.l	d3									; did we have a colon?
		bmi.s	@WeLikeItFine						; no, and that is correct for a file
		moveq.l	#dirNFErr, d0						; silly rabbi, colons are for directories
		bra.s	@ErrorExit
@WeLikeItFine:

		tst.l	d3									; are we out of segments?
		bne.s	@DoneParsing						; if so, got to get out

		tst.w	d0									; did we have trouble getting through the directory
		bne.s	@ErrorExit							; errors are our cue to cruise

		move.l	ioDirID(a0), d4						; now, look within this directory
		bra.s	@ParseSegments

@DoubleColon:
		cmp.l	#fsRtDirID, d4						; are we trying to go higher than the root?
		beq.s	@DirNFExit							; yes, we can’t (even though GetCatInfo would)
		move.w	#-1, ioFDirIndex(a0)				; we need this guy's parent
		go_GetCatInfo
		bne.s	@ErrorExit							; barf on badness
		move.l	ioFlParID(a0), d4					; get parent because we are done
		bra.s	@DirIDButNoCatInfo

@GetCatInfoByDirID:
		move.w	#-1, ioFDirIndex(a0)				; we need this guy's parent
		go_GetCatInfo
		bne.s	@ErrorExit							; barf on badness
		move.l	ioFlParID(a0), d4					; get parent because we are done

@DoneParsing:
		move.l	d4, FSSpec.parID(a2)				; use the parent from the last GetCatInfo
		tst.w	d0									; did we get an error here?
		beq.s	@FoundSomething						; if not, we found something real
		cmp.w	#fnfErr, d0							; did we get fnfErr, a perfectly acceptable error?
		bne.s	@ErrorExit							; no, it was another error, report it

; GetCatInfo returns an fnfErr instead of a dirNFErr when given a bad directory ID.  Since an fnfErr
; from MakeFSSpec is an invitation to call _Create, we filter out bad directories here.
		move.w	#-1, ioFDirIndex(a0)				; info about directory
		clr.l	ioNamePtr(a0)						; we don't want the name back
		move.l	FSSpec.parID(a2), ioDirID(a0)		; use the directory we're about to return
		go_GetCatInfo
		bne.s	@ErrorExit							; an error implies a bad directory
		moveq.l	#fnfErr, d0							; good directory, so restore the fnfErr
		cmp.l	#fsRtParID, d4						; were we searching in the root’s parent?
		bne.s	@Exit								; no, we can return safely (can't create in fsRtParID)

@ErrorExit:	
		cmp.w	#fnfErr, d0							; if an fnfErr made it here, it is really a dirNFErr
		bne.s	@notFNF
@DirNFExit:
		moveq.l	#dirNFErr, d0						; return a dirNFErr instead
@notFNF:
		clr.w	(a2)+								; clear the FSSpec.vRefNum
		clr.l	(a2)+								; clear the FSSpec.parID
		clr.b	(a2)+								; clear the FSSpec.name length byte
		bra.s	@Exit

@FoundSomething:
		bsr		CorrectCapitals						; Get correct spelling of leaf name
@Exit:
		adda.w	#ioHVQElSize, a6					; deallocate param block
		movem.l	(a6)+, ExternalMakeFSSpecRegs
		move.l	(a6)+, -(sp)
		tst.w	d0
		rts
		endproc
		end