]> git.saurik.com Git - wxWidgets.git/blobdiff - src/unix/threadpsx.cpp
Fix VC++ compile error
[wxWidgets.git] / src / unix / threadpsx.cpp
index ac55f84a1fb097074b70b04049c55a606ce8c555..031ade47b59acc933be89711ef0a8a22c331813e 100644 (file)
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        threadpsx.cpp
+// Name:        src/unix/threadpsx.cpp
 // Purpose:     wxThread (Posix) Implementation
 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
 // Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore
 // Purpose:     wxThread (Posix) Implementation
 // Author:      Original from Wolfram Gloger/Guilhem Lavaux
 // Modified by: K. S. Sreeram (2002): POSIXified wxCondition, added wxSemaphore
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "thread.h"
-#endif
-
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #if wxUSE_THREADS
 
 #include "wx/thread.h"
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #if wxUSE_THREADS
 
 #include "wx/thread.h"
-#include "wx/module.h"
-#include "wx/utils.h"
-#include "wx/log.h"
-#include "wx/intl.h"
-#include "wx/dynarray.h"
-#include "wx/timer.h"
+#include "wx/except.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/app.h"
+    #include "wx/dynarray.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/utils.h"
+    #include "wx/timer.h"
+    #include "wx/stopwatch.h"
+    #include "wx/module.h"
+#endif
 
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>
 
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>
-#if HAVE_SCHED_H
+#include <sys/time.h>           // needed for at least __QNX__
+#ifdef HAVE_SCHED_H
     #include <sched.h>
 #endif
 
     #include <sched.h>
 #endif
 
 // we use wxFFile under Linux in GetCPUCount()
 #ifdef __LINUX__
     #include "wx/ffile.h"
 // we use wxFFile under Linux in GetCPUCount()
 #ifdef __LINUX__
     #include "wx/ffile.h"
-    // For setpriority.
-    #include <sys/time.h>
-    #include <sys/resource.h>
+    #include <sys/resource.h>   // for setpriority()
 #endif
 
 #endif
 
+#define THR_ID_CAST(id)  (reinterpret_cast<void*>(id))
+#define THR_ID(thr)      THR_ID_CAST((thr)->GetId())
+
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
@@ -76,10 +80,10 @@ enum wxThreadState
 static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 
 // trace mask for wxThread operations
 static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 
 // trace mask for wxThread operations
-#define TRACE_THREADS   _T("thread")
+#define TRACE_THREADS   wxT("thread")
 
 // you can get additional debugging messages for the semaphore operations
 
 // you can get additional debugging messages for the semaphore operations
-#define TRACE_SEMA      _T("semaphore")
+#define TRACE_SEMA      wxT("semaphore")
 
 // ----------------------------------------------------------------------------
 // private functions
 
 // ----------------------------------------------------------------------------
 // private functions
@@ -93,7 +97,7 @@ static void DeleteThread(wxThread *This);
 // ----------------------------------------------------------------------------
 
 // an (non owning) array of pointers to threads
 // ----------------------------------------------------------------------------
 
 // an (non owning) array of pointers to threads
-WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
+WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
 
 // an entry for a thread we can wait for
 
 
 // an entry for a thread we can wait for
 
@@ -106,8 +110,15 @@ WX_DEFINE_ARRAY(wxThread *, wxArrayThread);
 // be left in memory
 static wxArrayThread gs_allThreads;
 
 // be left in memory
 static wxArrayThread gs_allThreads;
 
+// a mutex to protect gs_allThreads
+static wxMutex *gs_mutexAllThreads = NULL;
+
 // the id of the main thread
 // the id of the main thread
-static pthread_t gs_tidMain;
+//
+// we suppose that 0 is not a valid pthread_t value but in principle this might
+// be false (e.g. if it's a selector-like value), wxThread::IsMain() would need
+// to be updated in such case
+wxThreadIdType wxThread::ms_idMainThread = 0;
 
 // the key for the pointer to the associated wxThread object
 static pthread_key_t gs_keySelf;
 
 // the key for the pointer to the associated wxThread object
 static pthread_key_t gs_keySelf;
@@ -117,16 +128,16 @@ static pthread_key_t gs_keySelf;
 static size_t gs_nThreadsBeingDeleted = 0;
 
 // a mutex to protect gs_nThreadsBeingDeleted
 static size_t gs_nThreadsBeingDeleted = 0;
 
 // a mutex to protect gs_nThreadsBeingDeleted
-static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;
+static wxMutex *gs_mutexDeleteThread = NULL;
 
 // and a condition variable which will be signaled when all
 // gs_nThreadsBeingDeleted will have been deleted
 
 // and a condition variable which will be signaled when all
 // gs_nThreadsBeingDeleted will have been deleted
-static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
+static wxCondition *gs_condAllDeleted = NULL;
 
 
-#if wxUSE_GUI
-    // this mutex must be acquired before any call to a GUI function
-    static wxMutex *gs_mutexGui;
-#endif // wxUSE_GUI
+// this mutex must be acquired before any call to a GUI function
+// (it's not inside #if wxUSE_GUI because this file is compiled as part
+// of wxBase)
+static wxMutex *gs_mutexGui = NULL;
 
 // when we wait for a thread to exit, we're blocking on a condition which the
 // thread signals in its SignalExit() method -- but this condition can't be a
 
 // when we wait for a thread to exit, we're blocking on a condition which the
 // thread signals in its SignalExit() method -- but this condition can't be a
@@ -154,20 +165,28 @@ public:
     ~wxMutexInternal();
 
     wxMutexError Lock();
     ~wxMutexInternal();
 
     wxMutexError Lock();
+    wxMutexError Lock(unsigned long ms);
     wxMutexError TryLock();
     wxMutexError Unlock();
 
     bool IsOk() const { return m_isOk; }
 
     wxMutexError TryLock();
     wxMutexError Unlock();
 
     bool IsOk() const { return m_isOk; }
 
+private:
+    // convert the result of pthread_mutex_[timed]lock() call to wx return code
+    wxMutexError HandleLockResult(int err);
+
 private:
     pthread_mutex_t m_mutex;
     bool m_isOk;
 private:
     pthread_mutex_t m_mutex;
     bool m_isOk;
+    wxMutexType m_type;
+    unsigned long m_owningThread;
 
     // wxConditionInternal uses our m_mutex
     friend class wxConditionInternal;
 };
 
 
     // wxConditionInternal uses our m_mutex
     friend class wxConditionInternal;
 };
 
-#ifdef HAVE_PTHREAD_MUTEXATTR_T
+#if defined(HAVE_PTHREAD_MUTEXATTR_T) && \
+        wxUSE_UNIX && !defined(HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL)
 // on some systems pthread_mutexattr_settype() is not in the headers (but it is
 // in the library, otherwise we wouldn't compile this code at all)
 extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
 // on some systems pthread_mutexattr_settype() is not in the headers (but it is
 // in the library, otherwise we wouldn't compile this code at all)
 extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
