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

611 lines
23 KiB
Plaintext
Raw Blame History

;
; File: TFSRFN1.a
;
; Contains: This file contains routines using refnums.
;
; Copyright: © 1982-1993 by Apple Computer, Inc., all rights reserved.
;
; Change History (most recent first):
;
; <SM5> 8/27/93 BH Removed <SM4>. The flushing stuff is now in CmdDone.
; <SM4> 8/3/93 BH Flushing critical volume info when changed for a volume in a
; manual-eject drive.
; <SM3> 10/26/92 CSS We now flush on chip caches after we do a read and before we
; do a write. Also, make a short branch into a word branch.
; <SM2> 5/21/92 kc Append "Trap" to the names of GetFPosTrap and SetFPosTrap to
; avoid name conflict with the glue.
; <SM1> 4/1/92 kc Checked in from Reality.
; • Pre-SuperMario comments follow •
; <2> 9/12/91 JSM Add a header.
; <1.4> 4/13/89 DNF Vectored FileRead and FileWrite.
; <1.3> 3/2/89 DNF removed references to forROM; HFS now builds identically for ram
; or rom
; <1.2> 11/21/88 CCH Replaced references to forRAM with “NOT forROM.”
; <1.1> 11/10/88 CCH Fixed Header.
; <1.0> 11/9/88 CCH Adding to EASE.
; <1.0> 2/11/88 BBM Adding file for the first time into EASE…
; 1/22/86 LAK Set CacheFlag before FlushCache call for read-verify flush.
; 1/14/86 LAK TFSBitTst doesn't trash D0 as before (needed for FileAlloc
; change).
; 10/8/85 LAK Fixed bug in DoPart for ROM (vectoring to BlockMove kills D1).
; 10/1/85 LAK Added label for TFSVCBTst. Rewrote to call cache for all I/O.
; Write no longer prefetches when extending the file. Read-verify
; calls cause the file fork to be flushed and blocks to be read
; read from disk rather than the cache.
; 9/21/85 LAK Changed for new TrashBlocks interface.
; 9/18/85 LAK Call TrashBlocks with D2=last block number, not last block+1.
; 9/8/85 LAK Slight modification to read code so it doesn't use FSTemp4.
; 9/6/85 LAK Tag data bug for Write-in-place fixed. MyRWSub uses longword D3
; for start disk block for TFS volumes (for > 32MB volumes).
; 9/2/85 LAK Release cache buffer immediately after read (read-verify error
; path wasn't releasing the buffer). Use MarkBlock to dirty buffer
; for TFS write . . .
; 8/31/85 LAK Removed TFS support of OwnBuf buffers . . . removed Pat's debug
; code.
; 8/19/85 PWD Tempered enthusiam displayed above to save only between calls to
; MyRWSub0 and GetRegs, NEVER AFTER GetRegs.
; 8/15/85 PWD Added code to save A6 before ,ASYNC calls
; 2/25/85 GJC new today
; 6/27/84 GSS Put in line the WrPart patch from MSFileFix
; 8/30/83 LAK Removed redundant set of FCB dirty bit in FileWrite (gets set by
; AdjEOF).
; 8/15/83 LAK Flushes file buffer now if block is dirty and falls within
; read-in-place . . . saved some bytes, too.
; 8/11/83 LAK Added support for a read-verify mode.
; 8/2/83 LAK Fixed read bug (read count 0 with position past EOF). Changed
; file positioning mode 2 (relative to end of file) by defining
; IOPosOffset to be either positive or negative . . .
; 6/2/83 LAK Changes for FCBBfAdr=0 meaning use volume buffer.
; 2/10/83 LAK Fixed bugs in Read with EOL character.
; 2/9/83 LAK Fixed MyWriteIP bug (now invalidates file's buffer if it happens
; to write that block . . .)
; 1/17/83 LAK Latest changes for final structures. Brought SetFPos and GetFPos
; here from FSRFN2. Made GetFPos and SetFPos call FileRead with
; zero bytes requested.
; 12/14/82 LAK Rewrote for new file system data structures.
;
;_______________________________________________________________________
;
; External Routines: FileRead,FileWrite,SetFPos,GetFPos
;
; Internal Routines: MyWrite,Seek,CVFlgs,MyReadBk,MyReadDB,MyReadIP
;
;_______________________________________________________________________
;_______________________________________________________________________
;
; Routines TFSBitTst, TFSVolTst, TFSVCBTst
; Arguments A0.L (input) -- pointer to I/O parameter block
; D0 (output) -- status
; Calls GetVCBRfn
; Called by Create
; Function determines whether or not the volume is TFS format
; (TFSVolTst) and whether or not TFS params are defined
; for this call (TFSBitTst).
;
; Modification History:
;
; 25-Feb-85 GJC new today
;_______________________________________________________________________
BLANKS ON
STRING ASIS
TFSBitTst BTST #HFSBit,IOtrap(A0) ; test TFS bit <14Jan86>
RTS ; on return, status .ne. means TFS
TFSVolTst MOVEA.L FCBVPtr(A1,D1.w),A2
TFSVCBTst CMPI.W #Tsigword,VCBSigWord(A2) ; is sigword that of TFS? <01Oct85>
RTS ; on return, status .eq. TFS vol
;
;_______________________________________________________________________
;
; Routine: Seek
; Arguments: A0.L (input) -- I/O parameter block pointer, uses: IOPosMode,
; IOPosOffset
; (A1,D1) (input) -- FCB ptr for the file in question
; D0.W (output) -- error code
; D2.W (output) -- distance past EOF (0 or - if not past EOF)
; D5.L (output) -- current file position
; D7.L (output) -- set to IOReqCount
; IOActCount cleared
; trashes D4
; Called By: FileRead,FileWrite
; Function: Seek is a utility routine that interprets the positioning
; parameters in an read or write call, updating the current
; file position in the FCB.
;
; There are 4 positioning modes:
;
; mode 0 -> no positioning
; mode 1 -> relative to beginning (absolute)
; mode 2 -> relative to end of file
; mode 3 -> relative to current
;
; If the file positioning would cause the current position to
; become negative, it is not changed and an error
; (PosErr) is returned; otherwise, result code 0
; returned. Read and Write must check for positioning past
; current EOF since they handle that case differently (read
; reports an error, write extends the file). This routine will
; clip the position to the end-of-file but returns a remainder
; in D2.
;
; The IOReqCount field must be positive; IOPosOffset may be
; positive or negative . . .
;
; Modification History:
; 14 Dec 82 LAK Rewrote to reflect new file system data structures. Changed
; to handle positioning past end-of-file differently, reports
; error when positioning to before file start.
; 15 Aug 83 LAK Now trashes D4 and passes back file position in D5.
;
; USoft memo Aug 10: A read with position past end of file should return an
; error; a write should allocate space on the disk up to the specified
; position. Read and write should return the current file position in the
; in the parameter block after reads and writes regardless of positioning mode.
;
;_______________________________________________________________________
Seek
CLR.L IOActCount(A0) ; haven't actually done any bytes yet.
MOVEQ #ParamErr,D0 ; assume bad count
MOVE.L IOReqCount(A0),D7 ; # bytes to read/write
BMI.S SkExitRTS ; exit with error if negative
MOVE.L IOPosOffset(A0),D2 ; position value the user supplied
MOVE.L FCBCrPs(A1,D1),D5 ; current file position
MOVE.L FCBEOF(A1,D1),D4 ; get the current EOF
MOVE.B IOPosMode+1(A0),D0 ; the position mode is in bits 0,1
ROXR.B #2,D0 ; get position bits in carry, sign
BCC.S PM01 ; br if 0 or 1
BMI.S PM3 ; br if 3
; relative to the end of the file (mode 2)
MOVE.L D4,D5 ; current EOF
; relative to current position (mode 3)
PM3 ADD.L D2,D5
BRA.S SkExit
PM01 BPL.S SkExit ; br if no position operation (mode 0)
; relative to start (mode 1)
MOVE.L D2,D5 ; relative to start is absolute
SkExit BPL.S @1 ; did D5 go negative? br if not
MOVEQ #PosErr,D0 ; report positioning error
BRA.S SkExitRTS ; and don't change current position
@1 MOVE.L D5,D2 ; new position
SUB.L D4,D2 ; distance past end of file (pos-EOF)
BLE.S @2 ; br if not past the end
MOVE.L D4,D5 ; pin to EOF
@2 MOVE.L D5,FCBCrPs(A1,D1) ; set the new current position
MOVEQ #0,D0 ; no error
SkExitRTS RTS
;_______________________________________________________________________
;
; Routine: GetFPos
;
; (c) 1983 Apple Computer, Inc.
;
; Arguments: A0.L (input) -- pointer to I/O parameter block; uses:
; IORefNum,IOPosOffset
; D0.W (output) -- 0 if file was found, error code otherwise.
; Calls:
; Function: Get current file position for specified opened file
;
; Modification History:
; 10 Dec 82 LAK Modified for new file system data structures.
; 17 Jan 83 LAK Modified to call FileRead via SetFPos to do the work.
;
;_______________________________________________________________________
GetFPosTrap:
CLR.B IOPosMode+1(A0) ; no file positioning
; Fall thru to SetFPos
;_______________________________________________________________________
;
; Routine: SetFPos
;
; (c) 1983 Apple Computer, Inc.
;
; Arguments: A0.L (input) -- pointer to I/O parameter block; uses:
; IORefNum,IOPosOffset
; D0.W (output) -- 0 if file was found, error code otherwise.
; Calls:
; Function: Set current file position for specified opened file. Will
; not set the position past end of file. Uses positioning modes
; like FileRead.
;
; Modification History:
; 10 Dec 82 LAK New Today.
; 17 Jan 83 LAK Modified to call fileread.
;
;_______________________________________________________________________
SetFPosTrap:
CLR.L IOReqCount(A0) ; no bytes
; fall thru to FileRead
;_______________________________________________________________________
;
; Routine: FileRead
; Arguments: A0.L (input) -- I/O parameter block pointer, uses: IORefnum,
; IOBuffer,IOReqCount,IOActCount,IOPosMode,IOPosOffset
; D0.W (output) -- error code
; Calls: FSQueue,RFnCall,Seek,Lg2Phys,MyRead,CmdDone
; Function: General purpose file read call.
;
; Modification History:
; 15 Dec 82 LAK Rewrote to reflect new file system data structures;
; Separated reading with EOL mode from regular reading (now
; checks for EOL character whenever specified).
;
; 11 Mar 85 GJC Added modifications so FileRead can handle the caching scheme
; Used by TFS
; 16 May 85 PWD Set up options on FlushCache call.
;
; IOPosMode(A0).W = Newline char in bits 8-15, newline flag (1=enabled) in
; bit 7, bits 0-1 are position information
;
;
; - if positions to EOF and 0 bytes are requested, EOF is not reported.
; (reading exactly to EOF will not raise EOF condition unless byte count
; is not satisfied because EOF hit)
;_______________________________________________________________________
IMPORT CacheFlush ; <SM3> CSS
FileRead:
MOVE.L jFileRead,-(SP) ; jumptable entry for vFileRead <dnf v1.4>
RTS ; go there
vFileRead: ; 'vectored' FileRead routine
BSR FSQueue ; wait our turn
BSR RFnCall ; map the reference number
BNE FRdExit1 ; exit on errors (don't set IOPosOffset)
; (also exit for offline, ext fs calls)
BSR.S Seek ; do any positioning - D5 gets cur pos,
; IOActCount cleared, D7 set to
; IOReqCount
BNE.S FRdExit0 ; exit if positioned to before file start
; figure min(requested count,distance to EOF)
NEG.L D2 ; EOF-current pos (from seek)
BMI.S FRdEOFXit ; if negative, report end of file
CMP.L D2,D7 ; number of bytes desired within EOF?
BLE.S @1 ; br if so
MOVE.L D2,D7 ; just read distance to EOF
@1 TST.L D7 ; byte count 0?
BEQ.S FRdOK ; all done if none to read!
MOVE.W IOPosMode(A0),D2 ; get newline stuff
LSR.W #8,D2 ; newline char in low byte, enb in carry
BCS FRNewLine ; if newline enabled, do it differently <SM3> CSS
BTST #6,IOPosMode+1(A0) ; read verify? <01Oct85>
BEQ.S @2 ; br if not <01Oct85>
MOVEM.L A1/D1,-(A6) ; save A1/D1 across FlushCache call <01Oct85>
MOVE.W D1,D0 ; set up to make a flushcache for the file <01Oct85>
MOVEQ #0,D1 ; just normal call . . . <01Oct85>
MOVEA.L VCBBufAdr(A2),A1 ; point to volume buffer <01Oct85>
ST CacheFlag ; make sure we flush <22Jan86>
JSR FlushCache ; write all file blocks before read-verify <01Oct85>
MOVEM.L (A6)+,A1/D1 ; and trash so we actually read them <01Oct85>
@2 MOVE.W D5,D2 ; current file position (low word) <01Oct85>
AND.W #$01FF,D2 ; check lower 9 bits for blk bndry read
BEQ.S RDMain ; br if so (see if we can read into place)
; must read a funny amount of data (not a full block's worth)
RdPart BSR RdFileBlk ; read the data (asynchronously) <01Oct85>
BNE.S FRdExit ; exit on errors
; the data block is at (A5). Move it into user buffer byte by byte.
BTST #6,IOPosMode+1(A0) ; read verify only?
SNE D0 ; $00 if not, $FF if so
BSR DoPart ; share code with similar write code
BNE.S FRdExit ; exit on verify errors
; read multiple blocks into place in user's buffer
RdMain MOVE.L D7,D4 ; number of bytes we want.
BEQ.S FRdOK ; all done if no more bytes.
AND.W #$FE00,D4 ; only read whole blocks (pass D4=max bytes to read)
TST.L D4 ; any whole blocks to read?
BEQ.S RdPart ; br if not . . .
JSR CacheRdIP ; pass: A2=VCB ptr,(A1,D1.W)=FCB pointer
; D5.L=cur file pos, D4.L=max bytes to read
; A0=IO Param Blk ptr
; returns: D6=bytes read, D0=result code
BNE.S FRdExit ; disk errors deserve an exit
BSR UpdteCntPos ; using D6, update D7, D5, and IOActCount(A0)
BRA.s RdMain ; loop.
FRdOK MOVEQ #0,D0 ; no errors (except maybe EOF)
FRdExit TST.W D0 ; other error?
BNE.S FRdExit0 ; br if so
MOVE.L IOActCount(A0),D2 ; if actual count is not equal to
CMP.L IOReqCount(A0),D2 ; requested count, and no other errors,
BEQ.S FRdExit0 ; (br if not true)
FRdEOFXit MOVEQ #EOFErr,D0 ; then we must have hit end of file . . .
FRdExit0 MOVE.L D5,FCBCrPs(A1,D1) ; update current position in FCB
MOVE.L D5,IOPosOffset(A0) ; always return current pos
FRdExit1 BSR.L CacheFlush ; <SM3> CSS
BRA CmdDone ; bye now . . .
; reading while looking for end of line characters . . . do it a block at a time
FRNewLine BSR.S RdFileBlk ; read the data (asynchronously) <01Oct85>
BNE.S FRdExit ; exit on errors
; the data block is at (A5). Move it into user buffer byte by byte.
@5 MOVE.L D5,D2 ; current file position
AND.W #$01FF,D2 ; get the index
MOVE.L IOBuffer(A0),A3 ; user buffer
MOVE.L IOActCount(A0),D4 ; where to start continuing read
@10 MOVE.B 0(A5,D2.W),D0 ; get byte from the buffer
MOVE.B D0,0(A3,D4.L) ; put it into user's area
ADDQ.L #1,IOActCount(A0) ; actually read another byte!
ADDQ.L #1,D4 ; incr destination byte offset
ADDQ.W #1,D2 ; incr source byte offset
ADDQ.L #1,D5 ; incr current position
CMP.B IOPosMode(A0),D0 ; is it the EOL character?
BNE.S @20
MOVEQ #0,D0 ; no error, we found EOL!
BRA.S FRdExit0
@20 SUBQ.L #1,D7 ; decr byte count
BEQ.S FRdOK ; exit, checking for EOF condition
CMP.W D6,D2 ; reached end of buffer?
BCS.S @10 ; loop if not
BRA.S FRNewLine ; get another block
;_______________________________________________________________________
;
; Routine: RdFileBlk, PreRdFileBlk
; Arguments: A0.L (in ) -- I/O Param Blk Ptr (RdFileBlk)
; A2.L (in ) -- VCB ptr
; D5.L (in ) -- file position to read block from
; D0.W (out) -- error code
; D6.L (out) -- const 512 (byte count)
; A5.L (out) -- buffer pointer
; A6.L -- TFS stack pointer
; Clobbers:
; All other registers are preserved
; This routine returns to one level above caller during the
; read(caller must not have anything on the stack when
; issuing the call!)
; Called By: FileRead,FileWrite
; Function: Calls cache routines GetBlock and RelBlock to get a block
; of the file.
;
;
; Modification History:
; <01Oct85> LAK New today. Built from old MyReadBk.
;_______________________________________________________________________
PreRdFileBlk
BSR.S ReadBlock
CMP.L D3,D5 ; read position >= old LEOF rounded? <01Oct85>
BCS.S RdFileB1 ; br if not <01Oct85>
MOVEQ #kGBNoRead,D1 ; don't bother to read it then <01Oct85>
BRA.S RdFileB1 ; <01Oct85>
RdFileBlk
BSR.S ReadBlock ;
BTST #6,IOPosMode+1(A0) ; read verify? <01Oct85>
BEQ.S RdFileB1 ; br if not <01Oct85>
MOVEQ #kGBRead,D1 ; always read it if so <01Oct85>
RdFileB1
MOVEA.L VCBBufAdr(A2),A1 ; Use a TFS volume cache buffer <01Oct85>
MOVE.L D5,D2 ; Byte position <01Oct85>
LSR.L #8,D2 ; 'Divide' by 256 <01Oct85>
LSR.L #1,D2 ; by 512 to get long file block # <01Oct85>
RTS ; return to ReadBlock <01Oct85>
; Called by: MFSDirRead, MFSMapRead, RdFileBlk
ReadBlock
MOVEM.L A0-A1/D1-D2,-(A6) ; save status <01Oct85>
MOVE.L (SP)+,A1 ; 'set up routine' address <01Oct85>
MOVE.L (SP)+,-(A6) ; Save return address <01Oct85>
MOVE.W D1,D0 ; file refnum
MOVEQ #0,D1 ; flag <01Oct85>
MOVEQ #2,D6 ; always return D6=512 for historical <01Oct85>
LSL.L #8,D6 ; reasons . . . <01Oct85>
JSR (A1) ; fill in A1=Cache Ptr, D2.L=block num, <01Oct85>
; D0.W=refnum (file or volume). <01Oct85>
ADDQ.B #kGBrelease,D1 ; immediate release <01Oct85>
JSR GetBlock ; get the cache buffer <01Oct85>
MOVEA.L A0,A5 ; return A5->released buffer
MOVE.L (A6)+,-(SP) ; pop ret address off TFS stack
MOVEM.L (A6)+,A0-A1/D1-D2 ; restore status
TST.W D0 ; any errors?
RTS ; return to caller with error code
;_______________________________________________________________________
;
; Routine: FileWrite
; Arguments: A0.L (input) -- I/O parameter block pointer, uses: IORefnum,
; IOBuffer,IOReqCount,IOActCount,IOPosMode,IOPosOffset
; D0.W (output) -- error code
; Calls: FSQueue,TstMod,RFnCall,Seek,Lg2Phys,MyWriteIP,MyWriteDB,CmdDone
; Function: Write user data to a file, extending the file as necessary.
;
; Modification History:
; 17 Dec 82 LAK Rewrote to reflect new file system data structures;
; When file is initially positioned past end-of-file, the
; file is automatically extended enough for the write.
;
;_______________________________________________________________________
IMPORT CacheFlush ; <SM3> CSS
FileWrite:
MOVE.L jFileWrite,-(SP) ; jumptable entry for vFileWrite <dnf v1.4>
RTS ; go there
vFileWrite: ; 'vectored' FileWrite routine
BSR.L CacheFlush ; flush the chip caches so data is in memory. <SM3> CSS
BSR FSQueue ; don't do the call until time.
BSR TstMod ; test if we may modify this file.
BNE.S FWrExit1 ; br if not.
BSR Seek ; share this routine with read - D5 gets
; cur file position, IOActCount cleared,
; D7 set to IOReqCount
BNE.S @2 ; br if tried to position before start
; (to FWrExit0)
TST.L D2 ; positioned past EOF?
BMI.S @1 ; br if not
ADD.L D2,D5 ; extend added to cur pos
; set up D3 so PreRdFileBlk can tell when a block actually has to be read
@1 MOVE.L #511,D3 ; <01Oct85>
ADD.L D4,D3 ; add current LEOF from Seek <01Oct85>
AND.W #$FE00,D3 ; LEOF rounded to next block boundary <01Oct85>
; see if file has to be made physically longer
MOVE.L D5,D4 ; current position after positioning
ADD.L D7,D4 ; end byte for write + 1
CMP.L FCBEOF(A1,D1),D4 ; will it fit within the old EOF?
BLS.S SameLen ; if so, leave file at same phys length
SUB.L FCBPLen(A1,D1),D4 ; is it past the phys end?
BLS.S @3 ; no, just reset the eof
; ran off the physical end of the file--need to allocate more blocks
; Call alloc with D4=number of extra bytes we need, A2=addr of VCB,
; (A1,D1) ptr to FCB . . .
BSR Alloc ; do it to it (sets FCB PEOF, start blk)
@2 BNE.S FWrExit0 ; exit if didn't get it (return with
; cur file pos = EOF)
; now just update the logical len.
@3 MOVE.L D5,D4 ; current position after positioning
ADD.L D7,D4 ; plus # bytes to write
MOVE.L D4,FCBEOF(A1,D1) ; is new logical end-of-file
; the data will fit into the file. At this point:
; A0=ptr to params,
; (A1,D1) = ptr to file's FCB
; A2 = ptr to VCB
; D7 = # bytes to write total
; D5 = current file position.
SameLen MOVE.W D5,D0 ; check if writing to a block boundary
AND.W #$01FF,D0 ; if so, low 9 bits will be 0
BEQ.S WrMain ; if so, try writing full blocks out
; must write some funny amount of data
WrPart BSR PreRdFileBlk ; get the appropriate block <01Oct85>
BNE.S FWrExit ; just skip if bad read
; the destination data block is at (A5). Move it out of user buffer byte by byte.
MOVEQ #1,D0 ; D0=1 for write
BSR.S DoPart ; share code with fileread
JSR MarkA5Block ; mark the block dirty <01Oct85>
; This section tries to write out entire blocks and/or groups of blocks
WrMain MOVE.L D7,D4 ; number bytes we want.
BEQ.S FWrOK ; all done if no more bytes.
AND.W #$FE00,D4 ; only write whole blocks
TST.L D4 ; must want at least 512 bytes
BEQ.S WrPart ; br if not . . .
JSR CacheWrIP ; pass: A2=VCB ptr,(A1,D1.W)=FCB pointer
; D5.L=cur file pos, D4.L=max bytes to read
; A0=IO param blk ptr
; returns: D6=bytes read, D0=result code
BNE.S FWrExit ; disk errors deserve an exit
BSR.S UpdteCntPos
BRA.S WrMain ; loop.
FWrOK MOVEQ #0,D0 ; no errors
FWrExit BSR AdjEOF ; adjust other FCBs for this file
MOVE.L D5,FCBCrPs(A1,D1) ; update current position in FCB
FWrExit0 MOVE.L FCBCrPs(A1,D1),IOPosOffset(A0) ; always return current pos
FWrExit1 BRA CmdDone ; command is done.
UpdteCntPos
SUB.L D6,D7 ; adjust for number of bytes read
ADD.L D6,IOActCount(A0) ; actually read this many more
ADD.L D6,D5 ; update current position
RTS
; code sharing routine . . . D6 = 512 on entry
DoPart
MOVE.L D5,D2 ; current file position
AND.W #$01FF,D2 ; get the index
SUB.W D2,D6 ; bytes in blk from cur pos
CMP.L D6,D7 ; more than we want?
BCC.S @1
MOVE.L D7,D6 ; if so, only r/w num requested
@1 MOVE.L IOBuffer(A0),A3 ; user buffer
ADD.L IOActCount(A0),A3 ; where to start continuing read/write
BSR.S UpdteCntPos
MOVEM.L D1/A0-A2,-(SP) ; preserve blockmove registers <08Oct85>
MOVE.L A3,A0 ; src for writes
MOVE.L A5,A1
ADD D2,A1 ; dest for writes
TST.B D0 ; read or write?
BGT.S @2 ; br for write
BMI.S @5 ; br for read verify
EXG A0,A1 ; switch src, dest for reads
@2 MOVE.L D6,D0 ; byte count
MOVE.L JBlockMove, A2 ; <01Oct85>
JSR (A2) ; <01Oct85>
@3 MOVEQ #0,D0 ; no errors
@4 MOVEM.L (SP)+,D1/A0-A2 ; restore regs <08Oct85>
RTS
@5 MOVEQ #IOErr,D0 ; assume error
SUBQ.W #1, D6 ; for DBNE loop <01Oct85>
@6 CMPM.B (A0)+,(A1)+ ; compare next byte
DBNE D6,@6 ; exit on errors or done <01Oct85>
BNE.S @4 ; br if err <01Oct85>
BRA.S @3 ; and take the good route if done
Reference in New Issue View Git Blame Copy Permalink