Sun Dec 20 14:51:58 1998 Ross Johnson <rpj@ixobrychus.canberra.edu.au>

        * misc.c (pthreadCancelableWait): New function by John Bossom. Non-stand
ard
        but provides a hook that can be used to implement cancellation points in
        applications that use this library.
        * pthread.h (pthread_cleanup_pop): C++ (non-WIN32) version uses
        try/catch to emulate John Bossom's WIN32 __try/__finally behaviour.
        In the WIN32 version __finally block, add a test for AbnormalTermination
 otherwise
        cleanup is only run if the cleanup_pop execute arg is non-zero. Cancella
tion
        should cause the cleanup to run irrespective of the execute arg.
        * condvar.c (pthread_condattr_init): Replaced by John Bossom's version.
        (pthread_condattr_destroy): Replaced by John Bossom's version.
        (pthread_condattr_getpshared): Replaced by John Bossom's version.
        (pthread_condattr_setpshared): Replaced by John Bossom's version.
        (pthread_cond_init): Replaced by John Bossom's version.
        Fix comment (refered to mutex rather than condition variable).
        (pthread_cond_destroy): Replaced by John Bossom's version.
        (pthread_cond_wait): Replaced by John Bossom's version.
        (pthread_cond_timedwait): Replaced by John Bossom's version.
        (pthread_cond_signal): Replaced by John Bossom's version.
        (pthread_cond_broadcast): Replaced by John Bossom's version.
Thu Dec 17 19:10:46 1998  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
        * tsd.c (pthread_key_create): Replaced by John Bossom's version.
        (pthread_key_delete): Replaced by John Bossom's version.
        (pthread_setspecific): Replaced by John Bossom's version.
        (pthread_getspecific): Replaced by John Bossom's version.
Mon Dec  7 09:44:40 1998  Ross Johnson  <rpj@ixobrychus.canberra.edu.au>
        * cancel.c (pthread_setcancelstate): Replaced by John Bossom's version.
        (pthread_setcanceltype): Replaced by John Bossom's version.
        (pthread_testcancel): Replaced by John Bossom's version.
        (pthread_cancel): Replaced by John Bossom's version.
        * exit.c (pthread_exit): Replaced by John Bossom's version.
        * misc.c (pthread_self): Replaced by John Bossom's version.
        (pthread_equal): Replaced by John Bossom's version.
        * sync.c (pthread_detach): Replaced by John Bossom's version.
        (pthread_join): Replaced by John Bossom's version.
        * create.c (pthread_create): Replaced by John Bossom's version.
        * private.c (_pthread_processInitialize): New by John Bossom.
        (_pthread_processTerminate): Non-public function by John Bossom.
        (_pthread_threadStart): Non-public function by John Bossom.
        (_pthread_threadDestroy): Non-public function by John Bossom.
        (_pthread_cleanupStack): Non-public function by John Bossom.
        (_pthread_tkAssocCreate): Non-public function by John Bossom.
        (_pthread_tkAssocDestroy): Non-public function by John Bossom.
        (_pthread_callUserDestroyRoutines): Non-public function by John Bossom.
        * implement.h: Added John Bossom's non-API structures and
        declarations.
        * dll.c (PthreadsEntryPoint): Cast return value of GetProcAddress
        to resolve compile warning from MSVC.
        * dll.c (DLLmain): Replaced by John Bossom's version.
        * dll.c (PthreadsEntryPoint):
        Re-applied Anders Norlander's patch:-
        Initialize _pthread_try_enter_critical_section at startup
        and release kernel32 handle when DLL is being unloaded.

1 files changed, 210 insertions, 0 deletions

diff --git a/misc.c b/misc.c
index 659a4eb..e244701 100644
--- a/misc.c
+++ b/misc.c
@@ -39,6 +39,214 @@ pthread_once(pthread_once_t *once_control,
   return 0;
 }
 