@@ -175,6 +194,9 @@ extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
 
 wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
 {
 
 wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
 {
+    m_type = mutexType;
+    m_owningThread = 0;
+
     int err;
     switch ( mutexType )
     {
     int err;
     switch ( mutexType )
     {
@@ -206,7 +228,7 @@ wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
             break;
 
         default:
             break;
 
         default:
-            wxFAIL_MSG( _T("unknown mutex type") );
+            wxFAIL_MSG( wxT("unknown mutex type") );
             // fall through
 
         case wxMUTEX_DEFAULT:
             // fall through
 
         case wxMUTEX_DEFAULT:
@@ -235,29 +257,97 @@ wxMutexInternal::~wxMutexInternal()
 
 wxMutexError wxMutexInternal::Lock()
 {
 
 wxMutexError wxMutexInternal::Lock()
 {
-    int err = pthread_mutex_lock(&m_mutex);
+    if ((m_type == wxMUTEX_DEFAULT) && (m_owningThread != 0))
+    {
+        if (m_owningThread == wxThread::GetCurrentId())
+           return wxMUTEX_DEAD_LOCK;
+    }
+
+    return HandleLockResult(pthread_mutex_lock(&m_mutex));
+}
+
+wxMutexError wxMutexInternal::Lock(unsigned long ms)
+{
+#ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
+    static const long MSEC_IN_SEC   = 1000;
+    static const long NSEC_IN_MSEC  = 1000000;
+    static const long NSEC_IN_USEC  = 1000;
+    static const long NSEC_IN_SEC   = MSEC_IN_SEC * NSEC_IN_MSEC;
+
+    time_t seconds = ms/MSEC_IN_SEC;
+    long nanoseconds = (ms % MSEC_IN_SEC) * NSEC_IN_MSEC;
+    timespec ts = { 0, 0 };
+
+    // normally we should use clock_gettime(CLOCK_REALTIME) here but this
+    // function is in librt and we don't link with it currently, so use
+    // gettimeofday() instead -- if it turns out that this is really too
+    // imprecise, we should modify configure to check if clock_gettime() is
+    // available and whether it requires -lrt and use it instead
+#if 0
+    if ( clock_gettime(CLOCK_REALTIME, &ts) == 0 )
+    {
+    }
+#else
+    struct timeval tv;
+    if ( wxGetTimeOfDay(&tv) != -1 )
+    {
+        ts.tv_sec = tv.tv_sec;
+        ts.tv_nsec = tv.tv_usec*NSEC_IN_USEC;
+    }
+#endif
+    else // fall back on system timer
+    {
+        ts.tv_sec = time(NULL);
+    }
+
+    ts.tv_sec += seconds;
+    ts.tv_nsec += nanoseconds;
+    if ( ts.tv_nsec > NSEC_IN_SEC )
+    {
+        ts.tv_sec += 1;
+        ts.tv_nsec -= NSEC_IN_SEC;
+    }
+
+    return HandleLockResult(pthread_mutex_timedlock(&m_mutex, &ts));
+#else // !HAVE_PTHREAD_MUTEX_TIMEDLOCK
+    wxUnusedVar(ms);
+
+    return wxMUTEX_MISC_ERROR;
+#endif // HAVE_PTHREAD_MUTEX_TIMEDLOCK/!HAVE_PTHREAD_MUTEX_TIMEDLOCK
+}
+
+wxMutexError wxMutexInternal::HandleLockResult(int err)
+{
+    // wxPrintf( "err %d\n", err );
+
     switch ( err )
     {
         case EDEADLK:
             // only error checking mutexes return this value and so it's an
             // unexpected situation -- hence use assert, not wxLogDebug
     switch ( err )
     {
         case EDEADLK:
             // only error checking mutexes return this value and so it's an
             // unexpected situation -- hence use assert, not wxLogDebug
-            wxFAIL_MSG( _T("mutex deadlock prevented") );
+            wxFAIL_MSG( wxT("mutex deadlock prevented") );
             return wxMUTEX_DEAD_LOCK;
 
         case EINVAL:
             return wxMUTEX_DEAD_LOCK;
 
         case EINVAL:
-            wxLogDebug(_T("pthread_mutex_lock(): mutex not initialized."));
+            wxLogDebug(wxT("pthread_mutex_[timed]lock(): mutex not initialized"));
             break;
 
             break;
 
+        case ETIMEDOUT:
+            return wxMUTEX_TIMEOUT;
+
         case 0:
         case 0:
+            if (m_type == wxMUTEX_DEFAULT)
+                m_owningThread = wxThread::GetCurrentId();
             return wxMUTEX_NO_ERROR;
 
         default:
             return wxMUTEX_NO_ERROR;
 
         default:
-            wxLogApiError(_T("pthread_mutex_lock()"), err);
+            wxLogApiError(wxT("pthread_mutex_[timed]lock()"), err);
     }
 
     return wxMUTEX_MISC_ERROR;
 }
 
     }
 
     return wxMUTEX_MISC_ERROR;
 }
 
+
 wxMutexError wxMutexInternal::TryLock()
 {
     int err = pthread_mutex_trylock(&m_mutex);
 wxMutexError wxMutexInternal::TryLock()
 {
     int err = pthread_mutex_trylock(&m_mutex);
@@ -269,14 +359,16 @@ wxMutexError wxMutexInternal::TryLock()
             return wxMUTEX_BUSY;
 
         case EINVAL:
             return wxMUTEX_BUSY;
 
         case EINVAL:
-            wxLogDebug(_T("pthread_mutex_trylock(): mutex not initialized."));
+            wxLogDebug(wxT("pthread_mutex_trylock(): mutex not initialized."));
             break;
 
         case 0:
             break;
 
         case 0:
+            if (m_type == wxMUTEX_DEFAULT)
+                m_owningThread = wxThread::GetCurrentId();
             return wxMUTEX_NO_ERROR;
 
         default:
             return wxMUTEX_NO_ERROR;
 
         default:
-            wxLogApiError(_T("pthread_mutex_trylock()"), err);
+            wxLogApiError(wxT("pthread_mutex_trylock()"), err);
     }
 
     return wxMUTEX_MISC_ERROR;
     }
 
     return wxMUTEX_MISC_ERROR;
@@ -284,6 +376,8 @@ wxMutexError wxMutexInternal::TryLock()
 
 wxMutexError wxMutexInternal::Unlock()
 {
 
 wxMutexError wxMutexInternal::Unlock()
 {
+    m_owningThread = 0;
+
     int err = pthread_mutex_unlock(&m_mutex);
     switch ( err )
     {
     int err = pthread_mutex_unlock(&m_mutex);
     switch ( err )
     {
@@ -292,14 +386,14 @@ wxMutexError wxMutexInternal::Unlock()
             return wxMUTEX_UNLOCKED;
 
         case EINVAL:
             return wxMUTEX_UNLOCKED;
 
         case EINVAL:
-            wxLogDebug(_T("pthread_mutex_unlock(): mutex not initialized."));
+            wxLogDebug(wxT("pthread_mutex_unlock(): mutex not initialized."));
             break;
 
         case 0:
             return wxMUTEX_NO_ERROR;
 
         default:
             break;
 
         case 0:
             return wxMUTEX_NO_ERROR;
 
         default:
-            wxLogApiError(_T("pthread_mutex_unlock()"), err);
+            wxLogApiError(wxT("pthread_mutex_unlock()"), err);
     }
 
     return wxMUTEX_MISC_ERROR;
     }
 
     return wxMUTEX_MISC_ERROR;
@@ -348,7 +442,7 @@ wxConditionInternal::wxConditionInternal(wxMutex& mutex)
 
     if ( !m_isOk )
     {
 
     if ( !m_isOk )
     {
-        wxLogApiError(_T("pthread_cond_init()"), err);
+        wxLogApiError(wxT("pthread_cond_init()"), err);
     }
 }
 
     }
 }
 
@@ -359,7 +453,7 @@ wxConditionInternal::~wxConditionInternal()
         int err = pthread_cond_destroy(&m_cond);
         if ( err != 0 )
         {
         int err = pthread_cond_destroy(&m_cond);
         if ( err != 0 )
         {
-            wxLogApiError(_T("pthread_cond_destroy()"), err);
+            wxLogApiError(wxT("pthread_cond_destroy()"), err);
         }
     }
 }
         }
     }
 }
