passenger 1.0.5 → 2.0.1

data/ext/boost/src/mutex.inl

@@ -1,128 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-// boostinspect:nounnamed
-
-namespace {
-
-#if defined(BOOST_HAS_WINTHREADS)
-//:PREVENT THIS FROM BEING DUPLICATED
-typedef BOOL (WINAPI* TryEnterCriticalSection_type)(LPCRITICAL_SECTION lpCriticalSection);
-TryEnterCriticalSection_type g_TryEnterCriticalSection = 0;
-boost::once_flag once_init_TryEnterCriticalSection = BOOST_ONCE_INIT;
-
-void init_TryEnterCriticalSection()
-{
-    //TryEnterCriticalSection is only available on WinNT 4.0 or later; 
-    //it is not available on Win9x.
-
-    OSVERSIONINFO version_info = {sizeof(OSVERSIONINFO)};
-    ::GetVersionEx(&version_info);
-    if (version_info.dwPlatformId == VER_PLATFORM_WIN32_NT && 
-        version_info.dwMajorVersion >= 4)
-    {
-        if (HMODULE kernel_module = GetModuleHandle(TEXT("KERNEL32.DLL")))
-        {
-            g_TryEnterCriticalSection = reinterpret_cast<TryEnterCriticalSection_type>(
-#if defined(BOOST_NO_ANSI_APIS)
-                GetProcAddressW(kernel_module, L"TryEnterCriticalSection")
-#else
-                GetProcAddress(kernel_module, "TryEnterCriticalSection")
-#endif        
-                );
-        }
-    }
-}
-
-inline bool has_TryEnterCriticalSection()
-{
-    boost::call_once(init_TryEnterCriticalSection, once_init_TryEnterCriticalSection);
-    return g_TryEnterCriticalSection != 0;
-}
-
-inline HANDLE mutex_cast(void* p)
-{
-    return reinterpret_cast<HANDLE>(p);
-}
-
-inline LPCRITICAL_SECTION critical_section_cast(void* p)
-{
-    return reinterpret_cast<LPCRITICAL_SECTION>(p);
-}
-
-inline void* new_critical_section()
-{
-    try
-    {
-        LPCRITICAL_SECTION critical_section = new CRITICAL_SECTION;
-        if (critical_section == 0) throw boost::thread_resource_error();
-        InitializeCriticalSection(critical_section);
-        return critical_section;
-    }
-    catch(...)
-    {
-        throw boost::thread_resource_error();
-    }
-}
-
-inline void* new_mutex(const char* name)
-{
-#if defined(BOOST_NO_ANSI_APIS)
-    USES_CONVERSION;
-    HANDLE mutex = CreateMutexW(0, 0, A2CW(name));
-#else
-    HANDLE mutex = CreateMutexA(0, 0, name);
-#endif
-    if (mutex == 0 || mutex == INVALID_HANDLE_VALUE) //:xxx (check for both values?)
-        throw boost::thread_resource_error();
-    return reinterpret_cast<void*>(mutex);
-}
-
-inline void delete_critical_section(void* mutex)
-{
-    DeleteCriticalSection(critical_section_cast(mutex));
-    delete critical_section_cast(mutex);
-}
-
-inline void delete_mutex(void* mutex)
-{
-    int res = 0;
-    res = CloseHandle(mutex_cast(mutex));
-    assert(res);
-}
-
-inline void wait_critical_section_infinite(void* mutex)
-{
-    EnterCriticalSection(critical_section_cast(mutex)); //:xxx Can throw an exception under low memory conditions
-}
-
-inline bool wait_critical_section_try(void* mutex)
-{
-    BOOL res = g_TryEnterCriticalSection(critical_section_cast(mutex));
-    return res != 0;
-}
-
-inline int wait_mutex(void* mutex, int time)
-{
-    unsigned int res = 0;
-    res = WaitForSingleObject(mutex_cast(mutex), time);
-//:xxx    assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
-    return res;
-}
-
-inline void release_critical_section(void* mutex)
-{
-    LeaveCriticalSection(critical_section_cast(mutex));
-}
-
-inline void release_mutex(void* mutex)
-{
-    BOOL res = FALSE;
-    res = ReleaseMutex(mutex_cast(mutex));
-    assert(res);
-}
-#endif
-
-}

