diff options
Diffstat (limited to 'external/meta-openembedded/meta-oe/recipes-support/ssiapi/ssiapi/0002-boost-Backport-clang-support.patch')
| -rw-r--r-- | external/meta-openembedded/meta-oe/recipes-support/ssiapi/ssiapi/0002-boost-Backport-clang-support.patch | 1409 |
1 files changed, 1409 insertions, 0 deletions
diff --git a/external/meta-openembedded/meta-oe/recipes-support/ssiapi/ssiapi/0002-boost-Backport-clang-support.patch b/external/meta-openembedded/meta-oe/recipes-support/ssiapi/ssiapi/0002-boost-Backport-clang-support.patch new file mode 100644 index 00000000..2eeab54e --- /dev/null +++ b/external/meta-openembedded/meta-oe/recipes-support/ssiapi/ssiapi/0002-boost-Backport-clang-support.patch @@ -0,0 +1,1409 @@ +From ef90544f8df369781a6ef094330c9cfa9f0ee1e4 Mon Sep 17 00:00:00 2001 +From: Khem Raj <raj.khem@gmail.com> +Date: Thu, 29 Aug 2019 14:09:11 -0700 +Subject: [PATCH 2/4] boost: Backport clang support + +backport headers from boost 1.59 + +Signed-off-by: Khem Raj <raj.khem@gmail.com> +--- + lib/boost/config/compiler/clang.hpp | 272 +++++++++ + lib/boost/config/stdlib/libcpp.hpp | 80 +++ + lib/boost/cstdint.hpp | 542 ++++++++++++++++++ + .../detail/sp_counted_base_clang.hpp | 140 +++++ + 4 files changed, 1034 insertions(+) + create mode 100644 lib/boost/config/compiler/clang.hpp + create mode 100644 lib/boost/config/stdlib/libcpp.hpp + create mode 100644 lib/boost/cstdint.hpp + create mode 100644 lib/boost/smart_ptr/detail/sp_counted_base_clang.hpp + +--- /dev/null ++++ b/lib/boost/config/compiler/clang.hpp +@@ -0,0 +1,272 @@ ++ ++// (C) Copyright Douglas Gregor 2010 ++// ++// Use, modification and distribution are subject to 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) ++ ++// See http://www.boost.org for most recent version. ++ ++// Clang compiler setup. ++ ++#define BOOST_HAS_PRAGMA_ONCE ++ ++// Detecting `-fms-extension` compiler flag assuming that _MSC_VER defined when that flag is used. ++#if defined (_MSC_VER) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 4)) ++# define BOOST_HAS_PRAGMA_DETECT_MISMATCH ++#endif ++ ++// When compiling with clang before __has_extension was defined, ++// even if one writes 'defined(__has_extension) && __has_extension(xxx)', ++// clang reports a compiler error. So the only workaround found is: ++ ++#ifndef __has_extension ++#define __has_extension __has_feature ++#endif ++ ++#if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS) ++# define BOOST_NO_EXCEPTIONS ++#endif ++ ++#if !__has_feature(cxx_rtti) && !defined(BOOST_NO_RTTI) ++# define BOOST_NO_RTTI ++#endif ++ ++#if !__has_feature(cxx_rtti) && !defined(BOOST_NO_TYPEID) ++# define BOOST_NO_TYPEID ++#endif ++ ++#if defined(__int64) && !defined(__GNUC__) ++# define BOOST_HAS_MS_INT64 ++#endif ++ ++#define BOOST_HAS_NRVO ++ ++// Branch prediction hints ++#if defined(__has_builtin) ++#if __has_builtin(__builtin_expect) ++#define BOOST_LIKELY(x) __builtin_expect(x, 1) ++#define BOOST_UNLIKELY(x) __builtin_expect(x, 0) ++#endif ++#endif ++ ++// Clang supports "long long" in all compilation modes. ++#define BOOST_HAS_LONG_LONG ++ ++// ++// We disable this if the compiler is really nvcc as it ++// doesn't actually support __int128 as of CUDA_VERSION=5000 ++// even though it defines __SIZEOF_INT128__. ++// See https://svn.boost.org/trac/boost/ticket/10418 ++// Only re-enable this for nvcc if you're absolutely sure ++// of the circumstances under which it's supported: ++// ++#if defined(__SIZEOF_INT128__) && !defined(__CUDACC__) ++# define BOOST_HAS_INT128 ++#endif ++ ++ ++// ++// Dynamic shared object (DSO) and dynamic-link library (DLL) support ++// ++#if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32) ++# define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default"))) ++# define BOOST_SYMBOL_IMPORT ++# define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default"))) ++#endif ++ ++// ++// The BOOST_FALLTHROUGH macro can be used to annotate implicit fall-through ++// between switch labels. ++// ++#if __cplusplus >= 201103L && defined(__has_warning) ++# if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough") ++# define BOOST_FALLTHROUGH [[clang::fallthrough]] ++# endif ++#endif ++ ++#if !__has_feature(cxx_auto_type) ++# define BOOST_NO_CXX11_AUTO_DECLARATIONS ++# define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS ++#endif ++ ++// ++// Currently clang on Windows using VC++ RTL does not support C++11's char16_t or char32_t ++// ++#if defined(_MSC_VER) || !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L) ++# define BOOST_NO_CXX11_CHAR16_T ++# define BOOST_NO_CXX11_CHAR32_T ++#endif ++ ++#if !__has_feature(cxx_constexpr) ++# define BOOST_NO_CXX11_CONSTEXPR ++#endif ++ ++#if !__has_feature(cxx_decltype) ++# define BOOST_NO_CXX11_DECLTYPE ++#endif ++ ++#if !__has_feature(cxx_decltype_incomplete_return_types) ++# define BOOST_NO_CXX11_DECLTYPE_N3276 ++#endif ++ ++#if !__has_feature(cxx_defaulted_functions) ++# define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS ++#endif ++ ++#if !__has_feature(cxx_deleted_functions) ++# define BOOST_NO_CXX11_DELETED_FUNCTIONS ++#endif ++ ++#if !__has_feature(cxx_explicit_conversions) ++# define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS ++#endif ++ ++#if !__has_feature(cxx_default_function_template_args) ++# define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS ++#endif ++ ++#if !__has_feature(cxx_generalized_initializers) ++# define BOOST_NO_CXX11_HDR_INITIALIZER_LIST ++#endif ++ ++#if !__has_feature(cxx_lambdas) ++# define BOOST_NO_CXX11_LAMBDAS ++#endif ++ ++#if !__has_feature(cxx_local_type_template_args) ++# define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS ++#endif ++ ++#if !__has_feature(cxx_noexcept) ++# define BOOST_NO_CXX11_NOEXCEPT ++#endif ++ ++#if !__has_feature(cxx_nullptr) ++# define BOOST_NO_CXX11_NULLPTR ++#endif ++ ++#if !__has_feature(cxx_range_for) ++# define BOOST_NO_CXX11_RANGE_BASED_FOR ++#endif ++ ++#if !__has_feature(cxx_raw_string_literals) ++# define BOOST_NO_CXX11_RAW_LITERALS ++#endif ++ ++#if !__has_feature(cxx_reference_qualified_functions) ++# define BOOST_NO_CXX11_REF_QUALIFIERS ++#endif ++ ++#if !__has_feature(cxx_generalized_initializers) ++# define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX ++#endif ++ ++#if !__has_feature(cxx_rvalue_references) ++# define BOOST_NO_CXX11_RVALUE_REFERENCES ++#endif ++ ++#if !__has_feature(cxx_strong_enums) ++# define BOOST_NO_CXX11_SCOPED_ENUMS ++#endif ++ ++#if !__has_feature(cxx_static_assert) ++# define BOOST_NO_CXX11_STATIC_ASSERT ++#endif ++ ++#if !__has_feature(cxx_alias_templates) ++# define BOOST_NO_CXX11_TEMPLATE_ALIASES ++#endif ++ ++#if !__has_feature(cxx_unicode_literals) ++# define BOOST_NO_CXX11_UNICODE_LITERALS ++#endif ++ ++#if !__has_feature(cxx_variadic_templates) ++# define BOOST_NO_CXX11_VARIADIC_TEMPLATES ++#endif ++ ++#if !__has_feature(cxx_user_literals) ++# define BOOST_NO_CXX11_USER_DEFINED_LITERALS ++#endif ++ ++#if !__has_feature(cxx_alignas) ++# define BOOST_NO_CXX11_ALIGNAS ++#endif ++ ++#if !__has_feature(cxx_trailing_return) ++# define BOOST_NO_CXX11_TRAILING_RESULT_TYPES ++#endif ++ ++#if !__has_feature(cxx_inline_namespaces) ++# define BOOST_NO_CXX11_INLINE_NAMESPACES ++#endif ++ ++#if !__has_feature(cxx_override_control) ++# define BOOST_NO_CXX11_FINAL ++#endif ++ ++#if !(__has_feature(__cxx_binary_literals__) || __has_extension(__cxx_binary_literals__)) ++# define BOOST_NO_CXX14_BINARY_LITERALS ++#endif ++ ++#if !__has_feature(__cxx_decltype_auto__) ++# define BOOST_NO_CXX14_DECLTYPE_AUTO ++#endif ++ ++#if !__has_feature(__cxx_aggregate_nsdmi__) ++# define BOOST_NO_CXX14_AGGREGATE_NSDMI ++#endif ++ ++#if !__has_feature(__cxx_init_captures__) ++# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES ++#endif ++ ++#if !__has_feature(__cxx_generic_lambdas__) ++# define BOOST_NO_CXX14_GENERIC_LAMBDAS ++#endif ++ ++// clang < 3.5 has a defect with dependent type, like following. ++// ++// template <class T> ++// constexpr typename enable_if<pred<T> >::type foo(T &) ++// { } // error: no return statement in constexpr function ++// ++// This issue also affects C++11 mode, but C++11 constexpr requires return stmt. ++// Therefore we don't care such case. ++// ++// Note that we can't check Clang version directly as the numbering system changes depending who's ++// creating the Clang release (see https://github.com/boostorg/config/pull/39#issuecomment-59927873) ++// so instead verify that we have a feature that was introduced at the same time as working C++14 ++// constexpr (generic lambda's in this case): ++// ++#if !__has_feature(__cxx_generic_lambdas__) || !__has_feature(__cxx_relaxed_constexpr__) ++# define BOOST_NO_CXX14_CONSTEXPR ++#endif ++ ++#if !__has_feature(__cxx_return_type_deduction__) ++# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION ++#endif ++ ++#if !__has_feature(__cxx_variable_templates__) ++# define BOOST_NO_CXX14_VARIABLE_TEMPLATES ++#endif ++ ++#if __cplusplus < 201400 ++// All versions with __cplusplus above this value seem to support this: ++# define BOOST_NO_CXX14_DIGIT_SEPARATORS ++#endif ++ ++ ++// Unused attribute: ++#if defined(__GNUC__) && (__GNUC__ >= 4) ++# define BOOST_ATTRIBUTE_UNUSED __attribute__((unused)) ++#endif ++ ++#ifndef BOOST_COMPILER ++# define BOOST_COMPILER "Clang version " __clang_version__ ++#endif ++ ++// Macro used to identify the Clang compiler. ++#define BOOST_CLANG 1 ++ +--- /dev/null ++++ b/lib/boost/config/stdlib/libcpp.hpp +@@ -0,0 +1,80 @@ ++// (C) Copyright Christopher Jefferson 2011. ++// Use, modification and distribution are subject to 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) ++ ++// See http://www.boost.org for most recent version. ++ ++// config for libc++ ++// Might need more in here later. ++ ++#if !defined(_LIBCPP_VERSION) ++# include <ciso646> ++# if !defined(_LIBCPP_VERSION) ++# error "This is not libc++!" ++# endif ++#endif ++ ++#define BOOST_STDLIB "libc++ version " BOOST_STRINGIZE(_LIBCPP_VERSION) ++ ++#define BOOST_HAS_THREADS ++ ++#ifdef _LIBCPP_HAS_NO_VARIADICS ++# define BOOST_NO_CXX11_HDR_TUPLE ++#endif ++ ++// BOOST_NO_CXX11_ALLOCATOR should imply no support for the C++11 ++// allocator model. The C++11 allocator model requires a conforming ++// std::allocator_traits which is only possible with C++11 template ++// aliases since members rebind_alloc and rebind_traits require it. ++#if defined(_LIBCPP_HAS_NO_TEMPLATE_ALIASES) ++# define BOOST_NO_CXX11_ALLOCATOR ++#endif ++ ++#if __cplusplus < 201103 ++# define BOOST_NO_CXX11_HDR_ARRAY ++# define BOOST_NO_CXX11_HDR_CODECVT ++# define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE ++# define BOOST_NO_CXX11_HDR_FORWARD_LIST ++# define BOOST_NO_CXX11_HDR_INITIALIZER_LIST ++# define BOOST_NO_CXX11_HDR_MUTEX ++# define BOOST_NO_CXX11_HDR_RANDOM ++# define BOOST_NO_CXX11_HDR_RATIO ++# define BOOST_NO_CXX11_HDR_REGEX ++# define BOOST_NO_CXX11_HDR_SYSTEM_ERROR ++# define BOOST_NO_CXX11_HDR_THREAD ++# define BOOST_NO_CXX11_HDR_TUPLE ++# define BOOST_NO_CXX11_HDR_TYPEINDEX ++# define BOOST_NO_CXX11_HDR_UNORDERED_MAP ++# define BOOST_NO_CXX11_HDR_UNORDERED_SET ++# define BOOST_NO_CXX11_NUMERIC_LIMITS ++# define BOOST_NO_CXX11_ALLOCATOR ++# define BOOST_NO_CXX11_SMART_PTR ++# define BOOST_NO_CXX11_HDR_FUNCTIONAL ++# define BOOST_NO_CXX11_STD_ALIGN ++# define BOOST_NO_CXX11_ADDRESSOF ++#endif ++ ++// ++// These appear to be unusable/incomplete so far: ++// ++# define BOOST_NO_CXX11_HDR_CHRONO ++# define BOOST_NO_CXX11_HDR_FUTURE ++# define BOOST_NO_CXX11_HDR_TYPE_TRAITS ++# define BOOST_NO_CXX11_ATOMIC_SMART_PTR ++# define BOOST_NO_CXX11_HDR_ATOMIC ++ ++// libc++ uses a non-standard messages_base ++#define BOOST_NO_STD_MESSAGES ++ ++#if defined(__has_include) ++#if !__has_include(<shared_mutex>) ++# define BOOST_NO_CXX14_HDR_SHARED_MUTEX ++#elif __cplusplus <= 201103 ++# define BOOST_NO_CXX14_HDR_SHARED_MUTEX ++#endif ++#elif __cplusplus < 201402 ++# define BOOST_NO_CXX14_HDR_SHARED_MUTEX ++#endif ++ ++// --- end --- +--- /dev/null ++++ b/lib/boost/cstdint.hpp +@@ -0,0 +1,542 @@ ++// boost cstdint.hpp header file ------------------------------------------// ++ ++// (C) Copyright Beman Dawes 1999. ++// (C) Copyright Jens Mauer 2001 ++// (C) Copyright John Maddock 2001 ++// 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) ++ ++// See http://www.boost.org/libs/integer for documentation. ++ ++// Revision History ++// 31 Oct 01 use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.) ++// 16 Apr 01 check LONGLONG_MAX when looking for "long long" (Jens Maurer) ++// 23 Jan 01 prefer "long" over "int" for int32_t and intmax_t (Jens Maurer) ++// 12 Nov 00 Merged <boost/stdint.h> (Jens Maurer) ++// 23 Sep 00 Added INTXX_C macro support (John Maddock). ++// 22 Sep 00 Better 64-bit support (John Maddock) ++// 29 Jun 00 Reimplement to avoid including stdint.h within namespace boost ++// 8 Aug 99 Initial version (Beman Dawes) ++ ++ ++#ifndef BOOST_CSTDINT_HPP ++#define BOOST_CSTDINT_HPP ++ ++// ++// Since we always define the INT#_C macros as per C++0x, ++// define __STDC_CONSTANT_MACROS so that <stdint.h> does the right ++// thing if possible, and so that the user knows that the macros ++// are actually defined as per C99. ++// ++#ifndef __STDC_CONSTANT_MACROS ++# define __STDC_CONSTANT_MACROS ++#endif ++ ++#include <boost/config.hpp> ++ ++// ++// Note that GLIBC is a bit inconsistent about whether int64_t is defined or not ++// depending upon what headers happen to have been included first... ++// so we disable use of stdint.h when GLIBC does not define __GLIBC_HAVE_LONG_LONG. ++// See https://svn.boost.org/trac/boost/ticket/3548 and http://sources.redhat.com/bugzilla/show_bug.cgi?id=10990 ++// ++#if defined(BOOST_HAS_STDINT_H) \ ++ && (!defined(__GLIBC__) \ ++ || defined(__GLIBC_HAVE_LONG_LONG) \ ++ || (defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 17))))) ++ ++// The following #include is an implementation artifact; not part of interface. ++# ifdef __hpux ++// HP-UX has a vaguely nice <stdint.h> in a non-standard location ++# include <inttypes.h> ++# ifdef __STDC_32_MODE__ ++ // this is triggered with GCC, because it defines __cplusplus < 199707L ++# define BOOST_NO_INT64_T ++# endif ++# elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX) ++# include <inttypes.h> ++# else ++# include <stdint.h> ++ ++// There is a bug in Cygwin two _C macros ++# if defined(__STDC_CONSTANT_MACROS) && defined(__CYGWIN__) ++# undef INTMAX_C ++# undef UINTMAX_C ++# define INTMAX_C(c) c##LL ++# define UINTMAX_C(c) c##ULL ++# endif ++ ++# endif ++ ++#ifdef __QNX__ ++ ++// QNX (Dinkumware stdlib) defines these as non-standard names. ++// Reflect to the standard names. ++ ++typedef ::intleast8_t int_least8_t; ++typedef ::intfast8_t int_fast8_t; ++typedef ::uintleast8_t uint_least8_t; ++typedef ::uintfast8_t uint_fast8_t; ++ ++typedef ::intleast16_t int_least16_t; ++typedef ::intfast16_t int_fast16_t; ++typedef ::uintleast16_t uint_least16_t; ++typedef ::uintfast16_t uint_fast16_t; ++ ++typedef ::intleast32_t int_least32_t; ++typedef ::intfast32_t int_fast32_t; ++typedef ::uintleast32_t uint_least32_t; ++typedef ::uintfast32_t uint_fast32_t; ++ ++# ifndef BOOST_NO_INT64_T ++ ++typedef ::intleast64_t int_least64_t; ++typedef ::intfast64_t int_fast64_t; ++typedef ::uintleast64_t uint_least64_t; ++typedef ::uintfast64_t uint_fast64_t; ++ ++# endif ++ ++#endif ++ ++namespace boost ++{ ++ ++ using ::int8_t; ++ using ::int_least8_t; ++ using ::int_fast8_t; ++ using ::uint8_t; ++ using ::uint_least8_t; ++ using ::uint_fast8_t; ++ ++ using ::int16_t; ++ using ::int_least16_t; ++ using ::int_fast16_t; ++ using ::uint16_t; ++ using ::uint_least16_t; ++ using ::uint_fast16_t; ++ ++ using ::int32_t; ++ using ::int_least32_t; ++ using ::int_fast32_t; ++ using ::uint32_t; ++ using ::uint_least32_t; ++ using ::uint_fast32_t; ++ ++# ifndef BOOST_NO_INT64_T ++ ++ using ::int64_t; ++ using ::int_least64_t; ++ using ::int_fast64_t; ++ using ::uint64_t; ++ using ::uint_least64_t; ++ using ::uint_fast64_t; ++ ++# endif ++ ++ using ::intmax_t; ++ using ::uintmax_t; ++ ++} // namespace boost ++ ++#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS) || defined(__SOLARIS9__) || defined(__NetBSD__) ++// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need. ++# include <inttypes.h> ++ ++namespace boost { ++ ++ using ::int8_t; ++ typedef int8_t int_least8_t; ++ typedef int8_t int_fast8_t; ++ using ::uint8_t; ++ typedef uint8_t uint_least8_t; ++ typedef uint8_t uint_fast8_t; ++ ++ using ::int16_t; ++ typedef int16_t int_least16_t; ++ typedef int16_t int_fast16_t; ++ using ::uint16_t; ++ typedef uint16_t uint_least16_t; ++ typedef uint16_t uint_fast16_t; ++ ++ using ::int32_t; ++ typedef int32_t int_least32_t; ++ typedef int32_t int_fast32_t; ++ using ::uint32_t; ++ typedef uint32_t uint_least32_t; ++ typedef uint32_t uint_fast32_t; ++ ++# ifndef BOOST_NO_INT64_T ++ ++ using ::int64_t; ++ typedef int64_t int_least64_t; ++ typedef int64_t int_fast64_t; ++ using ::uint64_t; ++ typedef uint64_t uint_least64_t; ++ typedef uint64_t uint_fast64_t; ++ ++ typedef int64_t intmax_t; ++ typedef uint64_t uintmax_t; ++ ++# else ++ ++ typedef int32_t intmax_t; ++ typedef uint32_t uintmax_t; ++ ++# endif ++ ++} // namespace boost ++ ++#else // BOOST_HAS_STDINT_H ++ ++# include <boost/limits.hpp> // implementation artifact; not part of interface ++# include <limits.h> // needed for limits macros ++ ++ ++namespace boost ++{ ++ ++// These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit ++// platforms. For other systems, they will have to be hand tailored. ++// ++// Because the fast types are assumed to be the same as the undecorated types, ++// it may be possible to hand tailor a more efficient implementation. Such ++// an optimization may be illusionary; on the Intel x86-family 386 on, for ++// example, byte arithmetic and load/stores are as fast as "int" sized ones. ++ ++// 8-bit types ------------------------------------------------------------// ++ ++# if UCHAR_MAX == 0xff ++ typedef signed char int8_t; ++ typedef signed char int_least8_t; ++ typedef signed char int_fast8_t; ++ typedef unsigned char uint8_t; ++ typedef unsigned char uint_least8_t; ++ typedef unsigned char uint_fast8_t; ++# else ++# error defaults not correct; you must hand modify boost/cstdint.hpp ++# endif ++ ++// 16-bit types -----------------------------------------------------------// ++ ++# if USHRT_MAX == 0xffff ++# if defined(__crayx1) ++ // The Cray X1 has a 16-bit short, however it is not recommend ++ // for use in performance critical code. ++ typedef short int16_t; ++ typedef short int_least16_t; ++ typedef int int_fast16_t; ++ typedef unsigned short uint16_t; ++ typedef unsigned short uint_least16_t; ++ typedef unsigned int uint_fast16_t; ++# else ++ typedef short int16_t; ++ typedef short int_least16_t; ++ typedef short int_fast16_t; ++ typedef unsigned short uint16_t; ++ typedef unsigned short uint_least16_t; ++ typedef unsigned short uint_fast16_t; ++# endif ++# elif (USHRT_MAX == 0xffffffff) && defined(__MTA__) ++ // On MTA / XMT short is 32 bits unless the -short16 compiler flag is specified ++ // MTA / XMT does support the following non-standard integer types ++ typedef __short16 int16_t; ++ typedef __short16 int_least16_t; ++ typedef __short16 int_fast16_t; ++ typedef unsigned __short16 uint16_t; ++ typedef unsigned __short16 uint_least16_t; ++ typedef unsigned __short16 uint_fast16_t; ++# elif (USHRT_MAX == 0xffffffff) && defined(CRAY) ++ // no 16-bit types on Cray: ++ typedef short int_least16_t; ++ typedef short int_fast16_t; ++ typedef unsigned short uint_least16_t; ++ typedef unsigned short uint_fast16_t; ++# else ++# error defaults not correct; you must hand modify boost/cstdint.hpp ++# endif ++ ++// 32-bit types -----------------------------------------------------------// ++ ++# if UINT_MAX == 0xffffffff ++ typedef int int32_t; ++ typedef int int_least32_t; ++ typedef int int_fast32_t; ++ typedef unsigned int uint32_t; ++ typedef unsigned int uint_least32_t; ++ typedef unsigned int uint_fast32_t; ++# elif (USHRT_MAX == 0xffffffff) ++ typedef short int32_t; ++ typedef short int_least32_t; ++ typedef short int_fast32_t; ++ typedef unsigned short uint32_t; ++ typedef unsigned short uint_least32_t; ++ typedef unsigned short uint_fast32_t; ++# elif ULONG_MAX == 0xffffffff ++ typedef long int32_t; ++ typedef long int_least32_t; ++ typedef long int_fast32_t; ++ typedef unsigned long uint32_t; ++ typedef unsigned long uint_least32_t; ++ typedef unsigned long uint_fast32_t; ++# elif (UINT_MAX == 0xffffffffffffffff) && defined(__MTA__) ++ // Integers are 64 bits on the MTA / XMT ++ typedef __int32 int32_t; ++ typedef __int32 int_least32_t; ++ typedef __int32 int_fast32_t; ++ typedef unsigned __int32 uint32_t; ++ typedef unsigned __int32 uint_least32_t; ++ typedef unsigned __int32 uint_fast32_t; ++# else ++# error defaults not correct; you must hand modify boost/cstdint.hpp ++# endif ++ ++// 64-bit types + intmax_t and uintmax_t ----------------------------------// ++ ++# if defined(BOOST_HAS_LONG_LONG) && \ ++ !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \ ++ (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \ ++ (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) ++# if defined(__hpux) ++ // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions ++# elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) ++ // 2**64 - 1 ++# else ++# error defaults not correct; you must hand modify boost/cstdint.hpp ++# endif ++ ++ typedef ::boost::long_long_type intmax_t; ++ typedef ::boost::ulong_long_type uintmax_t; ++ typedef ::boost::long_long_type int64_t; ++ typedef ::boost::long_long_type int_least64_t; ++ typedef ::boost::long_long_type int_fast64_t; ++ typedef ::boost::ulong_long_type uint64_t; ++ typedef ::boost::ulong_long_type uint_least64_t; ++ typedef ::boost::ulong_long_type uint_fast64_t; ++ ++# elif ULONG_MAX != 0xffffffff ++ ++# if ULONG_MAX == 18446744073709551615 // 2**64 - 1 ++ typedef long intmax_t; ++ typedef unsigned long uintmax_t; ++ typedef long int64_t; ++ typedef long int_least64_t; ++ typedef long int_fast64_t; ++ typedef unsigned long uint64_t; ++ typedef unsigned long uint_least64_t; ++ typedef unsigned long uint_fast64_t; ++# else ++# error defaults not correct; you must hand modify boost/cstdint.hpp ++# endif ++# elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG) ++ __extension__ typedef long long intmax_t; ++ __extension__ typedef unsigned long long uintmax_t; ++ __extension__ typedef long long int64_t; ++ __extension__ typedef long long int_least64_t; ++ __extension__ typedef long long int_fast64_t; ++ __extension__ typedef unsigned long long uint64_t; ++ __extension__ typedef unsigned long long uint_least64_t; ++ __extension__ typedef unsigned long long uint_fast64_t; ++# elif defined(BOOST_HAS_MS_INT64) ++ // ++ // we have Borland/Intel/Microsoft __int64: ++ // ++ typedef __int64 intmax_t; ++ typedef unsigned __int64 uintmax_t; ++ typedef __int64 int64_t; ++ typedef __int64 int_least64_t; ++ typedef __int64 int_fast64_t; ++ typedef unsigned __int64 uint64_t; ++ typedef unsigned __int64 uint_least64_t; ++ typedef unsigned __int64 uint_fast64_t; ++# else // assume no 64-bit integers ++# define BOOST_NO_INT64_T ++ typedef int32_t intmax_t; ++ typedef uint32_t uintmax_t; ++# endif ++ ++} // namespace boost ++ ++ ++#endif // BOOST_HAS_STDINT_H ++ ++// intptr_t/uintptr_t are defined separately because they are optional and not universally available ++#if defined(BOOST_WINDOWS) && !defined(_WIN32_WCE) && !defined(BOOST_HAS_STDINT_H) ++// Older MSVC don't have stdint.h and have intptr_t/uintptr_t defined in stddef.h ++#include <stddef.h> ++#endif ++ ++// PGI seems to not support intptr_t/uintptr_t properly. BOOST_HAS_STDINT_H is not defined for this compiler by Boost.Config. ++#if !defined(__PGIC__) ++ ++#if (defined(BOOST_WINDOWS) && !defined(_WIN32_WCE)) \ ++ || (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \ ++ || defined(__CYGWIN__) \ ++ || defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \ ++ || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(sun) ++ ++namespace boost { ++ using ::intptr_t; ++ using ::uintptr_t; ++} ++#define BOOST_HAS_INTPTR_T ++ ++// Clang pretends to be GCC, so it'll match this condition ++#elif defined(__GNUC__) && defined(__INTPTR_TYPE__) && defined(__UINTPTR_TYPE__) ++ ++namespace boost { ++ typedef __INTPTR_TYPE__ intptr_t; ++ typedef __UINTPTR_TYPE__ uintptr_t; ++} ++#define BOOST_HAS_INTPTR_T ++ ++#endif ++ ++#endif // !defined(__PGIC__) ++ ++#endif // BOOST_CSTDINT_HPP ++ ++ ++/**************************************************** ++ ++Macro definition section: ++ ++Added 23rd September 2000 (John Maddock). ++Modified 11th September 2001 to be excluded when ++BOOST_HAS_STDINT_H is defined (John Maddock). ++Modified 11th Dec 2009 to always define the ++INT#_C macros if they're not already defined (John Maddock). ++ ++******************************************************/ ++ ++#if !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && \ ++ (!defined(INT8_C) || !defined(INT16_C) || !defined(INT32_C) || !defined(INT64_C)) ++// ++// For the following code we get several warnings along the lines of: ++// ++// boost/cstdint.hpp:428:35: error: use of C99 long long integer constant ++// ++// So we declare this a system header to suppress these warnings. ++// ++#if defined(__GNUC__) && (__GNUC__ >= 4) ++#pragma GCC system_header ++#endif ++ ++#include <limits.h> ++# define BOOST__STDC_CONSTANT_MACROS_DEFINED ++# if defined(BOOST_HAS_MS_INT64) ++// ++// Borland/Intel/Microsoft compilers have width specific suffixes: ++// ++#ifndef INT8_C ++# define INT8_C(value) value##i8 ++#endif ++#ifndef INT16_C ++# define INT16_C(value) value##i16 ++#endif ++#ifndef INT32_C ++# define INT32_C(value) value##i32 ++#endif ++#ifndef INT64_C ++# define INT64_C(value) value##i64 ++#endif ++# ifdef __BORLANDC__ ++ // Borland bug: appending ui8 makes the type a signed char ++# define UINT8_C(value) static_cast<unsigned char>(value##u) ++# else ++# define UINT8_C(value) value##ui8 ++# endif ++#ifndef UINT16_C ++# define UINT16_C(value) value##ui16 ++#endif ++#ifndef UINT32_C ++# define UINT32_C(value) value##ui32 ++#endif ++#ifndef UINT64_C ++# define UINT64_C(value) value##ui64 ++#endif ++#ifndef INTMAX_C ++# define INTMAX_C(value) value##i64 ++# define UINTMAX_C(value) value##ui64 ++#endif ++ ++# else ++// do it the old fashioned way: ++ ++// 8-bit types ------------------------------------------------------------// ++ ++# if (UCHAR_MAX == 0xff) && !defined(INT8_C) ++# define INT8_C(value) static_cast<boost::int8_t>(value) ++# define UINT8_C(value) static_cast<boost::uint8_t>(value##u) ++# endif ++ ++// 16-bit types -----------------------------------------------------------// ++ ++# if (USHRT_MAX == 0xffff) && !defined(INT16_C) ++# define INT16_C(value) static_cast<boost::int16_t>(value) ++# define UINT16_C(value) static_cast<boost::uint16_t>(value##u) ++# endif ++ ++// 32-bit types -----------------------------------------------------------// ++#ifndef INT32_C ++# if (UINT_MAX == 0xffffffff) ++# define INT32_C(value) value ++# define UINT32_C(value) value##u ++# elif ULONG_MAX == 0xffffffff ++# define INT32_C(value) value##L ++# define UINT32_C(value) value##uL ++# endif ++#endif ++ ++// 64-bit types + intmax_t and uintmax_t ----------------------------------// ++#ifndef INT64_C ++# if defined(BOOST_HAS_LONG_LONG) && \ ++ (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX) || defined(_ULLONG_MAX) || defined(_LLONG_MAX)) ++ ++# if defined(__hpux) ++ // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions ++# define INT64_C(value) value##LL ++# define UINT64_C(value) value##uLL ++# elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || \ ++ (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || \ ++ (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) || \ ++ (defined(_ULLONG_MAX) && _ULLONG_MAX == 18446744073709551615ULL) || \ ++ (defined(_LLONG_MAX) && _LLONG_MAX == 9223372036854775807LL) ++ ++# define INT64_C(value) value##LL ++# define UINT64_C(value) value##uLL ++# else ++# error defaults not correct; you must hand modify boost/cstdint.hpp ++# endif ++# elif ULONG_MAX != 0xffffffff ++ ++# if ULONG_MAX == 18446744073709551615U // 2**64 - 1 ++# define INT64_C(value) value##L ++# define UINT64_C(value) value##uL ++# else ++# error defaults not correct; you must hand modify boost/cstdint.hpp ++# endif ++# elif defined(BOOST_HAS_LONG_LONG) ++ // Usual macros not defined, work things out for ourselves: ++# if(~0uLL == 18446744073709551615ULL) ++# define INT64_C(value) value##LL ++# define UINT64_C(value) value##uLL ++# else ++# error defaults not correct; you must hand modify boost/cstdint.hpp ++# endif ++# else ++# error defaults not correct; you must hand modify boost/cstdint.hpp ++# endif ++ ++# ifdef BOOST_NO_INT64_T ++# define INTMAX_C(value) INT32_C(value) ++# define UINTMAX_C(value) UINT32_C(value) ++# else ++# define INTMAX_C(value) INT64_C(value) ++# define UINTMAX_C(value) UINT64_C(value) ++# endif ++#endif ++# endif // Borland/Microsoft specific width suffixes ++ ++#endif // INT#_C macros. +--- /dev/null ++++ b/lib/boost/smart_ptr/detail/sp_counted_base_clang.hpp +@@ -0,0 +1,140 @@ ++#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED ++#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED ++ ++// MS compatible compilers support #pragma once ++ ++#if defined(_MSC_VER) && (_MSC_VER >= 1020) ++# pragma once ++#endif ++ ++// detail/sp_counted_base_clang.hpp - __c11 clang intrinsics ++// ++// Copyright (c) 2007, 2013, 2015 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/sp_typeinfo.hpp> ++#include <boost/cstdint.hpp> ++ ++namespace boost ++{ ++ ++namespace detail ++{ ++ ++typedef _Atomic( boost::int_least32_t ) atomic_int_least32_t; ++ ++inline void atomic_increment( atomic_int_least32_t * pw ) ++{ ++ __c11_atomic_fetch_add( pw, 1, __ATOMIC_RELAXED ); ++} ++ ++inline boost::int_least32_t atomic_decrement( atomic_int_least32_t * pw ) ++{ ++ return __c11_atomic_fetch_sub( pw, 1, __ATOMIC_ACQ_REL ); ++} ++ ++inline boost::int_least32_t atomic_conditional_increment( atomic_int_least32_t * pw ) ++{ ++ // long r = *pw; ++ // if( r != 0 ) ++*pw; ++ // return r; ++ ++ boost::int_least32_t r = __c11_atomic_load( pw, __ATOMIC_RELAXED ); ++ ++ for( ;; ) ++ { ++ if( r == 0 ) ++ { ++ return r; ++ } ++ ++ if( __c11_atomic_compare_exchange_weak( pw, &r, r + 1, __ATOMIC_RELAXED, __ATOMIC_RELAXED ) ) ++ { ++ return r; ++ } ++ } ++} ++ ++class sp_counted_base ++{ ++private: ++ ++ sp_counted_base( sp_counted_base const & ); ++ sp_counted_base & operator= ( sp_counted_base const & ); ++ ++ atomic_int_least32_t use_count_; // #shared ++ atomic_int_least32_t weak_count_; // #weak + (#shared != 0) ++ ++public: ++ ++ sp_counted_base() ++ { ++ __c11_atomic_init( &use_count_, 1 ); ++ __c11_atomic_init( &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( sp_typeinfo const & ti ) = 0; ++ virtual void * get_untyped_deleter() = 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_ ) == 1 ) ++ { ++ dispose(); ++ weak_release(); ++ } ++ } ++ ++ void weak_add_ref() // nothrow ++ { ++ atomic_increment( &weak_count_ ); ++ } ++ ++ void weak_release() // nothrow ++ { ++ if( atomic_decrement( &weak_count_ ) == 1 ) ++ { ++ destroy(); ++ } ++ } ++ ++ long use_count() const // nothrow ++ { ++ return __c11_atomic_load( const_cast< atomic_int_least32_t* >( &use_count_ ), __ATOMIC_ACQUIRE ); ++ } ++}; ++ ++} // namespace detail ++ ++} // namespace boost ++ ++#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED +--- /dev/null ++++ b/lib/boost/smart_ptr/detail/sp_counted_base_sync.hpp +@@ -0,0 +1,156 @@ ++#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SYNC_HPP_INCLUDED ++#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SYNC_HPP_INCLUDED ++ ++// MS compatible compilers support #pragma once ++ ++#if defined(_MSC_VER) && (_MSC_VER >= 1020) ++# pragma once ++#endif ++ ++// detail/sp_counted_base_sync.hpp - g++ 4.1+ __sync intrinsics ++// ++// Copyright (c) 2007 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/sp_typeinfo.hpp> ++#include <limits.h> ++ ++#if defined( __ia64__ ) && defined( __INTEL_COMPILER ) ++# include <ia64intrin.h> ++#endif ++ ++namespace boost ++{ ++ ++namespace detail ++{ ++ ++#if INT_MAX >= 2147483647 ++ ++typedef int sp_int32_t; ++ ++#else ++ ++typedef long sp_int32_t; ++ ++#endif ++ ++inline void atomic_increment( sp_int32_t * pw ) ++{ ++ __sync_fetch_and_add( pw, 1 ); ++} ++ ++inline sp_int32_t atomic_decrement( sp_int32_t * pw ) ++{ ++ return __sync_fetch_and_add( pw, -1 ); ++} ++ ++inline sp_int32_t atomic_conditional_increment( sp_int32_t * pw ) ++{ ++ // long r = *pw; ++ // if( r != 0 ) ++*pw; ++ // return r; ++ ++ sp_int32_t r = *pw; ++ ++ for( ;; ) ++ { ++ if( r == 0 ) ++ { ++ return r; ++ } ++ ++ sp_int32_t r2 = __sync_val_compare_and_swap( pw, r, r + 1 ); ++ ++ if( r2 == r ) ++ { ++ return r; ++ } ++ else ++ { ++ r = r2; ++ } ++ } ++} ++ ++class sp_counted_base ++{ ++private: ++ ++ sp_counted_base( sp_counted_base const & ); ++ sp_counted_base & operator= ( sp_counted_base const & ); ++ ++ sp_int32_t use_count_; // #shared ++ sp_int32_t 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( sp_typeinfo const & ti ) = 0; ++ virtual void * get_untyped_deleter() = 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_ ) == 1 ) ++ { ++ dispose(); ++ weak_release(); ++ } ++ } ++ ++ void weak_add_ref() // nothrow ++ { ++ atomic_increment( &weak_count_ ); ++ } ++ ++ void weak_release() // nothrow ++ { ++ if( atomic_decrement( &weak_count_ ) == 1 ) ++ { ++ destroy(); ++ } ++ } ++ ++ long use_count() const // nothrow ++ { ++ return const_cast< sp_int32_t const volatile & >( use_count_ ); ++ } ++}; ++ ++} // namespace detail ++ ++} // namespace boost ++ ++#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SYNC_HPP_INCLUDED +--- /dev/null ++++ b/lib/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp +@@ -0,0 +1,182 @@ ++#ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_MIPS_HPP_INCLUDED ++#define BOOST_DETAIL_SP_COUNTED_BASE_GCC_MIPS_HPP_INCLUDED ++ ++// MS compatible compilers support #pragma once ++ ++#if defined(_MSC_VER) && (_MSC_VER >= 1020) ++# pragma once ++#endif ++ ++// ++// detail/sp_counted_base_gcc_mips.hpp - g++ on MIPS ++// ++// Copyright (c) 2009, Spirent Communications, Inc. ++// ++// 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 <boost/detail/sp_typeinfo.hpp> ++ ++namespace boost ++{ ++ ++namespace detail ++{ ++ ++inline void atomic_increment( int * pw ) ++{ ++ // ++*pw; ++ ++ int tmp; ++ ++ __asm__ __volatile__ ++ ( ++ "0:\n\t" ++ ".set push\n\t" ++ ".set mips2\n\t" ++ "ll %0, %1\n\t" ++ "addiu %0, 1\n\t" ++ "sc %0, %1\n\t" ++ ".set pop\n\t" ++ "beqz %0, 0b": ++ "=&r"( tmp ), "=m"( *pw ): ++ "m"( *pw ) ++ ); ++} ++ ++inline int atomic_decrement( int * pw ) ++{ ++ // return --*pw; ++ ++ int rv, tmp; ++ ++ __asm__ __volatile__ ++ ( ++ "0:\n\t" ++ ".set push\n\t" ++ ".set mips2\n\t" ++ "ll %1, %2\n\t" ++ "addiu %0, %1, -1\n\t" ++ "sc %0, %2\n\t" ++ ".set pop\n\t" ++ "beqz %0, 0b\n\t" ++ "addiu %0, %1, -1": ++ "=&r"( rv ), "=&r"( tmp ), "=m"( *pw ): ++ "m"( *pw ): ++ "memory" ++ ); ++ ++ return rv; ++} ++ ++inline int atomic_conditional_increment( int * pw ) ++{ ++ // if( *pw != 0 ) ++*pw; ++ // return *pw; ++ ++ int rv, tmp; ++ ++ __asm__ __volatile__ ++ ( ++ "0:\n\t" ++ ".set push\n\t" ++ ".set mips2\n\t" ++ "ll %0, %2\n\t" ++ "beqz %0, 1f\n\t" ++ "addiu %1, %0, 1\n\t" ++ "sc %1, %2\n\t" ++ ".set pop\n\t" ++ "beqz %1, 0b\n\t" ++ "addiu %0, %0, 1\n\t" ++ "1:": ++ "=&r"( rv ), "=&r"( tmp ), "=m"( *pw ): ++ "m"( *pw ): ++ "memory" ++ ); ++ ++ 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( sp_typeinfo const & ti ) = 0; ++ virtual void * get_untyped_deleter() = 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<int const volatile &>( use_count_ ); ++ } ++}; ++ ++} // namespace detail ++ ++} // namespace boost ++ ++#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_MIPS_HPP_INCLUDED |