compilation warning about signed/unsigned comparison fixed

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

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index f47319d5e34363772336f5246c0b1f5dc35ee1d0..5e8ba134236f1b5b4b89bf2642aff45488963a77 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -7,7 +7,7 @@
 // RCS-ID:      $Id$
 // Copyright:   (c) Wolfram Gloger (1996, 1997)
 //                  Guilhem Lavaux (1998)
 // RCS-ID:      $Id$
 // Copyright:   (c) Wolfram Gloger (1996, 1997)
 //                  Guilhem Lavaux (1998)

-//                  Vadim Zeitlin (1999)
+//                  Vadim Zeitlin (1999-2002)

 //                  Robert Roebling (1999)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 //                  Robert Roebling (1999)
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////


@@ -40,7 +40,6 @@
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>
 #include <pthread.h>
 #include <errno.h>
 #include <time.h>

-

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


@@ -73,6 +72,15 @@ static const wxThread::ExitCode EXITCODE_CANCELLED = (wxThread::ExitCode)-1;
 // our trace mask
 #define TRACE_THREADS   _T("thread")
 
 // our trace mask
 #define TRACE_THREADS   _T("thread")
 

+// ----------------------------------------------------------------------------
+// pseudo template types
+// ----------------------------------------------------------------------------
+
+WX_DECLARE_LIST(pthread_mutex_t, wxMutexList);
+
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxMutexList);
+

 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------


@@ -147,23 +155,29 @@ static wxCondition *gs_condAllDeleted = (wxCondition *)NULL;
 #endif // wxUSE_GUI
 
 // ============================================================================
 #endif // wxUSE_GUI
 
 // ============================================================================

-// implementation
+// wxMutex implementation

 // ============================================================================
 
 // ============================================================================
 

-//--------------------------------------------------------------------
-// wxMutex (Posix implementation)
-//--------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// wxMutexInternal
+// ----------------------------------------------------------------------------

 
 class wxMutexInternal
 {
 public:
 
 class wxMutexInternal
 {
 public:

+    wxMutexInternal();
+    ~wxMutexInternal();
+
+    wxMutexError Lock();
+    wxMutexError TryLock();
+    wxMutexError Unlock();
+
+private:

     pthread_mutex_t m_mutex;
 };
 
     pthread_mutex_t m_mutex;
 };
 

