Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/threads.c

 /**
  * threads.c: set of generic threading related routines
  *
  * See Copyright for the status of this software.
  *
  * Gary Pennington <Gary.Pennington@uk.sun.com>
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
@@ skipping 128 matching lines @@
 /*
  * This module still has some internal static data.
  *   - xmlLibraryLock a global lock
  *   - globalkey used for per-thread data
  */
 
 #ifdef HAVE_PTHREAD_H
 static pthread_key_t globalkey;
 static pthread_t mainthread;
 static pthread_once_t once_control = PTHREAD_ONCE_INIT;
+static pthread_once_t once_control_init = PTHREAD_ONCE_INIT;
 static pthread_mutex_t global_init_lock = PTHREAD_MUTEX_INITIALIZER;
 #elif defined HAVE_WIN32_THREADS
 #if defined(HAVE_COMPILER_TLS)
 static __declspec(thread) xmlGlobalState tlstate;
 static __declspec(thread) int tlstate_inited = 0;
 #else /* HAVE_COMPILER_TLS */
 static DWORD globalkey = TLS_OUT_OF_INDEXES;
 #endif /* HAVE_COMPILER_TLS */
 static DWORD mainthread;
 static struct {
@@ skipping 85 matching lines @@
 #ifdef HAVE_PTHREAD_H
     if (libxml_is_threaded != 0)
         pthread_mutex_lock(&tok->lock);
 #elif defined HAVE_WIN32_THREADS
     WaitForSingleObject(tok->mutex, INFINITE);
 #elif defined HAVE_BEOS_THREADS
     if (acquire_sem(tok->sem) != B_NO_ERROR) {
 #ifdef DEBUG_THREADS
         xmlGenericError(xmlGenericErrorContext,
                         "xmlMutexLock():BeOS:Couldn't aquire semaphore\n");
-        exit();
 #endif
     }
     tok->tid = find_thread(NULL);
 #endif
 
 }
 
 /**
  * xmlMutexUnlock:
  * @tok:  the simple mutex
@@ skipping 106 matching lines @@
             while (tok->held)
                 pthread_cond_wait(&tok->cv, &tok->lock);
             tok->waiters--;
         }
     }
     tok->tid = pthread_self();
     tok->held = 1;
     pthread_mutex_unlock(&tok->lock);
 #elif defined HAVE_WIN32_THREADS
     EnterCriticalSection(&tok->cs);
-    ++tok->count;
+    tok->count++;
 #elif defined HAVE_BEOS_THREADS
     if (tok->lock->tid == find_thread(NULL)) {
         tok->count++;
         return;
     } else {
         xmlMutexLock(tok->lock);
         tok->count = 1;
     }
 #endif
 }
@@ skipping 15 matching lines @@
 
     pthread_mutex_lock(&tok->lock);
     tok->held--;
     if (tok->held == 0) {
         if (tok->waiters)
             pthread_cond_signal(&tok->cv);
         memset(&tok->tid, 0, sizeof(tok->tid));
     }
     pthread_mutex_unlock(&tok->lock);
 #elif defined HAVE_WIN32_THREADS
-    if (!--tok->count)
+    if (tok->count > 0) {
         LeaveCriticalSection(&tok->cs);
+        tok->count--;
+    }
 #elif defined HAVE_BEOS_THREADS
     if (tok->lock->tid == find_thread(NULL)) {
         tok->count--;
         if (tok->count == 0) {
             xmlMutexUnlock(tok->lock);
         }
         return;
     }
 #endif
 }
 
 /**
  * xmlGlobalInitMutexLock
  *
  * Makes sure that the global initialization mutex is initialized and
  * locks it.
  */
 void
 __xmlGlobalInitMutexLock(void)
 {
     /* Make sure the global init lock is initialized and then lock it. */
 #ifdef HAVE_PTHREAD_H
     /* The mutex is statically initialized, so we just lock it. */
-    pthread_mutex_lock(&global_init_lock);
+    if (pthread_mutex_lock != NULL)
+        pthread_mutex_lock(&global_init_lock);
 #elif defined HAVE_WIN32_THREADS
     LPCRITICAL_SECTION cs;
 
     /* Create a new critical section */
     if (global_init_lock == NULL) {
         cs = malloc(sizeof(CRITICAL_SECTION));
         if (cs == NULL) {
             xmlGenericError(xmlGenericErrorContext,
                             "xmlGlobalInitMutexLock: out of memory\n");
             return;
@@ skipping 38 matching lines @@
      * section in the global_init_lock then discard the one
      * allocated by this thread. */
     if (global_init_lock != sem)
         delete_sem(sem);
 
     /* Acquire the chosen semaphore */
     if (acquire_sem(global_init_lock) != B_NO_ERROR) {
 #ifdef DEBUG_THREADS
         xmlGenericError(xmlGenericErrorContext,
                         "xmlGlobalInitMutexLock():BeOS:Couldn't acquire semaphore\n");
-        exit();
 #endif
     }
 #endif
 }
 
 void
 __xmlGlobalInitMutexUnlock(void)
 {
 #ifdef HAVE_PTHREAD_H
-    pthread_mutex_unlock(&global_init_lock);
+    if (pthread_mutex_unlock != NULL)
+        pthread_mutex_unlock(&global_init_lock);
 #elif defined HAVE_WIN32_THREADS
     if (global_init_lock != NULL) {
         LeaveCriticalSection(global_init_lock);
     }
 #elif defined HAVE_BEOS_THREADS
     release_sem(global_init_lock);
 #endif
 }
 
 /**
@@ skipping 384 matching lines @@
  */
 void
 xmlCleanupThreads(void)
 {
 #ifdef DEBUG_THREADS
     xmlGenericError(xmlGenericErrorContext, "xmlCleanupThreads()\n");
 #endif
 #ifdef HAVE_PTHREAD_H
     if ((libxml_is_threaded)  && (pthread_key_delete != NULL))
         pthread_key_delete(globalkey);
+    once_control = once_control_init;
 #elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
     if (globalkey != TLS_OUT_OF_INDEXES) {
         xmlGlobalStateCleanupHelperParams *p;
 
         EnterCriticalSection(&cleanup_helpers_cs);
         p = cleanup_helpers_head;
         while (p != NULL) {
             xmlGlobalStateCleanupHelperParams *temp = p;
 
             p = p->next;
@@ skipping 19 matching lines @@
  * pthread_once() in association with the once_control variable to ensure
  * that the function is only called once. See man pthread_once for more
  * details.
  */
 static void
 xmlOnceInit(void)
 {
 #ifdef HAVE_PTHREAD_H
     (void) pthread_key_create(&globalkey, xmlFreeGlobalState);
     mainthread = pthread_self();
+    __xmlInitializeDict();
 #elif defined(HAVE_WIN32_THREADS)
     if (!run_once.done) {
         if (InterlockedIncrement(&run_once.control) == 1) {
 #if !defined(HAVE_COMPILER_TLS)
             globalkey = TlsAlloc();
 #endif
             mainthread = GetCurrentThreadId();
+            __xmlInitializeDict();
             run_once.done = 1;
         } else {
             /* Another thread is working; give up our slice and
              * wait until they're done. */
             while (!run_once.done)
                 Sleep(0);
         }
     }
 #elif defined HAVE_BEOS_THREADS
     if (atomic_add(&run_once_init, 1) == 0) {
         globalkey = tls_allocate();
         tls_set(globalkey, NULL);
         mainthread = find_thread(NULL);
+        __xmlInitializeDict();
     } else
         atomic_add(&run_once_init, -1);
 #endif
 }
 #endif
 
 /**
  * DllMain:
  * @hinstDLL: handle to DLL instance
  * @fdwReason: Reason code for entry
@@ skipping 38 matching lines @@
                     free(p);
                 }
             }
             break;
     }
     return TRUE;
 }
 #endif
 #define bottom_threads
 #include "elfgcchack.h"