passenger 6.0.7 → 6.0.8

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/{ops_extending_cas_based.hpp → extending_cas_based_arithmetic.hpp}

@@ -6,19 +6,20 @@
  * Copyright (c) 2014 Andrey Semashev
  */
 /*!
- * \file   atomic/detail/ops_extending_cas_based.hpp
+ * \file   atomic/detail/extending_cas_based_arithmetic.hpp
  *
- * This header contains a boilerplate of the \c operations template implementation that requires sign/zero extension in arithmetic operations.
+ * This header contains a boilerplate of core atomic operations that require sign/zero extension in arithmetic operations.
  */
 
-#ifndef BOOST_ATOMIC_DETAIL_OPS_EXTENDING_CAS_BASED_HPP_INCLUDED_
-#define BOOST_ATOMIC_DETAIL_OPS_EXTENDING_CAS_BASED_HPP_INCLUDED_
+#ifndef BOOST_ATOMIC_DETAIL_EXTENDING_CAS_BASED_ARITHMETIC_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_EXTENDING_CAS_BASED_ARITHMETIC_HPP_INCLUDED_
 
 #include <cstddef>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
-#include <boost/atomic/detail/storage_type.hpp>
-#include <boost/atomic/detail/integral_extend.hpp>
+#include <boost/atomic/detail/storage_traits.hpp>
+#include <boost/atomic/detail/integral_conversions.hpp>
+#include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -29,11 +30,11 @@ namespace atomics {
 namespace detail {
 
 template< typename Base, std::size_t Size, bool Signed >
-struct extending_cas_based_operations :
+struct extending_cas_based_arithmetic :
     public Base
 {
     typedef typename Base::storage_type storage_type;
-    typedef typename make_storage_type< Size >::type emulated_storage_type;
+    typedef typename storage_traits< Size >::type emulated_storage_type;
 
     static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
@@ -66,4 +67,6 @@ struct extending_cas_based_operations :
 } // namespace atomics
 } // namespace boost
 
-#endif // BOOST_ATOMIC_DETAIL_OPS_EXTENDING_CAS_BASED_HPP_INCLUDED_
+#include <boost/atomic/detail/footer.hpp>
+
+#endif // BOOST_ATOMIC_DETAIL_EXTENDING_CAS_BASED_ARITHMETIC_HPP_INCLUDED_

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/extra_fp_operations_fwd.hpp

@@ -16,6 +16,7 @@
 
 #include <cstddef>
 #include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -25,11 +26,13 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-template< typename Base, typename Value, std::size_t Size, bool = Base::is_always_lock_free >
+template< typename Base, typename Value = typename Base::value_type, std::size_t Size = sizeof(typename Base::storage_type), bool = Base::is_always_lock_free >
 struct extra_fp_operations;
 
 } // namespace detail
 } // namespace atomics
 } // namespace boost
 
+#include <boost/atomic/detail/footer.hpp>
+
 #endif // BOOST_ATOMIC_DETAIL_EXTRA_FP_OPERATIONS_FWD_HPP_INCLUDED_

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/extra_fp_ops_emulated.hpp

@@ -15,11 +15,12 @@
 #define BOOST_ATOMIC_DETAIL_EXTRA_FP_OPS_EMULATED_HPP_INCLUDED_
 
 #include <cstddef>
+#include <boost/static_assert.hpp>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/bitwise_fp_cast.hpp>
 #include <boost/atomic/detail/extra_fp_operations_fwd.hpp>
-#include <boost/atomic/detail/lockpool.hpp>
+#include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -29,49 +30,54 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-//! Generic implementation of extra floating point operations
+//! Emulated implementation of extra floating point operations
 template< typename Base, typename Value, std::size_t Size >
-struct emulated_extra_fp_operations :
+struct extra_fp_operations_emulated :
     public Base
 {
     typedef Base base_type;
     typedef typename base_type::storage_type storage_type;
     typedef Value value_type;
+    typedef typename base_type::scoped_lock scoped_lock;
 
-    static BOOST_FORCEINLINE value_type fetch_negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static value_type fetch_negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         value_type old_val = atomics::detail::bitwise_fp_cast< value_type >(s);
         value_type new_val = -old_val;
         s = atomics::detail::bitwise_fp_cast< storage_type >(new_val);
         return old_val;
     }
 
