info-mac@uw-beaver (09/16/85)
From: shebanow%ucbernie@Berkeley (Mike Shebanow)
A Modest proposal:
This is the list of functions that are not implemented as traps
in the current Mac ROMs. Apple provides most of these routines in
the Lisa Pascal environment only. I have implemented quite a few
of these routines for my own purposes. Many of them are extremely
useful. Some of them simply return the contents of global variables.
I am submitting this with the hope that somebody (or somebodies) out
there will implement the remaining functions and post them. I will probably
implement the routines from the 'OS Event Manager' and Text Edit' sections
sometime soon. I have no plans to do the driver level calls. If I can't
figure out a way to use Apple's Print Manager routines for MDS effectively,
I will rewrite those as well.
All of the code is written for Consulair C, and take register based
arguments. All the code was written by me, with the exception of the
File Manager code, which was written by Russ Whetmore. I am reposting
these, since I have added some routines and made some unnecessary changes.
I don't have the author's mail address, so I hope he doesn't object to
the reposting. I greatly appreciated his code, since it cut the size of my
application by about 1.5K (I had implemented the calls in C). I hope more
people will submit general purpose library code for MacC and other compilers.
A few of these routines have been posted to info-mac previously. These
versions supersede the previous versions.
Most of the routines have been very well tested by a make program I am in
the final phases of. The only exception to this is the code in Packages.asm,
of which I have used only the string comparison functions of the International
Utils package, and the SFGetFile routine from the Standard File package. The
other routines should work, since the code is pretty straightforward, but bugs
are a distinct possibility.
A special note: the routines in FinderParms.c contain not only the listed
routines from the Segment Loader, but also some routines for creating NEW
argument lists, which can be used to open documents when launching. The first
step is to call ZeroAppFiles(), which wipes the slate clean. The second step
is to call SetAppMessage(appPrint) if you want to set the message to appPrint.
Finally, call AddAppFile() once for each filename you wish to add, in order.
AddAppFile() accepts a pointer to a structure of type AppFile as its argument.
This is the same structure filled in by GetAppFiles(), as described in the
Segment loader docs.
Hope this stuff is useful...
Andrew Shebanow
c/o shebanow@ucbernie.ARPA
----------------------------- CUT HERE -------------------------------
Function IM Section Done? By Whom?
GetDblTime Event Manager NO
GetCaretTime Event Manager NO
TEFromScrap TextEdit NO
TEToScrap TextEdit NO
TEScrapHandle TextEdit NO
TEGetScrapLen TextEdit NO
TESetScrapLen TextEdit NO
GetIndString ToolUtil YES AGS
GetIndPattern ToolUtil YES AGS
IUDateString Package Mgr YES AGS
IUDatePString Package Mgr YES AGS
IUTimeString Package Mgr YES AGS
IUTimePString Package Mgr YES AGS
IUMetric Package Mgr YES AGS
IUGetIntl Package Mgr YES AGS
IUSetIntl Package Mgr YES AGS
IUCompString Package Mgr YES AGS
IUMagString Package Mgr YES AGS
IUEqualString Package Mgr YES AGS
IUMagIDString Package Mgr YES AGS
NumToString Package Mgr YES AGS
StringToNum Package Mgr YES AGS
SFPutFile Package Mgr YES Consulair/AGS
SFPPutFile Package Mgr YES AGS
SFGetFile Package Mgr YES Consulair/AGS
SFPGetFile Package Mgr YES AGS
DILoad Package Mgr YES AGS
DIUnLoad Package Mgr YES AGS
DIBadMount Package Mgr YES AGS
DIFormat Package Mgr YES AGS
DIVerify Package Mgr YES AGS
DIZero Package Mgr YES AGS
MaxApplZone Memory Mgr YES MacTutor
SystemZone Memory Mgr YES AGS
ApplicZone Memory Mgr YES AGS
GZCritical Memory Mgr YES AGS
GZSaveHnd Memory Mgr YES AGS
TopMem Memory Mgr YES AGS
MemError Memory Mgr YES AGS
CountAppFiles Segment Ldr YES AGS
GetAppFiles Segment Ldr YES AGS
ClrAppFiles Segment Ldr YES AGS
SetEventMask OS Event Mgr NO
GetEVQHdr OS Event Mgr NO
GetVInfo File Mgr YES RW
GetVol File Mgr YES RW
SetVol File Mgr YES RW
FlushVol File Mgr YES RW
UnmountVol File Mgr YES RW
Eject File Mgr YES RW
Create File Mgr YES RW
FSOpen File Mgr YES RW
FSRead File Mgr YES RW
FSWrite File Mgr YES RW
GetFPos File Mgr YES RW
SetFPos File Mgr YES RW
GetEOF File Mgr YES RW
SetEOF File Mgr YES RW
Allocate File Mgr YES RW
FSClose File Mgr YES RW
GetFInfo File Mgr YES RW
SetFInfo File Mgr YES RW
SetFLock File Mgr YES RW
RstFLock File Mgr YES RW
Rename File Mgr YES RW
FSDelete File Mgr YES RW
GetFSQHdr File Mgr YES AGS
GetVCBQHdr File Mgr YES AGS
GetDrvQHdr File Mgr YES AGS
OpenDriver Device Mgr NO
CloseDriver Device Mgr NO
Control Device Mgr NO
Status Device Mgr NO
KillIO Device Mgr NO
GetDCtlQHdr Device Mgr NO
DiskEject Disk Driver NO
SetTagBuffer Disk Driver NO
DriveStatus Disk Driver NO
StartSound Sound Driver NO
StopSound Sound Driver NO
SoundDone Sound Driver NO
GetSoundVol Sound Driver NO
SetSoundVol Sound Driver NO
SerReset Serial Driver NO
SerSetBuf Serial Driver NO
SerHShake Serial Driver NO
SerSetBrk Serial Driver NO
SerClrBrk Serial Driver NO
SerGetBuf Serial Driver NO
SerErrFlag Serial Driver NO
GetVBLQHdr Task Mgr NO
GetDateTime OS Utils NO
GetTime OS Utils NO
SetTime OS Utils NO
GetSysPPtr OS Utils NO
Print Manager? Print Mgr YES Apple (for MDS, stack based)
RAMSDOpen Serial Driver YES Apple (for MDS, stack based)
RAMSDClose Serial Driver YES Apple (for MDS, stack based)
AppleTalk? AppleTalk Mgr NO
----------------------------- CUT HERE -------------------------------
/*
* FinderParms.c Andrew G. Shebanow 8/31/85
*
* Routines to emulate the Pascal calls which return finder information
* (e.g., file arguments, open or print, etc). Written to
* interface to Consulair's MacC compiler.
*
* In addition, several additional calls have been added to the library.
* These routines let applications manipulate the application parms for
* another application prior to a Launch call.
*
* Copyright 1985 HyperSoft All Rights Reserved
*
* Modification History
*
* 9/9/85 Moved to C version (AGS)
* 9/9/85 Added code to set finder parms (AGS)
*/
#include "memory.h"
/* finder message open files or print files */
#define appOpen 0
#define appPrint 1
/* finder application parameter info */
typedef struct {
short vRefNum;
unsigned long fType;
short versNum;
Str255 fName;
} AppFile;
#define APPPARMHANDLE 0x0aec
typedef struct {
short message;
short count;
AppFile files[4]; /* actually open ended */
} AppParms;
short AddAppFile(appFile)
AppFile *appFile;
{
Handle appParmH;
AppParms *appParmPtr;
AppFile *newAppFile;
unsigned long appHsize, appFsize;
unsigned long newSize;
appParmH = (Handle) APPPARMHANDLE;
appParmH = (Handle) *appParmH;
appHsize = GetHandleSize(appParmH);
appFsize = (unsigned long) appFile->fName.count;
appFsize++;
if ((appFsize & 0x01) != 0)
appFsize++;
appFsize += 8;
newSize = appFsize + appHsize;
if (SetHandleSize(appParmH,newSize) != 0)
return(1);
appParmPtr = (AppParms *) *appParmH;
newAppFile = &(appParmPtr->files[appParmPtr->count]);
BlockMove(appFile,newAppFile,appFsize);
appParmPtr->count += 1;
return(0);
}
static asmprocs()
{
#asm
INCLUDE MACTRAPS.D
INCLUDE SYSEQU.D
INCLUDE TOOLEQU.D
; Routines declared here:
XDEF CountAppFiles
XDEF GetAppFiles
XDEF ClrAppFiles
XDEF ZeroAppFiles
XDEF SetAppMessage
XDEF GetAppName
XDEF GetFndrName
XDEF SetFndrName
; void CountAppFiles(message,count)
; short *message; (D0)
; short *count; (D1)
CountAppFiles:
MOVEM.L A0-A2,-(SP) ; save regs
MOVE.L AppParmHandle,A0
MOVE.L (A0),A0 ; A0 points to AppParms
MOVE.L D0,A1 ; A1 points to message
MOVE.L D1,A2 ; A2 points to count
MOVE (A0),(A1) ; save into message
MOVE 2(A0),(A2) ; save into count
MOVEM.L (SP)+,A0-A2 ; restore regs
RTS
; void GetAppFiles(index,appFile)
; short index; (D0)
; AppFile *appFile; (D1)
GetAppFiles:
MOVEM.L A0-A2/D0-D1,-(SP) ; save regs
MOVE.L AppParmHandle,A0
MOVE.L (A0),A0 ; A0 points to AppParms
MOVE.L D1,A2 ; A2 points to appFile
JSR FindIndex ; find index
CMP.L #0,A1
BEQ @1 ; if couldn't find, handle error
; copy AppFile data from A1 to appFile
MOVE.L A1,A0 ; source ptr
MOVE.L A2,A1 ; dest ptr
MOVE.L 8(A0),D0 ; put str len in D0
AND.L #$0FF,D0 ; mask hight bytes
ADDQ.L #1,D0
BTST #0,D0
BEQ @2 ; if odd number of bytes...
ADDQ.L #1,D0 ; pad with additional byte
@2 ADD.L #8,D0 ; add space for other data
_BlockMove
@1 MOVEM.L (SP)+,A0-A2/D0-D1 ; restore regs
RTS
; void ClrAppFiles(index)
; short index; (D0)
ClrAppFiles:
MOVEM.L A0-A1,-(SP) ; save regs
MOVE.L AppParmHandle,A0
MOVE.L (A0),A0 ; A0 points to AppParms
JSR FindIndex ; find index
CMP.L #0,A1
BEQ @1
MOVE.L #0,2(A1) ; clear out fType field
@1 MOVEM.L (SP)+,A0-A1 ; restore regs
RTS
; void ZeroAppFiles()
ZeroAppFiles
MOVEM.L A0-A1,-(SP) ; save regs
MOVE.L AppParmHandle,A0
MOVE.L (A0),A1 ; A1 points to AppParms
CLR.L (A1) ; set message & count to 0
MOVEQ.L #4,D0 ; set handle size to 4
_SetHandleSize
MOVEM.L (SP)+,A0-A1 ; restore regs
RTS
; void SetAppMessage(message)
; short message; (D0)
SetAppMessage
MOVE.L A0,-(SP) ; save regs
MOVE.L AppParmHandle,A0
MOVE.L (A0),A1 ; A1 points to AppParms
MOVE.W D0,(A0) ; move message into app parm area
MOVE.L (SP)+,A0 ; restore regs
RTS
; void GetAppName(appName)
; StringPtr appName; (D0)
;
; return name of current finder.
GetAppName
MOVEM.L A0-A1/D0,-(SP)
TST.L D0
BEQ @1 ; if string pointer is null, return
LEA CurApName,A0 ; src <- CurApName global
MOVE.L D0,A1 ; dst <- appName
MOVE.B (A0),D0 ; get string size
AND.L #$0FF,D0
ADDQ.L #1,D0 ; add 1 for size byte
_BlockMove ; copy the string
@1 MOVEM.L (SP)+,A0-A1/D0
RTS
; GetFndrName(fndrName)
; StringPtr fndrName; (D0)
;
; return name of current finder.
;
GetFndrName
MOVEM.L A0-A1/D0,-(SP)
TST.L D0
BEQ @1 ; if string pointer is null, return
LEA FinderName,A0 ; src <- FinderName
MOVE.L D0,A1 ; dst <- fndrName
MOVE.B (A0),D0 ; get string size
AND.L #$0FF,D0
ADDQ.L #1,D0 ; add 1 for size byte
_BlockMove ; copy the string
@1 MOVEM.L (SP)+,A0-A1/D0
RTS
; SetFndrName(fndrName)
; StringPtr fndrName; (D0)
;
; set current finder.
;
SetFndrName
MOVEM.L A0-A1/D0,-(SP)
TST.L D0
BEQ @1 ; if string pointer is null, return
MOVE.L D0,A0 ; src <- fndrName
LEA FinderName,A1 ; dst <- FinderName global
MOVE.B (A0),D0 ; get string size
CMP.B #15,D0
BGT @1 ; if string to big, do nothing
AND.L #$0FF,D0
ADDQ.L #1,D0 ; add 1 for size byte
_BlockMove ; copy the string
@1 MOVEM.L (SP)+,A0-A1/D0
RTS
; FindIndex
;
; finds the nth AppFile record.
;
; INPUT:
; A0.L pointer to AppParms
; D0.W index (1..count)
; OUTPUT:
; A1.L pointer to AppFile data or 0 if not found
FindIndex
MOVEM.L A2-A4/D1-D2,-(SP) ; save regs
MOVE.L 0,A1 ; set result to 0
TST D0 ; test for legal index
BLE FindXit
CMP 2(A0),D0
BGT FindXit
LEA 4(A0),A2 ; start of first AppFile
MOVE D0,D1 ; D1 is loop counter
@1 SUBQ #1,D1 ; index from 0
BEQ @2 ; if 0 we are done
ADD.L #8,A2 ; start of filename string
MOVE.B (A2),D2 ; D2 gets filename size
AND.L #$0FF,D2 ; mask off high bits
ADDQ.L #1,D2 ; plus one more for size byte
BTST #0,D2 ; test for pad byte
BEQ @3 ; if odd count, we must pad
ADDQ.L #1,D2 ; add one for pad byte
@3 ADD.L D2,A2 ; add string size to address
BRA @1
@2 MOVE.L A2,A1 ; store in result
FindXit MOVEM.L (SP)+,A2-A4/D1-D2 ; restore regs
RTS
#endasm
}
/********************* end of FinderParms.asm *********************/;
----------------------------- CUT HERE -------------------------------
; MemoryMgr.Asm Andrew G. Shebanow 9/1/85
;
; Routines to emulate the [NO TRAP MACRO] routines documented in
; the Memory Manager section of Inside Mac.
;
; The routine MaxApplZone was taken from the 8/85 issue of MacTutor Magazine
; and is copyrighted by MacTutor Magazine.
;
; Copyright 1985 HyperSoft All Rights Reserved
;
INCLUDE MacTraps.D
INCLUDE SysEquX.D
; Declared here:
XDEF MaxApplZone
XDEF SystemZone
XDEF ApplicZone
XDEF GZCritical
XDEF GZSaveHnd
XDEF TopMem
XDEF MemError
; MaxApplZone()
;
; This routine from 8/85 issue of MacTutor magazine
;
; "MaxApplZone expands the application heap zone to the application heap
; limit without purging any blocks currently in the zone. If the zone
; already extends to the limit, it won't be changed"
; Inside Macintosh spec of MaxApplZone
MinBlkSize EQU 12 ; minimum physical size of block
MaxApplZone
MOVEM.L A0-A1/D0-D1,-(SP) ; save regs
MOVE.L ApplLimit,A0 ; A0 = application heap limit (ptr)
MOVE.L HeapEnd,A1 ; A1 = addr of cur zone trailer
MOVE.L A0,D0
SUB.L A1,D0 ; D0 = size of unused space (incl trailer)
MOVEQ #MinBlkSize,D1 ; D1 = min phys size of a block
CMP.L D1,D0 ; unused space < min block size?
BLO.S @0 ; if so, can't expand zone, bye-bye
MOVE.L A0,HeapEnd ; update HeapEnd to heap limit
MOVE.L D0,(A1) ; unused space = free block (header = size)
MOVE.L ApplZone,A1 ; A1 points to zone header
MOVE.L A0,(A1) ; ApplicZone->bkLim = heap limit
MOVE.L D1,(A0) ; make new zone trailer (free, size = min)
ADD.L D0,zcbFree(A1) ; update count of free bytes in zone
MOVEM.L (SP)+,A0-A1/D0-D1 ; restore regs
@0 RTS
; THz SystemZone()
SystemZone
MOVE.L SysZone,A0 ; SysZone is a pointer to system zone
RTS
; THz ApplicZone()
ApplicZone
MOVE.L ApplZone,A0 ; ApplZone is a pointer to applic zone
RTS
; char GZCritical()
GZCritical
MOVE.L D1,-(SP) ; save D1
MOVE.L #1,D0 ; default return is TRUE
MOVE.L GZMoveHnd,D1
BEQ.S @0
MOVE.L GZRootHnd,D1
BEQ.S @0
MOVE.B #0,D0 ; return false
@0 MOVE.L (SP)+,D1
RTS
; Handle GZSaveHnd()
GZSaveHnd
MOVE.L GZRootHnd,A0
RTS
; Ptr TopMem()
TopMem
MOVE.L MemTop,A0
RTS
; OSErr MemError()
; this routine always returns 0, since all MacC mem traps return the error
; immediately!
MemError
MOVE.W #0,D0 ; always NoErr!!!
RTS
END
----------------------------- CUT HERE -------------------------------
;
; Packages.ASM Andrew G. Shebanow 8/31/85
;
; Portions of this code Copyright 1984,1985 Consulair Corp.
;
; This file contains routines to emulate the high level calls
; for all of the Macintosh packages (with the exception of the SANE
; related ones). These interface routines have the same names
; and calling conventions as the routines in Inside Mac. The routines
; are intended for use with Consulair's MacC compiler, but could
; be converted to any other compiler as well.
;
; The Standard File package routines are based on code written
; by Bill Duvall of Consulair Corp.
;
; CopyRight 1985 HyperSoft All Rights Reserved
;
INCLUDE MacTraps.D
INCLUDE ToolEqu.D
INCLUDE SysEqu.D
; International Utilities
XDEF IUDateString
XDEF IUDatePString
XDEF IUTimeString
XDEF IUTimePString
XDEF IUMetric
XDEF IUGetIntl
XDEF IUSetIntl
XDEF IUCompString
XDEF IUMagString
XDEF IUEqualString
XDEF IUMagIDString
; Binary Decimal Conversion
XDEF NumToString
XDEF StringToNum
; Standard File
XDEF SFPutFile
XDEF SFPPutFile
XDEF SFGetFile
XDEF SFPGetFile
; Disk Initialization
XDEF DILoad
XDEF DIUnload
XDEF DIBadMount
XDEF DIFormat
XDEF DIVerify
XDEF DIZero
; IUDateString(dateTime,form,theString)
; long dateTime; (D0)
; DateForm *form; (D1)
; Str255 *theString; (D2)
IUDateString
MOVE.L D0,-(SP) ; dateTime
MOVE.L D1,-(SP) ; form
MOVE.L D2,-(SP) ; theString
MOVE #0,-(SP) ; routine selector
_Pack6
RTS
; IUDatePString(dateTime,form,theString,intlParam)
; long dateTime; (D0)
; DateForm *form; (D1)
; Str255 *theString; (D2)
; Handle intlParam; (D3)
IUDatePString
MOVE.L D0,-(SP) ; dateTime
MOVE.L D1,-(SP) ; form
MOVE.L D2,-(SP) ; theString
MOVE.L D3,-(SP) ; intlParam
MOVE #14,-(SP) ; routine selector
_Pack6
RTS
; IUTimeString(dateTime,wantSeconds,theString)
; long dateTime; (D0)
; short wantSeconds; (D1) (actually boolean)
; Str255 *theString (D2)
IUTimeString
MOVE.L D0,-(SP) ; dateTime
MOVE.B D1,-(SP) ; wantSeconds (BOOLEAN)
MOVE.L D2,-(SP) ; theString
MOVE #2,-(SP) ; routine selector
_Pack6
RTS
; IUTimePString(dateTime,wantSeconds,theString,intlParam)
; long dateTime; (D0)
; short wantSeconds; (D1) (actually boolean)
; Str255 *theString (D2)
; Handle intlParam; (D3)
IUTimePString
MOVE.L D0,-(SP) ; dateTime
MOVE.B D1,-(SP) ; wantSeconds
MOVE.L D2,-(SP) ; theString
MOVE.L D3,-(SP) ; intlParam
MOVE #16,-(SP) ; routine selector
_Pack6
RTS
; char IUMetric() (actually boolean)
IUMetric
MOVE.B #0,-(SP) ; save space for result
MOVE #4,-(SP) ; routine selector
_Pack6
MOVE.B (SP)+,D0 ; get result
RTS ; result in D0???
; Handle IUGetIntl(theID)
; short theID; (D0)
IUGetIntl
MOVE.L #0,-(SP) ; save space for result
MOVE.W D0,-(SP) ; theID
MOVE #6,-(SP) ; routine selector
_Pack6
MOVE.L (SP)+,A0 ; save result in A0
RTS
; IUSetIntl(refNum,theID,intlParam)
; short refNum; (D0)
; short theID; (D1)
; Handle intlParam; (D2)
IUSetIntl
MOVE.W D0,-(SP) ; refnum
MOVE.W D1,-(SP) ; theID
MOVE.L D2,-(SP) ; intlParam
MOVE #8,-(SP) ; routine selector
_Pack6
RTS
; short IUCompString(aStr,bStr)
; Str255 *aStr; (D0)
; Str255 *bStr; (D1)
IUCompString
MOVE.L D0,A0 ; get pointer to string
MOVE.B (A0)+,D2 ; D2 = aLen
MOVE.L A0,D0 ; D0 = first char of aStr
MOVE.L D1,A0
MOVE.B (A0)+,D3 ; D3 = bLen
MOVE.L A0,D1 ; D1 = first char of bStr
BSR IUMagString
RTS ; result in D0
; short IUMagString(aStr,bStr,aLen,bLen)
; char *aStr; (D0)
; char *bStr; (D1)
; short aLen; (D2)
; short bLen; (D3)
IUMagString
MOVE.W #0,-(SP) ; save space for result
MOVE.L D0,-(SP) ; aStr
MOVE.L D1,-(SP) ; bStr
MOVE.W D2,-(SP) ; aLen
MOVE.W D3,-(SP) ; bLen
MOVE #10,-(SP) ; routine selector
_Pack6
MOVE.W (SP)+,D0
RTS ; result in D0
; short IUEqualString(aStr,bStr)
; Str255 *aStr; (D0)
; Str255 *bStr; (D1)
IUEqualString
MOVE.L D0,A0 ; get pointer to string
MOVE.B (A0)+,D2 ; D2 = aLen
AND.L #$0FF,D2
MOVE.L A0,D0 ; D0 = first char of aStr
MOVE.L D1,A0
MOVE.B (A0)+,D3 ; D3 = bLen
AND.L #$0FF,D3
MOVE.L A0,D1 ; D1 = first char of bStr
BSR IUMagIDString
RTS ; result in D0
; short IUMagIDString(aStr,bStr,aLen,bLen)
; char *aStr; (D0)
; char *bStr; (D1)
; short aLen; (D2)
; short bLen; (D3)
IUMagIDString
MOVE.W #0,-(SP) ; save space for result
MOVE.L D0,-(SP) ; aStr
MOVE.L D1,-(SP) ; bStr
MOVE.W D2,-(SP) ; aLen
MOVE.W D3,-(SP) ; bLen
MOVE #12,-(SP) ; routine selector
_Pack6
MOVE.W (SP)+,D0
RTS ; result in D0
; NumToString(theNum,theString)
; long theNum; (D0)
; Str255 *theString (D1)
NumToString
MOVE.L A0,-(SP) ; save A0
MOVE.L D1,A0 ; theString
MOVE #0,-(SP) ; routine selector
_Pack7
MOVE.L (SP)+,A0 ; restore A0
RTS
; StringToNum(theString,theNum)
; Str255 *theString; (D0)
; long *theNum; (D1)
StringToNum
MOVEM.L A0/D0-D1,-(SP) ; save regs
MOVE.L D0,A0 ; A0 -> theString
MOVE #0,-(SP) ; routine selector
_Pack7
MOVE.L D1,A0
MOVE.L D0,(A0) ; save result
MOVEM.L (SP)+,A0/D0-D1 ; restore regs
RTS
; SFPutFile(where, prompt, origName, dlgHook, reply)
; Point *where; (D0)
; struct PStr *prompt; (D1)
; struct PStr *origName; (D2)
; int (*dlgHook)(); (D3)
; SFReply *reply; (D4)
SFPutFile
MOVE.L D0,A0
MOVE.L (A0),-(SP) ; WHERE
MOVE.L D1,-(SP) ; PROMPT
MOVE.L D2,-(SP) ; origName
MOVE.L D3,-(SP) ; dlgHook
MOVE.L D4,-(SP) ; reply
MOVE #1,-(SP) ; routine selector
_Pack3
RTS
; SFPPutFile(where,prompt,origName,dlgHook,reply,dlgID,filterProc)
; Point *where; (D0)
; struct PStr *prompt; (D1)
; struct PStr *origName; (D2)
; int (*dlgHook)(); (D3)
; SFReply *reply; (D4)
; short dlgID; (D5)
; int (*dlgHook)() (D6)
SFPPutFile
MOVE.L D0,A0
MOVE.L (A0),-(SP) ; WHERE
MOVE.L D1,-(SP) ; PROMPT
MOVE.L D2,-(SP) ; origName
MOVE.L D3,-(SP) ; dlgHook
MOVE.L D4,-(SP) ; reply
MOVE.W D5,-(SP) ; dlgID
MOVE.L D6,-(SP) ; dlgHook
MOVE #3,-(SP) ; routine selector
_Pack3
RTS
; SFGetFile(where, prompt, fileFilter, numTypes, typeList, dlgHook, reply)
; Point *where; (D0)
; struct PStr *prompt; (D1)
; int (*fileFilter)(); (D2)
; short numTypes; (D3)
; SFTypeList *typeList; (D4)
; int (*dlgHook)(); (D5)
; SFReply *reply; (D6)
SFGetFile
MOVE.L D0,A0
MOVE.L (A0),-(SP) ; WHERE
MOVE.L D1,-(SP) ; PROMPT
MOVE.L D2,-(SP) ; FILTER PROC
MOVE.W D3,-(SP) ; numTypes
MOVE.L D4,-(SP) ; typeList
MOVE.L D5,-(SP) ; dlgHook
MOVE.L D6,-(SP) ; reply
MOVE #2,-(SP) ; routine selector
_Pack3
RTS
; SFPGetFile(where, prompt, fileFilter, numTypes, typeList,
; dlgHook, reply, dlgID, filterProc)
; Point *where; (D0)
; struct PStr *prompt; (D1)
; int (*fileFilter)(); (D2)
; short numTypes; (D3)
; SFTypeList *typeList; (D4)
; int (*dlgHook)(); (D5)
; SFReply *reply; (D6)
; short dlgID; 8(A6)
; int (*filterProc)() 12(A6)
SFPGetFile
LINK A6,#0
MOVE.L D0,A0
MOVE.L (A0),-(SP) ; WHERE
MOVE.L D1,-(SP) ; PROMPT
MOVE.L D2,-(SP) ; FILTER PROC
MOVE.W D3,-(SP) ; numTypes
MOVE.L D4,-(SP) ; typeList
MOVE.L D5,-(SP) ; dlgHook
MOVE.L D6,-(SP) ; reply
MOVE.W 10(A6),-(SP) ; dlgID
MOVE.L 12(A6),-(SP) ; filterProc
MOVE #4,-(SP) ; routine selector
_Pack3
UNLK A6
RTS
; DILoad()
DILoad
MOVE #2,-(SP) ; routine selector
_Pack2
RTS
; DIUnload()
DIUnload
MOVE #4,-(SP) ; routine selector
_Pack2
RTS
; short DIBadMount(where,evtMessage)
; Point *where; (D0)
; long evtMessage; (D1)
DIBadMount
MOVE.W #0,-(SP) ; save space for result
MOVE.L D0,A0 ; convert point to long
MOVE.L (A0),-(SP) ; where
MOVE.L D1,-(SP) ; evtMessage
MOVE #0,-(SP) ; routine selector
_Pack2
MOVE.W (SP)+,D0
RTS ; D0 contains error
; short DIFormat(drvNum)
; short drvNum; (D0)
DIFormat
MOVE.W #0,-(SP) ; save space for result
MOVE.W D0,-(SP) ; drvNum
MOVE #6,-(SP) ; routine selector
_Pack2
MOVE.W (SP)+,D0
RTS ; D0 contains error
; short DIVerify(drvNum)
; short drvNum; (D0)
DIVerify
MOVE.W #0,-(SP) ; save space for result
MOVE.W D0,-(SP) ; drvNum
MOVE #8,-(SP) ; routine selector
_Pack2
MOVE.W (SP)+,D0
RTS ; D0 contains error
; short DIZero(drvNum,volName)
; short drvNum; (D0)
; Str255 *volName; (D1)
DIZero
MOVE.W #0,-(SP) ; save space for result
MOVE.W D0,-(SP) ; drvNum
MOVE.L D1,-(SP) ; volName
MOVE #10,-(SP) ; routine selector
_Pack2
MOVE.W (SP)+,D0
RTS ; D0 contains error
END
----------------------------- CUT HERE -------------------------------
/*
* ToolUtils.c Andrew G. Shebanow 9/3/85
*
* Implementation of ToolBox utility routines for MacC. These
* routines emulate the [ No Trap Macro ] routines documented in the
* ToolBox Utilities section of Inside Mac.
*/
#include <QuickDraw.h>
#include <Memory.h>
#include <Resource.h>
/* pascal boolean definitions */
#define TRUE 1
#define FALSE 0
#define NULL 0
/*
* GetIndString:
*
* This function attempts to read a 'STR#' resource into memory
* and extract an individual string from that resource.
*/
GetIndString(theString,strListID,index)
StringPtr theString; /* set to the string */
unsigned short strListID; /* the id of the STR# resource */
unsigned short index; /* index (range 1-n) of desired Str255 */
{
StringHandle strHandle;
unsigned char *strPtr;
unsigned char idx;
unsigned char lcntr, total;
unsigned short *cntPtr, cnt;
strHandle = (StringHandle) GetResource('STR#',strListID);
if (strHandle == NULL)
{
theString->count = 0;
return;
}
HLock(strHandle);
cntPtr = (unsigned short *) *strHandle;
cnt = *cntPtr;
if (index > cnt)
{
theString->count = 0;
return;
}
strPtr = (unsigned char *) ++cntPtr;
index -= 1;
for (idx = 0; idx < index; idx++)
{
/* get the strings before the desired string */
total = *strPtr;
for (lcntr = 0; lcntr <= total; lcntr++)
strPtr++;
}
theString->count = *strPtr;
strPtr++;
total = theString->count;
for (lcntr = 0; lcntr < total; lcntr++)
{
theString->s[lcntr] = *strPtr;
strPtr++;
}
HUnlock(strHandle);
}
typedef struct {
short count;
Pattern thePats[100];
} PatList;
GetIndPattern(thePattern,patListID,index)
Pattern *thePattern;
short patListID;
short index;
{
PatList **patHandle;
PatList *patPtr;
patHandle = (PatList **) GetResource('PAT#',patListID);
if (patHandle == NULL)
return;
HLock(patHandle);
patPtr = *patHandle;
if (index > patPtr->count)
{
HUnlock(patHandle);
return;
}
BlockMove(&(patPtr->thePats[index]),thePattern,8);
HUnlock(patHandle);
}
/**************************** end of ToolUtils.c *********************/
----------------------------- CUT HERE -------------------------------
;------------------------------------------------------------------------------
; FileManager.ASM
;
; Emulation of Lisa Pascal interface for high-level file manager routines
; (Written to interface with Consulair Mac C)
;
; Russ Wetmore for Star Systems Software, Inc.
;
; Version 2.1 24 June 1985
;
; Added the three Queue related [ Pascal Only ] calls from Inside
; Mac & removed the signal exit possibilities. Mercilessy removed comments,
; because I was running out of disk space! My apologies to the author.
;
; Andrew Shebanow
;------------------------------------------------------------------------------
; UPDATE HISTORY:
; 9 Sep 1985 - Removed Signal call error handling
; 4 Sep 1985 - Added File Mgr Queue routines for completeness
;------------------------------------------------------------------------------
; This module was created for a number of reasons, mainly to resolve
; ideological inconsistencies between Consulair's C-flavored
; library routines and file management as described in
; Inside Macintosh.
; One caveat: These routines use one common parameter block, which as
; a convenience is cleared before _any_ routine is executed.
; For most functions, the loss of efficiency with regards to
; speed is offset by the compactness of these routines. For
; those instances where separately maintained parameter blocks
; will result in better performance, you're probably better off
; doing the low-level diddling yourself.
; This module can be used as well by assembly language programmers, with
; one exception:
; 1) "GetVInfo" uses a Consulair C macro called MULS.L which is
; a signed multiply of two 32-bit values. You'd have to emulate
; this with your own subroutine. I was just too lazy to write it
; out myself and too honest to copy Bill Duvall's copyrighted
; routines and imply that they were my own.
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; Include support files:
;------------------------------------------------------------------------------
Include SysEqu.D ; I need system equates
Include MacTraps.D ; I need (want) trap macros
Include FSEqu.D ; Need File Manager Equates
Include M68KLIB.D ; (Consulair C file - for macro)
;------------------------------------------------------------------------------
; Global variables
;------------------------------------------------------------------------------
XDEF paramBlock
.ALIGN 2
paramBlock: ds.L 20,0 ;Globally accessable parameter block (80 bytes max)
;------------------------------------------------------------------------------
; Support subroutines
;------------------------------------------------------------------------------
; Clear parameter block to zeroes
clearPB: move #20-1,D6 ;max size of ioParam/FileParam/VolumeParam (in longs)
lea paramBlock(A5),A0 ;Fetch => to start of block
@1: clr.L (A0)+
dbra D6,@1
globret: rts
; Common subroutine to plug ioNamePtr and ioVRefNum fields
; (and sets up parameter block for trap call to boot)
NameAndVref: move.L D0,paramBlock+ioFileName(A5)
move D1,paramBlock+ioVRefNum(A5)
lea paramBlock(A5),A0
rts
; Common subroutine to return volume name to user from parameter block
; Assumes A1 points to user supplied Str255 struct
retvolName: move.L paramBlock+ioFileName(A5),A0
; A1 already equals target address (volName)
clr.L D0
move.B (A0),D0 ;fetch Pascal string length
addq.L #1,D0 ;Plus 1 to offset for length byte
_BlockMove
rts
;------------------------------------------------------------------------------
; OSErr GetVInfo(drvNum, volName, vRefNum, freeBytes)
; short drvNum; (D0.W)
; char *volName; (D1.L)
; short *vRefNum; (D2.L)
; long *freeBytes; (D3.L)
;------------------------------------------------------------------------------
XDEF GetVInfo
GetVInfo: jsr clearPB ;clear out parameter block
movem.L D1-D3,-(SP) ;save volName, vRefNum, freeBytes
tst D0 ;drvNum given?
bne.S @1 ;Yes
; drvNum = 0, so we use vRefNum to determine volume
move.L D2,A2 ;Gotta go indirect
move (A2),paramBlock+ioVRefNum(A5)
bra.S @2
@1: ; if drvNum is negative, only use volName to determine volume
bmi.S @2 ;Go if drvNum is negative
; drvNum is positive, so use it to determine volume
move D0,paramBlock+ioVolIndex(A5)
@2: ; In any case, stuff volName into parameter block
move.L D1,paramBlock+ioFileName(A5)
lea paramBlock(A5),A0 ;Set up trap call
_GetVolInfo
movem.L (SP)+,A1-A3 ;fetch saved params
move D0,D4 ;Save returned error
move.L A1,D0 ;Was volName supplied?
beq.S @4 ;Nope, go on
jsr retvolName
@4: move paramBlock+ioVRefNum(A5),(A2) ;return volume reference number
move.L paramBlock+ioVAlBlkSiz(A5),D0 ;freeBytes = size of alloc block
move paramBlock+ioVFrBlk(A5),D1 ;...times number of free blocks
ext.L D1
MULS.L D0,D1 ;(CONSULAIR MACRO)
move.L D1,(A3)
@3: move D4,D0 ;Fetch saved error code
rts ;We always return OSErr, regardless of signalflag
;------------------------------------------------------------------------------
; OSErr GetVol(volName, vRefNum)
; char *volName; (D0.L)
; short *vRefNum; (D1.L)
;------------------------------------------------------------------------------
XDEF GetVol
GetVol: jsr clearPB
movem.L D0-D1,-(SP) ;Save params
lea paramBlock(A5),A0 ;Set up trap call
_GetVol
movem.L (SP)+,A1-A2 ;Fetch saved params
move D0,D4 ;Save returned error
move.L A1,D0 ;volName supplied?
beq.S @1 ;Nope, go on
jsr retvolName
@1: move paramBlock+ioVRefNum(A5),(A2) ;return VRefNum
move D4,D0
rts
;------------------------------------------------------------------------------
; OSErr SetVol(volName, vRefNum)
; char *volName; (D0.L)
; short vRefNum; (D1.W)
;------------------------------------------------------------------------------
; OSErr FlushVol(volName, vRefNum)
; char *volName; (D0.L)
; short vRefNum; (D1.W)
;------------------------------------------------------------------------------
; OSErr UnmountVol(volName, vRefNum)
; char *volName; (D0.L)
; short vRefNum; (D1.W)
;------------------------------------------------------------------------------
; OSErr Eject(volName, vRefNum)
; char *volName; (D0.L)
; short vRefNum; (D1.W)
;------------------------------------------------------------------------------
XDEF SetVol
SetVol: move #$A015,D2 ; (_SetVol)
bra.S VolCommon
XDEF FlushVol
FlushVol: move #$A013,D2 ; (_FlshVol)
bra.S VolCommon
XDEF UnmountVol
UnmountVol: move #$A00E,D2 ; (_UnmountVol)
bra.S VolCommon
XDEF Eject
Eject: move #$A017,D2 ; (_Eject)
VolCommon: jsr clearPB
tst D1 ;vRefNum supplied?
beq.S @1 ;Nope, go on
; if vRefNum is non-zero, use it to determine volume
move D1,paramBlock+ioVRefNum(A5)
bra.S @2
@1: ; else, use volName to determine volume
move.L D0,paramBlock+ioFileName(A5)
@2: lea paramBlock(A5),A0
lea @3,A1
move D2,(A1)
; We have to initialize this to a trap value, else, the 68000 may
; get confused first time through trying to determine how many
; bytes make up the next command
@3: _SetVol ;Gets replaced by proper trap value
rts
;------------------------------------------------------------------------------
; OSErr Create(fileName, vRefNum, creator, fileType)
; Str255 *fileName; (D0.L)
; short vRefNum; (D1.W)
; OSType creator; (D2.L)
; OSType fileType; (D3.L)
;------------------------------------------------------------------------------
XDEF Create
Create: jsr clearPB
movem.L D2-D3,-(SP) ;Save OSTypes
jsr NameAndVref
_Create
movem.L (SP)+,D2-D3 ;Fetch saved OSTypes
tst D0 ;Error occurred?
bne.S @1 ;Yes, make like a tree and leaf
move.L D2,D0 ;Test to see if either creator
or.L D3,D0 ;...or fileType supplied
beq.S @1 ;Nope, just exit quietly
move.L D3,paramBlock+ioFlUsrWds(A5) ;Set creator
move.L D2,paramBlock+ioFlUsrWds+4(A5) ;Set type
lea paramBlock(A5),A0
_SetFileInfo
@1: rts
;------------------------------------------------------------------------------
; OSErr FSOpen(fileName, vRefNum, refNum)
; Str255 *fileName; (D0.L)
; short vRefNum; (D1.W)
; short *refNum; (D2.L)
;------------------------------------------------------------------------------
; OSErr OpenRF(fileName, vRefNum, refNum)
; Str255 *fileName; (D0.L)
; short vRefNum; (D1.W)
; short *refNum; (D2.L)
;------------------------------------------------------------------------------
; NOTE: An additional non-Pascal-ish entry point is supplied which has the format:
; OpenFork(fileName, vRefNum, refNum, fork)
; where fork = 0 if data fork, 1 if resource fork
;------------------------------------------------------------------------------
opentable: _Open
_OpenRF
XDEF OpenRF
OpenRF: move #1,D3
bra.S OpenFork
XDEF FSOpen
FSOpen: clr D3
XDEF OpenFork
OpenFork: jsr clearPB
move.L D2,A3 ;Save => to refNum
lsr #1,D3 ;Account for word offset
jsr NameAndVref
lea opentable,A1 ;Point to table
add D3,A1 ;A1 points to proper trap value
lea @1,A2
move (A1),(A2)
@1: _Open ;Replaced by proper trap value
move paramBlock+ioRefNum(A5),(A3) ;Pass back refNum
@2: rts
;------------------------------------------------------------------------------
; OSErr FSRead(refNum, count, buffPtr)
; short refNum; (D0.W)
; long *count; (D1.L)
; char *buffPtr; (D2.L)
;------------------------------------------------------------------------------
; OSErr FSWrite(refNum, count, buffPtr)
; short refNum; (D0.W)
; long *count; (D1.L)
; char *buffPtr; (D2.L)
;------------------------------------------------------------------------------
XDEF FSRead
FSRead: move #$A002,D3 ; (_Read)
bra.S RWcommon
XDEF FSWrite
FSWrite: move #$A003,D3 ; (_Write)
RWcommon: jsr clearPB
move.L D1,A3 ;Gotta go indirect to get to count
move D0,paramBlock+ioRefNum(A5) ;Set up refNum
move.L (A3),paramBlock+ioReqCount(A5) ;Set up count
move.L D2,paramBlock+ioBuffer(A5) ;Set up buffPtr
lea paramBlock(A5),A0 ;Set up trap call
lea @1,A1
move D3,(A1)
@1: _Read ;Gets replaced by proper trap value
move.L paramBlock+ioActCount(A5),(A3) ;Return count
@2: rts
;------------------------------------------------------------------------------
; OSErr GetFPos(refNum, filePos)
; short refNum; (D0.W)
; long *filePos; (D1.L)
;------------------------------------------------------------------------------
XDEF GetFPos
GetFPos: jsr clearPB
move.L D1,A3
move D0,paramBlock+ioRefNum(A5) ;Set up refNum
lea paramBlock(A5),A0
_GetFPos
move.L paramBlock+ioPosOffset(A5),(A3) ;Return filePos
rts
;------------------------------------------------------------------------------
; OSErr SetFPos(refNum, posMode, posOff)
; short refNum; (D0.W)
; short posMode; (D1.W)
; long posOff; (D2.L)
;------------------------------------------------------------------------------
XDEF SetFPos
SetFPos: jsr clearPB
move D0,paramBlock+ioRefNum(A5)
move D1,paramBlock+ioPosMode(A5)
move.L D2,paramBlock+ioPosOffset(A5)
lea paramBlock(A5),A0
_SetFPos
rts
;------------------------------------------------------------------------------
; OSErr GetEOF(refNum, logEOF)
; short refNum; (D0.W)
; long *logEOF; (D1.L)
;------------------------------------------------------------------------------
XDEF GetEOF
GetEOF: jsr clearPB
move.L D1,A3
move D0,paramBlock+ioRefNum(A5)
lea paramBlock(A5),A0
_GetEOF
move.L paramBlock+ioLEOF(A5),(A3) ;Return logEOF
rts
;------------------------------------------------------------------------------
; OSErr SetEOF(refNum, filePos)
; short refNum; (D0.W)
; long logEOF; (D1.L)
;------------------------------------------------------------------------------
XDEF SetEOF
SetEOF: jsr clearPB
move D0,paramBlock+ioRefNum(A5)
move.L D1,paramBlock+ioLEOF(A5)
lea paramBlock(A5),A0
_SetEOF
rts
;------------------------------------------------------------------------------
; OSErr Allocate(refNum, count)
; short refNum; (D0.W)
; long count; (D1.L)
;------------------------------------------------------------------------------
XDEF Allocate
Allocate: jsr clearPB
move D0,paramBlock+ioRefNum(A5)
move.L D1,paramBlock+ioReqCount(A5)
lea paramBlock(A5),A0
_Allocate
rts
;------------------------------------------------------------------------------
; OSErr FSClose(refNum)
; short refNum; (D0.W)
;------------------------------------------------------------------------------
XDEF FSClose
FSClose: jsr clearPB
move D0,paramBlock+ioRefNum(A5)
lea paramBlock(A5),A0
_Close
rts
;------------------------------------------------------------------------------
; OSErr GetFInfo(fileName, vRefNum, fndrInfo)
; Str255 *fileName; (D0.L)
; short vRefNum; (D1.W)
; FInfo *fndrInfo; (D2.L)
;------------------------------------------------------------------------------
XDEF GetFInfo
GetFInfo: jsr clearPB
move.L D2,A3
jsr NameAndVref
_GetFileInfo
lea paramBlock+ioFlUsrWds(A5),A2
move.L (A2)+,(A3)+ ; (faster than _BlockMove)
move.L (A2)+,(A3)+
move.L (A2)+,(A3)+
move.L (A2),(A3)
rts ;We always return OSErr, regardless of signalflag
;------------------------------------------------------------------------------
; OSErr SetFInfo(fileName, vRefNum, fndrInfo)
; Str255 *fileName; (D0.L)
; short vRefNum; (D1.W)
; FInfo *fndrInfo; (D2.L)
;------------------------------------------------------------------------------
XDEF SetFInfo
SetFInfo: jsr clearPB
jsr NameAndVref
move.L D2,A1
lea paramBlock+ioFlUsrWds(A5),A2
move.L (A1)+,(A2)+ ; (faster than _BlockMove)
move.L (A1)+,(A2)+
move.L (A1)+,(A2)+
move.L (A1),(A2)
_SetFileInfo
rts
;------------------------------------------------------------------------------
; OSErr SetFLock(fileName, vRefNum)
; Str255 *fileName; (D0.L)
; short vRefNum; (D1.W)
;------------------------------------------------------------------------------
; OSErr RstFLock(fileName, vRefNum)
; Str255 *fileName; (D0.L)
; short vRefNum; (D1.W)
;------------------------------------------------------------------------------
; OSErr FSDelete(fileName, vRefNum)
; Str255 *fileName; (D0.L)
; short vRefNum; (D1.W)
;------------------------------------------------------------------------------
XDEF SetFLock
SetFLock: move #$A041,D2 ; (_SetFLock)
bra.S LkDlcommon
XDEF RstFLock
RstFLock: move #$A042,D2 ; (_RstFLock)
bra.S LkDlcommon
XDEF FSDelete
FSDelete: move #$A009,D2 ; (_Delete)
LkDlcommon: jsr clearPB
jsr NameAndVref
lea @1,A1
move D2,(A1)
@1: _RstFilLock ;Gets replaced by proper trap value
rts
;------------------------------------------------------------------------------
; OSErr Rename(oldName, vRefNum, newName)
; Str255 *oldName; (D0.L)
; short vRefNum; (D1.W)
; Str255 *newName; (D2.L)
;------------------------------------------------------------------------------
XDEF Rename
Rename: jsr clearPB
jsr NameAndVref
move.L D2,paramBlock+ioNewName(A5)
_Rename
rts
;------------------------------------------------------------------------------
; QHdrPtr GetFSQHdr()
;------------------------------------------------------------------------------
XDEF GetFSQHdr
GetFSQHdr
move.l fsQHdr,A0
rts
;------------------------------------------------------------------------------
; QHdrPtr GetVCBQHdr()
;------------------------------------------------------------------------------
XDEF GetVCBQHdr
GetVCBQHdr
move.l vcbQHdr,A0
rts
;------------------------------------------------------------------------------
; QHdrPtr GetDrvQHdr()
;------------------------------------------------------------------------------
XDEF GetDrvQHdr
GetDrvQHdr
move.l drvQHdr,A0
rts
END
--------------------------- end of posting ------------------------------------