Split thread.c into a number of system-specific files.
Added Tim Peters' pthread version.
diff --git a/Python/thread_pthread.h b/Python/thread_pthread.h
new file mode 100644
index 0000000..b98c12f
--- /dev/null
+++ b/Python/thread_pthread.h
@@ -0,0 +1,272 @@
+/***********************************************************
+Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
+Amsterdam, The Netherlands.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+#ifdef sun
+#define FLORIDA_HACKS
+#endif
+
+#ifdef FLORIDA_HACKS
+/* Hacks for Florida State Posix threads implementation */
+#undef _POSIX_THREADS
+#include "/ufs/guido/src/python/Contrib/pthreads/pthreads/pthread.h"
+#define pthread_attr_default ((pthread_attr_t *)0)
+#define pthread_mutexattr_default ((pthread_mutexattr_t *)0)
+#define pthread_condattr_default ((pthread_condattr_t *)0)
+#define TRYLOCK_OFFSET 1
+#else /* !FLORIDA_HACKS */
+#include <pthread.h>
+#define TRYLOCK_OFFSET 0
+#endif /* FLORIDA_HACKS */
+#include <stdlib.h>
+
+/* A pthread mutex isn't sufficient to model the Python lock type (at
+ * least not the way KSR did 'em -- haven't dug thru the docs to verify),
+ * because a thread that locks a mutex can't then do a pthread_mutex_lock
+ * on it (to wait for another thread to unlock it).
+ * In any case, pthread mutexes are designed for serializing threads over
+ * short pieces of code, so wouldn't be an appropriate implementation of
+ * Python's locks regardless.
+ * The pthread_lock struct below implements a Python lock as a pthread
+ * mutex and a <condition, mutex> pair. In general, if the mutex can be
+ * be acquired instantly, it is, else the pair is used to block the
+ * thread until the mutex is released. 7 May 1994 [email protected]
+ */
+typedef struct {
+ /* the lock */
+ pthread_mutex_t mutex;
+ /* a <cond, mutex> pair to handle an acquire of a locked mutex */
+ pthread_cond_t cond;
+ pthread_mutex_t cmutex;
+} pthread_lock;
+
+/*
+ * Initialization.
+ */
+static void _init_thread _P0()
+{
+}
+
+/*
+ * Thread support.
+ */
+int start_new_thread _P2(func, void (*func) _P((void *)), arg, void *arg)
+{
+#if defined(SGI_THREADS) && defined(USE_DL)
+ long addr, size;
+ static int local_initialized = 0;
+#endif /* SGI_THREADS and USE_DL */
+ pthread_t th;
+ int success = 0; /* init not needed when SOLARIS_THREADS and */
+ /* C_THREADS implemented properly */
+
+ dprintf(("start_new_thread called\n"));
+ if (!initialized)
+ init_thread();
+ success = pthread_create(&th, pthread_attr_default, func, arg);
+ return success < 0 ? 0 : 1;
+}
+
+static void do_exit_thread _P1(no_cleanup, int no_cleanup)
+{
+ dprintf(("exit_thread called\n"));
+ if (!initialized)
+ if (no_cleanup)
+ _exit(0);
+ else
+ exit(0);
+}
+
+void exit_thread _P0()
+{
+ do_exit_thread(0);
+}
+
+void _exit_thread _P0()
+{
+ do_exit_thread(1);
+}
+
+#ifndef NO_EXIT_PROG
+static void do_exit_prog _P2(status, int status, no_cleanup, int no_cleanup)
+{
+ dprintf(("exit_prog(%d) called\n", status));
+ if (!initialized)
+ if (no_cleanup)
+ _exit(status);
+ else
+ exit(status);
+}
+
+void exit_prog _P1(status, int status)
+{
+ do_exit_prog(status, 0);
+}
+
+void _exit_prog _P1(status, int status)
+{
+ do_exit_prog(status, 1);
+}
+#endif /* NO_EXIT_PROG */
+
+/*
+ * Lock support.
+ */
+type_lock allocate_lock _P0()
+{
+ pthread_lock *lock;
+
+ dprintf(("allocate_lock called\n"));
+ if (!initialized)
+ init_thread();
+
+ lock = (pthread_lock *) malloc(sizeof(pthread_lock));
+ {
+ int err = 0;
+ if ( pthread_mutex_init(&lock->mutex,
+ pthread_mutexattr_default) ) {
+ perror("pthread_mutex_init");
+ err = 1;
+ }
+ if ( pthread_cond_init(&lock->cond,
+ pthread_condattr_default) ) {
+ perror("pthread_cond_init");
+ err = 1;
+ }
+ if ( pthread_mutex_init(&lock->cmutex,
+ pthread_mutexattr_default)) {
+ perror("pthread_mutex_init");
+ err = 1;
+ }
+ if (err) {
+ free((void *)lock);
+ lock = 0;
+ }
+ }
+
+ dprintf(("allocate_lock() -> %lx\n", (long)lock));
+ return (type_lock) lock;
+}
+
+void free_lock _P1(lock, type_lock lock)
+{
+ dprintf(("free_lock(%lx) called\n", (long)lock));
+ if ( pthread_mutex_destroy(&((pthread_lock *)lock)->mutex) )
+ perror("pthread_mutex_destroy");
+ if ( pthread_cond_destroy(&((pthread_lock *)lock)->cond) )
+ perror("pthread_cond_destroy");
+ if ( pthread_mutex_destroy(&((pthread_lock *)lock)->cmutex) )
+ perror("pthread_mutex_destroy");
+ free((void *)lock);
+}
+
+int acquire_lock _P2(lock, type_lock lock, waitflag, int waitflag)
+{
+ int success;
+
+ dprintf(("acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
+ {
+ pthread_lock *thelock = (pthread_lock *)lock;
+ success = TRYLOCK_OFFSET +
+ pthread_mutex_trylock( &thelock->mutex );
+ if (success < 0) {
+ perror("pthread_mutex_trylock [1]");
+ success = 0;
+ } else if ( success == 0 && waitflag ) {
+ /* continue trying until we get the lock */
+
+ /* cmutex must be locked by me -- part of the condition
+ * protocol */
+ if ( pthread_mutex_lock( &thelock->cmutex ) )
+ perror("pthread_mutex_lock");
+ while ( 0 == (success = TRYLOCK_OFFSET +
+ pthread_mutex_trylock(&thelock->mutex)) ) {
+ if ( pthread_cond_wait(&thelock->cond,
+ &thelock->cmutex) )
+ perror("pthread_cond_wait");
+ }
+ if (success < 0)
+ perror("pthread_mutex_trylock [2]");
+ /* now ->mutex & ->cmutex are both locked by me */
+ if ( pthread_mutex_unlock( &thelock->cmutex ) )
+ perror("pthread_mutex_unlock");
+ }
+ }
+ dprintf(("acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
+ return success;
+}
+
+void release_lock _P1(lock, type_lock lock)
+{
+ dprintf(("release_lock(%lx) called\n", (long)lock));
+ {
+ pthread_lock *thelock = (pthread_lock *)lock;
+
+ /* tricky: if the release & signal occur between the
+ * pthread_mutex_trylock(&thelock->mutex))
+ * and pthread_cond_wait during the acquire, the acquire
+ * will miss the signal it's waiting for; locking cmutex
+ * around the release prevents that
+ */
+ if (pthread_mutex_lock( &thelock->cmutex ))
+ perror("pthread_mutex_lock");
+ if (pthread_mutex_unlock( &thelock->mutex ))
+ perror("pthread_mutex_unlock");
+ if (pthread_mutex_unlock( &thelock->cmutex ))
+ perror("pthread_mutex_unlock");
+
+ /* wake up someone (anyone, if any) waiting on the lock */
+ if (pthread_cond_signal( &thelock->cond ))
+ perror("pthread_cond_signal");
+ }
+}
+
+/*
+ * Semaphore support.
+ */
+type_sema allocate_sema _P1(value, int value)
+{
+ char *sema = 0;
+ dprintf(("allocate_sema called\n"));
+ if (!initialized)
+ init_thread();
+
+ dprintf(("allocate_sema() -> %lx\n", (long) sema));
+ return (type_sema) sema;
+}
+
+void free_sema _P1(sema, type_sema sema)
+{
+ dprintf(("free_sema(%lx) called\n", (long) sema));
+}
+
+void down_sema _P1(sema, type_sema sema)
+{
+ dprintf(("down_sema(%lx) called\n", (long) sema));
+ dprintf(("down_sema(%lx) return\n", (long) sema));
+}
+
+void up_sema _P1(sema, type_sema sema)
+{
+ dprintf(("up_sema(%lx)\n", (long) sema));
+}
