/* 

 * tclMacThrd.c --

 *

 *	This file implements the Mac-specific thread support.

 *

 * Copyright (c) 1991-1994 The Regents of the University of California.

 * Copyright (c) 1994-1998 Sun Microsystems, Inc.

 *

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

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

 *

 * SCCS:  @(#) tclMacThrd.c 1.2 98/02/23 16:48:07

 */

#include "tclInt.h"

#include "tclPort.h"

#include "tclMacInt.h"

#include <Threads.h>

#include <Gestalt.h>

#define TCL_MAC_THRD_DEFAULT_STACK (256*1024)

typedef struct TclMacThrdData {

    ThreadID threadID;

    VOID *data;

    struct TclMacThrdData *next;

} TclMacThrdData;

/*

 * This is an array of the Thread Data Keys.  It is a process-wide table.

 * Its size is originally set to 32, but it can grow if needed.

 */

static TclMacThrdData **tclMacDataKeyArray;

#define TCL_MAC_INITIAL_KEYSIZE 32

/*

 * These two bits of data store the current maximum number of keys

 * and the keyCounter (which is the number of occupied slots in the

 * KeyData array.

 * 

 */

static int maxNumKeys = 0;

static int keyCounter = 0;

/*

 * Prototypes for functions used only in this file

 */

TclMacThrdData *GetThreadDataStruct(Tcl_ThreadDataKey keyVal);

TclMacThrdData *RemoveThreadDataStruct(Tcl_ThreadDataKey keyVal);

/*

 * Note: The race evoked by the emulation layer for joinable threads

 * (see ../win/tclWinThrd.c) cannot occur on this platform due to

 * the cooperative implementation of multithreading.

 */

/*

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

 *

 * TclMacHaveThreads --

 *

 *	Do we have the Thread Manager?

 *

 * Results:

 *	1 if the ThreadManager is present, 0 otherwise.

 *

 * Side effects:

 *	If this is the first time this is called, the return is cached.

 *

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

 */

int

TclMacHaveThreads(void)

{

    static initialized = false;

    static int tclMacHaveThreads = false;

    long response = 0;

    OSErr err = noErr;

    if (!initialized) {

	err = Gestalt(gestaltThreadMgrAttr, &response);

	if (err == noErr) {

	    tclMacHaveThreads = response | (1 << gestaltThreadMgrPresent);

	}

    }

    return tclMacHaveThreads;

}

/*

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

 *

 * Tcl_CreateThread --

 *

 *	This procedure creates a new thread.

 *

 * Results:

 *	TCL_OK if the thread could be created.  The thread ID is

 *	returned in a parameter.

 *

 * Side effects:

 *	A new thread is created.

 *

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

 */

int

Tcl_CreateThread(idPtr, proc, clientData, stackSize, flags)

    Tcl_ThreadId *idPtr;		/* Return, the ID of the thread */

    Tcl_ThreadCreateProc proc;		/* Main() function of the thread */

    ClientData clientData;		/* The one argument to Main() */

    int stackSize;			/* Size of stack for the new thread */

    int flags;				/* Flags controlling behaviour of

					 * the new thread */

{

    if (!TclMacHaveThreads()) {

        return TCL_ERROR;

    }

    if (stackSize == TCL_THREAD_STACK_DEFAULT) {

        stackSize = TCL_MAC_THRD_DEFAULT_STACK;

    }

#if TARGET_CPU_68K && TARGET_RT_MAC_CFM

    {

        ThreadEntryProcPtr entryProc;

        entryProc = NewThreadEntryUPP(proc);

        NewThread(kCooperativeThread, entryProc, (void *) clientData, 

            stackSize, kCreateIfNeeded, NULL, (ThreadID *) idPtr);

    }

#else

    NewThread(kCooperativeThread, proc, (void *) clientData, 

        stackSize, kCreateIfNeeded, NULL, (ThreadID *) idPtr);

#endif        

    if ((ThreadID) *idPtr == kNoThreadID) {

        return TCL_ERROR;

    } else {

        if (flags & TCL_THREAD_JOINABLE) {

	    TclRememberJoinableThread (*idPtr);

	}

        return TCL_OK;

    }

}

/*

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

 *

 * Tcl_JoinThread --

 *

 *	This procedure waits upon the exit of the specified thread.

 *

 * Results:

 *	TCL_OK if the wait was successful, TCL_ERROR else.

 *

 * Side effects:

 *	The result area is set to the exit code of the thread we

 *	waited upon.

 *

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

 */

int

Tcl_JoinThread(threadId, result)

    Tcl_ThreadId threadId; /* Id of the thread to wait upon */

    int*     result;	   /* Reference to the storage the result

			    * of the thread we wait upon will be

			    * written into. */

