correct bug with using uninitialized end variable (unused variable warnings are not...

[wxWidgets.git] / src / os2 / thread.cpp

diff --git a/src/os2/thread.cpp b/src/os2/thread.cpp
index 4d9b41694b71b1c2045e989896937f36d2215519..f0b8e6068e537e7b8aee83eaf93c1a0fd604dc0c 100644 (file)
--- a/src/os2/thread.cpp
+++ b/src/os2/thread.cpp
@@ -6,14 +6,9 @@
 // Created:     04/22/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Stefan Neis (2003)
 // Created:     04/22/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Stefan Neis (2003)

-//
-// Licence:     wxWidgets licence
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
-    #pragma implementation "thread.h"
-#endif
-

 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------


@@ -23,15 +18,19 @@
 
 #if wxUSE_THREADS
 
 
 #if wxUSE_THREADS
 

-#include <stdio.h>
+#include "wx/thread.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/app.h"
+    #include "wx/module.h"
+#endif //WX_PRECOMP

 
 

-#include "wx/app.h"

 #include "wx/apptrait.h"
 #include "wx/apptrait.h"

-#include "wx/module.h"
-#include "wx/intl.h"

 #include "wx/utils.h"
 #include "wx/utils.h"

-#include "wx/log.h"
-#include "wx/thread.h"
+
+#include <stdio.h>

 
 #define INCL_DOSSEMAPHORES
 #define INCL_DOSPROCESS
 
 #define INCL_DOSSEMAPHORES
 #define INCL_DOSPROCESS


@@ -64,8 +63,8 @@ wxMutex*                            p_wxMainMutex;
 // OS2 substitute for Tls pointer the current parent thread object
 wxThread*                           m_pThread;    // pointer to the wxWidgets thread object
 
 // OS2 substitute for Tls pointer the current parent thread object
 wxThread*                           m_pThread;    // pointer to the wxWidgets thread object
 

-// if it's FALSE, some secondary thread is holding the GUI lock
-static bool gs_bGuiOwnedByMainThread = TRUE;
+// if it's false, some secondary thread is holding the GUI lock
+static bool gs_bGuiOwnedByMainThread = true;

 
 // critical section which controls access to all GUI functions: any secondary
 // thread (i.e. except the main one) must enter this crit section before doing
 
 // critical section which controls access to all GUI functions: any secondary
 // thread (i.e. except the main one) must enter this crit section before doing


@@ -79,7 +78,7 @@ static wxCriticalSection *gs_pCritsectWaitingForGui = NULL;
 static size_t gs_nWaitingForGui = 0;
 
 // are we waiting for a thread termination?
 static size_t gs_nWaitingForGui = 0;
 
 // are we waiting for a thread termination?

-static bool gs_bWaitingForThread = FALSE;
+static bool gs_bWaitingForThread = false;

 
 // ============================================================================
 // OS/2 implementation of thread and related classes
 
 // ============================================================================
 // OS/2 implementation of thread and related classes


@@ -97,7 +96,8 @@ public:
     bool IsOk() const { return m_vMutex != NULL; }
 
     wxMutexError Lock() { return LockTimeout(SEM_INDEFINITE_WAIT); }
     bool IsOk() const { return m_vMutex != NULL; }
 
     wxMutexError Lock() { return LockTimeout(SEM_INDEFINITE_WAIT); }

-    wxMutexError TryLock() { return LockTimeout(SEM_IMMEDIATE_RETURN); }
+    wxMutexError Lock(unsigned long ms) { return LockTimeout(ms); }
+    wxMutexError TryLock();

     wxMutexError Unlock();
 
 private:
     wxMutexError Unlock();
 
 private:


@@ -109,13 +109,9 @@ private:
 // (Calls to DosRequestMutexSem and DosReleaseMutexSem can be nested, but
 //  the request count for a semaphore cannot exceed 65535. If an attempt is
 //  made to exceed this number, ERROR_TOO_MANY_SEM_REQUESTS is returned.)
 // (Calls to DosRequestMutexSem and DosReleaseMutexSem can be nested, but
 //  the request count for a semaphore cannot exceed 65535. If an attempt is
 //  made to exceed this number, ERROR_TOO_MANY_SEM_REQUESTS is returned.)

-wxMutexInternal::wxMutexInternal(
-  wxMutexType                       WXUNUSED(eMutexType)
-)
+wxMutexInternal::wxMutexInternal(wxMutexType WXUNUSED(eMutexType))

 {
 {

-    APIRET                          ulrc;
-
-    ulrc = ::DosCreateMutexSem(NULL, &m_vMutex, 0L, FALSE);
+    APIRET ulrc = ::DosCreateMutexSem(NULL, &m_vMutex, 0L, FALSE);

     if (ulrc != 0)
     {
         wxLogSysError(_("Can not create mutex."));
     if (ulrc != 0)
     {
         wxLogSysError(_("Can not create mutex."));


@@ -132,6 +128,14 @@ wxMutexInternal::~wxMutexInternal()
     }
 }
 
     }
 }
 

+wxMutexError wxMutexInternal::TryLock()
+{
+    const wxMutexError rc = LockTimeout( SEM_IMMEDIATE_RETURN );
+
+    // we have a special return code for timeout in this case
+    return rc == wxMUTEX_TIMEOUT ? wxMUTEX_BUSY : rc;
+}
+

 wxMutexError wxMutexInternal::LockTimeout(ULONG ulMilliseconds)
 {
     APIRET                          ulrc;
 wxMutexError wxMutexInternal::LockTimeout(ULONG ulMilliseconds)
 {
     APIRET                          ulrc;


@@ -141,6 +145,7 @@ wxMutexError wxMutexInternal::LockTimeout(ULONG ulMilliseconds)
     switch (ulrc)
     {
         case ERROR_TIMEOUT:
     switch (ulrc)
     {
         case ERROR_TIMEOUT:

+            return wxMUTEX_TIMEOUT;

         case ERROR_TOO_MANY_SEM_REQUESTS:
             return wxMUTEX_BUSY;
 
         case ERROR_TOO_MANY_SEM_REQUESTS:
             return wxMUTEX_BUSY;
 


@@ -389,11 +394,9 @@ private:
     unsigned int                    m_nPriority;  // thread priority in "wx" units
 };
 
     unsigned int                    m_nPriority;  // thread priority in "wx" units
 };
 

-void wxThreadInternal::OS2ThreadStart(
-  void * pParam
-)
+void wxThreadInternal::OS2ThreadStart( void * pParam )

 {
 {

-    DWORD                           dwRet;
+    DWORD dwRet;

     bool bWasCancelled;
 
     wxThread *pThread = (wxThread *)pParam;
     bool bWasCancelled;
 
     wxThread *pThread = (wxThread *)pParam;


@@ -406,7 +409,7 @@ void wxThreadInternal::OS2ThreadStart(
     if ( pThread->m_internal->GetState() == STATE_EXITED )
     {
         dwRet = (DWORD)-1;
     if ( pThread->m_internal->GetState() == STATE_EXITED )
     {
         dwRet = (DWORD)-1;

-        bWasCancelled = TRUE;
+        bWasCancelled = true;

     }
     else // do run thread
     {
     }
     else // do run thread
     {


@@ -474,15 +477,14 @@ void wxThreadInternal::SetPriority(
     }
 }
 
     }
 }
 

-bool wxThreadInternal::Create(
-  wxThread*                         pThread
-, unsigned int                      uStackSize
-)
+bool wxThreadInternal::Create( wxThread* pThread,
+                               unsigned int uStackSize)

 {
 {

-    int                          tid;
+    int tid;

 
     if (!uStackSize)
 
     if (!uStackSize)

-      uStackSize = 131072;
+        uStackSize = 131072;
+

     pThread->m_critsect.Enter();
     tid = _beginthread(wxThreadInternal::OS2ThreadStart,
                              NULL, uStackSize, pThread);
     pThread->m_critsect.Enter();
     tid = _beginthread(wxThreadInternal::OS2ThreadStart,
                              NULL, uStackSize, pThread);


@@ -490,7 +492,7 @@ bool wxThreadInternal::Create(
     {
         wxLogSysError(_("Can't create thread"));
 
     {
         wxLogSysError(_("Can't create thread"));
 

-        return FALSE;
+        return false;

     }
     m_hThread = tid;
     if (m_nPriority != WXTHREAD_DEFAULT_PRIORITY)
     }
     m_hThread = tid;
     if (m_nPriority != WXTHREAD_DEFAULT_PRIORITY)


@@ -498,30 +500,31 @@ bool wxThreadInternal::Create(
         SetPriority(m_nPriority);
     }
 
         SetPriority(m_nPriority);
     }
 

-    return(TRUE);
+    return true;

 }
 
 bool wxThreadInternal::Suspend()
 {
 }
 
 bool wxThreadInternal::Suspend()
 {

-    ULONG                           ulrc = ::DosSuspendThread(m_hThread);
+    ULONG ulrc = ::DosSuspendThread(m_hThread);

 
     if (ulrc != 0)
     {
         wxLogSysError(_("Can not suspend thread %lu"), m_hThread);
 
     if (ulrc != 0)
     {
         wxLogSysError(_("Can not suspend thread %lu"), m_hThread);

-        return FALSE;
+        return false;

     }
     m_eState = STATE_PAUSED;
     }
     m_eState = STATE_PAUSED;

-    return TRUE;
+
+    return true;

 }
 
 bool wxThreadInternal::Resume()
 {
 }
 
 bool wxThreadInternal::Resume()
 {

-    ULONG                           ulrc = ::DosResumeThread(m_hThread);
+    ULONG ulrc = ::DosResumeThread(m_hThread);

 
     if (ulrc != 0)
     {
         wxLogSysError(_("Can not resume thread %lu"), m_hThread);
 
     if (ulrc != 0)
     {
         wxLogSysError(_("Can not resume thread %lu"), m_hThread);

-        return FALSE;
+        return false;

     }
 
     // don't change the state from STATE_EXITED because it's special and means
     }
 
     // don't change the state from STATE_EXITED because it's special and means


@@ -532,7 +535,7 @@ bool wxThreadInternal::Resume()
         m_eState = STATE_RUNNING;
     }
 
         m_eState = STATE_RUNNING;
     }
 

-    return TRUE;
+    return true;

 }
 
 // static functions
 }
 
 // static functions


@@ -546,14 +549,15 @@ wxThread *wxThread::This()
 
 bool wxThread::IsMain()
 {
 
 bool wxThread::IsMain()
 {

-    PTIB                            ptib;
-    PPIB                            ppib;
+    PTIB ptib;
+    PPIB ppib;

 
     ::DosGetInfoBlocks(&ptib, &ppib);
 
     if (ptib->tib_ptib2->tib2_ultid == s_ulIdMainThread)
 
     ::DosGetInfoBlocks(&ptib, &ppib);
 
     if (ptib->tib_ptib2->tib2_ultid == s_ulIdMainThread)

-        return TRUE;
-    return FALSE;
+        return true;
+
+    return false;

 }
 
 #ifdef Yield
 }
 
 #ifdef Yield


@@ -565,13 +569,6 @@ void wxThread::Yield()
     ::DosSleep(0);
 }
 
     ::DosSleep(0);
 }
 

-void wxThread::Sleep(
-  unsigned long                     ulMilliseconds
-)
-{
-    ::DosSleep(ulMilliseconds);
-}
-

 int wxThread::GetCPUCount()
 {
     ULONG CPUCount;
 int wxThread::GetCPUCount()
 {
     ULONG CPUCount;


@@ -694,9 +691,9 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
 
     // we might need to resume the thread, but we might also not need to cancel
     // it if it doesn't run yet
 
     // we might need to resume the thread, but we might also not need to cancel
     // it if it doesn't run yet

-    bool shouldResume = FALSE,
-         shouldCancel = TRUE,
-         isRunning = FALSE;
+    bool shouldResume = false,
+         shouldCancel = true,
+         isRunning = false;

 
     // check if the thread already started to run
     {
 
     // check if the thread already started to run
     {


@@ -711,10 +708,10 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
 
             Resume();   // it knows about STATE_EXITED special case
 
 
             Resume();   // it knows about STATE_EXITED special case
 

-            shouldCancel = FALSE;
-            isRunning = TRUE;
+            shouldCancel = false;
+            isRunning = true;

 
 

-            // shouldResume is correctly set to FALSE here
+            // shouldResume is correctly set to false here

         }
         else
         {
         }
         else
         {


@@ -726,14 +723,14 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
     if ( shouldResume )
         Resume();
 
     if ( shouldResume )
         Resume();
 

-    TID                             hThread = m_internal->GetHandle();
+    TID hThread = m_internal->GetHandle();

 
     if ( isRunning || IsRunning())
     {
         if (IsMain())
         {
             // set flag for wxIsWaitingForThread()
 
     if ( isRunning || IsRunning())
     {
         if (IsMain())
         {
             // set flag for wxIsWaitingForThread()

-            gs_bWaitingForThread = TRUE;
+            gs_bWaitingForThread = true;

         }
 
         // ask the thread to terminate
         }
 
         // ask the thread to terminate


@@ -811,7 +808,7 @@ wxThreadError wxThread::Delete(ExitCode *pRc)
 
         if ( IsMain() )
         {
 
         if ( IsMain() )
         {

-            gs_bWaitingForThread = FALSE;
+            gs_bWaitingForThread = false;

         }
     }
 
         }
     }
 


@@ -858,9 +855,7 @@ wxThreadError wxThread::Kill()
     return wxTHREAD_NO_ERROR;
 }
 
     return wxTHREAD_NO_ERROR;
 }
 

-void wxThread::Exit(
-  ExitCode                          pStatus
-)
+void wxThread::Exit(ExitCode WXUNUSED(pStatus))

 {
     delete this;
     _endthread();
 {
     delete this;
     _endthread();


@@ -942,13 +937,13 @@ bool wxThreadModule::OnInit()
     gs_pCritsectGui = new wxCriticalSection();
     gs_pCritsectGui->Enter();
 
     gs_pCritsectGui = new wxCriticalSection();
     gs_pCritsectGui->Enter();
 

-    PTIB                            ptib;
-    PPIB                            ppib;
+    PTIB ptib;
+    PPIB ppib;

 
     ::DosGetInfoBlocks(&ptib, &ppib);
 
     s_ulIdMainThread = ptib->tib_ptib2->tib2_ultid;
 
     ::DosGetInfoBlocks(&ptib, &ppib);
 
     s_ulIdMainThread = ptib->tib_ptib2->tib2_ultid;

-    return TRUE;
+    return true;

 }
 
 void wxThreadModule::OnExit()
 }
 
 void wxThreadModule::OnExit()


@@ -983,7 +978,7 @@ void WXDLLEXPORT wxWakeUpMainThread()
 #endif
 }
 
 #endif
 }
 

-void WXDLLEXPORT wxMutexGuiEnter()
+void wxMutexGuiEnterImpl()

 {
     // this would dead lock everything...
     wxASSERT_MSG( !wxThread::IsMain(),
 {
     // this would dead lock everything...
     wxASSERT_MSG( !wxThread::IsMain(),


@@ -1005,13 +1000,13 @@ void WXDLLEXPORT wxMutexGuiEnter()
     gs_pCritsectGui->Enter();
 }
 
     gs_pCritsectGui->Enter();
 }
 

-void WXDLLEXPORT wxMutexGuiLeave()
+void wxMutexGuiLeaveImpl()

 {
     wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
 
     if ( wxThread::IsMain() )
     {
 {
     wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
 
     if ( wxThread::IsMain() )
     {

-        gs_bGuiOwnedByMainThread = FALSE;
+        gs_bGuiOwnedByMainThread = false;

     }
     else
     {
     }
     else
     {


@@ -1042,7 +1037,7 @@ void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
         {
             gs_pCritsectGui->Enter();
 
         {
             gs_pCritsectGui->Enter();
 

-            gs_bGuiOwnedByMainThread = TRUE;
+            gs_bGuiOwnedByMainThread = true;

         }
         //else: already have it, nothing to do
     }
         }
         //else: already have it, nothing to do
     }