-wxMutex::wxMutex()
+wxMutexInternal::wxMutexInternal()

 {
 {

-    m_internal = new wxMutexInternal;
-

     // support recursive locks like Win32, i.e. a thread can lock a mutex which
     // it had itself already locked
     //
     // support recursive locks like Win32, i.e. a thread can lock a mutex which
     // it had itself already locked
     //


@@ -174,64 +188,147 @@ wxMutex::wxMutex()
     pthread_mutexattr_init(&attr);
     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 
     pthread_mutexattr_init(&attr);
     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 

-    pthread_mutex_init(&(m_internal->m_mutex), &attr);
+    pthread_mutex_init(&m_mutex, &attr);

 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
     // we can use this only as initializer so we have to assign it first to a
     // temp var - assigning directly to m_mutex wouldn't even compile
     pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
 #elif defined(HAVE_PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
     // we can use this only as initializer so we have to assign it first to a
     // temp var - assigning directly to m_mutex wouldn't even compile
     pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;

-    m_internal->m_mutex = mutex;
+    m_mutex = mutex;

 #else // no recursive mutexes
 #else // no recursive mutexes

-    pthread_mutex_init(&(m_internal->m_mutex), NULL);
+    pthread_mutex_init(&m_mutex, NULL);
+
+    // used by TryLock() below
+    #define NO_RECURSIVE_MUTEXES

 #endif // HAVE_PTHREAD_MUTEXATTR_T/...
 #endif // HAVE_PTHREAD_MUTEXATTR_T/...

+}
+
+wxMutexInternal::~wxMutexInternal()
+{
+    pthread_mutex_destroy(&m_mutex);
+}
+
+wxMutexError wxMutexInternal::Lock()
+{
+    int err = pthread_mutex_lock(&m_mutex);
+    switch ( err )
+    {
+        case EDEADLK:
+            wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+            return wxMUTEX_DEAD_LOCK;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_lock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to lock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+wxMutexError wxMutexInternal::TryLock()
+{
+    int err = pthread_mutex_trylock(&m_mutex);
+    switch ( err )
+    {
+        case EBUSY:
+            return wxMUTEX_BUSY;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_trylock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to try to lock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+wxMutexError wxMutexInternal::Unlock()
+{
+    int err = pthread_mutex_unlock(&m_mutex);
+    switch ( err )
+    {
+        case EPERM:
+            // we don't own the mutex
+            return wxMUTEX_UNLOCKED;
+
+        default:
+            wxFAIL_MSG( _T("unexpected pthread_mutex_unlock() return") );
+            // fall through
+
+        case EINVAL:
+            wxLogDebug(_T("Failed to unlock the mutex."));
+            return wxMUTEX_MISC_ERROR;
+
+        case 0:
+            return wxMUTEX_NO_ERROR;
+    }
+}
+
+// ----------------------------------------------------------------------------
+// wxMutex
+// ----------------------------------------------------------------------------
+
+// TODO: this is completely generic, move it to common code?
+
+wxMutex::wxMutex()
+{
+    m_internal = new wxMutexInternal;

 
     m_locked = 0;
 }
 
 wxMutex::~wxMutex()
 {
 
     m_locked = 0;
 }
 
 wxMutex::~wxMutex()
 {

-    if (m_locked > 0)
+    if ( m_locked > 0 )

         wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
 
         wxLogDebug(wxT("Freeing a locked mutex (%d locks)"), m_locked);
 

-    pthread_mutex_destroy( &(m_internal->m_mutex) );

     delete m_internal;
 }
 
 wxMutexError wxMutex::Lock()
 {
     delete m_internal;
 }
 
 wxMutexError wxMutex::Lock()
 {

-    int err = pthread_mutex_lock( &(m_internal->m_mutex) );
-    if (err == EDEADLK)
-    {
-        wxLogDebug(wxT("Locking this mutex would lead to deadlock!"));
+    wxMutexError err = m_internal->Lock();

 
 

-        return wxMUTEX_DEAD_LOCK;
+    if ( !err )
+    {
+        m_locked++;

     }
 
     }
 

-    m_locked++;
-
-    return wxMUTEX_NO_ERROR;
+    return err;

 }
 
 wxMutexError wxMutex::TryLock()
 {
 }
 
 wxMutexError wxMutex::TryLock()
 {

-    if (m_locked)
+    if ( m_locked )

     {
     {

-        return wxMUTEX_BUSY;
+#ifdef NO_RECURSIVE_MUTEXES
+        return wxMUTEX_DEAD_LOCK;
+#else // have recursive mutexes on this platform
+        // we will succeed in locking it when we have it already locked
+        return wxMUTEX_NO_ERROR;
+#endif // recursive/non-recursive mutexes

     }
 
     }
 

-    int err = pthread_mutex_trylock( &(m_internal->m_mutex) );
-    switch (err)
+    wxMutexError err = m_internal->TryLock();
+    if ( !err )

     {
     {

-        case EBUSY: return wxMUTEX_BUSY;
+        m_locked++;

     }
 
     }
 

-    m_locked++;
-
-    return wxMUTEX_NO_ERROR;
+    return err;

 }
 
 wxMutexError wxMutex::Unlock()
 {
 }
 
 wxMutexError wxMutex::Unlock()
 {

-    if (m_locked > 0)
+    if ( m_locked > 0 )

     {
         m_locked--;
     }
     {
         m_locked--;
     }


@@ -242,51 +339,51 @@ wxMutexError wxMutex::Unlock()
         return wxMUTEX_UNLOCKED;
     }
 
         return wxMUTEX_UNLOCKED;
     }
 

-    pthread_mutex_unlock( &(m_internal->m_mutex) );
-
-    return wxMUTEX_NO_ERROR;
+    return m_internal->Unlock();

 }
 
 }
 

-//--------------------------------------------------------------------
-// wxCondition (Posix implementation)
-//--------------------------------------------------------------------
+// ============================================================================
+// wxCondition implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxConditionInternal
+// ----------------------------------------------------------------------------

 
 // The native POSIX condition variables are dumb: if the condition is signaled
 // before another thread starts to wait on it, the signal is lost and so this
 // other thread will be never woken up. It's much more convenient to us to
 // remember that the condition was signaled and to return from Wait()
 // immediately in this case (this is more like Win32 automatic event objects)
 
 // The native POSIX condition variables are dumb: if the condition is signaled
 // before another thread starts to wait on it, the signal is lost and so this
 // other thread will be never woken up. It's much more convenient to us to
 // remember that the condition was signaled and to return from Wait()
 // immediately in this case (this is more like Win32 automatic event objects)

-

 class wxConditionInternal
 {
 public:
     wxConditionInternal();
     ~wxConditionInternal();
 
 class wxConditionInternal
 {
 public:
     wxConditionInternal();
     ~wxConditionInternal();
 

-    void Wait();
-    bool WaitWithTimeout(const timespec* ts);
-
-    void Signal();
-    void Broadcast();
+    // wait with the given timeout or indefinitely if NULL
+    bool Wait(const timespec* ts = NULL);

 
 

-    void WaitDone();
-    bool ShouldWait();
-    bool HasWaiters();
+    void Signal(bool all = FALSE);

 
 private:
 
 private:

-    bool m_wasSignaled;             // TRUE if condition was signaled while
-                                    // nobody waited for it
-    size_t m_nWaiters;              // TRUE if someone already waits for us
+    // the number of Signal() calls we "missed", i.e. which were done while
+    // there were no threads to wait for them
+    size_t m_nQueuedSignals;

 
 

-    pthread_mutex_t m_mutexProtect; // protects access to vars above
+    // counts all pending waiters
+    size_t m_nWaiters;

 
 

-    pthread_mutex_t m_mutex;        // the mutex used with the condition
-    pthread_cond_t m_condition;     // the condition itself
+    // the condition itself
+    pthread_cond_t m_condition;
+
+    // the mutex used with the conditon: it also protects the counters above
+    pthread_mutex_t m_mutex;

 };
 
 wxConditionInternal::wxConditionInternal()
 {
 };
 
 wxConditionInternal::wxConditionInternal()
 {

-    m_wasSignaled = FALSE;
+    m_nQueuedSignals =

     m_nWaiters = 0;
 
     if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )
     m_nWaiters = 0;
 
     if ( pthread_cond_init(&m_condition, (pthread_condattr_t *)NULL) != 0 )


@@ -295,19 +392,11 @@ wxConditionInternal::wxConditionInternal()
         wxFAIL_MSG( _T("pthread_cond_init() failed") );
     }
 
         wxFAIL_MSG( _T("pthread_cond_init() failed") );
     }
 

-    if ( pthread_mutex_init(&m_mutex, (pthread_mutexattr_t *)NULL) != 0 ||
-         pthread_mutex_init(&m_mutexProtect, NULL) != 0 )
+    if ( pthread_mutex_init(&m_mutex, NULL) != 0 )

     {
         // neither this
         wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
     }
     {
         // neither this
         wxFAIL_MSG( _T("wxCondition: pthread_mutex_init() failed") );
     }

-
-    // initially the mutex is locked, so no thread can Signal() or Broadcast()
-    // until another thread starts to Wait()
-    if ( pthread_mutex_lock(&m_mutex) != 0 )
-    {
-        wxFAIL_MSG( _T("wxCondition: pthread_mutex_lock() failed") );
-    }

 }
 
 wxConditionInternal::~wxConditionInternal()
 }
 
 wxConditionInternal::~wxConditionInternal()


