check that the version of __sync_sub_and_fetch that returns a value is supported...

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

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index d87748e03fb2e14b38047b1126b8b58a49cace0f..0384805c1ad09e9f98354e583ef09a43b0d2ba5f 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -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


@@ -21,28 +21,31 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "thread.h"
-#endif
-
-#include "wx/defs.h"
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"

 
 #if wxUSE_THREADS
 
 #include "wx/thread.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
+#ifdef HAVE_SCHED_H

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


@@ -58,6 +61,12 @@
     #include <sys/resource.h>
 #endif
 
     #include <sys/resource.h>
 #endif
 

+#ifdef __VMS
+    #define THR_ID(thr) ((long long)(thr)->GetId())
+#else
+    #define THR_ID(thr) ((long)(thr)->GetId())
+#endif
+

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


@@ -92,7 +101,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
 


@@ -105,8 +114,11 @@ 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;
+static pthread_t gs_tidMain = (pthread_t)-1;

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


@@ -122,10 +134,10 @@ static wxMutex *gs_mutexDeleteThread = (wxMutex *)NULL;
 // gs_nThreadsBeingDeleted will have been deleted
 static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
 
 // gs_nThreadsBeingDeleted will have been deleted
 static wxCondition *gs_condAllDeleted = (wxCondition *)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


@@ -153,11 +165,16 @@ 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;


@@ -166,6 +183,13 @@ private:
     friend class wxConditionInternal;
 };
 
     friend class wxConditionInternal;
 };
 

+#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);
+#endif
+

 wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
 {
     int err;
 wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
 {
     int err;


@@ -210,7 +234,7 @@ wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
     m_isOk = err == 0;
     if ( !m_isOk )
     {
     m_isOk = err == 0;
     if ( !m_isOk )
     {

-        wxLogApiError("pthread_mutex_init()", err);
+        wxLogApiError( wxT("pthread_mutex_init()"), err);

     }
 }
 
     }
 }
 


@@ -221,14 +245,68 @@ wxMutexInternal::~wxMutexInternal()
         int err = pthread_mutex_destroy(&m_mutex);
         if ( err != 0 )
         {
         int err = pthread_mutex_destroy(&m_mutex);
         if ( err != 0 )
         {

-            wxLogApiError("pthread_mutex_destroy()", err);
+            wxLogApiError( wxT("pthread_mutex_destroy()"), err);

         }
     }
 }
 
 wxMutexError wxMutexInternal::Lock()
 {
         }
     }
 }
 
 wxMutexError wxMutexInternal::Lock()
 {

-    int err = pthread_mutex_lock(&m_mutex);
+    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)
+{

     switch ( err )
     {
         case EDEADLK:
     switch ( err )
     {
         case EDEADLK:


@@ -238,19 +316,23 @@ wxMutexError wxMutexInternal::Lock()
             return wxMUTEX_DEAD_LOCK;
 
         case EINVAL:
             return wxMUTEX_DEAD_LOCK;
 
         case EINVAL:

-            wxLogDebug(_T("pthread_mutex_lock(): mutex not initialized."));
+            wxLogDebug(_T("pthread_mutex_[timed]lock(): mutex not initialized"));

             break;
 
             break;
 

+        case ETIMEDOUT:
+            return wxMUTEX_TIMEOUT;
+

         case 0:
             return wxMUTEX_NO_ERROR;
 
         default:
         case 0:
             return wxMUTEX_NO_ERROR;
 
         default:

-            wxLogApiError(_T("pthread_mutex_lock()"), err);
+            wxLogApiError(_T("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);


@@ -470,7 +552,7 @@ wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
     {
         wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") );
 
     {
         wxFAIL_MSG( _T("wxSemaphore: invalid initial or maximal count") );
 

-        m_isOk = FALSE;
+        m_isOk = false;

     }
     else
     {
     }
     else
     {


@@ -488,15 +570,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",
+                   _T("Thread %ld waiting for semaphore to become signalled"),

                    wxThread::GetCurrentId());
 
         if ( m_cond.Wait() != wxCOND_NO_ERROR )
             return wxSEMA_MISC_ERROR;
 
         wxLogTrace(TRACE_SEMA,
                    wxThread::GetCurrentId());
 
         if ( m_cond.Wait() != wxCOND_NO_ERROR )
             return wxSEMA_MISC_ERROR;
 
         wxLogTrace(TRACE_SEMA,

-                   "Thread %ld finished waiting for semaphore, count = %u",
-                   wxThread::GetCurrentId(), m_count);
+                   _T("Thread %ld finished waiting for semaphore, count = %lu"),
+                   wxThread::GetCurrentId(), (unsigned long)m_count);

     }
 
     m_count--;
     }
 
     m_count--;


@@ -532,8 +614,17 @@ wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long milliseconds)
             return wxSEMA_TIMEOUT;
         }
 
             return wxSEMA_TIMEOUT;
         }
 

