;
;	Hacks to match MacOS (most recent first):
;
;	<Sys7.1>	  8/3/92	Reverted <SM1> by putting back the "ROM" prefixes.
;				  9/2/94	SuperMario ROM source dump (header preserved below)
;

;
;	File:		CatSearch.a
;
;	Contains:	High speed catalog search
;
;	Written by: Dave N. Feldman
;
;	Copyright:	© 1988-1992 by Apple Computer, Inc., all rights reserved.
;
;	Change History (most recent first):
;
;	   <SM1>	 4/15/92	kc		Removed the "ROM" prefix from the RomBind routines.
;									• Pre-SuperMario comments follow •
;		<19>	 9/13/91	JSM		Cleanup header.
;		<18>	 2/25/91	dnf		dho, #83584: Change the name of maskNotFileNames to
;									maskNotSearchInfo2, since that what it really does. Update the
;									comment in the #paramErr rules section to note the new bits
;									that count here.
;		<17>	 2/12/91	dnf		gbm, #breaksTheAUXExternalFileSystem: Make sure CatSearch
;									clears A3 (WDCB pointer) when exiting, since we never identify
;									working directories.
;		<16>	11/28/90	dnf		Put a comment in front of <14>
;		<15>	11/28/90	dnf		Put a comment in front of <14>
;		<14>	11/27/90	dnf		(with dba) Fix use of fsSBNegate when ioFlAttrib specifies only
;									files or directories.
;		<13>	 11/6/90	dnf		(with dba) Don't crush the timerInstalled flag. Make sure that
;									long string target names (>31 characters) don't get searched.
;		<12>	10/30/90	dnf		(with dba) Start the timer way early for more accurate timing.
;									Fix early error exit cases where a3 wasn't set up.
;		<11>	 8/28/90	dnf 	Rename ioSpecBits, ioSpec1 and ioSpec2 to ioSearchBits,
;									ioSearchInfo1 and ioSearchInfo2
;		<10>	 7/30/90	dnf 	Convert to linked patch; change rom reference names and use
;									jsrRom macro.
;		 <9>	  7/2/90	dnf 	Fix typo in branch from FlXFndrInfoIsDir case.
;		 <8>	  6/2/90	dnf 	Use proper offsets for both file and directory search cases on
;									finder info and dates
;		 <7>	 4/17/90	dnf 	Fix register trashing bug in StartTimer
;		 <6>	 3/16/90	dnf 	Return FSSpecs in ioMatchPtr instead of MBufEntries
;		 <5>	 2/26/90	dnf 	Change ioQuant from a catalog record count to an amount of time
;									to let the call run (and rename it ioSearchTime)
;		 <4>	  2/8/90	dnf 	Test d0 before exiting CheckCriteria
;		 <3>	  2/4/90	dnf 	Added negate bit; fixed ioFlAttrib bug; Changed to include
;									StandardEqu.d
;		 <2>	  1/9/90	dnf 	Add support for search on parent ID, implement CheckCSPB
;									routine.
;	   <1.5>	  9/7/89	dnf 	Added support for CatPosition
;	   <1.4>	 8/26/89	dnf 	Get minimum buffer off of stack
;	   <1.3>	 7/31/89	dnf 	Bug fixes, input from code review
;	   <1.2>	  7/6/89	dnf 	Added read buffer support and offline check
;	   <1.1>	  6/1/89	GGD 	Added include of HFS70Equ.a so that it would assemble.
;	   <1.0>	 5/30/89	dnf 	Integrate CatSearch, FileID's and Desktop Database Mgr into one
;									ptch
;				 1/23/89	dnf 	Modified for new param block and search criteria
;				12/20/88	dnf 	Broke off BTPScan into separate file
;				 11/2/88	dnf 	New Today.
;
;	External
;	 Routine:			CMCatSearch  -	Searches catalog for files according to search criteria
;
;	Internal			GetReadBuffer	- Allocates a read buffer
;	 Subroutines:		MbufInsert		- Inserts a match record into match buffer
;						UpperCaseIt 	- Convert a CName to its canonical form for comparison
;						CompareMasked	- Masked bitwise comparison of a range of bytes
;						CompareRange	- See if a value falls within a specified range
;						CheckCriteria	- Checks current CNode against all specified search criteria
;
;						TimerRoutine	- timer task completion routine
;						StartTimer		- installs a timer task
;						StopTimer		- removes a timer task
;


	print	push
	PRINT	OFF
	LOAD		'StandardEqu.d'
	INCLUDE 	'CatSrchPriv.a'
	INCLUDE 	'BTScanPriv.a'			; for the NoMoreReads bit
	include 	'LinkedPatchMacros.a'
	include		'FileMgrPrivate.a'
	PRINT	pop

	import		BTIPScan, BTEndPScan, BTGetPhys

;__________________________________________________________________________________
;
; Routine:		GetReadBuffer
;
; Function: 	Allocates a read buffer
;
; Input:		A3.L  -  CatSearch state record pointer
;				A5.L  -  user pb pointer
;
; Output:		A1.L  -  address of buffer
;				D3.L  -  length (in bytes) of buffer
;
; The deal - If the ioRBufPtr field in the param block points to a suitable buffer
; that buffer will be used in the call.  If not, CatSearch will get a small (512-byte or so)
; buffer off the A6 stack.	A buffer is suitable if it is bigger than the one CatSearch
; would get off the stack.
;__________________________________________________________________________________

GetReadBuffer:	proc
	import		bufAddr, bufLength
	MOVE.L		ioOptBuffer(A5), D3 	; get the user's buffer address             <1.2>
	BEQ.S		@getOurOwn				; nil? Use our own buffer then				<1.2>
	MOVE.L		ioOptBufSize(A5), D3	; get the user's buffer length              <1.2>
	CMP.L		#CSMinBufferSize, D3	; bigger than ours? 						<1.2>
	BLE.S		@getOurOwn				; if not, we'll use ours                    <1.2>

	; the user's buffer is cool; go ahead and use it                                <1.2>
	MOVE.L		ioOptBuffer(A5), A1 	; move buffer address to output register	<1.2>
	BRA.S		@GRBExit														;	<1.2>

	; the user's buffer is uncool.  Get our own off the A6 stack.                   <1.4>