data/ext/boost/src/once.cpp

@@ -1,213 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/detail/workaround.hpp>
-
-#include <boost/thread/once.hpp>
-#include <cstdio>
-#include <cassert>
-
-
-#if defined(BOOST_HAS_WINTHREADS)
-#   if BOOST_WORKAROUND(__BORLANDC__,<= 0x551)
-      using std::size_t;
-#   endif
-#   include <windows.h>
-#   if defined(BOOST_NO_STRINGSTREAM)
-#       include <strstream>
-
-class unfreezer
-{
-public:
-    unfreezer(std::ostrstream& s) : m_stream(s) {}
-    ~unfreezer() { m_stream.freeze(false); }
-private:
-    std::ostrstream& m_stream;
-};
-
-#   else
-#       include <sstream>
-#   endif
-#elif defined(BOOST_HAS_MPTASKS)
-#   include <Multiprocessing.h>
-#endif
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::sprintf; }
-#endif
-
-#if defined(BOOST_HAS_PTHREADS)
-namespace {
-pthread_key_t key;
-pthread_once_t once = PTHREAD_ONCE_INIT;
-
-typedef void (*once_callback)();
-}
-
-extern "C" {
-
-    static void key_init()
-    {
-        pthread_key_create(&key, 0);
-    }
-
-    static void do_once()
-    {
-        once_callback* cb = reinterpret_cast<once_callback*>(
-            pthread_getspecific(key));
-        (**cb)();
-    }
-
-}
-#elif defined(BOOST_HAS_MPTASKS)
-namespace {
-void *remote_call_proxy(void *pData)
-{
-    std::pair<void (*)(), boost::once_flag *> &rData(
-        *reinterpret_cast<std::pair<void (*)(), boost::once_flag *> *>(pData));
-
-    if(*rData.second == false)
-    {
-        rData.first();
-        *rData.second = true;
-    }
-
-    return(NULL);
-}
-}
-
-#elif defined(BOOST_HAS_WINTHREADS)
-namespace {
-// The signature for InterlockedCompareExchange has changed with the
-// addition of Win64 support. I can't determine any (consistent and
-// portable) way of using conditional compilation to detect this, so
-// we use these type wrappers.  Unfortunately, the various vendors
-// use different calling conventions and other signature anamolies,
-// and thus have unique types as well.  This is known to work on VC6,
-// VC7, Borland 5.5.2 and gcc 3.2.  Are there other signatures for
-// other platforms?
-inline LONG ice_wrapper(LONG (__stdcall *ice)(LONG*, LONG, LONG),
-    volatile LONG* dest, LONG exch, LONG cmp)
-{
-    return (*ice)(const_cast<LONG*>(dest), exch, cmp);
-}
-
-inline LONG ice_wrapper(LONG (__stdcall *ice)(volatile LONG*, LONG, LONG),
-    volatile LONG* dest, LONG exch, LONG cmp)
-{
-    return (*ice)(dest, exch, cmp);
-}
-
-inline LONG ice_wrapper(LPVOID (__stdcall *ice)(LPVOID*, LPVOID, LPVOID),
-    volatile LONG* dest, LONG exch, LONG cmp)
-{
-    return (LONG)(*ice)((LPVOID*)dest, (LPVOID)exch, (LPVOID)cmp);
-}
-
-// The friendly form of InterlockedCompareExchange that defers
-// according to the above function type wrappers.
-inline LONG compare_exchange(volatile LPLONG dest, LONG exch, LONG cmp)
-{
-#ifdef _WIN64
-    // Original patch from Anthony Williams.
-    // I (Roland Schwarz) am trying this for RC_1_34_0, since x64 regressions are
-    // currently not run on x64 platforms for HEAD
-    return InterlockedCompareExchange(dest, exch,cmp);
-#else    
-    return ice_wrapper(&InterlockedCompareExchange, dest, exch, cmp);
-#endif
-}
-}
-#endif
-
-namespace boost {
-
-void call_once(void (*func)(), once_flag& flag)
-{
-#if defined(BOOST_HAS_WINTHREADS)
-    if (compare_exchange(&flag, 1, 1) == 0)
-    {
-#if defined(BOOST_NO_STRINGSTREAM)
-        std::ostrstream strm;
-        strm << "2AC1A572DB6944B0A65C38C4140AF2F4" 
-             << std::hex
-             << GetCurrentProcessId() 
-             << &flag 
-             << std::ends;
-        unfreezer unfreeze(strm);
-#   if defined (BOOST_NO_ANSI_APIS)
-        USES_CONVERSION;
-        HANDLE mutex = CreateMutexW(NULL, FALSE, A2CW(strm.str()));
-#   else
-        HANDLE mutex = CreateMutexA(NULL, FALSE, strm.str());
-#   endif
-#else
-#   if defined (BOOST_NO_ANSI_APIS)
-        std::wostringstream strm;
-        strm << L"2AC1A572DB6944B0A65C38C4140AF2F4" 
-             << std::hex
-             << GetCurrentProcessId() 
-             << &flag;
-        HANDLE mutex = CreateMutexW(NULL, FALSE, strm.str().c_str());
-#   else
-        std::ostringstream strm;
-        strm << "2AC1A572DB6944B0A65C38C4140AF2F4" 
-             << std::hex
-             << GetCurrentProcessId() 
-             << &flag;
-        HANDLE mutex = CreateMutexA(NULL, FALSE, strm.str().c_str());
-#   endif
-#endif
-        assert(mutex != NULL);
-
-        int res = 0;
-        res = WaitForSingleObject(mutex, INFINITE);
-        assert(res == WAIT_OBJECT_0);
-
-        if (compare_exchange(&flag, 1, 1) == 0)
-        {
-            try
-            {
-                func();
-            }
-            catch (...)
-            {
-                res = ReleaseMutex(mutex);
-                assert(res);
-                res = CloseHandle(mutex);
-                assert(res);
-                throw;
-            }
-            InterlockedExchange(&flag, 1);
-        }
-
-        res = ReleaseMutex(mutex);
-        assert(res);
-        res = CloseHandle(mutex);
-        assert(res);
-    }
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_once(&once, &key_init);
-    pthread_setspecific(key, &func);
-    pthread_once(&flag, do_once);
-#elif defined(BOOST_HAS_MPTASKS)
-    if(flag == false)
-    {
-        // all we do here is make a remote call to blue, as blue is not
-        // reentrant.
-        std::pair<void (*)(), once_flag *> sData(func, &flag);
-        MPRemoteCall(remote_call_proxy, &sData, kMPOwningProcessRemoteContext);
-        assert(flag == true);
-    }
-#endif
-}
-
-}
-
-// Change Log:
-//   1 Aug 01  WEKEMPF Initial version.