{

    if (!TclMacHaveThreads()) {

        return TCL_ERROR;

    }

    return TclJoinThread (threadId, result);

}

/*

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

 *

 * TclpThreadExit --

 *

 *	This procedure terminates the current thread.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	This procedure terminates the current thread.

 *

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

 */

void

TclpThreadExit(status)

    int status;

{

    ThreadID curThread;

    if (!TclMacHaveThreads()) {

        return;

    }

    GetCurrentThread(&curThread);

    TclSignalExitThread ((Tcl_ThreadId) curThread, status);

    DisposeThread(curThread, NULL, false);

}

/*

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

 *

 * Tcl_GetCurrentThread --

 *

 *	This procedure returns the ID of the currently running thread.

 *

 * Results:

 *	A thread ID.

 *

 * Side effects:

 *	None.

 *

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

 */

Tcl_ThreadId

Tcl_GetCurrentThread()

{

#ifdef TCL_THREADS

    ThreadID curThread;

    if (!TclMacHaveThreads()) {

        return (Tcl_ThreadId) 0;

    } else {

        GetCurrentThread(&curThread);

        return (Tcl_ThreadId) curThread;

    }

#else

    return (Tcl_ThreadId) 0;

#endif

}

/*

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

 *

 * TclpInitLock

 *

 *	This procedure is used to grab a lock that serializes initialization

 *	and finalization of Tcl.  On some platforms this may also initialize

 *	the mutex used to serialize creation of more mutexes and thread

 *	local storage keys.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Acquire the initialization mutex.

 *

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

 */

void

TclpInitLock()

{

#ifdef TCL_THREADS

    /* There is nothing to do on the Mac. */;

#endif

}

/*

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

 *

 * TclpInitUnlock

 *

 *	This procedure is used to release a lock that serializes initialization

 *	and finalization of Tcl.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Release the initialization mutex.

 *

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

 */

void

TclpInitUnlock()

{

#ifdef TCL_THREADS

    /* There is nothing to do on the Mac */;

#endif

}

/*

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

 *

 * TclpMasterLock

 *

 *	This procedure is used to grab a lock that serializes creation

 *	and finalization of serialization objects.  This interface is

 *	only needed in finalization; it is hidden during

 *	creation of the objects.

 *

 *	This lock must be different than the initLock because the

 *	initLock is held during creation of syncronization objects.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Acquire the master mutex.

 *

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

 */

void

TclpMasterLock()

{

#ifdef TCL_THREADS

    /* There is nothing to do on the Mac */;

#endif

}

/*

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

 *

 * TclpMasterUnlock

 *

 *	This procedure is used to release a lock that serializes creation

 *	and finalization of synchronization objects.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Release the master mutex.

 *

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

 */

void

TclpMasterUnlock()

{

#ifdef TCL_THREADS

    /* There is nothing to do on the Mac */

#endif

}

/*

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

 *

 * Tcl_GetAllocMutex

 *

 *	This procedure returns a pointer to a statically initialized

 *	mutex for use by the memory allocator.  The alloctor must

 *	use this lock, because all other locks are allocated...

 *

 * Results:

 *	A pointer to a mutex that is suitable for passing to

 *	Tcl_MutexLock and Tcl_MutexUnlock.

 *

 * Side effects:

 *	None.

 *

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

 */

Tcl_Mutex *

Tcl_GetAllocMutex()

{

    /* There is nothing to do on the Mac */

    return NULL;

}

#ifdef TCL_THREADS

/*

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

 *

 * Tcl_MutexLock --

 *

 *	This procedure is invoked to lock a mutex.  This procedure

 *	handles initializing the mutex, if necessary.  The caller

 *	can rely on the fact that Tcl_Mutex is an opaque pointer.

 *	This routine will change that pointer from NULL after first use.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	May block the current thread.  The mutex is aquired when

 *	this returns.  Will allocate memory for a pthread_mutex_t

 *	and initialize this the first time this Tcl_Mutex is used.

 *

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

 */

void

Tcl_MutexLock(mutexPtr)

    Tcl_Mutex *mutexPtr;	/* Really (pthread_mutex_t **) */

{

/* There is nothing to do on the Mac */

}

/*

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

 *

 * TclpMutexUnlock --

 *

 *	This procedure is invoked to unlock a mutex.  The mutex must

 *	have been locked by Tcl_MutexLock.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The mutex is released when this returns.

 *

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

 */

void

Tcl_MutexUnlock(mutexPtr)

    Tcl_Mutex *mutexPtr;	/* Really (pthread_mutex_t **) */

{

/* There is nothing to do on the Mac */

}

/*

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

 *

 * TclpFinalizeMutex --

 *

 *	This procedure is invoked to clean up one mutex.  This is only

 *	safe to call at the end of time.

 *

 *	This assumes the Master Lock is held.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The mutex list is deallocated.

 *

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

 */

