Macintosh-SW/mac-rom
1
0
Fork 0
mirror of https://github.com/elliotnunn/mac-rom.git synced 2024-12-28 01:29:20 +00:00
Code Issues Projects Releases Wiki Activity
minitest-displaymgr
mac-rom/Libs/InterfaceSrcs/OSTraps.a
Elliot Nunn 4325cdcc78 Bring in CubeE sources 
Resource forks are included only for .rsrc files. These are DeRezzed into their data fork. 'ckid' resources, from the Projector VCS, are not included.

The Tools directory, containing mostly junk, is also excluded.
2017-12-26 09:52:23 +08:00

3733 lines
105 KiB
Plaintext
Raw Permalink Blame History

;
; 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 View Git Blame Copy Permalink