-        if ( m_cond.Wait(remainingTime) != wxCOND_NO_ERROR )
-            return wxSEMA_MISC_ERROR;
+        switch ( m_cond.WaitTimeout(remainingTime) )
+        {
+            case wxCOND_TIMEOUT:
+                return wxSEMA_TIMEOUT;
+
+            default:
+                return wxSEMA_MISC_ERROR;
+
+            case wxCOND_NO_ERROR:
+                ;
+        }

     }
 
     m_count--;
     }
 
     m_count--;


@@ -553,9 +644,9 @@ wxSemaError wxSemaphoreInternal::Post()
     m_count++;
 
     wxLogTrace(TRACE_SEMA,
     m_count++;
 
     wxLogTrace(TRACE_SEMA,

-               "Thread %ld about to signal semaphore, count = %u",
-               wxThread::GetCurrentId(), m_count);
-    
+               _T("Thread %ld about to signal semaphore, count = %lu"),
+               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;
 }


@@ -568,10 +659,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);
 


@@ -620,7 +711,7 @@ public:
         };
 
         wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."),
         };
 
         wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."),

-                   GetId(), stateNames[m_state], stateNames[state]);
+                   (long)GetId(), stateNames[m_state], stateNames[state]);

 #endif // __WXDEBUG__
 
         m_state = state;
 #endif // __WXDEBUG__
 
         m_state = state;


@@ -629,7 +720,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; }


@@ -644,19 +735,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;


@@ -696,7 +787,7 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
 {
     wxThreadInternal *pthread = thread->m_internal;
 
 {
     wxThreadInternal *pthread = thread->m_internal;
 

-    wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId());
+    wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), THR_ID(pthread));

 
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work
 
     // associate the thread pointer with the newly created thread so that
     // wxThread::This() will work


@@ -712,11 +803,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();


@@ -733,13 +824,19 @@ 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()."),
-                   pthread->GetId());
+        wxLogTrace(TRACE_THREADS,
+                   _T("Thread %ld about to enter its Entry()."),
+                   THR_ID(pthread));

 
 

-        pthread->m_exitcode = thread->Entry();
+        wxTRY
+        {
+            pthread->m_exitcode = thread->Entry();

 
 

-        wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."),
-                   pthread->GetId(), (unsigned long)pthread->m_exitcode);
+            wxLogTrace(TRACE_THREADS,
+                       _T("Thread %ld Entry() returned %lu."),
+                       THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode));
+        }
+        wxCATCH_ALL( wxTheApp->OnUnhandledException(); )

 
         {
             wxCriticalSectionLocker lock(thread->m_critsect);
 
         {
             wxCriticalSectionLocker lock(thread->m_critsect);


@@ -751,13 +848,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 )
     {


@@ -777,7 +883,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)


@@ -787,6 +893,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 )


@@ -800,7 +907,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


@@ -809,17 +916,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()


