This commit was manufactured by cvs2svn to create tag

'Version_1_32_0'.

[SVN r26264]

include/boost/detail/atomic_count.hpp

@@ -73,6 +73,9 @@
 //      are called driven by smart_ptr interface...
 //
 
+//  Note: atomic_count_linux.hpp has been disabled by default; see the
+//        comments inside for more info.
+
 #include <boost/config.hpp>
 
 #ifndef BOOST_HAS_THREADS
@@ -89,11 +92,13 @@ typedef long atomic_count;
 
 }
 
+#elif defined(BOOST_USE_ASM_ATOMIC_H)
+#  include <boost/detail/atomic_count_linux.hpp>
 #elif defined(BOOST_AC_USE_PTHREADS)
 #  include <boost/detail/atomic_count_pthreads.hpp>
 #elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
 #  include <boost/detail/atomic_count_win32.hpp>
-#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+#elif defined(__GLIBCPP__)
 #  include <boost/detail/atomic_count_gcc.hpp>
 #elif defined(BOOST_HAS_PTHREADS)
 #  define BOOST_AC_USE_PTHREADS

include/boost/detail/atomic_count_gcc.hpp

@@ -10,7 +10,6 @@
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2002 Lars Gullik Bj<42>nnes <larsbj@lyx.org>
-//  Copyright 2003-2005 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -25,13 +24,6 @@ namespace boost
 namespace detail
 {
 
-#if defined(__GLIBCXX__) // g++ 3.4+
-
-using __gnu_cxx::__atomic_add;
-using __gnu_cxx::__exchange_and_add;
-
-#endif
-
 class atomic_count
 {
 public:

include/boost/detail/atomic_count_linux.hpp

@@ -0,0 +1,69 @@
+#ifndef BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED
+#define BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED
+
+//
+//  boost/detail/atomic_count_linux.hpp
+//
+//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//
+// 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)
+//
+
+//
+//  This implementation uses <asm/atomic.h>. This is a kernel header;
+//  using kernel headers in a user program may cause a number of problems,
+//  and not all flavors of Linux provide the atomic instructions.
+//
+//  This file is only provided because the performance of this implementation
+//  is significantly higher than the pthreads version. Use at your own risk
+//  (by defining BOOST_USE_ASM_ATOMIC_H.)
+//
+
+#include <asm/atomic.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class atomic_count
+{
+public:
+
+    explicit atomic_count(long v)
+    {
+        atomic_t init = ATOMIC_INIT(v);
+        value_ = init;
+    }
+
+    void operator++()
+    {
+        atomic_inc(&value_);
+    }
+
+    long operator--()
+    {
+        return !atomic_dec_and_test(&value_);
+    }
+
+    operator long() const
+    {
+        return atomic_read(&value_);
+    }
+
+private:
+
+    atomic_count(atomic_count const &);
+    atomic_count & operator=(atomic_count const &);
+
+    atomic_t value_;
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED

include/boost/detail/atomic_count_win32.hpp

@@ -10,14 +10,16 @@
 //
 //  boost/detail/atomic_count_win32.hpp
 //
-//  Copyright (c) 2001-2005 Peter Dimov
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov
 //
 // 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/detail/interlocked.hpp>
+#ifdef BOOST_USE_WINDOWS_H
+#  include <windows.h>
+#endif
 
 namespace boost
 {
@@ -25,35 +27,67 @@ namespace boost
 namespace detail
 {
 
+#ifndef BOOST_USE_WINDOWS_H
+
+#ifdef _WIN64
+
+// Intel 6.0 on Win64 version, posted by Tim Fenders to [boost-users]
+
+extern "C" long_type __cdecl _InterlockedIncrement(long volatile *);
+extern "C" long_type __cdecl _InterlockedDecrement(long volatile *);
+
+#pragma intrinsic(_InterlockedIncrement)
+#pragma intrinsic(_InterlockedDecrement)
+
+inline long InterlockedIncrement(long volatile * lp)
+{ 
+    return _InterlockedIncrement(lp);
+}
+
+inline long InterlockedDecrement(long volatile* lp)
+{ 
+    return _InterlockedDecrement(lp);
+}
+
+#else  // _WIN64
+
+extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement(long volatile *);
+extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement(long volatile *);
+
+#endif // _WIN64
+
+#endif // #ifndef BOOST_USE_WINDOWS_H
+
 class atomic_count
 {
 public:
 
-    explicit atomic_count( long v ): value_( v )
+    explicit atomic_count(long v): value_(v)
     {
     }
 
     long operator++()
     {
-        return BOOST_INTERLOCKED_INCREMENT( &value_ );
+        // Some older <windows.h> versions do not accept volatile
+        return InterlockedIncrement(const_cast<long*>(&value_));
     }
 
     long operator--()
     {
-        return BOOST_INTERLOCKED_DECREMENT( &value_ );
+        return InterlockedDecrement(const_cast<long*>(&value_));
     }
 
     operator long() const
     {
-        return static_cast<long const volatile &>( value_ );
+        return value_;
     }
 
 private:
 
-    atomic_count( atomic_count const & );
-    atomic_count & operator=( atomic_count const & );
+    atomic_count(atomic_count const &);
+    atomic_count & operator=(atomic_count const &);
 
-    long value_;
+    volatile long value_;
 };
 
 } // namespace detail

include/boost/detail/bad_weak_ptr.hpp

@@ -1,59 +0,0 @@
-#ifndef BOOST_BAD_WEAK_PTR_HPP_INCLUDED
-#define BOOST_BAD_WEAK_PTR_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/bad_weak_ptr.hpp
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//
-// 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 <exception>
-
-#ifdef __BORLANDC__
-# pragma warn -8026     // Functions with excep. spec. are not expanded inline
-#endif
-
-namespace boost
-{
-
-// The standard library that comes with Borland C++ 5.5.1, 5.6.4
-// defines std::exception and its members as having C calling
-// convention (-pc). When the definition of bad_weak_ptr
-// is compiled with -ps, the compiler issues an error.
-// Hence, the temporary #pragma option -pc below.
-
-#if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
-# pragma option push -pc
-#endif
-
-class bad_weak_ptr: public std::exception
-{
-public:
-
-    virtual char const * what() const throw()
-    {
-        return "boost::bad_weak_ptr";
-    }
-};
-
-#if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
-# pragma option pop
-#endif
-
-} // namespace boost
-
-#ifdef __BORLANDC__
-# pragma warn .8026     // Functions with excep. spec. are not expanded inline
-#endif
-
-#endif  // #ifndef BOOST_BAD_WEAK_PTR_HPP_INCLUDED

include/boost/detail/lightweight_mutex.hpp

@@ -18,21 +18,77 @@
 //
 //  typedef <unspecified> boost::detail::lightweight_mutex;
 //
-//  boost::detail::lightweight_mutex is a header-only implementation of
-//  a subset of the Mutex concept requirements:
+//  boost::detail::lightweight_mutex meets a subset of the Mutex concept
+//  requirements: http://www.boost.org/libs/thread/doc/mutex_concept.html#Mutex
 //
-//  http://www.boost.org/doc/html/threads/concepts.html#threads.concepts.Mutex
+//  * Used by the smart pointer library
+//  * Performance oriented
+//  * Header-only implementation
+//  * Small memory footprint
+//  * Not a general purpose mutex, use boost::mutex, CRITICAL_SECTION or
+//    pthread_mutex instead.
+//  * Never spin in a tight lock/do-something/unlock loop, since
+//    lightweight_mutex does not guarantee fairness.
+//  * Never keep a lightweight_mutex locked for long periods.
 //
-//  It maps to a CRITICAL_SECTION on Windows or a pthread_mutex on POSIX.
+//  The current implementation can use a pthread_mutex, a CRITICAL_SECTION,
+//  or a platform-specific spinlock.
 //
+//  You can force a particular implementation by defining BOOST_LWM_USE_PTHREADS,
+//  BOOST_LWM_USE_CRITICAL_SECTION, or BOOST_LWM_USE_SPINLOCK.
+//
+//  If neither macro has been defined, the default is to use a spinlock on Win32,
+//  and a pthread_mutex otherwise.
+//
+//  Note that a spinlock is not a general synchronization primitive. In particular,
+//  it is not guaranteed to be a memory barrier, and it is possible to "livelock"
+//  if a lower-priority thread has acquired the spinlock but a higher-priority
+//  thread is spinning trying to acquire the same lock.
+//
+//  For these reasons, spinlocks have been disabled by default except on Windows,
+//  where a spinlock can be several orders of magnitude faster than a CRITICAL_SECTION.
+
+
+//  Note: lwm_linux.hpp has been disabled by default; see the comments
+//        inside for more info.
+
 
 #include <boost/config.hpp>
 
+//  Note to implementors: if you write a platform-specific spinlock
+//  for a platform that supports pthreads, be sure to test its performance
+//  against the pthreads-based version using shared_ptr_timing_test.cpp and
+//  shared_ptr_mt_test.cpp. Custom versions are usually not worth the trouble
+//  _unless_ the performance gains are substantial.
+//
+//  Be sure to compare against a "real" pthreads library;
+//  shared_ptr_timing_test.cpp will compile succesfully with a stub do-nothing
+//  pthreads library, since it doesn't create any threads.
+
+#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__)) && !defined(BOOST_LWM_USE_CRITICAL_SECTION) && !defined(BOOST_LWM_USE_PTHREADS)
+# define BOOST_LWM_WIN32
+#endif
+
 #if !defined(BOOST_HAS_THREADS)
-# include <boost/detail/lwm_nop.hpp>
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+#  if defined(BOOST_LWM_WIN32)
+#    include <boost/detail/lwm_win32_nt.hpp>
+#  else
+#    include <boost/detail/lwm_nop.hpp>
+#  endif
+#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(BOOST_USE_ASM_ATOMIC_H)
+#  include <boost/detail/lwm_linux.hpp>
+#elif defined(BOOST_LWM_USE_CRITICAL_SECTION)
 #  include <boost/detail/lwm_win32_cs.hpp>
+#elif defined(BOOST_LWM_USE_PTHREADS)
+#  include <boost/detail/lwm_pthreads.hpp>
+#elif defined(BOOST_LWM_WIN32)
+#  include <boost/detail/lwm_win32.hpp>
+#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__sgi)
+#  include <boost/detail/lwm_irix.hpp>
+#elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__GLIBCPP__)
+#  include <boost/detail/lwm_gcc.hpp>
 #elif defined(BOOST_HAS_PTHREADS)
+#  define BOOST_LWM_USE_PTHREADS
 #  include <boost/detail/lwm_pthreads.hpp>
 #else
 // Use #define BOOST_DISABLE_THREADS to avoid the error

include/boost/detail/lwm_gcc.hpp

@@ -0,0 +1,77 @@
+#ifndef BOOST_DETAIL_LWM_GCC_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_GCC_HPP_INCLUDED
+
+//
+//  boost/detail/lwm_gcc.hpp
+//
+//  lightweight_mutex for GNU libstdc++ v3
+//
+//  http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2002 Lars Gullik Bj<42>nnes <larsbj@lyx.org>
+//
+//  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 <bits/atomicity.h>
+#include <sched.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    _Atomic_word a_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex(): a_(0)
+    {
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        lightweight_mutex & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex & m): m_(m)
+        {
+            while( __exchange_and_add(&m_.a_, 1) )
+            {
+                __atomic_add(&m_.a_, -1);
+                sched_yield();
+            }
+        }
+
+        ~scoped_lock()
+        {
+            __atomic_add(&m_.a_, -1);
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_GCC_HPP_INCLUDED

include/boost/detail/lwm_irix.hpp

@@ -0,0 +1,73 @@
+#ifndef BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED
+
+//
+//  boost/detail/lwm_irix.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2002 Dan Gohman
+//
+// 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 <sgidefs.h>
+#include <mutex.h>
+#include <sched.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    __uint32_t l_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex(): l_(0)
+    {
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        lightweight_mutex & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex & m): m_(m)
+        {
+            while( test_and_set32(&m_.l_, 1) )
+            {
+                sched_yield();
+            }
+        }
+
+        ~scoped_lock()
+        {
+            m_.l_ = 0;
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED

include/boost/detail/lwm_linux.hpp

@@ -0,0 +1,84 @@
+#ifndef BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED
+
+//
+//  boost/detail/lwm_linux.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+// 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)
+//
+
+//
+//  This implementation uses <asm/atomic.h>. This is a kernel header;
+//  using kernel headers in a user program may cause a number of problems,
+//  and not all flavors of Linux provide the atomic instructions.
+//
+//  This file is only provided because the performance of this implementation
+//  is about 3.5 times higher than the pthreads version. Use at your own risk
+//  (by defining BOOST_USE_ASM_ATOMIC_H.)
+//
+
+#include <asm/atomic.h>
+#include <sched.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    atomic_t a_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex()
+    {
+        atomic_t a = ATOMIC_INIT(1);
+        a_ = a;
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        lightweight_mutex & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex & m): m_(m)
+        {
+            while( !atomic_dec_and_test(&m_.a_) )
+            {
+                atomic_inc(&m_.a_);
+                sched_yield();
+            }
+        }
+
+        ~scoped_lock()
+        {
+            atomic_inc(&m_.a_);
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED

include/boost/detail/lwm_win32.hpp

@@ -0,0 +1,122 @@
+#ifndef BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/detail/lwm_win32.hpp
+//
+//  Copyright (c) 2002, 2003 Peter Dimov
+//
+// 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)
+//
+
+#ifdef BOOST_USE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+#ifdef __BORLANDC__
+# pragma warn -8027     // Functions containing while are not expanded inline
+#endif
+
+namespace boost
+{
+
+namespace detail
+{
+
+#ifndef BOOST_USE_WINDOWS_H
+
+#ifdef _WIN64
+
+// Intel 6.0 on Win64 version, posted by Tim Fenders to [boost-users]
+
+extern "C" long_type __cdecl _InterlockedExchange(long volatile *, long);
+
+#pragma intrinsic(_InterlockedExchange)
+
+inline long InterlockedExchange(long volatile* lp, long l)
+{
+    return _InterlockedExchange(lp, l);
+}
+
+#else  // _WIN64
+
+extern "C" __declspec(dllimport) long __stdcall InterlockedExchange(long volatile *, long);
+
+#endif // _WIN64
+
+extern "C" __declspec(dllimport) void __stdcall Sleep(unsigned long);
+
+#endif // #ifndef BOOST_USE_WINDOWS_H
+
+class lightweight_mutex
+{
+private:
+
+    long l_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex(): l_(0)
+    {
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        lightweight_mutex & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex & m): m_(m)
+        {
+            while( InterlockedExchange(&m_.l_, 1) )
+            {
+                // Note: changed to Sleep(1) from Sleep(0).
+                // According to MSDN, Sleep(0) will never yield
+                // to a lower-priority thread, whereas Sleep(1)
+                // will. Performance seems not to be affected.
+
+                Sleep(1);
+            }
+        }
+
+        ~scoped_lock()
+        {
+            InterlockedExchange(&m_.l_, 0);
+
+            // Note: adding a yield here will make
+            // the spinlock more fair and will increase the overall
+            // performance of some applications substantially in
+            // high contention situations, but will penalize the
+            // low contention / single thread case up to 5x
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#ifdef __BORLANDC__
+# pragma warn .8027     // Functions containing while are not expanded inline
+#endif
+
+#endif // #ifndef BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED

include/boost/detail/lwm_win32_nt.hpp

@@ -0,0 +1,63 @@
+#ifndef BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED
+#define BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/detail/lwm_win32_nt.hpp
+//
+//  Copyright (c) 2002, 2003 Peter Dimov
+//
+// 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)
+//
+//  "No threads" version of lwm_win32.hpp; binary compatible but no-op.
+//
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    long l_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex(): l_(0)
+    {
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        explicit scoped_lock(lightweight_mutex &)
+        {
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED

include/boost/detail/shared_count.hpp

@@ -11,35 +11,293 @@
 //  detail/shared_count.hpp
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
 //
 // 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)
 //
 
-#ifdef __BORLANDC__
-# pragma warn -8027     // Functions containing try are not expanded inline
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
 #endif
 
-#include <boost/config.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/detail/bad_weak_ptr.hpp>
-#include <boost/detail/sp_counted_base.hpp>
-#include <boost/detail/sp_counted_impl.hpp>
+#include <boost/detail/lightweight_mutex.hpp>
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+#include <boost/detail/quick_allocator.hpp>
+#endif
 
 #include <memory>           // std::auto_ptr, std::allocator
 #include <functional>       // std::less
+#include <exception>        // std::exception
 #include <new>              // std::bad_alloc
 #include <typeinfo>         // std::type_info in get_deleter
+#include <cstddef>          // std::size_t
+
+#ifdef __BORLANDC__
+# pragma warn -8026     // Functions with excep. spec. are not expanded inline
+# pragma warn -8027     // Functions containing try are not expanded inline
+#endif
 
 namespace boost
 {
 
+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_constructor_hook(void * px);
+void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_destructor_hook(void * px);
+
+#endif
+
+
+// The standard library that comes with Borland C++ 5.5.1
+// defines std::exception and its members as having C calling
+// convention (-pc). When the definition of bad_weak_ptr
+// is compiled with -ps, the compiler issues an error.
+// Hence, the temporary #pragma option -pc below. The version
+// check is deliberately conservative.
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option push -pc
+#endif
+
+class bad_weak_ptr: public std::exception
+{
+public:
+
+    virtual char const * what() const throw()
+    {
+        return "boost::bad_weak_ptr";
+    }
+};
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option pop
+#endif
+
 namespace detail
 {
 
+class sp_counted_base
+{
+private:
+
+    typedef detail::lightweight_mutex mutex_type;
+
+public:
+
+    sp_counted_base(): use_count_(1), weak_count_(1)
+    {
+    }
+
+    virtual ~sp_counted_base() // nothrow
+    {
+    }
+
+    // dispose() is called when use_count_ drops to zero, to release
+    // the resources managed by *this.
+
+    virtual void dispose() = 0; // nothrow
+
+    // destruct() is called when weak_count_ drops to zero.
+
+    virtual void destruct() // nothrow
+    {
+        delete this;
+    }
+
+    virtual void * get_deleter(std::type_info const & ti) = 0;
+
+    void add_ref_copy()
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        ++use_count_;
+    }
+
+    void add_ref_lock()
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        if(use_count_ == 0) boost::throw_exception(boost::bad_weak_ptr());
+        ++use_count_;
+    }
+
+    void release() // nothrow
+    {
+        {
+#if defined(BOOST_HAS_THREADS)
+            mutex_type::scoped_lock lock(mtx_);
+#endif
+            long new_use_count = --use_count_;
+
+            if(new_use_count != 0) return;
+        }
+
+        dispose();
+        weak_release();
+    }
+
+    void weak_add_ref() // nothrow
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        ++weak_count_;
+    }
+
+    void weak_release() // nothrow
+    {
+        long new_weak_count;
+
+        {
+#if defined(BOOST_HAS_THREADS)
+            mutex_type::scoped_lock lock(mtx_);
+#endif
+            new_weak_count = --weak_count_;
+        }
+
+        if(new_weak_count == 0)
+        {
+            destruct();
+        }
+    }
+
+    long use_count() const // nothrow
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        return use_count_;
+    }
+
+private:
+
+    sp_counted_base(sp_counted_base const &);
+    sp_counted_base & operator= (sp_counted_base const &);
+
+    long use_count_;        // #shared
+    long weak_count_;       // #weak + (#shared != 0)
+
+#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32)
+    mutable mutex_type mtx_;
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+{
+    boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+{
+    boost::sp_array_constructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+{
+    boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+{
+    boost::sp_array_destructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+#endif
+
+//
+// Borland's Codeguard trips up over the -Vx- option here:
+//
+#ifdef __CODEGUARD__
+# pragma option push -Vx-
+#endif
+
+template<class P, class D> class sp_counted_base_impl: public sp_counted_base
+{
+private:
+
+    P ptr; // copy constructor must not throw
+    D del; // copy constructor must not throw
+
+    sp_counted_base_impl(sp_counted_base_impl const &);
+    sp_counted_base_impl & operator= (sp_counted_base_impl const &);
+
+    typedef sp_counted_base_impl<P, D> this_type;
+
+public:
+
+    // pre: initial_use_count <= initial_weak_count, d(p) must not throw
+
+    sp_counted_base_impl(P p, D d): ptr(p), del(d)
+    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        detail::cbi_call_constructor_hook(this, p, d, 0);
+#endif
+    }
+
+    virtual void dispose() // nothrow
+    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        detail::cbi_call_destructor_hook(this, ptr, del, 0);
+#endif
+        del(ptr);
+    }
+
+    virtual void * get_deleter(std::type_info const & ti)
+    {
+        return ti == typeid(D)? &del: 0;
+    }
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR)
+
+    void * operator new(std::size_t)
+    {
+        return std::allocator<this_type>().allocate(1, static_cast<this_type *>(0));
+    }
+
+    void operator delete(void * p)
+    {
+        std::allocator<this_type>().deallocate(static_cast<this_type *>(p), 1);
+    }
+
+#endif
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+
+    void * operator new(std::size_t)
+    {
+        return quick_allocator<this_type>::alloc();
+    }
+
+    void operator delete(void * p)
+    {
+        quick_allocator<this_type>::dealloc(p);
+    }
+
+#endif
+};
+
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
 
 int const shared_count_id = 0x2C35F101;
@@ -70,36 +328,6 @@ public:
     {
     }
 
-    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-#ifndef BOOST_NO_EXCEPTIONS
-
-        try
-        {
-            pi_ = new sp_counted_impl_p<Y>( p );
-        }
-        catch(...)
-        {
-            boost::checked_delete( p );
-            throw;
-        }
-
-#else
-
-        pi_ = new sp_counted_impl_p<Y>( p );
-
-        if( pi_ == 0 )
-        {
-            boost::checked_delete( p );
-            boost::throw_exception( std::bad_alloc() );
-        }
-
-#endif
-    }
-
     template<class P, class D> shared_count(P p, D d): pi_(0)
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
@@ -109,7 +337,7 @@ public:
 
         try
         {
-            pi_ = new sp_counted_impl_pd<P, D>(p, d);
+            pi_ = new sp_counted_base_impl<P, D>(p, d);
         }
         catch(...)
         {
@@ -119,7 +347,7 @@ public:
 
 #else
 
-        pi_ = new sp_counted_impl_pd<P, D>(p, d);
+        pi_ = new sp_counted_base_impl<P, D>(p, d);
 
         if(pi_ == 0)
         {
@@ -135,20 +363,11 @@ public:
     // auto_ptr<Y> is special cased to provide the strong guarantee
 
     template<class Y>
-    explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
+    explicit shared_count(std::auto_ptr<Y> & r): pi_(new sp_counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>()))
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
     {
-#ifdef BOOST_NO_EXCEPTIONS
-
-        if( pi_ == 0 )
-        {
-            boost::throw_exception(std::bad_alloc());
-        }
-
-#endif
-
         r.release();
     }
 
@@ -156,7 +375,7 @@ public:
 
     ~shared_count() // nothrow
     {
-        if( pi_ != 0 ) pi_->release();
+        if(pi_ != 0) pi_->release();
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         id_ = 0;
 #endif
@@ -167,7 +386,7 @@ public:
         , id_(shared_count_id)
 #endif
     {
-        if( pi_ != 0 ) pi_->add_ref_copy();
+        if(pi_ != 0) pi_->add_ref_copy();
     }
 
     explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
@@ -176,10 +395,10 @@ public:
     {
         sp_counted_base * tmp = r.pi_;
 
-        if( tmp != pi_ )
+        if(tmp != pi_)
         {
-            if( tmp != 0 ) tmp->add_ref_copy();
-            if( pi_ != 0 ) pi_->release();
+            if(tmp != 0) tmp->add_ref_copy();
+            if(pi_ != 0) pi_->release();
             pi_ = tmp;
         }
 
@@ -210,15 +429,19 @@ public:
 
     friend inline bool operator<(shared_count const & a, shared_count const & b)
     {
-        return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
+        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
     }
 
     void * get_deleter(std::type_info const & ti) const
     {
-        return pi_? pi_->get_deleter( ti ): 0;
+        return pi_? pi_->get_deleter(ti): 0;
     }
 };
 
+#ifdef __CODEGUARD__
+# pragma option pop
+#endif
+
 
 class weak_count
 {
@@ -308,14 +531,18 @@ public:
     }
 };
 
-inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
+inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
 {
-    if( pi_ == 0 || !pi_->add_ref_lock() )
+    if(pi_ != 0)
     {
-        boost::throw_exception( boost::bad_weak_ptr() );
+        pi_->add_ref_lock();
+    }
+    else
+    {
+        boost::throw_exception(boost::bad_weak_ptr());
     }
 }
 
@@ -325,6 +552,7 @@ inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
 
 #ifdef __BORLANDC__
 # pragma warn .8027     // Functions containing try are not expanded inline
+# pragma warn .8026     // Functions with excep. spec. are not expanded inline
 #endif
 
 #endif  // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED

include/boost/detail/sp_counted_base.hpp

@@ -1,69 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/sp_counted_base.hpp
-//
-//  Copyright 2005 Peter Dimov
-//
-// 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/config.hpp>
-
-#if defined( BOOST_SP_DISABLE_THREADS )
-
-# include <boost/detail/sp_counted_base_nt.hpp>
-
-#elif defined( BOOST_SP_USE_PTHREADS )
-
-# include <boost/detail/sp_counted_base_pt.hpp>
-
-#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
-
-# include <boost/detail/sp_counted_base_gcc_x86.hpp>
-
-//~ #elif defined( __MWERKS__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
-
-//~ # include <boost/detail/sp_counted_base_cw_x86.hpp>
-
-#elif defined( __GNUC__ ) && defined( __ia64__ ) && !defined( __INTEL_COMPILER )
-
-# include <boost/detail/sp_counted_base_gcc_ia64.hpp>
-
-#elif defined( __MWERKS__ ) && defined( __POWERPC__ )
-
-# include <boost/detail/sp_counted_base_cw_ppc.hpp>
-
-#elif defined( __GNUC__ ) && ( defined( __powerpc__ ) || defined( __ppc__ ) )
-
-# include <boost/detail/sp_counted_base_gcc_ppc.hpp>
-
-#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
-
-# include <boost/detail/sp_counted_base_w32.hpp>
-
-#elif !defined( BOOST_HAS_THREADS )
-
-# include <boost/detail/sp_counted_base_nt.hpp>
-
-#elif defined( BOOST_HAS_PTHREADS )
-
-# include <boost/detail/sp_counted_base_pt.hpp>
-
-#else
-
-// Use #define BOOST_DISABLE_THREADS to avoid the error
-# error Unrecognized threading platform
-
-#endif
-
-#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED

include/boost/detail/sp_counted_base_cw_ppc.hpp

@@ -1,164 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_CW_PPC_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_CW_PPC_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/sp_counted_base_cw_ppc.hpp - CodeWarrior on PowerPC
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//
-//  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)
-//
-//
-//  Lock-free algorithm by Alexander Terekhov
-//
-//  Thanks to Ben Hitchings for the #weak + (#shared != 0)
-//  formulation
-//
-
-#include <typeinfo>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void atomic_increment( register long * pw )
-{
-    asm
-    {
-loop:
-
-    lwarx   r4, 0, r3
-    addi    r4, r4, 1
-    stwcx.  r4, 0, r3
-    bne-    loop
-    }
-}
-
-inline long atomic_decrement( register long * pw )
-{
-    asm
-    {
-    sync
-
-loop:
-
-    lwarx   r4, 0, r3
-    addi    r4, r4, -1
-    stwcx.  r4, 0, r3
-    bne-    loop
-
-    mr      r3, r4
-
-    isync
-    }
-}
-
-inline long atomic_conditional_increment( register long * pw )
-{
-    asm
-    {
-loop:
-
-    lwarx   r4, 0, r3
-    cmpwi   r4, 0
-    beq     store
-
-    addi    r4, r4, 1
-
-store:
-
-    stwcx.  r4, 0, r3
-    bne-    loop
-
-    mr      r3, r4
-    }
-}
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    long use_count_;        // #shared
-    long weak_count_;       // #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( std::type_info const & ti ) = 0;
-
-    void add_ref_copy()
-    {
-        atomic_increment( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        return atomic_conditional_increment( &use_count_ ) != 0;
-    }
-
-    void release() // nothrow
-    {
-        if( atomic_decrement( &use_count_ ) == 0 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        atomic_increment( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( atomic_decrement( &weak_count_ ) == 0 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return static_cast<long const volatile &>( use_count_ );
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_CW_PPC_HPP_INCLUDED

include/boost/detail/sp_counted_base_cw_x86.hpp

@@ -1,158 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_CW_X86_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_CW_X86_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/sp_counted_base_cw_x86.hpp - CodeWarrion on 486+
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//  Copyright 2005 Rene Rivera
-//
-//  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)
-//
-//
-//  Lock-free algorithm by Alexander Terekhov
-//
-//  Thanks to Ben Hitchings for the #weak + (#shared != 0)
-//  formulation
-//
-
-#include <typeinfo>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline int atomic_exchange_and_add( int * pw, int dv )
-{
-    // int r = *pw;
-    // *pw += dv;
-    // return r;
-
-    asm
-    {
-        mov esi, [pw]
-        mov eax, dv
-        lock xadd dword ptr [esi], eax
-    }
-}
-
-inline void atomic_increment( int * pw )
-{
-    //atomic_exchange_and_add( pw, 1 );
-
-    asm
-    {
-        mov esi, [pw]
-        lock inc dword ptr [esi]
-    }
-}
-
-inline int atomic_conditional_increment( int * pw )
-{
-    // int rv = *pw;
-    // if( rv != 0 ) ++*pw;
-    // return rv;
-
-    asm
-    {
-        mov esi, [pw]
-        mov eax, dword ptr [esi]
-    L0:
-        test eax, eax
-        je L1
-        mov ebx, eax
-        inc ebx
-        lock cmpxchg dword ptr [esi], ebx
-        jne L0
-    L1:
-    }
-}
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    int use_count_;        // #shared
-    int weak_count_;       // #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( std::type_info const & ti ) = 0;
-
-    void add_ref_copy()
-    {
-        atomic_increment( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        return atomic_conditional_increment( &use_count_ ) != 0;
-    }
-
-    void release() // nothrow
-    {
-        if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        atomic_increment( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return static_cast<int const volatile &>( use_count_ );
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED

include/boost/detail/sp_counted_base_gcc_ia64.hpp

@@ -1,157 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_IA64_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_GCC_IA64_HPP_INCLUDED
-
-//
-//  detail/sp_counted_base_gcc_ia64.hpp - g++ on IA64
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//  Copyright 2005 Ben Hutchings
-//
-//  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)
-//
-//
-//  Lock-free algorithm by Alexander Terekhov
-//
-
-#include <typeinfo>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void atomic_increment( long * pw )
-{
-    // ++*pw;
-
-    long tmp;
-
-    // No barrier is required here but fetchadd always has an acquire or
-    // release barrier associated with it.  We choose release as it should be
-    // cheaper.
-    __asm__ ("fetchadd8.rel %0=[%2],1" :
-         "=r"(tmp), "=m"(*pw) :
-         "r"(pw));
-}
-
-inline long atomic_decrement( long * pw )
-{
-    // return --*pw;
-
-    long rv;
-
-    __asm__ ("     fetchadd8.rel %0=[%2],-1 ;; \n"
-             "     cmp.eq        p7,p0=1,%0 ;; \n"
-             "(p7) ld8.acq       %0=[%2]    " :
-             "=&r"(rv), "=m"(*pw) :
-             "r"(pw) :
-             "p7");
-
-    return rv;
-}
-
-inline long atomic_conditional_increment( long * pw )
-{
-    // if( *pw != 0 ) ++*pw;
-    // return *pw;
-
-    long rv, tmp, tmp2;
-
-    __asm__ ("0:   ld8          %0=[%4]           ;; \n"
-         "     cmp.eq       p7,p0=0,%0        ;; \n"
-         "(p7) br.cond.spnt 1f                \n"
-         "     mov          ar.ccv=%0         \n"
-         "     add          %1=1,%0           ;; \n"
-         "     cmpxchg8.acq %2=[%4],%1,ar.ccv ;; \n"
-         "     cmp.ne       p7,p0=%0,%2       ;; \n"
-         "(p7) br.cond.spnt 0b                \n"
-         "     mov          %0=%1             ;; \n"
-         "1:" : 
-         "=&r"(rv), "=&r"(tmp), "=&r"(tmp2), "=m"(*pw) :
-         "r"(pw) :
-         "ar.ccv", "p7");
-
-    return rv;
-}
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    long use_count_;        // #shared
-    long weak_count_;       // #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( std::type_info const & ti ) = 0;
-
-    void add_ref_copy()
-    {
-        atomic_increment( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        return atomic_conditional_increment( &use_count_ ) != 0;
-    }
-
-    void release() // nothrow
-    {
-        if( atomic_decrement( &use_count_ ) == 0 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        atomic_increment( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( atomic_decrement( &weak_count_ ) == 0 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return static_cast<long const volatile &>( use_count_ );
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_IA64_HPP_INCLUDED

include/boost/detail/sp_counted_base_gcc_ppc.hpp

@@ -1,181 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_PPC_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_GCC_PPC_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/sp_counted_base_gcc_ppc.hpp - g++ on PowerPC
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//
-//  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)
-//
-//
-//  Lock-free algorithm by Alexander Terekhov
-//
-//  Thanks to Ben Hitchings for the #weak + (#shared != 0)
-//  formulation
-//
-
-#include <typeinfo>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void atomic_increment( long * pw )
-{
-    // ++*pw;
-
-    long tmp;
-
-    __asm__
-    (
-        "0:\n\t"
-        "lwarx %1, 0, %2\n\t"
-        "addi %1, %1, 1\n\t"
-        "stwcx. %1, 0, %2\n\t"
-        "bne- 0b":
-
-        "=m"( *pw ), "=&b"( tmp ):
-        "r"( pw ):
-        "cc"
-    );
-}
-
-inline long atomic_decrement( long * pw )
-{
-    // return --*pw;
-
-    long rv;
-
-    __asm__ __volatile__
-    (
-        "sync\n\t"
-        "0:\n\t"
-        "lwarx %1, 0, %2\n\t"
-        "addi %1, %1, -1\n\t"
-        "stwcx. %1, 0, %2\n\t"
-        "bne- 0b\n\t"
-        "isync":
-
-        "=m"( *pw ), "=&b"( rv ):
-        "r"( pw ):
-        "memory", "cc"
-    );
-
-    return rv;
-}
-
-inline long atomic_conditional_increment( long * pw )
-{
-    // if( *pw != 0 ) ++*pw;
-    // return *pw;
-
-    long rv;
-
-    __asm__
-    (
-        "0:\n\t"
-        "lwarx %1, 0, %2\n\t"
-        "cmpwi %1, 0\n\t"
-        "beq 1f\n\t"
-        "addi %1, %1, 1\n\t"
-        "1:\n\t"
-        "stwcx. %1, 0, %2\n\t"
-        "bne- 0b":
-
-        "=m"( *pw ), "=&b"( rv ):
-        "r"( pw ):
-        "cc"
-    );
-
-    return rv;
-}
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    long use_count_;        // #shared
-    long weak_count_;       // #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( std::type_info const & ti ) = 0;
-
-    void add_ref_copy()
-    {
-        atomic_increment( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        return atomic_conditional_increment( &use_count_ ) != 0;
-    }
-
-    void release() // nothrow
-    {
-        if( atomic_decrement( &use_count_ ) == 0 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        atomic_increment( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( atomic_decrement( &weak_count_ ) == 0 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return static_cast<long const volatile &>( use_count_ );
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_PPC_HPP_INCLUDED

include/boost/detail/sp_counted_base_gcc_x86.hpp

@@ -1,173 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/sp_counted_base_gcc_x86.hpp - g++ on 486+ or AMD64
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//
-//  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)
-//
-//
-//  Lock-free algorithm by Alexander Terekhov
-//
-//  Thanks to Ben Hitchings for the #weak + (#shared != 0)
-//  formulation
-//
-
-#include <typeinfo>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline int atomic_exchange_and_add( int * pw, int dv )
-{
-    // int r = *pw;
-    // *pw += dv;
-    // return r;
-
-    int r;
-
-    __asm__ __volatile__
-    (
-        "lock\n\t"
-        "xadd %1, %0":
-        "=m"( *pw ), "=r"( r ): // outputs (%0, %1)
-        "m"( *pw ), "1"( dv ): // inputs (%2, %3 == %1)
-        "memory", "cc" // clobbers
-    );
-
-    return r;
-}
-
-inline void atomic_increment( int * pw )
-{
-    //atomic_exchange_and_add( pw, 1 );
-
-    __asm__
-    (
-        "lock\n\t"
-        "incl %0":
-        "=m"( *pw ): // output (%0)
-        "m"( *pw ): // input (%1)
-        "cc" // clobbers
-    );
-}
-
-inline int atomic_conditional_increment( int * pw )
-{
-    // int rv = *pw;
-    // if( rv != 0 ) ++*pw;
-    // return rv;
-
-    int rv, tmp;
-
-    __asm__
-    (
-        "movl %0, %%eax\n\t"
-        "0:\n\t"
-        "test %%eax, %%eax\n\t"
-        "je 1f\n\t"
-        "movl %%eax, %2\n\t"
-        "incl %2\n\t"
-        "lock\n\t"
-        "cmpxchgl %2, %0\n\t"
-        "jne 0b\n\t"
-        "1:":
-        "=m"( *pw ), "=&a"( rv ), "=&r"( tmp ): // outputs (%0, %1, %2)
-        "m"( *pw ): // input (%3)
-        "cc" // clobbers
-    );
-
-    return rv;
-}
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    int use_count_;        // #shared
-    int weak_count_;       // #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( std::type_info const & ti ) = 0;
-
-    void add_ref_copy()
-    {
-        atomic_increment( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        return atomic_conditional_increment( &use_count_ ) != 0;
-    }
-
-    void release() // nothrow
-    {
-        if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        atomic_increment( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return static_cast<int const volatile &>( use_count_ );
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_X86_HPP_INCLUDED

include/boost/detail/sp_counted_base_nt.hpp

@@ -1,107 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_NT_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_NT_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/sp_counted_base_nt.hpp
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//
-// 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 <typeinfo>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    long use_count_;        // #shared
-    long weak_count_;       // #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( std::type_info const & ti ) = 0;
-
-    void add_ref_copy()
-    {
-        ++use_count_;
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        if( use_count_ == 0 ) return false;
-        ++use_count_;
-        return true;
-    }
-
-    void release() // nothrow
-    {
-        if( --use_count_ == 0 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        ++weak_count_;
-    }
-
-    void weak_release() // nothrow
-    {
-        if( --weak_count_ == 0 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return use_count_;
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_NT_HPP_INCLUDED

include/boost/detail/sp_counted_base_pt.hpp

@@ -1,135 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_PT_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_PT_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/sp_counted_base_pt.hpp
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//
-// 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 <typeinfo>
-#include <pthread.h>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    long use_count_;        // #shared
-    long weak_count_;       // #weak + (#shared != 0)
-
-    mutable pthread_mutex_t m_;
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-// HPUX 10.20 / DCE has a nonstandard pthread_mutex_init
-
-#if defined(__hpux) && defined(_DECTHREADS_)
-        pthread_mutex_init( &m_, pthread_mutexattr_default );
-#else
-        pthread_mutex_init( &m_, 0 );
-#endif
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-        pthread_mutex_destroy( &m_ );
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( std::type_info const & ti ) = 0;
-
-    void add_ref_copy()
-    {
-        pthread_mutex_lock( &m_ );
-        ++use_count_;
-        pthread_mutex_unlock( &m_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        pthread_mutex_lock( &m_ );
-        bool r = use_count_ == 0? false: ( ++use_count_, true );
-        pthread_mutex_unlock( &m_ );
-        return r;
-    }
-
-    void release() // nothrow
-    {
-        pthread_mutex_lock( &m_ );
-        long new_use_count = --use_count_;
-        pthread_mutex_unlock( &m_ );
-
-        if( new_use_count == 0 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        pthread_mutex_lock( &m_ );
-        ++weak_count_;
-        pthread_mutex_unlock( &m_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        pthread_mutex_lock( &m_ );
-        long new_weak_count = --weak_count_;
-        pthread_mutex_unlock( &m_ );
-
-        if( new_weak_count == 0 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        pthread_mutex_lock( &m_ );
-        long r = use_count_;
-        pthread_mutex_unlock( &m_ );
-
-        return r;
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_PT_HPP_INCLUDED

include/boost/detail/sp_counted_base_w32.hpp

@@ -1,117 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_BASE_W32_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_BASE_W32_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/sp_counted_base_w32.hpp
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//
-//  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)
-//
-//
-//  Lock-free algorithm by Alexander Terekhov
-//
-//  Thanks to Ben Hitchings for the #weak + (#shared != 0)
-//  formulation
-//
-
-#include <boost/detail/interlocked.hpp>
-#include <typeinfo>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    long use_count_;        // #shared
-    long weak_count_;       // #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( std::type_info const & ti ) = 0;
-
-    void add_ref_copy()
-    {
-        BOOST_INTERLOCKED_INCREMENT( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        for( ;; )
-        {
-            long tmp = static_cast< long const volatile& >( use_count_ );
-            if( tmp == 0 ) return false;
-            if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp + 1, tmp ) == tmp ) return true;
-        }
-    }
-
-    void release() // nothrow
-    {
-        if( BOOST_INTERLOCKED_DECREMENT( &use_count_ ) == 0 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        BOOST_INTERLOCKED_INCREMENT( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( BOOST_INTERLOCKED_DECREMENT( &weak_count_ ) == 0 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return static_cast<long const volatile &>( use_count_ );
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_W32_HPP_INCLUDED

include/boost/detail/sp_counted_impl.hpp

@@ -1,187 +0,0 @@
-#ifndef BOOST_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
-#define BOOST_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/sp_counted_impl.hpp
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//
-// 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/config.hpp>
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
-#endif
-
-#include <boost/checked_delete.hpp>
-#include <boost/detail/sp_counted_base.hpp>
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-#include <boost/detail/quick_allocator.hpp>
-#endif
-
-#include <memory>           // std::allocator
-#include <typeinfo>         // std::type_info in get_deleter
-#include <cstddef>          // std::size_t
-
-namespace boost
-{
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_scalar_constructor_hook( void * px, std::size_t size, void * pn );
-void sp_scalar_destructor_hook( void * px, std::size_t size, void * pn );
-
-#endif
-
-namespace detail
-{
-
-template<class X> class sp_counted_impl_p: public sp_counted_base
-{
-private:
-
-    X * px_;
-
-    sp_counted_impl_p( sp_counted_impl_p const & );
-    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
-
-    typedef sp_counted_impl_p<X> this_type;
-
-public:
-
-    explicit sp_counted_impl_p( X * px ): px_( px )
-    {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_scalar_constructor_hook( px, sizeof(X), this );
-#endif
-    }
-
-    virtual void dispose() // nothrow
-    {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_scalar_destructor_hook( px_, sizeof(X), this );
-#endif
-        boost::checked_delete( px_ );
-    }
-
-    virtual void * get_deleter( std::type_info const & )
-    {
-        return 0;
-    }
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR)
-
-    void * operator new( std::size_t )
-    {
-        return std::allocator<this_type>().allocate( 1, static_cast<this_type *>(0) );
-    }
-
-    void operator delete( void * p )
-    {
-        std::allocator<this_type>().deallocate( static_cast<this_type *>(p), 1 );
-    }
-
-#endif
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-
-    void * operator new( std::size_t )
-    {
-        return quick_allocator<this_type>::alloc();
-    }
-
-    void operator delete( void * p )
-    {
-        quick_allocator<this_type>::dealloc( p );
-    }
-
-#endif
-};
-
-//
-// Borland's Codeguard trips up over the -Vx- option here:
-//
-#ifdef __CODEGUARD__
-# pragma option push -Vx-
-#endif
-
-template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
-{
-private:
-
-    P ptr; // copy constructor must not throw
-    D del; // copy constructor must not throw
-
-    sp_counted_impl_pd( sp_counted_impl_pd const & );
-    sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
-
-    typedef sp_counted_impl_pd<P, D> this_type;
-
-public:
-
-    // pre: d(p) must not throw
-
-    sp_counted_impl_pd( P p, D d ): ptr(p), del(d)
-    {
-    }
-
-    virtual void dispose() // nothrow
-    {
-        del( ptr );
-    }
-
-    virtual void * get_deleter( std::type_info const & ti )
-    {
-        return ti == typeid(D)? &del: 0;
-    }
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR)
-
-    void * operator new( std::size_t )
-    {
-        return std::allocator<this_type>().allocate( 1, static_cast<this_type *>(0) );
-    }
-
-    void operator delete( void * p )
-    {
-        std::allocator<this_type>().deallocate( static_cast<this_type *>(p), 1 );
-    }
-
-#endif
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-
-    void * operator new( std::size_t )
-    {
-        return quick_allocator<this_type>::alloc();
-    }
-
-    void operator delete( void * p )
-    {
-        quick_allocator<this_type>::dealloc( p );
-    }
-
-#endif
-};
-
-#ifdef __CODEGUARD__
-# pragma option pop
-#endif
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED

include/boost/shared_ptr.hpp

@@ -121,7 +121,7 @@ public:
     }
 
     template<class Y>
-    explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
+    explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>()) // Y must be complete
     {
         detail::sp_enable_shared_from_this( pn, p, p );
     }
@@ -268,10 +268,7 @@ public:
         return px != 0;
     }
 
-#elif \
-    ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
-    ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) )
-
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
     typedef T * (this_type::*unspecified_bool_type)() const;
     
     operator unspecified_bool_type() const // never throws
@@ -445,12 +442,10 @@ template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::
 
 // get_deleter (experimental)
 
-#if ( defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3) ) || \
-    ( defined(__EDG_VERSION__) && BOOST_WORKAROUND(__EDG_VERSION__, <= 238) ) || \
-    ( defined(__HP_aCC) && BOOST_WORKAROUND(__HP_aCC, <= 33500) )
+#if (defined(__GNUC__) &&  (__GNUC__ < 3)) || (defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238))
 
 // g++ 2.9x doesn't allow static_cast<X const *>(void *)
-// apparently EDG 2.38 and HP aCC A.03.35 also don't accept it
+// apparently EDG 2.38 also doesn't accept it
 
 template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
 {

shared_ptr.htm

@@ -20,7 +20,7 @@
 			<A href="sp_techniques.html">Programming Techniques</A></p>
 		<h2><a name="Introduction">Introduction</a></h2>
 		<p>The <b>shared_ptr</b> class template stores a pointer to a dynamically allocated 
-			object, typically with a C++ <EM>new-expression</EM>. The object pointed to is 
+			object, typically with a C++ <EM>new-expression</EM> . The object pointed to is 
 			guaranteed to be deleted when the last <b>shared_ptr</b> pointing to it is 
 			destroyed or reset. See the <A href="#example">example</A>.</p>
 		<p>Every <b>shared_ptr</b> meets the <b>CopyConstructible</b> and <b>Assignable</b> 
@@ -47,13 +47,6 @@
 			to <STRONG>shared_ptr&lt;T const&gt;</STRONG>, to <STRONG>shared_ptr&lt;U&gt;</STRONG>
 			where <STRONG>U</STRONG> is an accessible base of <STRONG>T</STRONG>, and to <STRONG>
 				shared_ptr&lt;void&gt;</STRONG>.</P>
-		<P><STRONG>shared_ptr</STRONG> is now part of <STRONG>TR1</STRONG>, the first C++ 
-			Library Technical Report. The latest draft of <STRONG>TR1</STRONG> is available 
-			at the following location:</P>
-		<P><A href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1745.pdf">http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1745.pdf</A>
-			(1.36Mb PDF)</P>
-		<P>This implementation conforms to the TR1 specification, with the only exception 
-			that it resides in namespace <code>boost</code> instead of <code>std::tr1</code>.</P>
 		<h2><a name="BestPractices">Best Practices</a></h2>
 		<P>A simple guideline that nearly eliminates the possibility of memory leaks is: 
 			always use a named smart pointer variable to hold the result of <STRONG>new. </STRONG>
@@ -161,6 +154,15 @@ void bad()
   template&lt;class D, class T&gt;
     D * <A href="#get_deleter">get_deleter</A>(shared_ptr&lt;T&gt; const &amp; p);
 }</pre>
+		<P><EM>[It might be convenient to relax the requirements on <STRONG>shared_ptr</STRONG>'s 
+				signature, allowing an additional, defaulted, template parameter; the parameter 
+				can encode the threading model, for example. This would help in detecting 
+				possible ODR violations.</EM></P>
+		<P><EM>On the other hand, using <STRONG>shared_ptr</STRONG> as an argument to a 
+				template template parameter requires an exact signature match. </EM><EM>Metaprogramming 
+				experts tend to deemphasize template template parameters as they are too 
+				inflexible, but the alternative is typically an std::allocator::rebind-type 
+				"hack".]</EM></P>
 		<h2><a name="Members">Members</a></h2>
 		<h3><a name="element_type">element_type</a></h3>
 		<pre>typedef T element_type;</pre>
@@ -170,13 +172,24 @@ void bad()
 		<h3><a name="constructors">constructors</a></h3>
 		<pre>shared_ptr(); // never throws</pre>
 		<blockquote>
-			<p><b>Effects:</b> Constructs an <EM>empty</EM> <b>shared_ptr</b>.</p>
-			<p><b>Postconditions:</b> <code>use_count() == 0 &amp;&amp; get() == 0</code>.</p>
+			<p><b>Effects:</b> Constructs an <EM>empty</EM> <b>shared_ptr</b>. <EM>Empty</EM> <STRONG>
+					shared_ptr</STRONG> objects have an unspecified <A href="#use_count">use_count</A>.</p>
+			<p><b>Postconditions:</b> <code>get() == 0</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
 		<P><EM>[The nothrow guarantee is important, since <STRONG>reset()</STRONG> is specified 
 				in terms of the default constructor; this implies that the constructor must not 
-				allocate memory.]</EM></P>
+				allocate memory.</EM></P>
+		<P><EM>There are two possible implementations, one stores 0 as a pointer to the 
+				reference count, the other uses a single statically allocated count for all 
+				default-constructed <STRONG>shared_ptr</STRONG>s. The second option is 
+				difficult to achieve in the current header-only reference implementation due to 
+				thread safety issues and initialization order, but it should not be precluded 
+				by the specification. That's why the use_count() has been left unspecified.</EM></P>
+		<P><EM>A future release may enable <STRONG>shared_ptr</STRONG> construction from a 
+				literal zero, for consistency with built-in pointers. It is not clear yet 
+				whether this constructor should be left implicit, enabling <STRONG>0</STRONG> to 
+				be used as a shorthand for <STRONG>shared_ptr&lt;T&gt;().</STRONG>]</EM></P>
 		<pre>template&lt;class Y&gt; explicit shared_ptr(Y * p);</pre>
 		<blockquote>
 			<p><b>Requirements:</b> <b>p</b> must be convertible to <b>T *</b>. <STRONG>Y</STRONG>
@@ -185,8 +198,8 @@ void bad()
 			</p>
 			<p><b>Effects:</b> Constructs a <b>shared_ptr</b> that <EM>owns</EM> the pointer <b>p</b>.</p>
 			<p><b>Postconditions:</b> <code>use_count() == 1 &amp;&amp; get() == p</code>.</p>
-			<p><b>Throws:</b> <STRONG>std::bad_alloc</STRONG>, or an implementation-defined 
-				exception when a resource other than memory could not be obtained.</p>
+			<p><b>Throws:</b> <b>std::bad_alloc</b> or an implementation-defined exception when 
+				a resource other than memory could not be obtained.</p>
 			<p><b>Exception safety:</b> If an exception is thrown, <code>delete p</code> is 
 				called.</p>
 			<P><STRONG>Notes:</STRONG> <B>p</B> must be a pointer to an object that was 
@@ -213,8 +226,8 @@ void bad()
 			<p><b>Effects:</b> Constructs a <b>shared_ptr</b> that <EM>owns</EM> the pointer <STRONG>
 					p</STRONG> and the deleter <b>d</b>.</p>
 			<p><b>Postconditions:</b> <code>use_count() == 1 &amp;&amp; get() == p</code>.</p>
-			<p><b>Throws:</b> <STRONG>std::bad_alloc</STRONG>, or an implementation-defined 
-				exception when a resource other than memory could not be obtained.</p>
+			<p><b>Throws:</b> <b>std::bad_alloc</b> or an implementation-defined exception when 
+				a resource other than memory could not be obtained.</p>
 			<p><b>Exception safety:</b> If an exception is thrown, <code>d(p)</code> is called.</p>
 			<p><b>Notes:</b> When the the time comes to delete the object pointed to by <b>p</b>, 
 				the stored copy of <STRONG>d</STRONG> is invoked with the stored copy of <STRONG>p</STRONG>
@@ -232,10 +245,17 @@ void bad()
 		<P><EM>The requirement that the copy constructor of <b>D</b> does not throw comes from 
 				the pass by value. If the copy constructor throws, the pointer is leaked. 
 				Removing the requirement requires a pass by (const) reference.</EM></P>
-		<P><EM>The main problem with pass by reference lies in its interaction with rvalues. A 
-				const reference may still cause a copy, and will require a const operator(). A 
-				non-const reference won't bind to an rvalue at all. A good solution to this 
-				problem is the rvalue reference proposed in <A href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1377.htm">
+		<P><EM>Pass by reference is problematic since (1) pass by value conveniently changes 
+				functions (function references) to function pointers (this has to be performed 
+				manually otherwise and some compilers may not be able to do it) and (2) const 
+				references don't currently (per the standard) bind to functions. This can be 
+				solved (I think) but it requires an overload set that breaks on many compilers 
+				due to 14.5.5.2 problems (and of course it will break on compilers that don't 
+				do partial ordering at all.)</EM></P>
+		<P><EM>The main problem with pass by reference, though, lies in its interaction with 
+				rvalues. A const reference may still cause a copy, and will require a const 
+				operator(). A non-const reference won't bind to an rvalue at all. A good 
+				solution to this problem is the rvalue reference proposed in <A href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1377.htm">
 					N1377</A>/<A href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">N1385</A>.]</EM></P>
 		<pre>shared_ptr(shared_ptr const &amp; r); // never throws
 template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r); // never throws</pre>
@@ -248,8 +268,9 @@ template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r); // never
 		</blockquote>
 		<pre>template&lt;class Y&gt; explicit shared_ptr(<A href="weak_ptr.htm" >weak_ptr</A>&lt;Y&gt; const &amp; r);</pre>
 		<blockquote>
-			<p><b>Effects:</b> Constructs a <b>shared_ptr</b> that <EM>shares ownership</EM> with
-				<b>r</b> and stores a copy of the pointer stored in <STRONG>r</STRONG>.</p>
+			<p><b>Effects:</b> If <b>r</b> is <EM>empty</EM>, constructs an <EM>empty</EM> <b>shared_ptr</b>; 
+				otherwise, constructs a <b>shared_ptr</b> that <EM>shares ownership</EM> with <b>r</b>
+				and stores a copy of the pointer stored in <STRONG>r</STRONG>.</p>
 			<p><b>Postconditions:</b> <code>use_count() == r.use_count()</code>.</p>
 			<p><b>Throws:</b> <b>bad_weak_ptr</b> when <code>r.use_count() == 0</code>.</p>
 			<p><b>Exception safety:</b> If an exception is thrown, the constructor has no 
@@ -259,8 +280,8 @@ template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r); // never
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Constructs a <B>shared_ptr</B>, as if by storing a copy of <STRONG>r.release()</STRONG>.</P>
 			<p><b>Postconditions:</b> <code>use_count() == 1</code>.</p>
-			<p><b>Throws:</b> <STRONG>std::bad_alloc</STRONG>, or an implementation-defined 
-				exception when a resource other than memory could not be obtained.</p>
+			<p><b>Throws:</b> <b>std::bad_alloc</b> or an implementation-defined exception when 
+				a resource other than memory could not be obtained.</p>
 			<P><B>Exception safety:</B> If an exception is thrown, the constructor has no 
 				effect.</P>
 		</BLOCKQUOTE>
@@ -304,6 +325,12 @@ q = p;
 </pre>
 			<p>both assignments may be no-ops.</p>
 		</BLOCKQUOTE>
+		<P><EM>[Some experts consider the note to be redundant, as it appears to essentially 
+				mirror the "as if" rule. However, experience suggests that when C++ code is 
+				used to describe effects, it is often misinterpreted as required 
+				implementation. In addition, it is not entirely clear whether the "as if" rule 
+				actually applies here, so it's better to be explicit about the possible 
+				optimizations.]</EM></P>
 		<h3><a name="reset">reset</a></h3>
 		<pre>void reset(); // never throws</pre>
 		<BLOCKQUOTE>
@@ -400,7 +427,7 @@ q = p;
 				<LI>
 					under the equivalence relation defined by <STRONG>operator&lt;</STRONG>, <code>!(a 
 						&lt; b) &amp;&amp; !(b &lt; a)</code>, two <STRONG>shared_ptr</STRONG> instances 
-					are equivalent if and only if they <EM>share ownership</EM> or are both <EM>empty</EM>.</LI></UL>
+					are equivalent if and only if they <EM>share ownership</EM>.</LI></UL>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> Allows <STRONG>shared_ptr</STRONG> objects to be used as keys in 
 				associative containers.</P>
@@ -575,32 +602,11 @@ p3.reset(new int(1));
 // thread B
 p3.reset(new int(2)); // undefined, multiple writes
 </pre>
-		<p>&nbsp;</p>
-		<P>Starting with Boost release 1.33.0, <STRONG>shared_ptr</STRONG> uses a lock-free 
-			implementation on the following platforms:</P>
-		<UL>
-			<LI>
-			GNU GCC on x86 or x86-64;
-			<LI>
-			GNU GCC on IA64;
-			<LI>
-			Metrowerks CodeWarrior on PowerPC;
-			<LI>
-			GNU GCC on PowerPC;
-			<LI>
-				Windows.</LI></UL>
-		<P>If your program is single-threaded and does not link to any libraries that might 
-			have used <STRONG>shared_ptr</STRONG> in its default configuration, you can <STRONG>
-				#define</STRONG> the macro <STRONG>BOOST_SP_DISABLE_THREADS</STRONG> on a 
-			project-wide basis to switch to ordinary non-atomic reference count updates.</P>
-		<P>(Defining <STRONG>BOOST_SP_DISABLE_THREADS</STRONG> in some, but not all, 
-			translation units is technically a violation of the One Definition Rule and 
-			undefined behavior. Nevertheless, the implementation attempts to do its best to 
-			accommodate the request to use non-atomic updates in those translation units. 
-			No guarantees, though.)</P>
-		<P>You can define the macro <STRONG>BOOST_SP_USE_PTHREADS</STRONG> to turn off the 
-			lock-free platform-specific implementation and fall back to the generic <STRONG>pthread_mutex_t</STRONG>-based 
-			code.</P>
+		<p><STRONG>shared_ptr</STRONG> uses <A href="../config/config.htm">Boost.Config</A> 
+			to detect whether the implementation supports threads. If your program is 
+			single-threaded, but your platform is autodetected by <STRONG>Boost.Config</STRONG>
+			as supporting multiple threads, <STRONG>#define BOOST_DISABLE_THREADS</STRONG> to 
+			eliminate the thread safety overhead.</p>
 		<h2><a name="FAQ">Frequently Asked Questions</a></h2>
 		<P><B>Q.</B> There are several variations of shared pointers, with different 
 			tradeoffs; why does the smart pointer library supply only a single 
@@ -621,7 +627,7 @@ p3.reset(new int(2)); // undefined, multiple writes
 			day a highly configurable smart pointer may be invented that is also very easy 
 			to use and very hard to misuse. Until then, <B>shared_ptr</B> is the smart 
 			pointer of choice for a wide range of applications. (Those interested in policy 
-			based smart pointers should read <A href="http://www.awprofessional.com/bookstore/product.asp?isbn=0201704315&rl=1">
+			based smart pointers should read <A href="http://cseng.aw.com/book/0,,0201704315,00.html">
 				Modern C++ Design</A> by Andrei Alexandrescu.)<BR>
 		</P>
 		<P><B>Q.</B> I am not convinced. Default parameters can be used where appropriate 
@@ -685,7 +691,7 @@ int * p = a.release();
 		<p>
 			$Date$</p>
 		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
-				Copyright 2002-2005 Peter Dimov. Permission to copy, use, modify, sell and 
+				Copyright 2002, 2003 Peter Dimov. Permission to copy, use, modify, sell and 
 				distribute this document is granted provided this copyright notice appears in 
 				all copies. This document is provided "as is" without express or implied 
 				warranty, and with no claim as to its suitability for any purpose.</small></p>

sp_techniques.html

@@ -272,9 +272,6 @@ shared_ptr<X> createX()
 			single reference created in <code>make_shared_from_COM</code>. Weak pointers 
 			created from <code>pw</code> will be invalidated when the last <code>shared_ptr</code>
 			is destroyed, regardless of whether the COM object itself is still alive.</p>
-		<P>As <A href="../bind/mem_fn.html#Q3">explained</A> in the <code>mem_fn</code> documentation, 
-			you need to <A href="../bind/mem_fn.html#stdcall">#define 
-				BOOST_MEM_FN_ENABLE_STDCALL</A> first.</P>
 		<h2><A name="intrusive">Using a <code>shared_ptr</code> to hold a pointer to an object 
 				with an embedded reference count</A></h2>
 		<p>This is a generalization of the above technique. The example assumes that the 
@@ -756,8 +753,8 @@ public:
 		<hr>
 		<p>$Date$</p>
 		<p><small>Copyright <20> 2003 Peter Dimov. Permission to copy, use, modify, sell and 
-				distribute this document is granted provided this copyright notice appears in 
-				all copies. This document is provided "as is" without express or implied 
-				warranty, and with no claim as to its suitability for any purpose.</small></p>
+			distribute this document is granted provided this copyright notice appears in 
+			all copies. This document is provided "as is" without express or implied 
+			warranty, and with no claim as to its suitability for any purpose.</small></p>
 	</body>
 </html>

test/Jamfile

@@ -1,6 +1,6 @@
 #  Boost.SmartPtr Library test Jamfile
 #
-#  Copyright (c) 2003-2005 Peter Dimov
+#  Copyright (c) 2003 Peter Dimov
 #  Copyright (c) 2003 Dave Abrahams
 #
 #  Permission to copy, use, modify, sell and distribute this software
@@ -26,10 +26,7 @@ DEPENDS all : smart_ptr ;
           [ run get_deleter_test.cpp ]
           [ run intrusive_ptr_test.cpp ]
           [ run intrusive_ptr_test.cpp ]
-          [ run atomic_count_test.cpp ]
-          [ run lw_mutex_test.cpp ]
           [ compile-fail shared_ptr_assign_fail.cpp ]
-          [ compile-fail shared_ptr_delete_fail.cpp ]
         ;
     
     # this one is too slow to run unless explicitly requested, and ALL

test/Jamfile.v2

@@ -1,6 +1,6 @@
 #  Boost.SmartPtr Library test Jamfile
 #
-#  Copyright (c) 2003-2005 Peter Dimov
+#  Copyright (c) 2003 Peter Dimov
 #  Copyright (c) 2003 Dave Abrahams
 #
 #  Permission to copy, use, modify, sell and distribute this software
@@ -20,9 +20,17 @@ import testing ;
           [ run shared_from_this_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-non-virtual-dtor ]
           [ run get_deleter_test.cpp ]
           [ run intrusive_ptr_test.cpp ]
-          [ run atomic_count_test.cpp ]
-          [ run lw_mutex_test.cpp ]
           [ compile-fail shared_ptr_assign_fail.cpp ]
-          [ compile-fail shared_ptr_delete_fail.cpp ]
         ;
+    
+    # this one is too slow to run unless explicitly requested, and ALL
+    # tests are run by default when this file is subincluded from
+    # boost/status, so it's guarded from that case.  It will only be
+    # built from this directory when the targets "test" (all tests) or
+    # "shared_ptr_alloc_test" are requested.
+    #!!!
+    #if [ in-invocation-subdir ]
+    #{
+    #    run shared_ptr_alloc_test.cpp ;
+    #}
 }

test/atomic_count_test.cpp

@@ -1,40 +0,0 @@
-//
-// atomic_count_test.cpp
-//
-// Copyright 2005 Peter Dimov
-//
-// 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/detail/atomic_count.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-int main()
-{
-    boost::detail::atomic_count n( 4 );
-
-    BOOST_TEST( n == 4L );
-
-    ++n;
-
-    BOOST_TEST( n == 5L );
-    BOOST_TEST( --n != 0L );
-
-    boost::detail::atomic_count m( 0 );
-
-    BOOST_TEST( m == 0 );
-
-    ++m;
-
-    BOOST_TEST( m == 1 );
-
-    ++m;
-
-    BOOST_TEST( m == 2 );
-    BOOST_TEST( --m != 0 );
-    BOOST_TEST( --m == 0 );
-
-    return boost::report_errors();
-}

test/intrusive_ptr_test.cpp

@@ -19,7 +19,7 @@
 //
 //  intrusive_ptr_test.cpp
 //
-//  Copyright (c) 2002-2005 Peter Dimov
+//  Copyright (c) 2002, 2003 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -28,7 +28,6 @@
 
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/intrusive_ptr.hpp>
-#include <boost/detail/atomic_count.hpp>
 #include <boost/config.hpp>
 #include <algorithm>
 #include <functional>
@@ -42,7 +41,7 @@ class base
 {
 private:
 
-    boost::detail::atomic_count use_count_;
+    long use_count_;
 
     base(base const &);
     base & operator=(base const &);

test/lw_mutex_test.cpp

@@ -1,28 +0,0 @@
-//
-// lw_mutex_test.cpp
-//
-// Copyright 2005 Peter Dimov
-//
-// 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/detail/lightweight_mutex.hpp>
-
-// Sanity check only
-
-boost::detail::lightweight_mutex m1;
-
-int main()
-{
-    boost::detail::lightweight_mutex::scoped_lock lock1( m1 );
-
-    boost::detail::lightweight_mutex m2;
-    boost::detail::lightweight_mutex m3;
-
-    boost::detail::lightweight_mutex::scoped_lock lock2( m2 );
-    boost::detail::lightweight_mutex::scoped_lock lock3( m3 );
-
-    return 0;
-}

test/shared_ptr_delete_fail.cpp

@@ -1,27 +0,0 @@
-#include <boost/config.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable: 4786)  // identifier truncated in debug info
-#pragma warning(disable: 4710)  // function not inlined
-#pragma warning(disable: 4711)  // function selected for automatic inline expansion
-#pragma warning(disable: 4514)  // unreferenced inline removed
-#endif
-
-//
-//  shared_ptr_delete_fail.cpp - a negative test for "delete sp;"
-//
-//  Copyright 2005 Peter Dimov
-//
-// 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/shared_ptr.hpp>
-
-int main()
-{
-    boost::shared_ptr<int> p;
-    delete p; // must fail
-    return 0;
-}

test/shared_ptr_mt_test.cpp

@@ -143,11 +143,19 @@ void test(boost::shared_ptr<int> const & pi)
 
 int const m = 16; // threads
 
+#if defined(BOOST_LWM_USE_CRITICAL_SECTION)
+    char const * implementation = "critical section";
+#elif defined(BOOST_LWM_USE_PTHREADS)
+    char const * implementation = "pthread_mutex";
+#else
+    char const * implementation = "spinlock";
+#endif
+
 int main()
 {
     using namespace std; // printf, clock_t, clock
 
-    printf("%s: %d threads, %d iterations: ", title, m, n);
+    printf("%s: %s, %d threads, %d iterations: ", title, implementation, m, n);
 
     boost::shared_ptr<int> pi(new int(42));
 

test/weak_ptr_mt_test.cpp

@@ -1,214 +0,0 @@
-#include <boost/config.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable: 4786)  // identifier truncated in debug info
-#pragma warning(disable: 4710)  // function not inlined
-#pragma warning(disable: 4711)  // function selected for automatic inline expansion
-#pragma warning(disable: 4514)  // unreferenced inline removed
-#endif
-
-//
-//  weak_ptr_mt_test.cpp
-//
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright 2005 Peter Dimov
-//
-// 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/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
-#include <boost/bind.hpp>
-
-#include <vector>
-#include <memory>
-#include <stdexcept>
-
-#include <cstdio>
-#include <ctime>
-#include <cstdlib>
-
-// 'portable' thread framework
-
-class abstract_thread
-{
-public:
-
-    virtual ~abstract_thread() {}
-    virtual void run() = 0;
-};
-
-#if !defined(BOOST_HAS_PTHREADS) && defined(BOOST_HAS_WINTHREADS)
-
-char const * title = "Using Windows threads";
-
-#include <windows.h>
-#include <process.h>
-
-typedef HANDLE pthread_t;
-
-unsigned __stdcall common_thread_routine(void * pv)
-{
-    abstract_thread * pt = static_cast<abstract_thread *>(pv);
-    pt->run();
-    delete pt;
-    return 0;
-}
-
-int pthread_create(pthread_t * thread, void const *, unsigned (__stdcall * start_routine) (void*), void* arg)
-{
-    HANDLE h = (HANDLE)_beginthreadex(0, 0, start_routine, arg, 0, 0);
-
-    if(h != 0)
-    {
-        *thread = h;
-        return 0;
-    }
-    else
-    {
-        return 1; // return errno;
-    }
-}
-
-int pthread_join(pthread_t thread, void ** /*value_ptr*/)
-{
-    ::WaitForSingleObject(thread, INFINITE);
-    ::CloseHandle(thread);
-    return 0;
-}
-
-#else
-
-char const * title = "Using POSIX threads";
-
-#include <pthread.h>
-
-extern "C" void * common_thread_routine(void * pv)
-{
-    abstract_thread * pt = static_cast<abstract_thread *>(pv);
-    pt->run();
-    delete pt;
-    return 0;
-}
-
-#endif
-
-//
-
-template<class F> class thread: public abstract_thread
-{
-public:
-
-    explicit thread(F f): f_(f)
-    {
-    }
-
-    void run()
-    {
-        f_();
-    }
-
-private:
-
-    F f_;
-};
-
-template<class F> pthread_t createThread(F f)
-{
-    std::auto_ptr<abstract_thread> p(new thread<F>(f));
-
-    pthread_t r;
-
-    if(pthread_create(&r, 0, common_thread_routine, p.get()) == 0)
-    {
-        p.release();
-        return r;
-    }
-
-    throw std::runtime_error("createThread failed.");
-}
-
-//
-
-int const n = 16384;
-int const k = 512; // vector size
-int const m = 16; // threads
-
-void test( std::vector< boost::shared_ptr<int> > & v )
-{
-    using namespace std; // printf, rand
-
-    std::vector< boost::weak_ptr<int> > w( v.begin(), v.end() );
-
-    int s = 0, f = 0, r = 0;
-
-    for( int i = 0; i < n; ++i )
-    {
-        // randomly kill a pointer
-
-        v[ rand() % k ].reset();
-        ++s;
-
-        for( int j = 0; j < k; ++j )
-        {
-            if( boost::shared_ptr<int> px = w[ j ].lock() )
-            {
-                ++s;
-
-                if( rand() & 4 )
-                {
-                    continue;
-                }
-
-                // rebind anyway with prob. 50% for add_ref_lock() against weak_release() contention
-                ++f;
-            }
-            else
-            {
-                ++r;
-            }
-
-            w[ j ] = v[ rand() % k ];
-        }
-    }
-
-    printf( "\n%d locks, %d forced rebinds, %d normal rebinds.", s, f, r );
-}
-
-int main()
-{
-    using namespace std; // printf, clock_t, clock
-
-    printf("%s: %d threads, %d * %d iterations: ", title, m, n, k );
-
-    std::vector< boost::shared_ptr<int> > v( k );
-
-    for( int i = 0; i < k; ++i )
-    {
-        v[ i ].reset( new int( 0 ) );
-    }
-
-    clock_t t = clock();
-
-    pthread_t a[m];
-
-    for(int i = 0; i < m; ++i)
-    {
-        a[i] = createThread( boost::bind( test, v ) );
-    }
-
-    v.resize( 0 ); // kill original copies
-
-    for(int j = 0; j < m; ++j)
-    {
-        pthread_join( a[j], 0 );
-    }
-
-    t = clock() - t;
-
-    printf("\n\n%.3f seconds.\n", static_cast<double>(t) / CLOCKS_PER_SEC);
-
-    return 0;
-}

test/weak_ptr_test.cpp

@@ -17,7 +17,7 @@
 //
 //  weak_ptr_test.cpp
 //
-//  Copyright (c) 2002-2005 Peter Dimov
+//  Copyright (c) 2002, 2003 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -500,7 +500,7 @@ void test()
 namespace n_assignment
 {
 
-template<class T> void copy_assignment(boost::shared_ptr<T> & sp)
+template<class T> void copy_assignment(boost::shared_ptr<T> sp)
 {
     BOOST_TEST(sp.unique());
 
@@ -611,7 +611,7 @@ void conversion_assignment()
     }
 }
 
-template<class T, class U> void shared_ptr_assignment(boost::shared_ptr<U> & sp, T * = 0)
+template<class T, class U> void shared_ptr_assignment(boost::shared_ptr<U> sp, T * = 0)
 {
     BOOST_TEST(sp.unique());
 
@@ -644,62 +644,18 @@ template<class T, class U> void shared_ptr_assignment(boost::shared_ptr<U> & sp,
 
 void test()
 {
-    {
-        boost::shared_ptr<int> p( new int );
-        copy_assignment( p );
-    }
-
-    {
-        boost::shared_ptr<X> p( new X );
-        copy_assignment( p );
-    }
-
-    {
-        boost::shared_ptr<void> p( new int );
-        copy_assignment( p );
-    }
-
-    {
-        boost::shared_ptr<incomplete> p = create_incomplete();
-        copy_assignment( p );
-    }
-
+    copy_assignment(boost::shared_ptr<int>(new int));
+    copy_assignment(boost::shared_ptr<X>(new X));
+    copy_assignment(boost::shared_ptr<void>(new int));
+    copy_assignment(create_incomplete());
     conversion_assignment();
-
-    {
-        boost::shared_ptr<int> p( new int );
-        shared_ptr_assignment<int>( p );
-    }
-
-    {
-        boost::shared_ptr<int> p( new int );
-        shared_ptr_assignment<void>( p );
-    }
-
-    {
-        boost::shared_ptr<X> p( new X );
-        shared_ptr_assignment<X>( p );
-    }
-
-    {
-        boost::shared_ptr<X> p( new X );
-        shared_ptr_assignment<void>( p );
-    }
-
-    {
-        boost::shared_ptr<void> p( new int );
-        shared_ptr_assignment<void>( p );
-    }
-
-    {
-        boost::shared_ptr<incomplete> p = create_incomplete();
-        shared_ptr_assignment<incomplete>( p );
-    }
-
-    {
-        boost::shared_ptr<incomplete> p = create_incomplete();
-        shared_ptr_assignment<void>( p );
-    }
+    shared_ptr_assignment<int>(boost::shared_ptr<int>(new int));
+    shared_ptr_assignment<void>(boost::shared_ptr<int>(new int));
+    shared_ptr_assignment<X>(boost::shared_ptr<X>(new X));
+    shared_ptr_assignment<void>(boost::shared_ptr<X>(new X));
+    shared_ptr_assignment<void>(boost::shared_ptr<void>(new int));
+    shared_ptr_assignment<incomplete>(create_incomplete());
+    shared_ptr_assignment<void>(create_incomplete());
 }
 
 } // namespace n_assignment
@@ -707,7 +663,7 @@ void test()
 namespace n_reset
 {
 
-template<class T, class U> void test2( boost::shared_ptr<U> & sp, T * = 0 )
+template<class T, class U> void test2(boost::shared_ptr<U> sp, T * = 0)
 {
     BOOST_TEST(sp.unique());
 
@@ -741,40 +697,13 @@ template<class T, class U> void test2( boost::shared_ptr<U> & sp, T * = 0 )
 
 void test()
 {
-    {
-        boost::shared_ptr<int> p( new int );
-        test2<int>( p );
-    }
-
-    {
-        boost::shared_ptr<int> p( new int );
-        test2<void>( p );
-    }
-
-    {
-        boost::shared_ptr<X> p( new X );
-        test2<X>( p );
-    }
-
-    {
-        boost::shared_ptr<X> p( new X );
-        test2<void>( p );
-    }
-
-    {
-        boost::shared_ptr<void> p( new int );
-        test2<void>( p );
-    }
-
-    {
-        boost::shared_ptr<incomplete> p = create_incomplete();
-        test2<incomplete>( p );
-    }
-
-    {
-        boost::shared_ptr<incomplete> p = create_incomplete();
-        test2<void>( p );
-    }
+    test2<int>(boost::shared_ptr<int>(new int));
+    test2<void>(boost::shared_ptr<int>(new int));
+    test2<X>(boost::shared_ptr<X>(new X));
+    test2<void>(boost::shared_ptr<X>(new X));
+    test2<void>(boost::shared_ptr<void>(new int));
+    test2<incomplete>(create_incomplete());
+    test2<void>(create_incomplete());
 }
 
 } // namespace n_reset

test/weak_ptr_timing_test.cpp

@@ -1,85 +0,0 @@
-#include <boost/config.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable: 4786)  // identifier truncated in debug info
-#pragma warning(disable: 4710)  // function not inlined
-#pragma warning(disable: 4711)  // function selected for automatic inline expansion
-#pragma warning(disable: 4514)  // unreferenced inline removed
-#endif
-
-//
-//  weak_ptr_timing_test.cpp
-//
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright 2005 Peter Dimov
-//
-// 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/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
-
-#include <vector>
-#include <cstdio>
-#include <ctime>
-#include <cstdlib>
-
-//
-
-int const n = 29000;
-int const k = 2048;
-
-void test( std::vector< boost::shared_ptr<int> > & v )
-{
-    using namespace std; // printf, rand
-
-    std::vector< boost::weak_ptr<int> > w( v.begin(), v.end() );
-
-    int s = 0, r = 0;
-
-    for( int i = 0; i < n; ++i )
-    {
-        // randomly kill a pointer
-
-        v[ rand() % k ].reset();
-
-        for( int j = 0; j < k; ++j )
-        {
-            if( boost::shared_ptr<int> px = w[ j ].lock() )
-            {
-                ++s;
-            }
-            else
-            {
-                ++r;
-                w[ j ] = v[ rand() % k ];
-            }
-        }
-    }
-
-    printf( "\n%d locks, %d rebinds.", s, r );
-}
-
-int main()
-{
-    using namespace std; // printf, clock_t, clock
-
-    std::vector< boost::shared_ptr<int> > v( k );
-
-    for( int i = 0; i < k; ++i )
-    {
-        v[ i ].reset( new int( 0 ) );
-    }
-
-    clock_t t = clock();
-
-    test( v );
-
-    t = clock() - t;
-
-    printf( "\n\n%.3f seconds.\n", static_cast<double>( t ) / CLOCKS_PER_SEC );
-
-    return 0;
-}

weak_ptr.htm

@@ -145,8 +145,9 @@ template<class Y> weak_ptr & operator=(shared_ptr<Y> const &
 		<h3><a name="use_count">use_count</a></h3>
 		<pre>long use_count() const;</pre>
 		<blockquote>
-			<p><b>Returns:</b> 0 if <STRONG>*this</STRONG> is <EM>empty</EM>; otherwise, the 
-				number of <b>shared_ptr</b> objects that <EM>share ownership</EM> with <STRONG>*this</STRONG>.</p>
+			<p><b>Returns:</b> if <STRONG>*this</STRONG> is <EM>empty</EM>, an unspecified 
+				nonnegative value; otherwise, the number of <b>shared_ptr</b> objects that <EM>share 
+					ownership</EM> with <STRONG>*this</STRONG>.</p>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> <code>use_count()</code> is not necessarily efficient. Use only 
 				for debugging and testing purposes, not for production code.</P>
@@ -188,7 +189,7 @@ template&lt;class Y&gt; weak_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp;
 				<LI>
 					under the equivalence relation defined by <STRONG>operator&lt;</STRONG>, <code>!(a 
 						&lt; b) &amp;&amp; !(b &lt; a)</code>, two <STRONG>weak_ptr</STRONG> instances 
-					are equivalent if and only if they <EM>share ownership</EM> or are both <EM>empty</EM>.</LI></UL>
+					are equivalent if and only if they <EM>share ownership</EM>.</LI></UL>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> Allows <STRONG>weak_ptr</STRONG> objects to be used as keys in 
 				associative containers.</P>
@@ -235,7 +236,7 @@ public:
 		<hr>
 		<p>$Date$</p>
 		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
-				Copyright 2002-2005 Peter Dimov. Permission to copy, use, modify, sell and 
+				Copyright 2002, 2003 Peter Dimov. Permission to copy, use, modify, sell and 
 				distribute this document is granted provided this copyright notice appears in 
 				all copies. This document is provided "as is" without express or implied 
 				warranty, and with no claim as to its suitability for any purpose.</small></p>