@@ -369,7 +463,7 @@ wxCondError wxConditionInternal::Wait()
     int err = pthread_cond_wait(&m_cond, GetPMutex());
     if ( err != 0 )
     {
     int err = pthread_cond_wait(&m_cond, GetPMutex());
     if ( err != 0 )
     {
-        wxLogApiError(_T("pthread_cond_wait()"), err);
+        wxLogApiError(wxT("pthread_cond_wait()"), err);
 
         return wxCOND_MISC_ERROR;
     }
 
         return wxCOND_MISC_ERROR;
     }
@@ -402,7 +496,7 @@ wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
             return wxCOND_NO_ERROR;
 
         default:
             return wxCOND_NO_ERROR;
 
         default:
-            wxLogApiError(_T("pthread_cond_timedwait()"), err);
+            wxLogApiError(wxT("pthread_cond_timedwait()"), err);
     }
 
     return wxCOND_MISC_ERROR;
     }
 
     return wxCOND_MISC_ERROR;
@@ -413,7 +507,7 @@ wxCondError wxConditionInternal::Signal()
     int err = pthread_cond_signal(&m_cond);
     if ( err != 0 )
     {
     int err = pthread_cond_signal(&m_cond);
     if ( err != 0 )
     {
-        wxLogApiError(_T("pthread_cond_signal()"), err);
+        wxLogApiError(wxT("pthread_cond_signal()"), err);
 
         return wxCOND_MISC_ERROR;
     }
 
         return wxCOND_MISC_ERROR;
     }
@@ -426,7 +520,7 @@ wxCondError wxConditionInternal::Broadcast()
     int err = pthread_cond_broadcast(&m_cond);
     if ( err != 0 )
     {
     int err = pthread_cond_broadcast(&m_cond);
     if ( err != 0 )
     {
-        wxLogApiError(_T("pthread_cond_broadcast()"), err);
+        wxLogApiError(wxT("pthread_cond_broadcast()"), err);
 
         return wxCOND_MISC_ERROR;
     }
 
         return wxCOND_MISC_ERROR;
     }
@@ -475,9 +569,9 @@ wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
     if ( (initialcount < 0 || maxcount < 0) ||
             ((maxcount > 0) && (initialcount > maxcount)) )
     {
     if ( (initialcount < 0 || maxcount < 0) ||
             ((maxcount > 0) && (initialcount > maxcount)) )
     {
-        wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") );
+        wxFAIL_MSG( wxT("wxSemaphore: invalid initial or maximal count") );
 
 
-        m_isOk = FALSE;
+        m_isOk = false;
     }
     else
     {
     }
     else
     {
@@ -495,15 +589,15 @@ wxSemaError wxSemaphoreInternal::Wait()
     while ( m_count == 0 )
     {
         wxLogTrace(TRACE_SEMA,
     while ( m_count == 0 )
     {
         wxLogTrace(TRACE_SEMA,
-                   "Thread %ld waiting for semaphore to become signalled",
-                   wxThread::GetCurrentId());
+                   wxT("Thread %p waiting for semaphore to become signalled"),
+                   THR_ID_CAST(wxThread::GetCurrentId()));
 
         if ( m_cond.Wait() != wxCOND_NO_ERROR )
             return wxSEMA_MISC_ERROR;
 
         wxLogTrace(TRACE_SEMA,
 
         if ( m_cond.Wait() != wxCOND_NO_ERROR )
             return wxSEMA_MISC_ERROR;
 
         wxLogTrace(TRACE_SEMA,
-                   "Thread %ld finished waiting for semaphore, count = %lu",
-                   wxThread::GetCurrentId(), (unsigned long)m_count);
+                   wxT("Thread %p finished waiting for semaphore, count = %lu"),
+                   THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count);
     }
 
     m_count--;
     }
 
     m_count--;
@@ -569,8 +663,8 @@ wxSemaError wxSemaphoreInternal::Post()
     m_count++;
 
     wxLogTrace(TRACE_SEMA,
     m_count++;
 
     wxLogTrace(TRACE_SEMA,
-               "Thread %ld about to signal semaphore, count = %lu",
-               wxThread::GetCurrentId(), (unsigned long)m_count);
+               wxT("Thread %p about to signal semaphore, count = %lu"),
+               THR_ID_CAST(wxThread::GetCurrentId()), (unsigned long)m_count);
 
     return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
                                               : wxSEMA_MISC_ERROR;
 
     return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
                                               : wxSEMA_MISC_ERROR;
@@ -584,10 +678,10 @@ wxSemaError wxSemaphoreInternal::Post()
 extern "C"
 {
 
 extern "C"
 {
 
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
     // thread exit function
     void wxPthreadCleanup(void *ptr);
     // thread exit function
     void wxPthreadCleanup(void *ptr);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
 
 void *wxPthreadStart(void *ptr);
 
 
 void *wxPthreadStart(void *ptr);
 
@@ -626,18 +720,18 @@ public:
     wxThreadState GetState() const { return m_state; }
     void SetState(wxThreadState state)
     {
     wxThreadState GetState() const { return m_state; }
     void SetState(wxThreadState state)
     {
-#ifdef __WXDEBUG__
-        static const wxChar *stateNames[] =
+#if wxUSE_LOG_TRACE
+        static const wxChar *const stateNames[] =
         {
         {
-            _T("NEW"),
-            _T("RUNNING"),
-            _T("PAUSED"),
-            _T("EXITED"),
+            wxT("NEW"),
+            wxT("RUNNING"),
+            wxT("PAUSED"),
+            wxT("EXITED"),
         };
 
         };
 
-        wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."),
-                   (long)GetId(), stateNames[m_state], stateNames[state]);
-#endif // __WXDEBUG__
+        wxLogTrace(TRACE_THREADS, wxT("Thread %p: %s => %s."),
+                   THR_ID(this), stateNames[m_state], stateNames[state]);
+#endif // wxUSE_LOG_TRACE
 
         m_state = state;
     }
 
         m_state = state;
     }
@@ -645,7 +739,7 @@ public:
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }
         // "cancelled" flag
     pthread_t GetId() const { return m_threadId; }
     pthread_t *GetIdPtr() { return &m_threadId; }
         // "cancelled" flag
-    void SetCancelFlag() { m_cancelled = TRUE; }
+    void SetCancelFlag() { m_cancelled = true; }
     bool WasCancelled() const { return m_cancelled; }
         // exit code
     void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
     bool WasCancelled() const { return m_cancelled; }
         // exit code
     void SetExitCode(wxThread::ExitCode exitcode) { m_exitcode = exitcode; }
@@ -660,19 +754,19 @@ public:
     {
         wxCriticalSectionLocker lock(m_csJoinFlag);
 
     {
         wxCriticalSectionLocker lock(m_csJoinFlag);
 
-        m_shouldBeJoined = FALSE;
-        m_isDetached = TRUE;
+        m_shouldBeJoined = false;
+        m_isDetached = true;
     }
 
     }
 
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
     // this is used by wxPthreadCleanup() only
     static void Cleanup(wxThread *thread);
     // this is used by wxPthreadCleanup() only
     static void Cleanup(wxThread *thread);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
 
 private:
     pthread_t     m_threadId;   // id of the thread
     wxThreadState m_state;      // see wxThreadState enum
 
 private:
     pthread_t     m_threadId;   // id of the thread
     wxThreadState m_state;      // see wxThreadState enum
-    int           m_prio;       // in wxWindows units: from 0 to 100
+    int           m_prio;       // in wxWidgets units: from 0 to 100
 
     // this flag is set when the thread should terminate
     bool m_cancelled;
 
     // this flag is set when the thread should terminate
     bool m_cancelled;
@@ -712,12 +806,8 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
 {
     wxThreadInternal *pthread = thread->m_internal;
 
 {
     wxThreadInternal *pthread = thread->m_internal;
 
-#ifdef __VMS
-   wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), (long long)pthread->GetId());
-#else
-   wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), (long)pthread->GetId());
-#endif
-   
+    wxLogTrace(TRACE_THREADS, wxT("Thread %p started."), THR_ID(pthread));
+
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work
     int rc = pthread_setspecific(gs_keySelf, thread);
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work
     int rc = pthread_setspecific(gs_keySelf, thread);