@@ -849,7 +956,8 @@ void wxThreadInternal::Wait()
         wxMutexGuiLeave();
 
     wxLogTrace(TRACE_THREADS,
         wxMutexGuiLeave();
 
     wxLogTrace(TRACE_THREADS,

-               _T("Starting to wait for thread %ld to exit."), GetId());
+               _T("Starting to wait for thread %ld 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


@@ -862,17 +970,16 @@ void wxThreadInternal::Wait()
             //       we're cancelled inside pthread_join(), things will almost
             //       certainly break - but if we disable the cancellation, we
             //       might deadlock
             //       we're cancelled inside pthread_join(), things will almost
             //       certainly break - but if we disable the cancellation, we
             //       might deadlock

-            if ( pthread_join((pthread_t)GetId(), &m_exitcode) != 0 )
+            if ( pthread_join(GetId(), &m_exitcode) != 0 )

             {
                 // this is a serious problem, so use wxLogError and not
                 // wxLogDebug: it is possible to bring the system to its knees
                 // by creating too many threads and not joining them quite
                 // easily
             {
                 // this is a serious problem, so use wxLogError and not
                 // 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;

         }
     }
 
         }
     }
 


@@ -888,7 +995,8 @@ 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().") );
 

-    wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId());
+   wxLogTrace(TRACE_THREADS,
+              _T("Thread %ld 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();


@@ -903,18 +1011,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() )
     {

-        wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
+       wxLogTrace(TRACE_THREADS,
+                  _T("Waking up thread %ld"), 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"),
-                   GetId());
+        wxLogTrace(TRACE_THREADS,
+                   _T("Thread %ld is not yet really paused"), THR_ID(this));

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


@@ -931,7 +1040,7 @@ wxThread *wxThread::This()
 
 bool wxThread::IsMain()
 {
 
 bool wxThread::IsMain()
 {

-    return (bool)pthread_equal(pthread_self(), gs_tidMain);
+    return (bool)pthread_equal(pthread_self(), gs_tidMain) || gs_tidMain == (pthread_t)-1;

 }
 
 void wxThread::Yield()
 }
 
 void wxThread::Yield()


@@ -943,12 +1052,19 @@ void wxThread::Yield()
 
 void wxThread::Sleep(unsigned long milliseconds)
 {
 
 void wxThread::Sleep(unsigned long milliseconds)
 {

-    wxUsleep(milliseconds);
+    wxMilliSleep(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;


@@ -960,8 +1076,8 @@ int wxThread::GetCPUCount()
         wxString s;
         if ( file.ReadAll(&s) )
         {
         wxString s;
         if ( file.ReadAll(&s) )
         {

-            // (ab)use Replace() to find the number of "processor" strings
-            size_t count = s.Replace(_T("processor"), _T(""));
+            // (ab)use Replace() to find the number of "processor: num" strings
+            size_t count = s.Replace(_T("processor\t:"), _T(""));

             if ( count > 0 )
             {
                 return count;
             if ( count > 0 )
             {
                 return count;


@@ -974,32 +1090,30 @@ int wxThread::GetCPUCount()
             wxLogDebug(_T("failed to read /proc/cpuinfo"));
         }
     }
             wxLogDebug(_T("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;
 }
 

+// VMS is a 64 bit system and threads have 64 bit pointers.
+// FIXME: also needed for other systems????

 #ifdef __VMS
 #ifdef __VMS

-  // VMS is a 64 bit system and threads have 64 bit pointers.
-  // ??? also needed for other systems????

 unsigned long long wxThread::GetCurrentId()
 {
     return (unsigned long long)pthread_self();
 unsigned long long wxThread::GetCurrentId()
 {
     return (unsigned long long)pthread_self();

-#else
+}
+
+#else // !__VMS
+

 unsigned long wxThread::GetCurrentId()
 {
     return (unsigned long)pthread_self();
 unsigned long wxThread::GetCurrentId()
 {
     return (unsigned long)pthread_self();

-#endif

 }
 
 }
 

+#endif // __VMS/!__VMS
+
+

 bool wxThread::SetConcurrency(size_t level)
 {
 #ifdef HAVE_THR_SETCONCURRENCY
 bool wxThread::SetConcurrency(size_t level)
 {
 #ifdef HAVE_THR_SETCONCURRENCY


@@ -1023,14 +1137,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 )
     {


@@ -1042,6 +1166,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 )


@@ -1176,42 +1305,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__
             {


@@ -1392,25 +1500,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
             {


@@ -1418,14 +1527,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") );
+                  _T("wxThread::Exit() can only be called in the context of the same thread") );

 
     if ( m_isDetached )
     {
 
     if ( m_isDetached )
     {


@@ -1439,7 +1548,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


@@ -1452,6 +1565,13 @@ 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)
     }
 
     // terminate the thread (pthread_exit() never returns)


@@ -1464,14 +1584,13 @@ void wxThread::Exit(ExitCode status)
 bool wxThread::TestDestroy()
 {
     wxASSERT_MSG( This() == this,
 bool wxThread::TestDestroy()
 {
     wxASSERT_MSG( This() == this,

-                  _T("wxThread::TestDestroy() can only be called in the "
-                     "context of the same thread") );
+                  _T("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


@@ -1498,8 +1617,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."), GetId());
+        wxLogDebug(_T("The thread %ld is being destroyed although it is still running! The application may crash."),
+                   (long)GetId());

     }
 
     m_critsect.Leave();
     }
 
     m_critsect.Leave();


@@ -1508,7 +1627,11 @@ wxThread::~wxThread()
     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);
+    }

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


@@ -1530,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;

     }
 }
 
     }
 }
 


@@ -1565,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();
 
     }
 
     gs_tidMain = pthread_self();
 

-#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()


@@ -1598,21 +1719,28 @@ void wxThreadModule::OnExit()
 
         if ( nThreadsBeingDeleted > 0 )
         {
 
         if ( nThreadsBeingDeleted > 0 )
         {

-            wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"),
-                       nThreadsBeingDeleted);
+            wxLogTrace(TRACE_THREADS,
+                       _T("Waiting for %lu threads to disappear"),
+                       (unsigned long)nThreadsBeingDeleted);

 
             // have to wait until all of them disappear
             gs_condAllDeleted->Wait();
         }
     }
 
 
             // have to wait until all of them disappear
             gs_condAllDeleted->Wait();
         }
     }
 

-    // terminate any threads left
-    size_t count = gs_allThreads.GetCount();
-    if ( count != 0u )
+    size_t count;
+

     {
     {

-        wxLogDebug(wxT("%u threads were not terminated by the application."),
-                   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++ )
     {


@@ -1621,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);


@@ -1645,9 +1772,9 @@ static void ScheduleThreadForDeletion()
 
     gs_nThreadsBeingDeleted++;
 
 
     gs_nThreadsBeingDeleted++;
 

-    wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"),
-               gs_nThreadsBeingDeleted,
-               gs_nThreadsBeingDeleted == 1 ? "" : "s");
+    wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
+               (unsigned long)gs_nThreadsBeingDeleted,
+               gs_nThreadsBeingDeleted == 1 ? _T("") : _T("s"));

 }
 
 static void DeleteThread(wxThread *This)
 }
 
 static void DeleteThread(wxThread *This)


@@ -1663,8 +1790,8 @@ static void DeleteThread(wxThread *This)
     wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
                  _T("no threads scheduled for deletion, yet we delete one?") );
 
     wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
                  _T("no threads scheduled for deletion, yet we delete one?") );
 

-    wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
-               gs_nThreadsBeingDeleted - 1);
+    wxLogTrace(TRACE_THREADS, _T("%lu scheduled for deletion threads left."),
+               (unsigned long)gs_nThreadsBeingDeleted - 1);

 
     if ( !--gs_nThreadsBeingDeleted )
     {
 
     if ( !--gs_nThreadsBeingDeleted )
     {


@@ -1675,16 +1802,12 @@ static void DeleteThread(wxThread *This)
 
 void wxMutexGuiEnter()
 {
 
 void wxMutexGuiEnter()
 {

-#if wxUSE_GUI

     gs_mutexGui->Lock();
     gs_mutexGui->Lock();

-#endif // wxUSE_GUI

 }
 
 void wxMutexGuiLeave()
 {
 }
 
 void wxMutexGuiLeave()
 {

-#if wxUSE_GUI

     gs_mutexGui->Unlock();
     gs_mutexGui->Unlock();

-#endif // wxUSE_GUI

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


@@ -1694,4 +1817,3 @@ void wxMutexGuiLeave()
 #include "wx/thrimpl.cpp"
 
 #endif // wxUSE_THREADS
 #include "wx/thrimpl.cpp"
 
 #endif // wxUSE_THREADS

-