Removed support for Mac OS Classic platform [Patch 918142]

1 files changed, 0 insertions, 871 deletions

diff --git a/mac/tclMacThrd.c b/mac/tclMacThrd.c
deleted file mode 100644
index 4d98d9c..0000000
--- a/mac/tclMacThrd.c
+++ /dev/null
@@ -1,871 +0,0 @@
-/* 
- * 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) {
-        Tcl_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) {
-        Tcl_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 */
-