@@ -732,11 +822,11 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
     // block!
     bool dontRunAtAll;
 
     // block!
     bool dontRunAtAll;
 
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
     // install the cleanup handler which will be called if the thread is
     // cancelled
     pthread_cleanup_push(wxPthreadCleanup, thread);
     // install the cleanup handler which will be called if the thread is
     // cancelled
     pthread_cleanup_push(wxPthreadCleanup, thread);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
 
     // wait for the semaphore to be posted from Run()
     pthread->m_semRun.Wait();
 
     // wait for the semaphore to be posted from Run()
     pthread->m_semRun.Wait();
@@ -753,22 +843,20 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
     if ( !dontRunAtAll )
     {
         // call the main entry
     if ( !dontRunAtAll )
     {
         // call the main entry
-        wxLogTrace(TRACE_THREADS, _T("Thread %ld about to enter its Entry()."),
-#ifdef __VMS
-                   (long long)pthread->GetId());
-#else
-                   (long)pthread->GetId());
-#endif
-       
-        pthread->m_exitcode = thread->Entry();
+        wxLogTrace(TRACE_THREADS,
+                   wxT("Thread %p about to enter its Entry()."),
+                   THR_ID(pthread));
+
+        wxTRY
+        {
+            pthread->m_exitcode = thread->Entry();
+
+            wxLogTrace(TRACE_THREADS,
+                       wxT("Thread %p Entry() returned %lu."),
+                       THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+        }
+        wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
 
 
-        wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."),
-#ifdef __VMS
-                   (long long)pthread->GetId(), (unsigned long)pthread->m_exitcode);
-#else
-                   (long)pthread->GetId(), (unsigned long)pthread->m_exitcode);
-#endif
-       
         {
             wxCriticalSectionLocker lock(thread->m_critsect);
 
         {
             wxCriticalSectionLocker lock(thread->m_critsect);
 
@@ -779,13 +867,22 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
         }
     }
 
         }
     }
 
-    // NB: at least under Linux, pthread_cleanup_push/pop are macros and pop
-    //     contains the matching '}' for the '{' in push, so they must be used
-    //     in the same block!
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+    // NB: pthread_cleanup_push/pop() are macros and pop contains the matching
+    //     '}' for the '{' in push, so they must be used in the same block!
+#ifdef wxHAVE_PTHREAD_CLEANUP
+    #ifdef __DECCXX
+        // under Tru64 we get a warning from macro expansion
+        #pragma message save
+        #pragma message disable(declbutnotref)
+    #endif
+
     // remove the cleanup handler without executing it
     pthread_cleanup_pop(FALSE);
     // remove the cleanup handler without executing it
     pthread_cleanup_pop(FALSE);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+
+    #ifdef __DECCXX
+        #pragma message restore
+    #endif
+#endif // wxHAVE_PTHREAD_CLEANUP
 
     if ( dontRunAtAll )
     {
 
     if ( dontRunAtAll )
     {
@@ -805,7 +902,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
     }
 }
 
     }
 }
 
-#if HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifdef wxHAVE_PTHREAD_CLEANUP
 
 // this handler is called when the thread is cancelled
 extern "C" void wxPthreadCleanup(void *ptr)
 
 // this handler is called when the thread is cancelled
 extern "C" void wxPthreadCleanup(void *ptr)
@@ -815,6 +912,7 @@ extern "C" void wxPthreadCleanup(void *ptr)
 
 void wxThreadInternal::Cleanup(wxThread *thread)
 {
 
 void wxThreadInternal::Cleanup(wxThread *thread)
 {
+    if (pthread_getspecific(gs_keySelf) == 0) return;
     {
         wxCriticalSectionLocker lock(thread->m_critsect);
         if ( thread->m_internal->GetState() == STATE_EXITED )
     {
         wxCriticalSectionLocker lock(thread->m_critsect);
         if ( thread->m_internal->GetState() == STATE_EXITED )
@@ -828,7 +926,7 @@ void wxThreadInternal::Cleanup(wxThread *thread)
     thread->Exit(EXITCODE_CANCELLED);
 }
 
     thread->Exit(EXITCODE_CANCELLED);
 }
 
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
 
 // ----------------------------------------------------------------------------
 // wxThreadInternal
 
 // ----------------------------------------------------------------------------
 // wxThreadInternal
@@ -837,17 +935,17 @@ void wxThreadInternal::Cleanup(wxThread *thread)
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
 wxThreadInternal::wxThreadInternal()
 {
     m_state = STATE_NEW;
-    m_cancelled = FALSE;
+    m_cancelled = false;
     m_prio = WXTHREAD_DEFAULT_PRIORITY;
     m_threadId = 0;
     m_exitcode = 0;
 
     m_prio = WXTHREAD_DEFAULT_PRIORITY;
     m_threadId = 0;
     m_exitcode = 0;
 
-    // set to TRUE only when the thread starts waiting on m_semSuspend
-    m_isPaused = FALSE;
+    // set to true only when the thread starts waiting on m_semSuspend
+    m_isPaused = false;
 
     // defaults for joinable threads
 
     // defaults for joinable threads
-    m_shouldBeJoined = TRUE;
-    m_isDetached = FALSE;
+    m_shouldBeJoined = true;
+    m_isDetached = false;
 }
 
 wxThreadInternal::~wxThreadInternal()
 }
 
 wxThreadInternal::~wxThreadInternal()
@@ -869,7 +967,7 @@ wxThreadError wxThreadInternal::Run()
 
 void wxThreadInternal::Wait()
 {
 
 void wxThreadInternal::Wait()
 {
-    wxCHECK_RET( !m_isDetached, _T("can't wait for a detached thread") );
+    wxCHECK_RET( !m_isDetached, wxT("can't wait for a detached thread") );
 
     // if the thread we're waiting for is waiting for the GUI mutex, we will
     // deadlock so make sure we release it temporarily
 
     // if the thread we're waiting for is waiting for the GUI mutex, we will
     // deadlock so make sure we release it temporarily
@@ -877,12 +975,9 @@ void wxThreadInternal::Wait()
         wxMutexGuiLeave();
 
     wxLogTrace(TRACE_THREADS,
         wxMutexGuiLeave();
 
     wxLogTrace(TRACE_THREADS,
-#ifdef __VMS
-               _T("Starting to wait for thread %ld to exit."), (long long)GetId());
-#else
-               _T("Starting to wait for thread %ld to exit."), (long)GetId());
-#endif
-   
+               wxT("Starting to wait for thread %p to exit."),
+               THR_ID(this));
+
     // to avoid memory leaks we should call pthread_join(), but it must only be
     // done once so use a critical section to serialize the code below
     {
     // to avoid memory leaks we should call pthread_join(), but it must only be
     // done once so use a critical section to serialize the code below
     {
@@ -900,11 +995,10 @@ void wxThreadInternal::Wait()
                 // wxLogDebug: it is possible to bring the system to its knees
                 // by creating too many threads and not joining them quite
                 // easily
                 // wxLogDebug: it is possible to bring the system to its knees
                 // by creating too many threads and not joining them quite
                 // easily
-                wxLogError(_("Failed to join a thread, potential memory leak "
-                             "detected - please restart the program"));
+                wxLogError(_("Failed to join a thread, potential memory leak detected - please restart the program"));
             }
 
             }
 
-            m_shouldBeJoined = FALSE;
+            m_shouldBeJoined = false;
         }
     }
 
         }
     }
 
