From 1096b1e28e59907ed4ce1d666b644cf7d6e5874a Mon Sep 17 00:00:00 2001 From: Michael Glassford Date: Fri, 25 Jun 2004 20:22:02 +0000 Subject: [PATCH] Cleanup: always #include first; eliminate tabs; etc. [SVN r23190] --- include/boost/thread/detail/force_cast.hpp | 2 + include/boost/thread/detail/singleton.hpp | 2 + include/boost/thread/detail/threadmon.hpp | 10 +- include/boost/thread/mutex.hpp | 6 +- include/boost/thread/recursive_mutex.hpp | 6 +- include/boost/thread/tss.hpp | 8 +- src/barrier.cpp | 2 + src/condition.cpp | 648 ++++++++++----------- src/exceptions.cpp | 2 + src/mutex.cpp | 2 + src/once.cpp | 2 + src/recursive_mutex.cpp | 4 +- src/thread.cpp | 2 + src/threadmon.cpp | 2 +- src/xtime.cpp | 2 + 15 files changed, 353 insertions(+), 347 deletions(-) diff --git a/include/boost/thread/detail/force_cast.hpp b/include/boost/thread/detail/force_cast.hpp index 5632fb65..7f0b81a0 100644 --- a/include/boost/thread/detail/force_cast.hpp +++ b/include/boost/thread/detail/force_cast.hpp @@ -14,6 +14,8 @@ #ifndef BOOST_FORCE_CAST_MJM012402_HPP #define BOOST_FORCE_CAST_MJM012402_HPP +#include + namespace boost { namespace detail { namespace thread { diff --git a/include/boost/thread/detail/singleton.hpp b/include/boost/thread/detail/singleton.hpp index f4b589b4..27b72e63 100644 --- a/include/boost/thread/detail/singleton.hpp +++ b/include/boost/thread/detail/singleton.hpp @@ -14,6 +14,8 @@ #ifndef BOOST_SINGLETON_MJM012402_HPP #define BOOST_SINGLETON_MJM012402_HPP +#include + namespace boost { namespace detail { namespace thread { diff --git a/include/boost/thread/detail/threadmon.hpp b/include/boost/thread/detail/threadmon.hpp index 376481d6..483c3d5e 100644 --- a/include/boost/thread/detail/threadmon.hpp +++ b/include/boost/thread/detail/threadmon.hpp @@ -9,17 +9,15 @@ // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. -#include - -// insist on threading support being available: -#include +#ifndef BOOST_THREADMON_WEK062504_HPP +#define BOOST_THREADMON_WEK062504_HPP #include #ifdef BOOST_HAS_WINTHREADS -#include - extern "C" BOOST_THREAD_DECL int on_thread_exit(void (__cdecl * func)(void)); #endif // BOOST_HAS_WINTHREADS + +#endif // BOOST_THREADMON_WEK062504_HPP \ No newline at end of file diff --git a/include/boost/thread/mutex.hpp b/include/boost/thread/mutex.hpp index 31886741..6739abf4 100644 --- a/include/boost/thread/mutex.hpp +++ b/include/boost/thread/mutex.hpp @@ -12,13 +12,9 @@ #ifndef BOOST_MUTEX_WEK070601_HPP #define BOOST_MUTEX_WEK070601_HPP -#include - -// insist on threading support being available: -#include +#include #include -#include #include #if defined(BOOST_HAS_PTHREADS) diff --git a/include/boost/thread/recursive_mutex.hpp b/include/boost/thread/recursive_mutex.hpp index 122c1399..75fe6422 100644 --- a/include/boost/thread/recursive_mutex.hpp +++ b/include/boost/thread/recursive_mutex.hpp @@ -12,13 +12,9 @@ #ifndef BOOST_RECURSIVE_MUTEX_WEK070601_HPP #define BOOST_RECURSIVE_MUTEX_WEK070601_HPP -#include - -// insist on threading support being available: -#include +#include #include -#include #include #if defined(BOOST_HAS_PTHREADS) diff --git a/include/boost/thread/tss.hpp b/include/boost/thread/tss.hpp index 7520af7d..422d7c6b 100644 --- a/include/boost/thread/tss.hpp +++ b/include/boost/thread/tss.hpp @@ -12,13 +12,10 @@ #ifndef BOOST_TSS_WEK070601_HPP #define BOOST_TSS_WEK070601_HPP -#include - -// insist on threading support being available: -#include - #include +#ifndef BOOST_THREAD_NO_TSS_CLEANUP + #include #include #include @@ -110,6 +107,7 @@ private: } // namespace boost +#endif BOOST_THREAD_NO_TSS_CLEANUP #endif // BOOST_TSS_WEK070601_HPP // Change Log: diff --git a/src/barrier.cpp b/src/barrier.cpp index 5d7988e2..cd88e5f4 100644 --- a/src/barrier.cpp +++ b/src/barrier.cpp @@ -9,6 +9,8 @@ // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. +#include + #include namespace boost { diff --git a/src/condition.cpp b/src/condition.cpp index 0ac6f4a9..4ea91843 100644 --- a/src/condition.cpp +++ b/src/condition.cpp @@ -9,6 +9,8 @@ // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. +#include + #include #include #include @@ -39,32 +41,31 @@ condition_impl::condition_impl() : m_gone(0), m_blocked(0), m_waiting(0) { m_gate = reinterpret_cast(CreateSemaphore(0, 1, 1, 0)); - m_queue = reinterpret_cast(CreateSemaphore(0, 0, - (std::numeric_limits::max)(), - 0)); + m_queue = reinterpret_cast( + CreateSemaphore(0, 0, (std::numeric_limits::max)(), 0)); m_mutex = reinterpret_cast(CreateMutex(0, 0, 0)); if (!m_gate || !m_queue || !m_mutex) + { + int res = 0; + if (m_gate) { - int res = 0; - if (m_gate) - { - res = CloseHandle(reinterpret_cast(m_gate)); - assert(res); - } - if (m_queue) - { - res = CloseHandle(reinterpret_cast(m_queue)); - assert(res); - } - if (m_mutex) - { - res = CloseHandle(reinterpret_cast(m_mutex)); - assert(res); - } - - throw thread_resource_error(); + res = CloseHandle(reinterpret_cast(m_gate)); + assert(res); } + if (m_queue) + { + res = CloseHandle(reinterpret_cast(m_queue)); + assert(res); + } + if (m_mutex) + { + res = CloseHandle(reinterpret_cast(m_mutex)); + assert(res); + } + + throw thread_resource_error(); + } } condition_impl::~condition_impl() @@ -87,47 +88,47 @@ void condition_impl::notify_one() assert(res == WAIT_OBJECT_0); if (m_waiting != 0) // the m_gate is already closed + { + if (m_blocked == 0) { - if (m_blocked == 0) - { - res = ReleaseMutex(reinterpret_cast(m_mutex)); - assert(res); - return; - } + res = ReleaseMutex(reinterpret_cast(m_mutex)); + assert(res); + return; + } - ++m_waiting; - --m_blocked; - signals = 1; - } + ++m_waiting; + --m_blocked; + signals = 1; + } else + { + res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); + assert(res == WAIT_OBJECT_0); + if (m_blocked > m_gone) { - res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); - assert(res == WAIT_OBJECT_0); - if (m_blocked > m_gone) - { - if (m_gone != 0) - { - m_blocked -= m_gone; - m_gone = 0; - } - signals = m_waiting = 1; - --m_blocked; - } - else - { - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); - } + if (m_gone != 0) + { + m_blocked -= m_gone; + m_gone = 0; + } + signals = m_waiting = 1; + --m_blocked; } + else + { + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); + } + } res = ReleaseMutex(reinterpret_cast(m_mutex)); assert(res); if (signals) - { - res = ReleaseSemaphore(reinterpret_cast(m_queue), signals, 0); - assert(res); - } + { + res = ReleaseSemaphore(reinterpret_cast(m_queue), signals, 0); + assert(res); + } } void condition_impl::notify_all() @@ -139,47 +140,46 @@ void condition_impl::notify_all() assert(res == WAIT_OBJECT_0); if (m_waiting != 0) // the m_gate is already closed + { + if (m_blocked == 0) { - if (m_blocked == 0) - { - res = ReleaseMutex(reinterpret_cast(m_mutex)); - assert(res); - return; - } + res = ReleaseMutex(reinterpret_cast(m_mutex)); + assert(res); + return; + } - m_waiting += (signals = m_blocked); + m_waiting += (signals = m_blocked); + m_blocked = 0; + } + else + { + res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); + assert(res == WAIT_OBJECT_0); + if (m_blocked > m_gone) + { + if (m_gone != 0) + { + m_blocked -= m_gone; + m_gone = 0; + } + signals = m_waiting = m_blocked; m_blocked = 0; } - else + else { - res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); - assert(res == WAIT_OBJECT_0); - if (m_blocked > m_gone) - { - if (m_gone != 0) - { - m_blocked -= m_gone; - m_gone = 0; - } - signals = m_waiting = m_blocked; - m_blocked = 0; - } - else - { - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); - } + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); } + } res = ReleaseMutex(reinterpret_cast(m_mutex)); assert(res); if (signals) - { - res = ReleaseSemaphore(reinterpret_cast(m_queue), signals, - 0); - assert(res); - } + { + res = ReleaseSemaphore(reinterpret_cast(m_queue), signals, 0); + assert(res); + } } void condition_impl::enter_wait() @@ -206,47 +206,47 @@ void condition_impl::do_wait() was_waiting = m_waiting; was_gone = m_gone; if (was_waiting != 0) + { + if (--m_waiting == 0) { - if (--m_waiting == 0) - { - if (m_blocked != 0) - { - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, - 0); // open m_gate - assert(res); - was_waiting = 0; - } - else if (m_gone != 0) - m_gone = 0; - } + if (m_blocked != 0) + { + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, + 0); // open m_gate + assert(res); + was_waiting = 0; + } + else if (m_gone != 0) + m_gone = 0; } + } else if (++m_gone == ((std::numeric_limits::max)() / 2)) - { - // timeout occured, normalize the m_gone count - // this may occur if many calls to wait with a timeout are made and - // no call to notify_* is made - res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); - assert(res == WAIT_OBJECT_0); - m_blocked -= m_gone; - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); - m_gone = 0; - } + { + // timeout occured, normalize the m_gone count + // this may occur if many calls to wait with a timeout are made and + // no call to notify_* is made + res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); + assert(res == WAIT_OBJECT_0); + m_blocked -= m_gone; + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); + m_gone = 0; + } res = ReleaseMutex(reinterpret_cast(m_mutex)); assert(res); if (was_waiting == 1) + { + for (/**/ ; was_gone; --was_gone) { - for (/**/ ; was_gone; --was_gone) - { - // better now than spurious later - res = WaitForSingleObject(reinterpret_cast(m_queue), - INFINITE); - assert(res == WAIT_OBJECT_0); - } - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); + // better now than spurious later + res = WaitForSingleObject(reinterpret_cast(m_queue), + INFINITE); + assert(res == WAIT_OBJECT_0); } + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); + } } bool condition_impl::do_timed_wait(const xtime& xt) @@ -255,26 +255,26 @@ bool condition_impl::do_timed_wait(const xtime& xt) unsigned int res = 0; for (;;) + { + int milliseconds; + to_duration(xt, milliseconds); + + res = WaitForSingleObject(reinterpret_cast(m_queue), + milliseconds); + assert(res != WAIT_FAILED && res != WAIT_ABANDONED); + ret = (res == WAIT_OBJECT_0); + + if (res == WAIT_TIMEOUT) { - int milliseconds; - to_duration(xt, milliseconds); - - res = WaitForSingleObject(reinterpret_cast(m_queue), - milliseconds); - assert(res != WAIT_FAILED && res != WAIT_ABANDONED); - ret = (res == WAIT_OBJECT_0); - - if (res == WAIT_TIMEOUT) - { - xtime cur; - xtime_get(&cur, TIME_UTC); - if (xtime_cmp(xt, cur) > 0) - continue; - } - - break; + xtime cur; + xtime_get(&cur, TIME_UTC); + if (xtime_cmp(xt, cur) > 0) + continue; } + break; + } + unsigned was_waiting=0; unsigned was_gone=0; @@ -283,54 +283,54 @@ bool condition_impl::do_timed_wait(const xtime& xt) was_waiting = m_waiting; was_gone = m_gone; if (was_waiting != 0) + { + if (!ret) // timeout { - if (!ret) // timeout - { - if (m_blocked != 0) - --m_blocked; - else - ++m_gone; // count spurious wakeups - } - if (--m_waiting == 0) - { - if (m_blocked != 0) - { - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, - 0); // open m_gate - assert(res); - was_waiting = 0; - } - else if (m_gone != 0) - m_gone = 0; - } + if (m_blocked != 0) + --m_blocked; + else + ++m_gone; // count spurious wakeups } + if (--m_waiting == 0) + { + if (m_blocked != 0) + { + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, + 0); // open m_gate + assert(res); + was_waiting = 0; + } + else if (m_gone != 0) + m_gone = 0; + } + } else if (++m_gone == ((std::numeric_limits::max)() / 2)) - { - // timeout occured, normalize the m_gone count - // this may occur if many calls to wait with a timeout are made and - // no call to notify_* is made - res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); - assert(res == WAIT_OBJECT_0); - m_blocked -= m_gone; - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); - m_gone = 0; - } + { + // timeout occured, normalize the m_gone count + // this may occur if many calls to wait with a timeout are made and + // no call to notify_* is made + res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); + assert(res == WAIT_OBJECT_0); + m_blocked -= m_gone; + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); + m_gone = 0; + } res = ReleaseMutex(reinterpret_cast(m_mutex)); assert(res); if (was_waiting == 1) + { + for (/**/ ; was_gone; --was_gone) { - for (/**/ ; was_gone; --was_gone) - { - // better now than spurious later - res = WaitForSingleObject(reinterpret_cast(m_queue), - INFINITE); - assert(res == WAIT_OBJECT_0); - } - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); + // better now than spurious later + res = WaitForSingleObject(reinterpret_cast(m_queue), + INFINITE); + assert(res == WAIT_OBJECT_0); } + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); + } return ret; } @@ -399,20 +399,20 @@ condition_impl::condition_impl() lStatus = MPCreateSemaphore(ULONG_MAX, 0, &m_queue); if(lStatus != noErr || !m_gate || !m_queue) + { + if (m_gate) { - if (m_gate) - { - lStatus = MPDeleteSemaphore(m_gate); - assert(lStatus == noErr); - } - if (m_queue) - { - lStatus = MPDeleteSemaphore(m_queue); - assert(lStatus == noErr); - } - - throw thread_resource_error(); + lStatus = MPDeleteSemaphore(m_gate); + assert(lStatus == noErr); } + if (m_queue) + { + lStatus = MPDeleteSemaphore(m_queue); + assert(lStatus == noErr); + } + + throw thread_resource_error(); + } } condition_impl::~condition_impl() @@ -430,51 +430,51 @@ void condition_impl::notify_one() OSStatus lStatus = noErr; lStatus = safe_enter_critical_region(m_mutex, kDurationForever, - m_mutex_mutex); + m_mutex_mutex); assert(lStatus == noErr); if (m_waiting != 0) // the m_gate is already closed + { + if (m_blocked == 0) { - if (m_blocked == 0) - { - lStatus = MPExitCriticalRegion(m_mutex); - assert(lStatus == noErr); - return; - } - - ++m_waiting; - --m_blocked; - } - else - { - lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); - assert(lStatus == noErr); - if (m_blocked > m_gone) - { - if (m_gone != 0) - { - m_blocked -= m_gone; - m_gone = 0; - } - signals = m_waiting = 1; - --m_blocked; - } - else - { - lStatus = MPSignalSemaphore(m_gate); - assert(lStatus == noErr); - } - lStatus = MPExitCriticalRegion(m_mutex); assert(lStatus == noErr); - - while (signals) - { - lStatus = MPSignalSemaphore(m_queue); - assert(lStatus == noErr); - --signals; - } + return; } + + ++m_waiting; + --m_blocked; + } + else + { + lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); + assert(lStatus == noErr); + if (m_blocked > m_gone) + { + if (m_gone != 0) + { + m_blocked -= m_gone; + m_gone = 0; + } + signals = m_waiting = 1; + --m_blocked; + } + else + { + lStatus = MPSignalSemaphore(m_gate); + assert(lStatus == noErr); + } + + lStatus = MPExitCriticalRegion(m_mutex); + assert(lStatus == noErr); + + while (signals) + { + lStatus = MPSignalSemaphore(m_queue); + assert(lStatus == noErr); + --signals; + } + } } void condition_impl::notify_all() @@ -483,51 +483,51 @@ void condition_impl::notify_all() OSStatus lStatus = noErr; lStatus = safe_enter_critical_region(m_mutex, kDurationForever, - m_mutex_mutex); + m_mutex_mutex); assert(lStatus == noErr); if (m_waiting != 0) // the m_gate is already closed + { + if (m_blocked == 0) { - if (m_blocked == 0) - { - lStatus = MPExitCriticalRegion(m_mutex); - assert(lStatus == noErr); - return; - } - - m_waiting += (signals = m_blocked); - m_blocked = 0; - } - else - { - lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); - assert(lStatus == noErr); - if (m_blocked > m_gone) - { - if (m_gone != 0) - { - m_blocked -= m_gone; - m_gone = 0; - } - signals = m_waiting = m_blocked; - m_blocked = 0; - } - else - { - lStatus = MPSignalSemaphore(m_gate); - assert(lStatus == noErr); - } - lStatus = MPExitCriticalRegion(m_mutex); assert(lStatus == noErr); - - while (signals) - { - lStatus = MPSignalSemaphore(m_queue); - assert(lStatus == noErr); - --signals; - } + return; } + + m_waiting += (signals = m_blocked); + m_blocked = 0; + } + else + { + lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); + assert(lStatus == noErr); + if (m_blocked > m_gone) + { + if (m_gone != 0) + { + m_blocked -= m_gone; + m_gone = 0; + } + signals = m_waiting = m_blocked; + m_blocked = 0; + } + else + { + lStatus = MPSignalSemaphore(m_gate); + assert(lStatus == noErr); + } + + lStatus = MPExitCriticalRegion(m_mutex); + assert(lStatus == noErr); + + while (signals) + { + lStatus = MPSignalSemaphore(m_queue); + assert(lStatus == noErr); + --signals; + } + } } void condition_impl::enter_wait() @@ -550,50 +550,50 @@ void condition_impl::do_wait() unsigned was_gone=0; lStatus = safe_enter_critical_region(m_mutex, kDurationForever, - m_mutex_mutex); + m_mutex_mutex); assert(lStatus == noErr); was_waiting = m_waiting; was_gone = m_gone; if (was_waiting != 0) + { + if (--m_waiting == 0) { - if (--m_waiting == 0) - { - if (m_blocked != 0) - { - lStatus = MPSignalSemaphore(m_gate); // open m_gate - assert(lStatus == noErr); - was_waiting = 0; - } - else if (m_gone != 0) - m_gone = 0; - } + if (m_blocked != 0) + { + lStatus = MPSignalSemaphore(m_gate); // open m_gate + assert(lStatus == noErr); + was_waiting = 0; + } + else if (m_gone != 0) + m_gone = 0; } + } else if (++m_gone == ((std::numeric_limits::max)() / 2)) - { - // timeout occured, normalize the m_gone count - // this may occur if many calls to wait with a timeout are made and - // no call to notify_* is made - lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); - assert(lStatus == noErr); - m_blocked -= m_gone; - lStatus = MPSignalSemaphore(m_gate); - assert(lStatus == noErr); - m_gone = 0; - } + { + // timeout occured, normalize the m_gone count + // this may occur if many calls to wait with a timeout are made and + // no call to notify_* is made + lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); + assert(lStatus == noErr); + m_blocked -= m_gone; + lStatus = MPSignalSemaphore(m_gate); + assert(lStatus == noErr); + m_gone = 0; + } lStatus = MPExitCriticalRegion(m_mutex); assert(lStatus == noErr); if (was_waiting == 1) + { + for (/**/ ; was_gone; --was_gone) { - for (/**/ ; was_gone; --was_gone) - { - // better now than spurious later - lStatus = safe_wait_on_semaphore(m_queue, kDurationForever); - assert(lStatus == noErr); - } - lStatus = MPSignalSemaphore(m_gate); + // better now than spurious later + lStatus = safe_wait_on_semaphore(m_queue, kDurationForever); assert(lStatus == noErr); } + lStatus = MPSignalSemaphore(m_gate); + assert(lStatus == noErr); + } } bool condition_impl::do_timed_wait(const xtime& xt) @@ -616,52 +616,52 @@ bool condition_impl::do_timed_wait(const xtime& xt) was_waiting = m_waiting; was_gone = m_gone; if (was_waiting != 0) + { + if (!ret) // timeout { - if (!ret) // timeout - { - if (m_blocked != 0) - --m_blocked; - else - ++m_gone; // count spurious wakeups - } - if (--m_waiting == 0) - { - if (m_blocked != 0) - { - lStatus = MPSignalSemaphore(m_gate); // open m_gate - assert(lStatus == noErr); - was_waiting = 0; - } - else if (m_gone != 0) - m_gone = 0; - } + if (m_blocked != 0) + --m_blocked; + else + ++m_gone; // count spurious wakeups } + if (--m_waiting == 0) + { + if (m_blocked != 0) + { + lStatus = MPSignalSemaphore(m_gate); // open m_gate + assert(lStatus == noErr); + was_waiting = 0; + } + else if (m_gone != 0) + m_gone = 0; + } + } else if (++m_gone == ((std::numeric_limits::max)() / 2)) - { - // timeout occured, normalize the m_gone count - // this may occur if many calls to wait with a timeout are made and - // no call to notify_* is made - lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); - assert(lStatus == noErr); - m_blocked -= m_gone; - lStatus = MPSignalSemaphore(m_gate); - assert(lStatus == noErr); - m_gone = 0; - } + { + // timeout occured, normalize the m_gone count + // this may occur if many calls to wait with a timeout are made and + // no call to notify_* is made + lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); + assert(lStatus == noErr); + m_blocked -= m_gone; + lStatus = MPSignalSemaphore(m_gate); + assert(lStatus == noErr); + m_gone = 0; + } lStatus = MPExitCriticalRegion(m_mutex); assert(lStatus == noErr); if (was_waiting == 1) + { + for (/**/ ; was_gone; --was_gone) { - for (/**/ ; was_gone; --was_gone) - { - // better now than spurious later - lStatus = safe_wait_on_semaphore(m_queue, kDurationForever); - assert(lStatus == noErr); - } - lStatus = MPSignalSemaphore(m_gate); + // better now than spurious later + lStatus = safe_wait_on_semaphore(m_queue, kDurationForever); assert(lStatus == noErr); } + lStatus = MPSignalSemaphore(m_gate); + assert(lStatus == noErr); + } return ret; } diff --git a/src/exceptions.cpp b/src/exceptions.cpp index 75beac84..c9fa8a13 100644 --- a/src/exceptions.cpp +++ b/src/exceptions.cpp @@ -9,6 +9,8 @@ // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. +#include + #include #include diff --git a/src/mutex.cpp b/src/mutex.cpp index 224c663d..c02f578f 100644 --- a/src/mutex.cpp +++ b/src/mutex.cpp @@ -9,6 +9,8 @@ // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. +#include + #include #include #include diff --git a/src/once.cpp b/src/once.cpp index e829542b..f90e8a2a 100644 --- a/src/once.cpp +++ b/src/once.cpp @@ -9,6 +9,8 @@ // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. +#include + #include #include #include diff --git a/src/recursive_mutex.cpp b/src/recursive_mutex.cpp index 1afae625..5e79498d 100644 --- a/src/recursive_mutex.cpp +++ b/src/recursive_mutex.cpp @@ -9,6 +9,8 @@ // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. +#include + #include #include #include @@ -36,7 +38,7 @@ namespace boost { recursive_mutex::recursive_mutex() : m_mutex(0) - , m_critical_section(false) + , m_critical_section(false) , m_count(0) { m_critical_section = true; diff --git a/src/thread.cpp b/src/thread.cpp index 423fa754..e66408bf 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -9,6 +9,8 @@ // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. +#include + #include #include #include diff --git a/src/threadmon.cpp b/src/threadmon.cpp index de4d594c..e4936c80 100644 --- a/src/threadmon.cpp +++ b/src/threadmon.cpp @@ -9,7 +9,7 @@ // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. -#include +#include #if defined(BOOST_HAS_WINTHREADS) diff --git a/src/xtime.cpp b/src/xtime.cpp index 9f234a90..ae7458b1 100644 --- a/src/xtime.cpp +++ b/src/xtime.cpp @@ -9,6 +9,8 @@ // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. +#include + #include #if defined(BOOST_HAS_FTIME)