Merge John Bossom's code into the main trunk. See ChangeLog for details.snapshot-1999-01-04-1305

This will be tagged as snapshot-1999-01-04-1305

1 files changed, 819 insertions, 222 deletions

diff --git a/pthread.h b/pthread.h
index ef22d80..702028f 100644
--- a/pthread.h
+++ b/pthread.h
@@ -1,33 +1,199 @@
 /* This is the POSIX thread API (POSIX 1003).
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public
-License as published by the Free Software Foundation; either
-version 2 of the License, or (at your option) any later version.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-*/
-
-/* FIXME: do not include function prototypes for functions which are
-   not yet implemented.  This will allow us to keep a better handle on
-   where we're at. */
-
-#ifndef _PTHREADS_H
-#define _PTHREADS_H
-
-/* Convert these to defined when implemented. */
-#define _POSIX_THREAD_ATTR_STACKSIZE
-#ifdef _POSIX_THREAD_ATTR_STACKADDR
-#undef _POSIX_THREAD_ATTR_STACKADDR
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * -------------------------------------------------------------
+ *
+ *
+ * Module: pthread.h
+ *
+ * Purpose:
+ *      Provides an implementation of PThreads based upon the
+ *      standard:
+ *
+ *              POSIX 1003.1c-1995      (POSIX.1c)
+ *
+ * Authors:
+ *      Contributors are listed in the file "MAINTAINERS".
+ *
+ * The following functions are implemented:
+ *      ---------------------------
+ *      PThreads
+ *      ---------------------------
+ *      pthread_attr_init
+ *      pthread_attr_destroy
+ *      pthread_attr_getdetachstate
+ *      pthread_attr_getstackaddr
+ *      pthread_attr_getstacksize
+ *      pthread_attr_setdetachstate     
+ *      pthread_attr_setstackaddr
+ *      pthread_attr_setstacksize
+ *
+ *      pthread_create
+ *      pthread_detach
+ *      pthread_equal
+ *      pthread_exit
+ *      pthread_join
+ *      pthread_self
+ *      sched_yield
+ *
+ *      pthread_cancel
+ *      pthread_cleanup_pop
+ *      pthread_cleanup_push
+ *      pthread_setcancelstate
+ *      pthread_setcanceltype
+ *      pthread_testcancel
+ *
+ *      ---------------------------
+ *      Thread Specific Data
+ *      ---------------------------
+ *      pthread_key_create
+ *      pthread_key_delete
+ *      pthread_setspecific
+ *      pthread_getspecific
+ *
+ *      ---------------------------
+ *      Mutexes
+ *      ---------------------------
+ *      pthread_mutexattr_init
+ *      pthread_mutexattr_destroy
+ *      pthread_mutexattr_getpshared
+ *      pthread_mutexattr_setpshared
+ *
+ *      pthread_mutex_init
+ *      pthread_mutex_destroy
+ *      pthread_mutex_lock
+ *      pthread_mutex_trylock
+ *      pthread_mutex_unlock
+ *
+ *      ---------------------------
+ *      Condition Variables
+ *      ---------------------------
+ *      pthread_condattr_init
+ *      pthread_condattr_destroy
+ *      pthread_condattr_getpshared
+ *      pthread_condattr_setpshared
+ *
+ *      pthread_cond_init
+ *      pthread_cond_destroy
+ *      pthread_cond_wait
+ *      pthread_cond_timedwait
+ *      pthread_cond_signal
+ *      pthread_cond_broadcast
+ *
+ *      ---------------------------
+ *      Protected Methods
+ *      ---------------------------
+ *      pthreadCancelableWait
+ *
+ *      ---------------------------
+ *      RealTime Scheduling:
+ *      ---------------------------
+ *      pthread_attr_getschedparam
+ *      pthread_attr_setschedparam
+ *      pthread_getschedparam
+ *      pthread_setschedparam
+ *      sched_get_priority_max
+ *      sched_get_priority_min
+ *
+ *      ---------------------------
+ *      Signals:
+ *      ---------------------------
+ *      pthread_sigmask
+ *
+ * Limitations
+ * ===========
+ *      The following functions are not implemented:
+ *
+ *      ---------------------------
+ *      RealTime Scheduling:
+ *      ---------------------------
+ *      pthread_attr_getinheritsched
+ *      pthread_attr_getschedpolicy
+ *      pthread_attr_getscope
+ *      pthread_attr_setinheritsched
+ *      pthread_attr_setschedpolicy
+ *      pthread_attr_setscope
+ *      pthread_mutex_getprioceiling
+ *      pthread_mutex_setprioceiling
+ *      pthread_mutex_attr_getprioceiling
+ *      pthread_mutex_attr_getprotocol
+ *      pthread_mutex_attr_setprioceiling
+ *      pthread_mutex_attr_setprotocol
+ *
+ *      ---------------------------
+ *      Fork Handlers:
+ *      ---------------------------
+ *      pthread_atfork
+ *
+ *      ---------------------------
+ *      Stdio:
+ *      ---------------------------
+ *      flockfile
+ *      ftrylockfile
+ *      funlockfile
+ *      getc_unlocked
+ *      getchar_unlocked
+ *      putc_unlocked
+ *      putchar_unlocked
+ *
+ *      ---------------------------
+ *      Thread-Safe C Runtime Library:
+ *      ---------------------------
+ *      readdir_r
+ *      getgrgid_r
+ *      getgrnam_r
+ *      getpwuid_r
+ *      getpwnam_r
+ *
+ *      ---------------------------
+ *      Signals:
+ *      ---------------------------
+ *      pthread_kill
+ *      sigtimedwait
+ *      sigwait
+ *      sigwaitinfo
+ *
+ *
+ * -------------------------------------------------------------
+ */
+#if !defined( PTHREAD_H )
+#define PTHREAD_H
+
+#ifdef _WIN32
+/*
+ * Disable following warnings when including Windows headers
+ *
+ * warning C4115: named type definition in parentheses
+ * warning C4116: unnamed type definition in parentheses
+ * warning C4127: conditional expression is constant
+ * warning C4201: nonstandard extension used : nameless struct/union
+ * warning C4214: nonstandard extension used : bit field types other than int
+ * warning C4514: unreferenced inline function has been removed
+ */
+#pragma warning( disable : 4115 4116 4127 4201 4214 4514)
 #endif
 