@@ -318,138 +407,105 @@ wxConditionInternal::~wxConditionInternal()
                       "threads are probably still waiting on it?)"));
     }
 
                       "threads are probably still waiting on it?)"));
     }
 

-    if ( pthread_mutex_unlock( &m_mutex ) != 0 )
-    {
-        wxLogDebug(_T("wxCondition: failed to unlock the mutex"));
-    }
-
-    if ( pthread_mutex_destroy( &m_mutex ) != 0 ||
-         pthread_mutex_destroy( &m_mutexProtect ) != 0 )
+    if ( pthread_mutex_destroy( &m_mutex ) != 0 ) 

     {
         wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
     }
 }
 
     {
         wxLogDebug(_T("Failed to destroy mutex (it is probably locked)"));
     }
 }
 

-void wxConditionInternal::WaitDone()
+bool wxConditionInternal::Wait(const timespec* ts)

 {
 {

-    MutexLock lock(m_mutexProtect);
-
-    m_wasSignaled = FALSE;
-    m_nWaiters--;
-}
+    MutexLock lock(m_mutex);

 
 

-bool wxConditionInternal::ShouldWait()
-{
-    MutexLock lock(m_mutexProtect);
-
-    if ( m_wasSignaled )
+    if ( m_nQueuedSignals )

     {
     {

-        // the condition was signaled before we started to wait, reset the
-        // flag and return
-        m_wasSignaled = FALSE;
+        m_nQueuedSignals--;

 
 

-        return FALSE;
+        wxLogTrace(TRACE_THREADS,
+                   _T("wxCondition(%08x)::Wait(): Has been signaled before"),
+                   this);
+
+        return TRUE;

     }
 
     }
 

-    // we start to wait for it
+    // there are no queued signals, so start really waiting

     m_nWaiters++;
 
     m_nWaiters++;
 

-    return TRUE;
-}
-
-bool wxConditionInternal::HasWaiters()
-{
-    MutexLock lock(m_mutexProtect);
+    // calling wait function below unlocks the mutex and Signal() or
+    // Broadcast() will be able to continue to run now if they were
+    // blocking for it in the loop locking all mutexes)
+    wxLogTrace(TRACE_THREADS,
+               _T("wxCondition(%08x)::Wait(): starting to wait"), this);

 
 

-    if ( m_nWaiters )
+    int err = ts ? pthread_cond_timedwait(&m_condition, &m_mutex, ts)
+                 : pthread_cond_wait(&m_condition, &m_mutex);
+    switch ( err )

     {
     {

-        // someone waits for us, signal the condition normally
-        return TRUE;
-    }
+        case 0:
+            // condition was signaled
+            wxLogTrace(TRACE_THREADS,
+                       _T("wxCondition(%08x)::Wait(): ok"), this);
+            break;

 
 

-    // nobody waits for us and may be never will - so just remember that the
-    // condition was signaled and don't do anything else
-    m_wasSignaled = TRUE;
+        default:
+            wxLogDebug(_T("unexpected pthread_cond_[timed]wait() return"));
+            // fall through

 
 

-    return FALSE;
-}
+        case ETIMEDOUT:
+        case EINTR:
+            // The condition has not been signaled, so we have to
+            // decrement the counter manually
+            --m_nWaiters;

 
 

-void wxConditionInternal::Wait()
-{
-    if ( ShouldWait() )
-    {
-        if ( pthread_cond_wait( &m_condition, &m_mutex ) != 0 )
-        {
-            // not supposed to ever happen
-            wxFAIL_MSG( _T("pthread_cond_wait() failed") );
-        }
+            // wait interrupted or timeout elapsed
+            wxLogTrace(TRACE_THREADS,
+                       _T("wxCondition(%08x)::Wait(): timeout/intr"), this);

     }
 
     }
 

-    WaitDone();
+    return err == 0;

 }
 
 }
 

