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(_("Cannot 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 = wxPRIORITY_DEFAULT;
 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 != wxPRIORITY_DEFAULT)
 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(_("Cannot 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(_("Cannot 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     // Create the thread if it wasn't created yet with an explicit
 630     // Create() call:
 631     if ( !m_internal->GetHandle() )
 632     {
 633         if ( !m_internal->Create(this, 0) )
 634             return wxTHREAD_NO_RESOURCE;
 635     }
 636
 637     if ( m_internal->GetState() != STATE_NEW )
 638     {
 639         // actually, it may be almost any state at all, not only STATE_RUNNING
 640         return wxTHREAD_RUNNING;
 641     }
 642     return Resume();
 643 }
 644
 645 // suspend/resume thread
 646 // ---------------------
 647
 648 wxThreadError wxThread::Pause()
 649 {
 650     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 651
 652     return m_internal->Suspend() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 653 }
 654
 655 wxThreadError wxThread::Resume()
 656 {
 657     if (m_internal->GetState() == STATE_NEW)
 658     {
 659         m_internal->SetState(STATE_RUNNING);
 660         m_critsect.Leave();
 661         return wxTHREAD_NO_ERROR;
 662     }
 663
 664     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 665
 666     return m_internal->Resume() ? wxTHREAD_NO_ERROR : wxTHREAD_MISC_ERROR;
 667 }
 668
 669 // stopping thread
 670 // ---------------
 671
 672 wxThread::ExitCode wxThread::Wait(wxThreadWait waitMode)
 673 {
 674     // although under Windows we can wait for any thread, it's an error to
 675     // wait for a detached one in wxWin API
 676     wxCHECK_MSG( !IsDetached(), (ExitCode)-1,
 677                  wxT("can't wait for detached thread") );
 678     ExitCode rc = (ExitCode)-1;
 679     (void)Delete(&rc, waitMode);
 680     return(rc);
 681 }
 682
 683 wxThreadError wxThread::Delete(ExitCode *pRc, wxThreadWait WXUNUSED(waitMode))
 684 {
 685     ExitCode rc = 0;
 686
 687     // Delete() is always safe to call, so consider all possible states
 688
 689     // we might need to resume the thread, but we might also not need to cancel
 690     // it if it doesn't run yet
 691     bool shouldResume = false,
 692          shouldCancel = true,
 693          isRunning = false;
 694
 695     // check if the thread already started to run
 696     {
 697         wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 698
 699         if ( m_internal->GetState() == STATE_NEW )
 700         {
 701             // WinThreadStart() will see it and terminate immediately, no need
 702             // to cancel the thread - but we still need to resume it to let it
 703             // run
 704             m_internal->SetState(STATE_EXITED);
 705
 706             Resume();   // it knows about STATE_EXITED special case
 707
 708             shouldCancel = false;
 709             isRunning = true;
 710
 711             // shouldResume is correctly set to false here
 712         }
 713         else
 714         {
 715             shouldResume = IsPaused();
 716         }
 717     }
 718
 719     // resume the thread if it is paused
 720     if ( shouldResume )
 721         Resume();
 722
 723     TID hThread = m_internal->GetHandle();
 724
 725     if ( isRunning || IsRunning())
 726     {
 727         if (IsMain())
 728         {
 729             // set flag for wxIsWaitingForThread()
 730             gs_bWaitingForThread = true;
 731         }
 732
 733         // ask the thread to terminate
 734         if ( shouldCancel )
 735         {
 736             wxCriticalSectionLocker lock(m_critsect);
 737
 738             m_internal->Cancel();
 739         }
 740
 741 #if 0
 742         // we can't just wait for the thread to terminate because it might be
 743         // calling some GUI functions and so it will never terminate before we
 744         // process the Windows messages that result from these functions
 745         DWORD result = 0;       // suppress warnings from broken compilers
 746         do
 747         {
 748             if ( IsMain() )
 749             {
 750                 // give the thread we're waiting for chance to do the GUI call
 751                 // it might be in
 752                 if ( (gs_nWaitingForGui > 0) && wxGuiOwnedByMainThread() )
 753                 {
 754                     wxMutexGuiLeave();
 755                 }
 756             }
 757
 758             result = ::DosWaitThread(&hThread, DCWW_NOWAIT);
 759             // FIXME: We ought to have a message processing loop here!!
 760
 761             switch ( result )
 762             {
 763                 case ERROR_INTERRUPT:
 764                 case ERROR_THREAD_NOT_TERMINATED:
 765                     break;
 766                 case ERROR_INVALID_THREADID:
 767                 case NO_ERROR:
 768                     // thread we're waiting for just terminated
 769                     // or even does not exist any more.
 770                     result = NO_ERROR;
 771                     break;
 772                 default:
 773                     wxFAIL_MSG(wxT("unexpected result of DosWaitThread"));
 774             }
 775             if ( IsMain() )
 776             {
 777                 // event processing - needed if we are the main thread
 778                 // to give other threads a chance to do remaining GUI
 779                 // processing and terminate cleanly.
 780                 wxTheApp->HandleSockets();
 781                 if (wxTheApp->Pending())
 782                   if ( !wxTheApp->DoMessage() )
 783                   {
 784                       // WM_QUIT received: kill the thread
 785                       Kill();
 786
 787                       return wxTHREAD_KILLED;
 788                   }
 789                   else
 790                     wxUsleep(10);
 791             }
 792             else
 793                 wxUsleep(10);
 794         } while ( result != NO_ERROR );
 795 #else // !wxUSE_GUI
 796         // simply wait for the thread to terminate
 797         //
 798         // OTOH, even console apps create windows (in wxExecute, for WinSock
 799         // &c), so may be use MsgWaitForMultipleObject() too here?
 800         if ( ::DosWaitThread(&hThread, DCWW_WAIT) != NO_ERROR )
 801         {
 802             wxFAIL_MSG(wxT("unexpected result of DosWaitThread"));
 803         }
 804 #endif // wxUSE_GUI/!wxUSE_GUI
 805
 806         if ( IsMain() )
 807         {
 808             gs_bWaitingForThread = false;
 809         }
 810     }
 811
 812 #if 0
 813     // although the thread might be already in the EXITED state it might not
 814     // have terminated yet and so we are not sure that it has actually
 815     // terminated if the "if" above hadn't been taken
 816     do
 817     {
 818         if ( !::GetExitCodeThread(hThread, (LPDWORD)&rc) )
 819         {
 820             wxLogLastError(wxT("GetExitCodeThread"));
 821
 822             rc = (ExitCode)-1;
 823         }
 824     } while ( (DWORD)rc == STILL_ACTIVE );
 825 #endif
 826
 827     if ( IsDetached() )
 828     {
 829         // if the thread exits normally, this is done in WinThreadStart, but in
 830         // this case it would have been too early because
 831         // MsgWaitForMultipleObject() would fail if the thread handle was
 832         // closed while we were waiting on it, so we must do it here
 833         delete this;
 834     }
 835
 836     if ( pRc )
 837         *pRc = rc;
 838
 839     return rc == (ExitCode)-1 ? wxTHREAD_MISC_ERROR : wxTHREAD_NO_ERROR;
 840 }
 841
 842 wxThreadError wxThread::Kill()
 843 {
 844     if (!IsRunning())
 845         return wxTHREAD_NOT_RUNNING;
 846
 847     ::DosKillThread(m_internal->GetHandle());
 848     if (IsDetached())
 849     {
 850         delete this;
 851     }
 852     return wxTHREAD_NO_ERROR;
 853 }
 854
 855 void wxThread::Exit(ExitCode WXUNUSED(pStatus))
 856 {
 857     delete this;
 858     _endthread();
 859     wxFAIL_MSG(wxT("Couldn't return from DosExit()!"));
 860 }
 861
 862 void wxThread::SetPriority(
 863   unsigned int                      nPrio
 864 )
 865 {
 866     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 867
 868     m_internal->SetPriority(nPrio);
 869 }
 870
 871 unsigned int wxThread::GetPriority() const
 872 {
 873     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 874
 875     return m_internal->GetPriority();
 876 }
 877
 878 unsigned long wxThread::GetId() const
 879 {
 880     wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
 881
 882     return (unsigned long)m_internal->GetId();
 883 }
 884
 885 bool wxThread::IsRunning() const
 886 {
 887     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 888
 889     return(m_internal->GetState() == STATE_RUNNING);
 890 }
 891
 892 bool wxThread::IsAlive() const
 893 {
 894     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 895
 896     return (m_internal->GetState() == STATE_RUNNING) ||
 897            (m_internal->GetState() == STATE_PAUSED);
 898 }
 899
 900 bool wxThread::IsPaused() const
 901 {
 902     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 903
 904     return (m_internal->GetState() == STATE_PAUSED);
 905 }
 906
 907 bool wxThread::TestDestroy()
 908 {
 909     wxCriticalSectionLocker         lock((wxCriticalSection &)m_critsect);
 910
 911     return m_internal->GetState() == STATE_CANCELED;
 912 }
 913
 914 // ----------------------------------------------------------------------------
 915 // Automatic initialization for thread module
 916 // ----------------------------------------------------------------------------
 917
 918 class wxThreadModule : public wxModule
 919 {
 920 public:
 921     virtual bool OnInit();
 922     virtual void OnExit();
 923
 924 private:
 925     DECLARE_DYNAMIC_CLASS(wxThreadModule)
 926 };
 927
 928 IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule)
 929
 930 bool wxThreadModule::OnInit()
 931 {
 932     gs_pCritsectWaitingForGui = new wxCriticalSection();
 933
 934     gs_pCritsectGui = new wxCriticalSection();
 935     gs_pCritsectGui->Enter();
 936
 937     wxThread::ms_idMainThread = wxThread::GetCurrentId();
 938
 939     return true;
 940 }
 941
 942 void wxThreadModule::OnExit()
 943 {
 944     if (gs_pCritsectGui)
 945     {
 946         gs_pCritsectGui->Leave();
 947 #if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
 948         delete gs_pCritsectGui;
 949 #endif
 950         gs_pCritsectGui = NULL;
 951     }
 952
 953 #if (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
 954     wxDELETE(gs_pCritsectWaitingForGui);
 955 #endif
 956 }
 957
 958 // ----------------------------------------------------------------------------
 959 // Helper functions
 960 // ----------------------------------------------------------------------------
 961
 962 // wake up the main thread if it's in ::GetMessage()
 963 void WXDLLEXPORT wxWakeUpMainThread()
 964 {
 965 #if 0
 966     if ( !::WinPostQueueMsg(wxTheApp->m_hMq, WM_NULL, 0, 0) )
 967     {
 968         // should never happen
 969         wxLogLastError(wxT("WinPostMessage(WM_NULL)"));
 970     }
 971 #endif
 972 }
 973
 974 void wxMutexGuiEnterImpl()
 975 {
 976     // this would dead lock everything...
 977     wxASSERT_MSG( !wxThread::IsMain(),
 978                   wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
 979
 980     // the order in which we enter the critical sections here is crucial!!
 981
 982     // set the flag telling to the main thread that we want to do some GUI
 983     {
 984         wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
 985
 986         gs_nWaitingForGui++;
 987     }
 988
 989     wxWakeUpMainThread();
 990
 991     // now we may block here because the main thread will soon let us in
 992     // (during the next iteration of OnIdle())
 993     gs_pCritsectGui->Enter();
 994 }
 995
 996 void wxMutexGuiLeaveImpl()
 997 {
 998     wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
 999
1000     if ( wxThread::IsMain() )
1001     {
1002         gs_bGuiOwnedByMainThread = false;
1003     }
1004     else
1005     {
1006         // decrement the number of waiters now
1007         wxASSERT_MSG(gs_nWaitingForGui > 0,
1008                       wxT("calling wxMutexGuiLeave() without entering it first?") );
1009
1010         gs_nWaitingForGui--;
1011
1012         wxWakeUpMainThread();
1013     }
1014
1015     gs_pCritsectGui->Leave();
1016 }
1017
1018 void WXDLLEXPORT wxMutexGuiLeaveOrEnter()
1019 {
1020     wxASSERT_MSG( wxThread::IsMain(),
1021                   wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
1022
1023     wxCriticalSectionLocker enter(*gs_pCritsectWaitingForGui);
1024
1025     if (gs_nWaitingForGui == 0)
1026     {
1027         // no threads are waiting for GUI - so we may acquire the lock without
1028         // any danger (but only if we don't already have it)
1029         if (!wxGuiOwnedByMainThread())
1030         {
1031             gs_pCritsectGui->Enter();
1032
1033             gs_bGuiOwnedByMainThread = true;
1034         }
1035         //else: already have it, nothing to do
1036     }
1037     else
1038     {
1039         // some threads are waiting, release the GUI lock if we have it
1040         if (wxGuiOwnedByMainThread())
1041         {
1042             wxMutexGuiLeave();
1043         }
1044         //else: some other worker thread is doing GUI
1045     }
1046 }
1047
1048 bool WXDLLEXPORT wxGuiOwnedByMainThread()
1049 {
1050     return gs_bGuiOwnedByMainThread;
1051 }
1052
1053 bool WXDLLEXPORT wxIsWaitingForThread()
1054 {
1055     return gs_bWaitingForThread;
1056 }
1057
1058 // ----------------------------------------------------------------------------
1059 // include common implementation code
1060 // ----------------------------------------------------------------------------
1061
1062 #include "wx/thrimpl.cpp"
1063
1064 #endif
1065   // wxUSE_THREADS