+/*
+ * -----------------
+ * autoconf switches
+ * -----------------
+ */
+
 #if HAVE_CONFIG_H
 #include "config.h"
 #endif /* HAVE_CONFIG_H */
@@ -58,299 +224,730 @@ struct timespec {
 #define SIG_SETMASK 2
 #endif /* SIG_SETMASK */
 
-#define PTHREAD_STACK_MIN   65535
 
-/* Thread scheduling policies */
+#include <process.h>
+#include <errno.h>
 
-#define SCHED_OTHER 0
-#define SCHED_FIFO  1
-#define SCHED_RR    2
-
-#define SCHED_MIN   SCHED_OTHER
-#define SCHED_MAX   SCHED_RR
+#ifdef _WIN32
+/*
+ * Re-enable all but 4127, 4514
+ */
+#pragma warning( default : 4115 4116 4201 4214)
+#endif
 
-/* Cancelation return value.
-   This value must be neither NULL nor the value of any
-   pointer to an object in memory. */
-#define PTHREAD_CANCELED            ((void *) 1)
+#if !defined( TRUE )
+#define TRUE	!FALSE
+#define FALSE	0
+#endif /* !TRUE */
 
-#define PTHREAD_MUTEX_INITIALIZER {0 /* ignore internals */ }
-#define PTHREAD_ONCE_INIT { 0, PTHREAD_MUTEX_INITIALIZER }
 
-typedef struct _pthread * pthread_t;
-typedef struct {
-	int valid;
-	CRITICAL_SECTION cs;
-} pthread_mutex_t;
+#include <semaphore.h>
+/* #include <sched.h> /**/
 
 
-typedef DWORD pthread_key_t;
+#ifdef __cplusplus
+extern "C"
+{
+#endif				/* __cplusplus */
+
+/*
+ * -------------------------------------------------------------
+ *
+ * POSIX 1003.1c-1995 Options
+ * ===========================
+ *
+ * _POSIX_SEMAPHORES
+ *                      Semaphores come from POSIX.1b (POSIX 1003.1b-1993)
+ *                      rather than from PThreads. This macro indicates
+ *                      that POSIX Semaphores are supported:
+ *                              sem_destroy
+ *                              sem_init
+ *                              sem_wait
+ *                              sem_trywait
+ *                              sem_post
+ *
+ * _POSIX_THREADS (set)
+ *                      If set, you can use threads
+ *
+ * _POSIX_THREAD_ATTR_STACKSIZE (set)
+ *                      If set, you can control the size of a thread's
+ *                      stack
+ *                              pthread_attr_getstacksize
+ *                              pthread_attr_setstacksize
+ *
+ * _POSIX_THREAD_ATTR_STACKADDR (not set)
+ *                      If set, you can allocate and control a thread's
+ *                      stack. If not supported, the following functions
+ *                      will return ENOSYS, indicating they are not
+ *                      supported:
+ *                              pthread_attr_getstackaddr
+ *                              pthread_attr_setstackaddr
+ *
+ * _POSIX_THREAD_PRIORITY_SCHEDULING (not set)
+ *                      If set, you can use realtime scheduling.
+ *                      Indicates the availability of:
+ *                              pthread_attr_getinheritsched
+ *                              pthread_attr_getschedparam
+ *                              pthread_attr_getschedpolicy
+ *                              pthread_attr_getscope
+ *                              pthread_attr_setinheritsched
+ *                              pthread_attr_setschedparam
+ *                              pthread_attr_setschedpolicy
+ *                              pthread_attr_setscope
+ *                              pthread_getschedparam
+ *                              pthread_setschedparam
+ *                              pthread_get_priority_max
+ *                              pthread_get_priority_min
+ *
+ * _POSIX_THREAD_PRIO_INHERIT (not set)
+ *                      If set, you can create priority inheritance
+ *                      mutexes.
+ *                              pthread_mutexattr_getprotocol +
+ *                              pthread_mutexattr_setprotocol +
+ *
+ * _POSIX_THREAD_PRIO_PROTECT (not set)
+ *                      If set, you can create priority ceiling mutexes
+ *                      Indicates the availability of:
+ *                              pthread_mutex_getprioceiling
+ *                              pthread_mutex_setprioceiling
+ *                              pthread_mutexattr_getprioceiling
+ *                              pthread_mutexattr_getprotocol     +
+ *                              pthread_mutexattr_setprioceiling
+ *                              pthread_mutexattr_setprotocol     +
+ *
+ * _POSIX_THREAD_PROCESS_SHARED (not set)
+ *                      If set, you can create mutexes and condition
+ *                      variables that can be shared with another
+ *                      process.If set, indicates the availability
+ *                      of:
+ *                              pthread_mutexattr_getpshared
+ *                              pthread_mutexattr_setpshared
+ *                              pthread_condattr_getpshared
+ *                              pthread_condattr_setpshared
+ *
+ * _POSIX_THREAD_SAFE_FUNCTIONS (set)
+ *                      If set you can use the special *_r library
+ *                      functions that provide thread-safe behaviour
+ *
+ *      + These functions provide both 'inherit' and/or
+ *        'protect' protocol, based upon these macro
+ *        settings.
+ *
+ * POSIX 1003.1c-1995 Limits
+ * ===========================
+ *
+ * PTHREAD_DESTRUCTOR_ITERATIONS
+ *                      Maximum number of attempts to destroy
+ *                      a thread's thread-specific data on
+ *                      termination (must be at least 4)
+ *
+ * PTHREAD_KEYS_MAX
+ *                      Maximum number of thread-specific data keys
+ *                      available per process (must be at least 128)
+ *
+ * PTHREAD_STACK_MIN
+ *                      Minimum supported stack size for a thread
+ *
+ * PTHREAD_THREADS_MAX
+ *                      Maximum number of threads supported per
+ *                      process (must be at least 64).
+ *
+ * -------------------------------------------------------------
+ */
+
+/*
+ * POSIX Options
+ */
+#define _POSIX_THREADS
+#define _POSIX_SEMAPHORES
+#define _POSIX_THREAD_SAFE_FUNCTIONS
 
+#define _POSIX_THREAD_ATTR_STACKSIZE
 
-/*                                      Related constants */
-typedef struct {
-  long valid;
+#if defined( KLUDGE )
+/*
+ * The following are not supported
+ */
+#define _POSIX_THREAD_ATTR_STACKADDR
+#define _POSIX_THREAD_PRIORITY_SCHEDULING
+#define _POSIX_THREAD_PRIO_INHERIT
+#define _POSIX_THREAD_PRIO_PROTECT
+#define _POSIX_THREAD_PROCESS_SHARED
+
+#endif				/* KLUDGE */
+
+/*
+ * POSIX Limits
+ *
+ *      PTHREAD_DESTRUCTOR_ITERATIONS
+ *              Standard states this must be at least
+ *              4.
+ *
+ *      PTHREAD_KEYS_MAX
+ *              WIN32 permits only 64 TLS keys per process.
+ *              This limitation could be worked around by
+ *              simply simulating keys.
+ *
+ *      PTHREADS_STACK_MIN
+ *              artibrarily chose 1K. By default, WIN32
+ *              selects 1Meg stacks.
+ *
+ *      PTHREAD_THREADS_MAX
+ *              Not documented by WIN32. Wrote a test program
+ *              that kept creating threads until it failed
+ *              revealed this approximate number.
+ *
+ */
+#define PTHREAD_DESTRUCTOR_ITERATIONS	                   4
+#define PTHREAD_KEYS_MAX				  64
+#define PTHREAD_STACK_MIN				1024
+#define PTHREAD_THREADS_MAX				2019
+
+
+  typedef struct pthread_t_ *pthread_t;
+  typedef struct pthread_attr_t_ *pthread_attr_t;
+  typedef struct pthread_once_t_ pthread_once_t;
+  typedef struct pthread_key_t_ *pthread_key_t;
+  typedef struct pthread_mutex_t_ pthread_mutex_t;
+  typedef struct pthread_mutexattr_t_ pthread_mutexattr_t;
+  typedef struct pthread_cond_t_ *pthread_cond_t;
+  typedef struct pthread_condattr_t_ *pthread_condattr_t;
+
+
+/*
+ * ====================
+ * ====================
+ * POSIX Threads
+ * ====================
+ * ====================
+ */
+
+/*
+ * pthread_attr_{get,set}detachstate
+ */
+#define PTHREAD_CREATE_JOINABLE		0
+#define PTHREAD_CREATE_DETACHED		1
+
+/*
+ * pthread_attr{get,set}inheritsched
+ */
+#define PTHREAD_INHERIT_SCHED		0
+#define PTHREAD_EXPLICIT_SCHED		1
+
+/*
+ * pthread_setcancelstate paramters
+ */
+#define PTHREAD_CANCEL_ENABLE		0
+#define PTHREAD_CANCEL_DISABLE		1
+
+/*
+ * pthread_setcanceltype parameters
+ */
+#define PTHREAD_CANCEL_ASYNCHRONOUS	0
+#define PTHREAD_CANCEL_DEFERRED		1
+
+/*
+ * ====================
+ * ====================
+ * Mutex
+ * ====================
+ * ====================
+ */
+
+/* FIXME: Replace the NULL with a valid critical section initializer
+ * and then also change the 0 (first element) to 1.
+ */
+#define PTHREAD_MUTEX_INITIALIZER { 0, NULL }
+
+
+/*
+ * pthread_mutexattr_{get,set}pshared
+ * pthread_condattr_{get,set}pshared
+ */
+#define PTHREAD_PROCESS_PRIVATE		0
+#define PTHREAD_PROCESS_SHARED		1
+
+
+/*
+ * ====================
+ * ====================
+ * Once Key
+ * ====================
+ * ====================
+ */
+#define PTHREAD_ONCE_INIT	 { 0, PTHREAD_MUTEX_INITIALIZER }
+
+
+/*
+ * ====================
+ * ====================
+ * Condition Variable
+ * ====================
+ * ====================
+ */
+#define PTHREAD_COND_INITIALIZER { {0, 0}, 0, PTHREAD_MUTEX_INITIALIZER }
+
+
+/*
+ * ====================
+ * ====================
+ * Opaque Structure Definitions
+ * ====================
+ * ====================
+ */
+
+typedef enum {
+  /*
+   * This enumeration represents the state of the thread;
+   * The thread is still "alive" if the numeric value of the
+   * state is greater or equal "PThreadStateRunning".
+   */
+  PThreadStateInitial = 0,	/* Thread not running                   */
+  PThreadStateRunning,	        /* Thread alive & kicking               */
+  PThreadStateSuspended,	/* Thread alive but suspended           */
+  PThreadStateCanceling,	/* Thread alive but and is              */
+                                /* in the process of terminating        */
+                                /* due to a cancellation request        */
+  PThreadStateException,	/* Thread alive but exiting             */
+                                /* due to an exception                  */
+  PThreadStateLast
+}
+PThreadState;
+
+
+typedef enum {
+  /*
+   * This enumeration represents the reason why a thread has
+   * terminated/is terminating.
+   */
+  PThreadDemisePeaceful = 0,	/* Death due natural causes     */
+  PThreadDemiseCancelled,	/* Death due to user cancel     */
+  PThreadDemiseException,	/* Death due to unhandled       */
+                                /* exception                    */
+  PThreadDemiseNotDead	/* I'm not dead!                */
+}
+PThreadDemise;
+
+
+struct pthread_t_ {
+  DWORD thread;
+  HANDLE threadH;
+  PThreadState state;
+  PThreadDemise demise;
+  void *exitStatus;
+  void *parms;
+  int detachState;
+  int cancelState;
+  int cancelType;
+  HANDLE cancelEvent;
+  int implicit:1;
+  void *keys;
+};
 
-#ifdef _POSIX_THREAD_ATTR_STACKSIZE
-  size_t stacksize;                  /* PTHREAD_STACK_MIN */
-#endif
 
-  int detachedstate;                 /* PTHREAD_CREATE_DETACHED
-					PTHREAD_CREATE_JOINABLE */
+/* 
+ * Special value to mark attribute objects as valid.
+ */
+#define _PTHREAD_ATTR_VALID 0xC4C0FFEE
 
+struct pthread_attr_t_ {
+  long valid;
+  void *stackaddr;
+  size_t stacksize;
+  int detachstate;
+  int priority;
 #if HAVE_SIGSET_T
   sigset_t sigmask;
 #endif /* HAVE_SIGSET_T */
+};
 
-  int priority;
 
-} pthread_attr_t;
+struct pthread_mutex_t_ {
+	int valid;
+	CRITICAL_SECTION cs;
+  };
+
+
+struct pthread_mutexattr_t_ {
+  int pshared;
+};
 
-/* I don't know why this structure isn't in some kind of namespace.
-   According to my O'Reilly book, this is what this struct is
-   called. */
-struct sched_param {
-  int sched_priority;
+
+struct pthread_key_t_ {
+  DWORD key;
+  void (*destructor) (void *);
+  pthread_mutex_t threadsLock;
+  void *threads;
 };
 
-enum { SIGNAL, BROADCAST, NUM_EVENTS };
 
-typedef struct {
-  /* Signal and broadcast event HANDLEs. */
-  HANDLE events[NUM_EVENTS];
+struct pthread_cond_t_ {
+  long waiters;                       /* # waiting threads             */
+  pthread_mutex_t waitersLock;        /* Mutex that guards access to 
+					 waiter count                  */
+  sem_t sema;                         /* Queue up threads waiting for the 
+					 condition to become signaled  */
+  HANDLE waitersDone;                 /* An auto reset event used by the 
+					 broadcast/signal thread to wait 
+					 for the waiting thread(s) to wake
+					 up and get a chance at the  
+					 semaphore                     */
+  int wasBroadcast;                   /* keeps track if we are signaling 
+					 or broadcasting               */
+};
+
 
-  /* Count of the number of waiters. */
-  unsigned waiters_count;
-  
-  /* Serialize access to waiters_count. */
-  pthread_mutex_t waiters_count_lock;
-} pthread_cond_t;
+struct pthread_condattr_t_ {
+  int pshared;
+};
 
-typedef struct { void * dummy; } pthread_condattr_t;
-typedef struct { void * dummy; } pthread_mutexattr_t;
 
-typedef struct {
+struct pthread_once_t_ {
   unsigned short flag;
   pthread_mutex_t lock;
-} pthread_once_t;
+};
 
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
 
-int pthread_atfork (void (*prepare)(void),
-		    void (*parent)(void),
-		    void (*child)(void));
+/*
+ * ====================
+ * ====================
+ * Scheduling
+ * ====================
+ * ====================
+ */
 
-int pthread_create(pthread_t *thread,
-		   const pthread_attr_t *attr,
-		   void * (*start_routine) (void *),
-		   void * arg);
+/* Thread scheduling policies */
 
-void pthread_exit(void *value);
+#define SCHED_OTHER 0
+#define SCHED_FIFO  1
+#define SCHED_RR    2
 
-pthread_t pthread_self(void);
+#define SCHED_MIN   SCHED_OTHER
+#define SCHED_MAX   SCHED_RR
 
-int pthread_equal(pthread_t t1, pthread_t t2);
+  struct sched_param {
+    int sched_priority;
+  };
 
-int pthread_join(pthread_t thread, void ** valueptr);
 
-int pthread_detach(pthread_t thread);
 
-int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));
+/* There are three implementations of cancel cleanup.
+ *
+ *   C
+ *   C++ (as per Cygwin32 or Mingw32)
+ *   WIN32 SEH or C++
+ */
 
-/* Functions for manipulating thread attribute objects. */
+  typedef struct _pthread_cleanup_t _pthread_cleanup_t;
 
-int pthread_attr_init(pthread_attr_t *attr);
+  struct _pthread_cleanup_t
+    {
+      void (*routine) (void *);
+      void *arg;
+#if !defined(__cplusplus)
+      _pthread_cleanup_t *prev;
+#endif
+    };
+
+#ifndef __cplusplus
+
+/*
+ * C implementation of PThreads cancel cleanup
+ */
+
+#define pthread_cleanup_push( _rout, _arg ) \
+	{ \
+	    _pthread_cleanup_t	_cleanup; \
+            \
+	    _pthread_push_cleanup( &_cleanup, (_rout), (_arg) ); \
+
+#define pthread_cleanup_pop( _execute ) \
+	    (void) _pthread_pop_cleanup( _execute ); \
+	}
+
+#else /* !__cplusplus */
+
+#ifdef _WIN32
+	/*
+	 * WIN32 SEH version of cancel cleanup.
+	 */
+
+#define pthread_cleanup_push( _rout, _arg ) \
+	{ \
+	    _pthread_cleanup_t	_cleanup; \
+	    \
+            _cleanup.routine	= (_rout); \
+	    _cleanup.arg	= (_arg); \
+	    __try \
+	      { \
+
+#define pthread_cleanup_pop( _execute ) \
+	      } \
+	    __finally \
+		{ \
+		    if( _execute || AbnormalTermination()) \
+		      { \
+			  (*(_cleanup.routine))( _cleanup.arg ); \
+		      } \
+		} \
+	}
+
+#else /* _WIN32 */
+
+	/*
+	 * C++ (ie. Cygwin32 or Mingw32) version of cancel cleanup.
+	 *
+	 * Emulate try-finally behaviour.
+	 */
+
+#define pthread_cleanup_push( _rout, _arg ) \
+	{ \
+	    _pthread_cleanup_t	_cleanup; \
+	    \
+            _cleanup.routine	= (_rout); \
+	    _cleanup.arg	= (_arg); \
+	    try \
+	      { \
+
+#define pthread_cleanup_pop( _execute ) \
+	      } \
+	    catch(...) \
+	      { \
+		  (*(_cleanup.routine))( _cleanup.arg ); \
+		  \
+		  throw; \
+	      } \
+              \
+	      if (_execute) \
+		{ \
+		    (*(_cleanup.routine))( _cleanup.arg ); \
+		} \
+      	}
 
-int pthread_attr_destroy(pthread_attr_t *attr);
+#endif /* _WIN32 */
 
-int pthread_attr_setstacksize(pthread_attr_t *attr,
-			      size_t stacksize);
+#endif /* !__cplusplus */
 
-int pthread_attr_getstacksize(const pthread_attr_t *attr,
-			      size_t *stacksize);
+/*
+ * ===============
+ * ===============
+ * Methods
+ * ===============
+ * ===============
+ */
 
-int pthread_attr_setstackaddr(pthread_attr_t *attr,
-			      void *stackaddr);
+/*
+ * PThread Attribute Functions
+ */
+int pthread_attr_init (pthread_attr_t * attr);
 
-int pthread_attr_getstackaddr(const pthread_attr_t *attr,
-			      void **stackaddr);
+int pthread_attr_destroy (pthread_attr_t * attr);
 
-int pthread_attr_getschedparam(const pthread_attr_t *attr,
-			       struct sched_param *param);
+int pthread_attr_getdetachstate (const pthread_attr_t * attr,
+				 int *detachstate);
 
-int pthread_attr_setschedparam(pthread_attr_t *attr,
-			       const struct sched_param *param);
+int pthread_attr_getstackaddr (const pthread_attr_t * attr,
+			       void **stackaddr);
 
-int pthread_attr_getdetachstate(const pthread_attr_t *attr,
-				int *detachstate);
+int pthread_attr_getstacksize (const pthread_attr_t * attr,
+			       size_t * stacksize);
 
-int pthread_attr_setdetachstate(pthread_attr_t *attr,
-				int detachstate);
-  
-int pthread_setschedparam(pthread_t thread,
-			  int policy,
-			  const struct sched_param *param);
+int pthread_attr_setdetachstate (pthread_attr_t * attr,
+				 int detachstate);
 
-int pthread_getschedparam(pthread_t thread,
-			  int *policy,
-			  struct sched_param *param);
+int pthread_attr_setstackaddr (pthread_attr_t * attr,
+			       void *stackaddr);
 
-int sched_get_priority_min(int policy);
+int pthread_attr_setstacksize (pthread_attr_t * attr,
+			       size_t stacksize);
 
-int sched_get_priority_max(int policy);
+/*
+ * PThread Functions
+ */
+int pthread_create (pthread_t * tid,
+		    const pthread_attr_t * attr,
+		    void *(*start) (void *),
+		    void *arg);
 
-int pthread_setcancelstate(int state,
-			   int *oldstate);
+int pthread_detach (pthread_t tid);
 
-int pthread_setcanceltype(int type,
-			  int *oldtype);
+int pthread_equal (pthread_t t1,
+		   pthread_t t2);
 
-/* Functions for manipulating cond. var. attribute objects. */
+int pthread_exit (void *value_ptr);
 
-int pthread_condattr_init(pthread_condattr_t *attr);
+int pthread_join (pthread_t thread,
+		  void **value_ptr);
 
-int pthread_condattr_setpshared(pthread_condattr_t *attr,
-			       int pshared);
+pthread_t pthread_self (void);
 
-int pthread_condattr_getpshared(pthread_condattr_t *attr,
-				int *pshared);
+int pthread_cancel (pthread_t thread);
 
-int pthread_condattr_destroy(pthread_condattr_t *attr);
+#ifndef __cplusplus
+_pthread_cleanup_t *_pthread_pop_cleanup (int execute);
 
-/* Functions for manipulating mutex attribute objects. */
+void _pthread_push_cleanup (_pthread_cleanup_t * cleanup,
+			   void (*routine) (void *),
+			   void *arg);
+#endif /* !__cplusplus */
 
-int pthread_mutexattr_init(pthread_mutexattr_t *attr);
+int pthread_setcancelstate (int state,
+			    int *oldstate);
 
-int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
+int pthread_setcanceltype (int type,
+			   int *oldtype);
 
-/* Primitives for condition variables. */
+void pthread_testcancel (void);
 
-int pthread_cond_init(pthread_cond_t *cv,
-		      const pthread_condattr_t *attr);
+int pthread_once (pthread_once_t * once_control,
+		  void (*init_routine) (void));
 
-int pthread_cond_broadcast(pthread_cond_t *cv);
+/*
+ * Thread Specific Data Functions
+ */
+int pthread_key_create (pthread_key_t * key,
+			void (*destructor) (void *));
 
-int pthread_cond_signal(pthread_cond_t *cv);
+int pthread_key_delete (pthread_key_t key);
 
-int pthread_cond_timedwait(pthread_cond_t *cv,
-			   pthread_mutex_t *mutex,
-			   const struct timespec *abstime);
+int pthread_setspecific (pthread_key_t key,
+			 const void *value);
 
-int pthread_cond_wait(pthread_cond_t *cv,
-		      pthread_mutex_t *mutex);
+void *pthread_getspecific (pthread_key_t key);
 
-int pthread_cond_destroy(pthread_cond_t *cv);
 
-/* Primitives for mutexes. */
+/*
+ * Mutex Attribute Functions
+ */
+int pthread_mutexattr_init (pthread_mutexattr_t * attr);
 
-int pthread_mutex_init(pthread_mutex_t *mutex,
-		       const pthread_mutexattr_t *attr);
+int pthread_mutexattr_destroy (pthread_mutexattr_t * attr);
 
-int pthread_mutex_destroy(pthread_mutex_t *mutex);
+int pthread_mutexattr_getpshared (const pthread_mutexattr_t
+				  * attr,
+				  int *pshared);
 
-int pthread_mutex_lock(pthread_mutex_t *mutex);
+int pthread_mutexattr_setpshared (pthread_mutexattr_t * attr,
+				  int pshared);
 
-int pthread_mutex_trylock(pthread_mutex_t *mutex);
+/*
+ * Mutex Functions
+ */
+int pthread_mutex_init (pthread_mutex_t * mutex,
+			const pthread_mutexattr_t * attr);
 
-int pthread_mutex_unlock(pthread_mutex_t *mutex);
+int pthread_mutex_destroy (pthread_mutex_t * mutex);
 
-/* Primitives for thread-specific data (TSD). */
+int pthread_mutex_lock (pthread_mutex_t * mutex);
 
-int pthread_key_create(pthread_key_t *key,
-		       void (*destructor)(void *));
+int pthread_mutex_trylock (pthread_mutex_t * mutex);
 
-int pthread_setspecific(pthread_key_t key, void *value);
+int pthread_mutex_unlock (pthread_mutex_t * mutex);
 
-void *pthread_getspecific(pthread_key_t key);
+/*
+ * Condition Variable Attribute Functions
+ */
+int pthread_condattr_init (pthread_condattr_t * attr);
 
-int pthread_key_delete(pthread_key_t key);
+int pthread_condattr_destroy (pthread_condattr_t * attr);
 
-/* Signal handling. */
+int pthread_condattr_getpshared (const pthread_condattr_t * attr,
+				 int *pshared);
 
-#if HAVE_SIGSET_T
-int pthread_sigmask(int how,
-		    const sigset_t *set,
-		    sigset_t *oset);
-#endif /* HAVE_SIGSET_T */
+int pthread_condattr_setpshared (pthread_condattr_t * attr,
+				 int pshared);
 
-/* Thread cancelation functions. */
+/*
+ * Condition Variable Functions
+ */
+int pthread_cond_init (pthread_cond_t * cond,
+		       const pthread_condattr_t * attr);
 
-void pthread_testcancel(void);
+int pthread_cond_destroy (pthread_cond_t * cond);
 
-int pthread_cancel(pthread_t thread);
+int pthread_cond_wait (pthread_cond_t * cond,
+		       pthread_mutex_t * mutex);
 
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+int pthread_cond_timedwait (pthread_cond_t * cond,
+			    pthread_mutex_t * mutex,
+			    const struct timespec *abstime);
 
-/* Constants declared in global.c */
-extern const int _POSIX_THREAD_THREADS_MAX;
-extern const int _POSIX_THREAD_DESTRUCTOR_ITERATIONS;
-extern const int _POSIX_THREAD_KEYS_MAX;
+int pthread_cond_signal (pthread_cond_t * cond);
 
-extern const int _pthread_create_joinable;
-extern const int _pthread_create_detached;
+int pthread_cond_broadcast (pthread_cond_t * cond);
 
-extern const int _pthread_cancel_enable;
-extern const int _pthread_cancel_disable;
+/*
+ * Scheduling
+ */
 
-extern const int _pthread_cancel_asynchronous;
-extern const int _pthread_cancel_deferred;
+int pthread_setschedparam (pthread_t thread,
+			   int policy,
+			   const struct sched_param *param);
 
-#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS
-#define PTHREAD_KEYS_MAX _POSIX_THREAD_KEYS_MAX
-#define PTHREAD_THREADS_MAX _POSIX_THREAD_THREADS_MAX
+int pthread_getschedparam (pthread_t thread,
+			   int *policy,
+			   struct sched_param *param);
 
-#define PTHREAD_CREATE_JOINABLE     _pthread_create_joinable
-#define PTHREAD_CREATE_DETACHED     _pthread_create_detached
+int sched_get_priority_min (int policy);
 
-/* Cancelability attributes */
-#define PTHREAD_CANCEL_ENABLE       _pthread_cancel_enable
-#define PTHREAD_CANCEL_DISABLE      _pthread_cancel_disable
+int sched_get_priority_max (int policy);
 
-#define PTHREAD_CANCEL_ASYNCHRONOUS _pthread_cancel_asynchronous
-#define PTHREAD_CANCEL_DEFERRED     _pthread_cancel_deferred
+int pthread_attr_getschedparam (const pthread_attr_t *attr,
+				struct sched_param *param);
 
+int pthread_attr_setschedparam (pthread_attr_t *attr,
+				const struct sched_param *param);
 
-/* The following #defines implement POSIX cleanup handlers.
-   The standard requires that these functions be used as statements and
-   be used pairwise in the same scope. The standard suggests that, in C, they
-   may be implemented as macros starting and ending the same block.
 
-   POSIX requires that applications observe scoping requirements, but
-   doesn't say if the implemention must enforce them. The macros below
-   partially enforce scope but can lead to compile or runtime errors. */
+/*
+ * Protected Methods
+ *
+ * This function blocks until the given WIN32 handle
+ * is signaled or pthread_cancel had been called.
+ * This function allows the caller to hook into the
+ * PThreads cancel mechanism. It is implemented using
+ *
+ *              WaitForMultipleObjects
+ *
+ * on 'waitHandle' and a manually reset WIN32 Event
+ * used to implement pthread_cancel.
+ */
+int pthreadCancelableWait (HANDLE waitHandle);
 
-enum {
-  _PTHREAD_HANDLER_POP_LIFO,
-  _PTHREAD_HANDLER_POP_FIFO
-};
+/*
+ * Thread-Safe C Runtime Library Mappings
+ * WIN32 C runtime library had been made thread-safe
+ * without affecting the user interface. Provide
+ * mappings from the UNIX thread-safe versions to
+ * the standard C runtime library calls.
+ * Only provide function mappings for functions that
+ * actually exist on WIN32.
+ */
+#define strtok_r( _s, _sep, _lasts ) \
+	( *(_lasts) = strtok( (_s), (_sep) ) )
 
-enum {
-  _PTHREAD_CLEANUP_STACK,
-  _PTHREAD_DESTRUCTOR_STACK,
-  _PTHREAD_FORKPREPARE_STACK,
-  _PTHREAD_FORKPARENT_STACK,
-  _PTHREAD_FORKCHILD_STACK
-};
+#define asctime_r( _tm, _buf ) \
+	( strcpy( (_buf), asctime( (_tm) ) ), \
+	  (_buf) )
 
-#ifdef pthread_cleanup_push
-#undef pthread_cleanup_push
-#endif
+#define ctime_r( _clock, _buf ) \
+	( strcpy( (_buf), ctime( (_tm) ) ), \
+	  (_buf) )
 
-#define pthread_cleanup_push(routine, arg) \
-{ \
-  (void ) _pthread_handler_push(_PTHREAD_CLEANUP_STACK, \
-				_PTHREAD_HANDLER_POP_LIFO, routine, arg);
+#define gmtime_r( _clock, _result ) \
+	( *(_result) = *gmtime( (_clock) ), \
+	  (_result) )
 
-#ifdef pthread_cleanup_pop
-#undef pthread_cleanup_pop
-#endif
+#define localtime_r( _clock, _result ) \
+	( *(_result) = *localtime( (_clock) ), \
+	  (_result) )
 
-#define pthread_cleanup_pop(execute) \
-  _pthread_handler_pop(_PTHREAD_CLEANUP_STACK, execute);\
-}
+#define rand_r( _seed ) \
+	rand()
+
+
+#ifdef __cplusplus
+}				/* End of extern "C" */
+#endif				/* __cplusplus */
 
-#endif /* _PTHREADS_H */
+#endif /* PTHREAD_H */