@@ -920,12 +1014,9 @@ void wxThreadInternal::Pause()
     wxCHECK_RET( m_state == STATE_PAUSED,
                  wxT("thread must first be paused with wxThread::Pause().") );
 
     wxCHECK_RET( m_state == STATE_PAUSED,
                  wxT("thread must first be paused with wxThread::Pause().") );
 
-#ifdef __VMS
-   wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), (long long)GetId());
-#else
-   wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), (long)GetId());
-#endif
-   
+   wxLogTrace(TRACE_THREADS,
+              wxT("Thread %p goes to sleep."), THR_ID(this));
+
     // wait until the semaphore is Post()ed from Resume()
     m_semSuspend.Wait();
 }
     // wait until the semaphore is Post()ed from Resume()
     m_semSuspend.Wait();
 }
@@ -939,26 +1030,19 @@ void wxThreadInternal::Resume()
     // TestDestroy() since the last call to Pause() for example
     if ( IsReallyPaused() )
     {
     // TestDestroy() since the last call to Pause() for example
     if ( IsReallyPaused() )
     {
-#ifdef __VMS
-       wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), (long long)GetId());
-#else
-       wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), (long)GetId());
-#endif
-       
+       wxLogTrace(TRACE_THREADS,
+                  wxT("Waking up thread %p"), THR_ID(this));
+
         // wake up Pause()
         m_semSuspend.Post();
 
         // reset the flag
         // wake up Pause()
         m_semSuspend.Post();
 
         // reset the flag
-        SetReallyPaused(FALSE);
+        SetReallyPaused(false);
     }
     else
     {
     }
     else
     {
-        wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"),
-#ifdef __VMS
-                   (long long)GetId());
-#else
-                   (long)GetId());
-#endif
+        wxLogTrace(TRACE_THREADS,
+                   wxT("Thread %p is not yet really paused"), THR_ID(this));
     }
 
     SetState(STATE_RUNNING);
     }
 
     SetState(STATE_RUNNING);
@@ -973,11 +1057,6 @@ wxThread *wxThread::This()
     return (wxThread *)pthread_getspecific(gs_keySelf);
 }
 
     return (wxThread *)pthread_getspecific(gs_keySelf);
 }
 
-bool wxThread::IsMain()
-{
-    return (bool)pthread_equal(pthread_self(), gs_tidMain);
-}
-
 void wxThread::Yield()
 {
 #ifdef HAVE_SCHED_YIELD
 void wxThread::Yield()
 {
 #ifdef HAVE_SCHED_YIELD
@@ -985,19 +1064,21 @@ void wxThread::Yield()
 #endif
 }
 
 #endif
 }
 
-void wxThread::Sleep(unsigned long milliseconds)
-{
-    wxUsleep(milliseconds);
-}
-
 int wxThread::GetCPUCount()
 {
 int wxThread::GetCPUCount()
 {
-#if defined(__LINUX__) && wxUSE_FFILE
+#if defined(_SC_NPROCESSORS_ONLN)
+    // this works for Solaris and Linux 2.6
+    int rc = sysconf(_SC_NPROCESSORS_ONLN);
+    if ( rc != -1 )
+    {
+        return rc;
+    }
+#elif defined(__LINUX__) && wxUSE_FFILE
     // read from proc (can't use wxTextFile here because it's a special file:
     // it has 0 size but still can be read from)
     wxLogNull nolog;
 
     // read from proc (can't use wxTextFile here because it's a special file:
     // it has 0 size but still can be read from)
     wxLogNull nolog;
 
-    wxFFile file(_T("/proc/cpuinfo"));
+    wxFFile file(wxT("/proc/cpuinfo"));
     if ( file.IsOpened() )
     {
         // slurp the whole file
     if ( file.IsOpened() )
     {
         // slurp the whole file
@@ -1005,52 +1086,38 @@ int wxThread::GetCPUCount()
         if ( file.ReadAll(&s) )
         {
             // (ab)use Replace() to find the number of "processor: num" strings
         if ( file.ReadAll(&s) )
         {
             // (ab)use Replace() to find the number of "processor: num" strings
-            size_t count = s.Replace(_T("processor\t:"), _T(""));
+            size_t count = s.Replace(wxT("processor\t:"), wxT(""));
             if ( count > 0 )
             {
                 return count;
             }
 
             if ( count > 0 )
             {
                 return count;
             }
 
-            wxLogDebug(_T("failed to parse /proc/cpuinfo"));
+            wxLogDebug(wxT("failed to parse /proc/cpuinfo"));
         }
         else
         {
         }
         else
         {
-            wxLogDebug(_T("failed to read /proc/cpuinfo"));
+            wxLogDebug(wxT("failed to read /proc/cpuinfo"));
         }
     }
         }
     }
-#elif defined(_SC_NPROCESSORS_ONLN)
-    // this works for Solaris
-    int rc = sysconf(_SC_NPROCESSORS_ONLN);
-    if ( rc != -1 )
-    {
-        return rc;
-    }
 #endif // different ways to get number of CPUs
 
     // unknown
     return -1;
 }
 
 #endif // different ways to get number of CPUs
 
     // unknown
     return -1;
 }
 