-bool wxConditionInternal::WaitWithTimeout(const timespec* ts)
+void wxConditionInternal::Signal(bool all)

 {
 {

-    bool ok;
+    // make sure that only one Signal() or Broadcast() is in progress
+    MutexLock lock(m_mutex);

 
 

-    if ( ShouldWait() )
+    // Are there any waiters?
+    if ( m_nWaiters == 0 )

     {
     {

-        switch ( pthread_cond_timedwait( &m_condition, &m_mutex, ts ) )
-        {
-            case 0:
-                // condition signaled
-                ok = TRUE;
-                break;
+        // No, there are not, so don't signal but keep in mind for the next
+        // Wait()
+        m_nQueuedSignals++;

 
 

-            default:
-                wxLogDebug(_T("pthread_cond_timedwait() failed"));
+        return;
+    }

 
 

-                // fall through
+    // now we can finally signal it
+    wxLogTrace(TRACE_THREADS, _T("wxCondition(%08x)::Signal(): preparing to %s"),
+               this, all ? _T("broadcast") : _T("signal"));

 
 

-            case ETIMEDOUT:
-            case EINTR:
-                // wait interrupted or timeout elapsed
-                ok = FALSE;
-        }
+    int err = all ? pthread_cond_broadcast(&m_condition)
+                  : pthread_cond_signal(&m_condition);
+
+    if ( all )
+    {
+        m_nWaiters = 0;

     }
     else
     {
     }
     else
     {

-        // the condition had already been signaled before
-        ok = TRUE;
+        --m_nWaiters;

     }
 
     }
 

-    WaitDone();
-
-    return ok;
-}
-
-void wxConditionInternal::Signal()
-{
-    if ( HasWaiters() )
+    if ( err )

     {
     {

-        MutexLock lock(m_mutex);
-
-        if ( pthread_cond_signal( &m_condition ) != 0 )
-        {
-            // shouldn't ever happen
-            wxFAIL_MSG(_T("pthread_cond_signal() failed"));
-        }
+        // shouldn't ever happen
+        wxFAIL_MSG(_T("pthread_cond_{broadcast|signal}() failed"));

     }
 }
 
     }
 }
 