void

TclpFinalizeMutex(mutexPtr)

    Tcl_Mutex *mutexPtr;

{

/* There is nothing to do on the Mac */

}

/*

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

 *

 * TclpThreadDataKeyInit --

 *

 *	This procedure initializes a thread specific data block key.

 *	Each thread has table of pointers to thread specific data.

 *	all threads agree on which table entry is used by each module.

 *	this is remembered in a "data key", that is just an index into

 *	this table.  To allow self initialization, the interface

 *	passes a pointer to this key and the first thread to use

 *	the key fills in the pointer to the key.  The key should be

 *	a process-wide static.

 *

 *      There is no system-wide support for thread specific data on the 

 *	Mac.  So we implement this as an array of pointers.  The keys are

 *	allocated sequentially, and each key maps to a slot in the table.

 *      The table element points to a linked list of the instances of

 *	the data for each thread.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Will bump the key counter if this is the first time this key

 *      has been initialized.  May grow the DataKeyArray if that is

 *	necessary.

 *

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

 */

void

TclpThreadDataKeyInit(keyPtr)

    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,

				 * really (pthread_key_t **) */

{

    if (*keyPtr == NULL) {

        keyCounter += 1;

	*keyPtr = (Tcl_ThreadDataKey) keyCounter;

	if (keyCounter > maxNumKeys) {

	    TclMacThrdData **newArray;

	    int i, oldMax = maxNumKeys;

	    maxNumKeys = maxNumKeys + TCL_MAC_INITIAL_KEYSIZE;

	    newArray = (TclMacThrdData **) 

	            ckalloc(maxNumKeys * sizeof(TclMacThrdData *));

	    for (i = 0; i < oldMax; i++) {

	        newArray[i] = tclMacDataKeyArray[i];

	    }

	    for (i = oldMax; i < maxNumKeys; i++) {

	        newArray[i] = NULL;

	    }

	    if (tclMacDataKeyArray != NULL) {

		ckfree((char *) tclMacDataKeyArray);

	    }

	    tclMacDataKeyArray = newArray;

	}             

	/* TclRememberDataKey(keyPtr); */

    }

}

/*

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

 *

 * TclpThreadDataKeyGet --

 *

 *	This procedure returns a pointer to a block of thread local storage.

 *

 * Results:

 *	A thread-specific pointer to the data structure, or NULL

 *	if the memory has not been assigned to this key for this thread.

 *

 * Side effects:

 *	None.

 *

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

 */

VOID *

TclpThreadDataKeyGet(keyPtr)

    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,

				 * really (pthread_key_t **) */

{

    TclMacThrdData *dataPtr;

    dataPtr = GetThreadDataStruct(*keyPtr);

    if (dataPtr == NULL) {

        return NULL;

    } else {

        return dataPtr->data;

    }

}

/*

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

 *

 * TclpThreadDataKeySet --

 *

 *	This procedure sets the pointer to a block of thread local storage.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Sets up the thread so future calls to TclpThreadDataKeyGet with

 *	this key will return the data pointer.

 *

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

 */

void

TclpThreadDataKeySet(keyPtr, data)

    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,

				 * really (pthread_key_t **) */

    VOID *data;			/* Thread local storage */

{

    TclMacThrdData *dataPtr;

    ThreadID curThread;

    dataPtr = GetThreadDataStruct(*keyPtr);

    /* 

     * Is it legal to reset the thread data like this?

     * And if so, who owns the memory?

     */

    if (dataPtr != NULL) {

        dataPtr->data = data;

    } else {

        dataPtr = (TclMacThrdData *) ckalloc(sizeof(TclMacThrdData));

        GetCurrentThread(&curThread);

        dataPtr->threadID = curThread;

        dataPtr->data = data;

        dataPtr->next = tclMacDataKeyArray[(int) *keyPtr - 1];

        tclMacDataKeyArray[(int) *keyPtr - 1] = dataPtr;

   }

}

/*

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

 *

 * TclpFinalizeThreadData --

 *

 *	This procedure cleans up the thread-local storage.  This is

 *	called once for each thread.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Frees up all thread local storage.

 *

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

 */

void

TclpFinalizeThreadData(keyPtr)

    Tcl_ThreadDataKey *keyPtr;

{

    TclMacThrdData *dataPtr;

    if (*keyPtr != NULL) {

        dataPtr = RemoveThreadDataStruct(*keyPtr);

	if ((dataPtr != NULL) && (dataPtr->data != NULL)) {

	    ckfree((char *) dataPtr->data);

	    ckfree((char *) dataPtr);

	}

    }

}