-#ifdef __VMS
-  // VMS is a 64 bit system and threads have 64 bit pointers.
-  // ??? also needed for other systems????
-unsigned long long wxThread::GetCurrentId()
+wxThreadIdType wxThread::GetCurrentId()
 {
 {
-    return (unsigned long long)pthread_self();
-#else
-unsigned long wxThread::GetCurrentId()
-{
-    return (unsigned long)pthread_self();
-#endif
+    return (wxThreadIdType)pthread_self();
 }
 
 }
 
+
 bool wxThread::SetConcurrency(size_t level)
 {
 #ifdef HAVE_THR_SETCONCURRENCY
     int rc = thr_setconcurrency(level);
     if ( rc != 0 )
     {
 bool wxThread::SetConcurrency(size_t level)
 {
 #ifdef HAVE_THR_SETCONCURRENCY
     int rc = thr_setconcurrency(level);
     if ( rc != 0 )
     {
-        wxLogSysError(rc, _T("thr_setconcurrency() failed"));
+        wxLogSysError(rc, wxT("thr_setconcurrency() failed"));
     }
 
     return rc == 0;
     }
 
     return rc == 0;
@@ -1067,14 +1134,24 @@ bool wxThread::SetConcurrency(size_t level)
 wxThread::wxThread(wxThreadKind kind)
 {
     // add this thread to the global list of all threads
 wxThread::wxThread(wxThreadKind kind)
 {
     // add this thread to the global list of all threads
-    gs_allThreads.Add(this);
+    {
+        wxMutexLocker lock(*gs_mutexAllThreads);
+
+        gs_allThreads.Add(this);
+    }
 
     m_internal = new wxThreadInternal();
 
     m_isDetached = kind == wxTHREAD_DETACHED;
 }
 
 
     m_internal = new wxThreadInternal();
 
     m_isDetached = kind == wxTHREAD_DETACHED;
 }
 
-wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+    #define WXUNUSED_STACKSIZE(identifier)  identifier
+#else
+    #define WXUNUSED_STACKSIZE(identifier)  WXUNUSED(identifier)
+#endif
+
+wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(stackSize))
 {
     if ( m_internal->GetState() != STATE_NEW )
     {
 {
     if ( m_internal->GetState() != STATE_NEW )
     {
@@ -1086,6 +1163,11 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
     pthread_attr_t attr;
     pthread_attr_init(&attr);
 
     pthread_attr_t attr;
     pthread_attr_init(&attr);
 
+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+    if (stackSize)
+      pthread_attr_setstacksize(&attr, stackSize);
+#endif
+
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
     int policy;
     if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
     int policy;
     if ( pthread_attr_getschedpolicy(&attr, &policy) != 0 )
@@ -1128,14 +1210,14 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
         struct sched_param sp;
         if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
         {
         struct sched_param sp;
         if ( pthread_attr_getschedparam(&attr, &sp) != 0 )
         {
-            wxFAIL_MSG(_T("pthread_attr_getschedparam() failed"));
+            wxFAIL_MSG(wxT("pthread_attr_getschedparam() failed"));
         }
 
         sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100;
 
         if ( pthread_attr_setschedparam(&attr, &sp) != 0 )
         {
         }
 
         sp.sched_priority = min_prio + (prio*(max_prio - min_prio))/100;
 
         if ( pthread_attr_setschedparam(&attr, &sp) != 0 )
         {
-            wxFAIL_MSG(_T("pthread_attr_setschedparam(priority) failed"));
+            wxFAIL_MSG(wxT("pthread_attr_setschedparam(priority) failed"));
         }
     }
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
         }
     }
 #endif // HAVE_THREAD_PRIORITY_FUNCTIONS
@@ -1144,7 +1226,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
     // this will make the threads created by this process really concurrent
     if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
     {
     // this will make the threads created by this process really concurrent
     if ( pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0 )
     {
-        wxFAIL_MSG(_T("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
+        wxFAIL_MSG(wxT("pthread_attr_setscope(PTHREAD_SCOPE_SYSTEM) failed"));
     }
 #endif // HAVE_PTHREAD_ATTR_SETSCOPE
 
     }
 #endif // HAVE_PTHREAD_ATTR_SETSCOPE
 
@@ -1155,7 +1237,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
     {
         if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
         {
     {
         if ( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0 )
         {
-            wxFAIL_MSG(_T("pthread_attr_setdetachstate(DETACHED) failed"));
+            wxFAIL_MSG(wxT("pthread_attr_setdetachstate(DETACHED) failed"));
         }
 
         // never try to join detached threads
         }
 
         // never try to join detached threads
@@ -1174,7 +1256,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
 
     if ( pthread_attr_destroy(&attr) != 0 )
     {
 
     if ( pthread_attr_destroy(&attr) != 0 )
     {
-        wxFAIL_MSG(_T("pthread_attr_destroy() failed"));
+        wxFAIL_MSG(wxT("pthread_attr_destroy() failed"));
     }
 
     if ( rc != 0 )
     }
 
     if ( rc != 0 )
@@ -1220,42 +1302,21 @@ void wxThread::SetPriority(unsigned int prio)
         case STATE_PAUSED:
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
 #if defined(__LINUX__)
         case STATE_PAUSED:
 #ifdef HAVE_THREAD_PRIORITY_FUNCTIONS
 #if defined(__LINUX__)
-// On Linux, pthread_setschedparam with SCHED_OTHER does not allow
-// a priority other than 0.  Instead, we use the BSD setpriority
-// which alllows us to set a 'nice' value between 20 to -20.  Only
-// super user can set a value less than zero (more negative yields
-// higher priority).  setpriority set the static priority of a process,
-// but this is OK since Linux is configured as a thread per process.
-            {
-                float   fPrio;
-                float  pSpan;
-                int            iPrio;
-
-                // Map Wx priorites (WXTHREAD_MIN_PRIORITY -
-                // WXTHREAD_MAX_PRIORITY) into BSD priorities (20 - -20).
-                // Do calculation of values instead of hard coding them
-                // to make maintenance easier.
-
-                pSpan = ((float)(WXTHREAD_MAX_PRIORITY - WXTHREAD_MIN_PRIORITY)) / 2.0;
-
-                // prio starts as ...................  // value =>  (0) >=  p  <=  (n)
-
-                fPrio = ((float)prio) -  pSpan;        // value =>  (-n) >=  p  <=  (+n)
-
-                fPrio = 0.0 - fPrio;                   // value =>  (+n) <=  p  >=  (-n)
-
-                fPrio = fPrio * (20. / pSpan) + .5;    // value =>  (20) <=  p  >=  (-20)
-
-                iPrio = (int)fPrio;
-
-                // Clamp prio from 20 - -20;
-                iPrio = (iPrio > 20)  ?  20 : iPrio;
-                iPrio = (iPrio < -20) ? -20 : iPrio;
+            // On Linux, pthread_setschedparam with SCHED_OTHER does not allow
+            // a priority other than 0.  Instead, we use the BSD setpriority
+            // which alllows us to set a 'nice' value between 20 to -20.  Only
+            // super user can set a value less than zero (more negative yields
+            // higher priority).  setpriority set the static priority of a
+            // process, but this is OK since Linux is configured as a thread
+            // per process.
+            //
+            // FIXME this is not true for 2.6!!
 
 
-                if (setpriority(PRIO_PROCESS, 0, iPrio) == -1)
-                {
-                    wxLogError(_("Failed to set thread priority %d."), prio);
-                }
+            // map wx priorites WXTHREAD_MIN_PRIORITY..WXTHREAD_MAX_PRIORITY
+            // to Unix priorities 20..-20
+            if ( setpriority(PRIO_PROCESS, 0, -(2*(int)prio)/5 + 20) == -1 )
+            {
+                wxLogError(_("Failed to set thread priority %d."), prio);
             }
 #else // __LINUX__
             {
             }
 #else // __LINUX__
             {
@@ -1297,7 +1358,7 @@ wxThreadIdType wxThread::GetId() const
 wxThreadError wxThread::Pause()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
 wxThreadError wxThread::Pause()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
-                 _T("a thread can't pause itself") );
+                 wxT("a thread can't pause itself") );
 
     wxCriticalSectionLocker lock(m_critsect);
 
 
     wxCriticalSectionLocker lock(m_critsect);
 
@@ -1318,7 +1379,7 @@ wxThreadError wxThread::Pause()
 wxThreadError wxThread::Resume()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
 wxThreadError wxThread::Resume()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
-                 _T("a thread can't resume itself") );
+                 wxT("a thread can't resume itself") );
 
     wxCriticalSectionLocker lock(m_critsect);
 
 
     wxCriticalSectionLocker lock(m_critsect);
 
@@ -1327,20 +1388,20 @@ wxThreadError wxThread::Resume()
     switch ( state )
     {
         case STATE_PAUSED:
     switch ( state )
     {
         case STATE_PAUSED:
-            wxLogTrace(TRACE_THREADS, _T("Thread %ld suspended, resuming."),
-                       GetId());
+            wxLogTrace(TRACE_THREADS, wxT("Thread %p suspended, resuming."),
+                       THR_ID(this));
 
             m_internal->Resume();
 
             return wxTHREAD_NO_ERROR;
 
         case STATE_EXITED:
 
             m_internal->Resume();
 
             return wxTHREAD_NO_ERROR;
 
         case STATE_EXITED:
-            wxLogTrace(TRACE_THREADS, _T("Thread %ld exited, won't resume."),
-                       GetId());
+            wxLogTrace(TRACE_THREADS, wxT("Thread %p exited, won't resume."),
+                       THR_ID(this));
             return wxTHREAD_NO_ERROR;
 
         default:
             return wxTHREAD_NO_ERROR;
 
         default:
-            wxLogDebug(_T("Attempt to resume a thread which is not paused."));
+            wxLogDebug(wxT("Attempt to resume a thread which is not paused."));
 
             return wxTHREAD_MISC_ERROR;
     }
 
             return wxTHREAD_MISC_ERROR;
     }
@@ -1353,10 +1414,10 @@ wxThreadError wxThread::Resume()
 wxThread::ExitCode wxThread::Wait()
 {
     wxCHECK_MSG( This() != this, (ExitCode)-1,
 wxThread::ExitCode wxThread::Wait()
 {
     wxCHECK_MSG( This() != this, (ExitCode)-1,
-                 _T("a thread can't wait for itself") );
+                 wxT("a thread can't wait for itself") );
 
     wxCHECK_MSG( !m_isDetached, (ExitCode)-1,
 
     wxCHECK_MSG( !m_isDetached, (ExitCode)-1,
-                 _T("can't wait for detached thread") );
+                 wxT("can't wait for detached thread") );
 
     m_internal->Wait();
 
 
     m_internal->Wait();
 
@@ -1366,7 +1427,7 @@ wxThread::ExitCode wxThread::Wait()
 wxThreadError wxThread::Delete(ExitCode *rc)
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
 wxThreadError wxThread::Delete(ExitCode *rc)
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
-                 _T("a thread can't delete itself") );
+                 wxT("a thread can't delete itself") );
 
     bool isDetached = m_isDetached;
 
 
     bool isDetached = m_isDetached;
 
@@ -1412,6 +1473,11 @@ wxThreadError wxThread::Delete(ExitCode *rc)
             }
             //else: can't wait for detached threads
     }
             }
             //else: can't wait for detached threads
     }
+    
+    if (state == STATE_NEW)
+        return wxTHREAD_MISC_ERROR;
+            // for coherency with the MSW implementation, signal the user that 
+            // Delete() was called on a thread which didn't start to run yet.
 
     return wxTHREAD_NO_ERROR;
 }
 
     return wxTHREAD_NO_ERROR;
 }
