Macintosh-SW/supermario
1
0
Fork 0
mirror of https://github.com/elliotnunn/supermario.git synced 2024-12-01 18:50:30 +00:00
Code Issues Projects Releases Wiki Activity
4b6e398c8a
supermario/base/SuperMarioProj.1994-02-09/Libs/InterfaceSrcs/OSTraps.a

3733 lines
105 KiB
Plaintext
Raw Normal View History

Bring in sources, and document
2019-06-29 15:17:50 +00:00
;
; File: OSTraps.a
;
; Contains: Interfaces to register based traps
;
; Copyright: © 1984 - 1990, 1992 by Apple Computer, Inc., all rights reserved.
;
; Change History (most recent first):
;
; <SM7> 11/10/92 CSS Update from Reality:
; <16> 10/16/92 DTY Add BlockMoveData.
; <SM6> 11/6/92 SWC Changed PackMacs.a->Packages.a.
; <SM5> 10/28/92 SWC Changed INCLUDEs to a LOAD of StandardEqu.d.
; <SM4> 10/22/92 CSS Changed a short branch to word branch.
; <SM3> 9/21/92 RB Changed a short branch to word branch.
; <15> 7/6/92 DCL Added Support for new synonyms.
; <14> 6/12/91 LN Removed #includes for private interfaces from public interfaces.
; Changed #include 'HardwareEqu.a' to #include
; 'HardwarePrivateEqu.a'
; <13> 12/14/90 dba <JDR> move VInstall and VRemove to the obsolete section
; <12> 12/3/90 JDR <dba> Shorten glue for InsTime, RmvTime, PrimeTime and move them
; to the obsolete section; get rid of InsXTime glue since no one
; ever used it.
; <11> 11/28/90 JDR <KIP> There is no glue for calling _InsXTime and I need to use
; it, so I've added it.
; <10> 11/4/90 dba shortened some of the routines that use LINK to get a parameter
; block by doing a MOVE.L SP,A0 instead of a LEA
; -paramBlockSize(A6),A0; fixed GetHandleSize and GetPtrSize so
; they return 0 if an error occurs (instead of the error code);
; added ReallocateHandle, MaxMemSys, CompactMemSys
; GetOSTrapAddress, SetOSTrapAddress, GetToolTrapAddress,
; SetToolTrapAddress, GetToolboxTrapAddress,
; SetToolboxTrapAddress, MaxBlockSys, NewEmptyHandleSys; fixed a
; bug in StartSound (see below for details); made Create return an
; error code when GetFileInfo fails, instead of doing a
; SetFileInfo with random data; changed Open so it will try the
; OpenDF call first; got rid of the OpenDF glue, since it is now
; exactly equivalent to Open; shortened SetChooserAlert by taking
; advantage of the fact that BSET and BCLR return the old state of
; the bit being set/cleared; change GetDCtlEntry to return NIL if
; you pass a bad refNum - this matches how the Device Manager does
; this; moved obsolete glue routines to a separate part of the
; file
; <9+> 11/1/90 dba fix GetHandleSize and GetPtrSize failure case
; <9> 10/30/90 dnf (dragging dba along) Add OpenDF call. Remove DTGetPath,
; DTOpenInfom and DTCloseDown glue, since it is now inline.
; <8> 10/16/90 JL Putting Greg's Change Back
; <7> 10/4/90 JAL Implemented results of code review. No more 64K Rom Support.
; <6> 9/18/90 gbm Fix a build warning generated by a short branch to the next
; instruction... the way I fixed it was by making the exit points
; be in their own proc
; <5> 8/29/90 dnf Rename CreateFileID, DeleteFileID and ResolveFileID to the newly
; approved CreateFileIDRef, DeleteFileIDRef and ResolveFileIDRef.
; Change GetAltAccess/SetAltAccess to
; GetForeignPrivs/SetForeignPrivs
; <4> 5/4/90 dnf Add PBMakeFSSpec glue macro
; <3> 3/16/90 dnf Change desktop call names to match the latest in traps.a
; <2> 2/4/90 DNF Add glue for new HFS and Desktop calls
; 12/7/89 JAL Old (64K) Rom code which is now "unSupported". Removed from:
; SetSoundVol, ClsPorts, RamSDClose, RamSDOpen, romMoveHHi, MaxApplZone
; 12/4/89 JAL Removed HWNonPortable and PrNonPortable equates because they are
; now defined in the Makefile.
; 12/9/88 KLH StartSound must dispose handles after completion.
; 10/19/88 KLH Busy day. Fixed sndWait index in StartSound.
; 10/19/88 KLH Added NewHandleSys, NewHandleClear & NewHandleSysClear too.
; 10/19/88 KLH Added NewPtrSys, NewPtrClear & NewPtrSysClear per Ed Tecot, et al.
; 4/7/88 KLH Removed SystemZone, GetApplLimit, ApplicZone, GZSaveHnd & TopMem;
; provided inline.
; 1/7/88 KLH GetVInfo fixed to return correct size info.
; 12/1/87 KLH Mike Tibbott points out unnecessary save of ptr in Create.
; 9/21/87 KLH In GetDCtlEntry changed LSR.W #2,D0 to LSL.W to get index properly.
; 6/11/87 KLH Removed PBSetPEOF per Bill Bruffey.
; 4/13/87 KLH StartSound & StopSound now move.l -1 into SoundHdl to stop sounds &
; test only for a word of -1 to stop sounds started with old buggy code.
;
STRING ASIS
onMac EQU 1
LOAD 'StandardEqu.d'
INCLUDE 'HardwarePrivateEqu.a'
INCLUDE 'Packages.a'
INCLUDE 'Printing.a'
INCLUDE 'SANEMacs.a'
INCLUDE 'Slots.a'
obsoleteGlue equ 0 ; stuff conditionalized by this can be moved to a separate file
SoundHdl EQU $AE8 ; handle for the Sound Glue
; for EqualString
result EQU 16
str1 EQU 12
str2 EQU 8
caseSens EQU 6
diacSens EQU 4
parmSize EQU result-diacSens
;----------------------------------------------------------------------
;
; Procedure InitZone(growProc: ProcPtr;
; moreMasters: Integer;
; limitPtr,startPtr : Ptr);
; Creates and initializes a fresh zone from unstructured storage
;
; Arguments:
; growProc: points to grow procedure for this zone
; moreMasters: number of master pointers to create at a time
; limitPtr: points one past last byte of raw storage
; startPtr: points to first byte of raw storage
;
; Registers:
; D0 - result code from InitApplZone
;
InitZone PROC EXPORT
MOVE.L (SP)+,A1 ;return address
Move.L SP,A0 ;stack parameters form req blk
_InitZone
Add #14,SP ;strip parameters
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; FUNCTION CompactMem(cbNeeded: Size): Size;
;
; Compact the heap until a free block with cbNeeded bytes is found or
; until the end of the zone is reached. Returns cbFound, the size of
; the largest block found.
;
; Arguments:
; cbNeeded: size of block needed
;
; Result:
; size of largest block found, in bytes
;
; Registers:
; D0 - number of bytes needed/number of bytes in biggest block
;
CompactMem FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get cbNeeded
_CompactMem ;tell OS to do it
Move.L D0,(SP) ;save result
JMP (A1) ;return via A1
CompactMemSys FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get cbNeeded
_CompactMem sys ;tell OS to do it
Move.L D0,(SP) ;save result
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; FUNCTION MaxMem(VAR grow: Size): Size;
;
; Return the size of the maximum block which may be allocated without
; growing the zone. Also return the maximum number of bytes by which the
; zone may be grown.
;
; Arguments:
; None
;
; Result:
; size of largest available block in bytes
; grow: maximum growth allowed in current zone
;
; Registers:
; A0 - grow/pointer to VAR grow
; A1 - return address
; D0 - number of bytes in largest free block
;
MaxMem FUNC EXPORT
Move.L (SP)+,A1 ;get return address
_MaxMem ;let OS do it
Move.L A0,D1 ;max growth allowed
Move.L (SP)+,A0 ;get the pointer to VAR grow
Move.L D1,(A0)
Move.L D0,(SP) ;save result
JMP (A1) ;return via A1
MaxMemSys FUNC EXPORT
Move.L (SP)+,A1 ;get return address
_MaxMem sys ;let OS do it
Move.L A0,D1 ;max growth allowed
Move.L (SP)+,A0 ;get the pointer to VAR grow
Move.L D1,(A0)
Move.L D0,(SP) ;save result
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; FUNCTION NewPtr(byteCount: Size): Ptr;
; FUNCTION NewPtrSys(byteCount: Size): Ptr;
; FUNCTION NewPtrClear(byteCount: Size): Ptr;
; FUNCTION NewPtrSysClear(byteCount: Size): Ptr;
;
; Returns a pointer to a newly allocated non-relocatable block of
; memory byteCount bytes long.
;
; Arguments:
; byteCount: number of bytes needed
;
; Result:
; pointer to new block, or NIL, if not enough room
;
; Registers:
; A0 - points to new block, or NIL
; A1 - return address
; D0 - number of bytes needed/error code
;
NewPtr FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the byte count
_NewPtr ;ask OS to do request
Move.L A0,(SP) ;return result ptr on stack
JMP (A1) ;return via A1
NewPtrSys FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the byte count
_NewPtr ,sys ;ask OS to do request
Move.L A0,(SP) ;return result ptr on stack
JMP (A1) ;return via A1
NewPtrClear FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the byte count
_NewPtr ,clear ;ask OS to do request
Move.L A0,(SP) ;return result ptr on stack
JMP (A1) ;return via A1
NewPtrSysClear FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the byte count
_NewPtr ,sys,clear ;ask OS to do request
Move.L A0,(SP) ;return result ptr on stack
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; FUNCTION GetPtrSize(p: Ptr): Size;
;
; Returns number of bytes in the non-relocatable block pointed to by p.
;
; Arguments:
; p: points to non-relocatable block
;
; Result:
; number of bytes in block
;
; Registers:
; A0 - points to block
; A1 - holds return address
; D0 - number of bytes in block
;
GetPtrSize FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get the pointer
_GetPtrSize ;let OS do it
Move.L D0,(SP) ;return result on stack
bpl.s @done ;check for error <10>
clr.l (sp) ;return zero if we failed <10>
@done
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure SetPtrSize(p: Ptr; newSize: Size);
;
; Sets the size of the non-relocatable block pointed to by p to newSize
; bytes.
;
; Arguments:
; p: points to non-relocatable block
; newSize: number of bytes needed in block
;
; Result:
; None
;
; Registers:
; A0 - points to block
; A1 - holds return address
; D0 - number of bytes needed/error code
;
SetPtrSize PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the new size
Move.L (SP)+,A0 ;get the pointer
_SetPtrSize ;let OS do it
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; FUNCTION PtrZone(p: Ptr): THz;
;
; Recovers the reference to the heap zone object, given a pointer to
; a block.
;
; Arguments:
; p: points to non-relocatable block
;
; Result:
; pointer to the zone object for the zone
; containing the referenced block.
;
; Registers:
; A0 - points to block/points to block's zone object
; A1 - holds return address
; D0 - error code
;
PtrZone FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get the pointer
_PtrZone ;let OS do it
Move.L A0,(SP) ;save zone object pointer
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; FUNCTION NewHandle(byteCount: Size): Handle;
; FUNCTION NewHandleSys(byteCount: Size): Handle;
; FUNCTION NewHandleClear(byteCount: Size): Handle;
; FUNCTION NewHandleSysClear(byteCount: Size): Handle;
;
; Returns a handle to a newly allocated relocatable block
; byteCount bytes long.
;
; Arguments:
; byteCount: number of bytes needed
;
; Result:
; handle to new block, or NIL, if not enough room
;
; Registers:
; A0 - handle for new block, or NIL
; A1 - return address
; D0 - number of bytes needed/error code
;
NewHandle FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the byte count
_NewHandle ;ask OS to do request
Move.L A0,(SP) ;return result handle on stack
JMP (A1) ;return via A1
NewHandleSys FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the byte count
_NewHandle ,sys ;ask OS to do request
Move.L A0,(SP) ;return result handle on stack
JMP (A1) ;return via A1
NewHandleClear FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the byte count
_NewHandle ,clear ;ask OS to do request
Move.L A0,(SP) ;return result handle on stack
JMP (A1) ;return via A1
NewHandleSysClear FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the byte count
_NewHandle ,sys,clear ;ask OS to do request
Move.L A0,(SP) ;return result handle on stack
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; FUNCTION GetHandleSize(h: Handle): Size;
;
; Returns number of bytes in the relocatable block referenced by h.
;
; Arguments:
; h: handle for relocatable block
;
; Result:
; number of bytes in block
;
; Registers:
; A0 - points to block
; A1 - holds return address
; D0 - number of bytes in block
;
GetHandleSize FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get the handle
_GetHandleSize ;let OS do it
Move.L D0,(SP) ;return result on stack
bpl.s @done ;check for error <10>
clr.l (sp) ;return zero if we failed <10>
@done
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure SetHandleSize(h: Handle; newSize: Size);
;
; Sets the size of the relocatable block referred to by h to newSize
; bytes.
;
; Arguments:
; h: refers to relocatable block
; newSize: number of bytes needed in block
;
; Result:
; None
;
; Registers:
; A0 - points to block
; A1 - holds return address
; D0 - number of bytes needed/error code
;
SetHandleSize PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the new size
Move.L (SP)+,A0 ;get the handle
_SetHandleSize ;let OS do it
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; FUNCTION HandleZone(h: Handle): THz;
;
; Recovers the reference to the heap zone object, given a handle for
; a block.
;
; Arguments:
; h: refers to relocatable block
;
; Result:
; pointer to the zone object for the zone
; containing the referenced block.
;
; Registers:
; A0 - handle for block/points to block's zone object
; A1 - holds return address
; D0 - error code
;
HandleZone FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get the handle
_HandleZone ;let OS do it
Move.L A0,(SP) ;save zone object pointer
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; FUNCTION RecoverHandle(p: Ptr): Handle;
;
; Recovers the handle for a relocatable block, given a pointer to the
; relocatable block. theZone must be set to reflect the zone containing
; this relocatable block.
;
; Arguments:
; rp: points to relocatable block
;
; Result:
; handle for the referenced block.
;
; Registers:
; A0 - pointer to relocatable block/handle for block
; A1 - holds return address
; D0 - error code
;
RecoverHandle FUNC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get the reloc block pointer
_RecoverHandle ;let OS do it
Move.L A0,(SP) ;save handle for block
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure ReallocHandle(h: Handle; byteCount: Size);
;
; Allocates a relocatable block, using an existing handle.
; If the handle is not already empty, the handle is emptied first,
; then allocated.
;
; Arguments:
; h: refers to relocatable block
; byteCount: number of bytes needed in the new block
;
; Result:
; None
;
; Registers:
; A0 - handle for block/points to block's zone object
; A1 - holds return address
; D0 - new block size/error code
;
ReallocHandle PROC EXPORT
EXPORT ReallocateHandle
ReallocateHandle
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get the new size
Move.L (SP)+,A0 ;get the handle
_ReallocHandle ;let OS do it
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure BlockMove(srcPtr, destPtr: Ptr; byteCount: Size);
;
; Arguments:
; srcPtr: source pointer
; destPtr: destination pointer
; byteCount: bytecount for move
;
; Registers:
; A0 - source pointer
; A1 - destination pointer
; D0 - bytecount for move
; D1 - holds return address
;
BlockMove PROC EXPORT
Move.L (SP)+,D1 ;return address
Move.L (SP)+,D0 ;byte count
Move.L (SP)+,A1 ;destination ptr
Move.L (SP)+,A0 ;source ptr
_BlockMove ;let OS to do it.
Move.L D1,A1 ;return address
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure BlockMoveData(srcPtr, destPtr: Ptr; byteCount: Size);
;
; Arguments:
; srcPtr: source pointer
; destPtr: destination pointer
; byteCount: bytecount for move
;
; Registers:
; A0 - source pointer
; A1 - destination pointer
; D0 - bytecount for move
; D1 - holds return address
;
BlockMoveData PROC EXPORT
Move.L (SP)+,D1 ;return address
Move.L (SP)+,D0 ;byte count
Move.L (SP)+,A1 ;destination ptr
Move.L (SP)+,A0 ;source ptr
_BlockMoveData ;let OS to do it.
Move.L D1,A1 ;return address
JMP (A1) ;return via A1
;
; FUNCTION OpenDriver(driverName: OsStr255; VAR refNum: INTEGER): OsErr;
;
; OpenDriver opens the driver of a given name, returning refNum and error
;
OpenDriver FUNC EXPORT
MOVEQ #(ioQElSize/2)-1,D0
@1 CLR.W -(SP)
DBRA D0,@1
MOVE.L ioQElSize+8(sp),ioFileName(SP) ;set up name
MOVE.L SP,A0 ;point to it
_Open ;open the driver
MOVE.L ioQElSize+4(SP),a0 ;get place to put result
MOVE.W ioRefNum(SP),(a0) ;store result
MOVE.L ioQElSize(SP),A0 ;get return address
LEA ioQElSize+12(SP),SP ;get rid of param. block and parameters
MOVE.W D0,(SP) ;store error code
JMP (A0) ;return
;
; PROCEDURE CloseDriver(refNum: INTEGER):OsErr;
;
; CloseDriver closes the driver with the specified refNum
;
CloseDriver PROC EXPORT
MOVE.W 4(SP),D0 ;get the refNum
SUB #30,SP ;get space for param block
MOVE.W D0,ioRefNum(SP) ;set up refNum
MOVE.L SP,A0
_Close ;close it!
ADD #30,SP ;pop off param block
MOVE D0,6(SP) ;return result
MOVE.L (SP)+,A0
ADDQ #2,SP
JMP (A0)
;
;FUNCTION SerReset(refNum: INTEGER; serConfig: INTEGER): OSErr;
;
SerReset FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 10(A6),ioRefNum(A0) ; refnum
MOVE.W #8,csCode(A0) ; code for Reset
MOVE.W 8(A6),csParam(A0) ;the configuration
_Control
MOVE D0,12(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,(SP)
RTS
;
;FUNCTION SerSetBuf(refNum: INTEGER; serBPtr: Ptr; serBLen: INTEGER): OSErr;
;
SerSetBuf FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 14(A6),ioRefNum(A0) ; refnum
MOVE.W #9,csCode(A0) ; code for Set buffer
MOVE.L 10(A6),csParam(A0) ;the ptr to the buffer
MOVE.W 8(A6),csParam+4(A0) ;the buffer length
_Control
MOVE D0,16(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ #8,SP ; fix up stack
JMP (A1)
;
;FUNCTION SerHShake(refNum: INTEGER; flags: SerShk): OSErr;
;
SerHShake FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 12(A6),ioRefNum(A0) ; refnum
MOVE.W #10,csCode(A0) ; code for setting handshake options
MOVE.L 8(A6),A1 ;ptr to flags record
MOVE.L (A1)+,csParam(A0) ;copy the first 4 bytes
MOVE.L (A1),csParam+4(A0) ;copy the second 4 bytes
_Control
MOVE D0,14(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ #6,SP ; fix up stack
JMP (A1)
;
;FUNCTION SerSetBrk(refNum: INTEGER): OSErr;
;
SerSetBrk FUNC EXPORT
EXPORT SetClr
MOVE.W #12,D0
SetClr
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 8(A6),ioRefNum(A0) ; refnum
MOVE.W D0,csCode(A0) ; code for setting break
_Control
MOVE D0,10(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ #2,SP ; fix up stack
JMP (A1)
;
;FUNCTION SerClrBrk(refNum: INTEGER): OSErr;
;
SerClrBrk FUNC EXPORT
IMPORT SetClr
MOVE.W #11,D0 ;csCode for clearing break
JMP SetClr ;got to common set/clr break code
;
;FUNCTION SerGetBuf(refNum: INTEGER; VAR count: LongInt): OSErr;
;
SerGetBuf FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 12(A6),ioRefNum(A0) ; refnum
MOVE.W #2,csCode(A0) ; csCode for get buf
_Status
MOVE D0,14(A6) ; return the result code
MOVE.L 8(A6),A1 ; ptr to where to put count
MOVE.L csParam(A0),(A1) ;return the count
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ #6,SP ; fix up stack
JMP (A1)
;
;FUNCTION SerStatus(refNum: INTEGER; VAR serSta: SerStaRec): OSErr;
;
SerStatus FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 12(A6),ioRefNum(A0) ; refnum
MOVE.W #8,csCode(A0) ; csCode for get buf
_Status
MOVE D0,14(A6) ; return the result code
MOVE.L 8(A6),A1 ; ptr to where to put the status bytes
MOVE.L csParam(A0),(A1)+ ;return the first 4 bytes
MOVE.W csParam+4(A0),(A1) ;return the next 2 bytes
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ #6,SP ; fix up stack
JMP (A1)
;FUNCTION DiskEject(drvnum: INTEGER): OSErr;
;
DiskEject FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W #dskRfN,ioRefNum(A0) ; refnum of the Sony Disk
MOVE.W #ejectCode,csCode(A0) ; code for Eject
MOVE.W 8(A6),ioDrvNum(A0) ;the drvNum of drv to be eject
_Control
MOVE D0,10(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ #2,SP ; fix up stack
JMP (A1)
;FUNCTION SetTagBuffer(buffPtr: Ptr): OSErr;
;
SetTagBuffer FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W #dskRfN,ioRefNum(A0) ; refnum of the Sony Disk
MOVE.W #tgBuffCode,csCode(A0) ; code for SetTagBuffer
MOVE.L 8(A6),csParam(A0) ;csParam is the buffptr
_Control
MOVE D0,12(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,(SP)
RTS
;FUNCTION DriveStatus(drvNum: INTEGER; VAR status: DrvSts): OSErr;
;
DriveStatus FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W #dskRfN,ioRefNum(A0) ; refnum of the Sony Disk
MOVE.W #drvStsCode,csCode(A0) ; code for SetTagBuffer
MOVE.W 12(A6),ioDrvNum(A0) ;the drvNum of drv to be ejected
_Status
MOVE D0,14(A6) ; return the result code
MOVE.L 8(A6),A1 ; ptr to where to put the status bytes
LEA csParam(A0),A0 ;ptr from where to get status bytes
MOVEQ #22,D0 ;number of bytes to move
_BlockMove
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ #6,SP ; fix up stack
JMP (A1)
;FUNCTION GetTrapAddress(trapNum: INTEGER): LongInt;
GetTrapAddress FUNC EXPORT
MOVE.L (SP)+,A1 ;return address
MOVE.W (SP)+,D0 ;trap word
_GetTrapAddress
MOVE.L A0,(SP) ;return corresponding address
JMP (A1)
;PROCEDURE SetTrapAddress(trapAddr: LongInt; trapNum: INTEGER);
SetTrapAddress FUNC EXPORT
MOVE.L (SP)+,A1 ;return address
MOVE.W (SP)+,D0 ;trap number
MOVE.L (SP)+,A0 ;address
_SetTrapAddress
JMP (A1)
;FUNCTION NGetTrapAddress(trapNum: INTEGER; tTyp: TrapType): LongInt;
NGetTrapAddress FUNC EXPORT
MOVE.L (SP)+,A1 ;return address
MOVE.B (SP)+,D1 ;trap selector: 0-OSTrap 1-ToolTrap
MOVE.W (SP)+,D0 ;trap number
TST.B D1 ;0-OSTrap 1-ToolTrap
BEQ.S @1
_GetTrapAddress newTool
BRA.S @3
@1
_GetTrapAddress newOS
@3
MOVE.L A0,(SP) ;return corresponding address
JMP (A1)
;PROCEDURE NSetTrapAddress(trapAddr: LongInt; trapNum: INTEGER; tTyp: TrapType);
NSetTrapAddress FUNC EXPORT
MOVE.L (SP)+,A1 ;return address
MOVE.B (SP)+,D1 ;trap selector: 0-OSTrap 1-ToolTrap
MOVE.W (SP)+,D0 ;trap number
MOVE.L (SP)+,A0 ;trap address
TST.B D1 ;0-OSTrap 1-ToolTrap
BEQ.S @1
_SetTrapAddress newTool
BRA.S @3
@1
_SetTrapAddress newOS
@3
JMP (A1)
;FUNCTION GetOSTrapAddress(trapNum: INTEGER): LongInt;
GetOSTrapAddress FUNC EXPORT
MOVE.L (SP)+,A1 ;return address
MOVE.W (SP)+,D0 ;trap word
_GetTrapAddress newOS
MOVE.L A0,(SP) ;return corresponding address
JMP (A1)
;PROCEDURE SetOSTrapAddress(trapAddr: LongInt; trapNum: INTEGER);
SetOSTrapAddress FUNC EXPORT
MOVE.L (SP)+,A1 ;return address
MOVE.W (SP)+,D0 ;trap number
MOVE.L (SP)+,A0 ;address
_SetTrapAddress newOS
JMP (A1)
;FUNCTION GetToolTrapAddress(trapNum: INTEGER): LongInt;
;FUNCTION GetToolboxTrapAddress(trapNum: INTEGER): LongInt;
GetToolTrapAddress FUNC EXPORT
EXPORT GetToolboxTrapAddress
GetToolboxTrapAddress
MOVE.L (SP)+,A1 ;return address
MOVE.W (SP)+,D0 ;trap word
_GetTrapAddress newTool
MOVE.L A0,(SP) ;return corresponding address
JMP (A1)
;PROCEDURE SetToolTrapAddress(trapAddr: LongInt; trapNum: INTEGER);
;PROCEDURE SetToolboxTrapAddress(trapAddr: LongInt; trapNum: INTEGER);
SetToolTrapAddress FUNC EXPORT
EXPORT SetToolboxTrapAddress
SetToolboxTrapAddress
MOVE.L (SP)+,A1 ;return address
MOVE.W (SP)+,D0 ;trap number
MOVE.L (SP)+,A0 ;address
_SetTrapAddress newTool
JMP (A1)
;FUNCTION WriteParam: OsErr;
WriteParam FUNC EXPORT
LEA SysParam,A0 ;pointer to buffer to write to c chip
MOVEQ #-1,D0
_WriteParam
MOVE.W D0,4(SP) ;return error
RTS
;FUNCTION ReadDateTime(VAR time: LongInt):OsErr;
ReadDateTime PROC EXPORT
MOVE.L (SP)+,A1 ;get the return address
MOVE.L (SP)+,A0 ;get the parameter
_ReadDateTime
MOVE.W D0,(SP) ;return error
JMP (A1)
;PROCEDURE GetDateTime(VAR secs: LongInt);
GetDateTime PROC EXPORT
MOVE.L (SP)+,A1 ;get the return address
MOVE.L (SP)+,A0 ;get the parameter
MOVE.L Time,(A0)
JMP (A1)
; FUNCTION SetDateTime(time: LongInt):OsErr;
SetDateTime PROC EXPORT
MOVE.L (SP)+,A0 ;get the return address
MOVE.L (SP)+,D0 ;get the parameter
_SetDateTime
MOVE.W D0,(SP) ;return error
JMP (A0)
;PROCEDURE SetTime(d: DateArray);
SetTime PROC EXPORT
MOVE.L (SP)+,A1 ;get the return address
MOVE.L (SP)+,A0 ;get the parameter
_Date2Secs ;D0 = seconds since 1904
_SetDateTime ;clock = seconds since 1904
JMP (A1)
;PROCEDURE GetTime(VAR d: DateTimeRec);
GetTime PROC EXPORT
MOVE.L (SP)+,A1 ;get the return address
MOVE.L (SP)+,A0 ;get the parameter
MOVE.L Time,D0 ;get time from low memory
_Secs2Date
JMP (A1)
;PROCEDURE DateToSeconds(d: DateArray; VAR s: LongInt);
DateToSeconds PROC EXPORT
export Date2Secs ; obsolete old procedure name
Date2Secs
MOVEA.L 8(SP),A0 ;A0=date
_Date2Secs ;D0=seconds elapsed
MOVEM.L (SP)+,D1/A0-A1 ;D1=ret, A0=intptr, A1=date
MOVE.L D0,(A0) ;deliver result
MOVEA.L D1,A0 ;ret addr
JMP (A0)
;PROCEDURE SecondsToDate(s: LongInt; VAR d: DateArray);
SecondsToDate PROC EXPORT
export Secs2Date ; obsolete old procedure name
Secs2Date
MOVEM.L (SP)+,D0/A0-A1 ;D0=ret, A0=date, A1=s
MOVE.L D0,-(SP) ;restore return addr
MOVE.L A1,D0 ;place D0=s
_Secs2Date ;convert D0 to A0
RTS
;PROCEDURE Delay(numTicks: LongInt; VAR finalTicks: LongInt);
Delay PROC EXPORT
MOVE.L (SP)+,D0 ;get the return address
MOVE.L (SP)+,A1 ;ptr to where to return result
MOVE.L (SP)+,A0 ;numTicks
MOVE.L D0,-(SP) ;restore return address
_Delay
MOVE.L D0,(A1) ;return value of ticks after delay
RTS
;FUNCTION EqualString(str1,str2: OsStr255; caseSens,diacSens: BOOLEAN):BOOLEAN;
EqualString FUNC EXPORT
MOVE.L str1(SP),A0 ;ptr to str1
MOVE.L str2(SP),A1 ;ptr to str2
MOVEQ #0,D0
MOVE.B (A0)+,D0 ;str1 length
SWAP D0
MOVE.B (A1)+,D0 ;str2 length
;depending on value of booleans, make proper call
TST.B diacSens(SP) ;value of diacSens
BEQ.S @2 ;strip diacriticals
TST.B caseSens(SP) ;value of caseSens
BEQ.S @1 ;ignore case
_CmpString ,case ;both diacritical and case sensitive
BRA.S strDone
@1 _CmpString ;diacritical sensitive,map to upper case
BRA.S strDone
;strip diacriticals
@2 TST.B caseSens(SP) ;case sensitive?
BEQ.S @3
_CmpString ,marks,case ;ignore diacrits, case sensitive
BRA.S strDone
@3 _CmpString marks ;ignore diacrits and map to upper case
strDone EORI.B #1,D0 ;take opposite of what cmpString returns
MOVE.B D0,result(SP) ;return result
MOVE.L (SP)+,A0 ; rtn addr
LEA parmSize(SP),SP ; pop args
JMP (A0)
;PROCEDURE UprString(VAR theString: OsStr255; diacSens: BOOLEAN);
UprString PROC EXPORT
MOVE.L (SP)+,A1 ;get the return address
MOVE.B (SP)+,D1 ;diacritical sensitivity bool
MOVE.L (SP)+,A0 ;ptr to string to canonize
MOVEQ #0,D0
MOVE.B (A0)+,D0 ;string length
MOVE.L A1,-(SP) ;restore return address
;decide which flavor of uprString to call and call it
TST.B D1
BEQ.S @1 ;ignore diacriticals
_UprString ;keep diacriticals
BRA.S @2
@1 _UprString ,marks
@2 RTS
;PROCEDURE Enqueue(qElement: QElemPtr; qHeader: QHdrPtr);
Enqueue PROC EXPORT
MOVE.L (SP)+,D0
MOVE.L (SP)+,A1
MOVE.L (SP)+,A0
MOVE.L D0,-(SP)
_EnQueue
RTS
;FUNCTION Dequeue(qElement: QElemPtr; qHeader: QHdrPtr): OsErr;
Dequeue PROC EXPORT
MOVE.L (SP)+,D0
MOVE.L (SP)+,A1
MOVE.L (SP)+,A0
MOVE.L D0,-(SP)
_DeQueue
MOVE.W D0,4(SP) ;return error
RTS
;PROCEDURE Environs(VAR rom,machine: INTEGER);
Environs PROC EXPORT
MOVE.L (SP)+,A0 ;get rts
MOVE.L ROMBase,A1 ;ROM start
ADDQ #8,A1 ;offset to version
MOVE (A1),D0 ;get the version
MOVE.L (SP)+,A1 ;get machine VAR address
CLR (A1) ;assume it's a Lisa
CMP.B #$FF,D0 ;is it?
BEQ.S @0
ROR #8,D0 ;get machine into low byte
ADDQ.B #1,D0 ;turn into a Mac
MOVE.B D0,1(A1) ;set the machine parameter
@0 LSR #8,D0 ;get Lisa ROM version down
MOVE.L (SP)+,A1 ;get ROM VAR address
MOVE D0,(A1) ;return the ROM version
JMP (A0)
;FUNCTION GetDCtlEntry(refNum: INTEGER): DCtlHandle;
; Did status 1 call to get the DCEHandle... However, hard disk
; didn't know how to handle this and would crash. Now, at the
; suggestion of Jim Friedlander, I will go directly to the UnitTable
; to get the handle 12 Jun 87 - KLH
GetDCtlEntry FUNC EXPORT
MOVE.L (SP)+,A0 ; return address
MOVE.W (SP)+,D0 ; refNum
clr.l (sp) ; default result to nil <10>
NOT.W D0 ; unit entry := -1 * (refNum + 1) <10>
cmp.w UnitNtryCnt,d0 ; is there an entry of this number? <10>
bhs.s @noEntry ; no, so return NIL <10>
LSL.W #2,D0 ; index := entry * 4
MOVE.L UTableBase,A1 ; unit I/O table [pointer]
MOVE.L 0(A1,D0.W),(SP) ; return DCtlHandle
@noEntry
JMP (A0) ; RTS
;FUNCTION SetChooserAlert(f: BOOLEAN): BOOLEAN;
SetChooserAlert FUNC EXPORT
MOVE.L (SP)+,A0 ; return address
MOVE.B (SP)+,D0 ; get boolean parameter
BEQ.S @3
BSET #psAlert,HiliteMode ; now set flag true
BRA.S @5
@3 BCLR #psAlert,HiliteMode ; else set flag false
@5 SEQ d0 ; d0 = FF if it was 0, 0 if it was 1 <10>
ADDQ.B #1,d0 ; d0.b = 0 if it was 0, 1 if it was 1 <10>
move.b d0,(sp) ; set that flag <10>
JMP (A0)
;
; from ioTRAPS.TEXT -- Mac OS io Interface routines for Pascal
;
; Argument- A0: param: Points to Parameter block.
;
; Results- D0: ec: error code.
; <0: OS Call failed.
; 0: All is well.
; Registers- D0: ec: error code
; A0: param: Paramater list address.
; A1: ra: Return Address.
;
MACRO
OSCall
Move.L (SP)+,A1 ;get return address
.**** check this out thoroughly before changing
Move.B (SP)+,D0 ;Get ASync flag. (why was this a word?)
Move.L (SP)+,A0 ;get param pointer.
BNE.S @1
.*
&SysLst[1] ;tell OS to do it Synchronously
BrA.S @2
.*
@1 &SysLst[1] ,async ;Tell OS to do it Asynchronously
@2 Move.W D0,(SP) ;save result
Jmp (A1) ;return to caller
ENDM
; interface routines expecting a parameter block ptr as argument
; hence the prefix PB
;
; FUNCTION PBOpen(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBClose(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBRead(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBWrite(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBControl(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBStatus(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBKillio(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
;
PBOpen PROC EXPORT
OSCall _Open
PBClose PROC EXPORT
OSCall _Close
PBRead PROC EXPORT
OSCall _Read
PBWrite PROC EXPORT
OSCall _Write
PBControl PROC EXPORT
OSCall _Control
PBStatus PROC EXPORT
OSCall _Status
PBKillio PROC EXPORT
OSCall _Killio
; FUNCTION PBGetVInfo(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBGetVol(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBSetVol(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBFlushVol(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBCreate(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBDelete(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBOpenRF(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBRename(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBGetFInfo(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBSetFInfo(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBSetFLock(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBRstFLock(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBSetFVers(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBAllocate(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBGetEOF(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBSetEOF(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBGetFPos(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBSetFPos(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
; FUNCTION PBFlushFile(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
PBGetVInfo PROC EXPORT
OSCall _GetVolInfo
PBGetVol PROC EXPORT
OSCall _GetVol
PBSetVol PROC EXPORT
OSCall _SetVol
PBFlushVol PROC EXPORT
OSCall _FlushVol
PBCreate PROC EXPORT
OSCall _Create
PBDelete PROC EXPORT
OSCall _Delete
PBOpenRF PROC EXPORT
OSCall _OpenRF
PBRename PROC EXPORT
OSCall _Rename
PBGetFInfo PROC EXPORT
OSCall _GetFileInfo
PBSetFInfo PROC EXPORT
OSCall _SetFileInfo
PBSetFLock PROC EXPORT
OSCall _SetFilLock
PBRstFLock PROC EXPORT
OSCall _RstFilLock
PBSetFVers PROC EXPORT
OSCall _SetFilType
PBAllocate PROC EXPORT
OSCall _Allocate
PBGetEOF PROC EXPORT
OSCall _GetEOF
PBSetEOF PROC EXPORT
OSCall _SetEOF
PBGetFPos PROC EXPORT
OSCall _GetFPos
PBSetFPos PROC EXPORT
OSCall _SetFPos
PBFlushFile PROC EXPORT
OSCall _FlushFile
; MountVolume, UnMountVolume, Eject, Offline calls can only be made synchronously
; FUNCTION PBMountVol(paramBlock: ParmBlkPtr): OsErr;
; FUNCTION PBUnMountVol(paramBlock: ParmBlkPtr): OsErr;
; FUNCTION PBEject(paramBlock: ParmBlkPtr): OsErr;
; FUNCTION PBOffLine(paramBlock: ParmBlkPtr): OsErr;
PBMountVol PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get param pointer.
_MountVol ;tell OS to do it Synchronously
Move.W D0,(SP) ;save result
Jmp (A1) ;return to caller
PBUnMountVol PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get param pointer.
_UnMountVol ;tell OS to do it Synchronously
Move.W D0,(SP) ;save result
Jmp (A1) ;return to caller
PBEject PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get param pointer.
_Eject ;tell OS to do it Synchronously
Move.W D0,(SP) ;save result
Jmp (A1) ;return to caller
PBOffLine PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get param pointer.
_Offline ;tell OS to do it Synchronously
Move.W D0,(SP) ;save result
Jmp (A1) ;return to caller
; PROCEDURE AddDrive(drvrRefNum: INTEGER; drvNum: INTEGER; QEl: drvQElPtr);
AddDrive PROC EXPORT
MOVE.L (SP)+,A1 ;get return address
MOVE.L (SP)+,A0 ;ptr to memory for queue element
MOVE.L (SP)+,D0 ;drive number
_AddDrive
JMP (A1)
;FUNCTION FSOpen(fileName: Str255; versNum: SignedByte; vRefNum: INTEGER; VAR refNum: INTEGER): OSErr;
;Always try to use OpenDF (which does not open drivers) first. If it doesn’t work, then do a
;normal Open (this is for old systems that do not implement OpenDF).
FSOpen FUNC EXPORT
EXPORT OpenDF
OpenDF
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 14(A6),ioFileName(A0) ; set ptr to filename
MOVE.W 12(A6),ioDrvNum(A0) ; drive number
CLR.B ioFileType(A0) ; file type
CLR.B ioPermssn(A0) ; open for read/write
CLR.L ioOwnBuf(A0) ; use system buffer
_OpenDF
cmp.w #paramErr,d0 ; paramErr indicates that this OpenDF is not implemented
bne.s @continue
_Open ; use the old-style open
@continue
MOVE.L 8(A6),A1 ; return the refnum
MOVE ioRefNum(A0),(A1)
MOVE D0,18(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A0 ; return address
LEA 10(SP),SP ; fix up stack
JMP (A0)
;FUNCTION FSClose(refNum: INTEGER): OsErr;
FSClose FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE 8(A6),ioRefNum(A0) ; get the refnum param
_Close
MOVE D0,10(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A0 ; return address
ADDQ.L #2,SP ; fix up stack
JMP (A0)
;FUNCTION FSRead(refNum: INTEGER; VAR count: LongInt; buffPtr: Ptr): OsErr;
;FUNCTION FSWrite(refNum: INTEGER; VAR count: LongInt; buffPtr: Ptr): OsErr;
FSRead FUNC EXPORT
EXPORT FSWrite
SF D1 ; set up read
BRA.S DoBlk
FSWrite
ST D1 ; set up write
DoBlk
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 8(A6),ioBuffer(A0) ; buffer address
MOVE.W 16(A6),ioRefNum(A0) ; refnum
MOVE.L 12(A6),A1 ; address of the count
MOVE.L (A1),ioByteCount(A0) ; read count
CLR.W ioPosMode(A0) ; no special mode
CLR.L ioPosOffset(A0) ; clear offset
TST.B D1 ; look for read or write
BNE.S @1
_READ
BRA.S @2
@1 _WRITE
@2
MOVE D0,18(A6) ; return the result code
MOVE.L 12(A6),A1 ; address of the count
MOVE.L ioNumDone(A0),(A1) ; return count read
UNLK A6
MOVE.L (SP)+,A1 ; return address
LEA 10(SP),SP ; fix up stack
JMP (A1)
;FUNCTION Control(refNum: INTEGER; csCode: INTEGER; csParamPtr: Ptr): OsErr;
Control FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 14(A6),ioRefNum(A0) ; refnum
MOVE.W 12(A6),csCode(A0) ; the control operation to be performed
TST.L 8(A6) ; see if there is a parameter block
BEQ.S @1 ; if not, don't bother copying one
LEA csParam(A0),A1 ; dest address of op specific params
MOVE.L 8(A6),A0 ; src address of op specific params
MOVEQ #22,D0 ; max number of bytes to be moved
_BlockMove ; copy the op specific params
LEA -ioQElSize(A6),A0 ; put cmd block addr back into A0
@1 _CONTROL
MOVE D0,16(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #8,SP ; fix up stack
JMP (A1)
;FUNCTION Status(refNum: INTEGER; csCode: INTEGER; csParamPtr: Ptr): OsErr;
Status FUNC EXPORT ;analogous to MacControl but returns
;opParams rather than expecting it as arg
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 14(A6),ioRefNum(A0) ; refnum
MOVE.W 12(A6),csCode(A0) ; the control operation to be performed
_STATUS
MOVE D0,16(A6) ; return the result code
LEA csParam-ioQElSize(A6),A0 ;ptr to the status information
MOVE.L 8(A6),A1 ; ptr to where to put this information
MOVEQ #22,D0 ; max number of bytes to be moved
_BlockMove ; copy the op specific params
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #8,SP ; fix up stack
JMP (A1)
;FUNCTION KillIO(refNum: INTEGER): OsErr;
KillIO FUNC EXPORT
LINK A6,#-32 ;get space for control p-block
MOVE.L SP,A0 ;point A0 at the block
MOVE.W 8(A6),ioRefNum(A0) ; refnum
_KillIO ; make the control call
MOVE D0,10(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ #2,SP ; fix up stack
JMP (A1)
;FUNCTON GetVInfo(drvNum: INTEGER; volName: StringPtr; VAR vRefNum: INTEGER; VAR freeBytes: LongInt): OsErr;
GetVInfo FUNC EXPORT
LINK A6,#-ioHVQElSize ; BUG FIX, NEED MORE ROOM FOR HParamBlock
MOVE.L SP,A0 ; BUG FIX, NEED MORE ROOM FOR HParamBlock
MOVE.L 16(A6),ioVNPtr(A0) ; volume name pointer
MOVE.W 20(A6),ioVDrvNum(A0) ; drive number
CLR.W ioVolIndex(A0) ; no volume queue index
_HGetVInfo ; make the control call
MOVE D0,22(A6) ; return the result code
MOVE.L 12(A6),A1 ; pointer to vRefNum
MOVE.W ioVRefNum(A0),(A1) ; return volume ref num
;now calculate the number of free bytes on the volume by multiplying
;allocation block size * free allocation blocks
;would ideally like to multiply long * integer but since MULU only
;multiplies two ints, to allow for a larger than 16 bit allocation
;block size we shift it right by 9 (since we know it to be a multiple
;of 512 and then shift the result back.
MOVE.L ioVAlBlkSiz(A0),D0 ;num bytes in an allocation block
MOVEQ.L #9,D1 ;shift over by 8
ASR.L D1,D0 ;and one more
MULU ioVFrBlk(A0),D0 ;multiply by number of free blocks
ASL.L D1,D0 ;shift back to the left
MOVE.L 8(A6),A1 ;pointer to free bytes
MOVE.L D0,(A1) ;return the value
UNLK A6
MOVE.L (SP)+,A1 ; return address
LEA 14(SP),SP ; fix up stack
JMP (A1)
;FUNCTION GetFInfo(fileName: Str255; versNum: SignedByte; vRefNum: INTEGER; VAR fndrInfo: FInfo):OsErr;
GetFInfo FUNC EXPORT
LINK A6,#-ioFQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 14(A6),ioFileName(A0) ; set ptr to filename
MOVE.W 12(A6),ioVRefNum(A0) ; set volume ref num
CLR.B ioFileType(A0) ; (version field)
CLR.W ioFDirIndex(A0) ;clear directory index
_GetFileInfo ;get the info
MOVE D0,18(A6) ; return the result code
;transfer the user defined finder info words (16 bytes) into result
LEA ioFlUsrWds(A0),A0 ;where to copy from
MOVE.L 8(A6),A1 ;where to copy to
MOVEQ #16,D0 ; 16 bytes of information
_BlockMove
UNLK A6
MOVE.L (SP)+,A1 ; return address
LEA 10(SP),SP ; fix up stack
JMP (A1)
;FUNCTION GetVol(volName: StringPtr; VAR vRefNum: INTEGER):OsErr;
GetVol FUNC EXPORT
LINK A6,#-ioVQElSize ; get space for control p-block
MOVE.L SP,A0 ; point A0 at the block
MOVE.L 12(A6),ioVNPtr(A0) ; pointer to volume name pointer
_GetVol ; make the control call
MOVE D0,16(A6) ; return the result code
MOVE.L 8(A6),A1 ; pointer to drive number
MOVE.W ioVRefNum(A0),(A1) ; return drive number
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #8,SP ; fix up stack
JMP (A1)
;FUNCTION SetVol(volName: StringPtr; vRefNum: INTEGER): OsErr;
SetVol FUNC EXPORT
LINK A6,#-ioVQElSize ;get space for control p-block
MOVE.L SP,A0 ; point A0 at the block
MOVE.L 10(A6),ioVNPtr(A0) ; ptr to desired volume name
MOVE.W 8(A6),ioVRefNum(A0) ; desired default drive number
_SetVol ; make the control call
MOVE D0,14(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;FUNCTION UnmountVol(VolName: StringPtr; vRefNum: INTEGER):OsErr;
UnMountVol FUNC EXPORT
LINK A6,#-ioVQElSize ;get space for control p-block
MOVE.L SP,A0 ; point A0 at the block
MOVE.W 8(A6),ioVRefNum(A0) ; drive to be unmounted
MOVE.L 10(A6),ioVNPtr(A0) ; volume name pointer
_UnmountVol
MOVE D0,14(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;FUNCTION Eject(VolName: StringPtr; vRefNum: INTEGER): OSErr;
Eject FUNC EXPORT
LINK A6,#-ioVQElSize ; get space for control p-block
MOVE.L SP,A0 ; point A0 at the block
MOVE.W 8(A6),ioVRefNum(A0) ; drive to be unmounted
MOVE.L 10(A6),ioVNPtr(A0) ; volume name pointer
_Eject
MOVE D0,14(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;FUNCTION FlushVol(VolName: StringPtr; vRefNum: INTEGER): OSErr;
FlushVol FUNC EXPORT
LINK A6,#-ioVQElSize ; get space for control p-block
MOVE.L SP,A0 ; point A0 at the block
MOVE.W 8(A6),ioVRefNum(A0) ; drive to be unmounted
MOVE.L 10(A6),ioVNPtr(A0) ; volume name pointer
_FlushVol
MOVE D0,14(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;FUNCTION Create(fileName: Str255; vRefNum: INTEGER; creator: OSType; fileType: OSType): OSErr;
Create FUNC EXPORT
LINK A6,#-ioFQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 18(A6),ioFileName(A0) ; set ptr to filename
MOVE.W 16(A6),ioVRefNum(A0) ; set volume ref num
CLR.B ioFileType(A0) ; clear type, permissions (version field)
_Create
BNE.S crDone ;yes, don't bother setting type
CLR.W ioFDirIndex(A0) ;clear directory index
_GetFileInfo ;get the previous info
BNE.S crDone ;if we failed, return error <10>
;transfer the user defined finder info words (16 bytes)
LEA ioFlUsrWds(A0),A1 ;where to copy user words
MOVE.L 8(A6),(A1)+ ;enter in the new file type
MOVE.L 12(A6),(A1) ;enter in the new file creator
_SetFileInfo
crDone
MOVE D0,22(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
LEA 14(SP),SP ; fix up stack
JMP (A1)
;FUNCTION FSDelete(fileName: OsStr255; vRefNum: INTEGER):OsErr;
FSDelete FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 10(A6),ioFileName(A0) ; set ptr to filename
MOVE.W 8(A6),ioVRefNum(A0) ; set volume ref num
CLR.B ioFileType(A0) ; clear type, permissions (version field)
_Delete
MOVE D0,14(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;FUNCTION OpenRF(fileName: Str255; vRefNum: INTEGER; VAR refNum: INTEGER): OSErr;
OpenRF FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 14(A6),ioFileName(A0) ; set ptr to filename
MOVE.W 12(A6),ioVRefNum(A0) ; set volume ref num
CLR.B ioFileType(A0) ; clear type, permissions (version field)
CLR.B ioPermssn(A0) ; open for read/write
CLR.L ioOwnBuf(A0) ; use system buffer
_OpenRF
MOVE D0,18(A6) ; return the result code
MOVE.L 8(A6),A1 ; ptr to refNum
MOVE.W ioRefNum(A0),(A1) ; return the refNum
UNLK A6
MOVE.L (SP)+,A1 ; return address
LEA 10(SP),SP ; fix up stack
JMP (A1)
;FUNCTION Rename(oldName: Str255; vRefNum: INTEGER; newName: Str255):OsErr;
Rename FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 14(A6),ioFileName(A0) ; set ptr to filename
MOVE.W 12(A6),ioVRefNum(A0) ; set volume ref num
CLR.B ioFileType(A0) ; clear type, permissions (version field)
MOVE.L 8(A6),ioNewName(A0) ; new name to give to file
_Rename
MOVE D0,18(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
LEA 10(SP),SP ; fix up stack
JMP (A1)
;FUNCTION SetFInfo(fileName: Str255; vRefNum: INTEGER; fndrInfo: FInfo): OSErr;
SetFInfo FUNC EXPORT
LINK A6,#-ioFQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 14(A6),ioFileName(A0) ; set ptr to filename
MOVE.W 12(A6),ioVRefNum(A0) ; set volume ref num
CLR.B ioFileType(A0) ; (version field)
CLR.W ioFDirIndex(A0) ;clear directory index
_GetFileInfo ;get the previous info
;transfer the user defined finder info words (16 bytes)
LEA ioFlUsrWds(A0),A1 ;where to copy user words
MOVE.L 8(A6),A0 ;where the user words are now
MOVEQ #16,D0 ; 16 bytes of information
_BlockMove
MOVE.L SP,A0 ;restore A0
_SetFileInfo
MOVE D0,18(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
LEA 10(SP),SP ; fix up stack
JMP (A1)
;FUNCTION SetFLock(fileName: Str255; vRefNum: INTEGER): OSErr;
SetFLock FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 10(A6),ioFileName(A0) ; set ptr to filename
MOVE.W 8(A6),ioVRefNum(A0) ; set volume ref num
CLR.B ioFileType(A0) ; clear type, permissions (version field)
_SetFilLock
MOVE.W D0,14(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;FUNCTION RstFLock(fileName: Str255; vRefNum: INTEGER): OSErr;
RstFLock FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 10(A6),ioFileName(A0) ; set ptr to filename
MOVE.W 8(A6),ioVRefNum(A0) ; set volume ref num
CLR.B ioFileType(A0) ; clear type, permissions (version field)
_RstFilLock
MOVE.W D0,14(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;FUNCTION Allocate(refNum: INTEGER; VAR count: LongInt): OSErr;
Allocate FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.L 8(A6),A1 ;ptr to requested byte count
MOVE.L (A1),ioReqCount(A0)
MOVE.W 12(A6),ioRefNum(A0) ; set refnum
_Allocate
MOVE D0,14(A6) ; return the result code
MOVE.L ioActCount(A0),(A1) ; return actual byte count
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;FUNCTION GetEOF(refNum: INTEGER; VAR LogEOF: LongInt): OSErr;
GetEOF FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 12(A6),ioRefNum(A0) ; set refnum
_GetEOF
MOVE D0,14(A6) ; return the result code
MOVE.L 8(A6),A1 ;ptr to logical length variable
MOVE.L ioLEOF(A0),(A1) ;return logical end of file
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;FUNCTION SetEOF(refNum: INTEGER; logEOF: LongInt): OSErr;
SetEOF FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 12(A6),ioRefNum(A0) ; set refnum
MOVE.L 8(A6),ioLEOF(A0) ; the desired end of file
_SetEOF
MOVE D0,14(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;
;FUNCTION GetFPos(refNum: INTEGER; VAR filePos: LongInt):OsErr;
;
GetFPos FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 12(A6),ioRefNum(A0) ; set refnum
_GetFPos
MOVE D0,14(A6) ; return the result code
MOVE.L 8(A6),A1 ;ptr to logical length variable
MOVE.L ioPosOffset(A0),(A1) ;return logical end of file
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #6,SP ; fix up stack
JMP (A1)
;FUNCTION SetFPos(refNum: INTEGER; posMode: INTEGER; posOff: LongInt): OSErr;
SetFPos FUNC EXPORT
LINK A6,#-ioQElSize ; make room on stack for cmd block
MOVE.L SP,A0 ; address of cmd block
MOVE.W 14(A6),ioRefNum(A0) ; set refnum
MOVE.W 12(A6),ioPosMode(A0) ; positioning information
MOVE.L 8(A6),ioPosOffset(A0) ; new file position
_SetFPos
MOVE D0,16(A6) ; return the result code
UNLK A6
MOVE.L (SP)+,A1 ; return address
ADDQ.L #8,SP ; fix up stack
JMP (A1)
;FUNCTION GetVRefNum(fileRefNum: INTEGER; VAR vRefNum: INTEGER):OSErr;
;
; There was originally checking for valid refnums. However, when we went to
; HFS from MFS, the block size changed and the checking was commented out. This
; allowed some error to creep in, so we put INTELLIGENT checking back in. We
; check the size a block should be first! 9 Aug 88 - KLH
GetVRefNum FUNC EXPORT
MOVE.L (SP)+,A1 ;return addr
MOVEQ #0,D1 ;clear high word
MOVE.W 4(SP),D1 ;get the fileRefNum
MOVE.L FCBSPtr,A0 ;ptr to file-control-block buffer
MOVE.W FSFCBLen,D0 ;get size of file control blocks
BMI.S mfs ;-1 => MFS, so use fixed size
DIVU D0,D1 ;see if valid refnum
BRA.S hfs ; go test results
mfs DIVU #fcbEntLen,D1 ;old way: use fixed block size
hfs SWAP D1 ;continue with divide analysis: remainder
SUBQ.W #2,D1 ; should have been 2 for # of blocks.
BNE.S endError
MOVE.W 4(SP),D0 ;get fileRefNum again.
CMP.W (A0),D0 ;is refNum too large?
BCC.S endError ;br if so
MOVE.L fcbVPtr(A0,D0),A0 ;get ptr to volume control block
MOVE.W vcbVRefNum(A0),D0 ;return vRefNum
MOVEQ #0,D1 ;no err
BRA.S endG
endError MOVEQ #0,D0 ;default refum
MOVE #rfNumErr,D1 ;ref num error
endG MOVE.L (SP),A0 ;get vRefNum address
MOVE D0,(A0) ;put it there
ADDQ #6,SP ;remove passed parameters
MOVE D1,(SP) ;post the error
JMP (A1) ;go home
;_______________________________________________________________________
;
; Function: This section contains the Hierarchical File System trap macros.
;_______________________________________________________________________
;FUNCTION PBOpenWD(paramBlock: WDPBPtr; aSync: BOOLEAN): OsErr;
PBOpenWD PROC EXPORT
OSCall _OpenWD
;FUNCTION PBCloseWD(paramBlock: WDPBPtr; aSync: BOOLEAN): OsErr;
PBCloseWD PROC EXPORT
OSCall _CloseWD
;FUNCTION PBHSetVol(paramBlock: WDPBPtr; aSync: BOOLEAN): OsErr;
PBHSetVol PROC EXPORT
OSCall _HSetVol
;FUNCTION PBHGetVol(paramBlock: WDPBPtr; aSync: BOOLEAN): OsErr;
PBHGetVol PROC EXPORT
OSCall _HGetVol
;FUNCTION PBCatMove(paramBlock: CMovePBPtr; aSync: BOOLEAN): OsErr;
PBCatMove PROC EXPORT
OSCall _CatMove
;FUNCTION PBDirCreate(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBDirCreate PROC EXPORT
OSCall _DirCreate
;FUNCTION PBGetWDInfo(paramBlock: WDPBPtr; aSync: BOOLEAN): OsErr;
PBGetWDInfo PROC EXPORT
OSCall _GetWDInfo
;FUNCTION PBGetFCBInfo(paramBlock: FCBPBPtr; aSync: BOOLEAN): OsErr;
PBGetFCBInfo PROC EXPORT
OSCall _GetFCBInfo
;FUNCTION PBGetCatInfo(paramBlock: CInfoPBPtr; aSync: BOOLEAN): OsErr;
PBGetCatInfo PROC EXPORT
OSCall _GetCatInfo
;FUNCTION PBSetCatInfo(paramBlock: CInfoPBPtr; aSync: BOOLEAN): OsErr;
PBSetCatInfo PROC EXPORT
OSCall _SetCatInfo
;FUNCTION PBAllocContig(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
PBAllocContig PROC EXPORT
OSCall _AllocContig
;FUNCTION PBLockRange(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
PBLockRange PROC EXPORT
OSCall _LockRng
;FUNCTION PBUnLockRange(paramBlock: ParmBlkPtr; aSync: BOOLEAN): OsErr;
PBUnLockRange PROC EXPORT
OSCall _UnLockRng
;FUNCTION PBSetVInfo(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBSetVInfo PROC EXPORT
OSCall _SetVolInfo
;FUNCTION PBHGetVInfo(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBHGetVInfo PROC EXPORT
OSCall _HGetVInfo
;FUNCTION PBHOpen(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBHOpen PROC EXPORT
OSCall _HOpen
;FUNCTION PBHOpenRF(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBHOpenRF PROC EXPORT
OSCall _HOpenRF
;FUNCTION PBHCreate(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBHCreate PROC EXPORT
OSCall _HCreate
;FUNCTION PBHDelete(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBHDelete PROC EXPORT
OSCall _HDelete
;FUNCTION PBHRename(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBHRename PROC EXPORT
OSCall _HRename
;FUNCTION PBHRstFLock(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBHRstFLock PROC EXPORT
OSCall _HRstFLock
;FUNCTION PBHSetFLock(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBHSetFLock PROC EXPORT
OSCall _HSetFLock
;FUNCTION PBHGetFInfo(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBHGetFInfo PROC EXPORT
OSCall _HGetFileInfo
;FUNCTION PBHSetFInfo(paramBlock: hParmBlkPtr; aSync: BOOLEAN): OsErr;
PBHSetFInfo PROC EXPORT
OSCall _HSetFileInfo
;FUNCTION PBHGetVolParms(paramBlock: hParmBlkPtr; async: BOOLEAN): OSErr;
PBHGetVolParms PROC EXPORT
OSCall _GetVolParms
;FUNCTION PBHGetLogInInfo(paramBlock: hParmBlkPtr; async: BOOLEAN): OSErr;
PBHGetLogInInfo PROC EXPORT
OSCall _GetLogInInfo
;FUNCTION PBHGetDirAccess(paramBlock: hParmBlkPtr; async: BOOLEAN): OSErr;
PBHGetDirAccess PROC EXPORT
OSCall _GetDirAccess
;FUNCTION PBHSetDirAccess(paramBlock: hParmBlkPtr; async: BOOLEAN): OSErr;
PBHSetDirAccess PROC EXPORT
OSCall _SetDirAccess
;FUNCTION PBHMapID(paramBlock: hParmBlkPtr; async: BOOLEAN): OSErr;
PBHMapID PROC EXPORT
OSCall _MapID
;FUNCTION PBHMapName(paramBlock: hParmBlkPtr; async: BOOLEAN): OSErr;
PBHMapName PROC EXPORT
OSCall _MapName
;FUNCTION PBHCopyFile(paramBlock: hParmBlkPtr; async: BOOLEAN): OSErr;
PBHCopyFile PROC EXPORT
OSCall _CopyFile
;FUNCTION PBHMoveRename(paramBlock: hParmBlkPtr; async: BOOLEAN): OSErr;
PBHMoveRename PROC EXPORT
OSCall _MoveRename
;FUNCTION PBHOpenDeny(paramBlock: hParmBlkPtr; async: BOOLEAN): OSErr;
PBHOpenDeny PROC EXPORT
OSCall _OpenDeny
;FUNCTION PBHOpenRFDeny(paramBlock: hParmBlkPtr; async: BOOLEAN): OSErr;
PBHOpenRFDeny PROC EXPORT
OSCall _OpenRFDeny
PBCreateFileIDRef proc export
OSCall _CreateFileIDRef
PBDeleteFileIDRef proc export
OSCall _DeleteFileIDRef
PBResolveFileIDRef proc export
OSCall _ResolveFileIDRef
PBExchangeFiles proc export
OSCall _ExchangeFiles
PBCatSearch proc export
OSCall _CatSearch
PBGetForeignPrivs proc export
OSCall _GetForeignPrivs
PBSetForeignPrivs proc export
OSCall _SetForeignPrivs
PBOpenDF proc export
OSCall _OpenDF
PBHOpenDF proc export
OSCall _HOpenDF
PBMakeFSSpec proc export
OSCall _MakeFSSpec
; The Desktop Manager param block routines
; PBDTGetPath sync only call has inline glue <9>
; PBDTCloseDown sync only call has inline glue <9>
PBDTAddIcon proc export
OSCall _DTAddIcon
PBDTGetIcon proc export
OSCall _DTGetIcon
PBDTGetIconInfo proc export
OSCall _DTGetIconInfo
PBDTAddAPPL proc export
OSCall _DTAddAPPL
PBDTRemoveAPPL proc export
OSCall _DTRemoveAPPL
PBDTGetAPPL proc export
OSCall _DTGetAPPL
PBDTSetComment proc export
OSCall _DTSetComment
PBDTRemoveComment proc export
OSCall _DTRemoveComment
PBDTGetComment proc export
OSCall _DTGetComment
PBDTFlush proc export
OSCall _DTFlush
PBDTReset proc export
OSCall _DTReset
PBDTGetInfo proc export
OSCall _DTGetInfo
; PBDTOpenInform sync only calls has inline glue <9>
PBDTDelete proc export
OSCall _DTDelete
;The following are the implementation of the event mgr routines that are
;register based as oposed to stack based
;They are included here because they are OSTraps, however the interfaces for
;them are in toolIntf
;
; FUNCTION PostEvent(eventNum: INTEGER; eventMsg: LongInt): OsErr;
PostEvent PROC EXPORT
MOVE.L (SP)+,A1 ;A1 is return address
MOVE.L (SP)+,D0 ;32-bit quantity defined by the event
MOVE.W (SP)+,A0 ;word of event number
_POSTEVENT
MOVE.W D0,(SP) ;return 0=event posted; 1=not posted
JMP (A1)
; FUNCTION PPostEvent(eventCode: INTEGER; eventMsg: LONGINT; VAR qEl: EvQEl): OSErr;
PPostEvent PROC EXPORT
MOVE.L (SP)+,D1 ; return address, for now
MOVE.L (SP)+,A1 ; qEl
MOVE.L (SP)+,D0 ; eventMsg
MOVE.W (SP)+,A0 ; eventCode
MOVE.L D1,-(SP) ; restore return address
_PPostEvent
MOVE.L A0,(A1) ; stuff returned qEl ptr
MOVE.W D0,4(SP) ; stuff return code
RTS
;FUNCTION OSEventAvail(mask: INTEGER; VAR theEvent: EventRecord): BOOLEAN;
OSEventAvail FUNC EXPORT
MOVE.L (SP)+,A1 ;return address
MOVE.L (SP)+,A0 ;user event record
MOVE.W (SP)+,D0 ;event mask (set of events desired)
_OSEventAvail
ADDQ.W #1,D0
MOVE.B D0,(SP)
JMP (A1)
;FUNCTION GetOSEvent(mask: INTEGER; VAR theEvent: EventRecord): BOOLEAN;
GetOSEvent FUNC EXPORT
MOVE.L (SP)+,A1 ;return address
MOVE.L (SP)+,A0 ;user event record
MOVE.W (SP)+,D0 ;event mask (set of events desired)
_GetOSEvent
ADDQ.W #1,D0
MOVE.B D0,(SP)
JMP (A1)
; Sound Manager interface implementation
;
; PROCEDURE SetSoundVol(level: INTEGER);
SetSoundVol PROC EXPORT
MOVE.L (SP)+,A0 ;get return address
MOVE.W (SP)+,D0 ;get the volume
MOVE.L A0,-(SP) ;replace return address
LINK A6,#-32 ;get some space for the control p-block
MOVE.L SP,A0 ;point A0 at the block
MOVE.W #-4,ioRefNum(A0) ;set up the sound driver refNum
MOVE.W #2,csCode(A0) ;set up the control "opCode"
MOVE.W D0,csParam(A0) ;set up event ptr as parameter
_Control immed ;make the control call
UNLK A6 ;de-allocate parameter block
RTS
; PROCEDURE GetSoundVol(VAR level: INTEGER);
; actually, SdVolume is a byte.
GetSoundVol PROC EXPORT
MOVE.L (SP)+,A0 ;get return address
MOVE.L (SP)+,A1 ;ptr to result
CLR.B (A1)+ ;clear high byte
MOVE.B SdVolume,(A1) ;return volume level in low byte
JMP (A0)
;PROCEDURE StartSound(synthRec: Ptr; numBytes: LongInt; CompletionRtn: ProcPtr);
StartStuff PROC EXPORT
EXPORT StartSound, StopSound
;realSize set to 0 means that the parameter block is busy; the competion routine can
;not be executed while the sound handle is inconsistent
myPBlock EQU 0 ;50 bytes total, init ioResult to be NIL
realSize EQU myPBlock+50 ;what SetHandleSize means in a completion routine
IAZ EQU realSize+2 ;salted away IAZNotify routine
intrupt EQU IAZ+4 ;an interrupt routine tried to execute?
noIntrupt EQU intrupt+1 ;interrupt routines not allowed to execute
blkSize EQU noIntrupt+1
;set up the parameter block if it is free, otherwise queue up the request
;note that synchronous calls do not get queued up. We just loop around
;until all pending calls are done and then make the call. This is because
;you cannot start up a synchronous call in a VBL task
;
; 13mar87 - There was a bug in StartSound that moved only half of MinusOne
; into SoundHdl, so the following StartSound would fail the CMPA.L MinusOne
; test. That was fixed by doing a MOVE.L MinusOne,SoundHdl down by ThrowAway.
; However, code using the original incorrect glue will still break future
; applications, so we now test only for the upper half of SoundHdl having
; -1 in it. Extra work, but bulletproof.
;
; 9 Dec 88 John Dance finds StartSound is leaving a handle locked
; in the middle of the MPW shell application heap. Not all paths through
; Start & StopSound dispose of the handle. Most places that had jumped to
; ssDone (sound done) now include a path to throwAway. - KLH
StartSound
MOVE.L SoundHdl,A0 ;something like $0040 if uninitialized
; Keithen had a CMP.W MinusOne,A0 here, thinking that it checked only the high word of A0.
; Unfortunately all operations on address registers are done on the whole long word, so it
; never worked. Instead, we now use the high bit to tell if it is initialized or not. <10>
move.l a0,d0 ; <10>
BPL.S inited ;a0 != $FFFFFFFF => initialize
MOVEQ #blkSize,D0 ;enough for a single call for starters
_NewHandle ,clear
bne quit ;but can't dispose handle if didn't allocate!
_HLock
MOVE.L A0,SoundHdl ;salt away in low memory for next time
;Install code in IAZNotify so that SoundHdl can be reset to ROMBase when the
;application heap is scrubbed
MOVE.L (A0),A1
MOVE.L IAZNotify,IAZ(A1) ;keep old one so it can be called as well
LEA ClrSoundHdl,A1 ;routine to clean up after we leave
MOVE.L A1,IAZNotify
inited MOVE.L (A0),A1 ;the record mp, always good (not purgable)
TST.W ioResult(A1) ;ioResult is 0 if blk is free
BLE blkFree ;or if an error had occurred
; parameter block is not free, queue this request up if it is asynchronous. If it is
; synchronous, loop until everything else is done and then start it up
; If a completion routine trys to execute while the paramblk handle is being
; increased in size, the data would be inconsistent. To avoid this, a pair of
; flags, intrupt and noIntrupt, arbitrate between the synchronous call
; StartSound and the asynchronous MyCompletion to determine when it is safe for
; MyCompletion to execute. If MyCompletion interrupts StartSound while
; the param block handle is being moved, then MyCompletion is called by
; StartSound after the data is made consistent. A copy of the handle is created
; rather than growing the existing handle since it would be bad for the original
; handle to be locked while it is grown since this would likely fail, and it
; can not be unlocked since ioCore will still try to look at dCtlQHead at
; interrupt time. Also, since a new handle is created each time a new call
; is made, the handle can't be moved high or low since the one already high
; or low can't be freed up until after the new one is locked down.
;
; 9 Dec 88 Test for full -1 in completion routine due to bug reported by
; Jay Zipnick & Brian Baker of ICOM Simulations. Passing a Ptr with the high
; bit set doesn't seem to be a good idea, but isn't necessarily wrong yet. - KLH
MOVE.L 4(SP),D1 ;the completion rtn
; BMI.S sndWait ;oops, what if high bit set, but good address?
CMP.L MinusOne,D0 ; only full -1 => async
Beq.w sndWait ;branch if -1 to handle async <SM3> rb
ST noIntrupt(A1) ;make completion routine do nothing
MOVE realSize(A1),D1
MOVE.L A0,D2 ;save the handle to the old one
MOVEM.L D1/D2,-(SP)
_HandToHand
MOVEM.L (SP)+,D1/D2
TST D0
BNE ssDone
;??? In doing HandToHand & SetHandleSize to add new sound parameter
; block, if there is an error (BNE ssDone): we will do a throwaway,
; but could conceivably have the noIntrupt flags set and a completion
; routine that came in and not executed. So we should have done the
; clearing of flags and testing to see if we needed a completion
; routine executed. ??? Save for re-write of StartSound. 12/12/88
MOVEQ #0,D0
ADD #12,D1 ;make room for the next entry
MOVE D1,D0 ;save the size
_SetHandleSize ;make it bigger (or smaller, or the same)
BNE ssDone ;quit if couldn't do it
_HLock
MOVE.L A0,SoundHdl
MOVE.L (A0),A1 ;ptr to the queue
MOVE.L SoundDCE,A0 ;the sound driver's DCE
MOVE.L A1,dCtlQHead(A0)
MOVE.L A1,dCtlQTail(A0)
MOVE.L D2,A0 ;get back old handle
MOVE.L (A0),A0
MOVE.B intrupt(A0),D0
OR.B D0,intrupt(A1) ;just in case
MOVE.L D2,A0
_DisposHandle
MOVE D1,realSize(A1) ;keep track of real size for completion
BCLR #0,intrupt(A1) ;was it interrupted?
BEQ.S notIntrupt ;everything is just OK
; since routine was interrupted, clear ioResult since copy may have it still
; set busy
CLR ioResult(A1)
JSR myCompletion ;go take care of completion request
notIntrupt
SF noIntrupt(A1) ;allow completion routine to interrupt
ADD D1,A1 ;add in offset to end of prev data
MOVEQ #12,D0 ;number of bytes to copy
SUB D0,A1
LEA 4(SP),A0 ;ptr to the args
_BlockMove
BRA.S quit ;done queueing up, exit
; Index off of ioResult(A1) instead of A0, bug called in to
; Darin Adler. <KLH> 19 Oct 88.
sndWait MOVE.W ioResult(A1),D0 ;see if sound is done yet
BGT.S sndWait ;nope, loop on.
blkFree MOVE.L A1,A0
MOVE #blkSize,realSize(A0)
MOVE.L 8(SP),ioByteCount(A0) ;numbytes
MOVE.L 12(SP),ioBuffer(A0) ;the synthesizer rec
MOVE.W #-4,ioRefNum(A0) ;sound driver refNum
MOVE.L 4(SP),D1 ;the completion rtn
; BPL.S doAsync
CMP.L MinusOne,D1 ; only full -1 => async
Bne.S doAsync ;fall through if -1 to handle synchronous
_Write ;synchronous write
; BRA.S tstDone ;12/9/88 hmm.. why not go right to bsr throwAway?
BRA.S realDone ;must free up handle, even if error.
doAsync MOVE.L D1,ioOwnBuf(A0) ;save their compl rtn in ownBuff
LEA myCompletion,A1 ;my completion routine
MOVE.L A1,ioCompletion(A0)
_Write ,async ;asynchronous write
tstDone TST D0 ;set condition code if error
ssDone BEQ.S quit
realDone BSR.S throwAway ;if an error occurs along the way, just give up
quit MOVE.L (SP)+,A1
ADD #12,SP
JMP (A1)
throwAway
MOVE.L SoundHdl,A0 ;something like $0040 if uninitialized
; CMPA.L MinusOne,A0 ;
CMPA.W MinusOne,A0 ;only compare word to allow for old bug.
BEQ.S goHome ;if already nuked, go on
MOVE.L (A0),A1
MOVE.L IAZ(A1),IAZNotify ;fix up IAZNotify before we go
_DisposHandle
MOVE.L MinusOne,SoundHdl ;and mark low memory as unused
goHome RTS
;
; PROCEDURE StopSound;
;
StopSound
LINK A6,#-32 ;get some space for the control p-block
LEA -32(A6),A0 ;point A0 at the block
MOVE.W #-4,ioRefNum(A0) ;set up the sound driver refNum
_Killio ,immed ;make the control call
;so next StartSound with same Pitch square wave will appear to have different pitch
CLR.W CurPitch ;to fix SoundDriver bug
;now dispose of any pending write calls. Note: The completion routines are not
;called, although Killio normally would; they are just dequeued.
BSR.S throwAway ;get the handle and dispose it
UNLK A6 ;de-allocate parameter block
noMore RTS
ClrSoundHdl
BSR.S StopSound
MOVE.L IAZNotify,D0
BLE.S noMore
MOVE.L D0,A0
JMP (A0) ;otherwise, guess that it is OK to call app's
;the completion routine that gets called when an asynchronous call is through
;note: only asynchronous calls are queued up
myCompletion
MOVEM.L D0-D2/A0-A1,-(SP) ;preserve the regs
goOn MOVE.L SoundHdl,A0
MOVE.L (A0),A0
TST.B noIntrupt(A0) ;can we continue?
BEQ.S @0
ST intrupt(A0) ;we interrupted when we shouldn't have
BRA myCdone ;so do nothing (we'll get recalled later) <SM4> CSS
@0 MOVE realSize(A0),D0 ;get size
MOVE.L ioOwnBuf(A0),D1 ;address of their completion rtn
BEQ.S noCompl ;NIL completion routine
MOVE.L D1,A1 ;the completion routine
MOVEM.L D0/A0,-(SP)
JSR (A1) ;go to it
MOVEM.L (SP)+,D0/A0
noCompl CMP #blkSize,D0 ;is there a pending sound call?
; BEQ.S myCdone ;no queue, just return
; 12/9/88 per John Dance: if no queue, we are really done, so get
; rid of the handle so it won't be locked in the application heap.
BNE.S more
JSR throwAway
BRA.S myCdone
;there is a pending call, copy the parameters into the parm blk
more MOVE.L A0,A1 ;make a copy of it
LEA blkSize(A0),A0
MOVE.L (A0)+,ioOwnBuf(A1) ;their completion routine
MOVE.L (A0)+,ioByteCount(A1) ;numBytes
MOVE.L (A0)+,ioBuffer(A1) ;the synthesizer rec
MOVE.W #-4,ioRefNum(A1) ;sound driver refNum
;now remove the parameters from the queue
MOVEQ #blkSize+12,D1 ;size of handle with 1 pending entry
SUB D1,D0 ;did it have more than 1 entry?
BEQ.S dspQ ;no, just dispose of the handle
MOVE D0,D1 ;save the new size
EXT.L D0 ;clear top half for block move
MOVE.L A0,A1 ;A0 points to next queue entry
SUB #12,A1 ;A1 points to first queue entry
_BlockMove ;shift the bytes up in the queue
ADD #blkSize,D1 ;get back the new size
BRA.S setSize
dspQ MOVEQ #blkSize,D1
setSize MOVE.L SoundHdl,A0 ;get the handle again
MOVE.L (A0),A0
MOVE D1,realSize(A0)
;set up my completion routine and make the write call
complSS LEA myCompletion,A1 ;this completion routine
MOVE.L A1,ioCompletion(A0) ;stuff it
_Write ,async ;start asynchronous write and return
myCdone MOVEM.L (SP)+,D0-D2/A0-A1 ;restore regs
RTS
;global parameter block set up for the user. This allows for general
;async sound driver calls without the user worrying about memory allocation.
;if more than one sound driver call is pending at one time, a handle is created
;which contains a queue of the outstanding calls. These are posted as soon
;as the current calls is completed.
;
;FUNCTION SoundDone: BOOLEAN;
; One outstanding problem with this method; sound can not return an error.
; If ioResult is negative (error condition) then SoundDone returns TRUE.
SoundDone FUNC EXPORT
MOVE.L (SP)+,A1 ;return address
ST (SP) ;$FF, assume that sound is done
MOVE.L SoundHdl,A0 ;$E4 normally points to deep shit
; CMPA.L MinusOne,A0
CMPA.W MinusOne,A0 ;only compare word to allow for old bug.
BEQ.S exitTrue ;no handle if StopSound or sound never called
MOVE.L (A0),A0 ; parameter block
TST.W ioResult(A0) ; see if io is done
SLE (SP) ; if 0 or negative (error), set true
exitTrue
NEG.B (SP) ;turn $00 or $FF into $00 or $01
JMP (A1)
;PROCEDURE CountAppFiles(VAR message: INTEGER; VAR count: INTEGER);
;
CountAppFiles PROC EXPORT
MOVE.L 4(SP),A1
CLR (A1) ;set default count to 0
MOVE.L AppParmHandle,A0 ;the app parm handle
_GetHandleSize ;are we real
TST.L D0
BLE.S CountEnd
MOVE.L (A0),A0 ;deref appParm Handle
MOVE.L 8(SP),A1 ;ptr to message
MOVE.W (A0)+,(A1) ;return the message
MOVE.L 4(SP),A1
MOVE.W (A0),(A1) ;return the count
CountEnd
MOVE.L (SP)+,A0 ;return addr
ADDQ #8,SP
JMP (A0)
;
;PROCEDURE GetAppFiles(index: INTEGER; VAR theFile: AppFile);
;
; fType is set to all 0's if no next file was found or there is no file list
;AppFile = RECORD
; vRefNum: INTEGER;
; ftype: OsType;
; versNum: INTEGER; {versNum in high byte}
; fName: str255;
; END; {appFile}
;appParm has format: message (0/1) for load or print (2 bytes)
; # of entries (2 bytes)
; for each entry: volume refNum (2 bytes)
; type (4 bytes)
; version (2 bytes)
; name- padded to even
GetAppFiles FUNC EXPORT
MOVEM.L A2-A3,-(SP)
MOVE.L 4+8(SP),A1 ;ptr to fileListElem
CLR.L 2(A1) ;assume failure
MOVE.L AppParmHandle,A0 ;get the application parameter handle
_GetHandleSize ;are we real?
TST.L D0
BLE.S getEnd
MOVE.L (A0),A2 ;deref appParm Handle
ADDQ #2,A2 ;skip the msg
MOVE 8+8(SP),D1 ;which entry to go to
CMP (A2)+,D1 ;see if index within limit
BGT.S getEnd
SUBQ #1,D1 ;make index zero based
getLoop BLT.S getEnd ;are we done?
MOVE.L A2,A0 ;where to copy from
MOVEQ #2,D0
ADD.B 8(A0),D0 ;length of string
AND #$FFFE,D0 ;evenize it
ADDQ #8,D0 ;also move refnum,type,versNum
ADD D0,A2 ;move to next
_BlockMove
SUBQ #1,D1
BRA.S getLoop
getEnd MOVEM.L (SP)+,A2-A3 ;save regs
MOVE.L (SP)+,A0
ADDQ #6,SP ;pop args
JMP (A0)
;
;PROCEDURE ClrAppFiles(index: INTEGER);
;
ClrAppFiles PROC EXPORT
MOVE.L AppParmHandle,A0 ;get the application parameter handle
_GetHandleSize ;are we real?
TST.L D0
BLE.S clrEnd
MOVE.L (A0),A0 ;deref appParm Handle
ADDQ #2,A0 ;skip the msg
MOVE 4(SP),D1 ;which entry to go to
CMP (A0)+,D1 ;see if index within limit
BGT.S clrEnd
SUBQ #1,D1 ;make index zero based
clrLoop BLT.S clrEnd ;are we done?
BEQ.S ClrType
MOVEQ #2,D0
ADD.B 8(A0),D0 ;length of string
AND #$FFFE,D0 ;evenize it
ADD #8,D0 ;also move refnum,type,versNum
ADD D0,A0 ;move to next
SUBQ #1,D1
BRA.S clrLoop
ClrType CLR.L 2(A0)
clrEnd
MOVE.L (SP)+,A0
ADDQ #2,SP ;pop args
JMP (A0)
; PROCEDURE SysError(errorCode: INTEGER);
;
;implementation for system error handler (ie. deep sh*t manager)
;
; 2/26/88 KLH SysError calls in C Headers, Pascal Interfaces, and traps.a
; all are inline functions or traps. Nothing comes here, so remove from
; library!
;SysError PROC EXPORT
;
; MOVE.L (SP)+,A0 ;get return address
; MOVE.W (SP)+,D0 ;get error code
; _SysError ;invoke deeep sh*t
; DC.W $A9FF ;don't come back!
;----------------------------------------------------------------------
;
; FUNCTION MaxBlock: LONGINT;
;
; Returns maximum size for a block w/o compacting
;
;
; Arguments:
; none
;
; Entry:
; none
;
; Exit:
; D0.L - size of block that could be allocated
;
MaxBlock FUNC EXPORT
_MaxBlock
MOVE.L D0,4(A7)
RTS
MaxBlockSys FUNC EXPORT ; <10>
_MaxBlock sys
MOVE.L D0,4(A7)
RTS
;----------------------------------------------------------------------
;
; PROCEDURE PurgeSpace (VAR purgeFree, afterPurge: LONGINT);
;
; Returns the sum of free and purgeable bytes in the heap zone, as well
; as the maximum possible contiguous chunk which would be available
; after purging.
;
;
; Arguments:
; purgeFree sum of purgeable and free bytes in zone
; afterPurge maximum possible contiguous space after purge
;
; Entry:
; none
;
; Exit:
; A0 - maximum possible contiguous space after purge
; D0.L - sum of purgeable and free bytes in zone
;
;
PurgeSpace PROC EXPORT
_PurgeSpace
MOVE.L 4(A7),A1 ; get address of afterpurge
MOVE.L A0,(A1) ;
MOVE.L 8(A7),A1 ; get address of purgeFree
MOVE.L D0,(A1)
MOVE.L (A7)+,A1 ; get return address
ADD #8,A7 ; discard 8 bytes
JMP (A1)
;----------------------------------------------------------------------
;
; FUNCTION StackSpace: LONGINT;
;
; Returns remaining stack space available (i.e. space between A7 and HeapEnd.
;
;
; Arguments:
; none
;
; Entry:
; none
;
; Exit:
; D0.L - available stack space
;
StackSpace FUNC EXPORT
_StackSpace
MOVE.L D0,4(A7)
RTS
;----------------------------------------------------------------------
;
; FUNCTION NewEmptyHandle: Handle;
;
; This is an optimized special case of NewHandle. This routine is used
; mainly by the Resource Manager
;
;
; Arguments:
; none
;
; Entry:
; none
;
; Exit:
; A0 - handle to the new block
; D0.L - error code
;
NewEmptyHandle FUNC EXPORT
_NewEmptyHandle
MOVE.L A0,4(A7)
RTS
NewEmptyHandleSys FUNC EXPORT ; <10>
_NewEmptyHandle sys
MOVE.L A0,4(A7)
RTS
;----------------------------------------------------------------------
;
; FUNCTION HGetState(h: Handle): SignedByte;
;
; Given a handle, returns its master pointer's flags byte
;
;
; Arguments:
; h Handle to get state of
;
; Entry:
; A0 - handle
;
; Exit:
; D0.B - flags byte of handle's master pointer
;
HGetState FUNC EXPORT
MOVE.L (A7)+,A1 ; return address
MOVE.L (A7)+,A0 ; h
_HGetState
MOVE.B D0,(A7) ; is this the right byte????
JMP (A1)
;----------------------------------------------------------------------
;
; PROCEDURE HSetState(h:Handle;state: SignedByte);
;
; Given a handle and a flags byte, sets the handle's master pointer's
; flags byte
;
; Arguments:
; h: refers to relocatable block
; byteCount: number of bytes needed in the new block
;
; Entry:
; A0 - handle to set
; D0.B - flags byte
;
; Exit:
; D0.W - error code
;
HSetState PROC EXPORT
MOVE.L (A7)+,A1 ; return address
MOVE.B (A7)+,D0 ; state
MOVE.L (A7)+,A0 ; h
_HSetState
JMP (A1) ; return via A1 (2/4/86 Memerr OK)
;----------------------------------------------------------------------
DTInstall PROC EXPORT
MOVE.L 4(SP),A0 ; Get pointer to defer request block
_DTInstall
MOVE.L (SP)+,A0 ; Get return address off the stack
ADDQ.L #4,SP ; Adjust for parameter
MOVE.W D0,(SP) ; Set the OSErr return value
JMP (A0) ; Return
;----------------------------------------------------------------------
;
; FUNCTION RelString(str1,str2: Str255; caseSens, diacSens: Boolean): integer;
;
; Just like _CmpString, except it indicates sorting order of strings,
; _CmpString only tells whether or not they're equal.
;
;
; Arguments:
; str1 the first string
; str2 the second string
; caseSens case sensitive?
; diacSens sensitive to diacriticals?
;
; Entry:
; A0 - points to first character of first string
; A1 - points to first character of second string
; D0 (Hi Word) length of first string
; D0 (Lo Word) length of second string
;
; Exit:
; D0.L - -1 if first string sorts before second string
; 0 if strings are equal
; 1 if first string sorts after second string
;
RelString FUNC EXPORT
LINK A6, #0 ; allocate stack frame
MOVE.L 16(A6),A0 ;ptr to str1
MOVE.L 12(A6),A1 ;ptr to str2
MOVEQ #0,D0
MOVE.B (A0)+,D0 ;str1 length
SWAP D0
MOVE.B (A1)+,D0 ;str2 length
;depending on value of booleans, make proper call
TST.B 8(A6) ;value of diacSens
BEQ.S @2 ;strip diacriticals
TST.B 10(A6) ;value of caseSens
BEQ.S @1 ;ignore case
_RelString ,case ;both diacritical and case sensitive
BRA.S strDone
@1 _RelString ;diacritical sensitive,map to upper case
BRA.S strDone
;strip diacriticals
@2 TST.B 10(A6) ;case sensitive?
BEQ.S @3
_RelString ,marks,case ;ignore diacrits, case sensitive
BRA.S strDone
@3 _RelString ,marks ;ignore diacrits and map to upper case
strDone MOVE.W D0,20(A6) ;return result integer
UNLK A6 ; restore stack
MOVE.L (SP)+,A0 ; rtn addr
LEA 12(SP),SP ; fix up stack
JMP (A0)
;----------------------------------------------------------------------
;
;FUNCTION GetMMUMode: SignedByte;
GetMMUMode FUNC EXPORT
MOVE.B MMU32bit,4(SP) ; FUNCTION return
RTS
;PROCEDURE SwapMMUMode(VAR mode: SignedByte);
SwapMMUMode PROC EXPORT
MOVE.L 4(SP),A0 ; VAR
MOVE.B (A0),D0 ; D0 := new mode
_SwapMMUMode
MOVE.L 4(SP),A0 ; in case A0 was trashed.
MOVE.B D0,(A0) ; return old mode.
MOVE.L (SP)+,A0 ; return address
ADDQ #4,SP ; clear var address
JMP (A0)
;----------------------------------------------------------------------
;
;FUNCTION SwapInstructionCache(cacheEnable: BOOLEAN) : BOOLEAN;
SwapInstructionCache PROC EXPORT
MOVEA.L (A7)+,A1 ; save return address
CLR.L D0 ; clear D0 before we shove Boolean into it
MOVE.B (A7)+,D0 ; D0 <- new mode
MOVE.L D0,A0 ; trap wants mode in A0
CLR.W D0 ; set low word to 0 (routine selector)
_HWPriv
MOVE.W A0,D0 ; move old state of cache to D0
TST.W D0 ; if non-zero, cache was enabled
BEQ.S WasFalse ; if zero, leave result false
MOVEQ #$01,D0 ; set result to true
WasFalse:
MOVE.B D0,(A7) ; save result on stack
JMP (A1)
ENDPROC
FlushInstructionCache PROC EXPORT
MOVEA.L (A7)+,A1 ; save return address
MOVEQ #$01,D0 ; set low word to 1 (routine selector)
_HWPriv
JMP (A1)
ENDPROC
;----------------------------------------------------------------------
;
;FUNCTION SwapDataCache(cacheEnable: BOOLEAN) : BOOLEAN;
SwapDataCache PROC EXPORT
MOVEA.L (A7)+,A1 ; save return address
CLR.L D0 ; clear D0 before we shove Boolean into it
MOVE.B (A7)+,D0 ; D0 <- new mode
MOVE.L D0,A0 ; trap wants mode in A0
MOVE.W #$0002,D0 ; set low word to 2 (routine selector)
_HWPriv
MOVE.W A0,D0 ; move old state of cache to D0
TST.W D0 ; if non-zero, cache was enabled
BEQ.S WasFalse ; if zero, leave result false
MOVEQ #$01,D0 ; set result to true
WasFalse:
MOVE.B D0,(A7) ; save result on stack
JMP (A1)
ENDPROC
;PROCEDURE FlushDataCache;
FlushDataCache PROC EXPORT
MOVEA.L (A7)+,A1 ; save return address
MOVEQ #$03,D0 ; set low word to 3 (routine selector)
_HWPriv
JMP (A1)
ENDPROC
;----------------------------------------------------------------------
if obsoleteGlue then
;----------------------------------------------------------------------
;
; Procedure SetApplBase;
;
; Initialize the Application Zone while growing the System zone.
;
; Arguments:
; A0 - ptr to new application zone base.
;
; Registers:
; D0 - result code from SetApplBase (always 0)
;
SetApplBase PROC EXPORT
Move.L (SP)+,A1 ;return address
Move.L (SP)+,A0 ;startPtr
_SetApplBase ;ask OS to do request
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure InitApplZone;
;
; Initialize the Application Zone
;
; Arguments:
; None
;
; Registers:
; D0 - result code from InitApplZone
;
InitApplZone PROC EXPORT
_InitApplZone ;ask OS to do request
rts
;----------------------------------------------------------------------
;
; FUNCTION GetZone: THz;
;
; Returns value of theZone
;
; Arguments:
; None
;
; Result:
; size of largest available block in bytes
; grow: maximum growth allowed in current zone
;
; Registers:
; A1 - holds return address
;
GetZone FUNC EXPORT
_GetZone ;ask OS to do request
Move.L A0,4(SP) ;save result
rts
;----------------------------------------------------------------------
;
; Procedure SetZone(hz: THz);
;
; Sets theZone to hz
;
; Arguments:
; hz: holds new value for theZone
;
; Registers:
; A2 - holds return address
;
SetZone PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;zone pointer
_SetZone ;ask OS to do request
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure PurgeMem(cbNeeded: Size);
;
; Purge purgeable blocks in the heap until a free block of cbNeeded bytes
; is found, or until the end of the zone is reached.
;
; Arguments:
; cbNeeded: size of block needed
;
; Result:
;
; Registers:
; A1 - return address
; D0 - number of bytes needed/error code
;
PurgeMem PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get cbNeeded
_PurgeMem ;tell OS to do it
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; FUNCTION FreeMem: LongInt;
;
; Returns number of free bytes in the current zone
;
; Arguments:
; None
;
; Result:
; number of free bytes in the current zone
;
; Registers:
; D0 - holds result value
;
FreeMem FUNC EXPORT
_FreeMem ;ask OS to do request
Move.L D0,4(SP) ;save result
rts
;----------------------------------------------------------------------
;
; Procedure ResrvMem(cbNeeded: Size);
;
; Purge purgeable blocks in the heap until a free block of cbNeeded bytes
; is found, or until the end of the zone is reached.
;
; Arguments:
; cbNeeded: size of block needed
;
; Result:
;
; Registers:
; A1 - return address
; D0 - number of bytes needed/error code
;
ResrvMem PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,D0 ;get cbNeeded
_ResrvMem ;tell OS to do it
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure SetGrowZone(growZone: ProcPtr);
;
; Sets the current heap zone's GrowZone procedure to growZone
;
; Arguments:
; growZone: new value for this zone's GrowZone proc
;
; Registers:
; A1 - holds return address
;
SetGrowZone PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;Procedure pointer
_SetGrowZone ;ask OS to do request
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure SetApplLimit(zoneLimit: Ptr);
;
; Sets the application zone's limit to zoneLimit
;
; Arguments:
; zoneLimit: new value for application zone limit
;
; A2 - holds return address
;
SetApplLimit PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;zone pointer
_SetApplLimit ;ask OS to do request
JMP (A1) ;return via A1
;PROCEDURE MaxApplZone;
;
;grows the application zone to as large as allowable (by applLimit)
MaxApplZone PROC EXPORT
DC.W $A063 ;put ROM glue here
RTS
;-------------------------------------------------------------------------------------------
; PROCEDURE MoveHHi( h : Handle );
;
; Moves h up to the top of its region (space between two locked/nonrelocatable objects or
; between a locked/nonreloc and the heap end), but with neither purge nor heap growth, only
; compaction. The idea is to use a stack buffer to move slices of the rising block in steps,
; compacting along the way to free space at the top. Requires about 1K of stack space.
; If the block is already high, MoveHHi does nothing.
;
; Arguments: A0 = handle to be moved high
; Results: D0 = error code = 0 no error
; NilHandleErr
; LkdHandleErr
; StackErr
; Register conventions:
;
; A6 - theZone pointer
; A5 - stack locals, buffer
; A4 - handle of block we are moving
; A3 - BkLim(theZone)
;
; D6 - current BC of block moved so far (not including header)
; D7 - current BC of block left to move (not including header)
;-------------------------------------------------------------------------------------------
MoveHHi PROC EXPORT
MOVE.L (SP)+,A1 ; return address
MOVE.L (SP)+,A0 ; handle
_MoveHHi ; off to ROM version
JMP (A1) ; return to caller of glue
;----------------------------------------------------------------------
;
; Procedure DisposPtr(p: Ptr);
;
; Releases the block pointed to by p.
;
; Arguments:
; p: pointer to block to be freed
;
; Result:
; None
;
; Registers:
; A0 - points to block to be freed
; A1 - return address
; D0 - error code
;
DisposPtr PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get parameter
_DisposPtr ;let OS do work
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure DisposHandle(h: Handle);
;
; Releases the block referenced by h.
;
; Arguments:
; h: handle for the block to be freed
;
; Result:
; None
;
; Registers:
; A0 - handle for block to be freed
; A1 - return address
; D0 - error code
;
DisposHandle PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get handle
_DisposHandle ;let OS do work
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure EmptyHandle(h: Handle);
;
; Explicitly purges the relocatable block referred to by h.
;
; Arguments:
; h: refers to relocatable block
;
; Result:
; None
;
; Registers:
; A0 - handle for block
; A1 - holds return address
; D0 - error code
;
EmptyHandle PROC EXPORT
Move.L (SP)+,A1 ;get return address
Move.L (SP)+,A0 ;get the handle
_EmptyHandle ;let OS do it
JMP (A1) ;return via A1
;----------------------------------------------------------------------
;
; Procedure HLock(h: Handle);
; Procedure HUnLock(h: Handle);
; Procedure HPurge(h: Handle);
; Procedure HNoPurge(h: Handle);
; Procedure HSetRBit(h: Handle);
; Procedure HClrRBit(h: Handle);
;
; These procedure are used to change the lock and purge and resource
; attributes of the relocatable block referred to by h.
;
; Arguments:
; h: handle for relocatable block
;
; Registers:
; A0 - handle for relocatable block
; A1 - holds return address
;
HLock PROC EXPORT
Move.L (SP)+,A1 ;return address
Move.L (SP)+,A0 ;handle for block
_HLock ;let OS to do it.
JMP (A1) ;return via A1
HUnLock PROC EXPORT
Move.L (SP)+,A1 ;return address
Move.L (SP)+,A0 ;handle for block
_HUnLock ;let OS to do it.
JMP (A1) ;return via A1
HPurge PROC EXPORT
Move.L (SP)+,A1 ;return address
Move.L (SP)+,A0 ;handle for block
_HPurge ;let OS to do it.
JMP (A1) ;return via A1
HNoPurge PROC EXPORT
Move.L (SP)+,A1 ;return address
Move.L (SP)+,A0 ;handle for block
_HNoPurge ;let OS to do it.
JMP (A1) ;return via A1
HSetRBit PROC EXPORT
Move.L (SP)+,A1 ;return address
Move.L (SP)+,A0 ;handle for block
_HSetRBit ;let OS to do it.
JMP (A1) ; return via A1 (2/4/86 Memerr OK)
HClrRBit PROC EXPORT
Move.L (SP)+,A1 ;return address
Move.L (SP)+,A0 ;handle for block
_HClrRBit ;let OS to do it.
JMP (A1) ; return via A1 (2/4/86 Memerr OK)
;
;PROCEDURE MoreMasters;
;
MoreMasters PROC EXPORT
_MoreMasters
rts
;----------------------------------------------------------------------
;
; FUNCTION MemError: OsErr;
;
; Returns the error observed by the most recent memory manager call.
; It has been obsoleted by INLINE equivalent.
;
; Arguments:
; None
;
; Registers:
;
MemError FUNC EXPORT
Move.W MemErr,4(SP) ;last error
RTS
;___________________________________________________________________
;
; FUNCTION RamSDOpen(whichPort: SPortSel): OSErr;
;
; RAMSDOpen loads and installs Mac or MacXL RAM serial driver
; (resource type SERD, ID=1 for Mac, ID=2 for MacXL) if the system
; driver is version 0. The driver is then opened for both input
; and output. The resource should have the locked attribute set so
; that it is brought in low in the heap. If the driver is only used
; on a 512K system, it may have the System Heap bit set (there would
; probably not be room for it on a 128K machine).
;
; (1) This routine is intended for those who need the additional capability
; of the version 1 driver. History:
;
; Main problem was to get four drivers in which
; are packaged as one and still preserve the DCE pointers which the old
; one had. Probably would have been better to package as RAM DRVR 28 which,
; when opened, would have also installed 29, 30, and 31 into DCEs. Later, code
; was added to default to current drivers if they were a late enough version.
; Finally, configuration/use check was added to avoid Device Manager bug which
; ate Open error codes from driver, and to check for disk drivers using the DCEs
; which didn't support new protocol yet.
;
; (2) If we just had new ROMs, RAMSDOpen would not be needed because the driver
; would already exist - except: logical drivers which support version 1
; set may be around and want to be found. Open('.AIn') and Open('.AOut')
; would not necessarily work since open may work but version 1 level may
; still not be around.
;
; (3) So, RAMSDOpen is sort of an amalgamation of different FUNCTIONs which are handled
; separately in the future (hopefully):
;
; - loading RAM-based drivers (load appropriate one for MacXL).
; - closing old drivers and opening the new.
; - observing configuration/use protocols.
; - checking for a certain level of driver service.
;
; (4) Current loading logic is:
;
; IF either DCE is missing: fail with unitEmptyErr.
; (RAMSDOpen callers want full-duplex async service. This also
; keeps us from closing a hard-disk driver which is using one of the
; DCEs and disposing the other. We will also exit here in the case of
; AppleTalk and old ROMs because the DCEs will be removed by the MPP driver).
; IF the output DCE version byte>0, we will just try opening the current driver.
; (If both DCEs are around AND version bytes are > 0, we can assume that the
; driver is BOTH async - only async drivers in the future should use these
; refnums - AND that it's a superset version of the driver. The case of
; a network async driver should fall in here; if it's not a superset driver,
; it should just be version 0 and RAMSDOpen will fail in the config check (port
; will be in use). If it does support version 1 capability or more, RAMSDOpen
; goes directly to the open code and should open successfully. Old ROM device
; manager problems may still interfere in error cases, but we can't be perfect.
; IF both DCEs are present AND the version is 0, we check the configuration and use
; port bytes and figure out if it's ok to open. If so, we load the SERD
; resource (if not already loaded) and install it. Finally, we open the
; driver.
;
; We should put in a check for ROM85 and trap out if so; this would allow us to
; fix any problems in that ROM.
;
;
; possible errors:
; -1 - DCEs version is 0 but RAM-based (something wierd . . .)
; -97 PortInUse - some other driver is currently using this port
; -98 PortNotCf - parameter ram is set for some other type use
; -22 unitEmptyErr - DCE has been removed
; -192 ResNotFound - appropriate SERD resource not found
; -108 MemFullErr - not enough memory to load driver
;
;
;___________________________________________________________________
RamSDOpen FUNC EXPORT
EXPORT RamSDClose
serAInRfn EQU -6 ; -6 and -7 for port A
serAOutRfn EQU -7
serBInRfn EQU -8 ; -8 and -9 for port B
serBOutRfn EQU -9
idMacSERD EQU 1 ; resource ID 1 for Mac
idMacXLSERD EQU 2 ; resource ID 2 for Mac XL
resultOS EQU 10 ; RamSDOpen A6 offsets after link
portSelOS EQU 8 ; $0000=port A , $0100=port B
romVersOS EQU 8 ; version word offset from ROMBase
LINK A6, #-ioQElSize ; make room for io pblk and save
MOVEM.L D2-D3/A2-A3,-(SP) ; save regs
CLR.W ResultOS(A6) ; assume no error
; Open both drivers and we are done!
openBoth MOVEQ #1, D2 ; want to do this twice
LEA -ioQElSize(A6), A0 ; ptr to param blk
LEA drvANames, A1 ; assume port A
TST.B PortSelOS(A6) ; which port?
BEQ.S @1 ; br if port A
LEA drvBNames, A1 ; ptr to names: bIn and bOut
@1 MOVE.L A1, ioFileName(A0) ; stuff ptr to name
CLR.W ioDrvNum(A0)
CLR.B ioPermssn(A0) ; open for read/write
_Open
BNE.S ramSDFail ; better work!
CLR.W D1
MOVE.B (A1)+, D1 ; the length of this string
ADD.W D1, A1 ; skip to next name
DBRA D2, @1
RamSDExit MOVEM.L (SP)+,D2-D3/A2-A3 ; restore those regs
UNLK A6
MOVE.L (SP)+, A0 ; get rts
ADDQ #2, SP ; strip WhichPort parameter
JMP (A0)
ramSDFail MOVE.W D0, ResultOS(A6)
BRA.S RamSDExit
;___________________________________________________________________
;
; PROCEDURE RamSDClose(whichPort: SPortSel);
;
; RamSDClose closes the drivers (both in and out) for the port
; indicated by whichPort. It disposes of the RAM serial driver if
; it is no longer needed (ie the other port is not open).
;
;___________________________________________________________________
RamSDClose
LINK A6, #-ioQElSize ; make room for io pblk and save
MOVEM.L D2-D3/A2-A3,-(SP) ; save regs
; first close the in and out drivers for this port
MOVE.B PortSelOS(A6), D1 ; the value of whichPort
BSR ClsPorts
BRA.S RamSDExit ; and exit
;______________________________________;
;
; Routine: GetSerDCE
; Arguments: D2 (input) -- driver refnum
; D0 (output) -- 0 if DCE ok, unitEmptyErr if not
; A0 (output) -- DCE ptr if D0=0
; -ioQElSize(A6) -- io parameter block
; all other regs preserved
; Called By: RAMSDOpen
; Purpose: Get pointer to appropriate output DCE (based on WhichPort)
GetSerDCE LEA -ioQElSize(A6), A0 ; address of cmd block
MOVE.W D2, ioRefNum(A0) ; refnum
MOVE.W #1, csCode(A0) ; get DCE status code
_Status
BNE.S @2 ; br if the DCE is not around
MOVE.L csParam(A0), A0 ; get DCE handle
MOVE.L (A0), A0 ; get DCE ptr
BRA.S @3
@2 MOVEQ #unitEmptyErr, D0 ; no DCE (probable case of old ROM driver)
@3 RTS ; return
;______________________________________;
;
; Routine: ChkConfig
; Arguments: D1 (input) -- 0=port A , 1=port B
; D0 (output) -- 0 if avail (unchanged if avail for ChkConf1 entry)
; -97 PortInUse - some other driver is currently using this port
; -98 PortNotCf - parameter ram is set for some other type use
; all other regs preserved
; Called By: SDAvail, RAMSDOpen
; Purpose: Check to see if PortUse and SPConfig are ok for an async driver.
ChkConfig MOVEQ #0, D0 ; return 0 if ok
ChkConf1 MOVE.L D2, -(SP) ; preserve all regs (D0 changed on failure)
MOVE.B SPConfig, D2 ; see what parameter ram says
TST.B D1
BNE.S @1 ; br if port b
LSR.B #4, D2 ; use appropriate 4 bits
@1 AND.B #$0F, D2
BEQ.S @2 ; br if 0 (UseFree)
SUBQ.B #useAsync, D2 ; config'ed for async?
BEQ.S @2 ; br if so
MOVEQ #PortNotCf, D0 ; "port not configured error"
BRA.S @4
@2 MOVE.B PortBUse, D2 ; see if port is in use
TST.B D1
BNE.S @3 ; br if port b
MOVE.B PortAUse, D2
@3 BCLR #7, D2 ; in use?
BNE.S @4 ; br if not
EOR.B #useAsync, D2 ; in use by async driver?
BEQ.S @4 ; ok if so . . .
MOVEQ #PortInUse, D0 ; note the error
@4 MOVE.L (SP)+, D2 ; restore regs
TST D0 ; set CCR
RTS ; and return (D0 unchanged if ok)
;______________________________________;
;
; Routine: ClsPorts
; Arguments: D1 (input) -- 0=port A , 1=port B
; A2 (input) -- ptr to SDOpen/Close 'globals' record
; A6 (input) -- -ioQElSize(A6) is I/O parameter blk
; A0/D0 clobbered.
; Called By: RamSDOpen, RAMSDClose
; Purpose: ClsPorts closes both the in and out driver of a serial port.
intMask EQU $0600 ; excludes all ints on Mac, MacXL
ClsPorts MOVEQ #SerAInRfn, D0 ; assume port A
TST.B D1 ; portA or portB?
BEQ.S @1
MOVEQ #serBInRfn, D0 ; port B
@1 LEA -ioQElSize(A6), A0 ; the ptr to the param blk
MOVE.W D0, ioRefNum(A0) ; set up the parameter block
_Close ; close the in driver
SUBQ.W #1, ioRefNum(A0) ; refNum of out driver
_Close ; close it also
RTS ; and return
drvANames DC.B 4
DC.B '.AIn'
DC.B 5
DC.B '.AOut'
drvBNames DC.B 4
DC.B '.BIn'
DC.B 5
DC.B '.BOut'
;
;FUNCTION GetSysPPtr: SysPPtr;
;
GetSysPPtr FUNC EXPORT
MOVE.L #SysParam,4(SP) ;get the address
RTS
;PROCEDURE Restart;
Restart PROC EXPORT
MOVE.L ROMBase,A0 ;get ROM start
ADD #$A,A0 ;Offset of reboot location
JMP (A0) ;Bye
;FUNCTION GetFSQHdr: QHdrPtr;
GetFSQHdr PROC EXPORT
MOVE.L #FSQHdr,4(SP)
RTS
;FUNCTION GetDrvQHdr: QHdrPtr;
GetDrvQHdr PROC EXPORT
MOVE.L #DrvQHdr,4(SP)
RTS
;FUNCTION GetVCBQHdr: QHdrPtr;
GetVCBQHdr PROC EXPORT
MOVE.L #VCBQHdr,4(SP)
RTS
;FUNCTION GetVBLQHdr: QHdrPtr;
GetVBLQHdr PROC EXPORT
MOVE.L #VBLQueue,4(SP)
RTS
;FUNCTION GetEvQHdr: QHdrPtr;
;
GetEvQHdr PROC EXPORT
MOVE.L #EventQueue,4(SP)
RTS
;----------------------------------------------------------------------
;
; FUNCTION ApplicZone: THz;
;
; Returns value of ApplZone. It has been obsoleted by INLINE equivalent.
;
; Arguments:
; None
;
; Result:
; current value of ApplZone pointer
;
; Registers:
; A1 - holds return address
ApplicZone FUNC EXPORT
Move.L ApplZone,4(SP)
RTS
;----------------------------------------------------------------------
;
; FUNCTION SystemZone: THz;
;
; Returns value of SysZone. It has been obsoleted by INLINE equivalent.
;
; Arguments:
; None
;
; Result:
; current value of SysZone pointer
;
; Registers:
; A1 - holds return address
SystemZone FUNC EXPORT
Move.L SysZone,4(SP)
RTS
;----------------------------------------------------------------------
;
; FUNCTION TopMem: Ptr;
;
; Returns the address of the byte after the last byte of real memory.
; It has been obsoleted by INLINE equivalent.
;
; Arguments:
; None
;
; Result:
; Ptr: Address of byte just following last byte of
; real memory
;
; Registers:
; D0 - result code
TopMem FUNC EXPORT
Move.L MemTop,4(SP) ;set FUNCTION result
RTS
;----------------------------------------------------------------------
;
; FUNCTION GetApplLimit: Ptr;
;
; Fetches the current application heap limit. It has been obsoleted by
; INLINE equivalent.
GetApplLimit FUNC EXPORT
Move.L ApplLimit,4(SP) ;zone pointer
RTS
;----------------------------------------------------------------------
;
; PROCEDURE InsTime(tmTaskPtr: QElemPtr);
InsTime PROC EXPORT
; Someone thought this glue was bad because it relies on A1 being
; preserved across the trap call. That is wrong! The trap dispatcher
; preserves A1 across OS traps!
MOVE.L (A7)+,A1 ;get return address
MOVE.L (A7)+,A0 ;get pointer
_InsTime
JMP (A1) ;return
;----------------------------------------------------------------------
;
; PROCEDURE RmvTime(tmTaskPtr: QElemPtr);
RmvTime PROC EXPORT
; Someone thought this glue was bad because it relies on A1 being
; preserved across the trap call. That is wrong! The trap dispatcher
; preserves A1 across OS traps.
MOVE.L (A7)+,A1 ;get return address
MOVE.L (A7)+,A0 ;get pointer
_RmvTime
JMP (A1) ;return
;----------------------------------------------------------------------
;
; PROCEDURE PrimeTime(tmTaskPtr: QElemPtr; count: LONGINT);
PrimeTime PROC EXPORT
; Someone thought this glue was bad because it relies on A1 being
; preserved across the trap call. That is wrong! The trap dispatcher
; preserves A1 across OS traps.
MOVE.L (A7)+,A1 ;get return address
MOVE.L (A7)+,D0 ;get count
MOVE.L (A7)+,A0 ;get pointer
_PrimeTime
JMP (A1) ;return
;----------------------------------------------------------------------
;
;FUNCTION VInstall(VBLBlockPtr: VBLCBPtr): OsErr;
;
VInstall FUNC EXPORT
MOVE.L (SP)+,A1 ;get the return address
MOVE.L (SP)+,A0 ;addr of vertical retrace control blk
_VInstall
MOVE.W D0,(SP) ;return error
JMP (A1)
;
;FUNCTION VRemove(VBLBlockPtr: VBLCBPtr): OsErr;
;
VRemove FUNC EXPORT
MOVE.L (SP)+,A1 ;get the return address
MOVE.L (SP)+,A0 ;addr of vertical retrace control blk
_VRemove
MOVE.W D0,(SP) ;return error
JMP (A1)
ENDIF
;----------------------------------------------------------------------
END
Reference in New Issue Copy Permalink