sys7.1-doc-wip/OS/HFS/Extensions/DTDBMgr.a

;
;	Hacks to match MacOS (most recent first):
;
;	<Sys7.1>	  8/3/92	Reverted <SM1> by putting back the "ROM" prefixes and removing the
;							copied-in routines. Reverted the branch changes in <SM2> and <SM3>.
;							Reverted <SM4> by changing pascalRegs back to interruptRegs (i.e. not
;							saving a2/a3/d3).
;				  9/2/94	SuperMario ROM source dump (header preserved below)
;

;
;	File:		DTDBMgr.a
;
;	Contains:	Desktop Database manager routines
;
;	Written by: 		Patrick W. Dirks, July 6 1986.
;	Rewritten by:		David Feldman, April 7, 1989.
;
;	Copyright:	© 1986-1993 by Apple Computer, Inc., all rights reserved.
;
;	Change History (most recent first):
;
;	   <SM4>	  6/9/93	pdw		Changed register saving from interruptRegs to pascalRegs in
;									completionRoutine because it is supposed to be using this
;									convention.
;	   <SM3>	10/27/92	CSS		Changed some word bsrs to bigjsrs.
;	   <SM2>	10/27/92	CSS		Changed short branch to word branch.
;	   <SM1>	 4/1/92		kc		Copied the routines DesktopCloseDownProc, CheckDesktopSupport and  DTDBMgrInit
;									from FileMgrPatches.a. Removed the "ROM" prefix from the RomBind routines.