-    static BOOST_FORCEINLINE value_type negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static value_type negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         value_type old_val = atomics::detail::bitwise_fp_cast< value_type >(s);
         value_type new_val = -old_val;
         s = atomics::detail::bitwise_fp_cast< storage_type >(new_val);
         return new_val;
     }
 
-    static BOOST_FORCEINLINE value_type add(storage_type volatile& storage, value_type v, memory_order) BOOST_NOEXCEPT
+    static value_type add(storage_type volatile& storage, value_type v, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         value_type old_val = atomics::detail::bitwise_fp_cast< value_type >(s);
         value_type new_val = old_val + v;
         s = atomics::detail::bitwise_fp_cast< storage_type >(new_val);
         return new_val;
     }
 
-    static BOOST_FORCEINLINE value_type sub(storage_type volatile& storage, value_type v, memory_order) BOOST_NOEXCEPT
+    static value_type sub(storage_type volatile& storage, value_type v, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         value_type old_val = atomics::detail::bitwise_fp_cast< value_type >(s);
         value_type new_val = old_val - v;
         s = atomics::detail::bitwise_fp_cast< storage_type >(new_val);
@@ -80,23 +86,26 @@ struct emulated_extra_fp_operations :
 
     static BOOST_FORCEINLINE void opaque_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         fetch_negate(storage, order);
     }
 
     static BOOST_FORCEINLINE void opaque_add(storage_type volatile& storage, value_type v, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         base_type::fetch_add(storage, v, order);
     }
 
     static BOOST_FORCEINLINE void opaque_sub(storage_type volatile& storage, value_type v, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         base_type::fetch_sub(storage, v, order);
     }
 };
 
 template< typename Base, typename Value, std::size_t Size >
 struct extra_fp_operations< Base, Value, Size, false > :
-    public emulated_extra_fp_operations< Base, Value, Size >
+    public extra_fp_operations_emulated< Base, Value, Size >
 {
 };
 
@@ -104,4 +113,6 @@ struct extra_fp_operations< Base, Value, Size, false > :
 } // namespace atomics
 } // namespace boost
 
+#include <boost/atomic/detail/footer.hpp>
+
 #endif // BOOST_ATOMIC_DETAIL_EXTRA_FP_OPS_EMULATED_HPP_INCLUDED_

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/extra_fp_ops_generic.hpp

@@ -18,16 +18,17 @@
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
 #include <boost/atomic/detail/bitwise_fp_cast.hpp>
-#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/storage_traits.hpp>
 #include <boost/atomic/detail/extra_fp_operations_fwd.hpp>
 #include <boost/atomic/detail/type_traits/is_iec559.hpp>
 #include <boost/atomic/detail/type_traits/is_integral.hpp>
+#include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
 #endif
 
-#if defined(BOOST_GCC) && (BOOST_GCC+0) >= 60000
+#if defined(BOOST_GCC) && BOOST_GCC >= 60000
 #pragma GCC diagnostic push
 // ignoring attributes on template argument X - this warning is because we need to pass storage_type as a template argument; no problem in this case
 #pragma GCC diagnostic ignored "-Wignored-attributes"
@@ -46,7 +47,7 @@ template<
     , bool = atomics::detail::is_iec559< Value >::value && atomics::detail::is_integral< typename Base::storage_type >::value
 #endif
 >
