// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "thread.h"
#endif
-#include "wx/defs.h"
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
#if wxUSE_THREADS
friend class wxConditionInternal;
};
+#ifdef HAVE_PTHREAD_MUTEXATTR_T
+// on some systems pthread_mutexattr_settype() is not in the headers (but it is
+// in the library, otherwise we wouldn't compile this code at all)
+extern "C" int pthread_mutexattr_settype(pthread_mutexattr_t *, int);
+#endif
+
wxMutexInternal::wxMutexInternal(wxMutexType mutexType)
{
int err;
m_isOk = err == 0;
if ( !m_isOk )
{
- wxLogApiError("pthread_mutex_init()", err);
+ wxLogApiError( wxT("pthread_mutex_init()"), err);
}
}
int err = pthread_mutex_destroy(&m_mutex);
if ( err != 0 )
{
- wxLogApiError("pthread_mutex_destroy()", err);
+ wxLogApiError( wxT("pthread_mutex_destroy()"), err);
}
}
}
return wxSEMA_MISC_ERROR;
wxLogTrace(TRACE_SEMA,
- "Thread %ld finished waiting for semaphore, count = %u",
- wxThread::GetCurrentId(), m_count);
+ "Thread %ld finished waiting for semaphore, count = %lu",
+ wxThread::GetCurrentId(), (unsigned long)m_count);
}
m_count--;
return wxSEMA_TIMEOUT;
}
- if ( m_cond.Wait(remainingTime) != wxCOND_NO_ERROR )
- return wxSEMA_MISC_ERROR;
+ switch ( m_cond.WaitTimeout(remainingTime) )
+ {
+ case wxCOND_TIMEOUT:
+ return wxSEMA_TIMEOUT;
+
+ default:
+ return wxSEMA_MISC_ERROR;
+
+ case wxCOND_NO_ERROR:
+ ;
+ }
}
m_count--;
m_count++;
wxLogTrace(TRACE_SEMA,
- "Thread %ld about to signal semaphore, count = %u",
- wxThread::GetCurrentId(), m_count);
-
+ "Thread %ld about to signal semaphore, count = %lu",
+ wxThread::GetCurrentId(), (unsigned long)m_count);
+
return m_cond.Signal() == wxCOND_NO_ERROR ? wxSEMA_NO_ERROR
: wxSEMA_MISC_ERROR;
}
};
wxLogTrace(TRACE_THREADS, _T("Thread %ld: %s => %s."),
- GetId(), stateNames[m_state], stateNames[state]);
+ (long)GetId(), stateNames[m_state], stateNames[state]);
#endif // __WXDEBUG__
m_state = state;
{
wxThreadInternal *pthread = thread->m_internal;
- wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), pthread->GetId());
-
+#ifdef __VMS
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), (long long)pthread->GetId());
+#else
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), (long)pthread->GetId());
+#endif
+
// associate the thread pointer with the newly created thread so that
// wxThread::This() will work
int rc = pthread_setspecific(gs_keySelf, thread);
{
// call the main entry
wxLogTrace(TRACE_THREADS, _T("Thread %ld about to enter its Entry()."),
- pthread->GetId());
-
+#ifdef __VMS
+ (long long)pthread->GetId());
+#else
+ (long)pthread->GetId());
+#endif
+
pthread->m_exitcode = thread->Entry();
wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."),
- pthread->GetId(), (unsigned long)pthread->m_exitcode);
-
+#ifdef __VMS
+ (long long)pthread->GetId(), (unsigned long)pthread->m_exitcode);
+#else
+ (long)pthread->GetId(), (unsigned long)pthread->m_exitcode);
+#endif
+
{
wxCriticalSectionLocker lock(thread->m_critsect);
wxMutexGuiLeave();
wxLogTrace(TRACE_THREADS,
- _T("Starting to wait for thread %ld to exit."), GetId());
-
+#ifdef __VMS
+ _T("Starting to wait for thread %ld to exit."), (long long)GetId());
+#else
+ _T("Starting to wait for thread %ld to exit."), (long)GetId());
+#endif
+
// to avoid memory leaks we should call pthread_join(), but it must only be
// done once so use a critical section to serialize the code below
{
// we're cancelled inside pthread_join(), things will almost
// certainly break - but if we disable the cancellation, we
// might deadlock
- if ( pthread_join((pthread_t)GetId(), &m_exitcode) != 0 )
+ if ( pthread_join(GetId(), &m_exitcode) != 0 )
{
// this is a serious problem, so use wxLogError and not
// wxLogDebug: it is possible to bring the system to its knees
wxCHECK_RET( m_state == STATE_PAUSED,
wxT("thread must first be paused with wxThread::Pause().") );
- wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), GetId());
-
+#ifdef __VMS
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), (long long)GetId());
+#else
+ wxLogTrace(TRACE_THREADS, _T("Thread %ld goes to sleep."), (long)GetId());
+#endif
+
// wait until the semaphore is Post()ed from Resume()
m_semSuspend.Wait();
}
// TestDestroy() since the last call to Pause() for example
if ( IsReallyPaused() )
{
- wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), GetId());
-
+#ifdef __VMS
+ wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), (long long)GetId());
+#else
+ wxLogTrace(TRACE_THREADS, _T("Waking up thread %ld"), (long)GetId());
+#endif
+
// wake up Pause()
m_semSuspend.Post();
else
{
wxLogTrace(TRACE_THREADS, _T("Thread %ld is not yet really paused"),
- GetId());
+#ifdef __VMS
+ (long long)GetId());
+#else
+ (long)GetId());
+#endif
}
SetState(STATE_RUNNING);
wxString s;
if ( file.ReadAll(&s) )
{
- // (ab)use Replace() to find the number of "processor" strings
- size_t count = s.Replace(_T("processor"), _T(""));
+ // (ab)use Replace() to find the number of "processor: num" strings
+ size_t count = s.Replace(_T("processor\t:"), _T(""));
if ( count > 0 )
{
return count;
if ( nThreadsBeingDeleted > 0 )
{
- wxLogTrace(TRACE_THREADS, _T("Waiting for %u threads to disappear"),
- nThreadsBeingDeleted);
+ wxLogTrace(TRACE_THREADS,
+ _T("Waiting for %lu threads to disappear"),
+ (unsigned long)nThreadsBeingDeleted);
// have to wait until all of them disappear
gs_condAllDeleted->Wait();
size_t count = gs_allThreads.GetCount();
if ( count != 0u )
{
- wxLogDebug(wxT("%u threads were not terminated by the application."),
- count);
+ wxLogDebug(wxT("%lu threads were not terminated by the application."),
+ (unsigned long)count);
}
for ( size_t n = 0u; n < count; n++ )
gs_nThreadsBeingDeleted++;
- wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"),
- gs_nThreadsBeingDeleted,
+ wxLogTrace(TRACE_THREADS, _T("%lu thread%s waiting to be deleted"),
+ (unsigned long)gs_nThreadsBeingDeleted,
gs_nThreadsBeingDeleted == 1 ? "" : "s");
}
wxCHECK_RET( gs_nThreadsBeingDeleted > 0,
_T("no threads scheduled for deletion, yet we delete one?") );
- wxLogTrace(TRACE_THREADS, _T("%u scheduled for deletion threads left."),
- gs_nThreadsBeingDeleted - 1);
+ wxLogTrace(TRACE_THREADS, _T("%lu scheduled for deletion threads left."),
+ (unsigned long)gs_nThreadsBeingDeleted - 1);
if ( !--gs_nThreadsBeingDeleted )
{
projects / wxWidgets.git / blobdiff