/*

 * tclMacLibrary.c --

 *

 *	This file should be included in Tcl extensions that want to 

 *	automatically open their resource forks when the code is linked. 

 *	These routines should not be exported but should be compiled 

 *	locally by each fragment.  Many thanks to Jay Lieske

 *	<lieske@princeton.edu> who provide an initial version of this

 *	file.

 *

 * Copyright (c) 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: tclMacLibrary.c,v 1.5 2001/11/23 01:27:39 das Exp $

 */

/*

 * Here is another place that we are using the old routine names...

 */

#include <CodeFragments.h>

#include <Errors.h>

#include <Resources.h>

#include <Strings.h>

#include "tclMacInt.h"

#if defined(TCL_REGISTER_LIBRARY) && defined(USE_TCL_STUBS)

#error "Can't use TCL_REGISTER_LIBRARY and USE_TCL_STUBS at the same time!"

/*

 * Can't register a library with Tcl when using stubs in the current

 * implementation, since Tcl_InitStubs hasn't been called yet

 *  when OpenLibraryResource is executing. 

 */

#endif

/*

 * These function are not currently defined in any header file.  The

 * only place they should be used is in the Initialization and

 * Termination entry points for a code fragment.  The prototypes

 * are included here to avoid compile errors.

 */

OSErr TclMacInitializeFragment _ANSI_ARGS_((

			struct CFragInitBlock* initBlkPtr));

void TclMacTerminateFragment _ANSI_ARGS_((void));

/*

 * Static functions in this file.

 */

static OSErr OpenLibraryResource _ANSI_ARGS_((

			struct CFragInitBlock* initBlkPtr));

static void CloseLibraryResource _ANSI_ARGS_((void));

/* 

 * The refnum of the opened resource fork.

 */

static short ourResFile = kResFileNotOpened;

/*

 * This is the resource token for the our resource file.

 * It stores the name we registered with the resource facility.

 * We only need to use this if we are actually registering ourselves.

 */

#ifdef TCL_REGISTER_LIBRARY

static Tcl_Obj *ourResToken;

#endif

/*

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

 *

 * TclMacInitializeFragment --

 *

 *	Called by MacOS CFM when the shared library is loaded. All this

 *	function really does is give Tcl a chance to open and register

 *	the resource fork of the library. 

 *

 * Results:

 *	MacOS error code if loading should be canceled.

 *

 * Side effects:

 *	Opens the resource fork of the shared library file.

 *

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

 */

OSErr

TclMacInitializeFragment(

    struct CFragInitBlock* initBlkPtr)		/* Pointer to our library. */

{

    OSErr err = noErr;

#ifdef __MWERKS__

    {

    	extern OSErr __initialize( CFragInitBlock* initBlkPtr);

    	err = __initialize((CFragInitBlock *) initBlkPtr);

    }

#endif

    if (err == noErr)

    	err = OpenLibraryResource( initBlkPtr);

    return err;

}

/*

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

 *

 * TclMacTerminateFragment --

 *

 *	Called by MacOS CFM when the shared library is unloaded.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The resource fork of the code fragment is closed.

 *

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

 */

void 

TclMacTerminateFragment()

{

    CloseLibraryResource();

#ifdef __MWERKS__

    {

    	extern void __terminate(void);

    	__terminate();

    }

#endif

}

/*

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

 *

 * OpenLibraryResource --

 *

 *	This routine can be called by a MacOS fragment's initialiation 

 *	function to open the resource fork of the file.  

 *	Call it with the same data passed to the initialization function. 

 *	If the fragment loading should fail if the resource fork can't 

 *	be opened, then the initialization function can pass on this 

 *	return value.

 *

 *      If you #define TCL_REGISTER_RESOURCE before compiling this resource, 

 *	then your library will register its open resource fork with the

 *      resource command.

 *

 * Results:

 *	It returns noErr on success and a MacOS error code on failure.

 *

 * Side effects:

 *	The resource fork of the code fragment is opened read-only and 

 *	is installed at the head of the resource chain.

 *

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

 */

static OSErr 

OpenLibraryResource(

    struct CFragInitBlock* initBlkPtr)

{

    /*

     * The 3.0 version of the Universal headers changed CFragInitBlock

     * to an opaque pointer type.  CFragSystem7InitBlock is now the

     * real pointer.

     */

#if !defined(UNIVERSAL_INTERFACES_VERSION) || (UNIVERSAL_INTERFACES_VERSION < 0x0300)

    struct CFragInitBlock *realInitBlkPtr = initBlkPtr;

#else 

    CFragSystem7InitBlock *realInitBlkPtr = (CFragSystem7InitBlock *) initBlkPtr;

#endif

    FSSpec* fileSpec = NULL;

    OSErr err = noErr;

    if (realInitBlkPtr->fragLocator.where == kDataForkCFragLocator) {

    	fileSpec = realInitBlkPtr->fragLocator.u.onDisk.fileSpec;

    } else if (realInitBlkPtr->fragLocator.where == kResourceCFragLocator) {

    	fileSpec = realInitBlkPtr->fragLocator.u.inSegs.fileSpec;

    } else {

    	err = resFNotFound;

    }

    /*

     * Open the resource fork for this library in read-only mode.  

     * This will make it the current res file, ahead of the 

     * application's own resources.

     */

    if (fileSpec != NULL) {

	ourResFile = FSpOpenResFile(fileSpec, fsRdPerm);

	if (ourResFile == kResFileNotOpened) {

	    err = ResError();

	} else {

#ifdef TCL_REGISTER_LIBRARY

	    ourResToken = Tcl_NewObj();

	    Tcl_IncrRefCount(ourResToken);

	    p2cstr(realInitBlkPtr->libName);

	    Tcl_SetStringObj(ourResToken, (char *) realInitBlkPtr->libName, -1);

	    c2pstr((char *) realInitBlkPtr->libName);

	    TclMacRegisterResourceFork(ourResFile, ourResToken,

	            TCL_RESOURCE_DONT_CLOSE);

#endif

            SetResFileAttrs(ourResFile, mapReadOnly);

	}

    }

    return err;

}

/*

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

 *

 * CloseLibraryResource --

 *

 *	This routine should be called by a MacOS fragment's termination 

 *	function to close the resource fork of the file 

 *	that was opened with OpenLibraryResource.  

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The resource fork of the code fragment is closed.

 *

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

 */

static void

CloseLibraryResource()

{

    if (ourResFile != kResFileNotOpened) {

#ifdef TCL_REGISTER_LIBRARY

        int length;

        TclMacUnRegisterResourceFork(

	        Tcl_GetStringFromObj(ourResToken, &length),

                NULL);

        Tcl_DecrRefCount(ourResToken);

#endif

	CloseResFile(ourResFile);

	ourResFile = kResFileNotOpened;

    }

}