@getOurOwn: 																	;	<1.2>
	MOVE.L		#CSMinBufferSize, D3	; length of read buffer 					<1.4>
	SUBA.L		D3, A6					; get memory off the stack					<1.4>
	MOVEA.L 	A6, A1					; address of read buffer					<1.4>
	BSET.B		#bufferOnStack, CSSR.flags(A3)	; remember so we can deallocate 	<1.4>
@GRBExit:
	RTS
	_CSDebug	'GetReadBuffer', 0
	endproc


;
; How the timer works here:
;
;	Before reading any data from the catalog, we start a timer running.
;	When the timer expires the timer completion routine will set the timerFired bit
;	in the CatSearch state record. This is passed along to the BTree scanner in the
;	"noMoreReads" bit, telling the scanner to continue to deliver records until it
;	needs to hit the disk again.
;
;	The effect is that CatSearch will process records until the timer goes off,
;	at which point it will finish the records it's got in memory and exit
;

;__________________________________________________________________________________
;
; Routine:		TimerRoutine
;
; Function: 	Gets run when the timer goes off
;				Sets the "noMoreReads" bit in the PScan flags
;
; Input:		A1		- csTimeTask record (a.k.a CatSearch state record pointer)
;
; Output:		A1		- trashed
;
; Note that since csTimeTask is first in the CSSR, a1 can be used like a pointer
; to the CSSR.
;__________________________________________________________________________________

TimerRoutine:	proc
	bset.b		#timerFired, CSSR.flags(a1) 		; boom!					<12>
	rts
	endproc

;__________________________________________________________________________________
;
; Routine:		StartTimer
;
; Function: 	Checks to see if we need to run a timer during this search
;				If so, starts the timer
;
; Input:		A3.L  -  CatSearch state record pointer
;				D0.L  -  Time count (time manager form) or zero for no timer
;
; Output:		A3.L  -  CatSearch state record pointer
;
; If the time count is zero, no timer task is started.	If a timer task is started
; the "timerWasInstalled" bit is set in CSSR.flags.
;__________________________________________________________________________________

StartTimerRegs	reg 		d0-d1/a0-a1

StartTimer: 	proc
	tst.l		d0						; do we need to start a timer?
	beq.s		@StartTimerExit 		; if count = 0, no.

	movem.l 	StartTimerRegs, -(sp)
	move.l		d0, d1					; save time value around _InsTime
	bset.b		#timerWasInstalled, CSSR.flags(a3)	; note that we're doing this
	move.l		a3, a0					; a0 = ptr (our time task record)
	lea.l		TimerRoutine, a1		; a1 = ptr(our timer completion routine)
	move.l		a1, tmAddr(a0)			; point to our completion routine
	_InsTime							; put our task in the queue
	move.l		d1, d0					; restore time value
	_PrimeTime							; start the timer ticking
	movem.l 	(sp)+, StartTimerRegs

@StartTimerExit:
	rts
	endproc

;__________________________________________________________________________________
;
; Routine:		StopTimer
;
; Function: 	Checks to see if we installed a time manager task
;				If so, removes it.
;
; Input:		A3.L  -  CatSearch state record pointer
;
; Output:		A3.L  -  CatSearch state record pointer
;
;__________________________________________________________________________________

StopTimerRegs	reg 	d0/a0
StopTimer:		proc

	btst.b		#timerWasInstalled, CSSR.flags(a3)	; did we use a timer this search?
	beq.s		@noTimerUsed

	movem.l 	StopTimerRegs, -(sp)
	move.l		a3, a0					; a0 = ptr (our time task record)
	_RmvTime							; remove the task from the queue
	movem.l 	(sp)+, StopTimerRegs

@noTimerUsed:
	rts
	endproc