data/ext/boost/src/recursive_mutex.cpp

@@ -1,1040 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/thread/recursive_mutex.hpp>
-#include <boost/thread/xtime.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/limits.hpp>
-#include <string>
-#include <stdexcept>
-#include <cassert>
-#include "timeconv.inl"
-
-#if defined(BOOST_HAS_WINTHREADS)
-#   include <new>
-#   include <boost/thread/once.hpp>
-#   include <windows.h>
-#   include <time.h>
-#   include "mutex.inl"
-#elif defined(BOOST_HAS_PTHREADS)
-#   include <errno.h>
-#elif defined(BOOST_HAS_MPTASKS)
-#   include <MacErrors.h>
-#   include "safe.hpp"
-#endif
-
-namespace boost {
-
-#if defined(BOOST_HAS_WINTHREADS)
-
-recursive_mutex::recursive_mutex()
-    : m_mutex(0)
-    , m_critical_section(false)
-    , m_count(0)
-{
-    m_critical_section = true;
-    if (m_critical_section)
-        m_mutex = new_critical_section();
-    else
-        m_mutex = new_mutex(0);
-}
-
-recursive_mutex::~recursive_mutex()
-{
-    if (m_critical_section)
-        delete_critical_section(m_mutex);
-    else
-        delete_mutex(m_mutex);
-}
-
-void recursive_mutex::do_lock()
-{
-    if (m_critical_section)
-        wait_critical_section_infinite(m_mutex);
-    else
-        wait_mutex(m_mutex, INFINITE);
-
-    if (++m_count > 1)
-    {
-        if (m_critical_section)
-            release_critical_section(m_mutex);
-        else
-            release_mutex(m_mutex);
-    }
-}
-
-void recursive_mutex::do_unlock()
-{
-    if (--m_count == 0)
-    {
-        if (m_critical_section)
-            release_critical_section(m_mutex);
-        else
-            release_mutex(m_mutex);
-    }
-}
-
-void recursive_mutex::do_lock(cv_state& state)
-{
-    if (m_critical_section)
-        wait_critical_section_infinite(m_mutex);
-    else
-        wait_mutex(m_mutex, INFINITE);
-
-    m_count = state;
-}
-
-void recursive_mutex::do_unlock(cv_state& state)
-{
-    state = m_count;
-    m_count = 0;
-
-    if (m_critical_section)
-        release_critical_section(m_mutex);
-    else
-        release_mutex(m_mutex);
-}
-
-recursive_try_mutex::recursive_try_mutex()
-    : m_mutex(0)
-    , m_critical_section(false)
-    , m_count(0)
-{
-    m_critical_section = has_TryEnterCriticalSection();
-    if (m_critical_section)
-        m_mutex = new_critical_section();
-    else
-        m_mutex = new_mutex(0);
-}
-
-recursive_try_mutex::~recursive_try_mutex()
-{
-    if (m_critical_section)
-        delete_critical_section(m_mutex);
-    else
-        delete_mutex(m_mutex);
-}
-
-void recursive_try_mutex::do_lock()
-{
-    if (m_critical_section)
-        wait_critical_section_infinite(m_mutex);
-    else
-        wait_mutex(m_mutex, INFINITE);
-
-    if (++m_count > 1)
-    {
-        if (m_critical_section)
-            release_critical_section(m_mutex);
-        else
-            release_mutex(m_mutex);
-    }
-}
-
-bool recursive_try_mutex::do_trylock()
-{
-    bool res = false;
-    if (m_critical_section)
-        res = wait_critical_section_try(m_mutex);
-    else
-        res = wait_mutex(m_mutex, 0) == WAIT_OBJECT_0;
-
-    if (res)
-    {
-        if (++m_count > 1)
-        {
-            if (m_critical_section)
-                release_critical_section(m_mutex);
-            else
-                release_mutex(m_mutex);
-        }
-        return true;
-    }
-    return false;
-}
-
-void recursive_try_mutex::do_unlock()
-{
-    if (--m_count == 0)
-    {
-        if (m_critical_section)
-            release_critical_section(m_mutex);
-        else
-            release_mutex(m_mutex);
-    }
-}
-
-void recursive_try_mutex::do_lock(cv_state& state)
-{
-    if (m_critical_section)
-        wait_critical_section_infinite(m_mutex);
-    else
-        wait_mutex(m_mutex, INFINITE);
-
-    m_count = state;
-}
-
-void recursive_try_mutex::do_unlock(cv_state& state)
-{
-    state = m_count;
-    m_count = 0;
-
-    if (m_critical_section)
-        release_critical_section(m_mutex);
-    else
-        release_mutex(m_mutex);
-}
-
-recursive_timed_mutex::recursive_timed_mutex()
-    : m_mutex(0)
-    , m_count(0)
-{
-    m_mutex = new_mutex(0);
-}
-
-recursive_timed_mutex::~recursive_timed_mutex()
-{
-    delete_mutex(m_mutex);
-}
-
-void recursive_timed_mutex::do_lock()
-{
-    wait_mutex(m_mutex, INFINITE);
-
-    if (++m_count > 1)
-        release_mutex(m_mutex);
-}
-
-bool recursive_timed_mutex::do_trylock()
-{
-    bool res = wait_mutex(m_mutex, 0) == WAIT_OBJECT_0;
-
-    if (res)
-    {
-        if (++m_count > 1)
-            release_mutex(m_mutex);
-        return true;
-    }
-    return false;
-}
-
-bool recursive_timed_mutex::do_timedlock(const xtime& xt)
-{
-    for (;;)
-    {
-        int milliseconds;
-        to_duration(xt, milliseconds);
-
-        unsigned int res = wait_mutex(m_mutex, milliseconds);
-
-        if (res == WAIT_TIMEOUT)
-        {
-            xtime cur;
-            xtime_get(&cur, TIME_UTC);
-            if (xtime_cmp(xt, cur) > 0)
-                continue;
-        }
-
-        if (res == WAIT_OBJECT_0)
-        {
-            if (++m_count > 1)
-                release_mutex(m_mutex);
-            return true;
-        }
-
-        return false;
-    }
-}
-
-void recursive_timed_mutex::do_unlock()
-{
-    if (--m_count == 0)
-        release_mutex(m_mutex);
-}
-
-void recursive_timed_mutex::do_lock(cv_state& state)
-{
-    wait_mutex(m_mutex, INFINITE);
-
-    m_count = state;
-}
-
-void recursive_timed_mutex::do_unlock(cv_state& state)
-{
-    state = m_count;
-    m_count = 0;
-
-    release_mutex(m_mutex);
-}
-
-#elif defined(BOOST_HAS_PTHREADS)
-
-recursive_mutex::recursive_mutex()
-    : m_count(0)
-#   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    , m_valid_id(false)
-#   endif
-{
-    pthread_mutexattr_t attr;
-    int res = pthread_mutexattr_init(&attr);
-    assert(res == 0);
-
-#   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    res = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-    assert(res == 0);
-#   endif
-
-    res = pthread_mutex_init(&m_mutex, &attr);
-    {
-        int res = 0;
-        res = pthread_mutexattr_destroy(&attr);
-        assert(res == 0);
-    }
-    if (res != 0)
-        throw thread_resource_error();
-
-#   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    res = pthread_cond_init(&m_unlocked, 0);
-    if (res != 0)
-    {
-        pthread_mutex_destroy(&m_mutex);
-        throw thread_resource_error();
-    }
-#   endif
-}
-
-recursive_mutex::~recursive_mutex()
-{
-    int res = 0;
-    res = pthread_mutex_destroy(&m_mutex);
-    assert(res == 0);
-
-#   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    res = pthread_cond_destroy(&m_unlocked);
-    assert(res == 0);
-#   endif
-}
-
-void recursive_mutex::do_lock()
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-#   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    if (++m_count > 1)
-    {
-        res = pthread_mutex_unlock(&m_mutex);
-        assert(res == 0);
-    }
-#   else
-    pthread_t tid = pthread_self();
-    if (m_valid_id && pthread_equal(m_thread_id, tid))
-        ++m_count;
-    else
-    {
-        while (m_valid_id)
-        {
-            res = pthread_cond_wait(&m_unlocked, &m_mutex);
-            assert(res == 0);
-        }
-
-        m_thread_id = tid;
-        m_valid_id = true;
-        m_count = 1;
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-#   endif
-}
-
-void recursive_mutex::do_unlock()
-{
-#   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    if (--m_count == 0)
-    {
-        int res = 0;
-        res = pthread_mutex_unlock(&m_mutex);
-        assert(res == 0);
-    }
-#   else
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    pthread_t tid = pthread_self();
-    if (m_valid_id && !pthread_equal(m_thread_id, tid))
-    {
-        res = pthread_mutex_unlock(&m_mutex);
-        assert(res == 0);
-        throw lock_error();
-    }
-
-    if (--m_count == 0)
-    {
-        assert(m_valid_id);
-        m_valid_id = false;
-
-        res = pthread_cond_signal(&m_unlocked);
-        assert(res == 0);
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-#   endif
-}
-
-void recursive_mutex::do_lock(cv_state& state)
-{
-#   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    m_count = state.count;
-#   else
-    int res = 0;
-
-    while (m_valid_id)
-    {
-        res = pthread_cond_wait(&m_unlocked, &m_mutex);
-        assert(res == 0);
-    }
-
-    m_thread_id = pthread_self();
-    m_valid_id = true;
-    m_count = state.count;
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-#   endif
-}
-
-void recursive_mutex::do_unlock(cv_state& state)
-{
-#   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    assert(m_valid_id);
-    m_valid_id = false;
-
-    res = pthread_cond_signal(&m_unlocked);
-    assert(res == 0);
-#   endif
-
-    state.pmutex = &m_mutex;
-    state.count = m_count;
-    m_count = 0;
-}
-
-recursive_try_mutex::recursive_try_mutex()
-    : m_count(0)
-#   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    , m_valid_id(false)
-#   endif
-{
-    pthread_mutexattr_t attr;
-    int res = pthread_mutexattr_init(&attr);
-    assert(res == 0);
-
-#   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    res = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-    assert(res == 0);
-#   endif
-
-    res = pthread_mutex_init(&m_mutex, &attr);
-    {
-        int res = 0;
-        res = pthread_mutexattr_destroy(&attr);
-        assert(res == 0);
-    }
-    if (res != 0)
-        throw thread_resource_error();
-
-#   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    res = pthread_cond_init(&m_unlocked, 0);
-    if (res != 0)
-    {
-        pthread_mutex_destroy(&m_mutex);
-        throw thread_resource_error();
-    }
-#   endif
-}
-
-recursive_try_mutex::~recursive_try_mutex()
-{
-    int res = 0;
-    res = pthread_mutex_destroy(&m_mutex);
-    assert(res == 0);
-
-#   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    res = pthread_cond_destroy(&m_unlocked);
-    assert(res == 0);
-#   endif
-}
-
-void recursive_try_mutex::do_lock()
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-#   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    if (++m_count > 1)
-    {
-        res = pthread_mutex_unlock(&m_mutex);
-        assert(res == 0);
-    }
-#   else
-    pthread_t tid = pthread_self();
-    if (m_valid_id && pthread_equal(m_thread_id, tid))
-        ++m_count;
-    else
-    {
-        while (m_valid_id)
-        {
-            res = pthread_cond_wait(&m_unlocked, &m_mutex);
-            assert(res == 0);
-        }
-
-        m_thread_id = tid;
-        m_valid_id = true;
-        m_count = 1;
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-#   endif
-}
-
-bool recursive_try_mutex::do_trylock()
-{
-#   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    int res = 0;
-    res = pthread_mutex_trylock(&m_mutex);
-    assert(res == 0 || res == EBUSY);
-
-    if (res == 0)
-    {
-        if (++m_count > 1)
-        {
-            res = pthread_mutex_unlock(&m_mutex);
-            assert(res == 0);
-        }
-        return true;
-    }
-
-    return false;
-#   else
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    bool ret = false;
-    pthread_t tid = pthread_self();
-    if (m_valid_id && pthread_equal(m_thread_id, tid))
-    {
-        ++m_count;
-        ret = true;
-    }
-    else if (!m_valid_id)
-    {
-        m_thread_id = tid;
-        m_valid_id = true;
-        m_count = 1;
-        ret = true;
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-    return ret;
-#   endif
-}
-
-void recursive_try_mutex::do_unlock()
-{
-#   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    if (--m_count == 0)
-    {
-        int res = 0;
-        res = pthread_mutex_unlock(&m_mutex);
-        assert(res == 0);
-    }
-#   else
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    pthread_t tid = pthread_self();
-    if (m_valid_id && !pthread_equal(m_thread_id, tid))
-    {
-        res = pthread_mutex_unlock(&m_mutex);
-        assert(res == 0);
-        throw lock_error();
-    }
-
-    if (--m_count == 0)
-    {
-        assert(m_valid_id);
-        m_valid_id = false;
-
-        res = pthread_cond_signal(&m_unlocked);
-        assert(res == 0);
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-#   endif
-}
-
-void recursive_try_mutex::do_lock(cv_state& state)
-{
-#   if defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    m_count = state.count;
-#   else
-    int res = 0;
-
-    while (m_valid_id)
-    {
-        res = pthread_cond_wait(&m_unlocked, &m_mutex);
-        assert(res == 0);
-    }
-
-    m_thread_id = pthread_self();
-    m_valid_id = true;
-    m_count = state.count;
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-#   endif
-}
-
-void recursive_try_mutex::do_unlock(cv_state& state)
-{
-#   if !defined(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE)
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    assert(m_valid_id);
-    m_valid_id = false;
-
-    res = pthread_cond_signal(&m_unlocked);
-    assert(res == 0);
-#   endif
-
-    state.pmutex = &m_mutex;
-    state.count = m_count;
-    m_count = 0;
-}
-
-recursive_timed_mutex::recursive_timed_mutex()
-    : m_valid_id(false), m_count(0)
-{
-    int res = 0;
-    res = pthread_mutex_init(&m_mutex, 0);
-    if (res != 0)
-        throw thread_resource_error();
-
-    res = pthread_cond_init(&m_unlocked, 0);
-    if (res != 0)
-    {
-        pthread_mutex_destroy(&m_mutex);
-        throw thread_resource_error();
-    }
-}
-
-recursive_timed_mutex::~recursive_timed_mutex()
-{
-    int res = 0;
-    res = pthread_mutex_destroy(&m_mutex);
-    assert(res == 0);
-
-    res = pthread_cond_destroy(&m_unlocked);
-    assert(res == 0);
-}
-
-void recursive_timed_mutex::do_lock()
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    pthread_t tid = pthread_self();
-    if (m_valid_id && pthread_equal(m_thread_id, tid))
-        ++m_count;
-    else
-    {
-        while (m_valid_id)
-        {
-            res = pthread_cond_wait(&m_unlocked, &m_mutex);
-            assert(res == 0);
-        }
-
-        m_thread_id = tid;
-        m_valid_id = true;
-        m_count = 1;
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-}
-
-bool recursive_timed_mutex::do_trylock()
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    bool ret = false;
-    pthread_t tid = pthread_self();
-    if (m_valid_id && pthread_equal(m_thread_id, tid))
-    {
-        ++m_count;
-        ret = true;
-    }
-    else if (!m_valid_id)
-    {
-        m_thread_id = tid;
-        m_valid_id = true;
-        m_count = 1;
-        ret = true;
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-    return ret;
-}
-
-bool recursive_timed_mutex::do_timedlock(const xtime& xt)
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    bool ret = false;
-    pthread_t tid = pthread_self();
-    if (m_valid_id && pthread_equal(m_thread_id, tid))
-    {
-        ++m_count;
-        ret = true;
-    }
-    else
-    {
-        timespec ts;
-        to_timespec(xt, ts);
-
-        while (m_valid_id)
-        {
-            res = pthread_cond_timedwait(&m_unlocked, &m_mutex, &ts);
-            if (res == ETIMEDOUT)
-                break;
-            assert(res == 0);
-        }
-
-        if (!m_valid_id)
-        {
-            m_thread_id = tid;
-            m_valid_id = true;
-            m_count = 1;
-            ret = true;
-        }
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-    return ret;
-}
-
-void recursive_timed_mutex::do_unlock()
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    pthread_t tid = pthread_self();
-    if (m_valid_id && !pthread_equal(m_thread_id, tid))
-    {
-        res = pthread_mutex_unlock(&m_mutex);
-        assert(res == 0);
-        throw lock_error();
-    }
-
-    if (--m_count == 0)
-    {
-        assert(m_valid_id);
-        m_valid_id = false;
-
-        res = pthread_cond_signal(&m_unlocked);
-        assert(res == 0);
-    }
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-}
-
-void recursive_timed_mutex::do_lock(cv_state& state)
-{
-    int res = 0;
-
-    while (m_valid_id)
-    {
-        res = pthread_cond_wait(&m_unlocked, &m_mutex);
-        assert(res == 0);
-    }
-
-    m_thread_id = pthread_self();
-    m_valid_id = true;
-    m_count = state.count;
-
-    res = pthread_mutex_unlock(&m_mutex);
-    assert(res == 0);
-}
-
-void recursive_timed_mutex::do_unlock(cv_state& state)
-{
-    int res = 0;
-    res = pthread_mutex_lock(&m_mutex);
-    assert(res == 0);
-
-    assert(m_valid_id);
-    m_valid_id = false;
-
-    res = pthread_cond_signal(&m_unlocked);
-    assert(res == 0);
-
-    state.pmutex = &m_mutex;
-    state.count = m_count;
-    m_count = 0;
-}
-#elif defined(BOOST_HAS_MPTASKS)
-
-using threads::mac::detail::safe_enter_critical_region;
-
-
-recursive_mutex::recursive_mutex()
-    : m_count(0)
-{
-}
-
-recursive_mutex::~recursive_mutex()
-{
-}
-
-void recursive_mutex::do_lock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-
-    if (++m_count > 1)
-    {
-        lStatus = MPExitCriticalRegion(m_mutex);
-        assert(lStatus == noErr);
-    }
-}
-
-void recursive_mutex::do_unlock()
-{
-    if (--m_count == 0)
-    {
-        OSStatus lStatus = noErr;
-        lStatus = MPExitCriticalRegion(m_mutex);
-        assert(lStatus == noErr);
-    }
-}
-
-void recursive_mutex::do_lock(cv_state& state)
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-
-    m_count = state;
-}
-
-void recursive_mutex::do_unlock(cv_state& state)
-{
-    state = m_count;
-    m_count = 0;
-
-    OSStatus lStatus = noErr;
-    lStatus = MPExitCriticalRegion(m_mutex);
-    assert(lStatus == noErr);
-}
-
-recursive_try_mutex::recursive_try_mutex()
-    : m_count(0)
-{
-}
-
-recursive_try_mutex::~recursive_try_mutex()
-{
-}
-
-void recursive_try_mutex::do_lock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-
-    if (++m_count > 1)
-    {
-        lStatus = MPExitCriticalRegion(m_mutex);
-        assert(lStatus == noErr);
-    }
-}
-
-bool recursive_try_mutex::do_trylock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = MPEnterCriticalRegion(m_mutex, kDurationImmediate);
-    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
-
-    if (lStatus == noErr)
-    {
-        if (++m_count > 1)
-        {
-            lStatus = MPExitCriticalRegion(m_mutex);
-            assert(lStatus == noErr);
-        }
-        return true;
-    }
-    return false;
-}
-
-void recursive_try_mutex::do_unlock()
-{
-    if (--m_count == 0)
-    {
-        OSStatus lStatus = noErr;
-        lStatus = MPExitCriticalRegion(m_mutex);
-        assert(lStatus == noErr);
-    }
-}
-
-void recursive_try_mutex::do_lock(cv_state& state)
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-
-    m_count = state;
-}
-
-void recursive_try_mutex::do_unlock(cv_state& state)
-{
-    state = m_count;
-    m_count = 0;
-
-    OSStatus lStatus = noErr;
-    lStatus = MPExitCriticalRegion(m_mutex);
-    assert(lStatus == noErr);
-}
-
-recursive_timed_mutex::recursive_timed_mutex()
-    : m_count(0)
-{
-}
-
-recursive_timed_mutex::~recursive_timed_mutex()
-{
-}
-
-void recursive_timed_mutex::do_lock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-
-    if (++m_count > 1)
-    {
-        lStatus = MPExitCriticalRegion(m_mutex);
-        assert(lStatus == noErr);
-    }
-}
-
-bool recursive_timed_mutex::do_trylock()
-{
-    OSStatus lStatus = noErr;
-    lStatus = MPEnterCriticalRegion(m_mutex, kDurationImmediate);
-    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
-
-    if (lStatus == noErr)
-    {
-        if (++m_count > 1)
-        {
-            lStatus = MPExitCriticalRegion(m_mutex);
-            assert(lStatus == noErr);
-        }
-        return true;
-    }
-    return false;
-}
-
-bool recursive_timed_mutex::do_timedlock(const xtime& xt)
-{
-    int microseconds;
-    to_microduration(xt, microseconds);
-    Duration lDuration = kDurationMicrosecond * microseconds;
-
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, lDuration, m_mutex_mutex);
-    assert(lStatus == noErr || lStatus == kMPTimeoutErr);
-
-    if (lStatus == noErr)
-    {
-        if (++m_count > 1)
-        {
-            lStatus = MPExitCriticalRegion(m_mutex);
-            assert(lStatus == noErr);
-        }
-        return true;
-    }
-    return false;
-}
-
-void recursive_timed_mutex::do_unlock()
-{
-    if (--m_count == 0)
-    {
-        OSStatus lStatus = noErr;
-        lStatus = MPExitCriticalRegion(m_mutex);
-        assert(lStatus == noErr);
-    }
-}
-
-void recursive_timed_mutex::do_lock(cv_state& state)
-{
-    OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
-    assert(lStatus == noErr);
-
-    m_count = state;
-}
-
-void recursive_timed_mutex::do_unlock(cv_state& state)
-{
-    state = m_count;
-    m_count = 0;
-
-    OSStatus lStatus = noErr;
-    lStatus = MPExitCriticalRegion(m_mutex);
-    assert(lStatus == noErr);
-}
-#endif
-
-} // namespace boost
-
-// Change Log:
-//   8 Feb 01  WEKEMPF Initial version.