-struct generic_extra_fp_negate :
+struct extra_fp_negate_generic :
     public Base
 {
     typedef Base base_type;
@@ -93,7 +94,7 @@ struct generic_extra_fp_negate :
 
 //! Negate implementation for IEEE 754 / IEC 559 floating point types. We leverage the fact that the sign bit is the most significant bit in the value.
 template< typename Base, typename Value, std::size_t Size >
-struct generic_extra_fp_negate< Base, Value, Size, true > :
+struct extra_fp_negate_generic< Base, Value, Size, true > :
     public Base
 {
     typedef Base base_type;
@@ -123,10 +124,10 @@ struct generic_extra_fp_negate< Base, Value, Size, true > :
 
 //! Generic implementation of floating point operations
 template< typename Base, typename Value, std::size_t Size >
-struct generic_extra_fp_operations :
-    public generic_extra_fp_negate< Base, Value, Size >
+struct extra_fp_operations_generic :
+    public extra_fp_negate_generic< Base, Value, Size >
 {
-    typedef generic_extra_fp_negate< Base, Value, Size > base_type;
+    typedef extra_fp_negate_generic< Base, Value, Size > base_type;
     typedef typename base_type::storage_type storage_type;
     typedef Value value_type;
 
@@ -174,7 +175,7 @@ struct generic_extra_fp_operations :
 // Default extra_fp_operations template definition will be used unless specialized for a specific platform
 template< typename Base, typename Value, std::size_t Size >
 struct extra_fp_operations< Base, Value, Size, true > :
-    public generic_extra_fp_operations< Base, Value, Size >
+    public extra_fp_operations_generic< Base, Value, Size >
 {
 };
 
@@ -182,8 +183,10 @@ struct extra_fp_operations< Base, Value, Size, true > :
 } // namespace atomics
 } // namespace boost
 
-#if defined(BOOST_GCC) && (BOOST_GCC+0) >= 60000
+#if defined(BOOST_GCC) && BOOST_GCC >= 60000
 #pragma GCC diagnostic pop
 #endif
 
+#include <boost/atomic/detail/footer.hpp>
+
 #endif // BOOST_ATOMIC_DETAIL_FP_OPS_GENERIC_HPP_INCLUDED_

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/extra_operations_fwd.hpp

@@ -16,6 +16,7 @@
 
 #include <cstddef>
 #include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -25,11 +26,13 @@ namespace boost {
 namespace atomics {
 namespace detail {
 
-template< typename Base, std::size_t Size, bool Signed, bool = Base::is_always_lock_free >
+template< typename Base, std::size_t Size = sizeof(typename Base::storage_type), bool Signed = Base::is_signed, bool = Base::is_always_lock_free >
 struct extra_operations;
 
 } // namespace detail
 } // namespace atomics
 } // namespace boost
 
+#include <boost/atomic/detail/footer.hpp>
+
 #endif // BOOST_ATOMIC_DETAIL_EXTRA_OPERATIONS_FWD_HPP_INCLUDED_

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/extra_ops_emulated.hpp

@@ -15,115 +15,120 @@
 #define BOOST_ATOMIC_DETAIL_EXTRA_OPS_EMULATED_HPP_INCLUDED_
 
 #include <cstddef>
+#include <boost/static_assert.hpp>
 #include <boost/memory_order.hpp>
 #include <boost/atomic/detail/config.hpp>
-#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/storage_traits.hpp>
 #include <boost/atomic/detail/extra_operations_fwd.hpp>
-#include <boost/atomic/detail/lockpool.hpp>
+#include <boost/atomic/detail/header.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
 #endif
 
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-// unary minus operator applied to unsigned type, result still unsigned
-#pragma warning(disable: 4146)
-#endif
-
 namespace boost {
 namespace atomics {
 namespace detail {
 
-//! Generic implementation of extra operations
+//! Emulated implementation of extra operations
 template< typename Base, std::size_t Size, bool Signed >
-struct emulated_extra_operations :
+struct extra_operations_emulated :
     public Base
 {
     typedef Base base_type;
     typedef typename base_type::storage_type storage_type;
+    typedef typename base_type::scoped_lock scoped_lock;
 
-    static BOOST_FORCEINLINE storage_type fetch_negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static storage_type fetch_negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         storage_type old_val = s;
         s = static_cast< storage_type >(-old_val);
         return old_val;
     }
 
-    static BOOST_FORCEINLINE storage_type negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static storage_type negate(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         storage_type new_val = static_cast< storage_type >(-s);
         s = new_val;
         return new_val;
     }
 
-    static BOOST_FORCEINLINE storage_type add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         storage_type new_val = s;
         new_val += v;
         s = new_val;
         return new_val;
     }
 
-    static BOOST_FORCEINLINE storage_type sub(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type sub(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         storage_type new_val = s;
         new_val -= v;
         s = new_val;
         return new_val;
     }
 
-    static BOOST_FORCEINLINE storage_type bitwise_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type bitwise_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         storage_type new_val = s;
         new_val &= v;
         s = new_val;
         return new_val;
     }
 
-    static BOOST_FORCEINLINE storage_type bitwise_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type bitwise_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         storage_type new_val = s;
         new_val |= v;
         s = new_val;
         return new_val;
     }
 
-    static BOOST_FORCEINLINE storage_type bitwise_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    static storage_type bitwise_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         storage_type new_val = s;
         new_val ^= v;
         s = new_val;
         return new_val;
     }
 
