Macintosh-SW/sys7.1-doc-wip
1
0
Fork 0
mirror of https://github.com/elliotnunn/sys7.1-doc-wip.git synced 2024-06-12 14:29:29 +00:00
Code Issues Projects Releases Wiki Activity
2e2dcbd827
sys7.1-doc-wip/OS/HFS/Extensions/ExternalMakeFSSpec.a

680 lines
24 KiB
Plaintext
Raw Normal View History

happy commit
2020-03-22 08:44:21 +00:00
;
; Hacks to match MacOS (most recent first):
;
; <Sys7.1> 8/3/92 Reverted <SM3> by changing pascalRegs back to interruptRegs (i.e. not
; saving a2/a3/d3).
; 9/2/94 SuperMario ROM source dump (header preserved below)
;
SuperMarioProj.1994-02-09
2019-07-27 14:37:48 +00:00
;
; File: ExternalMakeFSSpec.a
;
; Contains: Code to perform emulation of the MakeFSSpec call
; for external file systems that don't support it
; themselves.
;
; This file can be assembled into code that relies on an a6 stack
; and QMgr.a-style queueing or into a simple subroutine for glue
; libraries. -d MakeGlue=0 should be used in system builds and
; -d MakeGlue=1 for glue library builds.
;
; Written by: Dave Feldman
;
; Copyright: © 1990-1991, 1993 by Apple Computer, Inc., all rights reserved.
;
; Change History (most recent first):
;
; <SM3> 6/9/93 pdw Changed register saving from interruptRegs to pascalRegs in
; myCompletionRoutine because it can be called from pascal (as it
; is when FileShare is running). Fixes a FileShare crash that
; appears when doing async I/O.
; <4> 9/13/91 JSM Cleanup header.
; <3> 3/17/91 dnf ppd, #dnf-0013: Use the result code from ioResult(a0) instead of
; from d0 to be extra-clean on async calls.
; <2> 9/22/90 dnf Put real code in here
; <1> 8/7/90 dnf first checked in
;
;
LOAD 'StandardEqu.d'
include 'FileMgrPrivate.a'
; Get inspired and move these somewhere
fsSpecNameLength equ 63
pathSeparator equ ':' ; a colon character
; Values for d3.b during parsing
moreSegments equ 0 ; also implies a colon-terminated segment
finalSegmentColon equ 1 ; no more segments; path ended with a colon
finalSegmentNoColon equ -1 ; no more segments; path didn't end with a colon
; For patch or ROM builds we need to include an i/o bottleneck to handle async calls.
; The bottleneck code assumes QMgr.a-style queueing.
if not(MakeGlue) then
include 'QMgrEqu.a'
;________________________________________________________________________________
;
; Routine: myBottleNeckIO
;
; Input: a0 points to param block
; Output: d0 contains result code
; a1 trash
;
; Function: Make traps which do I/O and do the right thing with completion
; routines.
;________________________________________________________________________________
;
BottleNeckRegs reg d1-d7/a1-a5 ; async could trash any regs
BottleNeckLocals record 0, increment
hasContinued ds.b 1 ; flag byte to watch stack depth
align 2
Lsize equ *-BottleNeckLocals
endr
myBottleNeckIO proc
import GetQMRecPtr
entry myCompletionRoutine
export myContCompatThread ; should be entry, but patch linker is dumb
export myContAppThread ; should be entry, but patch linker is dumb
movem.l BottleNeckRegs, -(a6) ; save our regs on hfs stack
with BottleNeckLocals
subq.w #Lsize, a6
bclr.b #0, hasContinued(a6) ; initialize completion routine flag
lea.l myCompletionRoutine, a1 ; get our ioCompletion routine address
move.l a1, ioCompletion(a0) ; and install it into the param block
move.w #fsCompatQType, d2 ; our queue type/refnum
bsr GetQMRecPtr ; a1 = ptr(QMRec)
move.l a6, QMRec.curStack(a1) ; save current alt stack pointer
; •• do high water mark checking here
btst.b #asyncCall, QMRec.qmFlags(a1) ; is this call async?
rts ; return to specific trap handling routine
; Some drivers have the nasty habit of calling their completion routines before returning
; from the trap that called them. This might lead to unbounded stack buildup from
; successive calls. To solve this we have a bit (in hasContinued) which is set both
; in the completion routine and after the trap.
; Case 1: The completion routine is called before we return from the trap. In this case
; we just cruise back to the driver, since we'll get control again when the driver
; rts's from our trap. When that happens we can just continue our call.
; Case 2: We get returned to before the completion routine is run (truly asynchronous).
; We rts to the app (giving back the async time) and we know we'll get control again
; at the completion routine. When we continue from here we need to save the
; appropriate interrupt registers.
; This little scheme is, of course, a critical section, but we're single threaded right now,
; so it doesn't matter.
myCompletionRoutine:
move.w #fsCompatQType, d2 ; our queue type/refnum
bsr GetQMRecPtr ; a1 = ptr(QMRec)
move.l a6, -(sp) ; save a6 for a sec
movea.l QMRec.curStack(a1), a6 ; get our a6 back
bset.b #0, hasContinued(a6) ; mark that we've been back
movea.l (sp)+, a6 ; restore a6
beq.s anRTSInstruction ; if we haven't returned from the trap, rts to driver
happy commit
2020-03-22 08:44:21 +00:00
movem.l interruptRegs, -(sp) ; save all regs that pascal callers need saved <LW2>pdw <Sys7.1>
pea restoreInterruptRegs ; and get in the chain to restore them later <LW2>pdw <Sys7.1>
SuperMarioProj.1994-02-09
2019-07-27 14:37:48 +00:00
myContCompatThread:
move.w #fsCompatQType, d2 ; our queue type/refnum
bsr GetQMRecPtr ; a1 = ptr(QMRec)
movea.l QMRec.curStack(a1), a6 ; restore alt stack pointer
adda.w #Lsize, a6 ; clear off the locals
movem.l (a6)+, BottleNeckRegs ; restore compatibility layer thread registers
move.l (a6)+, -(sp) ; push compatibility layer thread return address
move.w ioResult(a0),d0 ; set the ol' status register <3>
anRTSInstruction:
rts ; and return to caller
myContAppThread:
; •• we're ignoring the possibility of immediate errors
bset.b #0, hasContinued(a6) ; mark that we've returned
bne.s myContCompatThread ; if we already ran the completion routine, then
; continue without saving registers
rts ; return async time to application
happy commit
2020-03-22 08:44:21 +00:00
restoreInterruptRegs: ; <LW2>pdw <Sys7.1>
movem.l (sp)+, interruptRegs ; restore the regs that we saved last time through <Sys7.1>
SuperMarioProj.1994-02-09
2019-07-27 14:37:48 +00:00
rts ; back to the app thread
endproc
;________________________________________________________________________________
;
; Routine: DoAnA060Trap
;
; Input: a0 - paramblock
; d0 - HFSDispatch selector
;
; Output: a0 - paramblock
; d0 - result code
;
; Function: Fire off an a060 call
;
; Note: After myBottleNeckIO, Z = 1 -> async, Z = 0 -> sync.
;________________________________________________________________________________
DoAnA060Trap: proc
move.l (sp)+, -(a6) ; save thread ret addr on a6
bsr myBottleNeckIO ; do common set up
bne.s @1 ; zero flag set if async
_HFSDispatch ; sync trap
jmp myContCompatThread; keep going with this call
@1: _HFSDispatch async ; async trap
jmp myContAppThread ; keep going, but give async time to app
endproc
; Macro for generating code that executes a synchronous or asynchronous trap
; based on the value of the zero flag. Zero set = async, zero clear = sync.
macro
doSomeTrap &theTrap
move.l (sp)+, -(a6) ; save desktop thread ret addr on a6
bsr myBottleNeckIO ; do common set up
bne.s @1 ; zero flag set if async
_&theTrap ; sync trap
jmp myContCompatThread; keep going with this desktop call
@1: _&theTrap async ; async trap
jmp myContAppThread ; keep going, but give async time to app
endm
doGetCatInfo: proc
move.w #selectGetCatInfo, d0
jmp DoAnA060Trap
endproc
doGetWDInfo: proc
move.w #selectGetWDInfo, d0
jmp DoAnA060Trap
endproc
doGetVolInfo: proc
doSomeTrap GetVolInfo
endproc
doHGetVol: proc
doSomeTrap HGetVol
endproc
macro
go_GetCatInfo
bsr doGetCatInfo
endm
macro
go_GetWDInfo
bsr doGetWDInfo
endm
macro
go_GetVolInfo
bsr doGetVolInfo
endm
macro
go_HGetVol
bsr doHGetVol
endm
; For glue we can go straight to traps
else
macro
go_GetCatInfo
_GetCatInfo
endm
macro
go_GetWDInfo
_GetWDInfo
endm
macro
go_GetVolInfo
_GetVolInfo
endm
macro
go_HGetVol
_HGetVol
endm
endif
;________________________________________________________________________________
;
; Routine: ResetPathnameParser
;
; Input: a4 - caller's param block (uses ioNamePtr)
;
; Output: d1.l - number of characters in string (could be zero)
; a1 - pointer to first character in string (or nil)
;
; Function: Set registers used by parser to cause it to start at the beginning
; of the string when it is next called.
;________________________________________________________________________________
ResetPathnameParser: proc
moveq.l #0, d1 ; clear high bytes
move.l ioNamePtr(a4), d0 ; grab pathname pointer and set ccr's
movea.l d0, a1 ; move to a1 even if it's nil
beq.s @Exit
move.b (a1)+, d1 ; get the length and point at 1st char
@Exit:
rts
endproc
;________________________________________________________________________________
;
; Routine: ParseNextSegment
;
; Input: a1 - current location along pathname string
; a2 - pointer to FSSpec under construction
;
; d1.w - characters remaining in string in front of a1
;
; Output: a1 - update to new position along pathname string
; a2 - pointer to FSSpec under construction
;
; d0.w - error code (negative)
; d1.w - characters remaining in string in front of a1
;
; d3.l - stuff
; 0 moreSegments implies a colon-terminated segment
; 1 finalSegmentColon no more segments; path ended with a colon
; -1 finalSegmentNoColon no more segments; path didn't end with a colon
;
; Z
; set - saw an empty segment
; clear - saw a non-empty segment or an error occurred
;
; N
; set - error code in d0
; clear - success
;
; Function:
; Parse through the characters at (a1) and copy the
; next leaf (i.e. file/directory) name into FSSpec.name.
;
; Use the Z flag to indicate the presense of a '::' in the path
;
; Input:
; if d1 > 0 then
; a1 must point to the first character in the new segment
;
;________________________________________________________________________________
; ParseNextSegmentRegs reg a0
ParseNextSegment: proc
move.l a0, -(sp) ; save one register
move.w d2, -(sp) ; only low word
moveq.l #0, d0 ; no chars in this segment yet
lea.l FSSpec.name+1(a2), a0 ; address of 1st char in leaf name buffer
subq.b #1, d1 ; subtract one for dbra
cmp.b #pathSeparator, (a1) ; is this a colon?
beq.s @DoubleColon ; that means there's been 2 in a row
@Loop:
move.b (a1)+, d2 ; get the next character
cmp.b #pathSeparator, d2 ; is this a colon?
beq.s @SingleColon ; if so, we've got a whole segment
addq.b #1, d0 ; count the character
cmp.b #fsSpecNameLength, d0 ; are we overflowing FSSpec.name?
bhs.s @Overflow ; we overflowed, run for our lives...
move.b d2, (a0)+ ; copy the char into leaf buffer
dbra d1, @Loop ; while more characters keep going
moveq.l #finalSegmentNoColon, d3 ; we fell off the end, implying no colon there
bra.s @Success
@DoubleColon:
addq.l #1, a1 ; skip past the colon
@SingleColon:
moveq.l #moreSegments, d3 ; pretend we have more
tst.w d1 ; was the colon also the last character?
bne.s @Success ; if not, keep going
moveq.l #finalSegmentColon, d3 ; indicate our fate (done, with a colon)
@Success:
move.b d0, FSSpec.name(a2) ; turn FSSpec.name into a PString
@Exit:
move.w (sp)+, d2 ; restore low word
movea.l (sp)+, a0 ; restore one register
tst.w d0 ; Z if empty string, N if error
rts
@Overflow:
moveq.l #bdNamErr, d0 ; bummer - too many characters in file name
bra.s @Exit
endproc
;________________________________________________________________________________
;
; Routine: DetermineVolume
;
; Input:
; a1 - beginning of pathname (or nil)
; a2 - pointer to FSSpec under construction
; a4 - caller's param block (uses ioVRefNum and ioDirID)
;
; d1 - # of characters in string (could be zero)
; Output:
; FSSpec.vRefNum contains volume reference number
;
; d1.w - number of characters left in pathname
; d4.l - dirID of selected directory
; a1 - place to start parsing pathname from
; a2 - pointer to FSSpec under construction
; a4 - caller's param block (uses ioVRefNum and ioDirID)
;
; Function: Parse up ioVRefnum, ioNamePtr and ioDir to find the volume/directory
; pair. Set the FSSpec to describe the vol/dir pair, and return the
; dirID of the directory in question in d4.
;
; Handle all of the no-path-to-parse cases here:
; no vRef, dirID or path
; just a vRef
; just a wdRef
; just a vRef+dirID
; a colon for a pathname
;
;________________________________________________________________________________
DetermineVolume: proc
@DetermineVolumeRegs: reg d2/a0/a3
movem.l @DetermineVolumeRegs, -(a6)
suba.w #ioHVQElSize, a6 ; allocate a volume param block on a6
move.l a6, a0 ; leave pb in a0
; Check to see if there is a non-nil, non-zero length pathname
moveq.l #finalSegmentColon, d3 ; assume we have nothing to parse
tst.b d1 ; do we have a nil ptr or zero length name?
beq.s @UseVRefAndDirID ; if so, go use vRef+dirID
bsr ParseNextSegment ; parse next segment into FSSpec.name
bmi.s @Exit ; can't party if the parser don't want to
beq.s @UseVRefAndDirID ; initial colon implies vRef+dirID
tst.l d3 ; check parser results
bpl.s @VolumeNamePresent ; if it ended with a colon, it's a vol name
; We've got a special case - the pathname is a solo cname. Reset the path parser
; so that we'll see it again.
bsr ResetPathnameParser
moveq.l #moreSegments, d3 ; make sure they look at this again
bra.s @UseVRefAndDirID ; and go use the vRef and dirID fields
@VolumeNamePresent:
clr.w ioVRefNum(a0) ; use pathname, please
move.w #-1, ioFDirIndex(a0) ; use pathname, please
lea.l FSSpec.name(a2), a3 ; get the address of the just-parsed segment
move.l a3, ioNamePtr(a0) ; use caller's pathname
; slam a colon on because HFS sucks rocks
addq.b #1,d0 ; add a colon on to the end
cmp.b #fsSpecNameLength,d0 ; ooops! no space
bhs.s @BadNameError
move.b d0, (a3) ; jam the longer length
move.b #pathSeparator, (a3, d0.w) ; put in the lovely separator for the pleasure of Dirks
go_GetVolInfo
bne.s @Exit ; run away
move.w ioVRefNum(a0), FSSpec.vRefNum(a2) ; this is the volume
move.l #fsRtDirID, d4 ; use the root if we need to keep going
bra.s @Exit ; and we're done
; We don't have a volume name ('cause the path starts with a colon, the path is a
; solo file/directory name, or there's no path), so use the ioVRefNum and ioDirID
; fields to establish the volume and directory to start parsing from.
@UseVRefAndDirID:
clr.l ioNamePtr(a0) ; we don't need the name here
move.w ioVRefNum(a4), ioVRefNum(a0) ; use caller's vRef/WDRef
beq.s @HandleDefaultCase ; GetWDInfo has no clue about default directories
clr.w ioWDIndex(a0) ; no indexing, please
clr.l ioWDProcID(a0) ; any proc ID will do
clr.w ioWDVRefNum(a0) ; any volume will do
go_GetWDInfo
bne.s @Exit ; punt on errors
bra.s @GotVolAndDir
@HandleDefaultCase:
go_HGetVol
bne.s @Exit
@GotVolAndDir:
move.w ioWDVRefNum(a0), FSSpec.vRefNum(a2) ; use the volume from GetWDInfo
move.l ioDirID(a4), d4 ; are we overriding with the user's dirID?
bne.s @Exit ; if so, stop thinking now
move.l ioWDDirID(a0), d4 ; use dirID from vRef/wdRef or pathname
@Exit:
adda.w #ioHVQElSize, a6 ; deallocate volume param block on a6
movem.l (a6)+, @DetermineVolumeRegs
tst.w d0
rts
@BadNameError:
moveq.l #bdNamErr, d0 ; bummer - too many characters in file name
bra.s @Exit
endproc
;________________________________________________________________________________
;
; Routine: CorrectCapitals
;
; Input: a2 - pointer to FSSpec with leaf name
;
; Output: a2 - FSSpec has correct (same-as-catalog) spelling of leaf name
; d0 - result code
;
; Function: Replace the leaf name in FSSpec.name(a2) with the spelling as it
; is stored in the catalog.
;________________________________________________________________________________
CorrectCapitalsRegs reg a0/a1
CorrectCapitals proc
move.l (sp)+, -(a6) ; ret addr to local stack
movem.l CorrectCapitalsRegs, -(a6)
suba.w #ioHVQElSize, a6 ; allocate a pb
movea.l a6, a0
suba.w #256, a6 ; max name length is 256 bytes
movea.l a6, a1 ; a1 = ptr(name buffer)
move.l a1, ioFileName(a0) ; provide space for name output
move.w FSSpec.vRefNum(a2), ioVRefNum(a0) ; use the right volume
move.l FSSpec.parID(a2), d0 ; get parent directory
cmp.l #fsRtParID, d0 ; are we looking for the root's name?
beq.s @RootName
move.w #1, ioFDirIndex(a0) ; start indexing at 1
move.l d0, ioDirID(a0) ; use the right directory
@IndexLoop:
go_GetCatInfo
bne.s @Exit ; punt on errors
move.l a0,-(sp) ; stash regs
move.l a1,-(sp)
lea FSSpec.name(a2), a0 ; point to source name
moveq.l #0, d0 ; clear everything
move.b (a0)+, d0 ; length of caller's string
swap d0 ; up high where _RelString likes it
move.b (a1)+, d0 ; length of catalog's string
_FSRelString ; compare 'em
movea.l (sp)+, a1 ; restore regs
movea.l (sp)+, a0
beq.s @Hit ; cruise when they match
add.w #1, ioFDirIndex(a0) ; check out the next one
move.l FSSpec.parID(a2), ioDirID(a0) ; use the right directory
bra.s @IndexLoop
; GetCatInfo seems to not want to return info about the root directory when asked for
; the first item (indexed) in fsRtParID. Thus, we hack.
@RootName:
clr.w ioVolIndex(a0) ; no indexing for us
go_GetVolInfo
bne.s @Exit
@Hit:
moveq.l #0, d0 ; clear everything
lea.l FSSpec.name(a2),a0 ; a0 target FSSpec
move.b (a1), d0 ; get length of catalog-spelled name
cmp.b #63, d0 ; a massive MFS name?
bls.s @1 ; if length <= 63, we've enough room
moveq.l #63, d0 ; sorry; you only get the 1st 63 chars
@1:
move.b d0, (a1) ; set clipped string length back into source
@loop:
move.b (a1)+, (a0)+ ; set chars into FSSpec.name
dbra d0, @loop
moveq.l #noErr, d0 ; yay!
@Exit:
adda.w #ioHVQElSize+256,a6 ; deallocate the pb and name buffer
movem.l (a6)+, CorrectCapitalsRegs
move.l (a6)+, -(sp) ; ret addr back
tst.w d0
rts
endproc
;________________________________________________________________________________
;
; Routine: ExternalMakeFSSpec
;
; Input: a0 - caller's param block (uses ioVRefNum, ioNamePtr, ioDirID and ioMisc)
;
; Output: FSSpec (pointed to by ioMisc) is properly set
; d0 - result code
;
; Function: Parse up ioVRefnum, ioNamePtr and ioDir to make an FSSpec
;
; register usage:
; a0 - our working parameter block
; a1 - current place along the caller's pathname
; a2 - FSSpec record
; a4 - caller's param block
; d1 - characters left in pathname in front of a1
;
; Assumes that suitably big a6 (≈800 bytes) is set up (presumably the compatibility layer)
; This routine follows all of the conventions to be called in the compatibility layer
; but would also run fine as glue if someone aims a6 at a stack.
;________________________________________________________________________________
ExternalMakeFSSpecRegs reg a2-a4/d3-d4
ExternalMakeFSSpec: proc export
move.l (sp)+, -(a6) ; we do i/o
movem.l ExternalMakeFSSpecRegs, -(a6)
movea.l a0, a4 ; save caller's pb pointer in a safe reg
sub.w #ioHVQElSize, a6 ; allocate a (big) param block on a6
movea.l a6, a0 ; keep a pointer to it around in a0
move.l ioFSSpecPtr(a4), a2 ; a2 = ptr(Caller's FSSpec record)
lea.l FSSpec.name(a2), a3 ; use FSSpec.name for path segment name storage
move.l a3, ioNamePtr(a0) ; have
bsr ResetPathnameParser ; get ready to parse pathname
bsr DetermineVolume ; go get the volume and directory established
bne @ErrorExit
move.w FSSpec.vRefNum(a2), ioVRefNum(a0) ; we know the volume now
@DirIDButNoCatInfo:
move.l d4, ioDirID(a0) ; remember this so we can recognize our parents
tst.l d3 ; check result of last parse
bne.s @GetCatInfoByDirID ; no more segments? Get the name and par of this dir
@ParseSegments:
bsr ParseNextSegment ; using a1/d1 return next segment
bmi @ErrorExit ; splitsville if the parser won't dance
beq.s @DoubleColon ; handle double colon case
clr.w ioFDirIndex(a0) ; use dirID and name, please
go_GetCatInfo ; look and see if we can find anything
; There are two reasons that the following code rejects files when a colon is present:
; 1) a file in the middle of a path is an error, and its ioDirID is not a dirID
; 2) a file at the end of a colon-terminated path is an error, too (Bill B. sez)
bne.s @WeLikeItFine ; an error happened, so we can’t be picky
btst.b #ioDirFlg, ioFlAttrib(a0) ; was the thing we found a directory?
bne.s @WeLikeItFine ; yes, and we’re always happy to find directories
tst.l d3 ; did we have a colon?
bmi.s @WeLikeItFine ; no, and that is correct for a file
moveq.l #dirNFErr, d0 ; silly rabbi, colons are for directories
bra.s @ErrorExit
@WeLikeItFine:
tst.l d3 ; are we out of segments?
bne.s @DoneParsing ; if so, got to get out
tst.w d0 ; did we have trouble getting through the directory
bne.s @ErrorExit ; errors are our cue to cruise
move.l ioDirID(a0), d4 ; now, look within this directory
bra.s @ParseSegments
@DoubleColon:
cmp.l #fsRtDirID, d4 ; are we trying to go higher than the root?
beq.s @DirNFExit ; yes, we can’t (even though GetCatInfo would)
move.w #-1, ioFDirIndex(a0) ; we need this guy's parent
go_GetCatInfo
bne.s @ErrorExit ; barf on badness
move.l ioFlParID(a0), d4 ; get parent because we are done
bra.s @DirIDButNoCatInfo
@GetCatInfoByDirID:
move.w #-1, ioFDirIndex(a0) ; we need this guy's parent
go_GetCatInfo
bne.s @ErrorExit ; barf on badness
move.l ioFlParID(a0), d4 ; get parent because we are done
@DoneParsing:
move.l d4, FSSpec.parID(a2) ; use the parent from the last GetCatInfo
tst.w d0 ; did we get an error here?
beq.s @FoundSomething ; if not, we found something real
cmp.w #fnfErr, d0 ; did we get fnfErr, a perfectly acceptable error?
bne.s @ErrorExit ; no, it was another error, report it
; GetCatInfo returns an fnfErr instead of a dirNFErr when given a bad directory ID. Since an fnfErr
; from MakeFSSpec is an invitation to call _Create, we filter out bad directories here.
move.w #-1, ioFDirIndex(a0) ; info about directory
clr.l ioNamePtr(a0) ; we don't want the name back
move.l FSSpec.parID(a2), ioDirID(a0) ; use the directory we're about to return
go_GetCatInfo
bne.s @ErrorExit ; an error implies a bad directory
moveq.l #fnfErr, d0 ; good directory, so restore the fnfErr
cmp.l #fsRtParID, d4 ; were we searching in the root’s parent?
bne.s @Exit ; no, we can return safely (can't create in fsRtParID)
@ErrorExit:
cmp.w #fnfErr, d0 ; if an fnfErr made it here, it is really a dirNFErr
bne.s @notFNF
@DirNFExit:
moveq.l #dirNFErr, d0 ; return a dirNFErr instead
@notFNF:
clr.w (a2)+ ; clear the FSSpec.vRefNum
clr.l (a2)+ ; clear the FSSpec.parID
clr.b (a2)+ ; clear the FSSpec.name length byte
bra.s @Exit
@FoundSomething:
bsr CorrectCapitals ; Get correct spelling of leaf name
@Exit:
adda.w #ioHVQElSize, a6 ; deallocate param block
movem.l (a6)+, ExternalMakeFSSpecRegs
move.l (a6)+, -(sp)
tst.w d0
rts
endproc
end
Reference in New Issue Copy Permalink