-void wxConditionInternal::Broadcast()
-{
-    if ( HasWaiters() )
-    {
-        MutexLock lock(m_mutex);
-
-        if ( pthread_cond_broadcast( &m_condition ) != 0 )
-        {
-            // shouldn't ever happen
-            wxFAIL_MSG(_T("pthread_cond_broadcast() failed"));
-        }
-    }
-}
+// ----------------------------------------------------------------------------
+// wxCondition
+// ----------------------------------------------------------------------------

 
 wxCondition::wxCondition()
 {
 
 wxCondition::wxCondition()
 {


@@ -463,7 +519,7 @@ wxCondition::~wxCondition()
 
 void wxCondition::Wait()
 {
 
 void wxCondition::Wait()
 {

-    m_internal->Wait();
+    (void)m_internal->Wait();

 }
 
 bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
 }
 
 bool wxCondition::Wait(unsigned long sec, unsigned long nsec)


@@ -473,7 +529,7 @@ bool wxCondition::Wait(unsigned long sec, unsigned long nsec)
     tspec.tv_sec = time(0L) + sec;  // FIXME is time(0) correct here?
     tspec.tv_nsec = nsec;
 
     tspec.tv_sec = time(0L) + sec;  // FIXME is time(0) correct here?
     tspec.tv_nsec = nsec;
 

-    return m_internal->WaitWithTimeout(&tspec);
+    return m_internal->Wait(&tspec);

 }
 
 void wxCondition::Signal()
 }
 
 void wxCondition::Signal()


@@ -483,12 +539,12 @@ void wxCondition::Signal()
 
 void wxCondition::Broadcast()
 {
 
 void wxCondition::Broadcast()
 {

-    m_internal->Broadcast();
+    m_internal->Signal(TRUE /* all */);

 }
 
 }
 

-//--------------------------------------------------------------------
-// wxThread (Posix implementation)
-//--------------------------------------------------------------------
+// ============================================================================
+// wxThread implementation
+// ============================================================================

 
 // the thread callback functions must have the C linkage
 extern "C"
 
 // the thread callback functions must have the C linkage
 extern "C"


@@ -503,6 +559,10 @@ void *wxPthreadStart(void *ptr);
 
 } // extern "C"
 
 
 } // extern "C"
 

+// ----------------------------------------------------------------------------
+// wxThreadInternal
+// ----------------------------------------------------------------------------
+

 class wxThreadInternal
 {
 public:
 class wxThreadInternal
 {
 public:


@@ -615,6 +675,8 @@ void *wxThreadInternal::PthreadStart(wxThread *thread)
 {
     wxThreadInternal *pthread = thread->m_internal;
 
 {
     wxThreadInternal *pthread = thread->m_internal;
 

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

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


@@ -763,13 +825,10 @@ void wxThreadInternal::Wait()
         wxMutexGuiLeave();
 
     bool isDetached = m_isDetached;
         wxMutexGuiLeave();
 
     bool isDetached = m_isDetached;

-#ifdef __VMS
-   long long id = (long long)GetId();
-#else
-   long id = (long)GetId();
-#endif
-   wxLogTrace(TRACE_THREADS, _T("Starting to wait for thread %ld to exit."),
-               id);
+    wxThreadIdType id = (wxThreadIdType) GetId();
+
+    wxLogTrace(TRACE_THREADS,
+               _T("Starting to wait for thread %ld to exit."), id);

 
     // wait until the thread terminates (we're blocking in _another_ thread,
     // of course)
 
     // wait until the thread terminates (we're blocking in _another_ thread,
     // of course)


@@ -928,6 +987,19 @@ int wxThread::GetCPUCount()
     return -1;
 }
 
     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()
+{
+    return (unsigned long long)pthread_self();
+#else
+unsigned long wxThread::GetCurrentId()
+{
+    return (unsigned long)pthread_self();
+#endif
+}
+

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


@@ -986,7 +1058,7 @@ wxThreadError wxThread::Create(unsigned int WXUNUSED(stackSize))
 #define sched_get_priority_min(_pol_) \
      (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
 #endif
 #define sched_get_priority_min(_pol_) \
      (_pol_ == SCHED_OTHER ? PRI_FG_MIN_NP : PRI_FIFO_MIN)
 #endif

-   
+

     int max_prio = sched_get_priority_max(policy),
         min_prio = sched_get_priority_min(policy),
         prio = m_internal->GetPriority();
     int max_prio = sched_get_priority_max(policy),
         min_prio = sched_get_priority_min(policy),
         prio = m_internal->GetPriority();


@@ -1129,15 +1201,9 @@ unsigned int wxThread::GetPriority() const
     return m_internal->GetPriority();
 }
 
     return m_internal->GetPriority();
 }
 

-#ifdef __VMS
-unsigned long long wxThread::GetId() const
-{
-    return (unsigned long long)m_internal->GetId();
-#else
-unsigned long wxThread::GetId() const
+wxThreadIdType wxThread::GetId() const

 {
 {

-    return (unsigned long)m_internal->GetId();
-#endif
+    return (wxThreadIdType) m_internal->GetId();

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