-    static BOOST_FORCEINLINE storage_type fetch_complement(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static storage_type fetch_complement(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         storage_type old_val = s;
         s = static_cast< storage_type >(~old_val);
         return old_val;
     }
 
-    static BOOST_FORCEINLINE storage_type bitwise_complement(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
+    static storage_type bitwise_complement(storage_type volatile& storage, memory_order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type& s = const_cast< storage_type& >(storage);
-        lockpool::scoped_lock lock(&storage);
+        scoped_lock lock(&storage);
         storage_type new_val = static_cast< storage_type >(~s);
         s = new_val;
         return new_val;
@@ -131,99 +136,116 @@ struct emulated_extra_operations :
 
     static BOOST_FORCEINLINE void opaque_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        Base::fetch_add(storage, v, order);
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
+        base_type::fetch_add(storage, v, order);
     }
 
     static BOOST_FORCEINLINE void opaque_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        Base::fetch_sub(storage, v, order);
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
+        base_type::fetch_sub(storage, v, order);
     }
 
     static BOOST_FORCEINLINE void opaque_negate(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         fetch_negate(storage, order);
     }
 
     static BOOST_FORCEINLINE void opaque_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        Base::fetch_and(storage, v, order);
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
+        base_type::fetch_and(storage, v, order);
     }
 
     static BOOST_FORCEINLINE void opaque_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        Base::fetch_or(storage, v, order);
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
+        base_type::fetch_or(storage, v, order);
     }
 
     static BOOST_FORCEINLINE void opaque_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
-        Base::fetch_xor(storage, v, order);
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
+        base_type::fetch_xor(storage, v, order);
     }
 
     static BOOST_FORCEINLINE void opaque_complement(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         fetch_complement(storage, order);
     }
 
     static BOOST_FORCEINLINE bool add_and_test(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!add(storage, v, order);
     }
 
     static BOOST_FORCEINLINE bool sub_and_test(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!sub(storage, v, order);
     }
 
     static BOOST_FORCEINLINE bool negate_and_test(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!negate(storage, order);
     }
 
     static BOOST_FORCEINLINE bool and_and_test(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!bitwise_and(storage, v, order);
     }
 
     static BOOST_FORCEINLINE bool or_and_test(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!bitwise_or(storage, v, order);
     }
 
     static BOOST_FORCEINLINE bool xor_and_test(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!bitwise_xor(storage, v, order);
     }
 
     static BOOST_FORCEINLINE bool complement_and_test(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         return !!bitwise_complement(storage, order);
     }
 
     static BOOST_FORCEINLINE bool bit_test_and_set(storage_type volatile& storage, unsigned int bit_number, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type mask = static_cast< storage_type >(static_cast< storage_type >(1u) << bit_number);
-        storage_type old_val = Base::fetch_or(storage, mask, order);
+        storage_type old_val = base_type::fetch_or(storage, mask, order);
         return !!(old_val & mask);
     }
 
     static BOOST_FORCEINLINE bool bit_test_and_reset(storage_type volatile& storage, unsigned int bit_number, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type mask = static_cast< storage_type >(static_cast< storage_type >(1u) << bit_number);
-        storage_type old_val = Base::fetch_and(storage, ~mask, order);
+        storage_type old_val = base_type::fetch_and(storage, ~mask, order);
         return !!(old_val & mask);
     }
 
     static BOOST_FORCEINLINE bool bit_test_and_complement(storage_type volatile& storage, unsigned int bit_number, memory_order order) BOOST_NOEXCEPT
     {
+        BOOST_STATIC_ASSERT_MSG(!base_type::is_interprocess, "Boost.Atomic: operation invoked on a non-lock-free inter-process atomic object");
         storage_type mask = static_cast< storage_type >(static_cast< storage_type >(1u) << bit_number);
-        storage_type old_val = Base::fetch_xor(storage, mask, order);
+        storage_type old_val = base_type::fetch_xor(storage, mask, order);
         return !!(old_val & mask);
     }
 };
 
 template< typename Base, std::size_t Size, bool Signed >
 struct extra_operations< Base, Size, Signed, false > :
-    public emulated_extra_operations< Base, Size, Signed >
+    public extra_operations_emulated< Base, Size, Signed >
 {
 };
 
@@ -231,8 +253,6 @@ struct extra_operations< Base, Size, Signed, false > :
 } // namespace atomics
 } // namespace boost
 
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
+#include <boost/atomic/detail/footer.hpp>
 
 #endif // BOOST_ATOMIC_DETAIL_EXTRA_OPS_EMULATED_HPP_INCLUDED_