/*

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

 *

 * TclpFinalizeThreadDataKey --

 *

 *	This procedure is invoked to clean up one key.  This is a

 *	process-wide storage identifier.  The thread finalization code

 *	cleans up the thread local storage itself.

 *

 *      On the Mac, there is really nothing to do here, since the key

 *      is just an array index.  But we set the key to 0 just in case

 *	someone else is relying on that.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The keyPtr value is set to 0.

 *

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

 */

void

TclpFinalizeThreadDataKey(keyPtr)

    Tcl_ThreadDataKey *keyPtr;

{

    ckfree((char *) tclMacDataKeyArray[(int) *keyPtr - 1]);

    tclMacDataKeyArray[(int) *keyPtr - 1] = NULL;

    *keyPtr = NULL;

}

/*

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

 *

 * GetThreadDataStruct --

 *

 *	This procedure gets the data structure corresponding to

 *      keyVal for the current process.

 *

 * Results:

 *	The requested key data.

 *

 * Side effects:

 *	None.

 *

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

 */

TclMacThrdData *

GetThreadDataStruct(keyVal)

    Tcl_ThreadDataKey keyVal;

{

    ThreadID curThread;

    TclMacThrdData *dataPtr;

    /*

     * The keyPtr will only be greater than keyCounter is someone

     * has passed us a key without getting the value from 

     * TclpInitDataKey.

     */

    if ((int) keyVal <= 0)  {

        return NULL;

    } else if ((int) keyVal > keyCounter) {

        panic("illegal data key value");

    }

    GetCurrentThread(&curThread);

    for (dataPtr = tclMacDataKeyArray[(int) keyVal - 1]; dataPtr != NULL;

            dataPtr = dataPtr->next) {

        if (dataPtr->threadID ==  curThread) {

            break;

        }

    }

    return dataPtr;

}

/*

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

 *

 * RemoveThreadDataStruct --

 *

 *	This procedure removes the data structure corresponding to

 *      keyVal for the current process from the list kept for keyVal.

 *

 * Results:

 *	The requested key data is removed from the list, and a pointer 

 *      to it is returned.

 *

 * Side effects:

 *	None.

 *

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

 */

TclMacThrdData *

RemoveThreadDataStruct(keyVal)

    Tcl_ThreadDataKey keyVal;

{

    ThreadID curThread;

    TclMacThrdData *dataPtr, *prevPtr;

    if ((int) keyVal <= 0)  {

        return NULL;

    } else if ((int) keyVal > keyCounter) {

        panic("illegal data key value");

    }

    GetCurrentThread(&curThread);

    for (dataPtr = tclMacDataKeyArray[(int) keyVal - 1], prevPtr = NULL; 

            dataPtr != NULL;

            prevPtr = dataPtr, dataPtr = dataPtr->next) {

        if (dataPtr->threadID == curThread) {

            break;

        }

    }

    if (dataPtr == NULL) {

        /* No body */

    } else if ( prevPtr == NULL) {

        tclMacDataKeyArray[(int) keyVal - 1] = dataPtr->next;

    } else {

        prevPtr->next = dataPtr->next;

    }

    return dataPtr; 

}

/*

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

 *

 * Tcl_ConditionWait --

 *

 *	This procedure is invoked to wait on a condition variable.

 *	On the Mac, mutexes are no-ops, and we just yield.  After

 *	all, it is the application's job to loop till the condition 

 *	variable is changed...

 *

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Will block the current thread till someone else yields.

 *

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

 */

void

Tcl_ConditionWait(condPtr, mutexPtr, timePtr)

    Tcl_Condition *condPtr;	/* Really (pthread_cond_t **) */

    Tcl_Mutex *mutexPtr;	/* Really (pthread_mutex_t **) */

    Tcl_Time *timePtr;		/* Timeout on waiting period */

{

    if (TclMacHaveThreads()) {

        YieldToAnyThread();

    }

}

/*

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

 *

 * Tcl_ConditionNotify --

 *

 *	This procedure is invoked to signal a condition variable.

 *

 *	The mutex must be held during this call to avoid races,

 *	but this interface does not enforce that.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	May unblock another thread.

 *

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

 */

void

Tcl_ConditionNotify(condPtr)

    Tcl_Condition *condPtr;

{

    if (TclMacHaveThreads()) {

         YieldToAnyThread();

    }

}

/*

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

 *

 * TclpFinalizeCondition --

 *

 *	This procedure is invoked to clean up a condition variable.

 *	This is only safe to call at the end of time.

 *

 *	This assumes the Master Lock is held.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The condition variable is deallocated.

 *

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

 */

void

TclpFinalizeCondition(condPtr)

    Tcl_Condition *condPtr;

{

    /* Nothing to do on the Mac */

}

#endif /* TCL_THREADS */