1. bug fixes in wxCaret

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

diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index 8548b1801428a2d0873f70f77702859385a05292..edd373cdc467c86356acf5a00ba3c8628b69f153 100644 (file)
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -47,10 +47,6 @@
     #include <sched.h>
 #endif
 
     #include <sched.h>
 #endif
 

-#ifdef __WXGTK12__
-#include "gtk/gtk.h"
-#endif
-

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


@@ -85,10 +81,8 @@ static pthread_t gs_tidMain;
 // 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;
 

-#ifndef __WXGTK12__

 // this mutex must be acquired before any call to a GUI function
 static wxMutex *gs_mutexGui;
 // this mutex must be acquired before any call to a GUI function
 static wxMutex *gs_mutexGui;

-#endif

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -305,20 +299,19 @@ void *wxThreadInternal::PthreadStart(void *ptr)
     }
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
     // Install the cleanup handler.
     }
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
     // Install the cleanup handler.

-    pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);
+//    pthread_cleanup_push(wxThreadInternal::PthreadCleanup, ptr);

 #endif
 
     // wait for the condition to be signaled from Run()
     // mutex state: currently locked by the thread which created us
     pthread->m_cond.Wait(pthread->m_mutex);
 #endif
 
     // wait for the condition to be signaled from Run()
     // mutex state: currently locked by the thread which created us
     pthread->m_cond.Wait(pthread->m_mutex);

-

     // mutex state: locked again on exit of Wait()
 
     // call the main entry
     status = thread->Entry();
 
 #if HAVE_THREAD_CLEANUP_FUNCTIONS
     // mutex state: locked again on exit of Wait()
 
     // call the main entry
     status = thread->Entry();
 
 #if HAVE_THREAD_CLEANUP_FUNCTIONS

-    pthread_cleanup_pop(FALSE);
+//    pthread_cleanup_pop(FALSE);

 #endif
 
     // terminate the thread
 #endif
 
     // terminate the thread


@@ -360,6 +353,9 @@ wxThreadInternal::wxThreadInternal()
     // unlocked in the very end
     m_mutex.Lock();
  
     // unlocked in the very end
     m_mutex.Lock();
  

+    // this mutex is used by wxThreadInternal::Wait() and by
+    // wxThreadInternal::SignalExit(). We don't use m_mutex because of a
+    // possible deadlock in either Wait() or SignalExit().

     m_end_mutex.Lock();
 
     // this mutex is used in Pause()/Resume() and is also locked all the time
     m_end_mutex.Lock();
 
     // this mutex is used in Pause()/Resume() and is also locked all the time


@@ -374,6 +370,8 @@ wxThreadInternal::~wxThreadInternal()
 
     // note that m_mutex will be unlocked by the thread which waits for our
     // termination
 
     // note that m_mutex will be unlocked by the thread which waits for our
     // termination

+
+    // m_end_mutex can be unlocked here.

     m_end_mutex.Unlock();
 }
 
     m_end_mutex.Unlock();
 }
 


@@ -406,16 +404,17 @@ void wxThreadInternal::Wait()
     if ( wxThread::IsMain() )
         wxMutexGuiLeave();
 
     if ( wxThread::IsMain() )
         wxMutexGuiLeave();
 

-    printf("Entering wait ...\n");

     // entering Wait() releases the mutex thus allowing SignalExit() to acquire
     // it and to signal us its termination
     m_cond.Wait(m_end_mutex);
     // entering Wait() releases the mutex thus allowing SignalExit() to acquire
     // it and to signal us its termination
     m_cond.Wait(m_end_mutex);

-    printf("Exiting wait ...\n");

 
     // mutex is still in the locked state - relocked on exit from Wait(), so
     // unlock it - we don't need it any more, the thread has already terminated
     m_end_mutex.Unlock();
 
 
     // mutex is still in the locked state - relocked on exit from Wait(), so
     // unlock it - we don't need it any more, the thread has already terminated
     m_end_mutex.Unlock();
 

