Handle IN_MOVE inotify events better.

[wxWidgets.git] / src / unix / threadpsx.cpp

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 1b7248d98a7fa6cfdb601bb408959a51abca9c22..de36955cda32ac2ce70ba3bb2b1fc2d0b36e5031 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -45,6 +45,7 @@
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>

+#include <sys/time.h>           // needed for at least __QNX__

 #ifdef HAVE_SCHED_H
     #include <sched.h>
 #endif
 #ifdef HAVE_SCHED_H
     #include <sched.h>
 #endif


@@ -53,19 +54,18 @@
     #include <thread.h>
 #endif
 
     #include <thread.h>
 #endif
 

+#ifdef HAVE_ABI_FORCEDUNWIND
+    #include <cxxabi.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
 

-#ifdef __VMS
-    #define THR_ID(thr) ((long long)(thr)->GetId())
-#else
-    #define THR_ID(thr) ((long)(thr)->GetId())
-#endif
+#define THR_ID_CAST(id)  (reinterpret_cast<void*>(id))
+#define THR_ID(thr)      THR_ID_CAST((thr)->GetId())

 
 // ----------------------------------------------------------------------------
 // constants
 
 // ----------------------------------------------------------------------------
 // constants


@@ -84,10 +84,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


@@ -138,10 +138,12 @@ static wxMutex *gs_mutexDeleteThread = NULL;
 // gs_nThreadsBeingDeleted will have been deleted
 static wxCondition *gs_condAllDeleted = NULL;
 
 // gs_nThreadsBeingDeleted will have been deleted
 static wxCondition *gs_condAllDeleted = NULL;
 

+#ifndef __WXOSX__

 // 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;
 // 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;

+#endif

 
 // 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


@@ -232,7 +234,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:


@@ -329,11 +331,11 @@ wxMutexError wxMutexInternal::HandleLockResult(int err)
         case EDEADLK:
             // only error checking mutexes return this value and so it's an
             // unexpected situation -- hence use assert, not wxLogDebug
         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_[timed]lock(): mutex not initialized"));
+            wxLogDebug(wxT("pthread_mutex_[timed]lock(): mutex not initialized"));

             break;
 
         case ETIMEDOUT:
             break;
 
         case ETIMEDOUT:


@@ -345,7 +347,7 @@ wxMutexError wxMutexInternal::HandleLockResult(int err)
             return wxMUTEX_NO_ERROR;
 
         default:
             return wxMUTEX_NO_ERROR;
 
         default:

-            wxLogApiError(_T("pthread_mutex_[timed]lock()"), err);
+            wxLogApiError(wxT("pthread_mutex_[timed]lock()"), err);

     }
 
     return wxMUTEX_MISC_ERROR;
     }
 
     return wxMUTEX_MISC_ERROR;


@@ -363,7 +365,7 @@ 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:


@@ -372,7 +374,7 @@ wxMutexError wxMutexInternal::TryLock()
             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;


@@ -390,14 +392,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;


@@ -446,7 +448,7 @@ wxConditionInternal::wxConditionInternal(wxMutex& mutex)
 
     if ( !m_isOk )
     {
 
     if ( !m_isOk )
     {

-        wxLogApiError(_T("pthread_cond_init()"), err);
+        wxLogApiError(wxT("pthread_cond_init()"), err);

     }
 }
 
     }
 }
 


@@ -457,7 +459,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);

         }
     }
 }
         }
     }
 }


@@ -467,7 +469,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;
     }


@@ -477,7 +479,7 @@ wxCondError wxConditionInternal::Wait()
 
 wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
 {
 
 wxCondError wxConditionInternal::WaitTimeout(unsigned long milliseconds)
 {

-    wxLongLong curtime = wxGetLocalTimeMillis();
+    wxLongLong curtime = wxGetUTCTimeMillis();

     curtime += milliseconds;
     wxLongLong temp = curtime / 1000;
     int sec = temp.GetLo();
     curtime += milliseconds;
     wxLongLong temp = curtime / 1000;
     int sec = temp.GetLo();


@@ -500,7 +502,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;


@@ -511,7 +513,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;
     }


@@ -524,7 +526,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;
     }


@@ -573,7 +575,7 @@ 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;
     }