;									• Pre-SuperMario comments follow •
;		<32>	 9/13/91	JSM		Cleanup header.
;		<31>	 5/23/91	dba		MPW 3.2 assembler no longer supports local labels for records
;		<30>	 3/28/91	dnf		ewa, #SetFileAttribsIsntAsyncSafe: The SetFileAttribs subroutine
;									doesn't save its return address on the a6 stack, causing crashes
;									when doing async I/O.
;		<29>	 3/20/91	dnf		sad, #DTGetInfoConsumesGranite: Fix DTGetInfo so that the
;									AddFileSizes routine that it calls actually works. It is good to
;									know that someone is now actually using this call.
;		<28>	 3/19/91	dnf		dba, #dnf: Don’t clobber Z bit when restoring return addresses
;									from the a6 stack.
;		<27>	 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.
;		<26>	 3/17/91	dnf		dba, dty, #84670, #82944: Change more routines to make them work
;									in an asynchronous world. The desktop manager now does all of
;									its I/O synchronously (except for _FindFolder, a gaping time
;									bomb)
;		<25>	 2/12/91	dnf		gbm, #81716: Move the call to DTCloseDown from the Process
;									Manager's notification hook to a patch to _Unmount (in
;									FileMgrPatches.a) so that it will come after we know that
;									nobody on the hook has rejected the unmount. Also put in tweak
;									for brc #81858 (replace #fnfErr with #afpItemNotFound)
;		<24>	 1/22/91	dnf		(ppd, tgh) Force DTOpenInform, DTGetPath and DTCloseDown to be
;									synchronous. Don’t use MakePBLookAsync anymore.
;		<23>	 1/17/91	dnf		(pwd) Make sure that FindDTFiles has the volume info before it
;									tries to decide if the volume is locked or not.
;		<22>	12/21/90	dnf		(dfh) Move substitution of volume name + shadow for the standard
;									name until after we're sure we're not going to create files with
;									the standard name. Restore the pb ptr after enqueue the
;									DTDBQElt.
;		<21>	12/18/90	dnf		(dba) Save a hint for each desktop database b-tree file in the
;									DTDBQElt, and pass it to all BTree Manager calls. Looks for and
;									creates shadow desktop folders in the preferences folder. Also
;									rewrote FindDTFiles to be simpler and smaller. Did _Allocate of
;									clump size in RealOpenDT and in ResetDT to minimize
;									fragmentation. Used HGetFileInfo/HSetFileInfo instead of
;									Get/SetCatInfo to be more specific about files vs. directories.
;									FlushVol instead of FlushFile.
;		<20>	12/16/90	dnf		(dba) Fix OpenDTInform bug by getting RealDTOpen to return a
;									valid result. Get rid of code that was never executed that made
;									a lame attempt to update the key descriptor.
;		<19>	 12/5/90	dnf		(with dba) Have RemoveAPPL look at AppSpec.parID instead of
;									ioDirID from the DTParamBlock. Have AddAPPL do this too.
;		<18>	 12/5/90	dnf		(with dba) Fixed three places where we didn’t move the return
;									address to the a6 stack before calling potentially async
;									routines. Expand the size of a volume name storage to 32 bytes,
;									since it is really the root directory name, and is not
;									necessarily 28 bytes or smaller. Started work on Preferences
;									folder support, but it is still IF’d out for this check-in.
;		<17>	 9/25/90	dnf		(dnf/pwd) Set up FSVars.dtOwnCall to point to each parameter
;									block used by the desktop manager so that FileShare can allow
;									these calls to pass unmolested.
;		<16>	 9/22/90	dnf		(dnf/pwd) Remove include of QMgr.a; it's now a separate file.
;									Dispatch desktop calls to external file systems by transferring
;									them to the file system queue and returning an #extFSErr.
;		<15>	  8/6/90	dnf		Make DTAddIcon canonify files before putting them into the
;									database. Have DTGetInfo return the volume containing the files
;									in ioVRefNum. Revert to using local key compare routine instead
;									of a (special) key descriptor.
;		<14>	 7/30/90	dnf		Change all bsr and jsr instructions that point at Rom bind
;									symbols into jsrRom macros.
;		<13>	  6/2/90	gbm		Fix Dave’s eensy weensy little mistake of CHECKING IN x xxxx xx
;									xxxx’x xxxxxxxxx!!!! (Appropriate slime deleted anyway. <dnf 15>)
;		<12>	  6/2/90	dnf		Make DTDeleteAPPL move the next-newest app to the front of the
;									list
;		<11>	 5/15/90	dnf		Make sure that StandardLocals always returns an even-sized
;									locals block
;		<10>	 4/24/90	dnf		Fix signed compare bug in GetComment
;		 <9>	 4/22/90	dnf		Fix reopening of shadow databases
;		 <8>	 4/20/90	dnf		Add creator type check to RemoveAPPL
;		 <7>	 4/13/90	dnf		Fix AddAPPL swap case.
;		 <6>	 4/10/90	dnf		Clip GetComment ioActCounts. Look in server folder for
;									databases. Change routine names to match public call titles
;									Rework APPL algorithms to improve speed.
;		 <5>	  2/9/90	DNF		Set up a4 on entry to DTSetUp in DTClose; Set ioReqCount with a
;									long in RmvAPPL
;		 <4>	  2/8/90	dnf		Change FindDTVol to save regs on a7
;		 <3>	  2/4/90	DNF		Add shadow support, implement xOpenDT
;		 <2>	  1/9/90	DNF		Add xOpenDT call
;	   <2.0>	 12/8/89	dnf		Added dangling DTDBQElt check on OpenDT
;	   <1.9>	11/17/89	dnf		Volume notification for both Offline and Unmount. OpenDT checks
;									GetVolParms
;	   <1.8>	11/10/89	dnf		Save all async-trashable regs at I/O bottleneck
;	   <1.7>	 11/8/89	dnf		Clear filler byte on IconKeys, set length correctly, add Unmount
;									notification
;	   <1.6>	10/17/89	dnf		Fix data rec allocation on APPL calls
;	   <1.5>	10/11/89	dnf		Async bottleneck for I/O, FindDTVol, file refs for DTRefNum,
;	   <1.4>	 9/18/89	dnf		Fix bug in GetAPPL, map btRecNotFnd to afpItemNotFnd, new
;									dispatcher
;	   <1.3>	  9/1/89	dnf		Get proper pointer in a1 for DTClose's call to _Dequeue, test
;									the result
;	   <1.2>	  8/7/89	dnf		Change IconRec to IconDRec to avoid collisions with QD equates
;	   <1.1>	  7/6/89	dnf		Complete alpha code, start of testing
;	   <1.0>	 5/30/89	dnf		Integrate CatSearch, FileID's and Desktop Database Mgr into one
;									ptch
;				  4/7/89	DNF		Rewritten to use newly exported Btree manager calls, new DT data
;									structures, new DT dispatching, and new external file system
;									handling. This rewrite uses almost all of the existing logic for
;									the service routines.
;				 5/23/88	PWD		Changed AddAPPL to use DTContd flag logic for complete cycle
;									(FindRecord as well as subsequent GetRecords); the entire
;									AddAPPL now unfolds into a true loop instead of burrowing its
;									way down the stack with successive serial number retries.
;				  5/3/88	PWD		Added code to set up DTORefNum and DTVRefNum at open time; fixed
;									MapCSpec to use new DTORefNum to do _GetCatInfo, fixing a bug
;									where comment calls on CD ROM volumes would try the mapping with
;									the wrong VRefNum.
;				 4/25/88	PWD		Changed all interrupt-lockout code to use $0600 instead of $0300
;									or HiIntMask.
;				  3/1/88	PWD		Changed to free reserved space at first DTOpen call made.
;				10/23/87	PWD		Fixed AddIcon to rewrite B*-Tree entry with new TagInfo if an
;									icon is overwritten with a new icon image.
;				 10/8/87	PWD		Changed to use common routine (FindDT) to check whether DB
;									exists in DTOpen and GtMetaInfo. For CD-ROM volumes, only
;									indicate DB support if the Desktop DB file already exists.
;				 9/16/87	PWD		Changed to set Type & Creator on Desktop datafile.
;				 8/13/87	PWD		Changed to use shadow-Desktop in System Folder of BootDrive if
;									volume is locked and no Desktop DB exists.
;				 7/27/87	CRZ		Changed some branches to short branches and vice versa.
;				 6/26/87	PWD		Changed version number from 1 to 2 to indicate DTClose bug
;									fixed, FSQueueHook support in.
;				 6/17/87	PWD		Fixed bug in DTClose where it RTS-ed instead of branching to
;									DTDone when DTSetup returned VolOfflinErr. Changed to use AFP
;									error message names. Added code to invoke FSQueueHook on all
;									calls.
;				  1/6/87	PWD		Changed DTFlags to DTFFlags to avoid conflict with Deferred Task
;									Manager equate
;				  1/2/87	PWD		Changed to retry call if Server Folder ID is set in Finder info
;									but no such folder is found.
;				 12/8/86	PWD		Changed to skip completion routines called synchronously to save
;									stack space.
;				 12/1/86	PWD		Changed to clump out data file by explicit _Allocate calls
;									before an icon is written out instead of modifying FCBClpSize.
;				11/20/86	PWD		Changed to clear hint before re-inserting entry after BTDelete
;									in InsEntry. Changed key comparison to ignore length of trial
;									key (padded out in index nodes). Changed all routines to pass
;									full-length keys (Getxxx would get fouled up by passing
;									partial-length keys to new key comparison routine.
;				11/17/86	PWD		Fixed GetMetaInfo call to return right bit for DT support
;									Changed to check refNum in detail only for local operation
;				11/13/86	PWD		Fixed dispatch logic to properly preserve A1 after DTDone
;				11/12/86	PWD		Fixed async return code. Always RTS after async I/O initiation
;									Incorporated various small modifications per Rich's suggestions
;									Changed to use GetTrapAddress/SetTrapAddress on install and
;									remove.
;				 11/2/86	PWD		Changed to support only drives 3 and up to prevent the
;									proliferation of Desktop databases on diskettes. Changed DTOpen
;									to set invisible and system (name lock) bits on both files.
;									Changed AddAPPL to stop re-writing B*-Tree records if a
;									duplicate entry is requested with the same tag. Added DTReset
;									and DTStatus calls. Changed GetIcon and GtIcnInfo to return icon
;									position in ioPosOffset. Changed GetIcon to take a hint when
;									given. Changed serial number assignment algorithm in AddAPPL to
;									return last entries added first.
;				10/28/86	PWD		Fixed GetIcon to handle _Read errors correctly.
;				10/23/86	PWD		Converted for use under MPW.
;				10/15/86	PWD		Changed GetIcon to stop using ioIconDefault field. Changed to
;									return new meta-info indicating new DT support present.
;				10/13/86	PWD		Added code to set up ReqstVol on ExtFSErr returns.
;				10/12/86	PWD		Fixed similar bugs in AddAPPL and RmvAPPL which caused name
;									comparisons between the B*-Tree record and PB Record to fail.
;									Fixed bug in RfnChk (failed to set condition codes on exit).
;									Added code to force clump size for Desktop Datafile.
;				10/10/86	PWD		Fixed to check for offline volumes before starting any
;									operation. Fixed bug which clobbered lo-mem due to bogus
;									ioOwnBuf on _HOpen. Added code to do a BTFlush.
;				 10/6/86	PWD		Fixed to locate target VCB correctly under all circumstances
;									Changed DTGetAPPL to special case index=0; treat like index=1
;									Fixed calls to MapCSpec to handle errors correctly.
;				 10/4/86	PWD		Fixed to properly set up ioTrap field on all calls.
;				 10/2/86	PWD		Fixed bug in DTOpen: don't use user's PB for _HOpen call.
;									Changed to repond to GetVolMetaInfo calls to indicate new
;									desktop support.
;				 9/24/86	PWD		Changed to use new key structure
;				 8/21/86	PWD		Changed to remove patch installation code and local storage
;				  8/5/86	PWD		Added code to convert internal B*-Tree error codes to AFP
;									errors, and filter out other positive error returns
;				 7/17/86	PWD		Separated out from DTMgr to allow DTSvcs to be included in patch
;									code (where it's in blank seg) and FSCP, where it sits with the
;									B*-Tree manager in the BTMgr segment.
;

			print		push
			print		off
			LOAD		'StandardEqu.d'
			INCLUDE 	'BTreeEqu.a'
			INCLUDE 	'DTDBMgrEqu.a'
			INCLUDE		'DTDBMgrPriv.a'
			include		'LinkedPatchMacros.a'
			include		'QMgrEqu.a'
			include		'FileMgrPrivate.a'
			include		'MFPrivate.a'
			include		'HardwarePrivateEqu.a'
			include		'Folders.a'
			include		'InternalOnlyEqu.a'				; <SM3> CSS
			print		pop

			BLANKS ON
			STRING ASIS

			entry		DequeueDTDBQElt
			entry		deepShitError
			import		GetQMRecPtr

			macro
			MakeLocals
			endm

; All of the routines in the desktop manager that have a parameter block as one of their
; locals have one of size DTBigPBSize, and it is always the first local on a6.

; All of the service routines of the DTMgr use a very similar local variable layout
; The only difference among the routines is the size of the Data block they need.
; This macro takes a label name (for the locals record) and a size for the data block
; in that record.
			macro
			StandardLocals	&name, &datalen
&name		record		0, increment
bigPB		ds.b		DTBigPBSize			; big enough for any call made from the DT routines
Key			ds.b		DTMaxKeySize		; enough space to form any DT key
			align		2					; max key length could be odd
Data		ds.b		&datalen			; enough space for a data record of requested length
			align		2					; data size could be odd
LSize		equ			*-bigPB
			endr
			endm

; The key descriptor we use for our BTrees simply tells the btree manager that we'll
; always be using our own key descriptor routine.
DTKeyDescriptor:	proc
	dc.b		2								; length of descriptor
	dc.b		kdUseKCProc						; we'll always be using a compare proc
	dc.b		1								; just one of them
	align		2								; line things up
	endproc

; so desktop symbols start from here
			proc
			_DTDebugRts	'DTDBQueueManager', 0
			endproc
; ex<SM1><Sys7.1> Removed DesktopCloseDownProc, DTDBMgrInit and CheckDesktopSupport
;________________________________________________________________________________
;
; Routine:		BottleNeckIO
;
; Input: 	a0 points to dt's ioParam or BTioParam
; 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

BottleNeckIO		proc	export

	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			completionRoutine, a1	; get our ioCompletion routine address
	move.l			a1, ioCompletion(a0)	; and install it into the param block

	movea.l			FSVarsPtr, a1			;									<17>
	move.l			a0, FSVars.dtOwnCall(a1); leave a bread crumb for FileShare <17>

	moveq.l			#desktopQType, d2		; our queue type/refnum
	bsr				GetQMRecPtr				;									ex<SM3><Sys7.1>
	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

	_DTDebugTail	'TheBottleNeck', 0

; 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.

completionRoutine:
	moveq.l			#desktopQType, d2		; our queue type/refnum
	bsr				GetQMRecPtr				;									ex<SM3><Sys7.1>
	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	<SM4>pdw<Sys7.1>
	pea				restoreInterruptRegs	; and get in the chain to restore them later			<Sys7.1>

contDeskThread:
	moveq.l			#desktopQType, d2		; our queue type/refnum
	bsr				GetQMRecPtr				;									ex<SM3><Sys7.1>
	movea.l			QMRec.curStack(a1), a6	; restore alt stack pointer
	adda.w			#Lsize, a6				; clear off the locals
	movem.l			(a6)+, BottleNeckRegs	; restore desktop thread registers
	move.l			(a6)+, -(sp)			; push desktop thread return address
	move.w			ioResult(a0),d0			; get the real error code and set ccr's				<27>
anRTSInstruction:
	rts										; and return to caller

contAppThread:
	bset.b			#0, hasContinued(a6)	; mark that we've returned
	bne.s			contDeskThread			; if we already ran the completion routine, then
											; continue without saving registers
	rts										; return async time to application

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

	_DTDebugTail	'Completion',0

; 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
&sym:			doSomeTrap	&theTrap
				entry		&sym
&sym:
				move.l		(sp)+, -(a6)	; save desktop thread ret addr on a6
				bsr.s		BottleNeckIO	; do common set up
				bne.s		@async			; branch if Z = 0 (async call)
				_&theTrap					; sync trap
				bra			contDeskThread	; keep going with this desktop call
@async:			_&theTrap	async			; async trap
				bra			contAppThread	; keep going, but give async time to app
				_DTDebugRts	'do&theTrap',0
				endm

; Macro for generating code that executes a synchronous or asynchronous hfsdispatch
; based on the value of the zero flag.  Zero set = async, zero clear = sync.
				macro
&sym:			doSomeA060Trap	&theTrap, &theDispatch
				entry		&sym
&sym:
				move.l		(sp)+, -(a6)	; save desktop thread ret addr on a6
				bsr.s		BottleNeckIO	; do common set up
				bne.s		@async			; branch if Z = 0 (async call)
				moveq.l		#&theDispatch, d0	; tell'em which HFS dispatch to do
				_HFSDispatch				; sync trap
				bra			contDeskThread	; keep going with this desktop call
@async:			moveq.l		#&theDispatch, d0	; tell'em which HFS dispatch to do
				_HFSDispatch async			; async trap
				bra			contAppThread	; keep going, but give async time to app
				_DTDebugRts	'do&theTrap',0
				endm

; Macro for generating code that executes a synchronous or asynchronous hfsdispatch
; based on the value of the zero flag.  Zero set = async, zero clear = sync.
				macro
&sym:			doSomeA08ETrap	&theTrap, &theDispatch
				entry		&sym
&sym:
				move.l		(sp)+, -(a6)	; save desktop thread ret addr on a6
				bsr.s		BottleNeckIO	; do common set up
				bne.s		@async				; branch if Z = 0 (async call)
				moveq.l		#&theDispatch, d0	; tell'em which HFS dispatch to do
				dc.w		$A08E			; sync trap
				bra			contDeskThread	; keep going with this desktop call
@async:			moveq.l		#&theDispatch, d0	; tell'em which HFS dispatch to do
				dc.w		$A48E			; async trap
				bra			contAppThread	; keep going, but give async time to app
				_DTDebugRts	'do&theTrap',0
				endm

doHOpen:			doSomeTrap		HOpen
doHDelete:			doSomeTrap		HDelete
doClose:			doSomeTrap		Close
doRead				doSomeTrap		Read
doWrite:			doSomeTrap		Write
doGetCatInfo:		doSomeA060Trap	GetCatInfo, selectGetCatInfo
doHGetVInfo:		doSomeTrap		HGetVInfo
doHGetFileInfo:		doSomeTrap		HGetFileInfo
doHSetFileInfo:		doSomeTrap		HSetFileInfo
doHCreate:			doSomeTrap		HCreate
doAllocate:			doSomeTrap		Allocate
doSetEOF:			doSomeTrap		SetEOF
doGetEOF:			doSomeTrap		GetEOF
doGetFCBInfo:		doSomeA060Trap	GetFCBInfo, selectGetFCBInfo
doFlushVol:			doSomeTrap		FlushVol
doMakeFSSpec:		doSomeA060Trap	MakeFSSpec, selectMakeFSSpec
doGetVolParms:		doSomeA060Trap	GetVolParms, selectGetVolParms

doBTSearch:			doSomeA08ETrap	BTSearch, 6
doBTGetRec:			doSomeA08ETrap	BTGetRec, 7
doBTSetRec:			doSomeA08ETrap	BTSetRec, 4
doBTReplRec:		doSomeA08ETrap	BTReplRec, 5
doBTDelRec:			doSomeA08ETrap	BTDelRec, 8
doBTFlush:			doSomeA08ETrap	BTFlush, 10

	endproc

;
; A little wrapper for Begin/EndSystemMode to save regs including CCR
;

myBeginSystemMode:		proc
myBeginSystemModeRegs	reg		d0-d2/a0/a1
		move.w		sr,-(sp)
		movem.l		myBeginSystemModeRegs, -(sp)	; pascal call trashes these
		suba.w		#2, sp					; space for output
		_BeginSystemMode
		adda.w		#2, sp					; ignore the error
		movem.l		(sp)+, myBeginSystemModeRegs
		rtr
		_DTDebugTail	'myBeginSystemMode',0
		endproc

myEndSystemMode:	proc
myEndSystemModeRegs		reg		a0/a1/d0-d2
		move.w		sr,-(sp)
		movem.l		myEndSystemModeRegs, -(sp)		; pascal call trashes these
		suba.w		#2, sp					; space for output
		_EndSystemMode
		adda.w		#2, sp					; ignore the error
		movem.l		(sp)+, myEndSystemModeRegs
		rtr
		_DTDebugTail	'myEndSystemMode',0
		endproc

;________________________________________________________________________________
;
; Routine:		DeskMgrQueue
;
; input:		user's DTparam in a0
; output:		a1 - trashed
;
; Function: 	We're always called here while on the file system queue (upon which we
;				checked for calls to external file systems).  We first extricate ourselves
;				from the file system queue and then enqueue ourselves on the desktop manager
;				queue, setting up our own alternate (a6) stack and leaving all set to
;				process the call.
;
;				Note that we jump to QMEnqueue so that we leave only one level of
;				return address on top of the stack.
;________________________________________________________________________________
;

		entry		DTDone
DeskMgrQueue:	proc
		import		UnMungeTrapWord, MakePBLookAsync, GetOffFSQueue
		import		QMEnqueue

		jsr			GetOffFSQueue			; Get a0 (now FSQHead) off FSQueue

		moveq.l		#desktopQType, d2		; the dtqueue refnum
;		bsr			MakePBLookAsync			; adjust for the fact that we could be async now
		jsr			UnMungeTrapWord			; leave true trap word and dispatch in d1/d0
		jmp			QMEnqueue				; get queued up, dispatched to. CmdDone addr on a6 stack

		_DTDebugRts	'DeskMgrQueue',0
		endp

DTDone:	proc
		import		UnMungeTrapWord, FSQUEUE   , CMDDONE   
		move.l		(a6)+, a1				; get completion address from a6 stack

; error mapping - the original implementation of the desktop manager returned afp error
; codes, so we need to continue to do so.
@MapErrors:
		cmp.w	#btRecNotFnd, d0			; did we get a btRecNotFnd error?				<dnf 1.4>
		bne.s	@notBtRecNotFnd				; no - go check the next error
		move.w	#afpItemNotFound, d0		; yes - then replace it with the right afp error<dnf 1.4>
		bra.s	@justLeave
@notBtRecNotFnd:

		cmp.w	#btEofErr, d0				; did we get run into the end of the btree file?
		bne.s	@notBtEofErr				; no - go check the next error
		move.w	#afpItemNotFound, d0		; yes - tell'em about it in afp style
		bra.s	@justLeave
@notBtEofErr:

		cmp.w	#fnfErr, d0 				; #fnfErr is an HFS error code					<25>
		bne.s	@notFnfErr					; no - go check the next thing					<25>
		move.w	#afpItemNotFound, d0		; be true to our afp roots						<25>
@notFnfErr:

@justLeave:
		jmp		(a1)

		_DTDebugRts	'DTDone', 4
		endp

;________________________________________________________________________________
;
; Routine:		DTVolExtFSCheck
;
; Function:		Check whether this desktop call should be routed to an external
;				file system.  We're always called here already on the file system
;				queue.  That gives us the right to peek around lomem looking for
;				our volume.  If the call turns out to be for an external file system
;				we strip one return address (the one back to the DTMgr routine which
;				called us), set ReqstVol and return an #extFSErr to CMDDONE   , which
;				dutifully dispatches it down the toExtFS chain.
;
;				If the call turns out to be local, we rts to the DTMgr routine which
;				called us.  The DTMgr routine will then call DTMgrQueue, which knows
;				the the param block it is attempting to enqueue on the desktop manager
;				queue needs to be removed from the file system queue first.
;
; Inputs:		a0 - caller's desktop manager param block
;
;________________________________________________________________________________
DTVolExtFSCheck:	proc
		jsrROM	ROMDTRMV3						; Excuse me, Mr. FS, please find us a volume	ex<SM1><Sys7.1> Put back "ROM"
		bne.s	@LocalErr						; early trouble is a sign to leave

		tst.w	vcbFSID(a2)						; is this a local volume?
		beq.s	@LocalVolume

		move.l	a2, ReqstVol					; inform external file systems of our volume choice

		move.b	ioTrap+1(a0), d0				; grab our dispatch selector
		cmp.b	#selectDTGetPath, d0			; was it DTGetPath?
		beq.s	@GrabAnFCB						; externals expect an FCB on a DTOpen
		cmp.b	#selectDTOpenInform, d0			; was it DTOpenInform?
		bne.s	@ExternalExit					; if not, just let'em have the call

@GrabAnFCB:
		jsrROM	ROMGT1STFCB						; get (A1,D1) pointing to first FCB				ex<SM1><Sys7.1> Put back "ROM"
@1		tst.l	FCBFlNm(a1,d1)					; FCB unused?
		beq.s	@GotFCB							; br if so
		jsrROM	ROMGTNXTFCB						; get next one until we run out					ex<SM1><Sys7.1> Put back "ROM"
		bcs.s	@1

		moveq.l	#TMFOErr,d0 					; too many files open
		clr.w	IORefNum(a0)					; make refnum invalid
		bra.s	@LocalErr						; don't bother to pass this one along

@GotFCB:
		add.l	a1,d1							; Point to the FCB

@ExternalExit:
		moveq.l	#extFSErr, d0					; tell'em we can't handle it

@LocalErr:
		tst.l	(sp)+							; discard the return address to DTMgr caller
		jmpROM	ROMCMDDONE						; leave through the file system					ex<SM1><Sys7.1> Put back "ROM"

@LocalVolume:
		move.l	FSVarsPtr, a3					; a3 = ptr(file system global area)
		move.l	FSVars.DTDBMgr(a3), a3			; a3 = ptr(DTDB manager's global area)
		move.w	vcbVRefNum(a2), DTGlobals.targetVRef(a3)		; save our volume for later
		rts										; this call is for us
		endproc

;________________________________________________________________________________
;
; Routine:		DTRfnExtFSCheck
;
; Function:		Check whether this desktop call should be routed to an external
;				file system.  We're always called here already on the file system
;				queue.  That gives us the right to peek around lomem looking for
;				our volume.  If the call turns out to be for an external file system
;				we strip one return address (the one back to the DTMgr routine which
;				called us), set ReqstVol and return an #extFSErr to CMDDONE   , which
;				dutifully dispatches it down the toExtFS chain.
;
;				If the call turns out to be local, we rts to the DTMgr routine which
;				called us.  The DTMgr routine will then call DTMgrQueue, which knows
;				the the param block it is attempting to enqueue on the desktop manager
;				queue needs to be removed from the file system queue first.
;
; Inputs:		a0 - caller's desktop manager param block
;
;________________________________________________________________________________
DTRfnExtFSCheck:	proc
		import	RefNumCheck

		move.w	ioRefNum(a0), d0				; get the refnum in question
		move.w	d0, d1							; save a copy for later
		jsr		RefNumCheck						; see if we like this refnum
		bne.s	@LocalErr						; early trouble is a sign to leave

		movea.l	FCBSPtr, a1						; point to the FCBs
		movea.l	fcbVPtr(a1, d1.w), a2			; get the VCB in question
		tst.w	vcbFSID(a2)						; is this a local volume?
		beq.s	@LocalVolume

		move.l	a2, ReqstVol					; inform external file systems of our volume choice
		moveq.l	#extFSErr, d0					; tell'em we can't handle it

@LocalErr:
		tst.l	(sp)+							; discard the return address to DTMgr caller
		jmpROM	ROMCMDDONE						; leave through the file system					ex<SM1><Sys7.1> Put back "ROM"

@LocalVolume:
		rts										; this call is for us
		endproc

;________________________________________________________________________________
; <21>
; Routine:		SaveHintInDTDBQElt				param block -> dtqelt
;
; Function:		Gets the btree hint out of the current param block and
;				stores it in the globabls for the database that the
;				current call is running on.
;
; Inputs:		a0 - btioParam block
;				a3 - pointer to current DTDBQElt
;
; Outputs:		a0 - pointer to BTParam
;				a3 - pointer to current DTDBQElt
;				also preserves CCR
;
;________________________________________________________________________________
SaveHintInDTDBQElt	proc

Registers	reg		a1/a2

			movem.l	Registers,-(sp)
			lea.l	DTDBQElt.lastHint(a3), a1	; a1 = ptr(recent bt hint in DTDBQElt)
			lea.l	ioBTHint(a0), a2			; a2 = ptr(bt hint in param block)
			move.l	(a2)+,(a1)+					; a hint is 16 bytes
			move.l	(a2)+,(a1)+
			move.l	(a2)+,(a1)+
			move.l	(a2)+,(a1)+
			movem.l	(sp)+,Registers
			rts

			endproc

;________________________________________________________________________________
; <21>
; Routine:		GetHintFromDTDBQElt			dtqelt -> param block
;
; Function:		Gets the btree hint out of the the globabls for the database
;				that the current call is running on and stores it into the
;				btioParam on a0.
;
; Inputs:		a0 - btioParam block
;				a3 - pointer to current DTDBQElt
;
; Outputs:		a0 - pointer to BTParam
;				a3 - pointer to current DTDBQElt
;
;________________________________________________________________________________
GetHintFromDTDBQElt	proc

Registers	reg		a1/a2

			movem.l	Registers,-(sp)
			lea.l	DTDBQElt.lastHint(a3),a1	; a1 = ptr(recent bt hint in DTDBQElt)
			lea.l	ioBTHint(a0),a2				; a2 = ptr(bt hint in param block)
			move.l	(a1)+,(a2)+					; a hint is 16 bytes
			move.l	(a1)+,(a2)+
			move.l	(a1)+,(a2)+
			move.l	(a1)+,(a2)+
			movem.l	(sp)+,Registers
			rts

			endproc

;________________________________________________________________________________
;
; Routine:		SetUpBTPB
;
; Function:		Gets a param block on a0, and then fills in BTRefNum, key and data pointers
;				based on the standard locals layout.
;
; Inputs:		a3 - pointer to current DTDBQElt
;				a6 - pointer to executing routine's locals
;
; Outputs:		a0 - pointer to BTParam
;				a2 - pointer to space to build the BTree key
;				a3 - pointer to current DTDBQElt
;
;________________________________________________________________________________
SetUpBTPB:	proc

			StandardLocals BTDummy, 2			; just to get key and data offsets

			with BTDummy						; Key and Data refer to locals

			lea.l	bigPB(a6), a0				; a0 = ptr(param block)
			bsr		GetHintFromDTDBQElt			; get the hint <21>

			move.w	DTDBQElt.DBRefNum(a3), ioRefNum(a0)	; use the btree refnum

			lea.l	Data(a6), a2				; standard location of BTree record data buffer
			move.l	a2, ioBuffer(a0)			; tell the param block about it
			lea.l	Key(a6), a2					; a2 = ptr(place to build key)
			move.l	a2, ioBTKeyPtr(a0)			; tell the param block about it
			rts

			endwith
			_DTDebugTail	'SetUpBTPB',0
			endproc

;________________________________________________________________________________
; <21>
; Routine:		DoneBTPB
;
; Function:		Gets the btree hint out of the current param block and
;				stores it in the globabls for the database that the
;				current call is running on.
;
; Inputs:		a3 - pointer to current DTDBQElt
;				a6 - pointer to executing routine's locals
;				also preserves CCR
;________________________________________________________________________________
DoneBTPB		proc

			StandardLocals BTDummy, 2			; just to get key and data offsets

			with BTDummy						; Key and Data refer to locals

			move.w	sr,-(sp)					; save CCR
			move.l	a0,-(sp)
			lea.l	bigPB(a6), a0				; a0 = ptr(param block)
			bsr		SaveHintInDTDBQElt
			move.l	(sp)+,a0
			rtr									; restore CCR

			endwith
			_DTDebugTail	'DoneBTPB',0
			endproc

;________________________________________________________________________________
;
; Routine:		SetUpDFPB
;
; Function:		Gets a param block on a0, and then fills in DFRefNum
;
; Inputs:		a3 - pointer to current DTDBQElt
;				a6 - pointer to current StandardLocals
;
; Outputs:		a0 - pointer to param block
;
;________________________________________________________________________________
SetUpDFPB:	proc

			StandardLocals DFDummy, 0			; just to get offsets

			with DFDummy

			lea.l	bigPB(a6), a0				; a0 = ptr(param block)
			move.w	DTDBQElt.DFRefNum(a3), ioRefNum(a0)		; use icon data file refNum
			rts
			_DTDebugTail	'SetUpDFPB',0
			endwith
			endproc

;________________________________________________________________________________
;
; Routine:		FindDTVol
;
; Function: 	See if a desktop database is open for a given VRefNum
;
; Inputs:		d0 = user's VRefNum
;
; Output:		d0 = noErr or rfNumErr
;				a3 = Pointer to DTDBQElt block for selected database
;
; All other registers preserved.
; Note that the DesktopCloseDownProc in FileMgrPatches.a calls this routine.
;________________________________________________________________________________
;
FindDTVol: proc	export							; 				<25> added the export 
			move.l	d1, -(sp)					; save d1 around call
			move.l	FSVarsPtr, a3				; a3 = ptr(file system global area)
			move.l	FSVars.DTDBMgr(a3), a3		; a3 = ptr(DTDB manager's global area)
			move.l	DTGlobals.qHead(a3), a3		; a3 = ptr(1st open database)
			bra.s	@nextPtr					; check for nil (no open databases)

@WalkQueue:
			cmp.w	DTDBQElt.XVRefNum(a3), d0	; is this the right volume?
			beq.s	@foundIt					; yes? Then stop looking
			move.l	DTDBQElt.qLink(a3), a3		; move on to the next one
@nextPtr:
			move.l	a3, d1						; set condition codes to check for nil
			bne.s	@WalkQueue					; something there? keep looking.

; If we get here, then we saw a nil pointer, which means none of the open databases
; matched the user's volume.  Return a rfNumErr

			move.w	#rfNumErr, d0				; set result code
			bra.s	@leave

@foundIt:	move.w	#0, d0						; no errors
@leave:		move.l	(sp)+, d1					; restore d1
			tst.w	d0							; set the result code
			rts
			_DTDebugTail	'FindDTVol',0
			endproc

;________________________________________________________________________________
;
; Routine:		DTSetup
;
; Function: 	Setup common to all desktop manager operations which take a DTRefNum.
;
; Inputs:		a4 = DT Parameter block
;				a6 = alt stack
; Output:		d0 = error code (from FindDTVars).
;				a3 = Pointer to DTQElt block (if DTRef checked out)
;				a6 = alt stack
;
; All other registers preserved.
;________________________________________________________________________________
;
DTSetup:	proc
			move.l	d1, -(a6)					; save d1 around call
			move.w	ioDTRefNum(a4), d0			; extract DTRefNum from user's param block

			move.l	FSVarsPtr, a3				; a3 = ptr(file system global area)
			move.l	FSVars.DTDBMgr(a3), a3		; a3 = ptr(DTDB manager's global area)
			move.l	DTGlobals.qHead(a3), a3		; a3 = ptr(1st open database)
			bra.s	@nextPtr					; check for nil (no open databases)

@WalkQueue:
			cmp.w	DTDBQElt.DTRefNum(a3), d0	; is this the right database?
			beq.s	@foundIt					; yes? Then stop looking
			move.l	DTDBQElt.qLink(a3), a3		; move on to the next one
@nextPtr:
			move.l	a3, d1						; set condition codes to check for nil
			bne.s	@WalkQueue					; something there? keep looking.

; If we get here, then we saw a nil pointer, which means none of the open databases
; matched the user's DTRefNum.  Return a rfNumErr

			move.w	#rfNumErr, d0				; set result code
			bra.s	@leave

@foundIt:	move.w	#0, d0						; no errors
@leave:		move.l	(a6)+, d1					; restore d1
			tst.w	d0							; set the result code
			rts
			_DTDebugTail	'DTSetUp',0
			endproc

;________________________________________________________________________________
;
; Routine:		CheckCSpec
;
; Function: 	Get info on a CNodeID in the catalog.  Translate the user's
;				DTRefNum into the right volume for the check.
;
; Inputs:		a3 = DTDBQElt block for current database
;				a4 = User's DTParam block
;
; Outputs:		d0 = result code from _GetCatInfo on CNode
;				d1 = CNodeID of the CNode we just checked
;
;________________________________________________________________________________
CheckCSpec:		proc

CCSLocals		record	0, increment
bigPB			ds.b		DTBigPBSize					; big enough to make any HFS or Btree call
LSize			equ			*-bigPB
				endr

@CCSRegs		reg		a0/a1

			with	CCSLocals
			move.l	(sp)+, -(a6)						; save desktop return addr around i/o
			movem.l	@CCSRegs, -(a6)						; save regs
			suba.w	#LSize, a6							; allocate locals on a6

			lea.l	bigPB(a6), a0						; a0 = ptr(param block)
			move.l	ioFileName(a4), ioFileName(a0)		; use user's name ptr
			move.w	DTDBQElt.XVRefNum(a3), ioVRefNum(a0)	; use correct volume ref
			clr.w	ioFDirIndex(a0)						; no indexing
			move.l	ioDirID(a4), ioDirID(a0)			; use user's DirID
			go_GetCatInfo 								; Look up this CNode's CNID
			move.l	ioDirID(a0), d1						; ioDirID now contains CNodeID, so return it
			add.w	#LSize, a6							; deallocate locals
			movem.l	(a6)+, @CCSRegs
			move.l	(a6)+, -(sp)						; restore desktop return address
			tst.w	d0
			rts
			endwith
			_DTDebugTail	'CheckCSpec',0
			endproc

;________________________________________________________________________________
; <21>
; Routine:		MyFindFolder/MyMakeFolder
;
; A little wrapper for FindFolder that is register-based.
; Currently, we implement two extra specialties the are handy for us
;		'root'	returns the root directory
;		'serv'	returns the server directory	(we won't create this, though)
;
; Inputs:
;	d1.w	vRefNum or wdRefNum we're interested in
;	d2.l	folder specialty
;
; Outputs:
;	d0.w	error code (ccr set)
;	d1.w	vRefNum
;	d2.l	directory ID
;________________________________________________________________________________
MyMakeFolder:	proc
	entry	myFindFolder
	moveq.l	#kCreateFolder,d0
	bra.s	MakeFindCommon
MyFindFolder:
	moveq.l	#kDontCreateFolder,d0

MakeFindLocals			record		0, increment
vRef		ds.w		1				; stores the vRefNum of the volume under consideration
dirID		ds.l		1				; stores the directory ID of the directory we're looking in
bigPB		ds.b		ioHVQElSize		; enough for an HGetVolInfo
LSize		equ			*
			endr

MakeFindRegs	reg		a0/a1
FolderMgrSupportsRootAndServ	equ	0

	with	MakeFindLocals

MakeFindCommon:
	move.l	(sp)+,-(a6)					; we do I/O												<26>
	movem.l	MakeFindRegs, -(a6)			; so we save on the A6 stack							<26>
	sub.w	#LSize,a6

	if not(FolderMgrSupportsRootAndServ) then

	cmp.l	#'root',d2					; looking for the root directory?
	beq.s	@mine
	cmp.l	#'serv',d2					; looking for the server folder?
	bne.s	StandardFind

@mine:
	cmp.w	#kOnSystemDisk, d1			; folder manager's special system disk indicator?
	bne.s	@useTheVolume
	
	move.w	BootDrive, d1				; try the boot drive (a.k.a where the active system is)

@useTheVolume:
	lea.l	bigPB(a6),a0				; a0 = ptr(param block)
	clr.l	ioFileName(a0)				; we don't want the volume name
	move.w	d1,ioVRefNum(a0)			; VRef of volume to look at
	clr.w	ioVolIndex(a0)				; no indexing; use VRef only
	go_HGetVInfo
	bne.s	@error						; punt on errors
	move.w	ioVRefNum(a0),d1			; HGetVInfo extracts vRefs from wdRefs
	cmp.l	#'root',d2					; looking for the root directory?
	beq.s	@root
	move.l	ioVFndrInfo+28(a0),d2		; d2 = DirID of server folder
	bne.s	@test						; got one, success
	moveq.l	#fnfErr,d0					; just like the folder manager
@error:
@test:
	bra.s	Done

@root:
	moveq.l	#fsRtDirID,d2
	bra.s	Done						; get out of here, and test the result code				<28>

StandardFind:

	endif

	subq.l	#2,sp						; allocate a word for error code
	move.w	d1,-(sp)					; look for the folder on this volume
	move.l	d2,-(sp)					; look for this folder
	move.w	d0,-(sp)					; tell whether to create
	pea.l	vRef(a6)					; stuff the volume in here
	pea.l	dirID(a6)					; and the directory here

; Note: This is call will do synchronous I/O, which is strictly illegal in 
; the Desktop Manager, since Desktop Manager calls can trigger requests on
; the front the File System queue (which could themselves be Desktop Manager
; calls) and a executing a syncwait for the triggered call could hang the
; system.  The only solace we can take is that this call is executed only
; when a volume is mounted, so it won't hang the system very often.

	_FindFolder
	move.w	vRef(a6),d1					; grab the volume
	move.l	dirID(a6),d2				; grab the directory
	move.w	(sp)+,d0					; grab the error
Done:
	add.w	#LSize,a6
	movem.l	(a6)+,MakeFindRegs			; get the stuff back									<26>
	move.l	(a6)+,-(sp)					; we did I/O											<26>
	tst.w	d0							; make sure we set the ccr								<28>
	rts
	endwith
	endproc

;________________________________________________________________________________
; <21>
; Routine:		FindDTFiles
;
; Find the desktop database files, if they exist.  If they don't exist, return the
; appropriate location and name for them.
;
; The desktop database files are always a pair of files with names that differ
; only in the last character.  For normal desktop files, the names are 'Desktop DB'
; and 'Desktop DF'.  DB is a btree file, DF is a data file with icons in it.  For
; shadow desktops (databases maintained on a different volume to support a volume that
; isn't writeable) the files are named '<volume name> DDB' and '<volume name> DDF'
;
; The idea: On unlocked volumes, we'll look for a database file in the root (the normal spot),
;			then server folder (in case the volume is a server that had a file created
;			there by the old desktop manager), and the system folder (in case the volume is a
;			regular hard drive and the user was running the old Desktop Manager INIT).
;			If we don't find one, we'll return the root as the place to create one.
;
;			On locked volumes, we'll do the first part of above, then take a look
;			in the currently active preferences folder and system folder for a shadow database.
;			If we strike out both above and in the active system folder, we'll return the active
;			preferences folder as the place to create the shadow database.
;
; Inputs:	a1.l -	pointer to 32 character buffer
;			d0.w -	vRefNum of volume to open DT on
;
; Outputs:	a0.l -	preserved
;			a1.l -	ptr(Name for btree file).  Datafile name is always formed from btree file name
;					by changing the last character from a 'B' to an 'F'
;			d0.w -	result code (error invalidates d1/d2/d3)
;			d1.w -	VRefNum of volume containing actual database files
;			d2.l -	ParID of directory containing actual database files
;			d3.b -  Set true if the files exist, false if they don't
;					If the files don't exist, they should be created in d1/d2 w/name (a1)
;________________________________________________________________________________
FindDTFiles:		proc

FindDTLocals			record		0, increment
bigPB		ds.b		DTBigPBSize		; big enough for all HFS calls
LSize		equ			*
			endr

FindDTRegs	reg			d4/a0/a2/a3

	with	FindDTLocals
	move.l	(sp)+,-(a6)					; we do I/O												<26>
	movem.l	FindDTRegs,-(a6)			; save regs												<26>
	sub.w	#LSize,a6					; allocate locals
	move.w	d0,d3						; save caller's requested volume

; Use the standard dt btree file name.
	lea.l	StandardName, a0			; a0 = ptr(the standard btree file name)
	moveq.l	#0, d0						; clear high bytes
	move.b	(a0), d0					; get length of string
	addq.b	#1, d0						; add one for the length byte
	_BlockMove							; copy standard name into caller's (a1) buffer

	move.l	#'root',d2					; try the root first
	bsr		CheckDTExists
	beq		Found

	move.l	#'serv',d2					; try the server folder next
	bsr		CheckDTExists
	beq		Found

	move.l	#kSystemFolderType,d2		; try the server folder next
	bsr		CheckDTExists
	beq		Found

	lea.l	bigPB(a6),a0				; a0 = ptr(param block)
	clr.l	ioFileName(a0)				; we don't want the volume name
	move.w	d3,ioVRefNum(a0)			; vRef of volume to look at
	clr.w	ioVolIndex(a0)				; no indexing; use VRef only
	go_HGetVInfo
	bne.s	Error						; punt on errors <SM2> CSS <Sys7.1>
	
	move.w	bigPB+ioVAtrb(a6), d0		; get the volume attributes
	btst.l	#15, d0						; software locked?
	bne.s	VolLocked
	btst.l	#7, d0						; hardware locked?
	bne.s	VolLocked					; if not, then we need to make new files

	move.l	#'root',d2					; make it in the root
	bra.s	Create

VolLocked:

; Replace the standard name with the name of the volume we're shadowing
	lea.l	bigPB(a6),a0				; a0 = ptr(param block)
	move.l	a1,ioFileName(a0)			; tell the param block where to store the vol. name
	move.w	d3,ioVRefNum(a0)			; vRef of volume to look at
	clr.w	ioVolIndex(a0)				; no indexing; use VRef only
	go_HGetVInfo
	bne.s	Error						; punt on errors

; Transform volume name into shadow btree file name by adding StandardShadow to it.
	moveq.l	#0,d0						; clear high bytes
	moveq.l	#0,d2
	movea.l	a1, a2						; save base address of name string
	lea.l	StandardShadow,a0			; a0 = ptr(shadow pstring)
	move.b	(a0)+,d0					; d0 = number of characters to copy
	move.b	(a1),d2						; d2 = length of volume name
	add.b	d0,(a1)+					; update length to include shadow characters
	add.w	d2,a1						; point to end of volume name
	_BlockMove
	movea.l	a2, a1						; restore a1 to point as base of string
	
	move.w	#kOnSystemDisk,d3			; now we're looking on the system disk for shadow databases
	move.l	#kPreferencesFolderType,d2	; try the preferences folder first
	bsr.s	CheckDTExists
	beq.s	Found

	move.l	#'serv',d2					; try the server folder next
	bsr		CheckDTExists
	beq.s	Found

	move.l	#kSystemFolderType,d2		; try the system folder last
	bsr.s	CheckDTExists
	beq.s	Found

	move.l	#kPreferencesFolderType,d2	; make it in the preferences folder

Create:
	move.w	d3,d1						; get volume to create on
	bsr		MyMakeFolder
	bne.s	Error
	moveq.l	#0,d3						; indicate files don't exist
	bra.s	Done

Found:
	moveq.l	#1,d3						; indicate that files exist
	
Error:
Done:
	add.w	#LSize,a6
	movem.l	(a6)+,FindDTRegs			; restore												<26>
	move.l	(a6)+,-(sp)					; we did I/O											<26>
	tst.w	d0							; be nice and set up flags								<28>
	rts

; This  routine assumes the a6 stack from FindDTFiles
;
;	input:	d3.w			the volume to check
;			d2.l			the special folder to check
;			a1.l			ptr(name to look for)
;
;	output:	d1.w			volume found on
;			d2.l			directory found in
;			d0.w			error code

CheckDTExists:
	move.l	(sp)+,-(a6)					; we do I/O												<26>
	move.w	d3,d1
	bsr		myFindFolder				; convert d2 from specialty to dirID
	bne.s	@error
	lea.l	bigPB+4(a6), a0				; a0 = ptr(param block) (add 4 for ret. addr. on a6)	<28>
	move.l	a1,ioFileName(a0)			; we want info on this file
	move.w	d1,ioVRefNum(a0)			; look on our current volume
	clr.w	ioFDirIndex(a0)				; no indexing; look by dirID and CName only
	move.l	d2,ioDirID(a0)				; in the proper directory
	go_HGetFileInfo
@error:
	move.l	(a6)+,-(sp)					; we did I/O											<26>
	tst.w	d0							; make sure we set the ccr's							<28>
	rts

	_DTDebugTail 'FindDTFiles',18		; the names = 18 bytes

	endwith

	string	pascal
StandardName:
	dc.b	'Desktop DB'				; of the standard name for the desktop database btree file
	align
StandardShadow:
	dc.b	' DDB'						; suffix for shadow i.e. 'Hard Disk' becomes 'Hard Disk DDB'
	align
	string	asis

	endproc

;________________________________________________________________________________
; <1.7><1.9><25>
; Routine:		DesktopNotifyProc
;
; Inputs 		notifyFrame stack frame
;
; Outputs:		result from CloseDT call (normally noErr)
;				We don't do anything if FindDTVol shows that desktop database is closed
;
; Function:		Flush the desktop database on Offline calls
;				Flush the desktop database on Unmount calls
;
;________________________________________________________________________________
DesktopNotifyProc:	proc
@DesktopNotifyProcRegs	reg		a1/a3/d0

	link		a6, #0							; set up a stack frame
	movem.l		@DesktopNotifyProcRegs, -(sp)

	with		notifyFrame
	move.l		vnbPtr(a6), a1					; a1 = ptr(volume notice block)
	move.w		VNBNotice(a1), d0				; d0 = notice value
	cmp.w		#VNAboutToGoOffline, d0			; is this an offline notification?
	beq.s		@DoOfflineAction				; go do our stuff
	cmp.w		#VNAboutToUnmount, d0			; is this an unmount notification?
	bne.s		@SuccessExit					; no? then leave

; This is an offline or unmount notification.  Try to flush the desktop database for the
; indicated volume.
@DoOfflineAction:
	move.w		VNBVolume(a1), d0				; get the volume for which we're being notified
	bsr			FindDTVol						; try to find a DTDBQElt for this volume
	bne.s		@SuccessExit					; no database? Smile and leave

	sub.w		#ioDTQElSize, sp				; allocate a DT param block
	movea.l		sp, a0							; a0 = ptr(our DT param block)
	move.w		DTDBQElt.DTRefNum(a3), ioRefNum(a0)		; stash the DTRefNum for this volume
	_DTFlush
	move.w		d0, theErr(a6)					; return the error from CloseDT
	add.w		#ioDTQElSize, sp				; deallocate the DT param block
	bra.s		@Exit							; and leave

@SuccessExit:
	move.w		#noErr, theErr(a6)				; indicate no problems

@Exit:
	movem.l		(sp)+, @DesktopNotifyProcRegs
	unlk		a6								; undo the stack frame
	move.l		(sp)+, a0						; get the return address
	add.w		#4, sp							; blow away the input parameter
	jmp			(a0)							; return to caller
	_DTDebugRts	'DesktopNotifyProc', 0
	endproc

;________________________________________________________________________________
;
; Routine:		RealOpenDT
;
; Inputs:		a0 - pointer to caller's DT param block
;							uses only ioVRefNum
;
; Outputs:		d0 - result code
;				d1.b - file exists flag
;					true = files existed before this open call; they were just opened
;					false = files did not exist before call; they were just created
;
; Function: 	Open an access path to the Desktop database.  If the database is already
;				open for the specified volume, return its refNum.
;
;				This call is synchronous only.  Yes, those move.l (sp)+, -(a6) lines
;				could be removed someday.
;________________________________________________________________________________

RealOpenDTLocals	record	0, increment
bigPB			ds.b		DTBigPBSize			; big enough to make any HFS or Btree call
userVRef		ds.w		1					; User's requested vRefNum
dbName			ds.b		32					; Space for name of database files
volParmBuf		equ			dbName				; 32 bytes is fine for a _GetVolParms buffer	<20>
existsFlag		ds.b		1					; true if the files already existed
	align
LSize			equ			*-bigPB
				endr

	entry		SetFileAttribs
	entry		DTKeyCmp

RealOpenDT:			proc export

@OpenDTRegs		reg			a0-a4/d2

	with		RealOpenDTLocals
	move.l		(sp)+, -(a6)					; we do i/o
	movem.l		@OpenDTRegs, -(a6)
	suba.w		#LSize, a6
	movea.l		a0, a4							; move user's DTParam to a safe register

;
; Grab the volume that this call is aimed at (determined when checking for external file systems)
;
	move.l		FSVarsPtr, a3					; a3 = ptr(file system global area)
	move.l		FSVars.DTDBMgr(a3), a3			; a3 = ptr(DTDB manager's global area)
	move.w		DTGlobals.targetVRef(a3),userVRef(a6)	; pick up caller's requested volume (true vRef)

;
; First, check to make sure that this volume's DT isn't already open
;
	move.w		userVRef(a6), d0				; is this volume's database already open?
	bsr			FindDTVol						; go look for DT files (DTDBQElt ptr in a3 if success)
	bne.s		@NotAlreadyOpen					; if not, we'll have to open it

;
; Everything's cool - this really is an already opened database.
;
	move.w		DTDBQElt.DTRefNum(a3), ioDTRefNum(a4)	; put the DTRefNum into user's PB
	st.b		existsFlag(a6)					; say we got it open, and it was already there	<20>
	bra			@SuccessExit					; get out										<20>

;
; The database is not currently open on the given volume.  Go open it.
;
@NotAlreadyOpen:
; <1.9>
; Make sure that this volume supports a desktop database
;
	lea.l		bigPB(a6), a0					; a0 = ptr(param block)
	move.w		userVRef(a6), ioVRefNum(a0)		; fill in the volume ref
	clr.l		ioNamePtr(a0)					; no volume name
	lea.l		volParmBuf(a6), a1				; big enough for dumb _GetVolParms implementors	<20>
	move.l		a1, ioBuffer(a0)				; and fill it in
	move.l		#vMAttrib+4, ioReqCount(a0)		; and say much we want							<20>
	go_GetVolParms
	bne			@NoSupportExit					; punt on errors								<20>
	move.l		vMAttrib(a1), d0				; get the volume bits
	btst.l		#bHasDesktopMgr, d0				; desktop database support?
	beq			@NoSupportExit					; no? Then don't open

;
; See if the files exist already
;
	lea.l		dbName(a6), a1					; a1 = ptr(space for btree file name)
	move.w		userVRef(a6), d0				; d0 = volume to look for files for
	bsr			FindDTFiles						; go look for DT files (d1 = vol, d2 = dir, d3 = flg)
	bne			@OpenDTExit						; punt on serious errors
	move.b		d3, existsFlag(a6)				; do the files need to be created? (i.e. d3 = false)
	bne			@OpenFiles						; If they don't, go open them now
;
; The files didn't exist, but d1 has the vRef to create them on, d2 has the directory to
; create them in and a1 points to the name to create for the Btree file.
;
	lea.l		bigPB(a6), a0					; a0 = ptr(param block)
	moveq.l		#0, d0							; clear high bytes
	move.b		(a1), d0						; get length of btree file name
	move.b		#'F', (a1, d0.w)				; change name to datafile name
	move.l		a1, ioFileName(a0)				; use datafile name
	move.w		d1, ioVRefNum(a0)				; use volume from FindDTFiles
	move.l		d2, ioDirID(a0)					; use directory from FindDTFiles
	go_HCreate									; create the data file
	bne			@OpenDTExit						; punt on errors

	move.l		#DTDataFileType, d3				; set the data file type
	bsr			SetFileAttribs					; and the appropriate attrib bits
	bne			@DeleteDataExit

	moveq.l		#0, d0							; clear high bytes
	move.b		(a1), d0						; get length of data file name
	move.b		#'B', (a1, d0.w)				; change name to btree name
	go_HCreate									; create the file that will become the btree file
	bne			@DeleteDataExit					; errors? Delete data file and leave

	move.w		#DTMaxKeySize, ioBTMaxKLen(a0)	; set maximum key size
	clr.l		ioBTClumpSize(a0)				; use volume clump size
	pea.l		DTKeyDescriptor					; push pointer to our key descriptor
	move.l		(sp)+, ioBTKDPtr(a0)			; and tell the btree about it
	go_BTInit									; initialize btree file
	bne			@DeleteBothExit

	move.l		#DTBTFileType, d3				; set the btree file type
	bsr			SetFileAttribs					; and the appropriate attrib bits
	bne			@DeleteBothExit

;
; Try to open the files: allocate space in the system heap for a DTDBQElt and do the opens
;
@OpenFiles:
	move.l		#DTDBQElt.Size,d0				; Size of DT variable block
	_NewPtr 	sys, clear						; Try to allocate the space in the system heap
	bne			@OpenDTExit						; give up if there's no memory
	movea.l		a0, a3							; a3 = ptr(DTDBQElt)

@OpenBTFile:
	lea.l		bigPB(a6), a0					; a0 = ptr(param block)
	move.l		a1, ioFileName(a0)				; use btree name from FindDTFiles
	move.w		d1, ioVRefNum(a0)				; use vRef from FindDTFiles
	move.b		#fsRdWrPerm, ioPermssn(a0)		; grab write permission
	move.l		d2, ioDirID(a0)					; use DirID from FindDTFiles
	pea.l		DTKeyCmp						; use our own key comparison procedure
	move.l		(sp)+,ioBTKCProc(a0)
	go_BTOpen
	bne			@DeallocateExit					; if not, that's trouble						<20>
	move.w		ioRefNum(a0), DTDBQElt.DBRefNum(a3)		; save away the btree file refnum

	moveq.l		#0, d0							; clear high bytes
	move.b		(a1), d0						; get length of database name
	move.b		#'F', (a1, d0.w)				; change last character to an F
	move.b		#fsRdWrPerm, ioPermssn(a0)		; grab write permission
	clr.l		ioOwnBuf(a0)					; use volume buffer
	go_HOpen
	bne			@CloseBTExit					; punt on errors
	move.w		ioRefNum(a0), DTDBQElt.DFRefNum(a3)		; save away the data file refnum
;
; So far, so good.  Both files are open, and we've got a QElt ready.
; Fill in the rest of the info, enqueue it, get unmount notification, and we're done
;
	move.w	DTDBQElt.DBRefNum(a3), DTDBQElt.DTRefNum(a3)	; DTRefNum = ioRefNum of the btree file
	move.w	DTDBQElt.DBRefNum(a3), ioDTRefNum(a4)			; return DTRefNum to caller
	clr.b	DTDBQElt.Flags(a3)						; clear out our flags
	clr.b	DTDBQElt.Reserved(a3)					; clear out the reserved byte
	move.w	userVRef(a6), DTDBQElt.XVRefNum(a3)		; save user's target volume
	move.w	d1, DTDBQElt.VRefNum(a3)				; save the real volume where files are
	move.l	d2, DTDBQElt.ParID(a3)					; and the real directory
	move.l	#DTDataClump, DTDBQElt.DFClumpSize(a3)	; and an arbitrary clump
	clr.l	DTDBQElt.lastHint(a3)					; no btree hint yet

	move.l	FSVarsPtr, a1						; a1 = ptr(file system global area)
	move.l	FSVars.DTDBMgr(a1), a1				; a1 = ptr(DTDB manager's global area)
	lea.l	DTGlobals.qFlags(a1), a1			; a1 = ptr(DTQueue header)
	movea.l	a3, a0								; move DTDBQElt ptr into a0
	_Enqueue
	tst.w	d0									; enqueue is a toolbox trap
	beq.s	@SkyStillUp
	jmp		deepShitError						; if the sky falls, duck
@SkyStillUp:
;
; <21> If the files just got created, try to allocate a contiguous clump just for performance.
;
	tst.b		existsFlag(a6)					; are we brand new?
	bne.s		@alreadyExisted					; no, don’t allocate a clump
	lea.l		bigPB(a6), a0					; a0 = ptr(param block)						<22>
	move.l		DTDBQElt.DFClumpSize(a3), ioReqCount(a0)	; d1 = the data file's clump size
	go_Allocate 								; request the additional space
@alreadyExisted:
;
; <1.7> Install MultiFinder unmount notification
;
	move.l	FSVarsPtr, a1						; a1 = ptr(file system global area)
	move.l	FSVars.DTDBMgr(a1), a1				; a1 = ptr(DTDB manager's global area)
	bset.b	#notifyBit, DTGlobals.infoFlags(a1)	; do we already have notification installed?
	bne.s	@skipNotify							; yes? ->

	lea.l	-2(sp), sp							; leave space for OSErr output
	pea.l	DesktopNotifyProc					; the routine called at notification time
	move.l	#'KWAK', -(sp)						; we don't have a refCon
	bsr		myBeginSystemMode					; be the system
	_RequestVolumeNotification					; sign up for notify
	bsr		myEndSystemMode						; be the app
	move.w	(sp)+, d0							; did we succeed?
	beq.s	@ItWorked
	jmp		deepShitError						; if not, the sky is falling
@ItWorked:

@skipNotify:

@SuccessExit:									; all successful exits are through here		<20>
	moveq.l		#noErr, d0						; we succeeded
	tst.b		existsFlag(a6)					; return a result
	beq.s		@OpenDTExit
	moveq		#1,d1							; files existed, so we return a 1
	bra.s		@OpenDTExitResultInD1

; We failed while initializing the btree file, so delete both files before cruising
@DeleteBothExit:
	move.w		d0, ioResult(a4)				; save the error that got us here
	go_HDelete									; delete the btree file
	move.w		ioResult(a4), d0				; replace err w/real err that got us here

; We failed while creating the btree file, so delete the datafile before cruising
@DeleteDataExit:
	move.w		d0, ioResult(a4)				; save the error that got us here
	moveq.l		#0, d0							; clear high bytes
	move.b		(a1), d0						; get length of btree file name
	move.b		#'F', (a1, d0.w)				; change name to data file name
	move.l		a1, ioFileName(a0)				; use data file name
	go_HDelete									; delete the data file
	move.w		ioResult(a4), d0				; replace err w/real err that got us here
	bra.s		@OpenDTExit

; We failed on opening the datafile, so close the btree file before punting
@CloseBTExit:
	move.w		d0, ioResult(a4)				; save the error that got us here
	lea.l		bigPB(a6), a0					; a0 = ptr(param block)
	move.w		DTDBQElt.DBRefNum(a3), ioRefNum(a0)
	go_BTClose
	move.w		ioResult(a4), d0				; and make sure that it gets back to the user

; We allocated a DTDBQElt before failing, so deallocate it before punting
@DeallocateExit:
	movea.l		a3, a0							; get DTDBQElt ptr
	move.w		d0, -(sp)						; save failure-provoking result code
	_DisposPtr									; and free up DTDBQElt
	move.w		(sp)+, d0						; restore failure-provoking result code
	bra.s		@OpenDTExit						; and leave

@NoSupportExit:
	move.w		#wrgVolTypErr, d0				; indicate the boo-boo

@OpenDTExit:
	moveq.l		#0, d1							; clear high bytes
@OpenDTExitResultInD1:							; 											<20>
	adda.w		#LSize, a6						; deallocate locals
	movem.l		(a6)+, @OpenDTRegs
	move.l		(a6)+, -(sp)
	rts

	endwith
	_DTDebugTail		'OpenDT',0

	endproc

; ==========
; Routine:		SetFileAttribs (requires locals frame of RealOpenDT)
;
; Inputs:		a0 - pointer to PB w/vRef, ioNamePtr, and ioDirID set
;				a4 - pointer to OpenDT parameter block
;				a6 - pointer to RealOpenDT locals (uses userVRef) (does compensation for saved addr) 
;				d2 - dirID of file
;				d3 - file type (DTFL or BTFL)
;
; Outputs:		registers preserved
;				d0 - noErr or result code from call which failed
;
; Set the finder info (type in d3, creator DMGR)
; Set the attribute bits:
;	regular desktops: invisible
;	shadow desktops:  visible
; ==========

SetFileAttribs:	proc
	with		RealOpenDTLocals
	
	move.l		(sp)+,-(a6)						; we do I/O									<30>
	clr.w		ioFDirIndex(a0)					; no indexing; look by dirID and CName only
	go_HGetFileInfo								; fill the param block with cat info <21>
	bne			@errorExit
	move.l		d3, ioFlUsrWds+fdType(a0)		; set the file type
	move.l		#DTFileCreator, ioFlUsrWds+fdCreator(a0)		; set the file creator

	cmp.w		userVRef+4(a6), d1				; compare target volume to actual volume	<30>
	bne.s		@shadow							; if they're different, we're shadowing
	move.w		#fInvisible, d0					; bit pattern for invisible flag
	bra.s		@setAttributes

@shadow:
	moveq.l		#0,d0							; no special attributes

@setAttributes
	or.w		d0, ioFlUsrWds+fdFlags(a0)		; logical or into current attributes
	move.l		d2, ioDirID(a0)					; set correct directory (GetCatInfo blasts it)
	clr.w		ioFDirIndex(a0)					; no indexing; look by dirID and CName only
	go_HSetFileInfo								; set our new info <21>

@errorExit:
	move.l		(a6)+,-(sp)						; we did I/O								<30>
	tst.w		d0								; restore those cute cc's					<30>
	rts
	endproc
;________________________________________________________________________________
;
; Routine:		DTOpenInform
;
; Inputs:		a0 - pointer to caller's DT param block
;							uses only ioVRefNum
;
; Outputs:		d0 - result code
;
; Function: 	Same as DTGetPath, except returns a flag in ioTagInfo indicating
;				whether or not the files already existed.
;				True = already existed
;				False = were just created
;________________________________________________________________________________
DTOpenInform:		proc export
				jsrROM		ROMFSQUEUESYNC		; just to check for external file systems		ex<SM1><Sys7.1> Put back "ROM"
				bsr			DTVolExtFSCheck		; find the right volume and hope it's ours
				bsr			DeskMgrQueue
				bsr			RealOpenDT			; d1 true/false for dtExisted
				and.l		#1, d1				; return low bit only			<20>
				move.l		d1, ioTagInfo(a0)
				bra			DTDone
				_DTDebugRTS	'DTOpenInform', 0
				endproc

;________________________________________________________________________________
;
; Routine:		DTGetPath
;
; Inputs:		a0 - pointer to caller's DT param block
;							uses only ioVRefNum
;
; Outputs:		d0 - result code
;
; Function: 	Open an access path to the Desktop database.  If the database is already
;				open for the specified volume, return its refNum.
;________________________________________________________________________________
DTGetPath:		proc export
				jsrROM		ROMFSQUEUESYNC		; just to check for external file systems		ex<SM1><Sys7.1> Put back "ROM"
				bsr			DTVolExtFSCheck		; find the right volume and hope it's ours
				bsr			DeskMgrQueue
				bsr			RealOpenDT
				bra			DTDone
				_DTDebugRTS	'DTGetPath', 0
				endproc

;________________________________________________________________________________
;
; Routine:		DequeueDTDBQElt
;
; Inputs:		a0 - pointer to DTDBQElt to remove
; Outputs		none
;
; Function: 	Dequeue and deallocate a DTDBQElt.  No check of a0 is
;				done.  The block it points to must be both allocated
;				and in the queue.
; Called by:	CloseDT and VerifyOpenFiles
;________________________________________________________________________________
DequeueDTDBQElt:	proc
	move.l		a1, -(sp)
	move.l		FSVarsPtr, a1					; a1 = ptr(file system global area)
	move.l		FSVars.DTDBMgr(a1), a1			; a1 = ptr(DTDB manager's global area)
	lea.l		DTGlobals.qFlags(a1), a1		; a1 = ptr(DTQueue header)						<dnf 1.3>
	_Dequeue
	tst.w		d0								; 'cause _Dequeue doesn't test					<dnf 1.3>
	beq.s		@Ok
	jmp			deepShitError					; we're really up the creek if this fails
@Ok:
	_DisposPtr									; free it up the element
	movea.l		(sp)+, a1
	rts
	_DTDebugTail	'DequeueDTDBQElt', 0
	endproc

;________________________________________________________________________________
;
; Routine:		DTCloseDown
;
; Inputs:		a0 - pointer to caller's DT param block
;							uses only ioDTRefNum
;
; Outputs:		d0 - result code
;
; Function: 	Close the desktop database for a volume
;________________________________________________________________________________
DTCloseDown:		proc export

DTCloseDownLocals	record	0, increment
bigPB			ds.b		DTBigPBSize			; big enough to make any HFS or Btree call
LSize			equ			*-bigPB
				endr

@DTCloseDownRegs	reg			a0-a4/d1-d2
	jsrROM		ROMFSQUEUESYNC					; just to check for external file systems		ex<SM1><Sys7.1> Put back "ROM"
	bsr			DTRfnExtFSCheck					; find the right volume and hope it's ours
	bsr			DeskMgrQueue

	with		DTCloseDownLocals
	movem.l		@DTCloseDownRegs, -(a6)
	suba.w		#LSize, a6
	movea.l		a0, a4							; move user's DTParam to a safe register

	bsr 		DTSetup 						; Do common setup. a3 = ptr(DTDBQElt)
	bne.s		@DTCloseDownExit

	lea.l		bigPB(a6), a0					; a0 = ptr(param block)
	move.w		DTDBQElt.DBRefNum(a3), ioRefNum(a0)
	go_BTClose

	move.w		DTDBQElt.DFRefNum(a3), ioRefNum(a0)
	go_Close									; same goes for here

	movea.l		a3, a0							; move DTDBQElt to a0
	bsr			DequeueDTDBQElt					; dequeue and dispose of it

@DTCloseDownExit:
	adda.w		#LSize, a6						; deallocate locals
	movem.l		(a6)+, @DTCloseDownRegs
	bra			DTDone

	endwith
	_DTDebugRts		'DTCloseDown',0
	endproc

;________________________________________________________________________________
;
; Routine:		DTAddIcon
;
; Input:		a0 - user's DT param block
; Output:		d0 - result code
;
; Function: 	Add an icon bitmap to the Desktop database under its FileType/Creator
;________________________________________________________________________________
;
DTAddIcon:		proc export

	StandardLocals	AddIconLocals, IconDRec		; normal locals w/icon sized data rec

@AddIconRegs		reg		a0-a4/d1-d2	; set of regs to save around AddIcon
	jsrROM	ROMFSQUEUE					; just to check for external file systems				ex<SM1><Sys7.1> Put back "ROM"
	bsr		DTRfnExtFSCheck				; find the right volume and hope it's ours
	bsr 	DeskMgrQueue 				; Wait our turn.

	with	AddIconLocals				; Key and Data refer to locals
	movem.l	@AddIconRegs, -(a6)
	suba.w	#LSize, a6					; allocate locals on the a6 stack
	movea.l	a0, a4						; move user's DTParam to a safe register

	bsr 	DTSetup 					; Do common setup. a3 = ptr(DTDBQElt)
	bne		@AddIconExit				; and punt on errors

	move.l	ioReqCount(a0), d0			; d0 = user's icon data size
	cmp.l	#DTMaxIconSize, d0			; icon too big?
	ble.s	@SizeOK						; then keep going
	moveq	#paramErr, d0				; otherwise, complain
	bra		@AddIconExit				; and cruise

;
; First, search the btree to see if there's an icon with the same key already in the database
;
@SizeOK:
	bsr		SetUpBTPB					; standard BT param in a0 w/btree refNum
	move.l	#IconDRec.IRLen, ioReqCount(a0)	; indicate size of icon data record
	move.b	#IconKey.IKLen-1, (a2)+		; Set length of key (minus length byte)
	move.b	#IconKeyType,(a2)+			; ... and key type
	move.l	ioFlCreator(a4),(a2)+		; Set up CreatorType
	move.l	ioFlType(a4),(a2)+			; ... and FileType
	move.b	ioIconType(a4),(a2)+		; Pass in the requested icon Type
	clr.b	(a2)+						; clear the filler byte							<1.7>
	go_BTSearch
	bsr		DoneBTPB					; finished with BTPB <21>

	beq.s	@ChkSize 					; If no errors, check icon size
	cmp.w	#btRecNotFnd, d0			; Entry not found?
	beq.s	@AddNew 					; No problem - go create a brand new one
	bra 	@AddIconExit				; Other errors are more serious
;
; An entry for an icon of the same FlCreator/FlType/IconType already exists,
; make sure its the same size as the requested new one.
;
@ChkSize:
	lea.l 	Data(a6), a2				; a2 = ptr(B*-Tree Icon data record)
	move.w	IconDRec.IconSize(a2), d0	; Pick up current icon size
	cmp.w	ioReqCount+2(a4), d0 		; Same size as replacement?
	beq.s	@CanWrite					; Yes - go overwrite it
	move.w	#afpIconTypeError,d0
	bra		@AddIconExit				; otherwise, fail miserably

@CanWrite:
	move.l	IconDRec.IconPos(a2), d0	; Pick up old position
	bra.s	@AIWriteIcon				; And go overwrite the old icon bits

;
; We'll have to allocate space in the DF file for a new entry.  Just add to the end.
;
@AddNew:
	bsr		SetUpDFPB					; Get an ioParam on a0 w/data file refnum
	go_GetEOF 							; Find LEOF of the datafile
	bne.s	@AddIconExit				; Problems? See your registered pharmacist.
	move.l	ioLEOF(a0), d0 				; Pick up position to write icon at

;
; Arrive here from CanWrite or AddNew with d0 = position to write icon bits in Desktop DF:
; Write the icon into the data file, and if that succeeds, add the icon record to the Btree.
;
@AIWriteIcon:
	lea.l 	Data(a6), a2				; a2 = ptr(B*-Tree Icon data record)
	move.l	ioTagInfo(a4),IconDRec.TagInfo(a2)	; Copy tag information into data record
	move.l	d0,IconDRec.IconPos(a2)				; save file position in icon btree rec
	move.w	ioReqCount+2(a4),IconDRec.IconSize(a2) ; Copy size of icon

; a quick check to see if we need to extend the data file
	move.w	DTDBQElt.DFRefNum(a3), d1	; use the datafile's refNum
	move.l	FCBSPtr,a1					; a1 = ptr(FCB array)
	lea.l 	0(a1,d1.w),a1 				; a1 = ptr(datafile's FCB)
	move.l	d0,d2						; move icon's file position to d2 for some calculating
	add.l	ioReqCount(a4),d2			; d2 = file position + bitmap size
	cmp.l	fcbPLen(a1),d2				; Check against the current PEOF
	bls.s	@AIGoWrite					; If icon end < PEOF, start writing

; To minimize fragmentation, we extend the icon datafile by a bunch each time
	bsr		SetUpDFPB					; Get an ioParam on a0 w/data file refnum
	move.l	DTDBQElt.DFClumpSize(a3), ioReqCount(a0)	; d1 = the data file's clump size
	go_Allocate 						; Request the additional space

; The file's big enough, so write the icon data to the datafile
@AIGoWrite:
	bsr		SetUpDFPB					; Get an ioParam on a0 w/data file refnum
	move.l	ioBuffer(a4), ioBuffer(a0)			; data comes from user's pointer
	clr.l	ioReqCount(a0)						; size is just a word
	move.w	ioReqCount+2(a4), ioReqCount+2(a0)	; get size from user pb
	move.w	#fsFromStart, ioPosMode(a0)			; position is relative to byte 0
	move.l	IconDRec.IconPos(a2), ioPosOffset(a0)	; use the icon pos we've computed
	go_Write									; Fire off the write
	bne.s	@AddIconExit						; punt on errors

	; set the icon record in the Btree file
	bsr		SetUpBTPB							; standard BT param in a0 w/btree refNum
	move.l	#IconDRec.IRLen, ioReqCount(a0)		; tell the btree about the length
	go_BTSetRec									; the key is still cool from the search
	bsr		DoneBTPB							; finish up with the BTPB <21>

@AddIconExit:
	adda.w	#LSize, a6							; get rid of our locals
	movem.l	(a6)+, @AddIconRegs					; and restore our registers
	bra 	DTDone								; We're all set.

	endwith
	_DTDebugRts		'DTAddIcon',0
	endproc

;________________________________________________________________________________
;
; Routine:		DTGetIcon
;
; Input:		a0 - user's DT param block
; Output:		d0 - result code
;
; Function: 	Retrieve an icon from the Desktop database by Creator/Type
;________________________________________________________________________________
;
DTGetIcon:	proc export

	StandardLocals	GetIconLocals, IconDRec

@GetIconRegs		reg		a0-a4/d1-d2				; set of regs to save around AddIcon
	jsrROM	ROMFSQUEUE								; just to check for external file systems	ex<SM1><Sys7.1> Put back "ROM"
	bsr		DTRfnExtFSCheck							; find the right volume and hope it's ours
	bsr 	DeskMgrQueue 							; Wait our turn.

	with	GetIconLocals							; Key and Data refer to locals
	movem.l	@GetIconRegs, -(a6)
	suba.l	#LSize, a6								; allocate locals
	movea.l	a0, a4									; move user's DTParam to a safe register

	bsr 	DTSetup 								; Do common setup. a3 = ptr(DTDBQElt)
	bne.s	@GetIconExit							; punt on errors

; go look for the requested icon's entry in the btree
	bsr		SetUpBTPB								; a0 = ptr(BTioParam)
	move.l	#IconDRec.IRLen, ioReqCount(a0)			; indicate size of icon data record
	move.b	#IconKey.IKLen-1, (a2)+					; Stuff key length (minus length byte)
	move.b	#IconKeyType, (a2)+						; and the type
	move.l	ioFlCreator(a4), (a2)+					; creator from user's DTPB
	move.l	ioFlType(a4), (a2)+						; type from user's DTPB
	move.b	ioIconType(a4), (a2)+					; icon type from user's DTPB
	clr.b	(a2)+									; clear the filler byte 			<1.7>
	go_BTSearch
	bsr		DoneBTPB								; finish up with the BTPB <21>

	bne.s	@GetIconExit							; punt on errors

	move.l	IconDRec.TagInfo+Data(a6), ioTagInfo(a4)	; return tag information

;
; Read the icon from the data file
;
	bsr		SetUpDFPB								; Get an ioParam on a0 w/data file refnum
	move.l	ioBuffer(a4), ioBuffer(a0)				; data goes to the user's buffer
	moveq.l	#0, d0									; clear high word
	move.w	IconDRec.IconSize+Data(a6), d0			; d0 = size of icon data
	cmp.w	ioReqCount+2(a4), d0					; is the user's size big enough?
	bls.s	@sizeOk									; yes, read the whole icon
	move.w	ioReqCount+2(a4), d0					; otherwise clip to provided space
@sizeOk:
	move.l	d0, ioReqCount(a0)						; the correct length
	move.w	#fsFromStart, ioPosMode(a0)				; position from start of file
	move.l	IconDRec.IconPos+Data(a6), ioPosOffset(a0)	; get position from icon's btree rec
	go_Read 											; go get the icon data
	bne.s	@GetIconExit							; punt on errors

	move.l	ioActCount(a0),ioActCount(a4) 			; Return actual byte count

@GetIconExit
	adda.w	#LSize, a6								; deallocate locals
	movem.l	(a6)+, @GetIconRegs
	bra 	DTDone									; We're all set.

	endwith
	_DTDebugRts		'DTGetIcon',0
	endproc

;________________________________________________________________________________
;
; Routine:		DTGetIconInfo
;
; Input:		a0 - user's DT param block
; Output:		d0 - result code
;
; Function: 	Retrieve an icon from the Desktop database by Creator/Index
;________________________________________________________________________________
;
DTGetIconInfo:	proc export

	StandardLocals	GetIconInfoLocals, IconDRec

@GetIconInfoRegs		reg		a0-a4/d1-d2					; set of regs to save around this call
	jsrROM	ROMFSQUEUE					; just to check for external file systems				ex<SM1><Sys7.1> Put back "ROM"
	bsr		DTRfnExtFSCheck				; find the right volume and hope it's ours
	bsr 	DeskMgrQueue 				; Wait our turn

	with	GetIconInfoLocals			; Key and Data refer to locals
	movem.l	@GetIconInfoRegs, -(a6)
	suba.w	#LSize, a6
	movea.l	a0, a4						; move user's DTParam to a safe register

	bsr 	DTSetup 					; Do common setup. a3 = ptr(DTDBQElt)
	bne		@GetIconInfoExit2			; Punt on any error

; Do a search. We know we won't find anything, but the hint will put us just
; to the "left" of all of the icons with this icon creator
	bsr		SetUpBTPB					; a0 = ptr(BTioParam), a2 = ptr(key)
	move.l	#IconDRec.IRLen, ioReqCount(a0)	; we know how big the record is
	move.b	#05, (a2)+					; special short key  (•• magic constant)
	move.b	#IconKeyType, (a2)+			; standard icon type
	move.l	ioFlCreator(a4), (a2)+		; user's requested creator
	go_BTSearch
	cmp.w	#btRecNotFnd, d0 			; was the error a search miss?
	bne.s	@GetIconInfoExit			; otherwise, something's wrong

; With the ioBTHint set up, go get the indexed record
	move.w	ioIndex(a4), d0				; get the caller's index
	bne.s	@IndexOK					; did the user use a silly index, like zero?
	move.w	#btRecNotFnd, d0			; well, that one doesn't exist
	bra.s	@GetIconInfoExit			; so leave

@IndexOK:
	subq.w	#1, d0						; indicies start at 1, so adjust offset
	move.w	d0, ioBTPosMode(a0)			; record offset from current position
	move.w	#IconKey.IKLen, ioKReqCount(a0)	; we know how big the key is (including length byte here)
	go_BTGetRec
	bne.s	@GetIconInfoExit			; Bad day at the office? then leave.

	move.b	IconKey.Type+Key(a6), d0	; get the key id
	cmp.b	#IconKeyType, d0			; is it still an icon key?
	beq.s	@CheckCreator				; if so, go see if the creator is still the same
	move.w	#afpItemNotFound, d0		; otherwise, the index was too high
	bra.s	@GetIconInfoExit			; so return an error

@CheckCreator:
	move.l	IconKey.CrType+Key(a6), d0	; pick up the icon's creator type
	cmp.l	ioFlCreator(a4), d0			; check against user's requested type
	beq.s	@FoundGoodOne				; same = good
	move.w	#afpItemNotFound, d0		; otherwise, index was too high
	bra.s	@GetIconInfoExit			; so return an error

@FoundGoodOne:
	move.l	IconDRec.TagInfo+Data(a6), ioTagInfo(a4)	; return this icon's tag
	clr.l	ioActCount(a4)								; clear whole long
	move.w	IconDRec.IconSize+Data(a6), ioActCount+2(a4); and return word-sized icon size
	move.b	IconKey.IconType+Key(a6), ioIconType(a4)	; return this icon's iconType
	move.l	IconKey.FlType+Key(a6), ioFlType(a4)		; return this icon's fileType
	moveq.l	#0, d0						; All is well.

@GetIconInfoExit:
	bsr		DoneBTPB					; finish up with the BTPB <21>

@GetIconInfoExit2:
	adda.w	#LSize, a6									; deallocate locals
	movem.l	(a6)+, @GetIconInfoRegs
	bra 	DTDone										; We're all set.

	endwith
	_DTDebugRts		'DTGetIconInfo',0
	endproc

;________________________________________________________________________________
; The Application List
;
; Applications are stored in the app list by their creator and a synthetic 16-bit
; sequence number.  The seqnums exist to provide unique keys and ordering to each
; application with a given creator.
;
; The two app list routines which need to manipulate the list (add and delete)
; use a common iterator function that calls them once for each application in
; the list.  The iterator runs from higher seqnums to lower seqnums. (right to
; left).
;
; Apps are kept in the list so that the leftmost entry is always the youngest
; (as recorded by the creation date of the application file).
;________________________________________________________________________________

;________________________________________________________________________________
; Routine:		SetUpAPPLIterator
;
; Input:		a2 - standard locals (param block, key, data)
;				a3 - dtdbqelt pointer
;				d1 - creator type
;
; Output:		a0 - BT param block with valid hint, key and data sizes
;				d0 - result code from BTSearch (btRecNotFound error is suppressed)
;
; Function: 	Initialize a btree param block to point one to the right of
;				the "first" (i.e. rightmost) APPL entry of the given creator.
;				A btRecNotFound error is expected since we're using a short key,
;				so return noErr if we see it.  All other errors are passed through.
;
;________________________________________________________________________________
;
SetUpAPPLIterator:	proc

	move.l	(sp)+, -(a6)						; <18>

	with	APPLLocals							; Key and Data are application-sized
	move.l	a1, -(a6)

	lea.l	bigPB(a2), a0						; a0 = ptr(btree param block)
	bsr		GetHintFromDTDBQElt					; fetch the hints
	move.w	DTDBQElt.DBRefNum(a3), ioRefNum(a0)	; use the btree file's refnum
	lea.l	Data(a2), a1						; a1 = ptr(APPL record data block)
	move.l	a1, ioBuffer(a0)
	lea.l	Key(a2), a1							; a1 = ptr(APPL key block)
	move.l	a1, ioBTKeyPtr(a0)
	move.b	#5, (a1)+							; use short key so we'll be at the far left
	move.b	#APPLKeyType, (a1)+					; this is an APPL key
	move.l	d1, (a1)							; with the requested creator
	add.l	#1, (a1)+							; tweak the key up to the next higher creator
	move.l	#APPLRec.ARLen, ioReqCount(a0)		; set for later indexed BTGetRec calls
	move.w	#APPLKey.AKLen, ioKReqCount(a0)		; set for later indexed BTGetRec calls
	go_BTSearch									; go miss the target
	move.l	d1, APPLKey.SeqNum+Key(a2)			; restore correct creator type
	cmp.w	#btRecNotFnd, d0					; did we miss (as expected?)
	beq.s	@NoErrExit							; yes? Leave with a smile
	bra.s	@Exit								; otherwise pass the error through

@NoErrExit:
	moveq.l	#0, d0
@Exit:
	tst.w	d0
	move.l	(a6)+, a1
	move.l	(a6)+, -(sp)						; <18>
	rts
	endwith
	_DTDebugTail	'SetUpAPPLIterator',0
	endproc

;________________________________________________________________________________
; Routine:		APPLIterator
;
; Input:		a0 - BT param block with valid hint, key, and data pointers
;				a1 - callback procedure
;				a2 - standard locals (param block, key, data)
;				d1 - creator type
;
; Output:		a0 - BT param block with valid hint, key, and data pointers
;				a1 - callback procedure
;				a2 - standard locals (param block, key, data)
;				d0 - noErr if normal termination; terminating error code otherwise
;				d1 - creator type
;
; Function:		This iterator is used by the APPL calls (Add, Remove, and Get).
;				It iterates through all APPL records with a creator type that
;				matches the one in the user's param block.  For each record,
;				a callback procedure is called.  Iteration continues until either
;				no more APPL records with the right creator are available or
;				the callback procedure returns a zero in d0.
;
;				Registers a3-a5 and d2-d7 are passed directly to the callback
;				procedure; it is responsible for restoring all registers except d0.
;
;				Index through the records backwards (ffff through 0) to maintain
;				compatibility with AppleShare's desktop manager.
;________________________________________________________________________________
;
APPLIterator:		proc
	move.l	(sp)+, -(a6)						; <18>

	with	APPLLocals

	move.w	#-1, ioBTPosMode(a0)				; get records in descending key order

@Iterate:
	go_BTGetRec									; get the next record
	beq.s	@Examine							; if noErr, check for reasonableness
	cmp.w	#btBofErr, d0						; are we out of records?
	bra.s	@Exit								; else, a real error has ocurred

@Examine:
	move.b	APPLKey.Type+Key(a2), d0			; get this record's key type
	cmp.b	#APPLKeyType, d0					; is this an APPL key?
	bne.s	@NoErrExit							; if not, we're out of reasonable records

	move.l	APPLKey.CrType+Key(a2), d0			; get this record's creator
	cmp.l	d0, d1								; is this the right creator?
	bne.s	@NoErrExit							; if not, we're out of reasonable records

	jsr		(a1)								; give the caller a shot at it
	tst.w	d0									; are they all through?
	beq.s	@NoErrExit

	bra.s	@Iterate

@NoErrExit:
	moveq.l	#0, d0
@Exit:
	move.l	(a6)+, -(sp)						; <18>
	rts
	endwith
	_DTDebugTail	'APPLIterator',0
	endproc


;________________________________________________________________________________
; Routine:		APPLCompareNames
;
; Input:		a2 - standard APPL locals
;
; Output:		d0 - trashed
;				ccr state from _CmpString of names
;
; Function:
;	This routine compares the name from the current APPL rec (sitting in the
; APPL locals) to the name in the AppSpec (sitting in the APPL locals).
;
; You must have set up the AppSpec in APPLLocals before using this routine.
;________________________________________________________________________________
APPLCompareNames:	proc
	with	APPLLocals

@stash	reg		a0/a1

	movem.l	@stash, -(sp)						; save away for a sec
	moveq.l	#0, d0								; clear high bytes
	lea.l	AppSpec+FSSpec.name(a2), a0			; a0 = ptr(leaf name of app)
	move.b	(a0)+, d0							; d0 = length, a0 = ptr(1st char)
	swap	d0									; length of 1st string into high word
	lea.l	APPLRec.CName+Data(a2), a1			; a1 = ptr(CName of current entry)
	move.b	(a1)+, d0							; d0 = length, a1 = ptr(1st char)
	_FSCmpString								; are the names the same?
	movem.l	(sp)+, @stash
	rts

	endwith
	_DTDebugTail	'APPLCompareNames', 0
	endproc

;________________________________________________________________________________
; Routine:		AddAPPLCallback
;
; Input:		a0 - BT param block with valid hint, key, and data pointers
;				a1 - callback procedure
;				a2 - standard APPL locals
;				a3 - DTDBQElt pointer
;				a4 - user DT param block
;				d1 - creator type
;
; Output:		a0 - BT param block
;				a1 - callback procedure
;				a2 - standard locals (param block, key, data)
;				a3 - DTDBQElt pointer
;				a4 - user DT param block
;				d0 - zero to signal end of iteration; nonzero otherwise
;				d1 - creator type
;
; Function:
;	This routine will get called once per APPL entry with a creator matching the
;	one of the application being added to the list.
;	It does these things:
;		Look for a sequence number at which to add the new application.
;		Keep track of the creation date and sequence number of the last record it saw
;		Look for a duplicate entry, which means we don't need to insert anything.
;
;		If no free sequence number is found when scanning the list, index(a2) will
;		be one to the left of the last existing record - by definition a free
;		seqnum.
;________________________________________________________________________________
;
AddAPPLCallback:	proc

	with	APPLLocals

	bset.b	#applSawARecord, flags(a2)				; we've seen at least one record
	move.l	APPLRec.TagInfo+Data(a2), theDate(a2)	; record leftmost record's create date
	move.w	APPLKey.SeqNum+Key(a2), theSeqNum(a2)	; record leftmost record's sequence number

	move.l	APPLRec.parID+Data(a2), d0				; pick up the ParID
	cmp.l	AppSpec.parID(a2), d0					; entry in the same folder? <19>
	bne.s	@NotADuplicate

	bsr		APPLCompareNames						; are the names the same?
	bne.s	@NotADuplicate							; no ->

; The current application record has the same creator, parID and name as the app
; being added.

	move.l	APPLRec.TagInfo+Data(a2), d0			; get this application's creation date
	cmp.l	crDate(a2), d0							; check it against our prospective entry
	bne.s	@DifferentCreateDate					; handle same app/different date case

	bset.b	#applFoundADup, flags(a2)				; indicate our find
	moveq.l	#0, d0									; signal the end of this search
	bra.s	@Exit

; We've got most of a duplicate entry - everything except the create date matches.
; This really shouldn't happen, but if it does, simply return the seqnum of the
; current record as the place we should insert the new application.
@DifferentCreateDate:
	move.w	APPLKey.SeqNum+Key(a2), index(a2)		; use this seqnum
	bra.s	@FoundASeqNum

@NotADuplicate:
	btst.b	#applFoundASeqNum, APPLLocals.flags(a2)	; do we need to find a seqnum?
	bne.s	@KeepIterating
	move.w	APPLKey.SeqNum+Key(a2), d0				; get the current record's seqnum
	cmp.w	index(a2), d0							; collision?
	bne.s	@FoundASeqNum							; if not, we've found a good seqnum

	sub.w	#1, index(a2)							; subtract to get next prospective seqnum
	bra.s	@KeepIterating

@FoundASeqNum:
	bset.b	#applFoundASeqNum, flags(a2)			; indicate our find

@KeepIterating:
	moveq.l	#1, d0									; indicate that we should keep iterating
@Exit:
	rts

	endwith
	_DTDebugTail	'AddAPPLCallback',0
	endproc

;________________________________________________________________________________
; Routine:		DTAddAPPL
;
; Input:		a0 - user's DT param block
; Output:		d0 - result code
;
; Register Use:	a0 - bt param block
;				a1 -
;				a2 - locals
;				a3 - DTDBQElt
;				a4 - user's param block
;
; Function: 	Add an entry for an application into the application list
;
; Add the given application to the app list.  If this application is younger than
; all existing applications, make sure its sequence number is lowest.  If it's not
; the youngest, add the application at the highest available seqnum.
; If the application has the same name, directory and tag as an entry in the list,
; no action is necessary.  If the application has the same name and directory but a
; different tag, delete the existing entry and insert the application as if there
; had been no duplicate.
;________________________________________________________________________________
DTAddAPPL:		proc export

@AddAPPLRegs		reg		a0-a4/d1-d2			; set of regs to save around this call
	jsrROM	ROMFSQUEUE							; just to check for external file systems		ex<SM1><Sys7.1> Put back "ROM"
	bsr		DTRfnExtFSCheck						; find the right volume and hope it's ours
	bsr		DeskMgrQueue 						; Wait our turn

	with	APPLLocals							; Key and Data are APPL-sized
	movem.l	@AddAPPLRegs, -(a6)
	suba.w	#LSize, a6							; allocate locals
	movea.l	a6, a2								; setup a2 as locals ptr
	movea.l	a0, a4								; move user's DTParam to a safe register

	bsr 	DTSetup 							; Do common setup. a3 = ptr(DTDBQElt)
	bne		@Exit2								; Punt on any errors

	lea.l	bigPB(a2), a0						; a0 = ptr(param block)
	move.l	ioFileName(a4), ioFileName(a0)		; use user's application name
	move.w	DTDBQElt.XVRefNum(a3), ioVRefNum(a0); use correct volume ref
	clr.w	ioFDirIndex(a0)						; no indexing
	move.l	ioDirID(a4), ioDirID(a0)			; use user's DirID
	go_HGetFileInfo 							; Go get this app's creation date <21>
	bne		@Exit2								; run away on errors
	move.l	ioFlCrDat(a0), APPLLocals.crDate(a2)	; save the creation date

	move.l	ioDirID(a4), ioDirID(a0)			; reset dirID field (modified by GetCatInfo)
	lea.l	AppSpec(a2), a1						; address of our FSSpec record
	move.l	a1, ioFSSpecPtr(a0)					; tell the param block about it
	go_MakeFSSpec
	bne		@Exit2								; run away on errors

	move.w	#$ffff, index(a2)					; initial seqnum is ffff to maintain compatibility
	clr.b	flags(a2)							; clear all iterator signal flags

	move.l	ioFlCreator(a4), d1					; d1 = creator type for new APPL list entry
	bsr		SetUpAPPLIterator					; get ready to iterate through existing entries
	lea.l	AddAPPLCallback, a1					; a1 = ptr(AddAPPL's iterator callback)
	bsr		APPLIterator						; go look at each existing record

	move.w	index(a2), d1						; set up free seqnum

	btst.b	#applSawARecord, flags(a2)			; did we see at least one good record?
	beq.s	@Insert								; if not, insert the new sole record

@SawAnExistingRecord:
	btst.b	#applFoundADup, APPLLocals.flags(a2)	; did we find a duplicate?
	bne.s	@NoErrExit								; if so, take the easy way out

; We have a valid seqnum.  There's at least one other record with this creator,
; so make sure that the leftmost record has the newest creation date.
; There are four possibilities here, based on two facts:
;	The free seqnum is left or right of the leftmost existing record
;	The leftmost existing record is newer or older (by creation date) than the app being added
;
;                        free seqnum right of existing leftmost   free seqnum left of existing leftmost
; caller's app newer:            swap                                      insert at free seqnum
; caller's app older:            insert at free seqnum                     swap
;
; A swap puts the existing leftmost record into the free seqnum and the caller's
; app into the newly available seqnum where the leftmost app used to be. Note that
; this operation either ensures that the leftmost record stays that way (by moving it
; to a new, even lower seqnum) or that the new record becomes the leftmost (when the
; free seqnum was off to the right).
;
; This ensures that the leftmost record is always the one with the youngest app.

@HaveASeqNum:
	move.l	theDate(a2), d0						; d0 = creation date of leftmost existing record
	cmp.l	crDate(a2), d0						; compare that to the app's creation date
	bhi.s	@ExistingRecIsNewer

	move.w	theSeqNum(a2), d0					; d0 = seqnum of the leftmost existing record
	cmp.w	index(a2), d0						; compare that to this app's assigned seqnum
	blo.s	@DoASwap							; left seq < free seq, left rec older than caller's
	bra.s	@Insert								; left seq > free seq, left rec older than caller's

@ExistingRecIsNewer:
	move.w	theSeqNum(a2), d0					; d0 = seqnum of leftmost existing record
	cmp.w	index(a2), d0						; compare that to this app's assigned seqnum
	blo.s	@Insert								; left seq < free seq, left rec newer than caller's

; Move the existing leftmost record to the newly selected seqnum and the
; caller's app at the (freed up) seqnum of the existing leftmost
; record.  We know that the iterator left us one to the left of the leftmost
; record.

@DoASwap:
	move.l	ioFlCreator(a4), APPLKey.CrType+Key(a2)	; iterator always bumps into previous creator type
	move.w	theSeqNum(a2), APPLKey.SeqNum+Key(a2)	; we want the leftmost record
	go_BTSearch									; get the leftmost record
	move.w	index(a2), APPLKey.SeqNum+Key(a2)	; use the selected free seqnum
	go_BTSetRec									; move the leftmost record into the list at the free spot
	move.w	theSeqNum(a2), d1					; and add the new record at the leftmost position

; Add the caller's application at the sequence number in d1
@Insert:
	lea.l	APPLKey.Len+Key(a2), a1				; a1 = ptr(APPL key)
	move.b	#APPLKey.AKLen-1, (a1)+				; make a full length APPL key (-1 for length byte)
	move.b	#APPLKeyType, (a1)+					; make it an APPL key
	move.l	ioFlCreator(a4), (a1)+				; use the caller's creator
	move.w	d1, (a1)+							; use the seqnum in d1

	lea.l	APPLRec.TagInfo+Data(a2), a1		; a1 = ptr(APPL record)
	move.l	crDate(a2), (a1)+					; use this app's creation date
	move.l	AppSpec+FSSpec.parId(a2), (a1)+		; and parent ID
	lea.l	AppSpec+FSSpec.name(a2), a0			; a0 = ptr(CName of app)
	moveq.l	#0, d0								; clear high bytes
	move.b	(a0), d0							; name length into d0 (+1 for itself, -1 for dbra)
@loop:
	move.b	(a0)+, (a1)+
	dbra	d0, @loop

	lea.l	bigPB(a2), a0						; get our param block pointer back
	go_BTSetRec									; all fields are still valid
	bra.s	@Exit								; return the error straight back

@NoErrExit:
	moveq.l	#0, d0
@Exit:
	bsr		SaveHintInDTDBQElt					; save off the hint
@Exit2:
	add.w	#LSize, a6							; deallocate locals
	movem.l	(a6)+, @AddAPPLRegs
	bra 	DTDone								; We're all set.

	endwith
	_DTDebugRts		'DTAddAPPL',0
	endproc

;________________________________________________________________________________
; Routine:		RemoveAPPLCallback
;
; Input:		a0 - BT param block with valid hint, key, and data pointers
;				a1 - callback procedure
;				a2 - standard APPL locals
;				a3 - DTDBQElt pointer
;				d1 - creator type
;
; Output:		a0 - BT param block
;				a1 - callback procedure
;				a2 - standard locals (param block, key, data)
;				a3 - DTDBQElt pointer
;				d0 - zero to signal end of iteration; nonzero otherwise
;				d1 - creator type
;
; Function:
;	This routine will get called once per APPL entry with a creator matching the
;	one of the application being removed to the list.
;	It does these things:
;		Look for an entry whose name and dirID match the caller's pb
;		If there's a match, find out if it is the leftmost entry
;		Keep track of the youngest non-matching app seen, in case
;		the matching app was leftmost and the youngest one needs to
;		be found and made leftmost.
;
;________________________________________________________________________________
;
RemoveAPPLCallback:	proc

	with	APPLLocals

	add.w	#1, count(a2)							; tally this record
	btst.b	#applFoundAMatch, flags(a2)				; have we already seen a match?
	beq.s	@NoMatchYet								; if not, keep on looking

	bset.b	#applNotLeftmost, flags(a2)				; we've seen a match, and now another
													; record, which means that the match
													; wasn't the leftmost (youngest) entry,
													; so no rebalancing will be necessary.
	moveq.l	#0, d0									; Tell the iterator to chill out
	bra.s	@Exit									; And we're done iterating

@NoMatchYet:
	move.l	APPLRec.parID+Data(a2), d0				; pick up the ParID
	cmp.l	AppSpec.parID(a2), d0					; entry in the same folder? <19>
	bne.s	@NotAMatch

	bsr		APPLCompareNames						; are the names the same?
	bne.s	@NotAMatch								; no ->

; The current application record has the same creator, parID and name as the app
; being added.

	bset.b	#applFoundAMatch, flags(a2)				; remember that we've found it
	move.w	APPLKey.SeqNum+Key(a2), index(a2)		; remember its SeqNum
	bra.s	@KeepIterating							; and go look for a more-leftmost entry

; The current entry is a miss.  Check to see if it is the "newest" to date in the
; scan
@NotAMatch:
	move.l	theDate(a2), d0							; date of the current "youngest"
	cmp.l	APPLRec.TagInfo+Data(a2), d0			; is this record younger?
	bhi.s	@KeepIterating							; if not, just keep going

	move.w	APPLKey.SeqNum+Key(a2), theSeqNum(a2)	; remember this SeqNum
	move.l	APPLRec.TagInfo+Data(a2), theDate(a2)	; remember this date

@KeepIterating:
	moveq.l	#1, d0									; tell the iterator to keep at it
@Exit:
	rts

	endwith
	_DTDebugTail	'RemoveAPPLCallback',0
	endproc

;________________________________________________________________________________
; Routine:		DTRemoveAPPL
;
; Input:		a0 - user's DT param block
; Output:		d0 - result code
;
; Register Use:	a0 - bt param block
;				a1 -
;				a2 - locals
;				a3 - DTDBQElt
;				a4 - user's param block
;
; Function: 	Delete an entry for an application in the application list
;
; Remove the given application to the app list.  If this application is younger than
; all existing applications, make sure that after it is deleted the next-youngest
; app is promoted to the front of the list.
;________________________________________________________________________________
DTRemoveAPPL:		proc export
@RemoveAPPLRegs		reg			a0-a4/d1-d2

	jsrROM	ROMFSQUEUE							; just to check for external file systems		ex<SM1><Sys7.1> Put back "ROM"
	bsr		DTRfnExtFSCheck						; find the right volume and hope it's ours
	bsr		DeskMgrQueue						; wait our turn

	with	APPLLocals
	movem.l	@RemoveAPPLRegs, -(a6)
	suba.w	#LSize, a6						; allocate locals
	movea.l	a6, a2							; set up a2 as locals ptr
	movea.l	a0, a4							; move user's DTParam to a safe register

	bsr 	DTSetup 						; Do common setup. a3 = ptr(DTDBQElt)
	bne		@Exit2 							; Punt on any errors

	lea.l	bigPB(a2), a0						; a0 = ptr(param block)
	move.l	ioFileName(a4), ioFileName(a0)		; use user's application name
	move.w	DTDBQElt.XVRefNum(a3), ioVRefNum(a0); use correct volume ref
	move.l	ioDirID(a4), ioDirID(a0)			; use user's DirID
	lea.l	AppSpec(a2), a1						; address of our FSSpec record
	move.l	a1, ioFSSpecPtr(a0)					; tell the param block about it
	go_MakeFSSpec
	beq.s	@1									; no err? How pleasant.
	cmp.w	#fnfErr, d0							; app doesn't have to be here
	bne.s	@Exit2								; other errors spell trouble

@1:
	clr.b	flags(a2)						; clear all iterator signal flags
	clr.l	theDate(a2)						; oldest possible create date
	clr.w	theSeqNum(a2)					; indicate no younger APPL in the list
	clr.w	count(a2)						; we've seen no records

	move.l	ioFlCreator(a4), d1				; d1 = creator type for APPL entry to delete
	bsr		SetUpAPPLIterator				; get ready to look through existing entries
	lea.l	RemoveAPPLCallback, a1			; a1 = ptr(RemoveAPPL's iterator callback)
	bsr		APPLIterator					; go look at existing records

	btst.b	#applFoundAMatch, flags(a2)		; did we see a hit?
	beq.s	@NoMatchFound

	move.l	ioFlCreator(a4), APPLKey.CrType+Key(a2)	; put our creator back into key

; We saw a hit.  There are several things to consider, in this order
;	1) If there are only one or two records, we never need to re-balance
;	2) If the hit wasn't leftmost, we don't need to re-balance
;	3) If the hit was the leftmost record, we need to re-balance.

	cmp.w	#2, count(a2)					; did we see more than 2 records?
	bls.s	@DeleteMatch					; if not, just go delete the hit
	btst.b	#applNotLeftmost, flags(a2)		; was the hit leftmost?
	bne.s	@DeleteMatch					; if not, just go delete it

; We need to rebalance.  Since we know the seqnums of the youngest record
; and the seqnum of the leftmost record, we'll just get the youngest and
; set it into the leftmost position.
	move.w	theSeqNum(a2), APPLKey.SeqNum+Key(a2)	;
	go_BTSearch								; get the youngest
	bne.s	@Exit							; errors are trouble
	move.w	index(a2), APPLKey.SeqNum+Key(a2)	; leftmost SeqNum
	go_BTReplRec							; replace match with youngest
	bne.s	@Exit							; errors are trouble
	move.w	theSeqNum(a2), index(a2)		; aim our upcoming delete at
											; the old position of the youngest

@DeleteMatch:
	move.w	index(a2), APPLKey.SeqNum+Key(a2)
	go_BTDelRec								; delete the match (or the old
											; position of the youngest)
	bra.s	@Exit							; pass errors straight back

@NoMatchFound:
	move.l	#btRecNotFnd, d0				; tell'em about it and give up

@Exit:
	bsr		SaveHintInDTDBQElt				; save off the hint <21>
@Exit2:
	adda.w	#LSize, a6						; deallocate locals
	movem.l	(a6)+, @RemoveAPPLRegs			; restore registers
 	bra 	DTDone							; We're all set.

	endwith
	_DTDebugRts		'DTRemoveAPPL',0
	endp

;________________________________________________________________________________
;
; Routine:		DTGetAPPL
;
; Input: a0 points to user's DTParam
; Output: d0 contains result code
;
; Function: 	Retrieve an APPL entry from the Desktop database by Creator/index
;________________________________________________________________________________
DTGetAPPL:		proc export

	StandardLocals	GetAPPLLocals, APPLRec

@GetAPPLRegs		reg		a0-a4/d1-d2		; set of regs to save around GetAPPL
	jsrROM	ROMFSQUEUE						; just to check for external file systems			ex<SM1><Sys7.1> Put back "ROM"
	bsr		DTRfnExtFSCheck					; find the right volume and hope it's ours
	bsr 	DeskMgrQueue 					; Wait our turn

	with	GetAPPLLocals					; Key and Data refer to locals
	movem.l	@GetAPPLRegs, -(a6)
	suba.w	#LSize, a6						; allocate locals on a6
	movea.l	a0, a4							; move user's DTParam to a safe register

	bsr 	DTSetup 						; Do common setup. a3 = ptr(DTDBQElt)
	bne		@GetAPPLExit2 					; and run if we see trouble

	bsr		SetUpBTPB						; a0 = ptr(BTioParam), a2 = ptr(key)
	move.l	#APPLRec.ARLen, ioReqCount(a0)	; indicate size of an APPL data record
	move.b	#APPLKey.AKLen-1, (a2)+			; set APPL key length (minus length byte)
	move.b	#APPLKeyType, (a2)+				; and APPL type
	move.l	ioFlCreator(a4), (a2)+			; look for user's creator
	clr.l	(a2)+							; and a value "left" of all seqnums
	go_BTSearch
	cmp.w	#btRecNotFnd, d0				; was the error a simple not found?
	bne.s	@GetAPPLExit					; no, must be something more serious

	move.w	ioIndex(a4), d0					; get the user's requested index
	tst.w	d0								; is index 0?
	bne.s	@notSpecial						; if not, don't adjust
	moveq.l	#1, d0							; caller wants "best" app, which happens to be 1st one

@notSpecial:
	subq.w	#1, d0							; the user's index starts at 1
	move.w	d0, ioBTPosMode(a0)				; tell the btree the record offset
	move.w	#APPLKey.AKLen, ioKReqCount(a0)	; tell the btree how much space for key return
	go_BTGetRec
	bne.s	@GetAPPLExit 					; Punt on errors

	move.b	APPLKey.Type+Key(a6), d0		; pick up the key ID
	cmp.b	#APPLKeyType, d0				; is this record an APPL entry?
	beq.s	@FoundAPPL						; yes - check the creators					; <dnf 1.4>
	move.w	#btRecNotFnd, d0				; no - search failed
	bra.s	@GetAPPLExit 					; So punt

@FoundAPPL:									;											; <dnf 1.4>
	move.l	APPLKey.CrType+Key(a6), d0		; pick up this APPL entries' creator		; <dnf 1.4>
	cmp.l	ioFlCreator(a4), d0				; is it still the same as the caller's?		; <dnf 1.4>
	beq.s	@FoundOne						; yes - return information					; <dnf 1.4>
	move.w	#btRecNotFnd, d0				; no - search failed						; <dnf 1.4>
	bra.s	@GetAPPLExit					; So punt									; <dnf 1.4>

@FoundOne:
	move.l	APPLRec.TagInfo+Data(a6), ioTagInfo(a4)		; return tag information
	move.l	APPLRec.parID+Data(a6), ioFlParID(a4)		; return ParID
	tst.l	ioFileName(a4)					; did the user want the file name?
	beq.s	@NoCopy							; no - don't copy it over

	lea.l	APPLRec.CName+Data(a6), a0		; a0 = ptr(the Cname string)
	movea.l	ioFileName(a4), a1				; a1 = ptr(user's Cname string)
	moveq.l	#0, d0							; clear high bytes
	move.b	(a0), d0						; get length
	addq.b	#1, d0							; add one for the length byte
	_BlockMove								; copy the string over

@NoCopy:
	moveq.l	#0,d0							; All is well.

@GetAPPLExit:
	bsr		DoneBTPB						; finish up with the BTPB <21>

@GetAPPLExit2:
	adda.w	#LSize, a6						; deallocate locals
	movem.l	(a6)+, @GetAPPLRegs
	bra 	DTDone							; We're all set.

	endwith
	_DTDebugRts		'DTGetAPPL',0
	endp

;________________________________________________________________________________
;
; Routine:		DTSetComment
;
; Input: a0 points to user's DTParam
; Output: d0 contains result code
;
; Function: 	Add a comment for a file or folder to the Desktop database
;________________________________________________________________________________
DTSetComment:		proc export

	StandardLocals	SetCommentLocals, CommentRec

@SetCommentRegs		reg		a0-a4/d1-d2		; set of regs to save around SetComment
	jsrROM	ROMFSQUEUE						; just to check for external file systems			ex<SM1><Sys7.1> Put back "ROM"
	bsr		DTRfnExtFSCheck					; find the right volume and hope it's ours
	bsr	 	DeskMgrQueue 					; Wait our turn

	with	SetCommentLocals				; Key and Data refer to locals
	movem.l	@SetCommentRegs, -(a6)
	suba.w	#LSize, a6						; allocate locals on a6
	movea.l	a0, a4							; move user's DTParam to a safe register

	bsr 	DTSetup 						; Do common setup. a3 = ptr(DTDBQElt)
	bne.s	@AddCmtExit						; exit, stage left, if, like, errors are happenin

	bsr		CheckCSpec						; Make sure the file or directory exists
	bne.s	@AddCmtExit						; Punt on errors

;
; Build a Comment data record.  Notice that since we build the data record at Data(a6),
; SetUpBTPB will automatically point the BTParam at it.
;
	moveq.l	#0, d0							; clear high bytes (for _BlockMove)
	move.l	ioReqCount(a4), d0				; get comment text length
	cmp.l	#MaxCommentLen, d0				; is the comment too large?
	bls.s	@NoClip							; if not, no need to clip it
	move.l	#MaxCommentLen, d0				; clip length to max
@NoClip:
	move.b	d0, CommentRec.CmtSize+Data(a6)	; set the comment length
	move.l	ioBuffer(a4), a0				; get ready to copy the user's data
	lea.l	CommentRec.CmtData+Data(a6), a1	; into the Comment record
	_BlockMove								; copy that comment...

	bsr		SetUpBTPB						; a0 = ptr(BTioParam), a2 = ptr(key)
	moveq.l	#0, d0							; clear high bytes
	move.b	CommentRec.CmtSize+Data(a6), d0	; d0 = size of comment data
	addq.b	#1, d0							; add one for length byte
	move.l	d0, ioReqCount(a0)				; tell BTParam how big this comment record is
	move.b	#CommentKey.CKLen-1, (a2)+		; set key length (minus length byte)
	move.b	#CommentKeyType, (a2)+			; set key type
	move.l	d1, (a2)+						; d1 still has CNodeID from CheckCSpec
	go_BTSetRec
	bsr		DoneBTPB						; finish up with the BTPB <21>

@AddCmtExit:
	adda.w	#LSize, a6						; dispose of locals
	movem.l	(a6)+, @SetCommentRegs				; restore regs
	bra 	DTDone							; We're all set.

	endwith
	_DTDebugRts		'DTSetComment',0
	endproc

;________________________________________________________________________________
;
; Routine:		DTGetComment
;
; Input: a0 points to user's DTParam
; Output: d0 contains result code
;
; Function: 	Retrieve a comment for a file or folder from the Desktop database
;________________________________________________________________________________
DTGetComment:		proc export

	StandardLocals	GetCommentLocals, CommentRec

@GetCommentRegs		reg		a0-a4/d1-d2			; set of regs to save around GetComment
	jsrROM	ROMFSQUEUE						; just to check for external file systems			ex<SM1><Sys7.1> Put back "ROM"
	bsr		DTRfnExtFSCheck					; find the right volume and hope it's ours
	bsr 	DeskMgrQueue 					; Wait our turn

	with	GetCommentLocals					; Key and Data refer to locals
	movem.l	@GetCommentRegs, -(a6)
	suba.w	#LSize, a6						; allocate locals on a6
	movea.l	a0, a4							; move user's DTParam to a safe register

	bsr 	DTSetup 						; Do common setup. a3 = ptr(DTDBQElt)
	bne.s	@GetCommentExit					; Errors? Run and hide.

	clr.l	ioActCount(a4)					; in case we don't make it

	bsr 	CheckCSpec						; Look up the CNode's CNID
	bne.s	@GetCommentExit					; punt on errors

@GCGotCNID:
	bsr		SetUpBTPB						; a0 = ptr(BTioParam), a2 = ptr(key)
	move.l	#CommentRec.CRLen, ioReqCount(a0)	; indicate size of a comment record
	move.b	#CommentKey.CKLen-1, (a2)+		; set the key length (minus length byte)
	move.b	#CommentKeyType, (a2)+			; and the type
	move.l	d1, (a2)+						; d1 = CNodeID of requested file (from CheckCSpec)
	go_BTSearch								; go get that comment
	bsr		DoneBTPB						; finish up with the BTPB <21>
	bne.s	@GetCommentExit					; Yipes! an error!

	moveq.l	#0, d0							; clear high bytes
	move.b	CommentRec.CmtSize+Data(a6), d0	; d0 = length of comment data
	cmp.b	#MaxCommentLen, d0				; for some strange reason, is comment too big?
	bls.s	@sizeOK
	move.b	#MaxCommentLen, d0				; clip it.
@sizeOK:
	move.l	d0, ioActCount(a4)				; tell the user how much data there was
	lea.l	CommentRec.CmtData+Data(a6), a0	; copy starts from the Data
	move.l	ioBuffer(a4), a1				; a1 = address of user's buffer
	_BlockMove								; put the Comment Data in the user's buffer
	moveq.l	#0,d0							; All went well

@GetCommentExit:
	adda.w	#LSize, a6						; deallocate locals
	movem.l	(a6)+, @GetCommentRegs
	bra		DTDone							; We're all set.

	endwith
	_DTDebugRts		'DTGetComment',0
	endproc

;________________________________________________________________________________
;
; Routine:		DTRemoveComment
;
; Input: a0 points to user's DTParam
; Output: d0 contains result code
;
; Function: 	Remove a comment for a file or folder from the Desktop database
;________________________________________________________________________________
;
DTRemoveComment:		proc export

	StandardLocals	RemoveCommentLocals, 0		; we only need a pb and a key here. Zero Data

@RemoveCommentRegs		reg		a0-a4/d1-d2			; set of regs to save around RmvCmt
	jsrROM	ROMFSQUEUE						; just to check for external file systems			ex<SM1><Sys7.1> Put back "ROM"
	bsr		DTRfnExtFSCheck					; find the right volume and hope it's ours
	bsr 	DeskMgrQueue 					; Wait our turn

	with	RemoveCommentLocals				; Key and Data refer to locals
	movem.l	@RemoveCommentRegs, -(a6)		; save regs
	suba.l	#LSize, a6						; allocate and clear locals on a6
	movea.l	a0, a4							; move user's DTParam to a safe register

	bsr 	DTSetup 						; Do common setup. a3 = ptr(DTDBQElt)
	bne.s	@RmvCmtExit						; Zorro defects

	bsr		CheckCSpec						; does the file exist? (d1 = CNodeID)
	bne.s	@RmvCmtExit						; punt on errors

	bsr		SetUpBTPB						; a0 = ptr(BTparam), a2 = ptr(key)
	move.b	#CommentKey.CKLen-1, (a2)+		; set key length (minus length byte)
	move.b	#CommentKeyType, (a2)+			; it's a comment key
	move.l	d1, (a2)+						; d1 = CNodeID of file to delete comment for
	go_BTDelRec
	bsr		DoneBTPB						; finish up with the BTPB <21>

@RmvCmtExit:
	adda.w	#LSize, a6						; deallocate locals
	movem.l	(a6)+, @RemoveCommentRegs
	bra		DTDone							; We're all set.

	endwith
	_DTDebugRts		'RmvComment',0
	endp

;________________________________________________________________________________
;
; Routine:		DTFlush
;
; Input: a0 points to user's DTParam
; Output: d0 contains result code
;
; Function: 	Flush buffers associated with a database
;________________________________________________________________________________
DTFlush:		proc export

DTFlushLocals		record		0, increment
bigPB		ds.b		DTBigPBSize		; big enough for all HFS calls
LSize		equ			*-bigPB
			endr

@DTFlushRegs	reg		a0/a3-a4
	jsrROM		ROMFSQUEUE					; just to check for external file systems			ex<SM1><Sys7.1> Put back "ROM"
	bsr			DTRfnExtFSCheck				; find the right volume and hope it's ours
	bsr			DeskMgrQueue				; wait our turn

	with		DTFlushLocals
	movem.l		@DTFlushRegs, -(a6)			; save regs
	suba.w		#LSize, a6					; allocate locals on file system stack
	movea.l		a0, a4						; move user's DTParam to a safe register

	bsr			DTSetup						; Do common setup. a3 = ptr(DTDBQElt)
	bne.s		@DTFlushExit				; punt on errors

	lea.l		bigPB(a6), a0				; a0 = ptr(param block)
	move.w		DTDBQElt.DBRefNum(a3), ioRefNum(a0)	; use the btree file refnum
	go_BTFlush
	bne.s		@DTFlushExit				; punt on errors

	lea.l		bigPB(a6), a0				; a0 = ptr(param block)
	move.w		DTDBQElt.VRefNum(a3), ioVRefNum(a0)	; use the data file refnum
	clr.l		ioVNPtr(a0)					; no name needed <21>
	go_FlushVol								; flush a volume at a time <21>

@DTFlushExit:
	adda.w		#LSize, a6
	movem.l		(a6)+, @DTFlushRegs
	bra			DTDone

	endwith
	_DTDebugRts		'DTFlush',0
	endproc

;________________________________________________________________________________
;
; Routine:		DTReset
;
; Input: a0 points to user's DTParam
; Output: d0 contains result code
;
; Function: 	Reinitialize the btree files  (leaving them both open)
;	SetEOF on both to zero
;	Call BTInit on the BTree file
;________________________________________________________________________________
DTReset:		proc export

DTResetLocals		record		0, increment
bigPB		ds.b		DTBigPBSize		; big enough for all HFS calls
DBName		ds.b		32				; holds btree file name
DBParID		ds.l		1				; ParID of btree file
LSize		equ			*-bigPB
			endr

@DTResetRegs	reg		a0-a4/d1-d2
	jsrROM		ROMFSQUEUE					; just to check for external file systems			ex<SM1><Sys7.1> Put back "ROM"
	bsr			DTRfnExtFSCheck				; find the right volume and hope it's ours
	bsr			DeskMgrQueue				; wait our turn

	with		DTResetLocals
	movem.l		@DTResetRegs, -(a6)			; save regs
	suba.w		#LSize, a6					; allocate locals on file system stack
	movea.l		a0, a4						; move user's DTParam to a safe register

	bsr			DTSetup						; Do common setup.  a3 = ptr(DTDBQElt)
	bne			@DTResetExit				; and punt on errors

;
; Get the name and parent ID of the btree file
;
	lea.l		bigPB(a6), a0				; a0 = ptr(param block)
	lea.l		DBName(a6), a1				; a1 = ptr(space for btree file name)
	move.l		a1, ioFileName(a0)			; tell the param block about it
	clr.w		ioVRefNum(a0)				; look at all FCB's
	move.w		DTDBQElt.DBRefNum(a3), ioRefNum(a0)	; look for the btree file
	clr.l		ioFCBIndx(a0)				; and look only by ioRefNum
	go_GetFCBInfo
	bne			@DTResetExit
	move.l		ioFCBParID(a0), DBParID(a6)	; stash btree's parID

;
; Free up all of the space in both files
;
	lea.l		bigPB(a6), a0						; a0 = ptr(param block)
	move.w		DTDBQElt.DBRefNum(a3), ioRefNum(a0)	; zap the btree file
	clr.l		ioLEOF(a0)							; deallocate all space
	go_SetEOF
	bne			@DTResetExit						; errors are serious trouble here

	lea.l		bigPB(a6), a0						; a0 = ptr(param block)
	move.w		DTDBQElt.DFRefNum(a3), ioRefNum(a0)	; zap the data file
	clr.l		ioLEOF(a0)							; deallocate all space
	go_SetEOF
	bne			@DTResetExit						; errors are serious trouble here

;
; <21> To minimize fragmentation, we extend the icon datafile by a bunch each time
;
	move.l	DTDBQElt.DFClumpSize(a3), ioReqCount(a0)	; d1 = the data file's clump size
	go_Allocate 									; Request the additional space

;
; Close the btree file so we can BTInit it
;
	lea.l		bigPB(a6), a0						; a0 = ptr(param block)
	move.w		DTDBQElt.DBRefNum(a3), ioRefNum(a0)
	go_BTClose
	bne.s		@DTResetExit

;
; Now call BTInit on the btree file
;
	lea.l		bigPB(a6), a0						; a0 = ptr(param block)
	lea.l		DBName(a6), a1						; a1 = ptr(DB file name)
	move.l		a1, ioFileName(a0)					; use btree file name
	move.w		DTDBQElt.VRefNum(a3), ioVRefNum(a0)	; use the volume the file was on
	move.w		#DTMaxKeySize, ioBTMaxKLen(a0)		; set maximum key size
	clr.l		ioBTClumpSize(a0)					; use volume clump size
	move.l		DBParID(a6), ioDirID(a0)			; use DirID from when it was open
	pea.l		DTKeyDescriptor						; push pointer to our key descriptor
	move.l		(sp)+, ioBTKDPtr(a0)				; and tell the btree about it
	go_BTInit										; initialize btree file
	bne.s		@DTResetExit

;
; And then open it back up
;
	lea.l		bigPB(a6), a0						; a0 = ptr(param block)
	lea.l		DBName(a6), a1						; a1 = ptr(DB file name)
	move.l		a1, ioFileName(a0)					; use the name it had when it was open
	move.w		DTDBQElt.VRefNum(a3), ioVRefNum(a0)	; use vRef from when it was open
	move.b		#fsRdWrPerm, ioPermssn(a0)			; use exclusive read/write perm
	move.l		DBParID(a6), ioDirID(a0)			; use DirID from when it was open
	pea.l		DTKeyCmp							; use our own key comparison procedure
	move.l		(sp)+,ioBTKCProc(a0)
	go_BTOpen
	bne			@DTResetExit						; punt if there's trouble
	move.w		ioRefNum(a0), DTDBQElt.DBRefNum(a3)		; save away the btree file refnum

	moveq.l		#noErr, d0							; we made it.

@DTResetExit:
	adda.w		#LSize, a6
	movem.l		(a6)+, @DTResetRegs
	bra			DTDone

	endwith
	_DTDebugRts		'DTReset',0
	endproc

;________________________________________________________________________________
; Routine:		DTDelete
;
; Input: a0 points to param block with ioVRefNum
; Output: d0 contains result code
;
; Function: 	Delete all files that make up the desktop database
;				Note that DTReset only works if the desktop database can be
;				opened, while DTDelete takes a volume refnum
;________________________________________________________________________________
DTDelete:		proc export

DTDeleteLocals		record		0, increment
bigPB		ds.b		DTBigPBSize		; big enough for all HFS calls
DBName		ds.b		32				; holds btree file name
DBParID		ds.l		1				; ParID of btree file
LSize		equ			*-bigPB
			endr

@DTDeleteRegs	reg		a0-a4/d1-d2

	jsrROM		ROMFSQUEUE					; just to check for external file systems			ex<SM1><Sys7.1> Put back "ROM"
	bsr			DTVolExtFSCheck				; find the right volume and hope it's ours
	bsr			DeskMgrQueue				; wait our turn

	with		DTDeleteLocals
	movem.l		@DTDeleteRegs, -(a6)		; save regs
	suba.w		#LSize, a6					; allocate locals on file system stack
	movea.l		a0, a4						; move user's DTParam to a safe register

	move.l		FSVarsPtr, a3				; a3 = ptr(file system global area)
	move.l		FSVars.DTDBMgr(a3), a3		; a3 = ptr(DTDB manager's global area)
	move.w		DTGlobals.targetVRef(a3), d0	; get caller's target volume
	move.w		d0, d2						; save a copy

	bsr			FindDTVol					; is this volume's database already open?
	beq.s		@DatabaseOpenExit			; if so, we can't delete the files

	lea.l		DBName(a6), a1				; a1 = ptr(space for database file name)
	move.w		d2, d0						; d0 = vRef
	bsr			FindDTFiles					; go look for the database files
											; note that we don't bother to look for errors here

; delete the btree file

	lea.l		bigPB(a6), a0
	move.l		a1, ioNamePtr(a0)			; aim at the btree file
	move.w		d1, ioVRefNum(a0)			; on the right volume
	move.l		d2, ioDirID(a0)				; in the right directory
	go_HDelete								; ignore errors

	moveq.l		#0, d0						; clear high bytes
	move.b		(a1), d0					; get length of btree file name
	move.b		#'F', (a1, d0.w)			; change name to datafile name
	go_HDelete								; ignore errors

	moveq.l		#noErr, d0					; we always "succeed"
	bra.s		@DTDeleteExit

@DatabaseOpenExit:
	moveq.l		#fBsyErr, d0				; can't delete if the database is open

@DTDeleteExit:
	adda.w		#LSize, a6
	movem.l		(a6)+, @DTDeleteRegs
	bra			DTDone

	endwith
	_DTDebugRts		'DTDelete',0
	endproc

;________________________________________________________________________________
; Routine:		DTGetInfo
;
; Input: a0 points to user's DTParam
; Output: d0 contains result code
;
; Function: 	Returns informative and entertaining facts about today's desktop
;
; ioFlLgLen gets the sum of the logical lengths of the desktop files
; ioFlPyLen gets the sum of the physical lengths of the desktop files
; ioDTFlCnt gets the number of desktop files
; ioDirID gets the parent directory of the desktop files
;
; Even though neither file normally has a resource fork, we compute them
; in in case someone has added one.
;________________________________________________________________________________
DTGetInfo:		proc export

GetDTILocals		record		0, increment
bigPB		ds.b		DTBigPBSize		; big enough for all HFS calls
CName		ds.b		32				; space for a name
LSize		equ			*-bigPB
			endr

@DTGetInfoRegs	reg		a0-a4/d1-d2
	jsrROM		ROMFSQUEUE					; just to check for external file systems			ex<SM1><Sys7.1> Put back "ROM"
	bsr			DTRfnExtFSCheck				; find the right volume and hope it's ours
	bsr			DeskMgrQueue				; wait our turn

	with		GetDTILocals
	movem.l		@DTGetInfoRegs, -(a6)		; save regs
	suba.w		#LSize, a6					; allocate locals on file system stack
	movea.l		a0, a4						; move user's DTParam to a safe register

	bsr			DTSetup						; Do common setup.  a3 = ptr(DTDBQElt)
	bne.s		@DTGetInfoExit				; and punt on errors

	lea.l		bigPB(a6), a0				; a0 = ptr(param block)
	lea.l		CName(a6), a1				; space for a name
	move.l		a1, ioNamePtr(a0)			; tell 'em where to put the name
	clr.l		ioDTLgLen(a4)				; clear out so we can add						<29>
	clr.l		ioDTPyLen(a4)				; 												<29>

	move.w		DTDBQElt.DBRefNum(a3), ioRefNum(a0)	; use the btree file
	bsr.s		@AddFileSizes
	bne.s		@DTGetInfoExit
	move.w		DTDBQElt.DFRefNum(a3), ioRefNum(a0) ; use the data file
	bsr.s		@AddFileSizes
	bne.s		@DTGetInfoExit

	move.w		#2, ioDTFlCnt(a4)					; indicate # of desktop files
	move.w		DTDBQElt.VRefNum(a3), ioVRefNum(a4)	; indicate volume with files
	moveq.l		#0, d0						; we succeeded									<29>
@DTGetInfoExit:
	adda.w		#LSize, a6
	movem.l		(a6)+, @DTGetInfoRegs
	bra			DTDone

; assumes
;    a0 - param block with refnum and name pointer set up
;    a4 - user dt param block
;
@AddFileSizes:
	move.l		(sp)+, -(a6)				; <18>
	clr.l		ioFCBIndx(a0)				; return info by refnum only
	go_GetFCBInfo
	bne.s		@scram

	move.l		ioFCBParID(a0), ioDirID(a0)	; move for GetCatInfo call
	clr.w		ioFDirIndex(a0)				; by name & vref
	go_HGetFileInfo							; <21>
	bne.s		@scram

	move.l		ioDTLgLen(a4), d0			; get the current value							<29>
	add.l		ioFlLgLen(a0), d0			; add in data fork logical length
	add.l		ioFlRLgLen(a0), d0			; add in the resource fork logical length
	move.l		d0, ioDTLgLen(a4)			; stash it away									<29>

	move.l		ioDTPyLen(a4), d0			; get the current value							<29>
	add.l		ioFlPyLen(a0), d0			; add in data fork physical length
	add.l		ioFlRPyLen(a0), d0			; add in the resource fork physical length
	move.l		d0, ioDTPyLen(a4)			; stash it away									<29>
	moveq.l		#0,d0						; we succeeded									<29>
@scram:
	move.l		(a6)+, -(sp)				; <18>
	tst.w		d0							;												<29>
	rts										; rah

	endwith
	_DTDebugTail		'DTGetInfo',0
	endproc


;________________________________________________________________________________
;
; Routine:      DTKeyCmp
;
; Function:     Compare two Desktop B*-Tree keys.
;
; Input:        A0.L  -  search key pointer
;               A1.L  -  trial key pointer
;
; Output:       D0.W  -  result code
;                            +n  search key > trial key
;                             0  search key = trial key
;                            -n  search key < trial key
;
; NOTE: The keys in the Desktop B*-Tree are all either numeric or case-sensitive
;       strings, differentiated in the first position by the key type.  The key
;       type will ensure that keys are sorted by type first; beyond that, a
;       straight byte comparison may be used to properly differentiate the keys.
;________________________________________________________________________________
;
DTKeyCmp:   proc
			MOVEM.L A0-A1/D1,-(SP)      ; Save away scratch registers
;
; Figure the trial key length from the search key type; since all index
; keys are padded out to their full length, the trial key length is
; unreliable.  The search key length cannot be used because Getxxx routines
; pass shorter keys (Type & Creator only) meant to compare less than any
; key by that creator, but greater than preceding Creators.
;
			MOVE.B	(A0)+,D0					; Pick up length of search key
			MOVEQ	#IconKey.IKLen-1,D1			; Figure length of icon key
			CMP.B	#IconKeyType,(A0)			; Looking for an icon key?
			BEQ.S	@5							; Yes - we're in business
			MOVEQ	#APPLKey.AKLen-1,D1			; No - try an APPL key
			CMP.B	#APPLKeyType,(A0)			; Looking for an APPL key?
			BEQ.S	@5							; Yes - go with it
			MOVEQ	#CommentKey.CKLen-1,D1		; Finally, try a comment key
			CMP.B	#CommentKeyType,(A0)		; Looking at a comment?
			BEQ.S	@5							; Yes - finally right.
			MOVE.B	D0,D1						; No - just use the search key length
;
@5			TST.B   (A1)+						; Ignore length of trial key
@10			CMPM.B  (A1)+,(A0)+					; Compare byte in key
			BHI.S   DTKCIsGT					; search key > trial key
			BLO.S   DTKCIsLT					; search key < trial key
			SUBQ.B  #1,D1						; Count off one trial key character
			SUBQ.B  #1,D0						; Count off one search key character
			BEQ.S   @20							; If zero, stop comparison
			TST.B   D1							; Reached end of trial key?
			BNE.S   @10							; No - keep checking
			BRA.S   DTKCIsGT					; Yes - search key > trial key
@20			TST.B   D1							; Also reached end of trial key?
			BNE.S   DTKCIsLT					; No - search key < trial key
DTKCIsEQ	MOVEQ   #0,D0						; The two keys are equal
			BRA.S   DTKCExit					; So we're done
DTKCIsLT	MOVEQ   #-1,D0						; Search key < trial key
			BRA.S   DTKCExit
DTKCIsGT	MOVEQ   #1,D0						; Search key > trial key
DTKCExit	MOVEM.L (SP)+,A0-A1/D1				; Restore scratch registers [leaves CC alone]
			RTS									; And call it a day, leaving CC set from D0


;________________________________________________________________________________
;
; Routine:		deepShitError
;
; Input:
; Output:
;
; Function: 	Called when an error that shouldn't happen has, and the system
;				is in an inconsistent state.
;
;				Called when our request for unmount notification fails.
;				Called in an _enqueue fails in OpenDT
;				Called if a _dequeue fails in CloseDT
;________________________________________________________________________________

deepShitError	proc
	move.w		#HFSDSErr, d0
	_SysError								; bye-bye
	endproc

	end