#include "wx/except.h"
+#include "wx/dynlib.h"
+
// must have this symbol defined to get _beginthread/_endthread declarations
#ifndef _MT
#define _MT
#if defined(__VISUALC__) || \
(defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)) || \
(defined(__GNUG__) && defined(__MSVCRT__)) || \
- defined(__WATCOMC__) || defined(__MWERKS__)
+ defined(__WATCOMC__)
#ifndef __WXWINCE__
#undef wxUSE_BEGIN_THREAD
// id of the main thread - the one which can call GUI functions without first
// calling wxMutexGuiEnter()
-static DWORD gs_idMainThread = 0;
+wxThreadIdType wxThread::ms_idMainThread = 0;
// if it's false, some secondary thread is holding the GUI lock
static bool gs_bGuiOwnedByMainThread = true;
::EnterCriticalSection((CRITICAL_SECTION *)m_buffer);
}
+bool wxCriticalSection::TryEnter()
+{
+#if wxUSE_DYNLIB_CLASS
+ typedef BOOL
+ (WINAPI *TryEnterCriticalSection_t)(LPCRITICAL_SECTION lpCriticalSection);
+
+ static TryEnterCriticalSection_t
+ pfnTryEnterCriticalSection = (TryEnterCriticalSection_t)
+ wxDynamicLibrary(wxT("kernel32.dll")).
+ GetSymbol(wxT("TryEnterCriticalSection"));
+
+ return pfnTryEnterCriticalSection
+ ? (*pfnTryEnterCriticalSection)((CRITICAL_SECTION *)m_buffer) != 0
+ : false;
+#else
+ return false;
+#endif
+}
+
void wxCriticalSection::Leave()
{
::LeaveCriticalSection((CRITICAL_SECTION *)m_buffer);
if ( !m_mutex )
{
- wxLogLastError(_T("CreateMutex()"));
+ wxLogLastError(wxT("CreateMutex()"));
}
}
{
if ( !::CloseHandle(m_mutex) )
{
- wxLogLastError(_T("CloseHandle(mutex)"));
+ wxLogLastError(wxT("CloseHandle(mutex)"));
}
}
}
case WAIT_ABANDONED:
// the previous caller died without releasing the mutex, so even
// though we did get it, log a message about this
- wxLogDebug(_T("WaitForSingleObject() returned WAIT_ABANDONED"));
+ wxLogDebug(wxT("WaitForSingleObject() returned WAIT_ABANDONED"));
// fall through
case WAIT_OBJECT_0:
// fall through
case WAIT_FAILED:
- wxLogLastError(_T("WaitForSingleObject(mutex)"));
+ wxLogLastError(wxT("WaitForSingleObject(mutex)"));
return wxMUTEX_MISC_ERROR;
}
if ( !::ReleaseMutex(m_mutex) )
{
- wxLogLastError(_T("ReleaseMutex()"));
+ wxLogLastError(wxT("ReleaseMutex()"));
return wxMUTEX_MISC_ERROR;
}
#endif
if ( !m_semaphore )
{
- wxLogLastError(_T("CreateSemaphore()"));
+ wxLogLastError(wxT("CreateSemaphore()"));
}
}
{
if ( !::CloseHandle(m_semaphore) )
{
- wxLogLastError(_T("CloseHandle(semaphore)"));
+ wxLogLastError(wxT("CloseHandle(semaphore)"));
}
}
}
return wxSEMA_TIMEOUT;
default:
- wxLogLastError(_T("WaitForSingleObject(semaphore)"));
+ wxLogLastError(wxT("WaitForSingleObject(semaphore)"));
}
return wxSEMA_MISC_ERROR;
}
else
{
- wxLogLastError(_T("ReleaseSemaphore"));
+ wxLogLastError(wxT("ReleaseSemaphore"));
return wxSEMA_MISC_ERROR;
}
}
m_thread = thread;
m_hThread = 0;
m_state = STATE_NEW;
- m_priority = WXTHREAD_DEFAULT_PRIORITY;
+ m_priority = wxPRIORITY_DEFAULT;
m_nRef = 1;
}
// (politely, this is not Kill()!) to do it
wxThreadError WaitForTerminate(wxCriticalSection& cs,
wxThread::ExitCode *pRc,
+ wxThreadWait waitMode,
wxThread *threadToDelete = NULL);
// kill the thread unconditionally
// store the thread object in the TLS
if ( !::TlsSetValue(gs_tlsThisThread, thread) )
{
- wxLogSysError(_("Can not start thread: error writing TLS."));
+ wxLogSysError(_("Cannot start thread: error writing TLS."));
return THREAD_ERROR_EXIT;
}
// each thread has its own SEH translator so install our own a.s.a.p.
DisableAutomaticSETranslator();
+ // NB: Notice that we can't use wxCriticalSectionLocker in this function as
+ // we use SEH and it's incompatible with C++ object dtors.
+
// first of all, check whether we hadn't been cancelled already and don't
// start the user code at all then
+ thread->m_critsect.Enter();
const bool hasExited = thread->m_internal->GetState() == STATE_EXITED;
+ thread->m_critsect.Leave();
// run the thread function itself inside a SEH try/except block
wxSEH_TRY
const bool isDetached = thread->IsDetached();
if ( !hasExited )
{
- // enter m_critsect before changing the thread state
- //
- // NB: can't use wxCriticalSectionLocker here as we use SEH and it's
- // incompatible with C++ object dtors
thread->m_critsect.Enter();
thread->m_internal->SetState(STATE_EXITED);
thread->m_critsect.Leave();
bool wxThreadInternal::Create(wxThread *thread, unsigned int stackSize)
{
wxASSERT_MSG( m_state == STATE_NEW && !m_hThread,
- _T("Create()ing thread twice?") );
+ wxT("Create()ing thread twice?") );
// for compilers which have it, we should use C RTL function for thread
// creation instead of Win32 API one because otherwise we will have memory
return false;
}
- if ( m_priority != WXTHREAD_DEFAULT_PRIORITY )
+ if ( m_priority != wxPRIORITY_DEFAULT )
{
SetPriority(m_priority);
}
wxThreadError wxThreadInternal::Kill()
{
+ m_thread->OnKill();
+
if ( !::TerminateThread(m_hThread, THREAD_ERROR_EXIT) )
{
wxLogSysError(_("Couldn't terminate thread"));
wxThreadError
wxThreadInternal::WaitForTerminate(wxCriticalSection& cs,
wxThread::ExitCode *pRc,
+ wxThreadWait waitMode,
wxThread *threadToDelete)
{
// prevent the thread C++ object from disappearing as long as we are using
Cancel();
}
+ if ( threadToDelete )
+ threadToDelete->OnDelete();
// now wait for thread to finish
if ( wxThread::IsMain() )
wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
if ( traits )
{
- result = traits->WaitForThread(m_hThread);
+ result = traits->WaitForThread(m_hThread, waitMode);
}
else // can't wait for the thread
{
{
case 0xFFFFFFFF:
// error
- wxLogSysError(_("Can not wait for thread termination"));
+ wxLogSysError(_("Cannot wait for thread termination"));
Kill();
return wxTHREAD_KILLED;
DWORD nSuspendCount = ::SuspendThread(m_hThread);
if ( nSuspendCount == (DWORD)-1 )
{
- wxLogSysError(_("Can not suspend thread %x"), m_hThread);
+ wxLogSysError(_("Cannot suspend thread %lx"),
+ static_cast<unsigned long>(wxPtrToUInt(m_hThread)));
return false;
}
DWORD nSuspendCount = ::ResumeThread(m_hThread);
if ( nSuspendCount == (DWORD)-1 )
{
- wxLogSysError(_("Can not resume thread %x"), m_hThread);
+ wxLogSysError(_("Cannot resume thread %lx"),
+ static_cast<unsigned long>(wxPtrToUInt(m_hThread)));
return false;
}
return thread;
}
-bool wxThread::IsMain()
-{
- return ::GetCurrentThreadId() == gs_idMainThread || gs_idMainThread == 0;
-}
-
void wxThread::Yield()
{
// 0 argument to Sleep() is special and means to just give away the rest of
#ifdef __WXWINCE__
return false;
#else
- wxASSERT_MSG( IsMain(), _T("should only be called from the main thread") );
+ wxASSERT_MSG( IsMain(), wxT("should only be called from the main thread") );
// ok only for the default one
if ( level == 0 )
DWORD_PTR dwProcMask, dwSysMask;
if ( ::GetProcessAffinityMask(hProcess, &dwProcMask, &dwSysMask) == 0 )
{
- wxLogLastError(_T("GetProcessAffinityMask"));
+ wxLogLastError(wxT("GetProcessAffinityMask"));
return false;
}
// could we set all bits?
if ( level != 0 )
{
- wxLogDebug(_T("bad level %u in wxThread::SetConcurrency()"), level);
+ wxLogDebug(wxT("bad level %u in wxThread::SetConcurrency()"), level);
return false;
}
if ( !pfnSetProcessAffinityMask )
{
- HMODULE hModKernel = ::LoadLibrary(_T("kernel32"));
+ HMODULE hModKernel = ::LoadLibrary(wxT("kernel32"));
if ( hModKernel )
{
pfnSetProcessAffinityMask = (SETPROCESSAFFINITYMASK)
// we've discovered a MT version of Win9x!
wxASSERT_MSG( pfnSetProcessAffinityMask,
- _T("this system has several CPUs but no SetProcessAffinityMask function?") );
+ wxT("this system has several CPUs but no SetProcessAffinityMask function?") );
}
if ( !pfnSetProcessAffinityMask )
if ( pfnSetProcessAffinityMask(hProcess, dwProcMask) == 0 )
{
- wxLogLastError(_T("SetProcessAffinityMask"));
+ wxLogLastError(wxT("SetProcessAffinityMask"));
return false;
}
{
wxCriticalSectionLocker lock(m_critsect);
- if ( m_internal->GetState() != STATE_NEW )
+ // Create the thread if it wasn't created yet with an explicit
+ // Create() call:
+ if ( !m_internal->GetHandle() )
{
- // actually, it may be almost any state at all, not only STATE_RUNNING
- return wxTHREAD_RUNNING;
+ if ( !m_internal->Create(this, 0) )
+ return wxTHREAD_NO_RESOURCE;
}
+ wxCHECK_MSG( m_internal->GetState() == STATE_NEW, wxTHREAD_RUNNING,
+ wxT("thread may only be started once after Create()") );
+
// the thread has just been created and is still suspended - let it run
return Resume();
}
// stopping thread
// ---------------
-wxThread::ExitCode wxThread::Wait()
+wxThread::ExitCode wxThread::Wait(wxThreadWait waitMode)
{
ExitCode rc = wxUIntToPtr(THREAD_ERROR_EXIT);
// although under Windows we can wait for any thread, it's an error to
// wait for a detached one in wxWin API
wxCHECK_MSG( !IsDetached(), rc,
- _T("wxThread::Wait(): can't wait for detached thread") );
+ wxT("wxThread::Wait(): can't wait for detached thread") );
- (void)m_internal->WaitForTerminate(m_critsect, &rc);
+ (void)m_internal->WaitForTerminate(m_critsect, &rc, waitMode);
return rc;
}
-wxThreadError wxThread::Delete(ExitCode *pRc)
+wxThreadError wxThread::Delete(ExitCode *pRc, wxThreadWait waitMode)
{
- return m_internal->WaitForTerminate(m_critsect, pRc, this);
+ return m_internal->WaitForTerminate(m_critsect, pRc, waitMode, this);
}
wxThreadError wxThread::Kill()
void wxThread::Exit(ExitCode status)
{
+ wxThreadInternal::DoThreadOnExit(this);
+
m_internal->Free();
if ( IsDetached() )
unsigned int wxThread::GetPriority() const
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return m_internal->GetPriority();
}
unsigned long wxThread::GetId() const
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return (unsigned long)m_internal->GetId();
}
bool wxThread::IsRunning() const
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return m_internal->GetState() == STATE_RUNNING;
}
bool wxThread::IsAlive() const
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return (m_internal->GetState() == STATE_RUNNING) ||
(m_internal->GetState() == STATE_PAUSED);
bool wxThread::IsPaused() const
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return m_internal->GetState() == STATE_PAUSED;
}
bool wxThread::TestDestroy()
{
- wxCriticalSectionLocker lock((wxCriticalSection &)m_critsect); // const_cast
+ wxCriticalSectionLocker lock(const_cast<wxCriticalSection &>(m_critsect));
return m_internal->GetState() == STATE_CANCELED;
}
::TlsFree(gs_tlsThisThread);
gs_tlsThisThread = 0xFFFFFFFF;
- wxLogSysError(_("Thread module initialization failed: can not store value in thread local storage"));
+ wxLogSysError(_("Thread module initialization failed: cannot store value in thread local storage"));
return false;
}
gs_critsectThreadDelete = new wxCriticalSection;
- // no error return for GetCurrentThreadId()
- gs_idMainThread = ::GetCurrentThreadId();
+ wxThread::ms_idMainThread = wxThread::GetCurrentId();
return true;
}
wxLogLastError(wxT("TlsFree failed."));
}
- delete gs_critsectThreadDelete;
- gs_critsectThreadDelete = NULL;
+ wxDELETE(gs_critsectThreadDelete);
if ( gs_critsectGui )
{
gs_critsectGui->Leave();
- delete gs_critsectGui;
- gs_critsectGui = NULL;
+ wxDELETE(gs_critsectGui);
}
- delete gs_critsectWaitingForGui;
- gs_critsectWaitingForGui = NULL;
+ wxDELETE(gs_critsectWaitingForGui);
}
// ----------------------------------------------------------------------------
void WXDLLIMPEXP_BASE wxWakeUpMainThread()
{
// sending any message would do - hopefully WM_NULL is harmless enough
- if ( !::PostThreadMessage(gs_idMainThread, WM_NULL, 0, 0) )
+ if ( !::PostThreadMessage(wxThread::GetMainId(), WM_NULL, 0, 0) )
{
// should never happen
wxLogLastError(wxT("PostThreadMessage(WM_NULL)"));
projects / wxWidgets.git / blobdiff