/* 

  * 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 */