@@ -1419,7 +1485,7 @@ wxThreadError wxThread::Delete(ExitCode *rc)
 wxThreadError wxThread::Kill()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
 wxThreadError wxThread::Kill()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
-                 _T("a thread can't kill itself") );
+                 wxT("a thread can't kill itself") );
 
     switch ( m_internal->GetState() )
     {
 
     switch ( m_internal->GetState() )
     {
@@ -1436,25 +1502,26 @@ wxThreadError wxThread::Kill()
         default:
 #ifdef HAVE_PTHREAD_CANCEL
             if ( pthread_cancel(m_internal->GetId()) != 0 )
         default:
 #ifdef HAVE_PTHREAD_CANCEL
             if ( pthread_cancel(m_internal->GetId()) != 0 )
-#endif
+#endif // HAVE_PTHREAD_CANCEL
             {
                 wxLogError(_("Failed to terminate a thread."));
 
                 return wxTHREAD_MISC_ERROR;
             }
 
             {
                 wxLogError(_("Failed to terminate a thread."));
 
                 return wxTHREAD_MISC_ERROR;
             }
 
+#ifdef HAVE_PTHREAD_CANCEL
             if ( m_isDetached )
             {
                 // if we use cleanup function, this will be done from
                 // wxPthreadCleanup()
             if ( m_isDetached )
             {
                 // if we use cleanup function, this will be done from
                 // wxPthreadCleanup()
-#if !HAVE_THREAD_CLEANUP_FUNCTIONS
+#ifndef wxHAVE_PTHREAD_CLEANUP
                 ScheduleThreadForDeletion();
 
                 // don't call OnExit() here, it can only be called in the
                 // threads context and we're in the context of another thread
 
                 DeleteThread(this);
                 ScheduleThreadForDeletion();
 
                 // don't call OnExit() here, it can only be called in the
                 // threads context and we're in the context of another thread
 
                 DeleteThread(this);
-#endif // HAVE_THREAD_CLEANUP_FUNCTIONS
+#endif // wxHAVE_PTHREAD_CLEANUP
             }
             else
             {
             }
             else
             {
@@ -1462,14 +1529,14 @@ wxThreadError wxThread::Kill()
             }
 
             return wxTHREAD_NO_ERROR;
             }
 
             return wxTHREAD_NO_ERROR;
+#endif // HAVE_PTHREAD_CANCEL
     }
 }
 
 void wxThread::Exit(ExitCode status)
 {
     wxASSERT_MSG( This() == this,
     }
 }
 
 void wxThread::Exit(ExitCode status)
 {
     wxASSERT_MSG( This() == this,
-                  _T("wxThread::Exit() can only be called in the "
-                     "context of the same thread") );
+                  wxT("wxThread::Exit() can only be called in the context of the same thread") );
 
     if ( m_isDetached )
     {
 
     if ( m_isDetached )
     {
@@ -1483,7 +1550,11 @@ void wxThread::Exit(ExitCode status)
     // might deadlock if, for example, it signals a condition in OnExit() (a
     // common case) while the main thread calls any of functions entering
     // m_critsect on us (almost all of them do)
     // might deadlock if, for example, it signals a condition in OnExit() (a
     // common case) while the main thread calls any of functions entering
     // m_critsect on us (almost all of them do)
-    OnExit();
+    wxTRY
+    {
+        OnExit();
+    }
+    wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
 
     // delete C++ thread object if this is a detached thread - user is
     // responsible for doing this for joinable ones
 
     // delete C++ thread object if this is a detached thread - user is
     // responsible for doing this for joinable ones
@@ -1496,26 +1567,32 @@ void wxThread::Exit(ExitCode status)
         //       we make it a global object, but this would mean that we can
         //       only call one thread function at a time :-(
         DeleteThread(this);
         //       we make it a global object, but this would mean that we can
         //       only call one thread function at a time :-(
         DeleteThread(this);
+        pthread_setspecific(gs_keySelf, 0);
+    }
+    else
+    {
+        m_critsect.Enter();
+        m_internal->SetState(STATE_EXITED);
+        m_critsect.Leave();
     }
 
     // terminate the thread (pthread_exit() never returns)
     pthread_exit(status);
 
     }
 
     // terminate the thread (pthread_exit() never returns)
     pthread_exit(status);
 
