Macintosh-SW
/
mac-rom
mirror of https://github.com/elliotnunn/mac-rom.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
mac-rom/ProcessMgr/SegmentLoaderPatches.c

789 lines
25 KiB
C
Raw Permalink Blame History

/*
File: SegmentLoaderPatches.c
Contains: Routines which patch the segment loader traps.
Written by: Erich Ringewald and Phil Goldman
Copyright: © 1986-1992 by Apple Computer, Inc., all rights reserved.
This file is used in these builds: System
Change History (most recent first):
<18> 5/21/92 gbm #1030303,<dty>: Start using the new (and improved!) 'SIZE'(1)
for launching, if itÕs present.
<17> 1/14/92 YK Take out <15>,<16> since we found a better way.
<16> 1/10/92 YK Oops, I didn't close the comment.
<15> 1/10/92 YK Check if the app is the Service Window Manager app (for TSM) in
GetSizeInfo, then set the flag. (this is a tentative solution)
<14> 7/26/91 stb use HOpenResFile instead of old glue
<13> 4/18/91 DFH TED, WS#DFH-910418b : Fixed LaunchApplication to restore the
zone in the error patch where the file could not be opened.
<12> 4/1/91 DFH (with John Iarocci) Merged in latest AUX support code. NOTE: No
AUX support code is referenced unless the build defines the
HAS_AUX_PROCESSMGR condition.
<11> 3/25/91 DFH JSM,#DFH-910325a: Fix SetAppParameters to deal with the fact
that the fabricated AppleEvent is in an unlocked handle.
<10> 2/28/91 DFH VL,#83781: Removed 32-bit clean check from LaunchApplication. It
is deemed no longer relevant, since Finder always overrode it.
<9> 2/21/91 DFH dba,#82504, #82681, #83168, #83182, #83207: Available memory
calc in StandardLaunch no longer needs special param for
ProcessMgrMaxBlock to be accurate.
<8> 1/31/91 DFH NGK,WS#DFH-910131a:Changed SetAppParameters so that launchee
gets a saeLaunchedWithoutDocs AppleEvent when the launcher
passed launchAppParameters == nil.
<7> 1/14/91 DFH (JDR) Conditionalize out AUX support.
<5> 12/5/90 DFH Integrated AUX support.
<4> 11/26/90 DFH Change trespass() to dbmsg().
<2> 10/30/90 csd Fixed some identifiers to match the newest interfaces.
<0> x/xx/86 PYG New Today.
*/
#include <types.h>
#include <memory.h>
#include <toolutils.h>
#include <osutils.h>
#include <quickdraw.h>
#include <fonts.h>
#include <events.h>
#include <devices.h>
#include <desk.h>
#include <resources.h>
#include <retrace.h>
#include <menus.h>
#include <windows.h>
#include <files.h>
#include <segload.h>
#include <errors.h>
#include <Aliases.h>
#include <folders.h>
#include <MFPrivate.h>
#include "Glue.h"
#include "Lomem.h"
#include "Data.h"
#include "SysMisc.h"
#include "Aux.h"
#include "Puppet.h"
#include "Zone.h"
#include "AppleEventExtensions.h"
/* Function prototypes internal to this file */
void OpenAppWDs(PEntryPtr);
void CopyAppParmHandle(AppParmRecHdl, PCB **);
void GetSizeInfo(swParmPtr, short);
void SyncSIZEInfo(void);
/* Some function prototypes that should be in (yet another) header file */
AppParmRecHdl AEParmToAppParmHandle(AppParametersPtr, PCB **);
Handle AppParmHandleToAEParm(AppParmRecHdl);
OSErr DecomposeWD(short, short *, unsigned long *);
void FPInit(void);
void NextAppFile(AppFile **);
unsigned long SizeOfThisAppFile(AppFile *);
void kill_dce(THz);
/* Macros for easy access to the _Launch parameters */
#define IS_EXTENDED_BLOCK(pLaunchBlock) ((pLaunchBlock)->launchBlockID == extendedBlock)
#define FIRST_EXTENSION_SIZE (2*sizeof(short))
#define SECOND_EXTENSION_SIZE ( FIRST_EXTENSION_SIZE + sizeof(ProcessSerialNumber) + 5*sizeof(long) )
/* This is roughly the memory overhead to handle an application that will have
* half a chance of running. It includes PCBs, HLists, 'lmem' resources, AppleEvents,
* etc. that are made in either the system heap or the Process Mgr heap.
*/
#define APPSIZESLOP (0x1000)
/* SyncSIZEInfo. Sync the SIZE information in case a pre-7.1 system has touched the SIZE(0)
* information but the SIZE(1) is not yet updated. We would prefer to use the SIZE(1) resource
* to do the launch, but only after it is up to date. Data is updated as follows: if the
* psize (preferred size) in the SIZE(0) is different from the same field in SIZE(1), then
* copy that size into SIZE(1). Then, if the msize (minimum size) in SIZE(1) is greater than
* the new psize, set msize the same as psize. If either SIZE(1) or SIZE(0) are
* missing, then bail.
*/
void
SyncSIZEInfo()
{
swParmHdl h0, h1;
/* Get the resources */
h0 = Get1Resource('SIZE', 0);
h1 = Get1Resource('SIZE', 1);
if ( h0 && h1 ) // if we have both handles, then do more stuff
{
if ( (**h0).psize != (**h1).psize )
{
(**h1).psize = (**h0).psize;
if ( (**h1).msize > (**h1).psize )
(**h1).msize = (**h1).psize;
ChangedResource( (Handle) h1 ); // if this fails, we donÕt care...
WriteResource( (Handle) h1 ); // ...the in-memory copy will still be right
}
}
}
/* GetSizeInfo. Extract SIZE information from current file. Supplies defaults
* in no-find case. The defaults were chosen with the assumption that the app
* is capable of running on a MacPlus. We also assume that the sizes (default or
* otherwise) were chosen with the MacPlus stack size in mind, and adjust them
* according to the stack size we'll actually use for this launch.
*/
void
GetSizeInfo(swParmPtr pSizeInfo, short firstChoice)
{
swParmHdl h;
/* Make sure the SIZE resources are correct */
SyncSIZEInfo();
/* First, try the preferred resource ID. This will either be a 1 for applications or
* a weird negative ID for DAs. If itÕs for a DA and itÕs unavailable, give up. If itÕs for
* an application and weÕre looking for ID 1 and itÕs unavailable, then try ID 0. If neither
* ID 0 or ID 1 (made by Finder) are present, try one more time for ID -1. If ID -1 canÕt be
* found, then just give up.
*/
if ( ((h = Get1Resource('SIZE', firstChoice)) == nil) && (firstChoice == 1) )
if ( (h = Get1Resource('SIZE', 0)) == nil )
h = Get1Resource('SIZE', -1);
/* Copy info if available. Otherwise, assume the app has old requirements. */
if (h != nil)
BlockMove(*h,pSizeInfo,sizeof(swParms));
else
{
pSizeInfo->flags = 0;
pSizeInfo->psize = (512*1024);
pSizeInfo->msize = (512*1024);
}
/* Normalize to MacPlus stack size if not a daemon */
if (((pSizeInfo->flags & modeOnlyBackground) == 0) && (DEFLTSTACK > MACPLUS_DEFLTSTACK))
{
unsigned long normalization;
normalization = DEFLTSTACK - MACPLUS_DEFLTSTACK;
pSizeInfo->psize += normalization;
pSizeInfo->msize += normalization;
}
}
/* StandardLaunch. Subroutinizes most of what it takes to launch an application
* into a process. Name and vRefNum specify the application resource file. Assumes
* that any necessary working directories have already been opened.
* Called internally, we may have extra flags on in the taskMode (such as to
* indicate a Desk Accessory launch).
* NOTE: Callers should be able to rely on launchResults->pNewProcess == nil if the result != noErr.
* NOTE: assumes a5 == PROCESSMGRGLOBALS
*/
void
StandardLaunch(FSSpecPtr pFileSpec, u_short launchFlags, u_long taskMode, Ptr pAppParms, LaunchResultsPtr launchResults, DASpecBlockPtr pDAInfo)
{
InternalLaunchPB ILParams;
swParms sizeInfo;
OSErr retVal;
short rfn, saveCurMap;
u_size appSize;
THz saveZone;
/* Fill in param block for lower routines */
ILParams.ilAppSpecPtr = pFileSpec;
ILParams.ilDAInfoPtr = pDAInfo;
ILParams.ilStackSize = DEFLTSTACK;
ILParams.ilAppParameters = pAppParms;
ILParams.ilAppParamHdl = nil;
/* In case of error */
launchResults->pNewProcess = nil;
appSize = 0;
/* Get access to the application resource file SIZE resource. Switch to the
* system heap, since the caller may not have enough room to even create the
* resource map when we open the file.
*/
saveCurMap = CURMAP;
SafeSetZone(saveZone, SYSZONE);
if ((taskMode & modeDeskAccessory) != 0)
{
UseResFile(0);
GetSizeInfo(&sizeInfo, DAH_SIZE_RESOURCE_ID);
}
else
{
SetResLoad(false);
rfn = HOpenResFile(pFileSpec->vRefNum, pFileSpec->parID, &pFileSpec->name,
((taskMode & modeMultiLaunch) != 0) ? fsRdPerm : fsCurPerm);
launchResults->LaunchError = RESERR;
SetResLoad(true);
/* Fail if we couldn't open the resource file */
if (rfn == (-1))
{
SafeRestoreZone(saveZone);
return;
}
/* Set the taskMode. OR in the MultiLaunch flag, and replace the low word
* with control information from the SIZE resource.
*/
if ((taskMode & FILE_FLAG_MULTILAUNCH) != 0)
taskMode |= modeMultiLaunch;
GetSizeInfo(&sizeInfo, 1); // <18>
/* Don't close yet so that we get opWrErr later on.
* NOTE: Closing the app file (we do it here in the non-continue case)
* has the potential for screwing up VBLs (and others?) that will still
* be running out of its code segments. Mostly a problem only if the
* heap moves before the VBLKILL in the launcher's ExitToShell.
*/
if ( ((launchFlags & launchContinue) == 0) || (rfn != CURAPREFNUM) )
CloseResFile(rfn);
}
/* Have to restore map, since app file might not have been at top of chain */
SafeRestoreZone(saveZone);
CURMAP = saveCurMap;
/* Copy the flags into the task mode */
ILParams.ilTaskMode = ((taskMode & 0xFFFF0000) | (u_long) sizeInfo.flags);
/* If it's a BG-only app, is that OK? */
if (((sizeInfo.flags & modeOnlyBackground) != 0)
&& ((launchFlags & launchInhibitDaemon) != 0))
{
launchResults->LaunchError = appIsDaemon;
return;
}
/* Try to launch in the preferred size */
ILParams.ilPartitionSize = sizeInfo.psize;
retVal = KernelLaunch(&ILParams);
/* If launch failed because there was not enough room, retry in smaller space
* if the user wants to, and the space is available. Use the largest available
* size, as long as it meets the application's minimum size requirement. Try to
* leave enough memory in ProcessMgrZone to allocate subordinate structures, like
* the PCB, HLists, etc.
* NOTE: Assumes that the partition is the next block allocated from the
* ProcessMgrZone (otherwise, we are not guaranteed to get full appSize).
*/
if (retVal == memFullErr)
{
appSize = ProcessMgrMaxBlock();
if (appSize < APPSIZESLOP)
appSize = 0;
else
appSize -= APPSIZESLOP;
/* Do we have enough to retry?
* NOTE: Assumes that the first KernelLaunch didn't change anything in ILParams.
*/
if ( (appSize >= sizeInfo.msize)
&& ((launchFlags & launchUseMinimum) != 0) )
{
ILParams.ilPartitionSize = appSize;
retVal = KernelLaunch(&ILParams);
appSize = 0;
}
}
if (retVal == noErr)
{
/* Synchronize count for scrap coercion */
(ILParams.ilResultProc)->p_cutcopycount = cutCopyCount;
/* Launching an app cancels an saeQuitAll */
if (pSystemQuitAllMsg != nil)
CancelQuitAll(&((ILParams.ilResultProc)->p_serialNumber));
}
/* Return output information */
launchResults->pNewProcess = ILParams.ilResultProc;
launchResults->AvailableSize = appSize;
launchResults->PreferredSize = sizeInfo.psize;
launchResults->MinimumSize = sizeInfo.msize;
launchResults->LaunchError = retVal;
}
#pragma segment INIT
/* LaunchFacelessTasks. Find and launch all background applications kept in the
* "extensions" folder.
* NOTE: Theoretically, FindFolder or HOpenResFile could move memory by calling
* _GetResource, which is a problem for the rsrc mgr routine CheckLoad(), which
* will save and restore TheZone for resources w/ resSysHeap set. Growing the
* system heap means moving ProcessMgrZone, so the resource manager save/restore would
* restore an obsolete value.
* NOTE: assumes a5 == PROCESSMGRGLOBALS
* NOTE: assumes THEZONE == ProcessMgrZone since we specifically restore it
*/
void
LaunchFacelessTasks(void)
{
LaunchResults bgLaunchResults;
swParms sizeInfo;
short rfn, saveCurMap;
FSSpec fileSpec;
CInfoPBRec cInfoPBRec;
/* Locate the startup folder. */
assert(THEZONE == ProcessMgrZone);
THEZONE = SYSZONE;
if (FindFolder(kOnSystemDisk, kExtensionFolderType, kDontCreateFolder,
&fileSpec.vRefNum, &fileSpec.parID) != noErr)
{
THEZONE = ProcessMgrZone;
return;
}
/* Now iterate over all the files in the directory */
cInfoPBRec.hFileInfo.ioNamePtr = &fileSpec.name;
cInfoPBRec.hFileInfo.ioVRefNum = fileSpec.vRefNum;
cInfoPBRec.hFileInfo.ioFDirIndex = 0;
cInfoPBRec.hFileInfo.ioCompletion = nil;
for(;;)
{
/* Reset parameters and get next file. Quit if directory went bad. */
cInfoPBRec.hFileInfo.ioDirID = fileSpec.parID;
cInfoPBRec.hFileInfo.ioFDirIndex++;
if (PBGetCatInfo(&cInfoPBRec, SyncHFS) != noErr)
break;
/* Don't try launch if file isn't an application */
if ( ((cInfoPBRec.hFileInfo.ioFlAttrib & FILE_ATTRIB_ISDIR) != 0)
|| (cInfoPBRec.hFileInfo.ioFlFndrInfo.fdType != 'appe') )
continue;
/* Don't launch if it is not a background-only system extension */
saveCurMap = CURMAP;
SetResLoad(false);
rfn = HOpenResFile(fileSpec.vRefNum, fileSpec.parID, &fileSpec.name, fsCurPerm);
SetResLoad(true);
if (rfn == (-1))
continue;
GetSizeInfo(&sizeInfo, 1); // <18>
CloseResFile(rfn);
CURMAP = saveCurMap;
if ((sizeInfo.flags & modeOnlyBackground) == 0)
continue;
/* Try the launch */
StandardLaunch(&fileSpec, 0, 0, nil, &bgLaunchResults, nil);
}
THEZONE = ProcessMgrZone;
}
#pragma segment Main
/* c_launch. Our patch to the _Launch trap. It has takes a parameter block that
* may be any of three different sizes. To make things worse, there are flag
* fields that can tell us to perform optional extra work so that the caller
* doesn't have to. Please excuse my GOTOs, but they were the most effective
* way to bail out of error conditions without some extremely unwieldy coding.
* This is essentially a wrapper for our internal routine StandardLaunch.
*/
#define APPPARMS_NOT_SPECIFIABLE (-1)
pascal long
c_launch(LaunchPBPtr pLaunchBlock)
{
u_short launchOpts, wdRefNumDst;
u_long blockLen, olda5;
Boolean alreadyLaunched;
FInfo fndrInfo;
unsigned short fileFlags;
Ptr appParms;
LaunchResults appLaunchResults;
FSSpec fileSpec, *pFileSpec;
#define pProc (appLaunchResults.pNewProcess)
#define retVal (appLaunchResults.LaunchError)
olda5 = ProcessMgrA5SimpleSetup();
/* Clear retVal, pProc, and SIZE information */
MemClear(&appLaunchResults, sizeof(LaunchResults));
/* Fill in default values for parameters that might not be there */
blockLen = 0;
pFileSpec = nil;
fileFlags = 0;
launchOpts = 0;
appParms = (Ptr) APPPARMS_NOT_SPECIFIABLE;
/* Get the parameters that were given */
blockLen = (IS_EXTENDED_BLOCK(pLaunchBlock)) ? pLaunchBlock->launchEPBLength : 0;
if (blockLen >= FIRST_EXTENSION_SIZE)
{
fileFlags = pLaunchBlock->launchFileFlags;
launchOpts = pLaunchBlock->launchControlFlags;
}
if (blockLen >= SECOND_EXTENSION_SIZE)
{
pFileSpec = pLaunchBlock->launchAppSpec;
pLaunchBlock->launchPreferredSize = 0;
pLaunchBlock->launchMinimumSize = 0;
pLaunchBlock->launchAvailableSize = 0;
if ((appParms = pLaunchBlock->launchAppParameters) == APPPARMS_NOT_SPECIFIABLE)
appParms = nil;
}
else
{
GetVol(0, &wdRefNumDst);
if ((retVal = FSMakeFSSpec(wdRefNumDst, 0, (StringPtr) pLaunchBlock->reserved1, &fileSpec)) != noErr)
goto AfterLaunch;
pFileSpec = &fileSpec;
}
/* Launch the application into a process. Relaunch existing application only if
* it is the caller himself and he is not trying to get a second copy!.
*/
alreadyLaunched = ((pProc = PEntryFromFileSpec(pFileSpec, nil)) != nil);
if ( (alreadyLaunched == false) ||
((pProc == pCurrentProcess) && ((launchOpts & launchContinue) == 0)) )
{
/* Get file's flags if the caller wants us to */
if ((launchOpts & launchNoFileFlags) != 0)
{
if ((retVal = FSpGetFInfo(pFileSpec, &fndrInfo)) != noErr)
goto AfterLaunch;
fileFlags = fndrInfo.fdFlags;
}
/* Try the launch */
StandardLaunch(pFileSpec, launchOpts, (u_long) fileFlags, appParms, &appLaunchResults, nil);
}
/* Return output parameters */
if (blockLen >= SECOND_EXTENSION_SIZE)
{
if (retVal == noErr)
pLaunchBlock->launchProcessSN = pProc->p_serialNumber;
else
SetPSN(kNoProcess, &pLaunchBlock->launchProcessSN);
pLaunchBlock->launchPreferredSize = appLaunchResults.PreferredSize;
pLaunchBlock->launchMinimumSize = appLaunchResults.MinimumSize;
pLaunchBlock->launchAvailableSize = appLaunchResults.AvailableSize;
}
AfterLaunch:
/* Arrange for the new app layer to be created in front, unless overridden. We then
* put the newborn to sleep until fg_resched decides to schedule it. This ensures
* that the app gets its first time in the foreground, and when there are no modals
* up. A "don't switcher" will be created in the very back (it doesn't matter
* whether there's a modal in this case).
* If the app was already launched, a simple SetFrontProcess will do.
*/
if (retVal == noErr)
{
if ( ((launchOpts & launchDontSwitch) == 0) &&
((pProc->p_taskmode & modeOnlyBackground) == 0) )
{
if ((SetFrontProcess(&pProc->p_serialNumber) == noErr)
&& (alreadyLaunched == false))
PutOnSleepQueue(pProc, MAXVALUE);
}
}
/* Old style launch causes the launcher to quit. This is true even if the new
* application fails to launch (no error return possible, so just beep).
*/
if ((launchOpts & launchContinue) == 0)
{
if (retVal != noErr)
SysBeep(20);
A5SimpleRestore(olda5);
ExitToShell();
dbmsg("ExitToShell in LaunchApplication failed.");
}
A5SimpleRestore(olda5);
/* Return short process descriptor or error to caller */
return ( ((retVal == noErr) && (blockLen < SECOND_EXTENSION_SIZE)) ? pProc->p_mypid : retVal);
#undef pProc
#undef retVal
}
#pragma segment kernel_segment
/* NewAppParmHandle. Create a blank AppParmRecHdl of the specified size.
* NOTE: Locking the AppParmHandle is done explicitly for MacWrite 4.5 (and
* 4.6?) and should someday be removed.
*/
AppParmRecHdl
NewAppParmHandle(Size theSize)
{
AppParmRecHdl retHdl;
ResrvMem(theSize);
if ((retHdl = (AppParmRecHdl) NewHandleClear(theSize)) != nil)
HLock(retHdl);
return(retHdl);
}
/* SizeOfThisAppFile. Figure out the size of the given AppFile structure. Allows
* for even alignment.
*/
unsigned long
SizeOfThisAppFile(AppFile *pAppFile)
{
register unsigned long theSize;
theSize = 2*sizeof(short) + sizeof(OSType) + Length(&(pAppFile->fName))+ 1;
WORD_ALIGN(theSize);
return(theSize);
}
/* NextAppFile. Moves the specified AppFile pointer past its data. */
void
NextAppFile(AppFile **ppAppFile)
{
AppFile *pAppFile;
/* Bump pointer by size of data */
pAppFile = *ppAppFile;
(Ptr) pAppFile += SizeOfThisAppFile(pAppFile);
*ppAppFile = pAppFile;
}
/* CopyAppParmHandle. Copy the specified AppParmRecHdl into the current zone, and
* set up the p_appWDList for later consumption by OpenAppWDs.
*/
void
CopyAppParmHandle(AppParmRecHdl sourceAPH, PCB **hPCB)
{
AppWDRecPtr dstLoc;
AppWDListPtr pWDList;
AppWDListHdl hWDList;
AppParmRecPtr pAPH;
AppFile *parmLoc;
short parmCount = 0, sizeOfStruct;
/* In case of error */
(*hPCB)->p_appWDList = nil;
/* Copy the APPPARMHANDLE into new zone. Allocate it low so we can lock it.
* NOTE: Locking the AppParmHandle is done explicitly for MacWrite 4.5 (and
* 4.6?) and should someday be removed.
*/
ResrvMem(GetHandleSize(sourceAPH));
HandToHand(&sourceAPH);
if (MEMERROR != noErr)
return;
HLock(sourceAPH);
APPPARMHANDLE = sourceAPH;
pAPH = *sourceAPH;
/* See how many files there are. Get out if there are none. */
parmCount = pAPH->count;
if (parmCount == 0)
return;
/* Allocate the list in a relocatable block in the current heap */
sizeOfStruct = sizeof(AppWDList) + (parmCount * sizeof(AppWDRec));
if ( (hWDList = (AppWDListHdl) NewHandleClear(sizeOfStruct)) == nil )
{
DisposHandle(sourceAPH);
return;
}
/* Traverse the APPPARMHANDLE to save off the WD information therein */
pWDList = *hWDList;
pWDList->wdlCount = parmCount;
dstLoc = &(pWDList->wdlDirectories);
parmLoc = &(pAPH->appFiles[0]);
while (parmCount-- != 0)
{
(void) DecomposeWD(parmLoc->vRefNum, &dstLoc->awdVolume, &dstLoc->awdDirID);
parmLoc->vRefNum = 0;
NextAppFile(&parmLoc);
dstLoc++;
}
(*hPCB)->p_appWDList = hWDList;
}
/* SetAppParameters. Ensures that the new app gets the intended parameters in a
* form it can understand. This can mean translating from an AppleEvent to an
* APPPARMHANDLE, or vice versa. It definitely means saving the necessary working
* directory info.
*/
void
SetAppParameters(PCB **hPCB, unsigned long currentA5, register InternalLaunchPBPtr pParams, Boolean appDoesEppc)
{
PCB *pPCB;
DASpecBlockPtr pDAInfo;
AppParmRecHdl aph;
struct appparmarea *parm;
/* Get the resource file directory. If this is DA Handler being launched,
* the resource file directory is the one containing the Desk Accessory file.
*/
pPCB = *hPCB;
if ((pDAInfo = pParams->ilDAInfoPtr) == nil)
{
pPCB->p_appVolume = (pParams->ilAppSpecPtr)->vRefNum;
pPCB->p_appDirID = (pParams->ilAppSpecPtr)->parID;
}
else
{
pPCB->p_appVolume = (pDAInfo->daFileSpec)->vRefNum;
pPCB->p_appDirID = (pDAInfo->daFileSpec)->parID;
}
/* Convert DocList to AppParmRecHdl or vice-versa. Do nothing for the thoroughly
* modern case of the launcher giving an AppleEvent to an AppleEvent-aware launchee,
* except to ensure that the launchee gets an saeLaunchedWithoutDocs ('oapp') in
* case ilAppParameters is nil (AppleEvent-aware applications count on seeing an
* AppleEvent at startup, knowing that it came from the launcher and not sometime
* after they were launched).
*/
aph = APPPARMHANDLE;
APPPARMHANDLE = nil;
if (pParams->ilAppParameters != APPPARMS_NOT_SPECIFIABLE)
{
if (appDoesEppc == false)
{
APPPARMHANDLE = AEParmToAppParmHandle(pParams->ilAppParameters, hPCB);
pParams->ilAppParameters = nil;
}
else if (pParams->ilAppParameters == nil)
pParams->ilAppParamHdl = AppParmHandleToAEParm(nil);
}
else
{
pParams->ilAppParameters = nil;
if (appDoesEppc)
pParams->ilAppParamHdl = AppParmHandleToAEParm(aph);
else if ((aph != nil) && (*aph != nil))
CopyAppParmHandle(aph, hPCB);
}
/* fix up application parameter area */
parm = (struct appparmarea *) ((Ptr)currentA5 + 8);
parm->stdin = 0;
parm->stdout = 0;
parm->physexec = 0;
parm->parmhandle = APPPARMHANDLE;
}
/* OpenAppWDs. Open the working directories needed by a new application. Also
* sets CURDIRSTORE and SFSAVEDISK according to the last file in APPPARMHANDLE
* (if there is no APPPARMHANDLE, it uses the resource file directory).
*/
void
OpenAppWDs(PEntryPtr pProc)
{
AppWDListHdl hWDList;
AppWDRecPtr pWDInfo;
short wdCount;
WDPBRec wdpbrec;
AppFile *pAppFile;
PCB *pPCB;
/* Open home working directory */
wdpbrec.ioNamePtr = nil;
wdpbrec.ioCompletion = nil;
pPCB = *(pProc->p_pcb);
wdpbrec.ioVRefNum = pPCB->p_appVolume;
wdpbrec.ioWDDirID = pPCB->p_appDirID;
wdpbrec.ioWDProcID = 0;
PBOpenWD(&wdpbrec, SyncHFS);
(*pProc->p_pcb)->p_vrefnum = wdpbrec.ioVRefNum;
SetVol(nil, wdpbrec.ioVRefNum);
/* Get list of parameter WDs to open, if any. */
if ((hWDList = (*pProc->p_pcb)->p_appWDList) == nil)
{
SFSAVEDISK = -(pPCB->p_appVolume);
CURDIRSTORE = pPCB->p_appDirID;
return;
}
/* Traverse said list, opening a WD from the component info. Note that the
* volume/dirid that ultimately get used for SFSAVEDISK and CURDIRSTORE will
* be from the last AppFile in APPPARMHANDLE.
*/
HLock(hWDList);
wdCount = (*hWDList)->wdlCount;
pWDInfo = &((*hWDList)->wdlDirectories);
if (APPPARMHANDLE != nil)
pAppFile = &((*(AppParmRecHdl) APPPARMHANDLE)->appFiles[0]);
while (wdCount-- != 0)
{
wdpbrec.ioVRefNum = pWDInfo->awdVolume;
wdpbrec.ioWDDirID = pWDInfo->awdDirID;
wdpbrec.ioWDProcID = 0;
PBOpenWD(&wdpbrec, SyncHFS);
pAppFile->vRefNum = wdpbrec.ioVRefNum;
SFSAVEDISK = -(pWDInfo->awdVolume);
CURDIRSTORE = pWDInfo->awdDirID;
NextAppFile(&pAppFile);
pWDInfo++;
}
/* Free the memory */
DisposHandle(hWDList);
(*pProc->p_pcb)->p_appWDList = nil;
}
/* BeginApplication. Code executed by a newborn process after it is switched in for
* the very first time. Set up the toolbox and OS worlds.
*/
void
BeginApplication(void)
{
#ifdef HAS_AUX_PROCESSMGR
void (*auxidleprocptr)();
#endif HAS_AUX_PROCESSMGR
unsigned long olda5;
olda5 = ProcessMgrA5SimpleSetup();
if (MachineHasFPU)
FPInit();
/* Fix up working directories for home directory and files in APPPARMHANDLE */
OpenAppWDs(pCurrentProcess);
#ifdef HAS_AUX_PROCESSMGR
auxidleprocptr = ((pCurrentProcess->p_taskmode & COFF_BINARY) != 0) ? AUX_IdleProc : nil;
#endif HAS_AUX_PROCESSMGR
A5SimpleRestore(olda5);
/* now call toolbox/system initializing trap */
InitApplication();
#ifdef HAS_AUX_PROCESSMGR
/* Let coff binary be initialized and scheduled by AUX.
* NOTE: AUX context switch will probably occur hereÉ
*/
if (auxidleprocptr != nil)
(*auxidleprocptr)();
#endif HAS_AUX_PROCESSMGR
}
#pragma segment kernel_segment
/* c_rdrvrinstall. Fix up the unit table when the application zone is nuked.
* NOTE: Also, gives appropriate GBKisses to drivers, which is not done in the ROM
* routine (Done inline in _ExitToShell/_Launch) but no one except _ExitToShell should
* be calling this anyway.
* NOTE: Needs to be same segment as kill_dce.
*/
pascal void
c_rdrvrinstall(void)
{
kill_dce(APPLZONE);
}
Reference in New Issue View Git Blame Copy Permalink