@@ -593,15 +595,15 @@ wxSemaError wxSemaphoreInternal::Wait()
     while ( m_count == 0 )
     {
         wxLogTrace(TRACE_SEMA,
     while ( m_count == 0 )
     {
         wxLogTrace(TRACE_SEMA,

-                   _T("Thread %p 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,

-                   _T("Thread %p 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--;


@@ -667,8 +669,8 @@ wxSemaError wxSemaphoreInternal::Post()
     m_count++;
 
     wxLogTrace(TRACE_SEMA,
     m_count++;
 
     wxLogTrace(TRACE_SEMA,

-               _T("Thread %p 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;


@@ -725,16 +727,16 @@ public:
     void SetState(wxThreadState state)
     {
 #if wxUSE_LOG_TRACE
     void SetState(wxThreadState state)
     {
 #if wxUSE_LOG_TRACE

-        static const wxChar *stateNames[] =
+        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 %p: %s => %s."),
-                   GetId(), stateNames[m_state], stateNames[state]);
+        wxLogTrace(TRACE_THREADS, wxT("Thread %p: %s => %s."),
+                   THR_ID(this), stateNames[m_state], stateNames[state]);

 #endif // wxUSE_LOG_TRACE
 
         m_state = state;
 #endif // wxUSE_LOG_TRACE
 
         m_state = state;


@@ -810,14 +812,14 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
 {
     wxThreadInternal *pthread = thread->m_internal;
 
 {
     wxThreadInternal *pthread = thread->m_internal;
 

-    wxLogTrace(TRACE_THREADS, _T("Thread %p started."), THR_ID(pthread));
+    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);
     if ( rc != 0 )
     {
 
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work
     int rc = pthread_setspecific(gs_keySelf, thread);
     if ( rc != 0 )
     {

-        wxLogSysError(rc, _("Cannot start thread: error writing TLS"));
+        wxLogSysError(rc, _("Cannot start thread: error writing TLS."));

 
         return (void *)-1;
     }
 
         return (void *)-1;
     }


@@ -848,7 +850,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
     {
         // call the main entry
         wxLogTrace(TRACE_THREADS,
     {
         // call the main entry
         wxLogTrace(TRACE_THREADS,

-                   _T("Thread %p about to enter its Entry()."),
+                   wxT("Thread %p about to enter its Entry()."),

                    THR_ID(pthread));
 
         wxTRY
                    THR_ID(pthread));
 
         wxTRY


@@ -856,9 +858,21 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
             pthread->m_exitcode = thread->Entry();
 
             wxLogTrace(TRACE_THREADS,
             pthread->m_exitcode = thread->Entry();
 
             wxLogTrace(TRACE_THREADS,

-                       _T("Thread %p Entry() returned %lu."),
+                       wxT("Thread %p Entry() returned %lu."),

                        THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
         }
                        THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
         }

+#ifdef HAVE_ABI_FORCEDUNWIND
+        // When using common C++ ABI under Linux we must always rethrow this
+        // special exception used to unwind the stack when the thread was
+        // cancelled, otherwise the thread library would simply terminate the
+        // program, see http://udrepper.livejournal.com/21541.html
+        catch ( abi::__forced_unwind& )
+        {
+            wxCriticalSectionLocker lock(thread->m_critsect);
+            pthread->SetState(STATE_EXITED);
+            throw;
+        }
+#endif // HAVE_ABI_FORCEDUNWIND

         wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
 
         {
         wxCATCH_ALL( wxTheApp->OnUnhandledException(); )
 
         {


@@ -971,15 +985,25 @@ 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 ( wxThread::IsMain() )
 
     // if the thread we're waiting for is waiting for the GUI mutex, we will
     // deadlock so make sure we release it temporarily
     if ( wxThread::IsMain() )

+    {
+#ifdef __WXOSX__
+        // give the thread we're waiting for chance to do the GUI call
+        // it might be in, we don't do this conditionally as the to be waited on
+        // thread might have to acquire the mutex later but before terminating
+        if ( wxGuiOwnedByMainThread() )
+            wxMutexGuiLeave();
+#else

         wxMutexGuiLeave();
         wxMutexGuiLeave();

+#endif
+    }

 
     wxLogTrace(TRACE_THREADS,
 
     wxLogTrace(TRACE_THREADS,

-               _T("Starting to wait for thread %p to exit."),
+               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
                THR_ID(this));
 
     // to avoid memory leaks we should call pthread_join(), but it must only be


@@ -1006,9 +1030,11 @@ void wxThreadInternal::Wait()
         }
     }
 
         }
     }
 

+#ifndef __WXOSX__

     // reacquire GUI mutex
     if ( wxThread::IsMain() )
         wxMutexGuiEnter();
     // reacquire GUI mutex
     if ( wxThread::IsMain() )
         wxMutexGuiEnter();

+#endif

 }
 
 void wxThreadInternal::Pause()
 }
 
 void wxThreadInternal::Pause()


@@ -1019,7 +1045,7 @@ void wxThreadInternal::Pause()
                  wxT("thread must first be paused with wxThread::Pause().") );
 
    wxLogTrace(TRACE_THREADS,
                  wxT("thread must first be paused with wxThread::Pause().") );
 
    wxLogTrace(TRACE_THREADS,

-              _T("Thread %p goes to sleep."), THR_ID(this));
+              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();


@@ -1035,7 +1061,7 @@ void wxThreadInternal::Resume()
     if ( IsReallyPaused() )
     {
        wxLogTrace(TRACE_THREADS,
     if ( IsReallyPaused() )
     {
        wxLogTrace(TRACE_THREADS,

-                  _T("Waking up thread %p"), THR_ID(this));
+                  wxT("Waking up thread %p"), THR_ID(this));

 
         // wake up Pause()
         m_semSuspend.Post();
 
         // wake up Pause()
         m_semSuspend.Post();


@@ -1046,7 +1072,7 @@ void wxThreadInternal::Resume()
     else
     {
         wxLogTrace(TRACE_THREADS,
     else
     {
         wxLogTrace(TRACE_THREADS,

-                   _T("Thread %p is not yet really paused"), THR_ID(this));
+                   wxT("Thread %p is not yet really paused"), THR_ID(this));

     }
 
     SetState(STATE_RUNNING);
     }
 
     SetState(STATE_RUNNING);


@@ -1082,7 +1108,7 @@ int wxThread::GetCPUCount()
     // it has 0 size but still can be read from)
     wxLogNull nolog;
 
     // 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


@@ -1090,17 +1116,17 @@ 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"));

         }
     }
 #endif // different ways to get number of CPUs
         }
     }
 #endif // different ways to get number of CPUs


@@ -1117,18 +1143,23 @@ wxThreadIdType wxThread::GetCurrentId()
 
 bool wxThread::SetConcurrency(size_t level)
 {
 
 bool wxThread::SetConcurrency(size_t level)
 {

-#ifdef HAVE_THR_SETCONCURRENCY
+#ifdef HAVE_PTHREAD_SET_CONCURRENCY
+    int rc = pthread_setconcurrency( level );
+#elif defined(HAVE_THR_SETCONCURRENCY)

     int rc = thr_setconcurrency(level);
     int rc = thr_setconcurrency(level);

+#else // !HAVE_THR_SETCONCURRENCY
+    // ok only for the default value
+    int rc = level == 0 ? 0 : -1;
+#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
+

     if ( rc != 0 )
     {
     if ( rc != 0 )
     {

-        wxLogSysError(rc, _T("thr_setconcurrency() failed"));
+        wxLogSysError(rc, _("Failed to set thread concurrency level to %lu"),
+                      static_cast<unsigned long>(level));
+        return false;

     }
 
     }
 

-    return rc == 0;
-#else // !HAVE_THR_SETCONCURRENCY
-    // ok only for the default value
-    return level == 0;
-#endif // HAVE_THR_SETCONCURRENCY/!HAVE_THR_SETCONCURRENCY
+    return true;

 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------


@@ -1214,14 +1245,14 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(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


@@ -1230,7 +1261,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(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
 


@@ -1241,7 +1272,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(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


@@ -1260,7 +1291,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED_STACKSIZE(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 )


@@ -1362,7 +1393,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);
 


@@ -1383,7 +1414,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);
 


@@ -1392,20 +1423,20 @@ wxThreadError wxThread::Resume()
     switch ( state )
     {
         case STATE_PAUSED:
     switch ( state )
     {
         case STATE_PAUSED:

-            wxLogTrace(TRACE_THREADS, _T("Thread %p 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 %p 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;
     }


@@ -1415,23 +1446,23 @@ wxThreadError wxThread::Resume()
 // exiting thread
 // -----------------------------------------------------------------------------
 
 // exiting thread
 // -----------------------------------------------------------------------------
 

-wxThread::ExitCode wxThread::Wait()
+wxThread::ExitCode wxThread::Wait(wxThreadWait WXUNUSED(waitMode))

 {
     wxCHECK_MSG( This() != this, (ExitCode)-1,
 {
     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();
 
     return m_internal->GetExitCode();
 }
 
 
     m_internal->Wait();
 
     return m_internal->GetExitCode();
 }
 

-wxThreadError wxThread::Delete(ExitCode *rc)
+wxThreadError wxThread::Delete(ExitCode *rc, wxThreadWait WXUNUSED(waitMode))

 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
 {
     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;
 


@@ -1443,6 +1474,8 @@ wxThreadError wxThread::Delete(ExitCode *rc)
 
     m_critsect.Leave();
 
 
     m_critsect.Leave();
 

+    OnDelete();
+

     switch ( state )
     {
         case STATE_NEW:
     switch ( state )
     {
         case STATE_NEW:


@@ -1478,13 +1511,20 @@ 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;
 }
 
 wxThreadError wxThread::Kill()
 {
     wxCHECK_MSG( This() != this, wxTHREAD_MISC_ERROR,
     return wxTHREAD_NO_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") );
+
+    OnKill();

 
     switch ( m_internal->GetState() )
     {
 
     switch ( m_internal->GetState() )
     {


@@ -1535,7 +1575,7 @@ wxThreadError wxThread::Kill()
 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 )
     {


@@ -1578,14 +1618,14 @@ void wxThread::Exit(ExitCode status)
     // 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();
 
 
     m_critsect.Enter();
 


@@ -1617,8 +1657,8 @@ wxThread::~wxThread()
     if ( m_internal->GetState() != STATE_EXITED &&
          m_internal->GetState() != STATE_NEW )
     {
     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."),
-                   (long)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();


@@ -1670,6 +1710,11 @@ bool wxThread::IsPaused() const
 // wxThreadModule
 //--------------------------------------------------------------------
 
 // wxThreadModule
 //--------------------------------------------------------------------
 

+#ifdef __WXOSX__
+void wxOSXThreadModuleOnInit();
+void wxOSXThreadModuleOnExit();
+#endif
+

 class wxThreadModule : public wxModule
 {
 public:
 class wxThreadModule : public wxModule
 {
 public:


@@ -1696,8 +1741,12 @@ bool wxThreadModule::OnInit()
 
     gs_mutexAllThreads = new wxMutex();
 
 
     gs_mutexAllThreads = new wxMutex();
 

+#ifdef __WXOSX__
+    wxOSXThreadModuleOnInit();
+#else

     gs_mutexGui = new wxMutex();
     gs_mutexGui->Lock();
     gs_mutexGui = new wxMutex();
     gs_mutexGui->Lock();

+#endif

 
     gs_mutexDeleteThread = new wxMutex();
     gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread);
 
     gs_mutexDeleteThread = new wxMutex();
     gs_condAllDeleted = new wxCondition(*gs_mutexDeleteThread);


@@ -1719,7 +1768,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


@@ -1750,9 +1799,13 @@ void wxThreadModule::OnExit()
 
     delete gs_mutexAllThreads;
 
 
     delete gs_mutexAllThreads;
 

+#ifdef __WXOSX__
+    wxOSXThreadModuleOnExit();
+#else

     // destroy GUI mutex
     gs_mutexGui->Unlock();
     delete gs_mutexGui;
     // destroy GUI mutex
     gs_mutexGui->Unlock();
     delete gs_mutexGui;

+#endif

 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);
 
     // and free TLD slot
     (void)pthread_key_delete(gs_keySelf);


@@ -1771,25 +1824,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 ? _T("") : _T("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 %p 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 threads remain scheduled for deletion."),
+    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 )


@@ -1799,6 +1853,8 @@ static void DeleteThread(wxThread *This)
     }
 }
 
     }
 }
 

+#ifndef __DARWIN__
+

 void wxMutexGuiEnterImpl()
 {
     gs_mutexGui->Lock();
 void wxMutexGuiEnterImpl()
 {
     gs_mutexGui->Lock();


@@ -1809,6 +1865,8 @@ void wxMutexGuiLeaveImpl()
     gs_mutexGui->Unlock();
 }
 
     gs_mutexGui->Unlock();
 }
 

+#endif
+

 // ----------------------------------------------------------------------------
 // include common implementation code
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // include common implementation code
 // ----------------------------------------------------------------------------