|
@@ -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
|