+/*
+ * Code contributed by John E. Bossom <JEB>.
+ */
+
+pthread_t
+pthread_self (void)
+     /*
+      * ------------------------------------------------------
+      * DOCPUBLIC
+      *      This function returns a reference to the current running
+      *      thread.
+      *
+      * PARAMETERS
+      *      N/A
+      *
+      *
+      * DESCRIPTION
+      *      This function returns a reference to the current running
+      *      thread.
+      *
+      * RESULTS
+      *              pthread_t       reference to the current thread
+      *
+      * ------------------------------------------------------
+      */
+{
+  pthread_t self = NULL;
+  /*
+   * need to ensure there always is a self
+   */
+
+  if ((self = pthread_getspecific (_pthread_selfThreadKey)) == NULL)
+    {
+      /*
+       * Need to create an implicit 'self' for the currently
+       * executing thread.
+       */
+      self = (pthread_t) calloc (1, sizeof (*self));
+      if (self != NULL)
+	{
+
+	  self->implicit = 1;
+	  self->detachState = PTHREAD_CREATE_DETACHED;
+
+	  self->thread = GetCurrentThreadId ();
+	  self->threadH = GetCurrentThread ();
+	}
+
+      pthread_setspecific (_pthread_selfThreadKey, self);
+    }
+
+  return (self);
+
+}				/* pthread_self */
+
+int
+pthread_equal (pthread_t t1, pthread_t t2)
+     /*
+      * ------------------------------------------------------
+      * DOCPUBLIC
+      *      This function returns zero if t1 and t2 are equal, else
+      *      returns nonzero
+      *
+      * PARAMETERS
+      *      t1,
+      *      t2
+      *              references to an instances of thread_t
+      *
+      *
+      * DESCRIPTION
+      *      This function returns zero if t1 and t2 are equal, else
+      *      returns nonzero.
+      *
+      * RESULTS
+      *              0               if t1 and t2 refer to the same thread,
+      *              non-zero        t1 and t2 do not refer to the same thread
+      *
+      * ------------------------------------------------------
+      */
+{
+  int result;
+
+  result = !((t1 == t2) || (t1->thread == t2->thread));
+
+  return (result);
+
+}				/* pthread_equal */
+
+
+int
+pthreadCancelableWait (HANDLE waitHandle)
+     /*
+      * -------------------------------------------------------------------
+      * This provides an extra hook into the pthread_cancel
+      * mechanism that will allow you to wait on a Windows handle and make it a
+      * cancellation point. This function blocks until the given WIN32 handle is
+      * signaled or pthread_cancel has been called. It is implemented using
+      * WaitForMultipleObjects on 'waitHandle' and a manually reset WIN32
+      * event used to implement pthread_cancel.
+      * 
+      * Given this hook it would be possible to implement more of the cancellation
+      * points.
+      * -------------------------------------------------------------------
+      */
+{
+  int result;
+  pthread_t self;
+  HANDLE handles[2];
+  DWORD nHandles = 1;
+  DWORD status;
+
+
+  handles[0] = waitHandle;
+
+  if ((self = pthread_getspecific (_pthread_selfThreadKey)) != NULL)
+    {
+      /*
+       * Get cancelEvent handle
+       */
+      if (self->cancelState == PTHREAD_CANCEL_ENABLE)
+        {
+
+          if ((handles[1] = self->cancelEvent) != NULL)
+            {
+              nHandles++;
+            }
+        }
+    }
+  else
+    {
+      handles[1] = NULL;
+    }
+
+  status = WaitForMultipleObjects (
+                                    nHandles,
+                                    handles,
+                                    FALSE,
+                                    INFINITE);
+
+
+  if (status == WAIT_FAILED)
+    {
+      result = EINVAL;
+
+    }
+  else if (status == WAIT_ABANDONED_0)
+    {
+      result = EINVAL;
+
+    }
+  else
+    {
+      /*
+       * Either got the mutex or the cancel event
+       * was signaled
+       */
+      switch (status - WAIT_OBJECT_0)
+        {
+
+        case 0:
+          /*
+           * Got the mutex
+           */
+          result = 0;
+          break;
+
+        case 1:
+          /*
+           * Got cancel request
+           */
+          ResetEvent (handles[1]);
+
+          if (self != NULL && !self->implicit)
+            {
+              /*
+               * Thread started with pthread_create
+               */
+              DWORD exceptionInformation[3];
+
+              exceptionInformation[0] = (DWORD) (0);
+              exceptionInformation[1] = (DWORD) (0);
+
+              RaiseException (
+                               EXCEPTION_PTHREAD_SERVICES,
+                               0,
+                               3,
+                               exceptionInformation);
+            }
+
+
+          ((void *) -1);
+          break;
+
+        default:
+          result = EINVAL;
+          break;
+        }
+    }
+
+  return (result);
+
+}                               /* pthreadCancelableWait */
+
+
+/* </JEB> */
+
+#if 0 /* Pre Bossom */
+
 pthread_t
 pthread_self(void)
 {
@@ -61,3 +269,5 @@ pthread_equal(pthread_t t1, pthread_t t2)
 {
   return (t1 == t2);
 }
+
+#endif /* Pre Bossom */