/* 

  * tclMacExit.c --

  *

  *	This file contains routines that deal with cleaning up various state

  *	when Tcl/Tk applications quit.  Unfortunantly, not all state is cleaned

  *	up by the process when an application quites or crashes.  Also you

  *	need to do different things depending on wether you are running as

  *	68k code, PowerPC, or a code resource.  The Exit handler code was 

  *	adapted from code posted on alt.sources.mac by Dave Nebinger.

  *

  * Copyright (c) 1995 Dave Nebinger.

  * Copyright (c) 1995-1996 Sun Microsystems, Inc.

  *

  * See the file "license.terms" for information on usage and redistribution

  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

  *

  * RCS: @(#) $Id: tclMacExit.c,v 1.4 1999/04/16 00:47:19 stanton Exp $

  */

 #include "tclInt.h"

 #include "tclMacInt.h"

 #include <SegLoad.h>

 #include <Traps.h>

 #include <Processes.h>

 /*

  * Various typedefs and defines needed to patch ExitToShell.

  */

 enum {

         uppExitToShellProcInfo = kPascalStackBased

 };

 #if GENERATINGCFM

 typedef UniversalProcPtr ExitToShellUPP;

 #define CallExitToShellProc(userRoutine)        \

         CallUniversalProc((UniversalProcPtr)(userRoutine),uppExitToShellProcInfo)

 #define NewExitToShellProc(userRoutine) \

         (ExitToShellUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), \

 		uppExitToShellProcInfo, GetCurrentArchitecture())

 #else

 typedef ExitToShellProcPtr ExitToShellUPP;

 #define CallExitToShellProc(userRoutine)        \

         (*(userRoutine))()

 #define NewExitToShellProc(userRoutine) \

         (ExitToShellUPP)(userRoutine)

 #endif

 #define DisposeExitToShellProc(userRoutine) \

         DisposeRoutineDescriptor(userRoutine)

 #if defined(powerc)||defined(__powerc)

 #pragma options align=mac68k

 #endif

 struct ExitToShellUPPList{

         struct ExitToShellUPPList* nextProc;

         ExitToShellUPP userProc;

 };

 #if defined(powerc)||defined(__powerc)

 #pragma options align=reset

 #endif

 typedef struct ExitToShellDataStruct ExitToShellDataRec,* ExitToShellDataPtr,** ExitToShellDataHdl;

 typedef struct ExitToShellUPPList ExitToShellUPPList,* ExitToShellUPPListPtr,** ExitToShellUPPHdl;

 #if defined(powerc)||defined(__powerc)

 #pragma options align=mac68k

 #endif

 struct ExitToShellDataStruct{

     unsigned long a5;

     ExitToShellUPPList* userProcs;

     ExitToShellUPP oldProc;

 };

 #if defined(powerc)||defined(__powerc)

 #pragma options align=reset

 #endif

 /*

  * Static globals used within this file.

  */

 static ExitToShellDataPtr gExitToShellData = (ExitToShellDataPtr) NULL;

 /*

  *----------------------------------------------------------------------

  *

  * TclPlatformExit --

  *

  *	This procedure implements the Macintosh specific exit routine.

  *	We explicitly callthe ExitHandler function to do various clean

  *	up.  

  *

  * Results:

  *	None.

  *

  * Side effects:

  *	We exit the process.

  *

  *----------------------------------------------------------------------

  */

 void

 TclpExit(

     int status)		/* Ignored. */

 {

     TclMacExitHandler();

 /* 

  * If we are using the Metrowerks Standard Library, then we will call its exit so that it

  * will get a chance to clean up temp files, and so forth.  It always calls the standard 

  * ExitToShell, so the Tcl handlers will also get called.

  *   

  * If you have another exit, make sure that it does not patch ExitToShell, and does

  * call it.  If so, it will probably work as well.

  *

  */

 #ifdef __MSL__    

     exit(status);

 #else

     ExitToShell();

 #endif

 }

 /*

  *----------------------------------------------------------------------

  *

  * TclMacExitHandler --

  *

  *	This procedure is invoked after Tcl at the last possible moment

  *	to clean up any state Tcl has left around that may cause other

  *	applications to crash.  For example, this function can be used

  *	as the termination routine for CFM applications.

  *

  * Results:

  *	None.

  *

  * Side effects:

  *	Various cleanup occurs.

  *

  *----------------------------------------------------------------------

  */

 void

 TclMacExitHandler()

 {

     ExitToShellUPPListPtr curProc;

     /*

      * Loop through all installed Exit handlers

      * and call them.  Always make sure we are in

      * a clean state in case we are recursivly called.

      */

     if ((gExitToShellData) != NULL && (gExitToShellData->userProcs != NULL)){

 	/*

 	 * Call the installed exit to shell routines.

 	 */

 	curProc = gExitToShellData->userProcs;

 	do {

 	    gExitToShellData->userProcs = curProc->nextProc;

 	    CallExitToShellProc(curProc->userProc);

 	    DisposeExitToShellProc(curProc->userProc);

 	    DisposePtr((Ptr) curProc);

 	    curProc = gExitToShellData->userProcs;

 	} while (curProc != (ExitToShellUPPListPtr) NULL);

     }

     return;

 }

 /*

  *----------------------------------------------------------------------

  *

  * TclMacInstallExitToShellPatch --

  *

  *	This procedure installs a way to clean up state at the latest

  *	possible moment before we exit.  These are things that must

  *	be cleaned up or the system will crash.  The exact way in which

  *	this is implemented depends on the architecture in which we are

  *	running.  For 68k applications we patch the ExitToShell call.

  *	For PowerPC applications we just create a list of procs to call.

  *	The function ExitHandler should be installed in the Code 

  *	Fragments terminiation routine.

  *

  * Results:

  *	None.

  *

  * Side effects:

  *	Installs the new routine.

  *

  *----------------------------------------------------------------------

  */

 OSErr 

 TclMacInstallExitToShellPatch(

     ExitToShellProcPtr newProc)		/* Function pointer. */

 {

     ExitToShellUPP exitHandler;

     ExitToShellUPPListPtr listPtr;

     if (gExitToShellData == (ExitToShellDataPtr) NULL){

 	TclMacInitExitToShell(true);

     }

     /*

      * Add the passed in function pointer to the list of functions

      * to be called when ExitToShell is called.

      */

     exitHandler = NewExitToShellProc(newProc);

     listPtr = (ExitToShellUPPListPtr) NewPtrClear(sizeof(ExitToShellUPPList));

     listPtr->userProc = exitHandler;

     listPtr->nextProc = gExitToShellData->userProcs;

     gExitToShellData->userProcs = listPtr;

     return noErr;

 }

 /*

  *----------------------------------------------------------------------

  *

  * ExitToShellPatchRoutine --

  *

  *	This procedure is invoked when someone calls ExitToShell for

  *	this application.  This function performs some last miniute

  *	clean up and then calls the real ExitToShell routine.

  *

  * Results:

  *	None.

  *

  * Side effects:

  *	Various cleanup occurs.

  *

  *----------------------------------------------------------------------

  */

 static pascal void

 ExitToShellPatchRoutine()

 {

     ExitToShellUPP oldETS;

     long oldA5;

     /*

      * Set up our A5 world.  This allows us to have

      * access to our global variables in the 68k world.

      */

     oldA5 = SetCurrentA5();

     SetA5(gExitToShellData->a5);

     /*

      * Call the function that invokes all

      * of the handlers.

      */

     TclMacExitHandler();

     /*

      * Call the origional ExitToShell routine.

      */

     oldETS = gExitToShellData->oldProc;

     DisposePtr((Ptr) gExitToShellData);

     SetA5(oldA5);

     CallExitToShellProc(oldETS);

     return;

 }

 /*

  *----------------------------------------------------------------------

  *

  * TclMacInitExitToShell --

  *

  *	This procedure initializes the ExitToShell clean up machanism.

  *	Generally, this is handled automatically when users make a call

  *	to InstallExitToShellPatch.  However, it can be called 

  *	explicitly at startup time to turn off the patching mechanism.

  *	This can be used by code resources which could be removed from

  *	the application before ExitToShell is called.

  *

  *	Note, if we are running from CFM code we never install the

  *	patch.  Instead, the function ExitHandler should be installed

  *	as the terminiation routine for the code fragment.

  *

  * Results:

  *	None.

  *

  * Side effects:

  *	Creates global state.

  *

  *----------------------------------------------------------------------

  */

 void 

 TclMacInitExitToShell(

     int usePatch)	/* True if on 68k. */

 {

     if (gExitToShellData == (ExitToShellDataPtr) NULL){

 #if GENERATINGCFM

 	gExitToShellData = (ExitToShellDataPtr)

 	  NewPtr(sizeof(ExitToShellDataRec));

 	gExitToShellData->a5 = SetCurrentA5();

 	gExitToShellData->userProcs = (ExitToShellUPPList*) NULL;

 #else

 	ExitToShellUPP oldExitToShell, newExitToShellPatch;

 	short exitToShellTrap;

 	/*

 	 * Initialize patch mechanism.

 	 */

 	gExitToShellData = (ExitToShellDataPtr) NewPtr(sizeof(ExitToShellDataRec));

 	gExitToShellData->a5 = SetCurrentA5();

 	gExitToShellData->userProcs = (ExitToShellUPPList*) NULL;

 	/*

 	 * Save state needed to call origional ExitToShell routine.  Install

 	 * the new ExitToShell code in it's place.

 	 */

 	if (usePatch) {

 	    exitToShellTrap = _ExitToShell & 0x3ff;

 	    newExitToShellPatch = NewExitToShellProc(ExitToShellPatchRoutine);

 	    oldExitToShell = (ExitToShellUPP)

 	      NGetTrapAddress(exitToShellTrap, ToolTrap);

 	    NSetTrapAddress((UniversalProcPtr) newExitToShellPatch,

 		    exitToShellTrap, ToolTrap);

 	    gExitToShellData->oldProc = oldExitToShell;

 	}

 #endif

     }

 }