src/os2/thread.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/os2/thread.cpp
   3 // Purpose:     wxThread Implementation
   4 // Author:      Original from Wolfram Gloger/Guilhem Lavaux/David Webster
   5 // Modified by: Stefan Neis
   6 // Created:     04/22/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Stefan Neis (2003)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ----------------------------------------------------------------------------
  13 // headers
  14 // ----------------------------------------------------------------------------
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #if wxUSE_THREADS
  20
  21 #include "wx/thread.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/intl.h"
  25     #include "wx/log.h"
  26     #include "wx/app.h"
  27     #include "wx/module.h"
  28 #endif //WX_PRECOMP
  29
  30 #include "wx/apptrait.h"
  31 #include "wx/utils.h"
  32
  33 #include <stdio.h>
  34
  35 #define INCL_DOSSEMAPHORES
  36 #define INCL_DOSPROCESS
  37 #define INCL_DOSMISC
  38 #define INCL_ERRORS
  39 #include <os2.h>
  40 #ifndef __EMX__
  41 #include <bseerr.h>
  42 #endif
  43 // the possible states of the thread ("=>" shows all possible transitions from
  44 // this state)
  45 enum wxThreadState
  46 {
  47     STATE_NEW,          // didn't start execution yet (=> RUNNING)
  48     STATE_RUNNING,      // thread is running (=> PAUSED, CANCELED)
  49     STATE_PAUSED,       // thread is temporarily suspended (=> RUNNING)
  50     STATE_CANCELED,     // thread should terminate a.s.a.p. (=> EXITED)
  51     STATE_EXITED        // thread is terminating
  52 };
  53
  54 // ----------------------------------------------------------------------------
  55 // this module's globals
  56 // ----------------------------------------------------------------------------
  57
  58 // id of the main thread - the one which can call GUI functions without first
  59 // calling wxMutexGuiEnter()
  60 wxThreadIdType                      wxThread::ms_idMainThread = 0;
  61 wxMutex*                            p_wxMainMutex;
  62
  63 // OS2 substitute for Tls pointer the current parent thread object
  64 wxThread*                           m_pThread;    // pointer to the wxWidgets thread object
  65
  66 // if it's false, some secondary thread is holding the GUI lock
  67 static bool gs_bGuiOwnedByMainThread = true;
  68
  69 // critical section which controls access to all GUI functions: any secondary
  70 // thread (i.e. except the main one) must enter this crit section before doing
  71 // any GUI calls
  72 static wxCriticalSection *gs_pCritsectGui = NULL;
  73
  74 // critical section which protects s_nWaitingForGui variable
  75 static wxCriticalSection *gs_pCritsectWaitingForGui = NULL;
  76
  77 // number of threads waiting for GUI in wxMutexGuiEnter()
  78 static size_t gs_nWaitingForGui = 0;
  79
  80 // are we waiting for a thread termination?
  81 static bool gs_bWaitingForThread = false;
  82
  83 // ============================================================================
  84 // OS/2 implementation of thread and related classes
  85 // ============================================================================
  86
  87 // ----------------------------------------------------------------------------
  88 // wxMutex implementation
  89 // ----------------------------------------------------------------------------
  90 class wxMutexInternal
  91 {
  92 public:
  93     wxMutexInternal(wxMutexType mutexType);
  94     ~wxMutexInternal();
  95
  96     bool IsOk() const { return m_vMutex != NULL; }
  97
  98     wxMutexError Lock() { return LockTimeout(SEM_INDEFINITE_WAIT); }
  99     wxMutexError Lock(unsigned long ms) { return LockTimeout(ms); }
 100     wxMutexError TryLock();
 101     wxMutexError Unlock();
 102
 103 private:
 104     wxMutexError LockTimeout(ULONG ulMilliseconds);
 105     HMTX                            m_vMutex;
 106 };
 107
 108 // all mutexes are "pseudo-"recursive under OS2 so we don't use mutexType
 109 // (Calls to DosRequestMutexSem and DosReleaseMutexSem can be nested, but
 110 //  the request count for a semaphore cannot exceed 65535. If an attempt is
 111 //  made to exceed this number, ERROR_TOO_MANY_SEM_REQUESTS is returned.)
 112 wxMutexInternal::wxMutexInternal(wxMutexType WXUNUSED(eMutexType))
 113 {
 114     APIRET ulrc = ::DosCreateMutexSem(NULL, &m_vMutex, 0L, FALSE);
 115     if (ulrc != 0)
 116     {
 117         wxLogSysError(_("Can not create mutex."));
 118         m_vMutex = NULL;
 119     }
 120 }
 121
 122 wxMutexInternal::~wxMutexInternal()
 123 {
 124     if (m_vMutex)
 125     {
 126         if (::DosCloseMutexSem(m_vMutex))
 127         {
 128             wxLogLastError(wxT("DosCloseMutexSem(mutex)"));
 129         }
 130     }
 131 }
 132
 133 wxMutexError wxMutexInternal::TryLock()
 134 {
 135     const wxMutexError rc = LockTimeout( SEM_IMMEDIATE_RETURN );
 136
 137     // we have a special return code for timeout in this case
 138     return rc == wxMUTEX_TIMEOUT ? wxMUTEX_BUSY : rc;
 139 }
 140
 141 wxMutexError wxMutexInternal::LockTimeout(ULONG ulMilliseconds)
 142 {
 143     APIRET                          ulrc;
 144
 145     ulrc = ::DosRequestMutexSem(m_vMutex, ulMilliseconds);
 146
 147     switch (ulrc)
 148     {
 149         case ERROR_TIMEOUT:
 150             return wxMUTEX_TIMEOUT;
 151         case ERROR_TOO_MANY_SEM_REQUESTS:
 152             return wxMUTEX_BUSY;
 153
 154         case NO_ERROR:
 155             // ok
 156             break;
 157
 158         case ERROR_INVALID_HANDLE:
 159         case ERROR_INTERRUPT:
 160         case ERROR_SEM_OWNER_DIED:
 161             wxLogSysError(_("Couldn't acquire a mutex lock"));
 162             return wxMUTEX_MISC_ERROR;
 163
 164         default:
 165             wxFAIL_MSG(wxT("impossible return value in wxMutex::Lock"));
 166             return wxMUTEX_MISC_ERROR;
 167      }
 168     return wxMUTEX_NO_ERROR;
 169 }
 170
 171 wxMutexError wxMutexInternal::Unlock()
 172 {
 173     APIRET                          ulrc;
 174
 175     ulrc = ::DosReleaseMutexSem(m_vMutex);
 176     if (ulrc != 0)
 177     {
 178         wxLogSysError(_("Couldn't release a mutex"));
 179         return wxMUTEX_MISC_ERROR;
 180     }
 181     return wxMUTEX_NO_ERROR;
 182 }
 183
 184 // --------------------------------------------------------------------------
 185 // wxSemaphore
 186 // --------------------------------------------------------------------------
 187
 188 // a trivial wrapper around OS2 event semaphore
 189 class wxSemaphoreInternal
 190 {
 191 public:
 192     wxSemaphoreInternal(int initialcount, int maxcount);
 193     ~wxSemaphoreInternal();
 194
 195     bool IsOk() const { return m_vEvent != NULL; }
 196
 197     wxSemaError Wait() { return WaitTimeout(SEM_INDEFINITE_WAIT); }
 198     wxSemaError TryWait() { return WaitTimeout(SEM_IMMEDIATE_RETURN); }
 199     wxSemaError WaitTimeout(unsigned long milliseconds);
 200
 201     wxSemaError Post();
 202
 203 private:
 204     HEV m_vEvent;
 205     HMTX m_vMutex;
 206     int m_count;
 207     int m_maxcount;
 208 };
 209
 210 wxSemaphoreInternal::wxSemaphoreInternal(int initialcount, int maxcount)
 211 {
 212     APIRET ulrc;
 213     if ( maxcount == 0 )
 214     {
 215         // make it practically infinite
 216         maxcount = INT_MAX;
 217     }
 218
 219     m_count = initialcount;
 220     m_maxcount = maxcount;
 221     ulrc = ::DosCreateMutexSem(NULL, &m_vMutex, 0L, FALSE);
 222     if (ulrc != 0)
 223     {
 224         wxLogLastError(wxT("DosCreateMutexSem()"));
 225         m_vMutex = NULL;
 226         m_vEvent = NULL;
 227         return;
 228     }
 229     ulrc = ::DosCreateEventSem(NULL, &m_vEvent, 0L, FALSE);
 230     if ( ulrc != 0)
 231     {
 232         wxLogLastError(wxT("DosCreateEventSem()"));
 233         ::DosCloseMutexSem(m_vMutex);
 234         m_vMutex = NULL;
 235         m_vEvent = NULL;
 236     }
 237     if (initialcount)
 238         ::DosPostEventSem(m_vEvent);
 239 }
 240
 241 wxSemaphoreInternal::~wxSemaphoreInternal()
 242 {
 243     if ( m_vEvent )
 244     {
 245         if ( ::DosCloseEventSem(m_vEvent) )
 246         {
 247             wxLogLastError(wxT("DosCloseEventSem(semaphore)"));
 248         }
 249         if ( ::DosCloseMutexSem(m_vMutex) )
 250         {
 251             wxLogLastError(wxT("DosCloseMutexSem(semaphore)"));
 252         }
 253         else
 254             m_vEvent = NULL;
 255     }
 256 }
 257
 258 wxSemaError wxSemaphoreInternal::WaitTimeout(unsigned long ulMilliseconds)
 259 {
 260     APIRET ulrc;
 261     do {
 262         ulrc = ::DosWaitEventSem(m_vEvent, ulMilliseconds );
 263         switch ( ulrc )
 264         {
 265             case NO_ERROR:
 266                 break;
 267
 268             case ERROR_TIMEOUT:
 269                 if (ulMilliseconds == SEM_IMMEDIATE_RETURN)
 270                     return wxSEMA_BUSY;
 271                 else
 272                     return wxSEMA_TIMEOUT;
 273
 274             default:
 275                 wxLogLastError(wxT("DosWaitEventSem(semaphore)"));
 276                 return wxSEMA_MISC_ERROR;
 277         }
 278         ulrc = :: DosRequestMutexSem(m_vMutex, ulMilliseconds);
 279         switch ( ulrc )
 280         {
 281             case NO_ERROR:
 282                 // ok
 283                 break;
 284
 285             case ERROR_TIMEOUT:
 286             case ERROR_TOO_MANY_SEM_REQUESTS:
 287                 if (ulMilliseconds == SEM_IMMEDIATE_RETURN)
 288                     return wxSEMA_BUSY;
 289                 else
 290                     return wxSEMA_TIMEOUT;
 291
 292             default:
 293                 wxFAIL_MSG(wxT("DosRequestMutexSem(mutex)"));
 294                 return wxSEMA_MISC_ERROR;
 295         }
 296         bool OK = false;
 297         if (m_count > 0)
 298         {
 299             m_count--;
 300             OK = true;
 301         }
 302         else
 303         {
 304             ULONG ulPostCount;
 305             ::DosResetEventSem(m_vEvent, &ulPostCount);
 306         }
 307         ::DosReleaseMutexSem(m_vMutex);
 308         if (OK)
 309             return wxSEMA_NO_ERROR;
 310     } while (ulMilliseconds == SEM_INDEFINITE_WAIT);
 311
 312     if (ulMilliseconds == SEM_IMMEDIATE_RETURN)
 313         return wxSEMA_BUSY;
 314     return wxSEMA_TIMEOUT;
 315 }
 316
 317 wxSemaError wxSemaphoreInternal::Post()
 318 {
 319     APIRET ulrc;
 320     ulrc = ::DosRequestMutexSem(m_vMutex, SEM_INDEFINITE_WAIT);
 321     if (ulrc != NO_ERROR)
 322         return wxSEMA_MISC_ERROR;
 323     bool OK = false;
 324     if (m_count < m_maxcount)
 325     {
 326         m_count++;
 327         ulrc = ::DosPostEventSem(m_vEvent);
 328         OK = true;
 329     }
 330     ::DosReleaseMutexSem(m_vMutex);
 331     if (!OK)
 332         return wxSEMA_OVERFLOW;
 333     if ( ulrc != NO_ERROR && ulrc != ERROR_ALREADY_POSTED )
 334     {
 335         wxLogLastError(wxT("DosPostEventSem(semaphore)"));
 336
 337         return wxSEMA_MISC_ERROR;
 338     }
 339
 340     return wxSEMA_NO_ERROR;
 341 }
 342
 343 // ----------------------------------------------------------------------------
 344 // wxThread implementation
 345 // ----------------------------------------------------------------------------
 346
 347 // wxThreadInternal class
 348 // ----------------------
 349
 350 class wxThreadInternal
 351 {
 352 public:
 353     inline wxThreadInternal()
 354     {
 355         m_hThread = 0;
 356         m_eState = STATE_NEW;
 357         m_nPriority = WXTHREAD_DEFAULT_PRIORITY;
 358     }
 359
 360     ~wxThreadInternal()
 361     {
 362         m_hThread = 0;
 363     }
 364
 365     // create a new (suspended) thread (for the given thread object)
 366     bool Create( wxThread*    pThread
 367                 ,unsigned int uStackSize
 368                );
 369
 370     // suspend/resume/terminate
 371     bool Suspend();
 372     bool Resume();
 373     inline void Cancel() { m_eState = STATE_CANCELED; }
 374
 375     // thread state
 376     inline void SetState(wxThreadState eState) { m_eState = eState; }
 377     inline wxThreadState GetState() const { return m_eState; }
 378
 379     // thread priority
 380     void                SetPriority(unsigned int nPriority);
 381     inline unsigned int GetPriority() const { return m_nPriority; }
 382
 383     // thread handle and id
 384     inline TID GetHandle() const { return m_hThread; }
 385     TID  GetId() const { return m_hThread; }
 386
 387     // thread function
 388     static void OS2ThreadStart(void* pParam);
 389
 390 private:
 391     // Threads in OS/2 have only an ID, so m_hThread is both it's handle and ID
 392     // PM also has no real Tls mechanism to index pointers by so we'll just
 393     // keep track of the wxWidgets parent object here.
 394     TID                             m_hThread;    // handle and ID of the thread
 395     wxThreadState                   m_eState;     // state, see wxThreadState enum
 396     unsigned int                    m_nPriority;  // thread priority in "wx" units
 397 };
 398
 399 void wxThreadInternal::OS2ThreadStart( void * pParam )
 400 {
 401     DWORD dwRet;
 402     bool bWasCancelled;
 403
 404     wxThread *pThread = (wxThread *)pParam;
 405
 406     // first of all, wait for the thread to be started.
 407     pThread->m_critsect.Enter();
 408     pThread->m_critsect.Leave();
 409     // Now check whether we hadn't been cancelled already and don't
 410     // start the user code at all in this case.
 411     if ( pThread->m_internal->GetState() == STATE_EXITED )
 412     {
 413         dwRet = (DWORD)-1;
 414         bWasCancelled = true;
 415     }
 416     else // do run thread
 417     {
 418         wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
 419         unsigned long ulHab;
 420         if (traits)
 421             traits->InitializeGui(ulHab);
 422         dwRet = (DWORD)pThread->Entry();
 423         if (traits)
 424             traits->TerminateGui(ulHab);
 425
 426         // enter m_critsect before changing the thread state
 427         pThread->m_critsect.Enter();
 428
 429         bWasCancelled = pThread->m_internal->GetState() == STATE_CANCELED;
 430
 431         pThread->m_internal->SetState(STATE_EXITED);
 432         pThread->m_critsect.Leave();
 433     }
 434     pThread->OnExit();
 435
 436     // if the thread was cancelled (from Delete()), then it the handle is still
 437     // needed there
 438     if (pThread->IsDetached() && !bWasCancelled)
 439     {
 440         // auto delete
 441         delete pThread;
 442     }
 443     //else: the joinable threads handle will be closed when Wait() is done
 444     return;
 445 }
 446
 447 void wxThreadInternal::SetPriority(
 448   unsigned int                      nPriority
 449 )
 450 {
 451     // translate wxWidgets priority to the PM one
 452     ULONG                           ulOS2_PriorityClass;
 453     ULONG                           ulOS2_SubPriority;
 454     ULONG                           ulrc;
 455
 456     m_nPriority = nPriority;
 457     if (m_nPriority <= 25)
 458         ulOS2_PriorityClass = PRTYC_IDLETIME;
 459     else if (m_nPriority <= 50)
 460         ulOS2_PriorityClass = PRTYC_REGULAR;
 461     else if (m_nPriority <= 75)
 462         ulOS2_PriorityClass = PRTYC_TIMECRITICAL;
 463     else if (m_nPriority <= 100)
 464         ulOS2_PriorityClass = PRTYC_FOREGROUNDSERVER;
 465     else
 466     {
 467         wxFAIL_MSG(wxT("invalid value of thread priority parameter"));
 468         ulOS2_PriorityClass = PRTYC_REGULAR;
 469     }
 470     ulOS2_SubPriority = (ULONG) (((m_nPriority - 1) % 25 + 1) * 31.0 / 25);
 471     ulrc = ::DosSetPriority( PRTYS_THREAD
 472                             ,ulOS2_PriorityClass
 473                             ,ulOS2_SubPriority
 474                             ,(ULONG)m_hThread
 475                            );
 476     if (ulrc != 0)
 477     {
 478         wxLogSysError(_("Can't set thread priority"));
 479     }
 480 }
 481
 482 bool wxThreadInternal::Create( wxThread* pThread,
 483                                unsigned int uStackSize)
 484 {
 485     int tid;
 486
 487     if (!uStackSize)
 488         uStackSize = 131072;
 489
 490     pThread->m_critsect.Enter();
 491     tid = _beginthread(wxThreadInternal::OS2ThreadStart,
 492                              NULL, uStackSize, pThread);
 493     if(tid == -1)
 494     {
 495         wxLogSysError(_("Can't create thread"));
 496
 497         return false;
 498     }
 499     m_hThread = tid;
 500     if (m_nPriority != WXTHREAD_DEFAULT_PRIORITY)
 501     {
 502         SetPriority(m_nPriority);
 503     }
 504
 505     return true;
 506 }
 507
 508 bool wxThreadInternal::Suspend()
 509 {
 510     ULONG ulrc = ::DosSuspendThread(m_hThread);
 511
 512     if (ulrc != 0)
 513     {
 514         wxLogSysError(_("Can not suspend thread %lu"), m_hThread);
 515         return false;
 516     }
 517     m_eState = STATE_PAUSED;
 518
 519     return true;
 520 }
 521
 522 bool wxThreadInternal::Resume()
 523 {
 524     ULONG ulrc = ::DosResumeThread(m_hThread);
 525
 526     if (ulrc != 0)
 527     {
 528         wxLogSysError(_("Can not resume thread %lu"), m_hThread);
 529         return false;
 530     }
 531
 532     // don't change the state from STATE_EXITED because it's special and means
 533     // we are going to terminate without running any user code - if we did it,
 534     // the codei n Delete() wouldn't work
 535     if ( m_eState != STATE_EXITED )
 536     {
 537         m_eState = STATE_RUNNING;
 538     }
 539
 540     return true;
 541 }
 542
 543 // static functions
 544 // ----------------
 545
 546 wxThread *wxThread::This()
 547 {
 548     wxThread*                       pThread = m_pThread;
 549     return pThread;
 550 }
 551
 552 #ifdef Yield
 553     #undef Yield
 554 #endif
 555
 556 void wxThread::Yield()
 557 {
 558     ::DosSleep(0);
 559 }
 560
 561 int wxThread::GetCPUCount()
 562 {
 563     ULONG CPUCount;
 564     APIRET ulrc;
 565     ulrc = ::DosQuerySysInfo(26, 26, (void *)&CPUCount, sizeof(ULONG));
 566     // QSV_NUMPROCESSORS(26) is typically not defined in header files
 567
 568     if (ulrc != 0)
 569         CPUCount = 1;
 570
 571     return CPUCount;
 572 }
 573
 574 wxThreadIdType wxThread::GetCurrentId()
 575 {
 576     PTIB                            ptib;
 577     PPIB                            ppib;
 578
 579     ::DosGetInfoBlocks(&ptib, &ppib);
 580     return (wxThreadIdType) ptib->tib_ptib2->tib2_ultid;
 581 }
 582
 583 bool wxThread::SetConcurrency(size_t level)
 584 {
 585     wxASSERT_MSG( IsMain(), wxT("should only be called from the main thread") );
 586
 587     // ok only for the default one
 588     if ( level == 0 )
 589         return 0;
 590
 591     // Don't know how to realize this on OS/2.
 592     return level == 1;
 593 }
 594
 595 // ctor and dtor
 596 // -------------
 597
 598 wxThread::wxThread(wxThreadKind kind)
 599 {
 600     m_internal = new wxThreadInternal();
 601
 602     m_isDetached = kind == wxTHREAD_DETACHED;
 603 }
 604
 605 wxThread::~wxThread()
 606 {
 607     delete m_internal;
 608 }
 609
 610 // create/start thread
 611 // -------------------
 612
 613 wxThreadError wxThread::Create(
 614   unsigned int                      uStackSize
 615 )
 616 {
 617     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect);
 618
 619     if ( !m_internal->Create(this, uStackSize) )
 620         return wxTHREAD_NO_RESOURCE;
 621
 622     return wxTHREAD_NO_ERROR;
 623 }
 624
 625 wxThreadError wxThread::Run()
 626 {
 627     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 628
 629     if ( m_internal->GetState() != STATE_NEW )
 630     {
 631         // actually, it may be almost any state at all, not only STATE_RUNNING
 632         return wxTHREAD_RUNNING;
 633     }
 634     return Resume();
 635 }
 636
 637 // suspend/resume thread
 638 // ---------------------
 639
 640 wxThreadError wxThread::Pause()
 641 {
 642     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 643
 644     return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 645 }
 646
 647 wxThreadError wxThread::Resume()
 648 {
 649     if (m_internal->GetState() == STATE_NEW)
 650     {
 651         m_internal->SetState(STATE_RUNNING);
 652         m_critsect.Leave();
 653         return wxTHREAD_NO_ERROR;
 654     }
 655
 656     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 657
 658     return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 659 }
 660
 661 // stopping thread
 662 // ---------------
 663
 664 wxThread::ExitCode wxThread::Wait()
 665 {
 666     // although under Windows we can wait for any thread, it's an error to
 667     // wait for a detached one in wxWin API
 668     wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
 669                  wxT("can't wait for detached thread") );
 670     ExitCode rc = (ExitCode)-1;
 671     (void)Delete(&rc);
 672     return(rc);
 673 }
 674
 675 wxThreadError wxThread::Delete(ExitCode *pRc)
 676 {
 677     ExitCode rc = 0;
 678
 679     // Delete() is always safe to call, so consider all possible states
 680
 681     // we might need to resume the thread, but we might also not need to cancel
 682     // it if it doesn't run yet
 683     bool shouldResume = false,
 684          shouldCancel = true,
 685          isRunning = false;
 686
 687     // check if the thread already started to run
 688     {
 689         wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 690
 691         if ( m_internal->GetState() == STATE_NEW )
 692         {
 693             // WinThreadStart() will see it and terminate immediately, no need
 694             // to cancel the thread - but we still need to resume it to let it
 695             // run
 696             m_internal->SetState(STATE_EXITED);
 697
 698             Resume();   // it knows about STATE_EXITED special case
 699
 700             shouldCancel = false;
 701             isRunning = true;
 702
 703             // shouldResume is correctly set to false here
 704         }
 705         else
 706         {
 707             shouldResume = IsPaused();
 708         }
 709     }
 710
 711     // resume the thread if it is paused
 712     if ( shouldResume )
 713         Resume();
 714
 715     TID hThread = m_internal->GetHandle();
 716
 717     if ( isRunning || IsRunning())
 718     {
 719         if (IsMain())
 720         {
 721             // set flag for wxIsWaitingForThread()
 722             gs_bWaitingForThread = true;
 723         }
 724
 725         // ask the thread to terminate
 726         if ( shouldCancel )
 727         {
 728             wxCriticalSectionLocker lock(m_critsect);
 729
 730             m_internal->Cancel();
 731         }
 732
 733 #if 0
 734         // we can't just wait for the thread to terminate because it might be
 735         // calling some GUI functions and so it will never terminate before we
 736         // process the Windows messages that result from these functions
 737         DWORD result = 0;       // suppress warnings from broken compilers
 738         do
 739         {
 740             if ( IsMain() )
 741             {
 742                 // give the thread we're waiting for chance to do the GUI call
 743                 // it might be in
 744                 if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
 745                 {
 746                     wxMutexGuiLeave();
 747                 }
 748             }
 749
 750             result = ::DosWaitThread(&hThread, DCWW_NOWAIT);
 751             // FIXME: We ought to have a message processing loop here!!
 752
 753             switch ( result )
 754             {
 755                 case ERROR_INTERRUPT:
 756                 case ERROR_THREAD_NOT_TERMINATED:
 757                     break;
 758                 case ERROR_INVALID_THREADID:
 759                 case NO_ERROR:
 760                     // thread we're waiting for just terminated
 761                     // or even does not exist any more.
 762                     result = NO_ERROR;
 763                     break;
 764                 default:
 765                     wxFAIL_MSG(wxT("unexpected result of DosWaitThread"));
 766             }
 767             if ( IsMain() )
 768             {
 769                 // event processing - needed if we are the main thread
 770                 // to give other threads a chance to do remaining GUI
 771                 // processing and terminate cleanly.
 772                 wxTheApp->HandleSockets();
 773                 if (wxTheApp->Pending())
 774                   if ( !wxTheApp->DoMessage() )
 775                   {
 776                       // WM_QUIT received: kill the thread
 777                       Kill();
 778
 779                       return wxTHREAD_KILLED;
 780                   }
 781                   else
 782                     wxUsleep(10);
 783             }
 784             else
 785                 wxUsleep(10);
 786         } while ( result != NO_ERROR );
 787 #else // !wxUSE_GUI
 788         // simply wait for the thread to terminate
 789         //
 790         // OTOH, even console apps create windows (in wxExecute, for WinSock
 791         // &c), so may be use MsgWaitForMultipleObject() too here?
 792         if ( ::DosWaitThread(&hThread, DCWW_WAIT) != NO_ERROR )
 793         {
 794             wxFAIL_MSG(wxT("unexpected result of DosWaitThread"));
 795         }
 796 #endif // wxUSE_GUI/!wxUSE_GUI
 797
 798         if ( IsMain() )
 799         {
 800             gs_bWaitingForThread = false;
 801         }
 802     }
 803
 804 #if 0
 805     // although the thread might be already in the EXITED state it might not
 806     // have terminated yet and so we are not sure that it has actually
 807     // terminated if the "if" above hadn't been taken
 808     do
 809     {
 810         if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
 811         {
 812             wxLogLastError(wxT("GetExitCodeThread"));
 813
 814             rc = (ExitCode)-1;
 815         }
 816     } while ( (DWORD)rc == STILL_ACTIVE );
 817 #endif
 818
 819     if ( IsDetached() )
 820     {
 821         // if the thread exits normally, this is done in WinThreadStart, but in
 822         // this case it would have been too early because
 823         // MsgWaitForMultipleObject() would fail if the thread handle was
 824         // closed while we were waiting on it, so we must do it here
 825         delete this;
 826     }
 827
 828     if ( pRc )
 829         *pRc = rc;
 830
 831     return rc == (ExitCode)-1 ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR;
 832 }
 833
 834 wxThreadError wxThread::Kill()
 835 {
 836     if (!IsRunning())
 837         return wxTHREAD_NOT_RUNNING;
 838
 839     ::DosKillThread(m_internal->GetHandle());
 840     if (IsDetached())
 841     {
 842         delete this;
 843     }
 844     return wxTHREAD_NO_ERROR;
 845 }
 846
 847 void wxThread::Exit(ExitCode WXUNUSED(pStatus))
 848 {
 849     delete this;
 850     _endthread();
 851     wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));
 852 }
 853
 854 void wxThread::SetPriority(
 855   unsigned int                      nPrio
 856 )
 857 {
 858     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 859
 860     m_internal->SetPriority(nPrio);
 861 }
 862
 863 unsigned int wxThread::GetPriority() const
 864 {
 865     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 866
 867     return m_internal->GetPriority();
 868 }
 869
 870 unsigned long wxThread::GetId() const
 871 {
 872     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 873
 874     return (unsigned long)m_internal->GetId();
 875 }
 876
 877 bool wxThread::IsRunning() const
 878 {
 879     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 880
 881     return(m_internal->GetState() == STATE_RUNNING);
 882 }
 883
 884 bool wxThread::IsAlive() const
 885 {
 886     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 887
 888     return (m_internal->GetState() == STATE_RUNNING) ||
 889            (m_internal->GetState() == STATE_PAUSED);
 890 }
 891
 892 bool wxThread::IsPaused() const
 893 {
 894     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 895
 896     return (m_internal->GetState() == STATE_PAUSED);
 897 }
 898
 899 bool wxThread::TestDestroy()
 900 {
 901     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 902
 903     return m_internal->GetState() == STATE_CANCELED;
 904 }
 905
 906 // ----------------------------------------------------------------------------
 907 // Automatic initialization for thread module
 908 // ----------------------------------------------------------------------------
 909
 910 class wxThreadModule : public wxModule
 911 {
 912 public:
 913     virtual bool OnInit();
 914     virtual void OnExit();
 915
 916 private:
 917     DECLARE_DYNAMIC_CLASS(wxThreadModule)
 918 };
 919
 920 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 921
 922 bool wxThreadModule::OnInit()
 923 {
 924     gs_pCritsectWaitingForGui = new wxCriticalSection();
 925
 926     gs_pCritsectGui = new wxCriticalSection();
 927     gs_pCritsectGui->Enter();
 928
 929     wxThread::ms_idMainThread = wxThread::GetCurrentId();
 930
 931     return true;
 932 }
 933
 934 void wxThreadModule::OnExit()
 935 {
 936     if (gs_pCritsectGui)
 937     {
 938         gs_pCritsectGui->Leave();
 939 #if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
 940         delete gs_pCritsectGui;
 941 #endif
 942         gs_pCritsectGui = NULL;
 943     }
 944
 945 #if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
 946     wxDELETE(gs_pCritsectWaitingForGui);
 947 #endif
 948 }
 949
 950 // ----------------------------------------------------------------------------
 951 // Helper functions
 952 // ----------------------------------------------------------------------------
 953
 954 // wake up the main thread if it's in ::GetMessage()
 955 void WXDLLEXPORT wxWakeUpMainThread()
 956 {
 957 #if 0
 958     if ( !::WinPostQueueMsg(wxTheApp->m_hMq, WM_NULL, 0, 0) )
 959     {
 960         // should never happen
 961         wxLogLastError(wxT("WinPostMessage(WM_NULL)"));
 962     }
 963 #endif
 964 }
 965
 966 void wxMutexGuiEnterImpl()
 967 {
 968     // this would dead lock everything...
 969     wxASSERT_MSG( !wxThread::IsMain(),
 970                   wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
 971
 972     // the order in which we enter the critical sections here is crucial!!
 973
 974     // set the flag telling to the main thread that we want to do some GUI
 975     {
 976         wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
 977
 978         gs_nWaitingForGui++;
 979     }
 980
 981     wxWakeUpMainThread();
 982
 983     // now we may block here because the main thread will soon let us in
 984     // (during the next iteration of OnIdle())
 985     gs_pCritsectGui->Enter();
 986 }
 987
 988 void wxMutexGuiLeaveImpl()
 989 {
 990     wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
 991
 992     if ( wxThread::IsMain() )
 993     {
 994         gs_bGuiOwnedByMainThread = false;
 995     }
 996     else
 997     {
 998         // decrement the number of waiters now
 999         wxASSERT_MSG(gs_nWaitingForGui > 0,
1000                       wxT("calling wxMutexGuiLeave() without entering it first?") );
1001
1002         gs_nWaitingForGui--;
1003
1004         wxWakeUpMainThread();
1005     }
1006
1007     gs_pCritsectGui->Leave();
1008 }
1009
1010 void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
1011 {
1012     wxASSERT_MSG( wxThread::IsMain(),
1013                   wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
1014
1015     wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
1016
1017     if (gs_nWaitingForGui == 0)
1018     {
1019         // no threads are waiting for GUI - so we may acquire the lock without
1020         // any danger (but only if we don't already have it)
1021         if (!wxGuiOwnedByMainThread())
1022         {
1023             gs_pCritsectGui->Enter();
1024
1025             gs_bGuiOwnedByMainThread = true;
1026         }
1027         //else: already have it, nothing to do
1028     }
1029     else
1030     {
1031         // some threads are waiting, release the GUI lock if we have it
1032         if (wxGuiOwnedByMainThread())
1033         {
1034             wxMutexGuiLeave();
1035         }
1036         //else: some other worker thread is doing GUI
1037     }
1038 }
1039
1040 bool WXDLLEXPORT wxGuiOwnedByMainThread()
1041 {
1042     return gs_bGuiOwnedByMainThread;
1043 }
1044
1045 bool WXDLLEXPORT wxIsWaitingForThread()
1046 {
1047     return gs_bWaitingForThread;
1048 }
1049
1050 // ----------------------------------------------------------------------------
1051 // include common implementation code
1052 // ----------------------------------------------------------------------------
1053
1054 #include "wx/thrimpl.cpp"
1055
1056 #endif
1057   // wxUSE_THREADS