Macintosh-SW/supermario
1
0
Fork 0
mirror of https://github.com/elliotnunn/supermario.git synced 2024-11-26 16:49:18 +00:00
Code Issues Projects Releases Wiki Activity
0ecbd4a1a1
supermario/base/SuperMarioProj.1994-02-09/OS/HFS/Extensions/CatSearch.a
Elliot Nunn 2e16381318 Bring in sources, and document
2019-06-29 23:17:50 +08:00

1015 lines
39 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

;
; 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 FSQUEUE ; queue up the request
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 DTRMV3 ; find vol using ioNamePtr & ioVRefNum (D023/A234 trashed)
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 EXTOFFLINCK ; Is this volume on-line and one of ours? <1.2>
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 CMDDONE
_CSDebugRts 'CMCatSearch', 0
endproc
end
Reference in New Issue View Git Blame Copy Permalink