-    wxFAIL_MSG(_T("pthread_exit() failed"));
+    wxFAIL_MSG(wxT("pthread_exit() failed"));
 }
 
 // also test whether we were paused
 bool wxThread::TestDestroy()
 {
     wxASSERT_MSG( This() == this,
 }
 
 // also test whether we were paused
 bool wxThread::TestDestroy()
 {
     wxASSERT_MSG( This() == this,
-                  _T("wxThread::TestDestroy() can only be called in the "
-                     "context of the same thread") );
+                  wxT("wxThread::TestDestroy() can only be called in the context of the same thread") );
 
     m_critsect.Enter();
 
     if ( m_internal->GetState() == STATE_PAUSED )
     {
 
     m_critsect.Enter();
 
     if ( m_internal->GetState() == STATE_PAUSED )
     {
-        m_internal->SetReallyPaused(TRUE);
+        m_internal->SetReallyPaused(true);
 
         // leave the crit section or the other threads will stop too if they
         // try to call any of (seemingly harmless) IsXXX() functions while we
 
         // leave the crit section or the other threads will stop too if they
         // try to call any of (seemingly harmless) IsXXX() functions while we
@@ -1535,24 +1612,26 @@ bool wxThread::TestDestroy()
 
 wxThread::~wxThread()
 {
 
 wxThread::~wxThread()
 {
-#ifdef __WXDEBUG__
     m_critsect.Enter();
 
     // check that the thread either exited or couldn't be created
     if ( m_internal->GetState() != STATE_EXITED &&
          m_internal->GetState() != STATE_NEW )
     {
     m_critsect.Enter();
 
     // check that the thread either exited or couldn't be created
     if ( m_internal->GetState() != STATE_EXITED &&
          m_internal->GetState() != STATE_NEW )
     {
-        wxLogDebug(_T("The thread %ld is being destroyed although it is still "
-                      "running! The application may crash."), GetId());
+        wxLogDebug(wxT("The thread %p is being destroyed although it is still running! The application may crash."),
+                   THR_ID(this));
     }
 
     m_critsect.Leave();
     }
 
     m_critsect.Leave();
-#endif // __WXDEBUG__
 
     delete m_internal;
 
     // remove this thread from the global array
 
     delete m_internal;
 
     // remove this thread from the global array
-    gs_allThreads.Remove(this);
+    {
+        wxMutexLocker lock(*gs_mutexAllThreads);
+
+        gs_allThreads.Remove(this);
+    }
 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------
@@ -1574,10 +1653,10 @@ bool wxThread::IsAlive() const
     {
         case STATE_RUNNING:
         case STATE_PAUSED:
     {
         case STATE_RUNNING:
         case STATE_PAUSED:
-            return TRUE;
+            return true;
 
         default:
 
         default:
-            return FALSE;
+            return false;
     }
 }
 
     }
 }
 
@@ -1609,24 +1688,22 @@ bool wxThreadModule::OnInit()
     int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
     if ( rc != 0 )
     {
     int rc = pthread_key_create(&gs_keySelf, NULL /* dtor function */);
     if ( rc != 0 )
     {
-        wxLogSysError(rc, _("Thread module initialization failed: "
-                            "failed to create thread key"));
+        wxLogSysError(rc, _("Thread module initialization failed: failed to create thread key"));
 
 
-        return FALSE;
+        return false;
     }
 
     }
 
-    gs_tidMain = pthread_self();
+    wxThread::ms_idMainThread = wxThread::GetCurrentId();
 
 
-#if wxUSE_GUI
-    gs_mutexGui = new wxMutex();
+    gs_mutexAllThreads = new wxMutex();
 
 
+    gs_mutexGui = new wxMutex();
     gs_mutexGui->Lock();
     gs_mutexGui->Lock();
-#endif // wxUSE_GUI
 
     gs_mutexDeleteThread = new wxMutex();
 
     gs_mutexDeleteThread = new wxMutex();
-    gs_condAllDeleted = new wxCondition( *gs_mutexDeleteThread );
+    gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread);
 
 
-    return TRUE;
+    return true;
 }
 
 void wxThreadModule::OnExit()
 }
 
 void wxThreadModule::OnExit()
@@ -1643,7 +1720,7 @@ void wxThreadModule::OnExit()
         if ( nThreadsBeingDeleted > 0 )
         {
             wxLogTrace(TRACE_THREADS,
         if ( nThreadsBeingDeleted > 0 )
         {
             wxLogTrace(TRACE_THREADS,
-                       _T("Waiting for %lu threads to disappear"),
+                       wxT("Waiting for %lu threads to disappear"),
                        (unsigned long)nThreadsBeingDeleted);
 
             // have to wait until all of them disappear
                        (unsigned long)nThreadsBeingDeleted);
 
             // have to wait until all of them disappear
@@ -1651,13 +1728,19 @@ void wxThreadModule::OnExit()
         }
     }
 
         }
     }
 
-    // terminate any threads left
-    size_t count = gs_allThreads.GetCount();
-    if ( count != 0u )
+    size_t count;
+
     {
     {
-        wxLogDebug(wxT("%lu threads were not terminated by the application."),
-                   (unsigned long)count);
-    }
+        wxMutexLocker lock(*gs_mutexAllThreads);
+
+        // terminate any threads left
+        count = gs_allThreads.GetCount();
+        if ( count != 0u )
+        {
+            wxLogDebug(wxT("%lu threads were not terminated by the application."),
+                       (unsigned long)count);
+        }
+    } // unlock mutex before deleting the threads as they lock it in their dtor
 
     for ( size_t n = 0u; n < count; n++ )
     {
 
     for ( size_t n = 0u; n < count; n++ )
     {
@@ -1666,12 +1749,11 @@ void wxThreadModule::OnExit()
         gs_allThreads[0]->Delete();
     }
 
         gs_allThreads[0]->Delete();
     }
 
-#if wxUSE_GUI
+    delete gs_mutexAllThreads;
+
     // destroy GUI mutex
     gs_mutexGui->Unlock();
     // destroy GUI mutex
     gs_mutexGui->Unlock();
-
     delete gs_mutexGui;
     delete gs_mutexGui;
-#endif // wxUSE_GUI
 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);
 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);
@@ -1690,25 +1772,26 @@ static void ScheduleThreadForDeletion()
 
     gs_nThreadsBeingDeleted++;
 
 
     gs_nThreadsBeingDeleted++;
 
-    wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
+    wxLogTrace(TRACE_THREADS, wxT("%lu thread%s waiting to be deleted"),
                (unsigned long)gs_nThreadsBeingDeleted,
                (unsigned long)gs_nThreadsBeingDeleted,
-               gs_nThreadsBeingDeleted == 1 ? "" : "s");
+               gs_nThreadsBeingDeleted == 1 ? wxT("") : wxT("s"));
 }
 
 static void DeleteThread(wxThread *This)
 {
 }
 
 static void DeleteThread(wxThread *This)
 {
-    // gs_mutexDeleteThread should be unlocked before signalling the condition
-    // or wxThreadModule::OnExit() would deadlock
-    wxMutexLocker locker( *gs_mutexDeleteThread );
-
-    wxLogTrace(TRACE_THREADS, _T("Thread %ld auto deletes."), This->GetId());
+    wxLogTrace(TRACE_THREADS, wxT("Thread %p auto deletes."), THR_ID(This));
 
     delete This;
 
 
     delete This;
 
+    // only lock gs_mutexDeleteThread after deleting the thread to avoid
+    // calling out into user code with it locked as this may result in
+    // deadlocks if the thread dtor deletes another thread (see #11501)
+    wxMutexLocker locker( *gs_mutexDeleteThread );
+
     wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
     wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
-                 _T("no threads scheduled for deletion, yet we delete one?") );
+                 wxT("no threads scheduled for deletion, yet we delete one?") );
 
 
-    wxLogTrace(TRACE_THREADS, _T("%lu scheduled for deletion threads left."),
+    wxLogTrace(TRACE_THREADS, wxT("%lu threads remain scheduled for deletion."),
                (unsigned long)gs_nThreadsBeingDeleted - 1);
 
     if ( !--gs_nThreadsBeingDeleted )
                (unsigned long)gs_nThreadsBeingDeleted - 1);
 
     if ( !--gs_nThreadsBeingDeleted )
@@ -1718,18 +1801,14 @@ static void DeleteThread(wxThread *This)
     }
 }
 
     }
 }
 
-void wxMutexGuiEnter()
+void wxMutexGuiEnterImpl()
 {
 {
-#if wxUSE_GUI
     gs_mutexGui->Lock();
     gs_mutexGui->Lock();
-#endif // wxUSE_GUI
 }
 
 }
 
-void wxMutexGuiLeave()
+void wxMutexGuiLeaveImpl()
 {
 {
-#if wxUSE_GUI
     gs_mutexGui->Unlock();
     gs_mutexGui->Unlock();
-#endif // wxUSE_GUI
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -1739,4 +1818,3 @@ void wxMutexGuiLeave()
 #include "wx/thrimpl.cpp"
 
 #endif // wxUSE_THREADS
 #include "wx/thrimpl.cpp"
 
 #endif // wxUSE_THREADS
-