+    // After that, we wait for the real end of the other thread.
+    pthread_join(GetId(), NULL);
+

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


@@ -423,21 +422,18 @@ void wxThreadInternal::Wait()
 
 void wxThreadInternal::SignalExit()
 {
 
 void wxThreadInternal::SignalExit()
 {

-    printf("SignalExit\n");

     // GL: Unlock mutexSuspend here.
     m_mutexSuspend.Unlock();
 
     // as mutex is currently locked, this will block until some other thread
     // (normally the same which created this one) unlocks it by entering Wait()
     m_end_mutex.Lock();
     // GL: Unlock mutexSuspend here.
     m_mutexSuspend.Unlock();
 
     // as mutex is currently locked, this will block until some other thread
     // (normally the same which created this one) unlocks it by entering Wait()
     m_end_mutex.Lock();

-    printf("Mutex acquired\n");

 
     // wake up all the threads waiting for our termination
     m_cond.Broadcast();
 
     // after this call mutex will be finally unlocked
     m_end_mutex.Unlock();
 
     // wake up all the threads waiting for our termination
     m_cond.Broadcast();
 
     // after this call mutex will be finally unlocked
     m_end_mutex.Unlock();

-    printf("Mutex unacquired\n");

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


@@ -664,11 +660,12 @@ wxThread::ExitCode wxThread::Delete()
 {
     m_critsect.Enter();
     wxThreadState state = p_internal->GetState();
 {
     m_critsect.Enter();
     wxThreadState state = p_internal->GetState();

-    m_critsect.Leave();

 
     // ask the thread to stop
     p_internal->SetCancelFlag();
 
 
     // ask the thread to stop
     p_internal->SetCancelFlag();
 

+    m_critsect.Leave();
+

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


@@ -716,20 +713,16 @@ void wxThread::Exit(void *status)
 {
     // first call user-level clean up code
     OnExit();
 {
     // first call user-level clean up code
     OnExit();

-    printf(" ... OnExit()\n");

 
     // next wake up the threads waiting for us (OTOH, this function won't return
     // until someone waited for us!)
     p_internal->SignalExit();
 
     // next wake up the threads waiting for us (OTOH, this function won't return
     // until someone waited for us!)
     p_internal->SignalExit();

-    printf(" ... SignalExit()\n");

 
     p_internal->SetState(STATE_EXITED);
 
     p_internal->SetState(STATE_EXITED);

-    printf(" ... SetState()\n");

 
     // delete both C++ thread object and terminate the OS thread object
     // GL: This is very ugly and buggy ...
 //    delete this;
 
     // delete both C++ thread object and terminate the OS thread object
     // GL: This is very ugly and buggy ...
 //    delete this;

-    printf(" ... Exit\n");

     pthread_exit(status);
 }
 
     pthread_exit(status);
 }
 


@@ -819,15 +812,11 @@ bool wxThreadModule::OnInit()
         return FALSE;
     }
 
         return FALSE;
     }
 

-#ifndef __WXGTK12__

     gs_mutexGui = new wxMutex();
     gs_mutexGui = new wxMutex();

-#endif

 
     gs_tidMain = pthread_self();
 
 
     gs_tidMain = pthread_self();
 

-#ifndef __WXGTK12__

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

-#endif

 
     return TRUE;
 }
 
     return TRUE;
 }


@@ -846,12 +835,10 @@ void wxThreadModule::OnExit()
         gs_allThreads[n]->Delete();
     }
 
         gs_allThreads[n]->Delete();
     }
 

-#ifndef __WXGTK12__

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


@@ -863,20 +850,12 @@ void wxThreadModule::OnExit()
 
 void wxMutexGuiEnter()
 {
 
 void wxMutexGuiEnter()
 {

-#ifdef __WXGTK12__
-  gdk_threads_enter();
-#else

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

-#endif

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

-#ifdef __WXGTK12__
-  gdk_threads_leave();
-#else

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

-#endif

 }
 
 #endif
 }
 
 #endif