;__________________________________________________________________________________
;
; Routine:		MBufInsert
;
; Function: 	Convert the current record into an FSSpec and insert it
;				into the Match Buffer
;				Increments nextMBuf pointer in CSSR
;
; Input:		A0.L  -  ptr(catalog key)
;				A3.L  -  ptr(CatSearch state record)
;
; Output:
;				A0.L  -  trash
;				A1.L  -  trash
;				D0.L  -  trash
;__________________________________________________________________________________
MBufInsert: 	proc
	MOVE.L		CSSR.PSRPtr(A3), A1 		; A1 = ptr(Pscan state record)
	MOVE.L		PSR.fcbptr(A1), A1			; A1 = ptr(fcb of btree file we're scanning)
	MOVE.L		fcbVPtr(A1), A1 			; A1 = ptr(vcb of search volume)
	MOVE.W		vcbVRefNum(A1), D0			; D0 = vRefNum of search volume
	MOVE.L		CSSR.nextMBuf(A3), A1		; A1 = ptr(next empty MBuf entry)
	MOVE.W		D0, (A1)+					; copy vRefNum into FSSpec
	MOVE.L		ckrParID(A0), (A1)+ 		; copy ParID from key
	MOVEQ.L 	#0, D0						; clear D0 to clear high bytes
	LEA.L		ckrCName(A0), A0			; A0 = ptr(str31 containing CName)
	MOVE.B		(A0), D0					; get length of CName
	; don't add one for the length byte 'cause we're DBRAing                        <1.3>
@MoveCName:
	MOVE.B		(A0)+, (A1)+				; move the CName, byte by byte
	DBRA		D0, @MoveCName				; (this is still faster than _BlockMove)
	MOVE.L		CSSR.nextMBuf(A3), A1		; A1 = ptr(just filled MBuf entry)
	ADDA.W		#FSSpec.size, A1			; A1 = ptr(MBuf entry after the one we just filled)
	MOVE.L		A1, CSSR.nextMBuf(A3)		; remember position for next time
	RTS
	_CSDebug	'MBufInsert', 0

;	_AssumeEQ	ckrParID+4, ckrCName		; put this in. ••
	endproc

;__________________________________________________________________________________
;
; UpperCaseIt
;
; Function: 	Convert the current cName (from the key to its catalog record)
;				into a canonical form for comparison.  Store the result in the CatSearch
;				state record. Zero flag up if current cName has length of zero.
;
; Register
; Usage:		A0.L  -  ptr(key)
;				A3.L  -  ptr(CatSearch state record)
;				A4.L, A5.L - scratch
;
;				D5.L  - ioSearchBits
;
; Output:		zero flag high if current cName is empty
;				D0.L - D4.L  are trashed
;__________________________________________________________________________________
UpperCaseIt:	proc
	MOVE.L		A0, D2					; save address regs into trashable D regs
	MOVE.L		A4, D3
	MOVE.L		A5, D4
	MOVEQ.L 	#0, D0					; clear D0 to clear byte 1 (for DBRA)
	MOVE.B		ckrCName(A0), D0		; D0.W = len(current cName)
	BEQ.S		@failUCI				; null cNames fail
	MOVE.W		D0, D1					; keep another copy in D1

	; Don't add one for the length byte, 'cause we're DBRAing
	LEA.L		ckrCName(A0), A4		; A4 = ptr(current cName)
	LEA.L		CSSR.copyCur(A3), A5	; A5 = ptr(copy of current cName)
@block
	MOVE.B		(A4)+, (A5)+			; move a byte
	DBRA		D0, @block				; until we're done

	MOVE.W		D1, D0					; D0.W = len(copy of current cName)
	LEA.L		CSSR.copyCur+1(A3), A0	; A0 = ptr(1st char of copy of cName)
	_FSUprString						; uppercase, strip diacriticals
	MOVEQ.L 	#1, D0					; just something to clear the zero flag

	; Zero flag is cool regardless of how we got here
@failUCI
	MOVEA.L 	D2, A0					; restore A regs from D regs
	MOVEA.L 	D3, A4
	MOVEA.L 	D4, A5
	RTS
	_CSDebug	'UpperCaseIt', 0
	endproc

;__________________________________________________________________________________
;
; CompareMasked
;
; Function: 	Do a bitwise comparison with mask.	The source and data are exclusive-or'ed
;				together, yielding 1's where they differ.  That value is and'ed with the
;				comparison mask, leaving a word with 1's where there are significant
;				mismatches.  This technique allows the caller to set target bits only where
;				the mask bits are 1, and leaving the rest undefined. If all long words
;				pass, then the zero flag is set on return.
;
; Register
; Usage:		A0.L  -  ptr(source data)  (what you're checking out)
;				A4.L  -  ptr(target data)  (what you're looking for)
;				A5.L  -  ptr(comparison mask) (what bits you care about)
;
;				D0.W  -  comparison count - 1 (note: we step by longwords)
;				D1.L  -  trashed
;				D2.L  -  trashed
;
; Output:		zero flag high if hit
;
; Note: This routine steps on the register usage of CheckCriteria by using A0 as an input.
;__________________________________________________________________________________
CompareMasked:	proc
	MOVE.L		(A0)+, D1				; D1 = long word of source data
	MOVE.L		(A4)+, D2				; D2 = long of target data
	EOR.L		D2, D1					; D1 bits are on where source and data differ
	AND.L		(A5)+, D1				; D1 bits are on where we cared about mismatches
	DBNE		D0, CompareMasked		; keep going as long as the bytes match
	RTS
	_CSDebug	'CompareMasked', 0
	endproc

;__________________________________________________________________________________
;
; CompareRange
;
; Function: 	Compare to see if  ioSearchInfo1[D1].L <= D0.L <= ioSearchInfo2[D1].L
;				Return carry clear if yes, carry set if not.
;
; Register
; Usage:		A0.L  -  ptr(ioSearchInfo1)  (low end of range)
;				A2.L  -  ptr(ioSearchInfo2)  (high end of range)
;
;				D0.L  -  current value
;				D1.W  -  offset in CInfoPBRec to use for value
;
; Output:		zero flag high if D0 is in range, low if not
;
;__________________________________________________________________________________

CompareRange:	proc
	CMP.L		(A0, D1.W), D0			; is D0 >= low end of range?
	BLO.S		@failRange				; if (D0 < value in ioSearchInfo1), fail
	CMP.L		(A2, D1.W), D0			; is D0 <= high end of range?
	BLS.S		@succeedRange			; if (D0 <= value in ioSearchInfo2), succeed
@failRange:
	MOVEQ.L 	#1, D0					; clear the zero flag
	RTS
@succeedRange:
	MOVEQ.L 	#0, D0					; set the zero flag
	RTS
	_CSDebug	'CompareRange', 0
	endproc

;__________________________________________________________________________________
;
; Routine:		CheckCriteria
;
; Function: 	Checks current record against match criteria.
;				Partial and full name matches are the optimized cases
;
; Input:		A0.L  -  ptr(key)
;				A1.L  -  ptr(data record)
;				A3.L  -  ptr(CatSearch state record)
;				A5.L  -  ptr(user parameter block)
;				D5.L  -  ioSearchBits
;
; Output:		A0.L				- ptr(key)
;				A1.L, A2.L			- trash
;				A3.L, A4.L, A5.L	- preserved
;				D0, D1, D2, D3, D4	- trash
;				D5, D6, D7			- preserved
;				zero flag set if match, clear otherwise
;__________________________________________________________________________________
CheckCriteria:	proc
	MOVE.L		A0, -(A6)
	
	CMP.B		#cmFilCN, cdrType(A1)		; is this a file record?					<14>
	BEQ.S		@IsFile						;											<14>
	CMP.B		#cmDirCN, cdrType(A1)		; is this a directory record?				<14>
	BNE			@notSearchable				; we only consider files and directories	<14>
	BCLR.B		#isFile, CSSR.flags(A3)		; indicate that current record is a dir		<14>
	BTST.B		#inclDirs, CSSR.flags(A3)	; do criteria include directories?			<14>
	BEQ			@failed						; if not, we're done already				<14>
	BRA.S		@LookAtIt					; if so, continue with criteria				<14>
	
@IsFile:
	BSET.B		#isFile, CSSR.flags(A3) 	; indicate that current record is a file
	BTST.B		#inclFiles, CSSR.flags(A3)	; do criteria include files?
	BEQ			@failed						; if not, we're done already

@LookAtIt:
	BTST.L		#fsSBPartialName, D5		; is name substring included?
	BEQ.S		@FullName					; go check the next thing (Exact cName match)

	; This is the 'name substring' match
	BSR 		UpperCaseIt 				; make an uppercase copy of the current cName
	BEQ 		@failed 					; zero flag indicates current cName is empty

	;	Register use during substring compare
	;	A0 - ptr(current cName) 			D1 - starting point limit in current cName
	;	A1 - ptr(substring) 				D2 - length of substring
	;	A2 - scratch for DBRA				D3 - next starting point in current cName
	;	A3 - scratch for DBRA				D4 - scratch for DBNE

	MOVEM.L 	A0/A1/A3, -(A6) 		; save regs around string compare loop
	LEA.L		CSSR.copyCur(A3), A0	; A0 = ptr(current cName)
	LEA.L		CSSR.copyTarg(A3), A1	; A1 = ptr(target substring)
	MOVE.B		(A0), D1				; D1 = len(current cName)
	MOVEQ.L 	#0, D2					; make D2 clean for DBRA
	MOVE.B		(A1)+, D2				; D2 = len(target substring) (A1 = ptr(1st char))
	SUB.B		D2, D1					; D1 = -1 + last possible starting point for a match
	BMI.S		@failPartial			; if that's < 0, we couldn't possibly match

	SUBQ.L		#1, D2					; adjust D2 for DBRA
	ADDQ.B		#1, D1					; D1 = last possible starting point for a match
	MOVEQ.L 	#1, D3					; initialize "next starting point" value (past length byte)

@outer:
	LEA.L		(A0, D3), A2			; A2 = ptr(place to look for match)
	MOVEA.L 	A1, A3					; A3 = ptr(1st char in substring)
	MOVE.W		D2, D4					; D4 counts the DBRA
@loop:
	CMPM.B		(A2)+, (A3)+			; compare char by char
	DBNE		D4, @loop				; and keep going as long as they're the same
	BEQ.S		@hitPartial 			; all the way without a miss = a hit

@again:
	ADDQ.B		#1, D3					; up the starting point
	CMP.B		D1, D3					; is starting point beyond last possible start?
	BLS.S		@outer					; as long as it's not, check another starting point

	; if we fell through to here, we missed on all starting points
@failPartial
	MOVEM.L 	(A6)+, A0/A1/A3 		; restore regs saved around substring compare
	BRA 		@failed

@hitPartial
	MOVEM.L 	(A6)+, A0/A1/A3 		; restore regs saved around substring compare
	MOVEQ.L 	#maskPartialName, D0	; D0 = ioSearchBits long w/fsSBPartialName set
	CMP.L		D0, D5					; was PartialName the only criteria?
	BEQ 		@hit					; then leave now

@FullName:								; This is the 'full cName' match
	BTST.L		#fsSBFullName, D5		; is full name included?
	BEQ.S		@FlParID				; go check the next thing (file parent)

	BSR 		UpperCaseIt 			; make an uppercase copy of the current cName
	MOVE.L		A4, D1					; save A4 around string compare
	LEA.L		CSSR.copyCur(A3), A2	; A2 = ptr(current cName)
	LEA.L		CSSR.copyTarg(A3), A4	; A4 = ptr(target string)
	MOVE.B		(A2), D0				; D0 = length of current CName (+ length byte for DBRA)
@FullNameLoop:
	CMPM.B		(A2)+, (A4)+			; compare a byte
	DBNE		D0, @FullNameLoop
	BNE.S		@failedFull 			; did we end on a missed character?

	; If we fell through to here, we hit
	MOVEA.L 	D1, A4					; restore reg saved around string compare
	MOVEQ.L 	#maskFullName, D0		; D0 = ioSearchBits long w/fsSBFullName set
	CMP.L		D0, D5					; was Fullname the only criteria?
	BEQ 		@hit					; then leave now
	BRA.S		@FlParID				; or else keep going with the next criteria

@failedFull:
	MOVEA.L 	D1, A4					; restore reg saved around string compare
	BRA 		@failed

@FlParID:								; This is the parent ID check
	MOVE.L		ckrParID(A0), D0		; D0 = parent ID of current cNode (grabbed before we change A0)

	; from here down,
	;	 A0 - points to ioSearchInfo1
	;	 A2 - points to ioSearchInfo2
	MOVEA.L 	ioSearchInfo1(A5), A0		; A0 = ptr(CInfoPBRec with values & low end of ranges)
	MOVEA.L 	ioSearchInfo2(A5), A2		; A2 = ptr(CInfoPBRec with masks & high end of ranges)

	BTST.L		#fsSBFlParID, D5		; is parent ID included?
	BEQ.S		@FlAttrib				; go check the next thing (file attributes)
	MOVEQ.L 	#ioFlParID, D1			; D1 = offset into CInfoPBRec to parent ID
	BSR 		CompareRange
	BNE 		@failed

@FlAttrib:								; This is the file attributes check
	BTST.L		#fsSBFlAttrib, D5		; are file attributes included?
	BEQ.S		@DrNmFls				; go check the next thing (files/directory)
	MOVE.B		filFlags(A1), D0		; D0 = file flags (bit 0 = locked is the only one)
	MOVE.B		ioFlAttrib(A0), D1		; D1 = user's target for file attrib bits
	EOR.B		D1, D0					; D0 bits on where source and target differ
	AND.B		CSSR.attribMask(A3), D0 ; D0 bits on where we cared about mismatches
	BNE 		@failed

@DrNmFls:
	BTST.L		#fsSBDrNmFls, D5		; is # files per directory included?
	BEQ.S		@FlFndrInfo 			; go check the next thing (finder info)
	MOVE.W		dirVal(A1), D0			; D0 = # files in current directory
	CMP.W		ioDrNmFls(A0), D0		; is D0 >= low end of range?
	BCS 		@failed 				; if (D0 < # files in this directory), fail
	CMP.W		ioDrNmFls(A2), D0		; is D0 <= high end of range?
	BLS.S		@FlFndrInfo 			; if (D0 <= # files), continue with next criteria
	BRA 		@failed 				; D0 too high; fail

@FlFndrInfo:
	BTST.L		#fsSBFlFndrInfo, D5 	; is finder info included?
	BEQ.S		@FlXFndrInfo			; go check the next thing (extra finder info)
	MOVEM.L 	A0/A4/A5, -(A6) 		; save A0/A4/A5 around test
	MOVEQ.L 	#(FlFndrInfoLen/4-1), D0; D0 = DBRA count for # of finder info bytes
	LEA.L		ioFlUsrWds(A0), A4		; A4 = ptr(target user words)
	LEA.L		ioFlUsrWds(A2), A5		; A5 = ptr(mask for user words)
	BTST.B		#isFile, CSSR.flags(A3) ; are we looking at a file record?
	BEQ.S		@FlFndrInfoIsDir		; if not, go get the right offset for a directory
	LEA.L		filUsrWds(A1), A0		; A0 = ptr(source data)
	BRA.S		@1
@FlFndrInfoIsDir:
	LEA.L		dirUsrInfo(A1), A0		; A0 = ptr(source data)
@1:
	BSR 		CompareMasked			; see if they match
	MOVEM.L 	(A6)+, A0/A4/A5 		; restore A0/A4/A5
	BNE 		@failed

@FlXFndrInfo:
	BTST.L		#fsSBFlXFndrInfo, D5	; is extra finder info included?
	BEQ.S		@FlLgLen				; go check the next thing (file logical length)
	MOVEM.L 	A0/A4/A5, -(A6) 		; save A0/A4/A5 around test
	MOVEQ.L 	#(FlXFndrInfoLen/4-1), D0; D0 = DBRA count for # of Xfinder info bytes
	LEA.L		ioFlxFndrInfo(A0), A4	; A4 = ptr(target Xfinder info)
	LEA.L		ioFlxFndrInfo(A2), A5	; A5 = ptr(mask Xfinder words)
	BTST.B		#isFile, CSSR.flags(A3) ; are we looking at a file record?
	BEQ.S		@FlXFndrInfoIsDir		; if not, go get the right offset for a directory
	LEA.L		filFndrInfo(A1), A0 	; A0 = ptr(source data)
	BRA.S		@2
@FlXFndrInfoIsDir:
	LEA.L		dirFndrInfo(A1), A0 	; A0 = ptr(source data)
@2:
	BSR 		CompareMasked			; see if they match
	MOVEM.L 	(A6)+, A0/A4/A5 		; restore A0/A4/A5
	BNE 		@failed

@FlLgLen:
	BTST.L		#fsSBFlLgLen, D5		; is logical length included?
	BEQ.S		@FlPyLen				; go check the next thing (physical length)
	MOVE.L		filLgLen(A1), D0		; D0 = logical length of current file
	MOVEQ.L 	#ioFlLgLen, D1			; D1 = offset into CInfoPBRec to find logical length
	BSR 		CompareRange
	BNE 		@failed

@FlPyLen:
	BTST.L		#fsSBFlPyLen, D5		; is physical length included?
	BEQ.S		@FlRLgLen				; go check the next thing (resource logical length)
	MOVE.L		filPyLen(A1), D0		; D0 = physical length of current file
	MOVEQ.L 	#ioFlPyLen, D1			; D1 = offset into CInfoPBRec to find physical length
	BSR 		CompareRange
	BNE 		@failed

@FlRLgLen:
	BTST.L		#fsSBFlRLgLen, D5		; is resource logical length included?
	BEQ.S		@FlRPyLen				; go check the next thing (resource physical length)
	MOVE.L		filRLgLen(A1), D0		; D0 = resource logical length of current file
	MOVEQ.L 	#ioFlRLgLen, D1 		; D1 = offset into CInfoPBRec to find resource logical length
	BSR 		CompareRange
	BNE.S		@failed

@FlRPyLen:
	BTST.L		#fsSBFlRPyLen, D5		; is resource physical length included?
	BEQ.S		@FlCrDat				; go check the next thing (file create date)
	MOVE.L		filRPyLen(A1), D0		; D0 = resource physical length of current file
	MOVEQ.L 	#ioFlRPyLen, D1 		; D1 = offset into CInfoPBRec to find resource physical length
	BSR 		CompareRange
	BNE.S		@failed

@FlCrDat:
	BTST.L		#fsSBFlCrDat, D5		; is creation date included?
	BEQ.S		@FlMdDat				; go check the next thing (file modification date)
	BTST.B		#isFile, CSSR.flags(A3) ; are we looking at a file record?
	BEQ.S		@FlCrDatIsDir			; if not, go get the right offset for a directory
	MOVE.L		filCrDat(A1), D0		; D0 = creation date of current cNode
	BRA.S		@3
@FlCrDatIsDir:
	MOVE.L		dirCrDat(A1), D0		; D0 = creation date of current cNode
@3:
	MOVEQ.L 	#ioFlCrDat, D1			; D1 = offset into CInfoPBRec to find creation date
	BSR 		CompareRange
	BNE.S		@failed

@FlMdDat:
	BTST.L		#fsSBFlMdDat, D5		; is modification date included?
	BEQ.S		@FlBkDat				; go check the next thing (file backup date)
	BTST.B		#isFile, CSSR.flags(A3) ; are we looking at a file record?
	BEQ.S		@FlMdDatIsDir			; if not, go get the right offset for a directory
	MOVE.L		filMdDat(A1), D0		; D0 = modification date of current cNode
	BRA.S		@4
@FlMdDatIsDir:
	MOVE.L		dirMdDat(A1), D0		; D0 = modification date of the current cNode
@4:
	MOVEQ.L 	#ioFlMdDat, D1			; D1 = offset into CInfoPBRec to find modification date
	BSR 		CompareRange
	BNE.S		@failed

@FlBkDat:
	BTST.L		#fsSBFlBkDat, D5		; is backup date included?
	BEQ.S		@hit					; that's the last one, so we hit
	BTST.B		#isFile, CSSR.flags(A3) ; are we looking at a file record?
	BEQ.S		@FlBkDatIsDir			; if not, go get the right offset for a directory
	MOVE.L		filBkDat(A1), D0		; D0 = backup date of current cNode
	BRA.S		@5
@FlBkDatIsDir:
	MOVE.L		dirBkDat(A1), D0		; D0 = backup date of current cNode
@5:
	MOVEQ.L 	#ioFlBkDat, D1			; D1 = offset into CInfoPBRec to find backup date
	BSR 		CompareRange
	BEQ.S		@hit

@failed:
	MOVEQ.L 	#1, D0					; indicate failure
	BRA.S		@CheckNegate
@hit:
	MOVEQ.L 	#0, D0					; indicate success

@checkNegate:
	btst.l		#fsSBNegate, d5 		; do we want everything that doesn't match?
	beq.s		@CompareExit			; no; the result stands

	eor.b		#1, d0					; reverse the outcome
	bra.s		@compareExit

@notSearchable: 						; not a file or directory record
	moveq.l 	#1, d0					; indicate failure

@CompareExit:
	tst.w		d0						; set Z to indicate success
	MOVEA.L 	(A6)+, A0
	RTS
	_CSDebug	'CheckCriteria', 0
	endproc

;__________________________________________________________________________________
;
; Routine:		VerifyCSPB
;
; Function: 	Verify that a param block contains legal values
;
; Input:		A0.L  -  parameter block pointer
;
; Register Usage (during call):
;	A0.L  -  pointer to user's param block              D0.L - scratch
;	A1.L  -  pointer to ioSearchInfo1							D1.L - scratch
;														D2.B - copy of user's ioFlAttrib mask
;														D3.L - cssr.flags byte
;	A4.L  -  pointer to ioSearchInfo2
;	A5.L  -  pointer to user's param block              D5.L - ioSearchBits
;
; Output:
;	d0.W  -  result code (noErr, paramErr)
;	d2.b  -  copy of user's ioFlAttrib mask, ioDirFlg masked
;	d3.b  -  cssr.flags with inclFiles, inclDirs and inclNames set correctly
;
;__________________________________________________________________________________
VerifyCSPBRegs	reg 		A1/A4-A5/D1/D5
VerifyCSPB: 	proc		export

	movem.l 	VerifyCSPBRegs, -(sp)
	MOVE.L		a0, a5						; a5 = ptr(user's pb)

	; look for conditions that return paramErr
	TST.L		ioMatchPtr(A5)			; Nil mBuf? 							(P1)
	BEQ 		@ParamErrExit				; is a param err
	TST.L		ioSearchInfo1(A5)				; Nil ioSearchInfo1?							(P2)
	BEQ 		@ParamErrExit				; is a param err
	MOVE.L		ioSearchBits(A5), D5		; D5 = spec mask
	MOVE.L		D5, D1						; D1 = scratch copy of spec mask
	ANDI.L		#maskNotSearchInfo2, D1		; any criteria that requires ioSearchInfo2?	(P3)
	BEQ.S		@checkNamesIncluded 		; if not, we don't worry about ioSearchInfo2
	TST.L		ioSearchInfo2(A5)				; Nil ioSearchInfo2?
	BEQ 		@ParamErrExit				; is a param err

@checkNamesIncluded:
; If the search includes names, make a note of it and check to make sure that the name
; is non-nil and non-zero length.
	clr.b		d3							; d3 will become cssr.flags byte
	BTST.L		#fsSBPartialName, D5		; does search includes partial name?
	BNE.S		@cNameCheck 				; then go check it
	BTST.L		#fsSBFullName, D5			; does search includes full name?
	BEQ.S		@checkSpecBits				; no? then don't need to copy name

@cNameCheck:								; make sure name is not nil or zero length
	MOVEA.L 	ioSearchInfo1(A5), A1			; A1 = ptr(ioSearchInfo1)
	MOVEA.L 	ioFileName(A1), A1			; A1 = ptr(ioName)
	MOVE.L		A1, D2						; nil ioNamePtr?						(P4)
	BEQ 		@ParamErrExit				; is a param err
	MOVEQ.L 	#0, D0						; clear D0 to clear high bytes
	MOVE.B		(A1), D0					; D0 = len(target cName)
	BEQ 		@ParamErrExit				; zero length target name is a param err(P5)
	BSET.L		#inclNames, d3				; note that the search includes names

@checkSpecBits:
	MOVEA.L 	ioSearchInfo1(A5), A1			; A1 = ptr(ioSearchInfo1)
	MOVEA.L 	ioSearchInfo2(A5), A4			; A4 = ptr(ioSearchInfo2)
	BTST.L		#fsSBFlAttrib, D5			; are file attributes included in the search?
	BEQ.S		@includeBoth				; if not, search is on both files and directories

	move.b		ioFlAttrib(a4), d2			; d2.b = user's attribute mask
	MOVE.B		#maskBadAttribs, D0 		; D0 = illegal attribute bits on		(P6)
	AND.B		ioFlAttrib(A4), D0			; are there any illegal attribute bits included?
	BNE 		@ParamErrExit				; then it's a param err
	BTST.L		#ioDirFlg, d2				; is the mask bit for directories on?
	BEQ.S		@includeBoth				; no, which means to include both
	BTST.B		#ioDirFlg, ioFlAttrib(A1)	; what's the desired value for the directory bit?
	BEQ.S		@justFiles					; caller wants it off, i.e. just files
	BSET.L		#inclDirs, d3				; caller wants it on, i.e. just directories
	BRA.S		@clearMaskBit				; we're done deciding about files vs. directories

@includeBoth:
	BSET.L		#inclDirs, d3				; the search includes directories
@justFiles:
	BSET.L		#inclFiles, d3				; the search includes files

@clearMaskBit
	BCLR.L		#ioDirFlg, d2				; clear the dir bit; it isn't actually on disk

@P7:										;										(P7)
	BTST.L		#inclDirs, d3				; are directories included in the search?
	BEQ.S		@P8 						; if not, don't worry about rule 7
	BTST.L		#fsSBFlAttrib, D5			; does the search include file attributes?
	BEQ.S		@P8 						; if not, don't worry about rule 7
	BTST.B		#ioLockFlg, ioFlAttrib(A4)	; did caller care about the locked bit?
	BNE.S		@ParamErrExit				; locked attribute is meaningless on a directory

@P8:										;										(P8)
	BTST.L		#fsSBDrNmFls, D5			; is #files per directory included?
	BEQ.S		@P9 						; then can't conflict with files
	BTST.L		#inclFiles, d3				; does the search include files?
	BNE.S		@ParamErrExit				; then that's a param error

@P9:										;										(P9-P12)
	BTST.L		#inclDirs, d3				; are directories included in the search?
	BEQ.S		@OKExit 					; if not, don't worry about rules 9-12
	MOVE.L		D5, D0						; make a copy of ioSearchBits
	ANDI.L		#maskLengthBits, D0 		; kill all but the bits specifying some sort of length
	BNE.S		@ParamErrExit				; any length spec is meaningless in a directory

@OKExit:
	moveq.l 	#noErr, d0
	bra.s		@Exit

@ParamErrExit:
	move.w		#paramErr, d0

@Exit:
	movem.l 	(sp)+, VerifyCSPBRegs
	rts

	endproc

; Here are the parameter checking rules for PBCatSearch:						<1.3>
; The labels at the left also appear in the code which checks that rule.

; You get a paramErr if
; P1	ioMBufPtr is nil
; P2	ioSearchInfo1 is nil
; P3	(ioSearchBits includes not(fsSBPartialName or fsSBFullName or fsSBNegate)) and ioSearchInfo2 is nil;
;		i.e. A selected search bit requires the presence of ioSearchInfo2
;
; Then these,
; ioSearchBits rules: You get a paramErr if
; P4	fsSBPartialName
;		and (ioSearchInfo1->ioNamePtr = (nil or empty string))
; P5	fsSBFullName (same as above)
; P6	fsSBFlAttrib and some bit other than 0 (locked) or 4 (directory) returns paramErr
; P7	search includes directories and
;		(ioSearchBits includes fsSBFlAttrib) and (ioSearchInfo2^.ioFlAttrib bit 0 = 1)
;		return paramErr
;		(i.e. "locked directory" makes no sense)
; P8	fsSBDrNmFls and files returns paramErr
; P9	fsSBFlLgLen and directories returns paramErr
; P10	fsSBFlPyLen (same as above)
; P11	fsSBFlRLgLen (same as above)
; P12	fsSBFlRPyLen (same as above)
;
; A search includes (files only) if
;	ioSearchBits includes fsSBFlAttrib
;			- and -
;	ioSearchInfo1^.ioFlAttrib bit 4 = 0 		i.e. explicitly looking for non-directories
;			- and -
;	ioSearchInfo2^.ioFlAttrib bit 4 = 1
;
; A search includes (directories only) if
;	ioSearchBits includes fsSBFlAttrib
;			- and -
;	ioSearchInfo1^.ioFlAttrib bit 4 = 1 		i.e. explicitly looking for directories
;			- and -
;	ioSearchInfo2^.ioFlAttrib bit 4 = 1

; A search includes both if
;	ioSearchBits includes fsSBFlAttrib
;			- and -
;	ioSearchInfo2^.ioFlAttrib bit 4 = 0 		i.e. don't care about the directory bit
;
;			- OR -
;	ioSearchBits doesn't include fsSBFlAttrib   i.e. don't care about attributes at all


;__________________________________________________________________________________
;
; Routine:		CheckCSPB
;
; Function: 	Check that a param block contains legal values
;				This is a wrapper of VerifyCSPB that is set up as an
;				unqueued a060 call.  Its main purpose in life is to let
;				external file systems get a quick parameter block check
;				on a CatSearch call.
;
;				(Unqueued a060 call means that this is pretty much a register-based
;				 OS trap. )
;
; Input:		A0.L  -  parameter block pointer
;
; Output:		D0.W  -  noErr or paramErr
;__________________________________________________________________________________
CheckCSPBRegs	reg 	d2/d3			; the output registers from VerifyCSPB
CheckCSPB		proc	export

	movem.l 	CheckCSPBRegs, -(sp)
	bsr 		VerifyCSPB
	movem.l 	(sp)+, CheckCSPBRegs
	rts
	endproc

;__________________________________________________________________________________
;
; Routine:		CMCatSearch
;
; Function: 	Locates files by search criteria
;
; Input:		A0.L  -  parameter block pointer
;
; Register Usage (during call):
;	A0.L  -  scratch									D0.L - scratch
;	A1.L  -  scratch									D1.L - scratch
;	A2.L  -  scratch									D2.L - scratch
;	A3.L  -  pointer to CatSearch State Record (CSSR)	D3.L - scratch
;	A4.L  -  pointer to PScan State Record (PSR)		D4.L - scratch
;	A5.L  -  pointer to user's param block              D5.L - ioSearchBits
;	A6.L  -  standard file system stack
;														D7.L - ioActMatchCount
;
; Output:		D0.W  -  result code (noErr, extFSErr, ioErr, nsvErr, catChanged, paramErr)
;	A0.L, A1.L - trash
;	D0.L, D1.L, D2.L - trash
;__________________________________________________________________________________
CMCatSearch:	proc	export

	jsrRom		ROMFSQUEUE					; queue up the request						ex<SM1><Sys7.1> Put back "ROM"
	SUBA.W		#CSSR.size, A6				; allocate a CSSR on A6 					moved here <1.3>
	CLR.B		CSSR.flags(A6)				; clear the flags							moved here <1.3>
	MOVEA.L 	A6, A3						; move CSSR ptr to a safe register				<12>
	MOVEA.L 	A0, A5						; move userPB ptr to a safe register			<12>

	move.l		ioSearchTime(a5), d0		; get max search time (time mgr count)			<12>
	bsr 		StartTimer					; start a timer, if needed, right away			<12>

	jsrRom		ROMDTRMV3					; find vol using ioNamePtr & ioVRefNum (D023/A234 trashed)	ex<SM1><Sys7.1> Put back "ROM"
	MOVEA.L 	A6, A3						; reload pointer to CSSR (doesn’t hurt CCs)		<12>
	BNE 		@Exit						; (DtrmV3 puts VCBPtr in A2)
	MOVE.W		vcbSigWord(A2), D0			; Check out the volume signature
	CMP.W		#SigWord, D0				; Is this an MFS disk?	•• use TFSVCBCk
	BNE.S		@ItsHFS 					; Keep going if not
	MOVE.W		#wrgVolTypErr, D0			; Tell the silly caller
	BRA 		@Exit						; and cruise

@ItsHFS:
	jsrRom		ROMEXTOFFLINCK				; Is this volume on-line and one of ours?				<1.2> ex<SM1><Sys7.1> Put back "ROM"
	BEQ.S		@VolumeIsCool				; Keep going if so										<1.2>
	BRA 		@Exit						; Go home if not (with extFSErr or volOffLinErr in D0)	<1.2>

@VolumeIsCool:

	MOVE.L		ioSearchBits(A5), D5		; D5 = user's spec mask
	MOVEQ.L 	#0, D7						; no matches yet
	MOVE.L		D7, ioActMatchCount(A5) 	; set PB to initial value

	MOVE.L		ioMatchPtr(A5), CSSR.nextMBuf(A3) ; 1st MBuf entry is at the beginning of the buffer

; a0 = cspb
	bsr 		VerifyCSPB					; d2 = ioFlAttrib, d3 = cssr.flags
	bne 		@Exit						; no? ->
	move.b		d2, cssr.attribMask(a3) 	; save copy of user's attrib bits
	or.b		d3, cssr.flags(a3)			; add flags, keeping timer bit		<13>

; look for conditions that don't return paramErr, but are reason to quit now
	TST.L		ioReqMatchCount(A5) 		; max 0 matches?
	BEQ 		@LeaveEarly 				; just quit now; no error

; name setup - if the search includes any of the file name bits we need to make an
; uppercase copy of the target file name.
	BTST.L		#inclNames, d3				; does the search include names?
	BEQ.S		@go 						; if not, we're ready to roll
	MOVEA.L 	ioSearchInfo1(A5), A0		; A0 = ptr(ioSearchInfo1)
	MOVEA.L 	ioFileName(A0), A0			; A0 = ptr(ioName)
	MOVEQ.L 	#0, D0						; clear D0 to clear high bytes
	MOVE.B		(A0), D0					; D0 = len(target cName)
	CMPI.B		#31, D0						; is length > max hfs length?			<14>
	BHI.S		@NoWayName					; then we do this little optimization	<14>
	ADDQ.B		#1, D0						; D0 = len(target cName) + length byte
	LEA.L		CSSR.copyTarg(A3), A1		; A1 = ptr(copy of target cName)
	_BlockMove								; make the copy
	MOVEQ.L 	#0, D0						; clear D0 to clear high bytes
	MOVEA.L 	A1, A0						; A0 = ptr(length byte of copy of target cName)
	MOVE.B		(A0)+, D0					; D0 = len(target cName)
	_FSUprString							; uppercase, strip diacriticals
	bra.s		@go							;										<14>

; <14>
; Since we can't copy extra-long names into our private buffer (to let them fail against
; all the names on this Str31'd hfs volume) we'll psych out the parameter right here.
@NoWayName:
	moveq.l		#eofErr, d0					; in case we need this
	btst.l		#fsSBNegate, D5				; do we match everything or nothing?
	beq.s		@Exit						; if no negation, match nothing
	moveq.l		#0, D5						; if negation, clear criteria so as to match everything

; the parameters are cool, so start searching
@go:
	MOVE.W		vcbCTRef(A2), D0			; catalog btree refnum
	BSR 		GetReadBuffer				; A1 = ptr(buffer), D3 = length, cssr.bufferOnStack set
	LEA.L		ioCatPosition(A5), A0		; A0 = ptr(CatPosition record in param block)	<dnf 1.5>

	BSR 		BTIPScan					; A4 is now ptr(PScan state record), 1st record is read
	BNE.S		@EndScan					; BTIPScan returns a regular OSErr
	MOVE.L		A4, CSSR.PSRPtr(A3) 		; save a copy of the PScan state record

@loop:
	BSR 		CheckCriteria				; do we have a match?
	BNE.S		@continue					; Z=1 indicates a hit

	BSR 		MBufInsert					; yes, so add entry to match buffer
	ADDQ.L		#1, D7						; tally this match
	MOVE.L		D7, ioActMatchCount(A5)		; update PB, so async users can watch
	CMP.L		ioReqMatchCount(A5), D7		; hit user match limit?
	BHS.S		@LimitExit

@continue:
	btst		#timerFired, CSSR.flags(a3)	; did the timer fire?						<12>
	bz.s		@noTimerYet					; no, don’t bug Mr. Scanner					<12>
	bset		#noMoreReads, PSR.flags(a4)	; yes, tell him not to hit the disk again	<12>
@noTimerYet

	BSR 		BTGetPhys					; on to the next record
	BNE.S		@EndScan					; either a real error, or just EOF
	BRA.S		@loop

; Exit code
; There are 5 paths out of CatSearch
;	1) LeaveEarly - set result to noErr, don't clean up PScan
;	2) ParamErrExit - set result to paramErr, don't clean up PScan
;	3) LimitExit - set result to noErr, and clean up the PScan
;	4) EndScan - don't touch the result, and clean up the PScan
;	5) Exit - don't touch the result code, don't clean up the PScan.

@LeaveEarly:
	MOVEQ.L 	#noErr, D0					; No error
	BRA.S		@Exit						; No PScan cleanup

@ParamErrExit:
	MOVE.W		#paramErr, D0
	BRA.S		@Exit

@LimitExit:
	MOVEQ.L 	#noErr, D0					; user limit condition implies noErr

@EndScan:
	CMP.W		#userCanceledErr, d0		; is this because noMoreReads was set?
	BNE.S		@errorIsReal				; if not, this must be a real error
	MOVEQ.L 	#noErr, d0					; if so, replace the signal error with noErr

@errorIsReal:
	LEA.L		ioCatPosition(A5), A0		; A0 = ptr(CatPosition record in param block)		<dnf 1.5>
	BSR 		BTEndPScan					; clean up PScan (update CatPosition record)

@Exit:										; Pass the error code on and exit
	BSR 		StopTimer					; Stop the timer if we started one			<12>
	BTST.B		#bufferOnStack, CSSR.flags(A3)	; do we have our buffer on the stack?
	BEQ.S		@notBufferOnStack			; if not, don't deallocate one
	ADDA.L		#CSMinBufferSize, A6		; deallocate read buffer
@notBufferOnStack:
	ADDA.W		#CSSR.size, A6				; deallocate CSSR
	suba.l		a3, a3						; clear WDCB pointer for external file systems		<17>
	jmpRom		ROMCMDDONE					;													ex<SM1><Sys7.1> Put back "ROM"

	_CSDebugRts 'CMCatSearch', 0
	endproc
	end