diff options
92 files changed, 3019 insertions, 1346 deletions
diff --git a/ObsoleteFiles.inc b/ObsoleteFiles.inc index 325999495541..d79639622008 100644 --- a/ObsoleteFiles.inc +++ b/ObsoleteFiles.inc @@ -38,6 +38,8 @@ # xargs -n1 | sort | uniq -d; # done +# 2015mmdd: new libc++ import +OLD_FILES+=usr/include/c++/__tuple_03 # 2015mmdd: new clang import which bumps version from 3.6.1 to 3.7.0. OLD_FILES+=usr/lib/clang/3.6.1/include/__stddef_max_align_t.h OLD_FILES+=usr/lib/clang/3.6.1/include/__wmmintrin_aes.h diff --git a/contrib/libc++/CREDITS.TXT b/contrib/libc++/CREDITS.TXT index 7a28adae0965..1cf713a68842 100644 --- a/contrib/libc++/CREDITS.TXT +++ b/contrib/libc++/CREDITS.TXT @@ -12,6 +12,10 @@ N: Saleem Abdulrasool E: compnerd@compnerd.org D: Minor patches and Linux fixes. +N: Dan Albert +E: danalbert@google.com +D: Android support and test runner improvements. + N: Dimitry Andric E: dimitry@andric.com D: Visibility fixes, minor FreeBSD portability patches. @@ -84,6 +88,10 @@ N: Nico Rieck E: nico.rieck@gmail.com D: Windows fixes +N: Jon Roelofs +E: jonathan@codesourcery.com +D: Remote testing, Newlib port, baremetal/single-threaded support. + N: Jonathan Sauer D: Minor patches, mostly related to constexpr @@ -105,6 +113,9 @@ D: Minor <atomic> fix N: Michael van der Westhuizen E: r1mikey at gmail dot com +N: Larisse Voufo +D: Minor patches. + N: Klaas de Vries E: klaas at klaasgaaf dot nl D: Minor bug fix. diff --git a/contrib/libc++/LICENSE.TXT b/contrib/libc++/LICENSE.TXT index 41ca5d19cc65..53352e42dd1f 100644 --- a/contrib/libc++/LICENSE.TXT +++ b/contrib/libc++/LICENSE.TXT @@ -14,7 +14,7 @@ Full text of the relevant licenses is included below. University of Illinois/NCSA Open Source License -Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT +Copyright (c) 2009-2015 by the contributors listed in CREDITS.TXT All rights reserved. diff --git a/contrib/libc++/include/__config b/contrib/libc++/include/__config index c5b9a6b1cbff..8288b46a8892 100644 --- a/contrib/libc++/include/__config +++ b/contrib/libc++/include/__config @@ -17,14 +17,11 @@ #ifdef __GNUC__ #define _GNUC_VER (__GNUC__ * 100 + __GNUC_MINOR__) +#else +#define _GNUC_VER 0 #endif -#if !_WIN32 -#include <unistd.h> -#include <errno.h> // for ELAST on FreeBSD -#endif - -#define _LIBCPP_VERSION 1101 +#define _LIBCPP_VERSION 3700 #define _LIBCPP_ABI_VERSION 1 @@ -33,6 +30,23 @@ #define _LIBCPP_NAMESPACE _LIBCPP_CONCAT(__,_LIBCPP_ABI_VERSION) + +#ifndef __has_attribute +#define __has_attribute(__x) 0 +#endif +#ifndef __has_builtin +#define __has_builtin(__x) 0 +#endif +#ifndef __has_feature +#define __has_feature(__x) 0 +#endif +// '__is_identifier' returns '0' if '__x' is a reserved identifier provided by +// the compiler and '1' otherwise. +#ifndef __is_identifier +#define __is_identifier(__x) 1 +#endif + + #ifdef __LITTLE_ENDIAN__ #if __LITTLE_ENDIAN__ #define _LIBCPP_LITTLE_ENDIAN 1 @@ -76,10 +90,8 @@ #ifdef _WIN32 # define _LIBCPP_LITTLE_ENDIAN 1 # define _LIBCPP_BIG_ENDIAN 0 -// Compiler intrinsics (GCC or MSVC) -# if defined(__clang__) \ - || (defined(_MSC_VER) && _MSC_VER >= 1400) \ - || (defined(__GNUC__) && _GNUC_VER > 403) +// Compiler intrinsics (MSVC) +#if defined(_MSC_VER) && _MSC_VER >= 1400 # define _LIBCPP_HAS_IS_BASE_OF # endif # if defined(_MSC_VER) && !defined(__clang__) @@ -94,12 +106,6 @@ # endif #endif // _WIN32 -#ifdef __linux__ -# if defined(__GNUC__) && _GNUC_VER >= 403 -# define _LIBCPP_HAS_IS_BASE_OF -# endif -#endif - #ifdef __sun__ # include <sys/isa_defs.h> # ifdef _LITTLE_ENDIAN @@ -111,12 +117,22 @@ # endif #endif // __sun__ -#if defined(__native_client__) +#if defined(__CloudABI__) + // Certain architectures provide arc4random(). Prefer using + // arc4random() over /dev/{u,}random to make it possible to obtain + // random data even when using sandboxing mechanisms such as chroots, + // Capsicum, etc. +# define _LIBCPP_USING_ARC4_RANDOM +#elif defined(__native_client__) // NaCl's sandbox (which PNaCl also runs in) doesn't allow filesystem access, // including accesses to the special files under /dev. C++11's // std::random_device is instead exposed through a NaCl syscall. # define _LIBCPP_USING_NACL_RANDOM -#endif // defined(__native_client__) +#elif defined(_WIN32) +# define _LIBCPP_USING_WIN32_RANDOM +#else +# define _LIBCPP_USING_DEV_RANDOM +#endif #if !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN) # include <endian.h> @@ -173,10 +189,6 @@ #endif // _WIN32 -#ifndef __has_attribute -#define __has_attribute(__x) 0 -#endif - #ifndef _LIBCPP_HIDDEN #define _LIBCPP_HIDDEN __attribute__ ((__visibility__("hidden"))) #endif @@ -309,6 +321,10 @@ typedef __char32_t char32_t; # define _LIBCPP_HAS_IS_BASE_OF #endif +#if __has_feature(is_final) +# define _LIBCPP_HAS_IS_FINAL +#endif + // Objective-C++ features (opt-in) #if __has_feature(objc_arc) #define _LIBCPP_HAS_OBJC_ARC @@ -327,6 +343,10 @@ typedef __char32_t char32_t; #define _LIBCPP_HAS_NO_CXX14_CONSTEXPR #endif +#if !(__has_feature(cxx_variable_templates)) +#define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES +#endif + #if __ISO_C_VISIBLE >= 2011 || __cplusplus >= 201103L #if defined(__FreeBSD__) #define _LIBCPP_HAS_QUICK_EXIT @@ -388,6 +408,11 @@ namespace std { #if _GNUC_VER >= 407 #define _LIBCPP_UNDERLYING_TYPE(T) __underlying_type(T) #define _LIBCPP_IS_LITERAL(T) __is_literal_type(T) +#define _LIBCPP_HAS_IS_FINAL +#endif + +#if defined(__GNUC__) && _GNUC_VER >= 403 +# define _LIBCPP_HAS_IS_BASE_OF #endif #if !__EXCEPTIONS @@ -406,6 +431,8 @@ namespace std { // No version of GCC supports relaxed constexpr rules #define _LIBCPP_HAS_NO_CXX14_CONSTEXPR +// GCC 5 will support variable templates +#define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES #define _NOEXCEPT throw() #define _NOEXCEPT_(x) @@ -477,6 +504,7 @@ using namespace _LIBCPP_NAMESPACE __attribute__((__strong__)); #define _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER #define _LIBCPP_HAS_NO_CONSTEXPR #define _LIBCPP_HAS_NO_CXX14_CONSTEXPR +#define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES #define _LIBCPP_HAS_NO_UNICODE_CHARS #define _LIBCPP_HAS_NO_DELETED_FUNCTIONS #define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS @@ -519,6 +547,8 @@ namespace std { #define _LIBCPP_HAS_NO_NULLPTR #define _LIBCPP_HAS_NO_UNICODE_CHARS #define _LIBCPP_HAS_IS_BASE_OF +#define _LIBCPP_HAS_IS_FINAL +#define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES #if defined(_AIX) #define __MULTILOCALE_API @@ -558,7 +588,12 @@ template <unsigned> struct __static_assert_check {}; #endif // _LIBCPP_HAS_NO_STATIC_ASSERT #ifdef _LIBCPP_HAS_NO_DECLTYPE -#define decltype(x) __typeof__(x) +// GCC 4.6 provides __decltype in all standard modes. +#if !__is_identifier(__decltype) || _GNUC_VER >= 406 +# define decltype(__x) __decltype(__x) +#else +# define decltype(__x) __typeof__(__x) +#endif #endif #ifdef _LIBCPP_HAS_NO_CONSTEXPR @@ -579,14 +614,6 @@ template <unsigned> struct __static_assert_check {}; #define _NOALIAS #endif -#ifndef __has_feature -#define __has_feature(__x) 0 -#endif - -#ifndef __has_builtin -#define __has_builtin(__x) 0 -#endif - #if __has_feature(cxx_explicit_conversions) || defined(__IBMCPP__) # define _LIBCPP_EXPLICIT explicit #else @@ -633,10 +660,16 @@ template <unsigned> struct __static_assert_check {}; #define _LIBCPP_NONUNIQUE_RTTI_BIT (1ULL << 63) #endif -#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_WIN32) || defined(__sun__) || defined(__NetBSD__) +#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_WIN32) || \ + defined(__sun__) || defined(__NetBSD__) || defined(__CloudABI__) #define _LIBCPP_LOCALE__L_EXTENSIONS 1 #endif +#if !defined(_WIN32) && !defined(__ANDROID__) && !defined(_NEWLIB_VERSION) && \ + !defined(__CloudABI__) +#define _LIBCPP_HAS_CATOPEN 1 +#endif + #ifdef __FreeBSD__ #define _DECLARE_C99_LDBL_MATH 1 #endif @@ -649,21 +682,6 @@ template <unsigned> struct __static_assert_check {}; #define _LIBCPP_WCTYPE_IS_MASK #endif -#if defined(ELAST) -#define _LIBCPP_ELAST ELAST -#elif defined(__linux__) -#define _LIBCPP_ELAST 4095 -#elif defined(_NEWLIB_VERSION) -#define _LIBCPP_ELAST __ELASTERROR -#elif defined(__APPLE__) -// Not _LIBCPP_ELAST needed on Apple -#elif defined(__sun__) -#define _LIBCPP_ELAST ESTALE -#else -// Warn here so that the person doing the libcxx port has an easier time: -#warning This platform's ELAST hasn't been ported yet -#endif - #ifndef _LIBCPP_TRIVIAL_PAIR_COPY_CTOR # if defined(__FreeBSD__) // Making the std::pair copy constructor trivial breaks ABI compatibility with @@ -731,4 +749,29 @@ extern "C" void __sanitizer_annotate_contiguous_container( _LIBCPP_HAS_NO_THREADS is defined. #endif +// Systems that use capability-based security (FreeBSD with Capsicum, +// Nuxi CloudABI) may only provide local filesystem access (using *at()). +// Functions like open(), rename(), unlink() and stat() should not be +// used, as they attempt to access the global filesystem namespace. +#ifdef __CloudABI__ +#define _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE +#endif + +// CloudABI is intended for running networked services. Processes do not +// have standard input and output channels. +#ifdef __CloudABI__ +#define _LIBCPP_HAS_NO_STDIN +#define _LIBCPP_HAS_NO_STDOUT +#endif + +#if defined(__ANDROID__) || defined(__CloudABI__) +#define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE +#endif + +// Thread-unsafe functions such as strtok(), mbtowc() and localtime() +// are not available. +#ifdef __CloudABI__ +#define _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS +#endif + #endif // _LIBCPP_CONFIG diff --git a/contrib/libc++/include/__debug b/contrib/libc++/include/__debug index c1512246bfcf..a21f9a89884b 100644 --- a/contrib/libc++/include/__debug +++ b/contrib/libc++/include/__debug @@ -22,7 +22,7 @@ # include <cstdio> # include <cstddef> # ifndef _LIBCPP_ASSERT -# define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (_VSTD::printf("%s\n", m), _VSTD::abort())) +# define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (_VSTD::fprintf(stderr, "%s\n", m), _VSTD::abort())) # endif #endif diff --git a/contrib/libc++/include/__functional_03 b/contrib/libc++/include/__functional_03 index d8a9f05fa124..13c38d8548d9 100644 --- a/contrib/libc++/include/__functional_03 +++ b/contrib/libc++/include/__functional_03 @@ -333,7 +333,8 @@ template<class _Fp, class _Alloc, class _Rp> __base<_Rp()>* __func<_Fp, _Alloc, _Rp()>::__clone() const { - typedef typename _Alloc::template rebind<__func>::other _Ap; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; _Ap __a(__f_.second()); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); @@ -359,7 +360,8 @@ template<class _Fp, class _Alloc, class _Rp> void __func<_Fp, _Alloc, _Rp()>::destroy_deallocate() { - typedef typename _Alloc::template rebind<__func>::other _Ap; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); @@ -369,7 +371,8 @@ template<class _Fp, class _Alloc, class _Rp> _Rp __func<_Fp, _Alloc, _Rp()>::operator()() { - return __invoke(__f_.first()); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first()); } #ifndef _LIBCPP_NO_RTTI @@ -416,7 +419,8 @@ template<class _Fp, class _Alloc, class _Rp, class _A0> __base<_Rp(_A0)>* __func<_Fp, _Alloc, _Rp(_A0)>::__clone() const { - typedef typename _Alloc::template rebind<__func>::other _Ap; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; _Ap __a(__f_.second()); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); @@ -442,7 +446,8 @@ template<class _Fp, class _Alloc, class _Rp, class _A0> void __func<_Fp, _Alloc, _Rp(_A0)>::destroy_deallocate() { - typedef typename _Alloc::template rebind<__func>::other _Ap; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); @@ -452,7 +457,8 @@ template<class _Fp, class _Alloc, class _Rp, class _A0> _Rp __func<_Fp, _Alloc, _Rp(_A0)>::operator()(_A0 __a0) { - return __invoke(__f_.first(), __a0); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first(), __a0); } #ifndef _LIBCPP_NO_RTTI @@ -499,7 +505,8 @@ template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> __base<_Rp(_A0, _A1)>* __func<_Fp, _Alloc, _Rp(_A0, _A1)>::__clone() const { - typedef typename _Alloc::template rebind<__func>::other _Ap; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; _Ap __a(__f_.second()); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); @@ -525,7 +532,8 @@ template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> void __func<_Fp, _Alloc, _Rp(_A0, _A1)>::destroy_deallocate() { - typedef typename _Alloc::template rebind<__func>::other _Ap; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); @@ -535,7 +543,8 @@ template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> _Rp __func<_Fp, _Alloc, _Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1) { - return __invoke(__f_.first(), __a0, __a1); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first(), __a0, __a1); } #ifndef _LIBCPP_NO_RTTI @@ -582,7 +591,8 @@ template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> __base<_Rp(_A0, _A1, _A2)>* __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::__clone() const { - typedef typename _Alloc::template rebind<__func>::other _Ap; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; _Ap __a(__f_.second()); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); @@ -608,7 +618,8 @@ template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> void __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::destroy_deallocate() { - typedef typename _Alloc::template rebind<__func>::other _Ap; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); @@ -618,7 +629,8 @@ template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> _Rp __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2) { - return __invoke(__f_.first(), __a0, __a1, __a2); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first(), __a0, __a1, __a2); } #ifndef _LIBCPP_NO_RTTI @@ -790,17 +802,11 @@ function<_Rp()>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; - ::new (__f_) _FF(__f); + ::new (__f_) _FF(__f, __a0); } else { - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<_FF> -#else - rebind_alloc<_FF>::other -#endif - _Ap; + typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap; _Ap __a(__a0); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); @@ -827,6 +833,7 @@ function<_Rp()>::operator=(nullptr_t) else if (__f_) __f_->destroy_deallocate(); __f_ = 0; + return *this; } template<class _Rp> @@ -1092,17 +1099,11 @@ function<_Rp(_A0)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; - ::new (__f_) _FF(__f); + ::new (__f_) _FF(__f, __a0); } else { - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<_FF> -#else - rebind_alloc<_FF>::other -#endif - _Ap; + typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap; _Ap __a(__a0); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); @@ -1129,6 +1130,7 @@ function<_Rp(_A0)>::operator=(nullptr_t) else if (__f_) __f_->destroy_deallocate(); __f_ = 0; + return *this; } template<class _Rp, class _A0> @@ -1394,17 +1396,11 @@ function<_Rp(_A0, _A1)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; - ::new (__f_) _FF(__f); + ::new (__f_) _FF(__f, __a0); } else { - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<_FF> -#else - rebind_alloc<_FF>::other -#endif - _Ap; + typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap; _Ap __a(__a0); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); @@ -1431,6 +1427,7 @@ function<_Rp(_A0, _A1)>::operator=(nullptr_t) else if (__f_) __f_->destroy_deallocate(); __f_ = 0; + return *this; } template<class _Rp, class _A0, class _A1> @@ -1696,17 +1693,11 @@ function<_Rp(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc& __a0, _Fp if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; - ::new (__f_) _FF(__f); + ::new (__f_) _FF(__f, __a0); } else { - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<_FF> -#else - rebind_alloc<_FF>::other -#endif - _Ap; + typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap; _Ap __a(__a0); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); @@ -1733,6 +1724,7 @@ function<_Rp(_A0, _A1, _A2)>::operator=(nullptr_t) else if (__f_) __f_->destroy_deallocate(); __f_ = 0; + return *this; } template<class _Rp, class _A0, class _A1, class _A2> @@ -2099,14 +2091,16 @@ public: result_type operator()(_Args&& ...__args) { - return base::operator()(_VSTD::forward<_Args>(__args)...); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...); } template <class ..._Args> result_type operator()(_Args&& ...__args) const { - return base::operator()(_VSTD::forward<_Args>(__args)...); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...); } }; diff --git a/contrib/libc++/include/__functional_base b/contrib/libc++/include/__functional_base index 6766793d7c8a..09424bc025a9 100644 --- a/contrib/libc++/include/__functional_base +++ b/contrib/libc++/include/__functional_base @@ -70,7 +70,9 @@ struct _LIBCPP_TYPE_VIS_ONLY less<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -419,6 +421,26 @@ struct __invoke_return typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type; }; +template <class _Ret> +struct __invoke_void_return_wrapper +{ + template <class ..._Args> + static _Ret __call(_Args&&... __args) + { + return __invoke(_VSTD::forward<_Args>(__args)...); + } +}; + +template <> +struct __invoke_void_return_wrapper<void> +{ + template <class ..._Args> + static void __call(_Args&&... __args) + { + __invoke(_VSTD::forward<_Args>(__args)...); + } +}; + template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper : public __weak_result_type<_Tp> diff --git a/contrib/libc++/include/__functional_base_03 b/contrib/libc++/include/__functional_base_03 index 22c06add90f4..655027786665 100644 --- a/contrib/libc++/include/__functional_base_03 +++ b/contrib/libc++/include/__functional_base_03 @@ -995,6 +995,63 @@ struct __invoke_return2 _VSTD::declval<_A2>())) type; }; +template <class _Ret> +struct __invoke_void_return_wrapper +{ + template <class _Fn> + static _Ret __call(_Fn __f) + { + return __invoke(__f); + } + + template <class _Fn, class _A0> + static _Ret __call(_Fn __f, _A0& __a0) + { + return __invoke(__f, __a0); + } + + template <class _Fn, class _A0, class _A1> + static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1) + { + return __invoke(__f, __a0, __a1); + } + + template <class _Fn, class _A0, class _A1, class _A2> + static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2) + { + return __invoke(__f, __a0, __a1, __a2); + } +}; + + +template <> +struct __invoke_void_return_wrapper<void> +{ + template <class _Fn> + static void __call(_Fn __f) + { + __invoke(__f); + } + + template <class _Fn, class _A0> + static void __call(_Fn __f, _A0& __a0) + { + __invoke(__f, __a0); + } + + template <class _Fn, class _A0, class _A1> + static void __call(_Fn __f, _A0& __a0, _A1& __a1) + { + __invoke(__f, __a0, __a1); + } + + template <class _Fn, class _A0, class _A1, class _A2> + static void __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2) + { + __invoke(__f, __a0, __a1, __a2); + } +}; + template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper : public __weak_result_type<_Tp> diff --git a/contrib/libc++/include/__hash_table b/contrib/libc++/include/__hash_table index 7c954b68011d..f3a20309df71 100644 --- a/contrib/libc++/include/__hash_table +++ b/contrib/libc++/include/__hash_table @@ -19,6 +19,7 @@ #include <cmath> #include <__undef_min_max> +#include <__undef___deallocate> #include <__debug> @@ -61,7 +62,7 @@ struct __hash_node inline _LIBCPP_INLINE_VISIBILITY bool -__is_power2(size_t __bc) +__is_hash_power2(size_t __bc) { return __bc > 2 && !(__bc & (__bc - 1)); } @@ -75,7 +76,7 @@ __constrain_hash(size_t __h, size_t __bc) inline _LIBCPP_INLINE_VISIBILITY size_t -__next_pow2(size_t __n) +__next_hash_pow2(size_t __n) { return size_t(1) << (std::numeric_limits<size_t>::digits - __clz(__n-1)); } @@ -84,8 +85,6 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator; template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator; template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY __hash_map_const_iterator; -template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> - class _LIBCPP_TYPE_VIS_ONLY unordered_map; template <class _NodePtr> class _LIBCPP_TYPE_VIS_ONLY __hash_iterator @@ -776,13 +775,7 @@ public: public: // Create __node typedef __hash_node<value_type, typename __alloc_traits::void_pointer> __node; - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__node> -#else - rebind_alloc<__node>::other -#endif - __node_allocator; + typedef typename __rebind_alloc_helper<__alloc_traits, __node>::type __node_allocator; typedef allocator_traits<__node_allocator> __node_traits; typedef typename __node_traits::pointer __node_pointer; typedef typename __node_traits::pointer __node_const_pointer; @@ -797,13 +790,7 @@ public: private: - typedef typename __node_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__node_pointer> -#else - rebind_alloc<__node_pointer>::other -#endif - __pointer_allocator; + typedef typename __rebind_alloc_helper<__node_traits, __node_pointer>::type __pointer_allocator; typedef __bucket_list_deallocator<__pointer_allocator> __bucket_list_deleter; typedef unique_ptr<__node_pointer[], __bucket_list_deleter> __bucket_list; typedef allocator_traits<__pointer_allocator> __pointer_alloc_traits; @@ -909,11 +896,21 @@ public: iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args); #endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + template <class _ValueTp> + _LIBCPP_INLINE_VISIBILITY + pair<iterator, bool> __insert_unique_value(_ValueTp&& __x); +#else + _LIBCPP_INLINE_VISIBILITY + pair<iterator, bool> __insert_unique_value(const value_type& __x); +#endif + pair<iterator, bool> __insert_unique(const value_type& __x); #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + pair<iterator, bool> __insert_unique(value_type&& __x); template <class _Pp> - pair<iterator, bool> __insert_unique(_Pp&& __x); + pair<iterator, bool> __insert_unique(_Pp&& __x); #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -988,12 +985,14 @@ public: void swap(__hash_table& __u) _NOEXCEPT_( - (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value || - __is_nothrow_swappable<__pointer_allocator>::value) && - (!__node_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value) && - __is_nothrow_swappable<hasher>::value && - __is_nothrow_swappable<key_equal>::value); + __is_nothrow_swappable<hasher>::value && __is_nothrow_swappable<key_equal>::value +#if _LIBCPP_STD_VER <= 11 + && (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value + || __is_nothrow_swappable<__pointer_allocator>::value) + && (!__node_traits::propagate_on_container_swap::value + || __is_nothrow_swappable<__node_allocator>::value) +#endif + ); _LIBCPP_INLINE_VISIBILITY size_type max_bucket_count() const _NOEXCEPT @@ -1121,38 +1120,6 @@ private: _LIBCPP_INLINE_VISIBILITY void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {} - template <class _Ap> - _LIBCPP_INLINE_VISIBILITY - static - void - __swap_alloc(_Ap& __x, _Ap& __y) - _NOEXCEPT_( - !allocator_traits<_Ap>::propagate_on_container_swap::value || - __is_nothrow_swappable<_Ap>::value) - { - __swap_alloc(__x, __y, - integral_constant<bool, - allocator_traits<_Ap>::propagate_on_container_swap::value - >()); - } - - template <class _Ap> - _LIBCPP_INLINE_VISIBILITY - static - void - __swap_alloc(_Ap& __x, _Ap& __y, true_type) - _NOEXCEPT_(__is_nothrow_swappable<_Ap>::value) - { - using _VSTD::swap; - swap(__x, __y); - } - - template <class _Ap> - _LIBCPP_INLINE_VISIBILITY - static - void - __swap_alloc(_Ap&, _Ap&, false_type) _NOEXCEPT {} - void __deallocate(__node_pointer __np) _NOEXCEPT; __node_pointer __detach() _NOEXCEPT; @@ -1615,7 +1582,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __ { if (size()+1 > __bc * max_load_factor() || __bc == 0) { - rehash(_VSTD::max<size_type>(2 * __bc + !__is_power2(__bc), + rehash(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc), size_type(ceil(float(size() + 1) / max_load_factor())))); __bc = bucket_count(); __chash = __constrain_hash(__nd->__hash_, __bc); @@ -1658,7 +1625,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __c size_type __bc = bucket_count(); if (size()+1 > __bc * max_load_factor() || __bc == 0) { - rehash(_VSTD::max<size_type>(2 * __bc + !__is_power2(__bc), + rehash(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc), size_type(ceil(float(size() + 1) / max_load_factor())))); __bc = bucket_count(); } @@ -1728,7 +1695,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi( size_type __bc = bucket_count(); if (size()+1 > __bc * max_load_factor() || __bc == 0) { - rehash(_VSTD::max<size_type>(2 * __bc + !__is_power2(__bc), + rehash(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc), size_type(ceil(float(size() + 1) / max_load_factor())))); __bc = bucket_count(); } @@ -1752,6 +1719,26 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc> pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool> __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(const value_type& __x) { + return __insert_unique_value(__x); +} + + +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +template <class _Tp, class _Hash, class _Equal, class _Alloc> +template <class _ValueTp> +_LIBCPP_INLINE_VISIBILITY +pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool> +__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique_value(_ValueTp&& __x) +#else +template <class _Tp, class _Hash, class _Equal, class _Alloc> +_LIBCPP_INLINE_VISIBILITY +pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool> +__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique_value(const value_type& __x) +#endif +{ +#if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) + typedef const value_type& _ValueTp; +#endif size_t __hash = hash_function()(__x); size_type __bc = bucket_count(); bool __inserted = false; @@ -1773,10 +1760,10 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(const value_type& __x) } } { - __node_holder __h = __construct_node(__x, __hash); + __node_holder __h = __construct_node(_VSTD::forward<_ValueTp>(__x), __hash); if (size()+1 > __bc * max_load_factor() || __bc == 0) { - rehash(_VSTD::max<size_type>(2 * __bc + !__is_power2(__bc), + rehash(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc), size_type(ceil(float(size() + 1) / max_load_factor())))); __bc = bucket_count(); __chash = __constrain_hash(__hash, __bc); @@ -1857,6 +1844,13 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_hint_multi( #endif // _LIBCPP_HAS_NO_VARIADICS template <class _Tp, class _Hash, class _Equal, class _Alloc> +pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool> +__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(value_type&& __x) +{ + return __insert_unique_value(_VSTD::move(__x)); +} + +template <class _Tp, class _Hash, class _Equal, class _Alloc> template <class _Pp> pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool> __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(_Pp&& __x) @@ -1946,8 +1940,8 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::rehash(size_type __n) __n = _VSTD::max<size_type> ( __n, - __is_power2(__bc) ? __next_pow2(size_t(ceil(float(size()) / max_load_factor()))) : - __next_prime(size_t(ceil(float(size()) / max_load_factor()))) + __is_hash_power2(__bc) ? __next_hash_pow2(size_t(ceil(float(size()) / max_load_factor()))) : + __next_prime(size_t(ceil(float(size()) / max_load_factor()))) ); if (__n < __bc) __rehash(__n); @@ -2358,12 +2352,14 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc> void __hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u) _NOEXCEPT_( - (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value || - __is_nothrow_swappable<__pointer_allocator>::value) && - (!__node_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value) && - __is_nothrow_swappable<hasher>::value && - __is_nothrow_swappable<key_equal>::value) + __is_nothrow_swappable<hasher>::value && __is_nothrow_swappable<key_equal>::value +#if _LIBCPP_STD_VER <= 11 + && (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value + || __is_nothrow_swappable<__pointer_allocator>::value) + && (!__node_traits::propagate_on_container_swap::value + || __is_nothrow_swappable<__node_allocator>::value) +#endif + ) { { __node_pointer_pointer __npp = __bucket_list_.release(); @@ -2371,9 +2367,9 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u) __u.__bucket_list_.reset(__npp); } _VSTD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size()); - __swap_alloc(__bucket_list_.get_deleter().__alloc(), + __swap_allocator(__bucket_list_.get_deleter().__alloc(), __u.__bucket_list_.get_deleter().__alloc()); - __swap_alloc(__node_alloc(), __u.__node_alloc()); + __swap_allocator(__node_alloc(), __u.__node_alloc()); _VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_); __p2_.swap(__u.__p2_); __p3_.swap(__u.__p3_); diff --git a/contrib/libc++/include/__locale b/contrib/libc++/include/__locale index 0097fc28d79e..19895582cac8 100644 --- a/contrib/libc++/include/__locale +++ b/contrib/libc++/include/__locale @@ -30,6 +30,7 @@ # include <support/android/locale_bionic.h> # endif #elif defined(__sun__) +# include <xlocale.h> # include <support/solaris/xlocale.h> #elif defined(_NEWLIB_VERSION) # include <support/newlib/xlocale.h> @@ -352,16 +353,15 @@ public: static const mask punct = _PUNCT; static const mask xdigit = _HEX; static const mask blank = _BLANK; -#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) || defined(__ANDROID__) -#ifdef __APPLE__ +# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT +#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) +# ifdef __APPLE__ typedef __uint32_t mask; -#elif defined(__FreeBSD__) +# elif defined(__FreeBSD__) typedef unsigned long mask; -#elif defined(__EMSCRIPTEN__) || defined(__NetBSD__) +# elif defined(__EMSCRIPTEN__) || defined(__NetBSD__) typedef unsigned short mask; -#elif defined(__ANDROID__) - typedef unsigned char mask; -#endif +# endif static const mask space = _CTYPE_S; static const mask print = _CTYPE_R; static const mask cntrl = _CTYPE_C; @@ -370,11 +370,7 @@ public: static const mask alpha = _CTYPE_A; static const mask digit = _CTYPE_D; static const mask punct = _CTYPE_P; -# if defined(__ANDROID__) - static const mask xdigit = _CTYPE_X | _CTYPE_D; -# else static const mask xdigit = _CTYPE_X; -# endif # if defined(__NetBSD__) static const mask blank = _CTYPE_BL; @@ -393,7 +389,23 @@ public: static const mask punct = _ISPUNCT; static const mask xdigit = _ISXDIGIT; static const mask blank = _ISBLANK; -#else // __GLIBC__ || _WIN32 || __APPLE__ || __FreeBSD__ || __EMSCRIPTEN__ || __sun__ +#elif defined(_NEWLIB_VERSION) + // Same type as Newlib's _ctype_ array in newlib/libc/include/ctype.h. + typedef char mask; + static const mask space = _S; + static const mask print = _P | _U | _L | _N | _B; + static const mask cntrl = _C; + static const mask upper = _U; + static const mask lower = _L; + static const mask alpha = _U | _L; + static const mask digit = _N; + static const mask punct = _P; + static const mask xdigit = _X | _N; + static const mask blank = _B; +# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT +# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA +# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT +#else typedef unsigned long mask; static const mask space = 1<<0; static const mask print = 1<<1; @@ -405,7 +417,7 @@ public: static const mask punct = 1<<7; static const mask xdigit = 1<<8; static const mask blank = 1<<9; -#endif // __GLIBC__ || _WIN32 || __APPLE__ || __FreeBSD__ +#endif static const mask alnum = alpha | digit; static const mask graph = alnum | punct; @@ -1420,7 +1432,7 @@ protected: // template <class charT> class numpunct_byname -template <class charT> class _LIBCPP_TYPE_VIS_ONLY numpunct_byname; +template <class _CharT> class _LIBCPP_TYPE_VIS_ONLY numpunct_byname; template <> class _LIBCPP_TYPE_VIS numpunct_byname<char> diff --git a/contrib/libc++/include/__refstring b/contrib/libc++/include/__refstring index 6866bf1b9736..61ccc75122a5 100644 --- a/contrib/libc++/include/__refstring +++ b/contrib/libc++/include/__refstring @@ -13,7 +13,7 @@ #include <__config> #include <cstddef> #include <cstring> -#if __APPLE__ +#ifdef __APPLE__ #include <dlfcn.h> #include <mach-o/dyld.h> #endif @@ -49,7 +49,7 @@ private: return data + sizeof(*rep); } -#if __APPLE__ +#ifdef __APPLE__ static const char* compute_gcc_empty_string_storage() _NOEXCEPT diff --git a/contrib/libc++/include/__split_buffer b/contrib/libc++/include/__split_buffer index 1d529cbe27d2..727b1b6b5674 100644 --- a/contrib/libc++/include/__split_buffer +++ b/contrib/libc++/include/__split_buffer @@ -156,25 +156,6 @@ private: _LIBCPP_INLINE_VISIBILITY void __move_assign_alloc(__split_buffer&, false_type) _NOEXCEPT {} - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value|| - __is_nothrow_swappable<__alloc_rr>::value) - {__swap_alloc(__x, __y, integral_constant<bool, - __alloc_traits::propagate_on_container_swap::value>());} - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, true_type) - _NOEXCEPT_(__is_nothrow_swappable<__alloc_rr>::value) - { - using _VSTD::swap; - swap(__x, __y); - } - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__alloc_rr&, __alloc_rr&, false_type) _NOEXCEPT - {} }; template <class _Tp, class _Allocator> @@ -431,7 +412,7 @@ __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x) _VSTD::swap(__begin_, __x.__begin_); _VSTD::swap(__end_, __x.__end_); _VSTD::swap(__end_cap(), __x.__end_cap()); - __swap_alloc(__alloc(), __x.__alloc()); + __swap_allocator(__alloc(), __x.__alloc()); } template <class _Tp, class _Allocator> diff --git a/contrib/libc++/include/__sso_allocator b/contrib/libc++/include/__sso_allocator index 645f2ba17459..ca3b937c0138 100644 --- a/contrib/libc++/include/__sso_allocator +++ b/contrib/libc++/include/__sso_allocator @@ -15,6 +15,8 @@ #include <type_traits> #include <new> +#include <__undef___deallocate> + #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif diff --git a/contrib/libc++/include/__tree b/contrib/libc++/include/__tree index 9007dbf507da..574e74baf26b 100644 --- a/contrib/libc++/include/__tree +++ b/contrib/libc++/include/__tree @@ -28,14 +28,6 @@ template <class _Tp, class _NodePtr, class _DiffType> class _LIBCPP_TYPE_VIS_ONLY __tree_iterator; template <class _Tp, class _ConstNodePtr, class _DiffType> class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator; -template <class _Key, class _Tp, class _Compare, class _Allocator> - class _LIBCPP_TYPE_VIS_ONLY map; -template <class _Key, class _Tp, class _Compare, class _Allocator> - class _LIBCPP_TYPE_VIS_ONLY multimap; -template <class _Key, class _Compare, class _Allocator> - class _LIBCPP_TYPE_VIS_ONLY set; -template <class _Key, class _Compare, class _Allocator> - class _LIBCPP_TYPE_VIS_ONLY multiset; /* @@ -522,9 +514,9 @@ public: bool __value_constructed; _LIBCPP_INLINE_VISIBILITY - explicit __tree_node_destructor(allocator_type& __na) _NOEXCEPT + explicit __tree_node_destructor(allocator_type& __na, bool __val = false) _NOEXCEPT : __na_(__na), - __value_constructed(false) + __value_constructed(__val) {} _LIBCPP_INLINE_VISIBILITY @@ -622,8 +614,6 @@ class _LIBCPP_TYPE_VIS_ONLY __tree_iterator { typedef _NodePtr __node_pointer; typedef typename pointer_traits<__node_pointer>::element_type __node; - typedef typename __node::base __node_base; - typedef typename __node_base::pointer __node_base_pointer; __node_pointer __ptr_; @@ -652,17 +642,21 @@ public: {return pointer_traits<pointer>::pointer_to(__ptr_->__value_);} _LIBCPP_INLINE_VISIBILITY - __tree_iterator& operator++() - {__ptr_ = static_cast<__node_pointer>(__tree_next(static_cast<__node_base_pointer>(__ptr_))); - return *this;} + __tree_iterator& operator++() { + __ptr_ = static_cast<__node_pointer>( + __tree_next(static_cast<typename __node::base::pointer>(__ptr_))); + return *this; + } _LIBCPP_INLINE_VISIBILITY __tree_iterator operator++(int) {__tree_iterator __t(*this); ++(*this); return __t;} _LIBCPP_INLINE_VISIBILITY - __tree_iterator& operator--() - {__ptr_ = static_cast<__node_pointer>(__tree_prev(static_cast<__node_base_pointer>(__ptr_))); - return *this;} + __tree_iterator& operator--() { + __ptr_ = static_cast<__node_pointer>( + __tree_prev(static_cast<typename __node::base::pointer>(__ptr_))); + return *this; + } _LIBCPP_INLINE_VISIBILITY __tree_iterator operator--(int) {__tree_iterator __t(*this); --(*this); return __t;} @@ -691,14 +685,6 @@ class _LIBCPP_TYPE_VIS_ONLY __tree_const_iterator { typedef _ConstNodePtr __node_pointer; typedef typename pointer_traits<__node_pointer>::element_type __node; - typedef typename __node::base __node_base; - typedef typename pointer_traits<__node_pointer>::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind<__node_base> -#else - rebind<__node_base>::other -#endif - __node_base_pointer; __node_pointer __ptr_; @@ -743,17 +729,39 @@ public: {return pointer_traits<pointer>::pointer_to(__ptr_->__value_);} _LIBCPP_INLINE_VISIBILITY - __tree_const_iterator& operator++() - {__ptr_ = static_cast<__node_pointer>(__tree_next(static_cast<__node_base_pointer>(__ptr_))); - return *this;} + __tree_const_iterator& operator++() { + typedef typename pointer_traits<__node_pointer>::template +#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES + rebind<typename __node::base> +#else + rebind<typename __node::base>::other +#endif + __node_base_pointer; + + __ptr_ = static_cast<__node_pointer>( + __tree_next(static_cast<__node_base_pointer>(__ptr_))); + return *this; + } + _LIBCPP_INLINE_VISIBILITY __tree_const_iterator operator++(int) {__tree_const_iterator __t(*this); ++(*this); return __t;} _LIBCPP_INLINE_VISIBILITY - __tree_const_iterator& operator--() - {__ptr_ = static_cast<__node_pointer>(__tree_prev(static_cast<__node_base_pointer>(__ptr_))); - return *this;} + __tree_const_iterator& operator--() { + typedef typename pointer_traits<__node_pointer>::template +#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES + rebind<typename __node::base> +#else + rebind<typename __node::base>::other +#endif + __node_base_pointer; + + __ptr_ = static_cast<__node_pointer>( + __tree_prev(static_cast<__node_base_pointer>(__ptr_))); + return *this; + } + _LIBCPP_INLINE_VISIBILITY __tree_const_iterator operator--(int) {__tree_const_iterator __t(*this); --(*this); return __t;} @@ -794,13 +802,7 @@ public: typedef __tree_node<value_type, __void_pointer> __node; typedef __tree_node_base<__void_pointer> __node_base; - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__node> -#else - rebind_alloc<__node>::other -#endif - __node_allocator; + typedef typename __rebind_alloc_helper<__alloc_traits, __node>::type __node_allocator; typedef allocator_traits<__node_allocator> __node_traits; typedef typename __node_traits::pointer __node_pointer; typedef typename __node_traits::pointer __node_const_pointer; @@ -924,9 +926,12 @@ public: void swap(__tree& __t) _NOEXCEPT_( - __is_nothrow_swappable<value_compare>::value && - (!__node_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value)); + __is_nothrow_swappable<value_compare>::value +#if _LIBCPP_STD_VER <= 11 + && (!__node_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<__node_allocator>::value) +#endif + ); #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_VARIADICS @@ -1094,25 +1099,6 @@ private: _LIBCPP_INLINE_VISIBILITY void __move_assign_alloc(__tree& __t, false_type) _NOEXCEPT {} - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__node_allocator& __x, __node_allocator& __y) - _NOEXCEPT_( - !__node_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value) - {__swap_alloc(__x, __y, integral_constant<bool, - __node_traits::propagate_on_container_swap::value>());} - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, true_type) - _NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value) - { - using _VSTD::swap; - swap(__x, __y); - } - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, false_type) - _NOEXCEPT - {} - __node_pointer __detach(); static __node_pointer __detach(__node_pointer); @@ -1450,15 +1436,18 @@ __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT template <class _Tp, class _Compare, class _Allocator> void __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t) - _NOEXCEPT_( - __is_nothrow_swappable<value_compare>::value && - (!__node_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value)) + _NOEXCEPT_( + __is_nothrow_swappable<value_compare>::value +#if _LIBCPP_STD_VER <= 11 + && (!__node_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<__node_allocator>::value) +#endif + ) { using _VSTD::swap; swap(__begin_node_, __t.__begin_node_); swap(__pair1_.first(), __t.__pair1_.first()); - __swap_alloc(__node_alloc(), __t.__node_alloc()); + __swap_allocator(__node_alloc(), __t.__node_alloc()); __pair3_.swap(__t.__pair3_); if (size() == 0) __begin_node() = __end_node(); @@ -2290,7 +2279,7 @@ __tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT --size(); __tree_remove(__end_node()->__left_, static_cast<__node_base_pointer>(__np)); - return __node_holder(__np, _Dp(__node_alloc())); + return __node_holder(__np, _Dp(__node_alloc(), true)); } template <class _Tp, class _Compare, class _Allocator> diff --git a/contrib/libc++/include/__tuple b/contrib/libc++/include/__tuple index bffb95cb72c5..2837ce708f09 100644 --- a/contrib/libc++/include/__tuple +++ b/contrib/libc++/include/__tuple @@ -19,40 +19,9 @@ #pragma GCC system_header #endif -#ifdef _LIBCPP_HAS_NO_VARIADICS - -#include <__tuple_03> - -#else // _LIBCPP_HAS_NO_VARIADICS _LIBCPP_BEGIN_NAMESPACE_STD -// __lazy_and - -template <bool _Last, class ..._Preds> -struct __lazy_and_impl; - -template <class ..._Preds> -struct __lazy_and_impl<false, _Preds...> : false_type {}; - -template <> -struct __lazy_and_impl<true> : true_type {}; - -template <class _Pred> -struct __lazy_and_impl<true, _Pred> : integral_constant<bool, _Pred::type::value> {}; - -template <class _Hp, class ..._Tp> -struct __lazy_and_impl<true, _Hp, _Tp...> : __lazy_and_impl<_Hp::type::value, _Tp...> {}; - -template <class _P1, class ..._Pr> -struct __lazy_and : __lazy_and_impl<_P1::type::value, _Pr...> {}; - -// __lazy_not - -template <class _Pred> -struct __lazy_not : integral_constant<bool, !_Pred::type::value> {}; - - template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size; template <class _Tp> @@ -90,19 +59,18 @@ public: typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type; }; -template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple; -template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY pair; -template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array; - template <class _Tp> struct __tuple_like : false_type {}; template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {}; template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {}; template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {}; +// tuple specializations + +#if !defined(_LIBCPP_HAS_NO_VARIADICS) +template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple; + template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {}; -template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {}; -template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {}; template <size_t _Ip, class ..._Tp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 @@ -118,6 +86,13 @@ template <size_t _Ip, class ..._Tp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 typename tuple_element<_Ip, tuple<_Tp...> >::type&& get(tuple<_Tp...>&&) _NOEXCEPT; +#endif + +// pair specializations + +template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY pair; + +template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {}; template <size_t _Ip, class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 @@ -129,10 +104,18 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const typename tuple_element<_Ip, pair<_T1, _T2> >::type& get(const pair<_T1, _T2>&) _NOEXCEPT; +#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) template <size_t _Ip, class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 typename tuple_element<_Ip, pair<_T1, _T2> >::type&& get(pair<_T1, _T2>&&) _NOEXCEPT; +#endif + +// array specializations + +template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array; + +template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {}; template <size_t _Ip, class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 @@ -144,10 +127,39 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Tp& get(const array<_Tp, _Size>&) _NOEXCEPT; +#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) template <size_t _Ip, class _Tp, size_t _Size> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Tp&& get(array<_Tp, _Size>&&) _NOEXCEPT; +#endif + +#if !defined(_LIBCPP_HAS_NO_VARIADICS) + +// __lazy_and + +template <bool _Last, class ..._Preds> +struct __lazy_and_impl; + +template <class ..._Preds> +struct __lazy_and_impl<false, _Preds...> : false_type {}; + +template <> +struct __lazy_and_impl<true> : true_type {}; + +template <class _Pred> +struct __lazy_and_impl<true, _Pred> : integral_constant<bool, _Pred::type::value> {}; + +template <class _Hp, class ..._Tp> +struct __lazy_and_impl<true, _Hp, _Tp...> : __lazy_and_impl<_Hp::type::value, _Tp...> {}; + +template <class _P1, class ..._Pr> +struct __lazy_and : __lazy_and_impl<_P1::type::value, _Pr...> {}; + +// __lazy_not + +template <class _Pred> +struct __lazy_not : integral_constant<bool, !_Pred::type::value> {}; // __make_tuple_indices @@ -354,8 +366,8 @@ struct __tuple_assignable<_Tp, _Up, true, true> tuple_size<_Up>::value, _Tp, _Up> {}; -_LIBCPP_END_NAMESPACE_STD - #endif // _LIBCPP_HAS_NO_VARIADICS +_LIBCPP_END_NAMESPACE_STD + #endif // _LIBCPP___TUPLE diff --git a/contrib/libc++/include/__tuple_03 b/contrib/libc++/include/__undef___deallocate index b91c2cd48a63..2b4ad99dad38 100644 --- a/contrib/libc++/include/__tuple_03 +++ b/contrib/libc++/include/__undef___deallocate @@ -8,20 +8,11 @@ // //===----------------------------------------------------------------------===// -#ifndef _LIBCPP___TUPLE_03 -#define _LIBCPP___TUPLE_03 - -#include <__config> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header +#ifdef __deallocate +#if defined(_MSC_VER) && !defined(__clang__) +_LIBCPP_WARNING("macro __deallocate is incompatible with C++. #undefining __deallocate") +#else +#warning: macro __deallocate is incompatible with C++. #undefining __deallocate +#endif +#undef __deallocate #endif - -_LIBCPP_BEGIN_NAMESPACE_STD - -template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size; -template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element; - -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP___TUPLE_03 diff --git a/contrib/libc++/include/algorithm b/contrib/libc++/include/algorithm index 61b014387806..7b0c53e05a5a 100644 --- a/contrib/libc++/include/algorithm +++ b/contrib/libc++/include/algorithm @@ -521,11 +521,11 @@ template <class RandomAccessIterator, class Compare> template <class ForwardIterator> ForwardIterator - min_element(ForwardIterator first, ForwardIterator last); + min_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14 template <class ForwardIterator, class Compare> ForwardIterator - min_element(ForwardIterator first, ForwardIterator last, Compare comp); + min_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14 template <class T> const T& @@ -545,11 +545,11 @@ template<class T, class Compare> template <class ForwardIterator> ForwardIterator - max_element(ForwardIterator first, ForwardIterator last); + max_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14 template <class ForwardIterator, class Compare> ForwardIterator - max_element(ForwardIterator first, ForwardIterator last, Compare comp); + max_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14 template <class T> const T& @@ -569,11 +569,11 @@ template<class T, class Compare> template<class ForwardIterator> pair<ForwardIterator, ForwardIterator> - minmax_element(ForwardIterator first, ForwardIterator last); + minmax_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14 template<class ForwardIterator, class Compare> pair<ForwardIterator, ForwardIterator> - minmax_element(ForwardIterator first, ForwardIterator last, Compare comp); + minmax_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14 template<class T> pair<const T&, const T&> @@ -1672,7 +1672,8 @@ search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_, _BinaryPredicate __pred) { return _VSTD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type> - (__first, __last, __count, __value_, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); + (__first, __last, __convert_to_integral(__count), __value_, __pred, + typename iterator_traits<_ForwardIterator>::iterator_category()); } template <class _ForwardIterator, class _Size, class _Tp> @@ -1681,7 +1682,8 @@ _ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_) { typedef typename iterator_traits<_ForwardIterator>::value_type __v; - return _VSTD::search_n(__first, __last, __count, __value_, __equal_to<__v, _Tp>()); + return _VSTD::search_n(__first, __last, __convert_to_integral(__count), + __value_, __equal_to<__v, _Tp>()); } // copy @@ -1761,7 +1763,8 @@ typename enable_if __copy(_Tp* __first, _Tp* __last, _Up* __result) { const size_t __n = static_cast<size_t>(__last - __first); - _VSTD::memmove(__result, __first, __n * sizeof(_Up)); + if (__n > 0) + _VSTD::memmove(__result, __first, __n * sizeof(_Up)); return __result + __n; } @@ -1796,8 +1799,11 @@ typename enable_if __copy_backward(_Tp* __first, _Tp* __last, _Up* __result) { const size_t __n = static_cast<size_t>(__last - __first); - __result -= __n; - _VSTD::memmove(__result, __first, __n * sizeof(_Up)); + if (__n > 0) + { + __result -= __n; + _VSTD::memmove(__result, __first, __n * sizeof(_Up)); + } return __result; } @@ -1839,8 +1845,10 @@ typename enable_if !__is_random_access_iterator<_InputIterator>::value, _OutputIterator >::type -copy_n(_InputIterator __first, _Size __n, _OutputIterator __result) +copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) { + typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize; + _IntegralSize __n = __orig_n; if (__n > 0) { *__result = *__first; @@ -1862,8 +1870,10 @@ typename enable_if __is_random_access_iterator<_InputIterator>::value, _OutputIterator >::type -copy_n(_InputIterator __first, _Size __n, _OutputIterator __result) +copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) { + typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize; + _IntegralSize __n = __orig_n; return _VSTD::copy(__first, __first + __n, __result); } @@ -1890,7 +1900,8 @@ typename enable_if __move(_Tp* __first, _Tp* __last, _Up* __result) { const size_t __n = static_cast<size_t>(__last - __first); - _VSTD::memmove(__result, __first, __n * sizeof(_Up)); + if (__n > 0) + _VSTD::memmove(__result, __first, __n * sizeof(_Up)); return __result + __n; } @@ -1925,8 +1936,11 @@ typename enable_if __move_backward(_Tp* __first, _Tp* __last, _Up* __result) { const size_t __n = static_cast<size_t>(__last - __first); - __result -= __n; - _VSTD::memmove(__result, __first, __n * sizeof(_Up)); + if (__n > 0) + { + __result -= __n; + _VSTD::memmove(__result, __first, __n * sizeof(_Up)); + } return __result; } @@ -2055,7 +2069,7 @@ inline _LIBCPP_INLINE_VISIBILITY _OutputIterator fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_) { - return _VSTD::__fill_n(__first, __n, __value_); + return _VSTD::__fill_n(__first, __convert_to_integral(__n), __value_); } // fill @@ -2101,8 +2115,10 @@ generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) template <class _OutputIterator, class _Size, class _Generator> inline _LIBCPP_INLINE_VISIBILITY _OutputIterator -generate_n(_OutputIterator __first, _Size __n, _Generator __gen) +generate_n(_OutputIterator __first, _Size __orig_n, _Generator __gen) { + typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize; + _IntegralSize __n = __orig_n; for (; __n > 0; ++__first, (void) --__n) *__first = __gen(); return __first; @@ -2536,7 +2552,7 @@ rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterato template <class _ForwardIterator, class _Compare> inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator -__min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) +min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { if (__first != __last) { @@ -2548,20 +2564,12 @@ __min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp return __first; } -template <class _ForwardIterator, class _Compare> -inline _LIBCPP_INLINE_VISIBILITY -_ForwardIterator -min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) -{ - return __min_element(__first, __last, __comp); -} - template <class _ForwardIterator> -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator min_element(_ForwardIterator __first, _ForwardIterator __last) { - return __min_element(__first, __last, + return _VSTD::min_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); } @@ -2590,7 +2598,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Tp min(initializer_list<_Tp> __t, _Compare __comp) { - return *__min_element(__t.begin(), __t.end(), __comp); + return *_VSTD::min_element(__t.begin(), __t.end(), __comp); } template<class _Tp> @@ -2598,7 +2606,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Tp min(initializer_list<_Tp> __t) { - return *__min_element(__t.begin(), __t.end(), __less<_Tp>()); + return *_VSTD::min_element(__t.begin(), __t.end(), __less<_Tp>()); } #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS @@ -2608,7 +2616,7 @@ min(initializer_list<_Tp> __t) template <class _ForwardIterator, class _Compare> inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator -__max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) +max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { if (__first != __last) { @@ -2621,20 +2629,12 @@ __max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp } -template <class _ForwardIterator, class _Compare> -inline _LIBCPP_INLINE_VISIBILITY -_ForwardIterator -max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) -{ - return __max_element(__first, __last, __comp); -} - template <class _ForwardIterator> -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator max_element(_ForwardIterator __first, _ForwardIterator __last) { - return __max_element(__first, __last, + return _VSTD::max_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>()); } @@ -2663,7 +2663,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Tp max(initializer_list<_Tp> __t, _Compare __comp) { - return *__max_element(__t.begin(), __t.end(), __comp); + return *_VSTD::max_element(__t.begin(), __t.end(), __comp); } template<class _Tp> @@ -2671,7 +2671,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Tp max(initializer_list<_Tp> __t) { - return *__max_element(__t.begin(), __t.end(), __less<_Tp>()); + return *_VSTD::max_element(__t.begin(), __t.end(), __less<_Tp>()); } #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS @@ -2679,6 +2679,7 @@ max(initializer_list<_Tp> __t) // minmax_element template <class _ForwardIterator, class _Compare> +_LIBCPP_CONSTEXPR_AFTER_CXX11 std::pair<_ForwardIterator, _ForwardIterator> minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { @@ -2726,7 +2727,7 @@ minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __com } template <class _ForwardIterator> -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 std::pair<_ForwardIterator, _ForwardIterator> minmax_element(_ForwardIterator __first, _ForwardIterator __last) { @@ -2763,7 +2764,7 @@ minmax(initializer_list<_Tp> __t, _Compare __comp) typedef typename initializer_list<_Tp>::const_iterator _Iter; _Iter __first = __t.begin(); _Iter __last = __t.end(); - std::pair<_Tp, _Tp> __result ( *__first, *__first ); + std::pair<_Tp, _Tp> __result(*__first, *__first); ++__first; if (__t.size() % 2 == 0) @@ -2778,13 +2779,13 @@ minmax(initializer_list<_Tp> __t, _Compare __comp) while (__first != __last) { _Tp __prev = *__first++; - if (__comp(__prev, *__first)) { - if (__comp(__prev, __result.first)) __result.first = __prev; - if (__comp(__result.second, *__first)) __result.second = *__first; + if (__comp(*__first, __prev)) { + if ( __comp(*__first, __result.first)) __result.first = *__first; + if (!__comp(__prev, __result.second)) __result.second = __prev; } else { - if (__comp(*__first, __result.first)) __result.first = *__first; - if (__comp(__result.second, __prev)) __result.second = __prev; + if ( __comp(__prev, __result.first)) __result.first = __prev; + if (!__comp(*__first, __result.second)) __result.second = *__first; } __first++; @@ -3148,6 +3149,9 @@ is_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred) for (; __first != __last; ++__first) if (!__pred(*__first)) break; + if ( __first == __last ) + return true; + ++__first; for (; __first != __last; ++__first) if (__pred(*__first)) return false; @@ -4357,6 +4361,34 @@ merge(_InputIterator1 __first1, _InputIterator1 __last1, // inplace_merge +template <class _Compare, class _InputIterator1, class _InputIterator2, + class _OutputIterator> +void __half_inplace_merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) +{ + for (; __first1 != __last1; ++__result) + { + if (__first2 == __last2) + { + _VSTD::move(__first1, __last1, __result); + return; + } + + if (__comp(*__first2, *__first1)) + { + *__result = _VSTD::move(*__first2); + ++__first2; + } + else + { + *__result = _VSTD::move(*__first1); + ++__first1; + } + } + // __first2 through __last2 are already in the right spot. +} + template <class _Compare, class _BidirectionalIterator> void __buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, @@ -4372,11 +4404,7 @@ __buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator value_type* __p = __buff; for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), (void) ++__i, ++__p) ::new(__p) value_type(_VSTD::move(*__i)); - __merge<_Compare>(move_iterator<value_type*>(__buff), - move_iterator<value_type*>(__p), - move_iterator<_BidirectionalIterator>(__middle), - move_iterator<_BidirectionalIterator>(__last), - __first, __comp); + __half_inplace_merge(__buff, __p, __middle, __last, __first, __comp); } else { @@ -4385,9 +4413,9 @@ __buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator ::new(__p) value_type(_VSTD::move(*__i)); typedef reverse_iterator<_BidirectionalIterator> _RBi; typedef reverse_iterator<value_type*> _Rv; - __merge(move_iterator<_RBi>(_RBi(__middle)), move_iterator<_RBi>(_RBi(__first)), - move_iterator<_Rv>(_Rv(__p)), move_iterator<_Rv>(_Rv(__buff)), - _RBi(__last), __negate<_Compare>(__comp)); + __half_inplace_merge(_Rv(__p), _Rv(__buff), + _RBi(__middle), _RBi(__first), + _RBi(__last), __negate<_Compare>(__comp)); } } @@ -4404,6 +4432,9 @@ __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, // if __middle == __last, we're done if (__len2 == 0) return; + if (__len1 <= __buff_size || __len2 <= __buff_size) + return __buffered_inplace_merge<_Compare> + (__first, __middle, __last, __comp, __len1, __len2, __buff); // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0 for (; true; ++__first, (void) --__len1) { @@ -4412,11 +4443,6 @@ __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, if (__comp(*__middle, *__first)) break; } - if (__len1 <= __buff_size || __len2 <= __buff_size) - { - __buffered_inplace_merge<_Compare>(__first, __middle, __last, __comp, __len1, __len2, __buff); - return; - } // __first < __middle < __last // *__first > *__middle // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that @@ -4481,12 +4507,6 @@ __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, } } -template <class _Tp> -struct __inplace_merge_switch -{ - static const unsigned value = is_trivially_copy_assignable<_Tp>::value; -}; - template <class _BidirectionalIterator, class _Compare> inline _LIBCPP_INLINE_VISIBILITY void @@ -4498,13 +4518,9 @@ inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _ difference_type __len1 = _VSTD::distance(__first, __middle); difference_type __len2 = _VSTD::distance(__middle, __last); difference_type __buf_size = _VSTD::min(__len1, __len2); - pair<value_type*, ptrdiff_t> __buf(0, 0); - unique_ptr<value_type, __return_temporary_buffer> __h; - if (__inplace_merge_switch<value_type>::value && __buf_size > 8) - { - __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size); - __h.reset(__buf.first); - } + pair<value_type*, ptrdiff_t> __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size); + unique_ptr<value_type, __return_temporary_buffer> __h(__buf.first); + #ifdef _LIBCPP_DEBUG typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; __debug_less<_Compare> __c(__comp); diff --git a/contrib/libc++/include/array b/contrib/libc++/include/array index d37075da1a2a..2e02a43ed524 100644 --- a/contrib/libc++/include/array +++ b/contrib/libc++/include/array @@ -288,10 +288,6 @@ template <class _Tp, size_t _Size> class _LIBCPP_TYPE_VIS_ONLY tuple_size<array<_Tp, _Size> > : public integral_constant<size_t, _Size> {}; -template <class _Tp, size_t _Size> -class _LIBCPP_TYPE_VIS_ONLY tuple_size<const array<_Tp, _Size> > - : public integral_constant<size_t, _Size> {}; - template <size_t _Ip, class _Tp, size_t _Size> class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, array<_Tp, _Size> > { @@ -300,13 +296,6 @@ public: }; template <size_t _Ip, class _Tp, size_t _Size> -class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const array<_Tp, _Size> > -{ -public: - typedef const _Tp type; -}; - -template <size_t _Ip, class _Tp, size_t _Size> inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Tp& get(array<_Tp, _Size>& __a) _NOEXCEPT diff --git a/contrib/libc++/include/atomic b/contrib/libc++/include/atomic index b01a59f5f96f..97a998d33633 100644 --- a/contrib/libc++/include/atomic +++ b/contrib/libc++/include/atomic @@ -551,26 +551,27 @@ typedef enum memory_order #if _GNUC_VER >= 407 namespace __gcc_atomic { -template <typename T> +template <typename _Tp> struct __gcc_atomic_t { __gcc_atomic_t() _NOEXCEPT {} - explicit __gcc_atomic_t(T value) _NOEXCEPT : __a_value(value) {} - T __a_value; + _LIBCPP_CONSTEXPR explicit __gcc_atomic_t(_Tp value) _NOEXCEPT + : __a_value(value) {} + _Tp __a_value; }; #define _Atomic(x) __gcc_atomic::__gcc_atomic_t<x> -template <typename T> T __create(); +template <typename _Tp> _Tp __create(); -template <typename __Tp, typename __Td> -typename enable_if<sizeof(__Tp()->__a_value = __create<__Td>()), char>::type +template <typename _Tp, typename _Td> +typename enable_if<sizeof(_Tp()->__a_value = __create<_Td>()), char>::type __test_atomic_assignable(int); -template <typename T, typename U> +template <typename _Tp, typename _Up> __two __test_atomic_assignable(...); -template <typename __Tp, typename __Td> +template <typename _Tp, typename _Td> struct __can_assign { static const bool value = - sizeof(__test_atomic_assignable<__Tp, __Td>(1)) == sizeof(char); + sizeof(__test_atomic_assignable<_Tp, _Td>(1)) == sizeof(char); }; static inline constexpr int __to_gcc_order(memory_order __order) { @@ -583,6 +584,16 @@ static inline constexpr int __to_gcc_order(memory_order __order) { __ATOMIC_CONSUME)))); } +static inline constexpr int __to_gcc_failure_order(memory_order __order) { + // Avoid switch statement to make this a constexpr. + return __order == memory_order_relaxed ? __ATOMIC_RELAXED: + (__order == memory_order_acquire ? __ATOMIC_ACQUIRE: + (__order == memory_order_release ? __ATOMIC_RELAXED: + (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST: + (__order == memory_order_acq_rel ? __ATOMIC_ACQUIRE: + __ATOMIC_CONSUME)))); +} + } // namespace __gcc_atomic template <typename _Tp> @@ -623,10 +634,6 @@ static inline void __c11_atomic_signal_fence(memory_order __order) { __atomic_signal_fence(__gcc_atomic::__to_gcc_order(__order)); } -static inline bool __c11_atomic_is_lock_free(size_t __size) { - return __atomic_is_lock_free(__size, 0); -} - template <typename _Tp> static inline void __c11_atomic_store(volatile _Atomic(_Tp)* __a, _Tp __val, memory_order __order) { @@ -637,8 +644,8 @@ static inline void __c11_atomic_store(volatile _Atomic(_Tp)* __a, _Tp __val, template <typename _Tp> static inline void __c11_atomic_store(_Atomic(_Tp)* __a, _Tp __val, memory_order __order) { - return __atomic_store(&__a->__a_value, &__val, - __gcc_atomic::__to_gcc_order(__order)); + __atomic_store(&__a->__a_value, &__val, + __gcc_atomic::__to_gcc_order(__order)); } template <typename _Tp> @@ -683,7 +690,7 @@ static inline bool __c11_atomic_compare_exchange_strong( return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, false, __gcc_atomic::__to_gcc_order(__success), - __gcc_atomic::__to_gcc_order(__failure)); + __gcc_atomic::__to_gcc_failure_order(__failure)); } template <typename _Tp> @@ -693,7 +700,7 @@ static inline bool __c11_atomic_compare_exchange_strong( return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, false, __gcc_atomic::__to_gcc_order(__success), - __gcc_atomic::__to_gcc_order(__failure)); + __gcc_atomic::__to_gcc_failure_order(__failure)); } template <typename _Tp> @@ -703,7 +710,7 @@ static inline bool __c11_atomic_compare_exchange_weak( return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, true, __gcc_atomic::__to_gcc_order(__success), - __gcc_atomic::__to_gcc_order(__failure)); + __gcc_atomic::__to_gcc_failure_order(__failure)); } template <typename _Tp> @@ -713,7 +720,7 @@ static inline bool __c11_atomic_compare_exchange_weak( return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, true, __gcc_atomic::__to_gcc_order(__success), - __gcc_atomic::__to_gcc_order(__failure)); + __gcc_atomic::__to_gcc_failure_order(__failure)); } template <typename _Tp> @@ -817,10 +824,16 @@ struct __atomic_base // false _LIBCPP_INLINE_VISIBILITY bool is_lock_free() const volatile _NOEXCEPT - {return __c11_atomic_is_lock_free(sizeof(_Tp));} + { +#if __has_feature(cxx_atomic) + return __c11_atomic_is_lock_free(sizeof(_Tp)); +#else + return __atomic_is_lock_free(sizeof(_Tp), 0); +#endif + } _LIBCPP_INLINE_VISIBILITY bool is_lock_free() const _NOEXCEPT - {return __c11_atomic_is_lock_free(sizeof(_Tp));} + {return static_cast<__atomic_base const volatile*>(this)->is_lock_free();} _LIBCPP_INLINE_VISIBILITY void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {__c11_atomic_store(&__a_, __d, __m);} diff --git a/contrib/libc++/include/cctype b/contrib/libc++/include/cctype index b647903c45cd..26c740f7382d 100644 --- a/contrib/libc++/include/cctype +++ b/contrib/libc++/include/cctype @@ -39,6 +39,7 @@ int toupper(int c); #include <ctype.h> #if defined(_LIBCPP_MSVCRT) #include "support/win32/support.h" +#include "support/win32/locale_win32.h" #endif // _LIBCPP_MSVCRT #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) diff --git a/contrib/libc++/include/cinttypes b/contrib/libc++/include/cinttypes index 786692b8fec3..cfd763c98f4a 100644 --- a/contrib/libc++/include/cinttypes +++ b/contrib/libc++/include/cinttypes @@ -247,7 +247,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD using::imaxdiv_t; +#undef imaxabs using::imaxabs; +#undef imaxdiv using::imaxdiv; using::strtoimax; using::strtoumax; diff --git a/contrib/libc++/include/clocale b/contrib/libc++/include/clocale index f8b8f0dd34b6..05fa9c6edda8 100644 --- a/contrib/libc++/include/clocale +++ b/contrib/libc++/include/clocale @@ -45,7 +45,9 @@ lconv* localeconv(); _LIBCPP_BEGIN_NAMESPACE_STD using ::lconv; +#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS using ::setlocale; +#endif using ::localeconv; _LIBCPP_END_NAMESPACE_STD diff --git a/contrib/libc++/include/cmath b/contrib/libc++/include/cmath index d3aa4beeb584..5f9aaedd5afa 100644 --- a/contrib/libc++/include/cmath +++ b/contrib/libc++/include/cmath @@ -654,7 +654,11 @@ using ::double_t; // abs -#if !defined(_AIX) +#if defined(__sun__) +using ::abs; +#endif + +#if !defined(_AIX) && !defined(__sun__) inline _LIBCPP_INLINE_VISIBILITY float abs(float __lcpp_x) _NOEXCEPT {return fabsf(__lcpp_x);} @@ -1109,8 +1113,16 @@ cbrt(_A1 __lcpp_x) _NOEXCEPT {return cbrt((double)__lcpp_x);} using ::copysign; using ::copysignf; -inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return copysignf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return copysignl(__lcpp_x, __lcpp_y);} +#if !defined(_VC_CRT_MAJOR_VERSION) || (_VC_CRT_MAJOR_VERSION < 12) +inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x, + float __lcpp_y) _NOEXCEPT { + return copysignf(__lcpp_x, __lcpp_y); +} +inline _LIBCPP_INLINE_VISIBILITY long double +copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT { + return copysignl(__lcpp_x, __lcpp_y); +} +#endif template <class _A1, class _A2> inline _LIBCPP_INLINE_VISIBILITY diff --git a/contrib/libc++/include/cstdio b/contrib/libc++/include/cstdio index ce3af4d91dc4..d8ba6c2ef383 100644 --- a/contrib/libc++/include/cstdio +++ b/contrib/libc++/include/cstdio @@ -120,36 +120,44 @@ inline _LIBCPP_INLINE_VISIBILITY int __libcpp_putc(int __c, FILE* __stream) {ret inline _LIBCPP_INLINE_VISIBILITY int putc(int __c, FILE* __stream) {return __libcpp_putc(__c, __stream);} #endif // putc +#ifdef clearerr +inline _LIBCPP_INLINE_VISIBILITY void __libcpp_clearerr(FILE* __stream) { return clearerr(__stream); } +#undef clearerr +inline _LIBCPP_INLINE_VISIBILITY void clearerr(FILE* __stream) { return __libcpp_clearerr(__stream); } +#endif // clearerr + +#ifdef feof +inline _LIBCPP_INLINE_VISIBILITY int __libcpp_feof(FILE* __stream) { return feof(__stream); } +#undef feof +inline _LIBCPP_INLINE_VISIBILITY int feof(FILE* __stream) { return __libcpp_feof(__stream); } +#endif // feof + +#ifdef ferror +inline _LIBCPP_INLINE_VISIBILITY int __libcpp_ferror(FILE* __stream) { return ferror(__stream); } +#undef ferror +inline _LIBCPP_INLINE_VISIBILITY int ferror(FILE* __stream) { return __libcpp_ferror(__stream); } +#endif // ferror + _LIBCPP_BEGIN_NAMESPACE_STD using ::FILE; using ::fpos_t; using ::size_t; -using ::remove; -using ::rename; -using ::tmpfile; -using ::tmpnam; using ::fclose; using ::fflush; -using ::fopen; -using ::freopen; using ::setbuf; using ::setvbuf; using ::fprintf; using ::fscanf; -using ::printf; -using ::scanf; using ::snprintf; using ::sprintf; using ::sscanf; #ifndef _LIBCPP_MSVCRT using ::vfprintf; using ::vfscanf; -using ::vscanf; using ::vsscanf; #endif // _LIBCPP_MSVCRT -using ::vprintf; using ::vsnprintf; using ::vsprintf; using ::fgetc; @@ -157,13 +165,7 @@ using ::fgets; using ::fputc; using ::fputs; using ::getc; -using ::getchar; -#if _LIBCPP_STD_VER <= 11 -using ::gets; -#endif using ::putc; -using ::putchar; -using ::puts; using ::ungetc; using ::fread; using ::fwrite; @@ -177,6 +179,31 @@ using ::feof; using ::ferror; using ::perror; +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE +using ::fopen; +using ::freopen; +using ::remove; +using ::rename; +using ::tmpfile; +using ::tmpnam; +#endif + +#ifndef _LIBCPP_HAS_NO_STDIN +using ::getchar; +#if _LIBCPP_STD_VER <= 11 +using ::gets; +#endif +using ::scanf; +using ::vscanf; +#endif + +#ifndef _LIBCPP_HAS_NO_STDOUT +using ::printf; +using ::putchar; +using ::puts; +using ::vprintf; +#endif + _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_CSTDIO diff --git a/contrib/libc++/include/cstdlib b/contrib/libc++/include/cstdlib index 152b891de78e..55e15c82192e 100644 --- a/contrib/libc++/include/cstdlib +++ b/contrib/libc++/include/cstdlib @@ -131,19 +131,27 @@ using ::getenv; using ::system; using ::bsearch; using ::qsort; +#undef abs using ::abs; +#undef labs using ::labs; #ifndef _LIBCPP_HAS_NO_LONG_LONG +#undef llabs using ::llabs; #endif // _LIBCPP_HAS_NO_LONG_LONG +#undef div using ::div; +#undef ldiv using ::ldiv; #ifndef _LIBCPP_HAS_NO_LONG_LONG +#undef lldiv using ::lldiv; #endif // _LIBCPP_HAS_NO_LONG_LONG +#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS using ::mblen; using ::mbtowc; using ::wctomb; +#endif using ::mbstowcs; using ::wcstombs; #ifdef _LIBCPP_HAS_QUICK_EXIT diff --git a/contrib/libc++/include/cstring b/contrib/libc++/include/cstring index 21c9155cd4d9..d60b9923c6c2 100644 --- a/contrib/libc++/include/cstring +++ b/contrib/libc++/include/cstring @@ -102,7 +102,9 @@ inline _LIBCPP_INLINE_VISIBILITY void* memchr( void* __s, int __c, si inline _LIBCPP_INLINE_VISIBILITY char* strstr( char* __s1, const char* __s2) {return ::strstr(__s1, __s2);} #endif +#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS using ::strtok; +#endif using ::memset; using ::strerror; using ::strlen; diff --git a/contrib/libc++/include/ctime b/contrib/libc++/include/ctime index fc4eb26f5430..da9e3290bbb2 100644 --- a/contrib/libc++/include/ctime +++ b/contrib/libc++/include/ctime @@ -61,10 +61,12 @@ using ::clock; using ::difftime; using ::mktime; using ::time; +#ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS using ::asctime; using ::ctime; using ::gmtime; using ::localtime; +#endif using ::strftime; _LIBCPP_END_NAMESPACE_STD diff --git a/contrib/libc++/include/cwchar b/contrib/libc++/include/cwchar index 9f51587caa5f..797a1777c22f 100644 --- a/contrib/libc++/include/cwchar +++ b/contrib/libc++/include/cwchar @@ -126,24 +126,18 @@ using ::fwscanf; using ::swprintf; using ::vfwprintf; using ::vswprintf; -using ::vwprintf; #ifndef _LIBCPP_MSVCRT using ::swscanf; using ::vfwscanf; using ::vswscanf; -using ::vwscanf; #endif // _LIBCPP_MSVCRT -using ::wprintf; -using ::wscanf; using ::fgetwc; using ::fgetws; using ::fputwc; using ::fputws; using ::fwide; using ::getwc; -using ::getwchar; using ::putwc; -using ::putwchar; using ::ungetwc; using ::wcstod; #ifndef _LIBCPP_MSVCRT @@ -212,6 +206,20 @@ using ::wcrtomb; using ::mbsrtowcs; using ::wcsrtombs; +#ifndef _LIBCPP_HAS_NO_STDIN +using ::getwchar; +#ifndef _LIBCPP_MSVCRT +using ::vwscanf; +#endif // _LIBCPP_MSVCRT +using ::wscanf; +#endif + +#ifndef _LIBCPP_HAS_NO_STDOUT +using ::putwchar; +using ::vwprintf; +using ::wprintf; +#endif + _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_CWCHAR diff --git a/contrib/libc++/include/deque b/contrib/libc++/include/deque index 5602d4a3fdc5..5e152e425d0b 100644 --- a/contrib/libc++/include/deque +++ b/contrib/libc++/include/deque @@ -117,15 +117,14 @@ public: iterator insert(const_iterator p, value_type&& v); iterator insert(const_iterator p, size_type n, const value_type& v); template <class InputIterator> - iterator insert (const_iterator p, InputIterator f, InputIterator l); + iterator insert(const_iterator p, InputIterator f, InputIterator l); iterator insert(const_iterator p, initializer_list<value_type> il); void pop_front(); void pop_back(); iterator erase(const_iterator p); iterator erase(const_iterator f, const_iterator l); void swap(deque& c) - noexcept(!allocator_type::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value); + noexcept(allocator_traits<allocator_type>::is_always_equal::value); // C++17 void clear() noexcept; }; @@ -168,6 +167,7 @@ template <class T, class Allocator> _LIBCPP_BEGIN_NAMESPACE_STD template <class _Tp, class _Allocator> class __deque_base; +template <class _Tp, class _Allocator = allocator<_Tp> > class _LIBCPP_TYPE_VIS_ONLY deque; template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize> @@ -911,22 +911,10 @@ protected: static const difference_type __block_size = sizeof(value_type) < 256 ? 4096 / sizeof(value_type) : 16; - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<pointer> -#else - rebind_alloc<pointer>::other -#endif - __pointer_allocator; + typedef typename __rebind_alloc_helper<__alloc_traits, pointer>::type __pointer_allocator; typedef allocator_traits<__pointer_allocator> __map_traits; typedef typename __map_traits::pointer __map_pointer; - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<const_pointer> -#else - rebind_alloc<const_pointer>::other -#endif - __const_pointer_allocator; + typedef typename __rebind_alloc_helper<__alloc_traits, const_pointer>::type __const_pointer_allocator; typedef typename allocator_traits<__const_pointer_allocator>::const_pointer __map_const_pointer; typedef __split_buffer<pointer, __pointer_allocator> __map; @@ -965,8 +953,12 @@ public: #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES void swap(__deque_base& __c) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value); +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT; +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value); +#endif protected: void clear() _NOEXCEPT; @@ -1002,26 +994,6 @@ private: _LIBCPP_INLINE_VISIBILITY void __move_assign_alloc(__deque_base&, false_type) _NOEXCEPT {} - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(allocator_type& __x, allocator_type& __y) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) - {__swap_alloc(__x, __y, integral_constant<bool, - __alloc_traits::propagate_on_container_swap::value>());} - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type) - _NOEXCEPT_(__is_nothrow_swappable<allocator_type>::value) - { - using _VSTD::swap; - swap(__x, __y); - } - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(allocator_type&, allocator_type&, false_type) - _NOEXCEPT - {} }; template <class _Tp, class _Allocator> @@ -1145,13 +1117,17 @@ __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c, const allocator_ template <class _Tp, class _Allocator> void __deque_base<_Tp, _Allocator>::swap(__deque_base& __c) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value|| - __is_nothrow_swappable<allocator_type>::value) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value) +#endif { __map_.swap(__c.__map_); _VSTD::swap(__start_, __c.__start_); _VSTD::swap(size(), __c.size()); - __swap_alloc(__alloc(), __c.__alloc()); + __swap_allocator(__alloc(), __c.__alloc()); } template <class _Tp, class _Allocator> @@ -1178,7 +1154,7 @@ __deque_base<_Tp, _Allocator>::clear() _NOEXCEPT } } -template <class _Tp, class _Allocator = allocator<_Tp> > +template <class _Tp, class _Allocator /*= allocator<_Tp>*/> class _LIBCPP_TYPE_VIS_ONLY deque : private __deque_base<_Tp, _Allocator> { @@ -1332,11 +1308,15 @@ public: iterator insert(const_iterator __p, const value_type& __v); iterator insert(const_iterator __p, size_type __n, const value_type& __v); template <class _InputIter> - iterator insert (const_iterator __p, _InputIter __f, _InputIter __l, + iterator insert(const_iterator __p, _InputIter __f, _InputIter __l, typename enable_if<__is_input_iterator<_InputIter>::value - &&!__is_bidirectional_iterator<_InputIter>::value>::type* = 0); + &&!__is_forward_iterator<_InputIter>::value>::type* = 0); + template <class _ForwardIterator> + iterator insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l, + typename enable_if<__is_forward_iterator<_ForwardIterator>::value + &&!__is_bidirectional_iterator<_ForwardIterator>::value>::type* = 0); template <class _BiIter> - iterator insert (const_iterator __p, _BiIter __f, _BiIter __l, + iterator insert(const_iterator __p, _BiIter __f, _BiIter __l, typename enable_if<__is_bidirectional_iterator<_BiIter>::value>::type* = 0); #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS _LIBCPP_INLINE_VISIBILITY @@ -1349,8 +1329,12 @@ public: iterator erase(const_iterator __f, const_iterator __l); void swap(deque& __c) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT; +#else _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<allocator_type>::value); +#endif void clear() _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY @@ -2098,7 +2082,7 @@ template <class _InputIter> typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __l, typename enable_if<__is_input_iterator<_InputIter>::value - &&!__is_bidirectional_iterator<_InputIter>::value>::type*) + &&!__is_forward_iterator<_InputIter>::value>::type*) { __split_buffer<value_type, allocator_type&> __buf(__base::__alloc()); __buf.__construct_at_end(__f, __l); @@ -2107,6 +2091,20 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __ } template <class _Tp, class _Allocator> +template <class _ForwardIterator> +typename deque<_Tp, _Allocator>::iterator +deque<_Tp, _Allocator>::insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l, + typename enable_if<__is_forward_iterator<_ForwardIterator>::value + &&!__is_bidirectional_iterator<_ForwardIterator>::value>::type*) +{ + size_type __n = _VSTD::distance(__f, __l); + __split_buffer<value_type, allocator_type&> __buf(__n, 0, __base::__alloc()); + __buf.__construct_at_end(__f, __l); + typedef typename __split_buffer<value_type, allocator_type&>::iterator __fwd; + return insert(__p, move_iterator<__fwd>(__buf.begin()), move_iterator<__fwd>(__buf.end())); +} + +template <class _Tp, class _Allocator> template <class _BiIter> typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l, @@ -2269,19 +2267,14 @@ deque<_Tp, _Allocator>::__add_front_capacity() __split_buffer<pointer, typename __base::__pointer_allocator&> __buf(max<size_type>(2 * __base::__map_.capacity(), 1), 0, __base::__map_.__alloc()); -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - __buf.push_back(__alloc_traits::allocate(__a, __base::__block_size)); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __alloc_traits::deallocate(__a, __buf.front(), __base::__block_size); - throw; - } -#endif // _LIBCPP_NO_EXCEPTIONS + + typedef __allocator_destructor<_Allocator> _Dp; + unique_ptr<pointer, _Dp> __hold( + __alloc_traits::allocate(__a, __base::__block_size), + _Dp(__a, __base::__block_size)); + __buf.push_back(__hold.get()); + __hold.release(); + for (typename __base::__map_pointer __i = __base::__map_.begin(); __i != __base::__map_.end(); ++__i) __buf.push_back(*__i); @@ -2417,19 +2410,14 @@ deque<_Tp, _Allocator>::__add_back_capacity() __buf(max<size_type>(2* __base::__map_.capacity(), 1), __base::__map_.size(), __base::__map_.__alloc()); -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - __buf.push_back(__alloc_traits::allocate(__a, __base::__block_size)); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __alloc_traits::deallocate(__a, __buf.back(), __base::__block_size); - throw; - } -#endif // _LIBCPP_NO_EXCEPTIONS + + typedef __allocator_destructor<_Allocator> _Dp; + unique_ptr<pointer, _Dp> __hold( + __alloc_traits::allocate(__a, __base::__block_size), + _Dp(__a, __base::__block_size)); + __buf.push_back(__hold.get()); + __hold.release(); + for (typename __base::__map_pointer __i = __base::__map_.end(); __i != __base::__map_.begin();) __buf.push_front(*--__i); @@ -2702,7 +2690,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f) difference_type __pos = __f - __b; iterator __p = __b + __pos; allocator_type& __a = __base::__alloc(); - if (__pos < (__base::size() - 1) / 2) + if (__pos <= (__base::size() - 1) / 2) { // erase from front _VSTD::move_backward(__b, __p, _VSTD::next(__p)); __alloc_traits::destroy(__a, _VSTD::addressof(*__b)); @@ -2740,7 +2728,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l) if (__n > 0) { allocator_type& __a = __base::__alloc(); - if (__pos < (__base::size() - __n) / 2) + if (__pos <= (__base::size() - __n) / 2) { // erase from front iterator __i = _VSTD::move_backward(__b, __p, __p + __n); for (; __b != __i; ++__b) @@ -2796,8 +2784,12 @@ template <class _Tp, class _Allocator> inline _LIBCPP_INLINE_VISIBILITY void deque<_Tp, _Allocator>::swap(deque& __c) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value) +#endif { __base::swap(__c); } diff --git a/contrib/libc++/include/exception b/contrib/libc++/include/exception index cad802e056a5..5a905e7e58d8 100644 --- a/contrib/libc++/include/exception +++ b/contrib/libc++/include/exception @@ -48,7 +48,8 @@ terminate_handler set_terminate(terminate_handler f ) noexcept; terminate_handler get_terminate() noexcept; [[noreturn]] void terminate() noexcept; -bool uncaught_exception() noexcept; +bool uncaught_exception() noexcept; +int uncaught_exceptions() noexcept; // C++17 typedef unspecified exception_ptr; @@ -115,6 +116,7 @@ _LIBCPP_FUNC_VIS terminate_handler get_terminate() _NOEXCEPT; _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void terminate() _NOEXCEPT; _LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT; +_LIBCPP_FUNC_VIS int uncaught_exceptions() _NOEXCEPT; class _LIBCPP_TYPE_VIS exception_ptr; @@ -193,6 +195,7 @@ void throw_with_nested(_Tp&& __t, typename enable_if< is_class<typename remove_reference<_Tp>::type>::value && !is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value + && !__libcpp_is_final<typename remove_reference<_Tp>::type>::value >::type* = 0) #else // _LIBCPP_HAS_NO_RVALUE_REFERENCES throw_with_nested (_Tp& __t, typename enable_if< @@ -212,6 +215,7 @@ void throw_with_nested(_Tp&& __t, typename enable_if< !is_class<typename remove_reference<_Tp>::type>::value || is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value + || __libcpp_is_final<typename remove_reference<_Tp>::type>::value >::type* = 0) #else // _LIBCPP_HAS_NO_RVALUE_REFERENCES throw_with_nested (_Tp& __t, typename enable_if< diff --git a/contrib/libc++/include/experimental/__config b/contrib/libc++/include/experimental/__config index 684a3b4d83d8..f64a3a90cd12 100644 --- a/contrib/libc++/include/experimental/__config +++ b/contrib/libc++/include/experimental/__config @@ -13,6 +13,10 @@ #include <__config> +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace std { namespace experimental { #define _LIBCPP_END_NAMESPACE_EXPERIMENTAL } } #define _VSTD_EXPERIMENTAL std::experimental @@ -21,4 +25,8 @@ #define _LIBCPP_END_NAMESPACE_LFTS } } } #define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v1 +#define _LIBCPP_BEGIN_NAMESPACE_CHRONO_LFTS _LIBCPP_BEGIN_NAMESPACE_STD \ + namespace chrono { namespace experimental { inline namespace fundamentals_v1 { +#define _LIBCPP_END_NAMESPACE_CHRONO_LFTS _LIBCPP_END_NAMESPACE_STD } } } + #endif diff --git a/contrib/libc++/include/experimental/algorithm b/contrib/libc++/include/experimental/algorithm new file mode 100644 index 000000000000..a2e956f281a0 --- /dev/null +++ b/contrib/libc++/include/experimental/algorithm @@ -0,0 +1,114 @@ +// -*- C++ -*- +//===-------------------------- algorithm ---------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_ALGORITHM +#define _LIBCPP_EXPERIMENTAL_ALGORITHM + +/* + experimental/algorithm synopsis + +#include <algorithm> + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + +template <class ForwardIterator, class Searcher> +ForwardIterator search(ForwardIterator first, ForwardIterator last, + const Searcher &searcher); +template <class PopulationIterator, class SampleIterator, class Distance, + class UniformRandomNumberGenerator> +SampleIterator sample(PopulationIterator first, PopulationIterator last, + SampleIterator out, Distance n, + UniformRandomNumberGenerator &&g); + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + +*/ + +#include <experimental/__config> +#include <algorithm> +#include <type_traits> + +#include <__undef_min_max> + +#include <__debug> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS + + +template <class _PopulationIterator, class _SampleIterator, class _Distance, + class _UniformRandomNumberGenerator> +_LIBCPP_INLINE_VISIBILITY +_SampleIterator __sample(_PopulationIterator __first, + _PopulationIterator __last, _SampleIterator __out, + _Distance __n, + _UniformRandomNumberGenerator &&__g, + input_iterator_tag) { + + _Distance __k = 0; + for (; __first != __last && __k < __n; ++__first, (void)++__k) + __out[__k] = *__first; + _Distance __sz = __k; + for (; __first != __last; ++__first, (void)++__k) { + _Distance __r = _VSTD::uniform_int_distribution<_Distance>(0, __k)(__g); + if (__r < __sz) + __out[__r] = *__first; + } + return __out + _VSTD::min(__n, __k); +} + +template <class _PopulationIterator, class _SampleIterator, class _Distance, + class _UniformRandomNumberGenerator> +_LIBCPP_INLINE_VISIBILITY +_SampleIterator __sample(_PopulationIterator __first, + _PopulationIterator __last, _SampleIterator __out, + _Distance __n, + _UniformRandomNumberGenerator &&__g, + forward_iterator_tag) { + _Distance __unsampled_sz = _VSTD::distance(__first, __last); + for (__n = _VSTD::min(__n, __unsampled_sz); __n != 0; ++__first) { + _Distance __r = + _VSTD::uniform_int_distribution<_Distance>(0, --__unsampled_sz)(__g); + if (__r < __n) { + *__out++ = *__first; + --__n; + } + } + return __out; +} + +template <class _PopulationIterator, class _SampleIterator, class _Distance, + class _UniformRandomNumberGenerator> +_LIBCPP_INLINE_VISIBILITY +_SampleIterator sample(_PopulationIterator __first, + _PopulationIterator __last, _SampleIterator __out, + _Distance __n, _UniformRandomNumberGenerator &&__g) { + typedef typename iterator_traits<_PopulationIterator>::iterator_category + _PopCategory; + typedef typename iterator_traits<_PopulationIterator>::difference_type + _Difference; + typedef typename common_type<_Distance, _Difference>::type _CommonType; + _LIBCPP_ASSERT(__n >= 0, "N must be a positive number."); + return _VSTD_LFTS::__sample( + __first, __last, __out, _CommonType(__n), + _VSTD::forward<_UniformRandomNumberGenerator>(__g), + _PopCategory()); +} + +_LIBCPP_END_NAMESPACE_LFTS + +#endif /* _LIBCPP_EXPERIMENTAL_ALGORITHM */ diff --git a/contrib/libc++/include/experimental/chrono b/contrib/libc++/include/experimental/chrono new file mode 100644 index 000000000000..ca9e5f852ea2 --- /dev/null +++ b/contrib/libc++/include/experimental/chrono @@ -0,0 +1,59 @@ +// -*- C++ -*- +//===------------------------------ chrono ---------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_CHRONO +#define _LIBCPP_EXPERIMENTAL_CHRONO + +/** + experimental/chrono synopsis + +// C++1y + +#include <chrono> + +namespace std { +namespace chrono { +namespace experimental { +inline namespace fundamentals_v1 { + + // See C++14 20.12.4, customization traits + template <class Rep> constexpr bool treat_as_floating_point_v + = treat_as_floating_point<Rep>::value; + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace chrono +} // namespace std + + */ + +#include <experimental/__config> +#include <chrono> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#if _LIBCPP_STD_VER > 11 + +_LIBCPP_BEGIN_NAMESPACE_CHRONO_LFTS + +#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES + +template <class _Rep> _LIBCPP_CONSTEXPR bool treat_as_floating_point_v + = treat_as_floating_point<_Rep>::value; + +#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */ + +_LIBCPP_END_NAMESPACE_CHRONO_LFTS + +#endif /* _LIBCPP_STD_VER > 11 */ + +#endif /* _LIBCPP_EXPERIMENTAL_CHRONO */ diff --git a/contrib/libc++/include/experimental/dynarray b/contrib/libc++/include/experimental/dynarray index 0bc8dfe2cb7b..a0258628dfa6 100644 --- a/contrib/libc++/include/experimental/dynarray +++ b/contrib/libc++/include/experimental/dynarray @@ -104,6 +104,8 @@ public: #include <new> #include <algorithm> +#include <__undef___deallocate> + #if defined(_LIBCPP_NO_EXCEPTIONS) #include <cassert> #endif diff --git a/contrib/libc++/include/experimental/ratio b/contrib/libc++/include/experimental/ratio new file mode 100644 index 000000000000..757f24e08614 --- /dev/null +++ b/contrib/libc++/include/experimental/ratio @@ -0,0 +1,77 @@ +// -*- C++ -*- +//===------------------------------ ratio ---------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_RATIO +#define _LIBCPP_EXPERIMENTAL_RATIO + +/** + experimental/ratio synopsis + C++1y +#include <ratio> + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + + // See C++14 20.11.5, ratio comparison + template <class R1, class R2> constexpr bool ratio_equal_v + = ratio_equal<R1, R2>::value; + template <class R1, class R2> constexpr bool ratio_not_equal_v + = ratio_not_equal<R1, R2>::value; + template <class R1, class R2> constexpr bool ratio_less_v + = ratio_less<R1, R2>::value; + template <class R1, class R2> constexpr bool ratio_less_equal_v + = ratio_less_equal<R1, R2>::value; + template <class R1, class R2> constexpr bool ratio_greater_v + = ratio_greater<R1, R2>::value; + template <class R1, class R2> constexpr bool ratio_greater_equal_v + = ratio_greater_equal<R1, R2>::value; + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + +*/ + +#include <experimental/__config> + +#if _LIBCPP_STD_VER > 11 + +#include <ratio> + +_LIBCPP_BEGIN_NAMESPACE_LFTS + +#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES + +template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_equal_v + = ratio_equal<_R1, _R2>::value; + +template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_not_equal_v + = ratio_not_equal<_R1, _R2>::value; + +template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_less_v + = ratio_less<_R1, _R2>::value; + +template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_less_equal_v + = ratio_less_equal<_R1, _R2>::value; + +template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_v + = ratio_greater<_R1, _R2>::value; + +template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_equal_v + = ratio_greater_equal<_R1, _R2>::value; + +#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */ + +_LIBCPP_END_NAMESPACE_LFTS + +#endif /* _LIBCPP_STD_VER > 11 */ + +#endif // _LIBCPP_EXPERIMENTAL_RATIO diff --git a/contrib/libc++/include/experimental/string_view b/contrib/libc++/include/experimental/string_view index d423f39003a5..2a20d7caa687 100644 --- a/contrib/libc++/include/experimental/string_view +++ b/contrib/libc++/include/experimental/string_view @@ -280,11 +280,8 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS const_reference at(size_type __pos) const { return __pos >= size() - ? throw out_of_range("string_view::at") + ? (throw out_of_range("string_view::at"), __data[0]) : __data[__pos]; -// if (__pos >= size()) -// throw out_of_range("string_view::at"); -// return __data[__pos]; } _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY @@ -313,7 +310,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY void remove_prefix(size_type __n) _NOEXCEPT { - _LIBCPP_ASSERT(n <= size(), "remove_prefix() can't remove more than size()"); + _LIBCPP_ASSERT(__n <= size(), "remove_prefix() can't remove more than size()"); __data += __n; __size -= __n; } @@ -321,7 +318,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY void remove_suffix(size_type __n) _NOEXCEPT { - _LIBCPP_ASSERT(n <= size(), "remove_suffix() can't remove more than size()"); + _LIBCPP_ASSERT(__n <= size(), "remove_suffix() can't remove more than size()"); __size -= __n; } diff --git a/contrib/libc++/include/experimental/system_error b/contrib/libc++/include/experimental/system_error new file mode 100644 index 000000000000..2ec238544615 --- /dev/null +++ b/contrib/libc++/include/experimental/system_error @@ -0,0 +1,63 @@ +// -*- C++ -*- +//===-------------------------- system_error ------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR +#define _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR + +/** + experimental/system_error synopsis + +// C++1y + +#include <system_error> + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + + // See C++14 19.5, System error support + template <class T> constexpr bool is_error_code_enum_v + = is_error_code_enum<T>::value; + template <class T> constexpr bool is_error_condition_enum_v + = is_error_condition_enum<T>::value; + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + +*/ + +#include <experimental/__config> + +#if _LIBCPP_STD_VER > 11 + +#include <system_error> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS + +#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES + +template <class _Tp> _LIBCPP_CONSTEXPR bool is_error_code_enum_v + = is_error_code_enum<_Tp>::value; + +template <class _Tp> _LIBCPP_CONSTEXPR bool is_error_condition_enum_v + = is_error_condition_enum<_Tp>::value; + +#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */ + +_LIBCPP_END_NAMESPACE_LFTS + +#endif /* _LIBCPP_STD_VER > 11 */ + +#endif /* _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR */ diff --git a/contrib/libc++/include/experimental/tuple b/contrib/libc++/include/experimental/tuple new file mode 100644 index 000000000000..50d1e0555bc4 --- /dev/null +++ b/contrib/libc++/include/experimental/tuple @@ -0,0 +1,81 @@ +// -*- C++ -*- +//===----------------------------- tuple ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_TUPLE +#define _LIBCPP_EXPERIMENTAL_TUPLE + +/* + experimental/tuple synopsis + +// C++1y + +#include <tuple> + +namespace std { +namespace experimental { +inline namespace fundamentals_v1 { + + // See C++14 20.4.2.5, tuple helper classes + template <class T> constexpr size_t tuple_size_v + = tuple_size<T>::value; + + // 3.2.2, Calling a function with a tuple of arguments + template <class F, class Tuple> + constexpr decltype(auto) apply(F&& f, Tuple&& t); + +} // namespace fundamentals_v1 +} // namespace experimental +} // namespace std + + */ + +# include <experimental/__config> + +#if _LIBCPP_STD_VER > 11 + +# include <tuple> +# include <utility> +# include <__functional_base> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_LFTS + +#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES +template <class _Tp> +_LIBCPP_CONSTEXPR size_t tuple_size_v = tuple_size<_Tp>::value; +#endif + +template <class _Fn, class _Tuple, size_t ..._Id> +inline _LIBCPP_INLINE_VISIBILITY +decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t, + integer_sequence<size_t, _Id...>) { + return _VSTD::__invoke( + _VSTD::forward<_Fn>(__f), + _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))... + ); +} + +template <class _Fn, class _Tuple> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 +decltype(auto) apply(_Fn && __f, _Tuple && __t) { + return _VSTD_LFTS::__apply_tuple_impl( + _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t), + make_index_sequence<tuple_size<typename decay<_Tuple>::type>::value>() + ); +} + +_LIBCPP_END_NAMESPACE_LFTS + +#endif /* _LIBCPP_STD_VER > 11 */ + +#endif /* _LIBCPP_EXPERIMENTAL_TUPLE */ diff --git a/contrib/libc++/include/experimental/type_traits b/contrib/libc++/include/experimental/type_traits index ab2c8cdf81d6..ae49fc176c01 100644 --- a/contrib/libc++/include/experimental/type_traits +++ b/contrib/libc++/include/experimental/type_traits @@ -184,9 +184,13 @@ inline namespace fundamentals_v1 { #include <type_traits> +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + _LIBCPP_BEGIN_NAMESPACE_LFTS -#if __has_feature(cxx_variable_templates) +#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES // C++14 20.10.4.1, primary type categories @@ -393,7 +397,7 @@ template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_base_of_v template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_convertible_v = is_convertible<_Tp, _Up>::value; -#endif /* __has_feature(cxx_variable_templates) */ +#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */ // 3.3.2, Other type transformations /* diff --git a/contrib/libc++/include/experimental/utility b/contrib/libc++/include/experimental/utility index 84e461af073f..b5fca6c775bc 100644 --- a/contrib/libc++/include/experimental/utility +++ b/contrib/libc++/include/experimental/utility @@ -31,9 +31,12 @@ inline namespace fundamentals_v1 { */ -# include <experimental/__config> +#include <experimental/__config> +#include <utility> -# include <utility> +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif _LIBCPP_BEGIN_NAMESPACE_LFTS diff --git a/contrib/libc++/include/ext/hash_map b/contrib/libc++/include/ext/hash_map index 36cd595e0343..31fcedfb9f9e 100644 --- a/contrib/libc++/include/ext/hash_map +++ b/contrib/libc++/include/ext/hash_map @@ -203,6 +203,7 @@ template <class Key, class T, class Hash, class Pred, class Alloc> #include <__hash_table> #include <functional> #include <stdexcept> +#include <type_traits> #include <ext/__hash> #if __DEPRECATED @@ -213,16 +214,16 @@ template <class Key, class T, class Hash, class Pred, class Alloc> #endif #endif +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header +#endif namespace __gnu_cxx { using namespace std; -template <class _Tp, class _Hash, bool = is_empty<_Hash>::value -#if __has_feature(is_final) - && !__is_final(_Hash) -#endif +template <class _Tp, class _Hash, + bool = is_empty<_Hash>::value && !__libcpp_is_final<_Hash>::value > class __hash_map_hasher : private _Hash @@ -255,10 +256,8 @@ public: {return __hash_(__x);} }; -template <class _Tp, class _Pred, bool = is_empty<_Pred>::value -#if __has_feature(is_final) - && !__is_final(_Pred) -#endif +template <class _Tp, class _Pred, + bool = is_empty<_Pred>::value && !__libcpp_is_final<_Pred>::value > class __hash_map_equal : private _Pred @@ -493,13 +492,7 @@ private: typedef pair<key_type, mapped_type> __value_type; typedef __hash_map_hasher<__value_type, hasher> __hasher; typedef __hash_map_equal<__value_type, key_equal> __key_equal; - typedef typename allocator_traits<allocator_type>::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__value_type> -#else - rebind_alloc<__value_type>::other -#endif - __allocator_type; + typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, __value_type>::type __allocator_type; typedef __hash_table<__value_type, __hasher, __key_equal, __allocator_type> __table; @@ -772,13 +765,7 @@ private: typedef pair<key_type, mapped_type> __value_type; typedef __hash_map_hasher<__value_type, hasher> __hasher; typedef __hash_map_equal<__value_type, key_equal> __key_equal; - typedef typename allocator_traits<allocator_type>::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__value_type> -#else - rebind_alloc<__value_type>::other -#endif - __allocator_type; + typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, __value_type>::type __allocator_type; typedef __hash_table<__value_type, __hasher, __key_equal, __allocator_type> __table; diff --git a/contrib/libc++/include/forward_list b/contrib/libc++/include/forward_list index 651452f3fe8d..8a87fc5e1f26 100644 --- a/contrib/libc++/include/forward_list +++ b/contrib/libc++/include/forward_list @@ -107,8 +107,7 @@ public: iterator erase_after(const_iterator first, const_iterator last); void swap(forward_list& x) - noexcept(!allocator_type::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value); + noexcept(allocator_traits<allocator_type>::is_always_equal::value); // C++17 void resize(size_type n); void resize(size_type n, const value_type& v); @@ -218,7 +217,7 @@ struct __forward_list_node value_type __value_; }; -template<class _Tp, class _Alloc> class _LIBCPP_TYPE_VIS_ONLY forward_list; +template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TYPE_VIS_ONLY forward_list; template<class _NodeConstPtr> class _LIBCPP_TYPE_VIS_ONLY __forward_list_const_iterator; template <class _NodePtr> @@ -365,24 +364,12 @@ protected: typedef typename allocator_traits<allocator_type>::void_pointer void_pointer; typedef __forward_list_node<value_type, void_pointer> __node; typedef typename __begin_node_of<value_type, void_pointer>::type __begin_node; - typedef typename allocator_traits<allocator_type>::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__node> -#else - rebind_alloc<__node>::other -#endif - __node_allocator; + typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, __node>::type __node_allocator; typedef allocator_traits<__node_allocator> __node_traits; typedef typename __node_traits::pointer __node_pointer; typedef typename __node_traits::pointer __node_const_pointer; - typedef typename allocator_traits<allocator_type>::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__begin_node> -#else - rebind_alloc<__begin_node>::other -#endif - __begin_node_allocator; + typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, __begin_node>::type __begin_node_allocator; typedef typename allocator_traits<__begin_node_allocator>::pointer __begin_node_pointer; __compressed_pair<__begin_node, __node_allocator> __before_begin_; @@ -443,8 +430,12 @@ protected: public: void swap(__forward_list_base& __x) - _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value); +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT; +#else + _NOEXCEPT_(!__node_traits::propagate_on_container_move_assignment::value || + __is_nothrow_swappable<__node_allocator>::value); +#endif protected: void clear() _NOEXCEPT; @@ -466,26 +457,6 @@ private: void __move_assign_alloc(__forward_list_base& __x, true_type) _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value) {__alloc() = _VSTD::move(__x.__alloc());} - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__node_allocator& __x, __node_allocator& __y) - _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value) - {__swap_alloc(__x, __y, integral_constant<bool, - __node_traits::propagate_on_container_swap::value>());} - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, - false_type) - _NOEXCEPT - {} - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, - true_type) - _NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value) - { - using _VSTD::swap; - swap(__x, __y); - } }; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -524,10 +495,15 @@ template <class _Tp, class _Alloc> inline _LIBCPP_INLINE_VISIBILITY void __forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x) - _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else + _NOEXCEPT_(!__node_traits::propagate_on_container_move_assignment::value || + __is_nothrow_swappable<__node_allocator>::value) +#endif { - __swap_alloc(__alloc(), __x.__alloc()); + __swap_allocator(__alloc(), __x.__alloc(), + integral_constant<bool, __node_traits::propagate_on_container_swap::value>()); using _VSTD::swap; swap(__before_begin()->__next_, __x.__before_begin()->__next_); } @@ -547,7 +523,7 @@ __forward_list_base<_Tp, _Alloc>::clear() _NOEXCEPT __before_begin()->__next_ = nullptr; } -template <class _Tp, class _Alloc = allocator<_Tp> > +template <class _Tp, class _Alloc /*= allocator<_Tp>*/> class _LIBCPP_TYPE_VIS_ONLY forward_list : private __forward_list_base<_Tp, _Alloc> { @@ -715,8 +691,12 @@ public: _LIBCPP_INLINE_VISIBILITY void swap(forward_list& __x) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value || __is_nothrow_swappable<__node_allocator>::value) +#endif {base::swap(__x);} void resize(size_type __n); diff --git a/contrib/libc++/include/fstream b/contrib/libc++/include/fstream index 38778c6779aa..1f289eddc56f 100644 --- a/contrib/libc++/include/fstream +++ b/contrib/libc++/include/fstream @@ -206,8 +206,10 @@ public: // 27.9.1.4 Members: bool is_open() const; +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE basic_filebuf* open(const char* __s, ios_base::openmode __mode); basic_filebuf* open(const string& __s, ios_base::openmode __mode); +#endif basic_filebuf* close(); protected: @@ -463,6 +465,7 @@ basic_filebuf<_CharT, _Traits>::is_open() const return __file_ != 0; } +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE template <class _CharT, class _Traits> basic_filebuf<_CharT, _Traits>* basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) @@ -550,6 +553,7 @@ basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mod { return open(__s.c_str(), __mode); } +#endif template <class _CharT, class _Traits> basic_filebuf<_CharT, _Traits>* @@ -807,7 +811,7 @@ basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way, default: return pos_type(off_type(-1)); } -#if _WIN32 +#if defined(_WIN32) || defined(_NEWLIB_VERSION) if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence)) return pos_type(off_type(-1)); pos_type __r = ftell(__file_); @@ -826,7 +830,7 @@ basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode) { if (__file_ == 0 || sync()) return pos_type(off_type(-1)); -#if _WIN32 +#if defined(_WIN32) || defined(_NEWLIB_VERSION) if (fseek(__file_, __sp, SEEK_SET)) return pos_type(off_type(-1)); #else @@ -891,7 +895,7 @@ basic_filebuf<_CharT, _Traits>::sync() } } } -#if _WIN32 +#if defined(_WIN32) || defined(_NEWLIB_VERSION) if (fseek(__file_, -__c, SEEK_CUR)) return -1; #else @@ -1005,8 +1009,10 @@ public: typedef typename traits_type::off_type off_type; basic_ifstream(); +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in); explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in); +#endif #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES basic_ifstream(basic_ifstream&& __rhs); #endif @@ -1018,8 +1024,10 @@ public: basic_filebuf<char_type, traits_type>* rdbuf() const; bool is_open() const; +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE void open(const char* __s, ios_base::openmode __mode = ios_base::in); void open(const string& __s, ios_base::openmode __mode = ios_base::in); +#endif void close(); private: @@ -1033,6 +1041,7 @@ basic_ifstream<_CharT, _Traits>::basic_ifstream() { } +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE template <class _CharT, class _Traits> inline _LIBCPP_INLINE_VISIBILITY basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode) @@ -1050,6 +1059,7 @@ basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::ope if (__sb_.open(__s, __mode | ios_base::in) == 0) this->setstate(ios_base::failbit); } +#endif #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -1107,6 +1117,7 @@ basic_ifstream<_CharT, _Traits>::is_open() const return __sb_.is_open(); } +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE template <class _CharT, class _Traits> void basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) @@ -1126,6 +1137,7 @@ basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mo else this->setstate(ios_base::failbit); } +#endif template <class _CharT, class _Traits> inline _LIBCPP_INLINE_VISIBILITY @@ -1163,8 +1175,10 @@ public: basic_filebuf<char_type, traits_type>* rdbuf() const; bool is_open() const; +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE void open(const char* __s, ios_base::openmode __mode = ios_base::out); void open(const string& __s, ios_base::openmode __mode = ios_base::out); +#endif void close(); private: @@ -1178,6 +1192,7 @@ basic_ofstream<_CharT, _Traits>::basic_ofstream() { } +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE template <class _CharT, class _Traits> inline _LIBCPP_INLINE_VISIBILITY basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode) @@ -1195,6 +1210,7 @@ basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::ope if (__sb_.open(__s, __mode | ios_base::out) == 0) this->setstate(ios_base::failbit); } +#endif #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -1252,6 +1268,7 @@ basic_ofstream<_CharT, _Traits>::is_open() const return __sb_.is_open(); } +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE template <class _CharT, class _Traits> void basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) @@ -1271,6 +1288,7 @@ basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mo else this->setstate(ios_base::failbit); } +#endif template <class _CharT, class _Traits> inline _LIBCPP_INLINE_VISIBILITY @@ -1295,8 +1313,10 @@ public: typedef typename traits_type::off_type off_type; basic_fstream(); +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); +#endif #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES basic_fstream(basic_fstream&& __rhs); #endif @@ -1308,8 +1328,10 @@ public: basic_filebuf<char_type, traits_type>* rdbuf() const; bool is_open() const; +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); +#endif void close(); private: @@ -1323,6 +1345,7 @@ basic_fstream<_CharT, _Traits>::basic_fstream() { } +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE template <class _CharT, class _Traits> inline _LIBCPP_INLINE_VISIBILITY basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode) @@ -1340,6 +1363,7 @@ basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openm if (__sb_.open(__s, __mode) == 0) this->setstate(ios_base::failbit); } +#endif #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -1397,6 +1421,7 @@ basic_fstream<_CharT, _Traits>::is_open() const return __sb_.is_open(); } +#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE template <class _CharT, class _Traits> void basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) @@ -1416,6 +1441,7 @@ basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mod else this->setstate(ios_base::failbit); } +#endif template <class _CharT, class _Traits> inline _LIBCPP_INLINE_VISIBILITY diff --git a/contrib/libc++/include/functional b/contrib/libc++/include/functional index d14b46bb76af..5ee941763020 100644 --- a/contrib/libc++/include/functional +++ b/contrib/libc++/include/functional @@ -504,7 +504,9 @@ struct _LIBCPP_TYPE_VIS_ONLY plus<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -529,7 +531,9 @@ struct _LIBCPP_TYPE_VIS_ONLY minus<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -554,7 +558,9 @@ struct _LIBCPP_TYPE_VIS_ONLY multiplies<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -579,7 +585,9 @@ struct _LIBCPP_TYPE_VIS_ONLY divides<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -604,7 +612,9 @@ struct _LIBCPP_TYPE_VIS_ONLY modulus<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -629,7 +639,9 @@ struct _LIBCPP_TYPE_VIS_ONLY negate<void> template <class _Tp> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const - { return -_VSTD::forward<_Tp>(__x); } + _NOEXCEPT_(noexcept(- _VSTD::forward<_Tp>(__x))) + -> decltype (- _VSTD::forward<_Tp>(__x)) + { return - _VSTD::forward<_Tp>(__x); } typedef void is_transparent; }; #endif @@ -654,7 +666,9 @@ struct _LIBCPP_TYPE_VIS_ONLY equal_to<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -679,7 +693,9 @@ struct _LIBCPP_TYPE_VIS_ONLY not_equal_to<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -704,7 +720,9 @@ struct _LIBCPP_TYPE_VIS_ONLY greater<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -731,7 +749,9 @@ struct _LIBCPP_TYPE_VIS_ONLY greater_equal<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -756,7 +776,9 @@ struct _LIBCPP_TYPE_VIS_ONLY less_equal<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -781,7 +803,9 @@ struct _LIBCPP_TYPE_VIS_ONLY logical_and<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -806,7 +830,9 @@ struct _LIBCPP_TYPE_VIS_ONLY logical_or<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -831,7 +857,9 @@ struct _LIBCPP_TYPE_VIS_ONLY logical_not<void> template <class _Tp> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const - { return !_VSTD::forward<_Tp>(__x); } + _NOEXCEPT_(noexcept(!_VSTD::forward<_Tp>(__x))) + -> decltype (!_VSTD::forward<_Tp>(__x)) + { return !_VSTD::forward<_Tp>(__x); } typedef void is_transparent; }; #endif @@ -856,7 +884,9 @@ struct _LIBCPP_TYPE_VIS_ONLY bit_and<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -881,7 +911,9 @@ struct _LIBCPP_TYPE_VIS_ONLY bit_or<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -906,7 +938,9 @@ struct _LIBCPP_TYPE_VIS_ONLY bit_xor<void> template <class _T1, class _T2> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))) + -> decltype (_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)) + { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -927,7 +961,9 @@ struct _LIBCPP_TYPE_VIS_ONLY bit_not<void> template <class _Tp> _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const - { return ~_VSTD::forward<_Tp>(__x); } + _NOEXCEPT_(noexcept(~_VSTD::forward<_Tp>(__x))) + -> decltype (~_VSTD::forward<_Tp>(__x)) + { return ~_VSTD::forward<_Tp>(__x); } typedef void is_transparent; }; #endif @@ -1331,7 +1367,8 @@ template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> __base<_Rp(_ArgTypes...)>* __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const { - typedef typename _Alloc::template rebind<__func>::other _Ap; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; _Ap __a(__f_.second()); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); @@ -1357,7 +1394,8 @@ template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> void __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT { - typedef typename _Alloc::template rebind<__func>::other _Ap; + typedef allocator_traits<_Alloc> __alloc_traits; + typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); @@ -1367,7 +1405,8 @@ template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> _Rp __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) { - return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...); } #ifndef _LIBCPP_NO_RTTI @@ -1429,7 +1468,7 @@ class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_ArgTypes...)> template <class _Fp> struct __callable<_Fp, true> { - static const bool value = + static const bool value = is_same<void, _Rp>::value || is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type, _Rp>::value; }; @@ -1617,13 +1656,7 @@ function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp _ if (__not_null(__f)) { typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF; - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<_FF> -#else - rebind_alloc<_FF>::other -#endif - _Ap; + typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap; _Ap __a(__a0); if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value && is_nothrow_copy_constructible<_Ap>::value) @@ -1963,27 +1996,27 @@ struct __mu_return }; template <class _Fp, class _BoundArgs, class _TupleUj> -struct _is_valid_bind_return +struct __is_valid_bind_return { static const bool value = false; }; template <class _Fp, class ..._BoundArgs, class _TupleUj> -struct _is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> +struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> { static const bool value = __invokable<_Fp, typename __mu_return<_BoundArgs, _TupleUj>::type...>::value; }; template <class _Fp, class ..._BoundArgs, class _TupleUj> -struct _is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> +struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> { static const bool value = __invokable<_Fp, typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value; }; template <class _Fp, class _BoundArgs, class _TupleUj, - bool = _is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value> + bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value> struct __bind_return; template <class _Fp, class ..._BoundArgs, class _TupleUj> @@ -2153,12 +2186,13 @@ public: typename enable_if < is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type, - result_type>::value, + result_type>::value || is_void<_Rp>::value, result_type >::type operator()(_Args&& ...__args) { - return base::operator()(_VSTD::forward<_Args>(__args)...); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...); } template <class ..._Args> @@ -2166,12 +2200,13 @@ public: typename enable_if < is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type, - result_type>::value, + result_type>::value || is_void<_Rp>::value, result_type >::type operator()(_Args&& ...__args) const { - return base::operator()(_VSTD::forward<_Args>(__args)...); + typedef __invoke_void_return_wrapper<_Rp> _Invoker; + return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...); } }; @@ -2412,6 +2447,15 @@ struct _LIBCPP_TYPE_VIS_ONLY hash }; #endif + +#if _LIBCPP_STD_VER > 14 +template <class _Fn, class ..._Args> +result_of_t<_Fn&&(_Args&&...)> +invoke(_Fn&& __f, _Args&&... __args) { + return __invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...); +} +#endif + // struct hash<T*> in <memory> _LIBCPP_END_NAMESPACE_STD diff --git a/contrib/libc++/include/future b/contrib/libc++/include/future index 6fe6f8da5049..5b5afe6e2771 100644 --- a/contrib/libc++/include/future +++ b/contrib/libc++/include/future @@ -329,7 +329,7 @@ public: template <class F> explicit packaged_task(F&& f); template <class F, class Allocator> - explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f); + packaged_task(allocator_arg_t, const Allocator& a, F&& f); ~packaged_task(); // no copy @@ -651,7 +651,6 @@ __assoc_state<_Rp>::set_value(_Arg& __arg) #endif ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg)); this->__state_ |= base::__constructed | base::ready; - __lk.unlock(); __cv_.notify_all(); } @@ -672,7 +671,6 @@ __assoc_state<_Rp>::set_value_at_thread_exit(_Arg& __arg) ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg)); this->__state_ |= base::__constructed; __thread_local_data()->__make_ready_at_thread_exit(this); - __lk.unlock(); } template <class _Rp> @@ -733,7 +731,6 @@ __assoc_state<_Rp&>::set_value(_Rp& __arg) #endif __value_ = _VSTD::addressof(__arg); this->__state_ |= base::__constructed | base::ready; - __lk.unlock(); __cv_.notify_all(); } @@ -749,7 +746,6 @@ __assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg) __value_ = _VSTD::addressof(__arg); this->__state_ |= base::__constructed; __thread_local_data()->__make_ready_at_thread_exit(this); - __lk.unlock(); } template <class _Rp> @@ -783,10 +779,10 @@ __assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT { if (this->__state_ & base::__constructed) reinterpret_cast<_Rp*>(_VSTD::addressof(this->__value_))->~_Rp(); - typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _A; - typedef allocator_traits<_A> _ATraits; + typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al; + typedef allocator_traits<_Al> _ATraits; typedef pointer_traits<typename _ATraits::pointer> _PTraits; - _A __a(__alloc_); + _Al __a(__alloc_); this->~__assoc_state_alloc(); __a.deallocate(_PTraits::pointer_to(*this), 1); } @@ -809,10 +805,10 @@ template <class _Rp, class _Alloc> void __assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT { - typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _A; - typedef allocator_traits<_A> _ATraits; + typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al; + typedef allocator_traits<_Al> _ATraits; typedef pointer_traits<typename _ATraits::pointer> _PTraits; - _A __a(__alloc_); + _Al __a(__alloc_); this->~__assoc_state_alloc(); __a.deallocate(_PTraits::pointer_to(*this), 1); } @@ -835,10 +831,10 @@ template <class _Alloc> void __assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT { - typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _A; - typedef allocator_traits<_A> _ATraits; + typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _Al; + typedef allocator_traits<_Al> _ATraits; typedef pointer_traits<typename _ATraits::pointer> _PTraits; - _A __a(__alloc_); + _Al __a(__alloc_); this->~__assoc_sub_state_alloc(); __a.deallocate(_PTraits::pointer_to(*this), 1); } @@ -2046,7 +2042,7 @@ public: >::type > _LIBCPP_INLINE_VISIBILITY - explicit packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) + packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)), __p_(allocator_arg, __a) {} // ~packaged_task() = default; @@ -2177,7 +2173,7 @@ public: >::type > _LIBCPP_INLINE_VISIBILITY - explicit packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) + packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)), __p_(allocator_arg, __a) {} // ~packaged_task() = default; diff --git a/contrib/libc++/include/iosfwd b/contrib/libc++/include/iosfwd index d24c227bef79..eccfd349a4a5 100644 --- a/contrib/libc++/include/iosfwd +++ b/contrib/libc++/include/iosfwd @@ -180,7 +180,12 @@ typedef fpos<mbstate_t> u16streampos; typedef fpos<mbstate_t> u32streampos; #endif // _LIBCPP_HAS_NO_UNICODE_CHARS +#if defined(_NEWLIB_VERSION) +// On newlib, off_t is 'long int' +typedef long int streamoff; // for char_traits in <string> +#else typedef long long streamoff; // for char_traits in <string> +#endif template <class _CharT, // for <stdexcept> class _Traits = char_traits<_CharT>, diff --git a/contrib/libc++/include/iostream b/contrib/libc++/include/iostream index ddf248411448..136a849777fe 100644 --- a/contrib/libc++/include/iostream +++ b/contrib/libc++/include/iostream @@ -46,13 +46,17 @@ extern wostream wclog; _LIBCPP_BEGIN_NAMESPACE_STD +#ifndef _LIBCPP_HAS_NO_STDIN extern _LIBCPP_FUNC_VIS istream cin; -extern _LIBCPP_FUNC_VIS ostream cout; -extern _LIBCPP_FUNC_VIS ostream cerr; -extern _LIBCPP_FUNC_VIS ostream clog; extern _LIBCPP_FUNC_VIS wistream wcin; +#endif +#ifndef _LIBCPP_HAS_NO_STDOUT +extern _LIBCPP_FUNC_VIS ostream cout; extern _LIBCPP_FUNC_VIS wostream wcout; +#endif +extern _LIBCPP_FUNC_VIS ostream cerr; extern _LIBCPP_FUNC_VIS wostream wcerr; +extern _LIBCPP_FUNC_VIS ostream clog; extern _LIBCPP_FUNC_VIS wostream wclog; _LIBCPP_END_NAMESPACE_STD diff --git a/contrib/libc++/include/iterator b/contrib/libc++/include/iterator index bcf142a6c833..c06ef8f6777d 100644 --- a/contrib/libc++/include/iterator +++ b/contrib/libc++/include/iterator @@ -214,7 +214,7 @@ public: typedef traits traits_type; typedef basic_istream<charT,traits> istream_type; - istream_iterator(); + constexpr istream_iterator(); istream_iterator(istream_type& s); istream_iterator(const istream_iterator& x); ~istream_iterator(); @@ -575,7 +575,7 @@ public: _LIBCPP_INLINE_VISIBILITY reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;} _LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const - {return current[-__n-1];} + {return *(*this + __n);} }; template <class _Iter1, class _Iter2> @@ -765,7 +765,7 @@ private: istream_type* __in_stream_; _Tp __value_; public: - _LIBCPP_INLINE_VISIBILITY istream_iterator() : __in_stream_(0) {} + _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(0), __value_() {} _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(&__s) { if (!(*__in_stream_ >> __value_)) @@ -1241,7 +1241,7 @@ private: template <class _Up> friend class __wrap_iter; template <class _CharT, class _Traits, class _Alloc> friend class basic_string; - template <class _Tp, class _Alloc> friend class vector; + template <class _Tp, class _Alloc> friend class _LIBCPP_TYPE_VIS_ONLY vector; template <class _Iter1, class _Iter2> friend @@ -1580,29 +1580,29 @@ end(const _Cp& __c) #endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN) #if _LIBCPP_STD_VER > 14 -template <class _C> -constexpr auto size(const _C& __c) -> decltype(__c.size()) { return __c.size(); } +template <class _Cont> +constexpr auto size(const _Cont& __c) -> decltype(__c.size()) { return __c.size(); } -template <class _Tp, size_t _N> -constexpr size_t size(const _Tp (&__array)[_N]) noexcept { return _N; } +template <class _Tp, size_t _Sz> +constexpr size_t size(const _Tp (&__array)[_Sz]) noexcept { return _Sz; } -template <class _C> -constexpr auto empty(const _C& __c) -> decltype(__c.empty()) { return __c.empty(); } +template <class _Cont> +constexpr auto empty(const _Cont& __c) -> decltype(__c.empty()) { return __c.empty(); } -template <class _Tp, size_t _N> -constexpr bool empty(const _Tp (&__array)[_N]) noexcept { return false; } +template <class _Tp, size_t _Sz> +constexpr bool empty(const _Tp (&__array)[_Sz]) noexcept { return false; } template <class _Ep> constexpr bool empty(initializer_list<_Ep> __il) noexcept { return __il.size() == 0; } -template <class _C> constexpr -auto data(_C& __c) -> decltype(__c.data()) { return __c.data(); } +template <class _Cont> constexpr +auto data(_Cont& __c) -> decltype(__c.data()) { return __c.data(); } -template <class _C> constexpr -auto data(const _C& __c) -> decltype(__c.data()) { return __c.data(); } +template <class _Cont> constexpr +auto data(const _Cont& __c) -> decltype(__c.data()) { return __c.data(); } -template <class _Tp, size_t _N> -constexpr _Tp* data(_Tp (&__array)[_N]) noexcept { return __array; } +template <class _Tp, size_t _Sz> +constexpr _Tp* data(_Tp (&__array)[_Sz]) noexcept { return __array; } template <class _Ep> constexpr const _Ep* data(initializer_list<_Ep> __il) noexcept { return __il.begin(); } diff --git a/contrib/libc++/include/list b/contrib/libc++/include/list index 13f8a53bf25f..14201a80e348 100644 --- a/contrib/libc++/include/list +++ b/contrib/libc++/include/list @@ -118,8 +118,7 @@ public: void resize(size_type sz, const value_type& c); void swap(list&) - noexcept(!allocator_type::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value); + noexcept(allocator_traits<allocator_type>::is_always_equal::value); // C++17 void clear() noexcept; void splice(const_iterator position, list& x); @@ -226,7 +225,7 @@ struct __list_node _Tp __value_; }; -template <class _Tp, class _Alloc> class _LIBCPP_TYPE_VIS_ONLY list; +template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TYPE_VIS_ONLY list; template <class _Tp, class _Alloc> class __list_imp; template <class _Tp, class _VoidPtr> class _LIBCPP_TYPE_VIS_ONLY __list_const_iterator; @@ -515,13 +514,7 @@ protected: typedef __list_const_iterator<value_type, __void_pointer> const_iterator; typedef __list_node_base<value_type, __void_pointer> __node_base; typedef __list_node<value_type, __void_pointer> __node; - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__node> -#else - rebind_alloc<__node>::other -#endif - __node_allocator; + typedef typename __rebind_alloc_helper<__alloc_traits, __node>::type __node_allocator; typedef allocator_traits<__node_allocator> __node_alloc_traits; typedef typename __node_alloc_traits::pointer __node_pointer; typedef typename __node_alloc_traits::pointer __node_const_pointer; @@ -529,13 +522,7 @@ protected: typedef typename __alloc_traits::const_pointer const_pointer; typedef typename __alloc_traits::difference_type difference_type; - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__node_base> -#else - rebind_alloc<__node_base>::other -#endif - __node_base_allocator; + typedef typename __rebind_alloc_helper<__alloc_traits, __node_base>::type __node_base_allocator; typedef typename allocator_traits<__node_base_allocator>::pointer __node_base_pointer; __node_base __end_; @@ -605,8 +592,12 @@ protected: } void swap(__list_imp& __c) - _NOEXCEPT_(!__node_alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value); +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT; +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value); +#endif _LIBCPP_INLINE_VISIBILITY void __copy_assign_alloc(const __list_imp& __c) @@ -623,24 +614,6 @@ protected: private: _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__node_allocator& __x, __node_allocator& __y) - _NOEXCEPT_(!__node_alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value) - {__swap_alloc(__x, __y, integral_constant<bool, - __node_alloc_traits::propagate_on_container_swap::value>());} - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, true_type) - _NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value) - { - using _VSTD::swap; - swap(__x, __y); - } - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, false_type) - _NOEXCEPT - {} - - _LIBCPP_INLINE_VISIBILITY void __copy_assign_alloc(const __list_imp& __c, true_type) { if (__node_alloc() != __c.__node_alloc()) @@ -740,15 +713,19 @@ __list_imp<_Tp, _Alloc>::clear() _NOEXCEPT template <class _Tp, class _Alloc> void __list_imp<_Tp, _Alloc>::swap(__list_imp& __c) - _NOEXCEPT_(!__node_alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<__node_allocator>::value) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value) +#endif { _LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value || this->__node_alloc() == __c.__node_alloc(), "list::swap: Either propagate_on_container_swap must be true" " or the allocators must compare equal"); using _VSTD::swap; - __swap_alloc(__node_alloc(), __c.__node_alloc()); + __swap_allocator(__node_alloc(), __c.__node_alloc()); swap(__sz(), __c.__sz()); swap(__end_, __c.__end_); if (__sz() == 0) @@ -799,7 +776,7 @@ __list_imp<_Tp, _Alloc>::swap(__list_imp& __c) #endif } -template <class _Tp, class _Alloc = allocator<_Tp> > +template <class _Tp, class _Alloc /*= allocator<_Tp>*/> class _LIBCPP_TYPE_VIS_ONLY list : private __list_imp<_Tp, _Alloc> { @@ -984,8 +961,12 @@ public: _LIBCPP_INLINE_VISIBILITY void swap(list& __c) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else _NOEXCEPT_(!__node_alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<__node_allocator>::value) +#endif {base::swap(__c);} _LIBCPP_INLINE_VISIBILITY void clear() _NOEXCEPT {base::clear();} @@ -1480,7 +1461,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l, try { #endif // _LIBCPP_NO_EXCEPTIONS - for (++__f; __f != __l; ++__f, ++__e, ++__ds) + for (++__f; __f != __l; ++__f, (void) ++__e, (void) ++__ds) { __hold.reset(__node_alloc_traits::allocate(__na, 1)); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f); diff --git a/contrib/libc++/include/locale b/contrib/libc++/include/locale index 0d0100204204..e683ba33ae9d 100644 --- a/contrib/libc++/include/locale +++ b/contrib/libc++/include/locale @@ -198,7 +198,8 @@ template <class charT> class messages_byname; // include of <sys/cdefs.h> once https://sourceware.org/ml/newlib-cvs/2014-q3/msg00038.html // has had a chance to bake for a bit #include <support/newlib/xlocale.h> -#elif !defined(__ANDROID__) +#endif +#ifdef _LIBCPP_HAS_CATOPEN #include <nl_types.h> #endif @@ -216,7 +217,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD #if defined(__APPLE__) || defined(__FreeBSD__) # define _LIBCPP_GET_C_LOCALE 0 -#elif defined(__NetBSD__) +#elif defined(__CloudABI__) || defined(__NetBSD__) # define _LIBCPP_GET_C_LOCALE LC_C_LOCALE #else # define _LIBCPP_GET_C_LOCALE __cloc() @@ -235,7 +236,7 @@ typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii; // locale. Linux, not so much. The following functions avoid the locale when // that's possible and otherwise do the wrong thing. FIXME. #if defined(__linux__) || defined(__EMSCRIPTEN__) || defined(_AIX) || \ - defined(_NEWLIB_VERSION) + defined(_NEWLIB_VERSION) || defined(__GLIBC__) #ifdef _LIBCPP_LOCALE__L_EXTENSIONS decltype(MB_CUR_MAX_L(_VSTD::declval<locale_t>())) @@ -1190,7 +1191,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, #ifdef _LIBCPP_LOCALE__L_EXTENSIONS if (sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1) #else - if (__sscanf_l(__buf.c_str(), __cloc(), "%p", &__v) != 1) + if (__sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1) #endif __err = ios_base::failbit; // EOF checked @@ -1560,7 +1561,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, #ifdef _LIBCPP_LOCALE__L_EXTENSIONS int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); #else - int __nc = __snprintf_l(__nar, sizeof(__nar), __cloc(), __fmt, __v); + int __nc = __snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); #endif char* __ne = __nar + __nc; char* __np = this->__identify_padding(__nar, __ne, __iob); @@ -1585,12 +1586,12 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, this->__format_int(__fmt+1, __len, true, __iob.flags()); const unsigned __nbuf = (numeric_limits<long long>::digits / 3) + ((numeric_limits<long long>::digits % 3) != 0) - + 1; + + 2; char __nar[__nbuf]; #ifdef _LIBCPP_LOCALE__L_EXTENSIONS int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); #else - int __nc = __snprintf_l(__nar, sizeof(__nar), __cloc(), __fmt, __v); + int __nc = __snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); #endif char* __ne = __nar + __nc; char* __np = this->__identify_padding(__nar, __ne, __iob); @@ -1620,7 +1621,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, #ifdef _LIBCPP_LOCALE__L_EXTENSIONS int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); #else - int __nc = __snprintf_l(__nar, sizeof(__nar), __cloc(), __fmt, __v); + int __nc = __snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); #endif char* __ne = __nar + __nc; char* __np = this->__identify_padding(__nar, __ne, __iob); @@ -1650,7 +1651,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, #ifdef _LIBCPP_LOCALE__L_EXTENSIONS int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); #else - int __nc = __snprintf_l(__nar, sizeof(__nar), __cloc(), __fmt, __v); + int __nc = __snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); #endif char* __ne = __nar + __nc; char* __np = this->__identify_padding(__nar, __ne, __iob); @@ -1682,14 +1683,14 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v); #else - __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, - (int)__iob.precision(), __v); + __nc = __snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, + (int)__iob.precision(), __v); #endif else #ifdef _LIBCPP_LOCALE__L_EXTENSIONS __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v); #else - __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, __v); + __nc = __snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v); #endif unique_ptr<char, void(*)(void*)> __nbh(0, free); if (__nc > static_cast<int>(__nbuf-1)) @@ -1698,14 +1699,13 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, #ifdef _LIBCPP_LOCALE__L_EXTENSIONS __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v); #else - __nc = __asprintf_l(&__nb, __cloc(), __fmt, - (int)__iob.precision(), __v); + __nc = __asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v); #endif else #ifdef _LIBCPP_LOCALE__L_EXTENSIONS __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v); #else - __nc = __asprintf_l(&__nb, __cloc(), __fmt, (int)__iob.precision(), __v); + __nc = __asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v); #endif if (__nb == 0) __throw_bad_alloc(); @@ -1751,14 +1751,14 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v); #else - __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, - (int)__iob.precision(), __v); + __nc = __snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, + (int)__iob.precision(), __v); #endif else #ifdef _LIBCPP_LOCALE__L_EXTENSIONS __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v); #else - __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, __v); + __nc = __snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v); #endif unique_ptr<char, void(*)(void*)> __nbh(0, free); if (__nc > static_cast<int>(__nbuf-1)) @@ -1767,14 +1767,13 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, #ifdef _LIBCPP_LOCALE__L_EXTENSIONS __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v); #else - __nc = __asprintf_l(&__nb, __cloc(), __fmt, - (int)__iob.precision(), __v); + __nc = __asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v); #endif else #ifdef _LIBCPP_LOCALE__L_EXTENSIONS __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v); #else - __nc = __asprintf_l(&__nb, __cloc(), __fmt, __v); + __nc = __asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v); #endif if (__nb == 0) __throw_bad_alloc(); @@ -1814,7 +1813,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, #ifdef _LIBCPP_LOCALE__L_EXTENSIONS int __nc = snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); #else - int __nc = __snprintf_l(__nar, sizeof(__nar), __cloc(), __fmt, __v); + int __nc = __snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v); #endif char* __ne = __nar + __nc; char* __np = this->__identify_padding(__nar, __ne, __iob); @@ -3527,7 +3526,7 @@ money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl, #ifdef _LIBCPP_LOCALE__L_EXTENSIONS __n = static_cast<size_t>(asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units)); #else - __n = __asprintf_l(&__bb, __cloc(), "%.0Lf", __units); + __n = __asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units); #endif if (__bb == 0) __throw_bad_alloc(); @@ -3681,14 +3680,14 @@ template <class _CharT> typename messages<_CharT>::catalog messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const { -#if defined(_WIN32) || defined(__ANDROID__) || defined(_NEWLIB_VERSION) - return -1; -#else // _WIN32 || __ANDROID__ +#ifdef _LIBCPP_HAS_CATOPEN catalog __cat = (catalog)catopen(__nm.c_str(), NL_CAT_LOCALE); if (__cat != -1) __cat = static_cast<catalog>((static_cast<size_t>(__cat) >> 1)); return __cat; -#endif // _WIN32 || __ANDROID__ +#else // !_LIBCPP_HAS_CATOPEN + return -1; +#endif // _LIBCPP_HAS_CATOPEN } template <class _CharT> @@ -3696,9 +3695,7 @@ typename messages<_CharT>::string_type messages<_CharT>::do_get(catalog __c, int __set, int __msgid, const string_type& __dflt) const { -#if defined(_WIN32) || defined(__ANDROID__) || defined(_NEWLIB_VERSION) - return __dflt; -#else // _WIN32 +#ifdef _LIBCPP_HAS_CATOPEN string __ndflt; __narrow_to_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__ndflt), __dflt.c_str(), @@ -3711,19 +3708,21 @@ messages<_CharT>::do_get(catalog __c, int __set, int __msgid, __widen_from_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__w), __n, __n + strlen(__n)); return __w; -#endif // _WIN32 +#else // !_LIBCPP_HAS_CATOPEN + return __dflt; +#endif // _LIBCPP_HAS_CATOPEN } template <class _CharT> void messages<_CharT>::do_close(catalog __c) const { -#if !defined(_WIN32) && !defined(__ANDROID__) && !defined(_NEWLIB_VERSION) +#ifdef _LIBCPP_HAS_CATOPEN if (__c != -1) __c <<= 1; nl_catd __cat = (nl_catd)__c; catclose(__cat); -#endif // !_WIN32 +#endif // _LIBCPP_HAS_CATOPEN } _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_TYPE_VIS messages<char>) diff --git a/contrib/libc++/include/map b/contrib/libc++/include/map index 5c3969acdd28..eb6b8ed05308 100644 --- a/contrib/libc++/include/map +++ b/contrib/libc++/include/map @@ -135,16 +135,32 @@ public: void insert(InputIterator first, InputIterator last); void insert(initializer_list<value_type> il); + template <class... Args> + pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); // C++17 + template <class... Args> + pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); // C++17 + template <class... Args> + iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17 + template <class... Args> + iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); // C++17 + template <class M> + pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); // C++17 + template <class M> + pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); // C++17 + template <class M> + iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); // C++17 + template <class M> + iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); // C++17 + iterator erase(const_iterator position); + iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; void swap(map& m) - noexcept( - __is_nothrow_swappable<key_compare>::value && - (!allocator_type::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value)); + noexcept(allocator_traits<allocator_type>::is_always_equal::value && + __is_nothrow_swappable<key_compare>::value); // C++17 // observers: allocator_type get_allocator() const noexcept; @@ -330,15 +346,14 @@ public: void insert(initializer_list<value_type> il); iterator erase(const_iterator position); + iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; void swap(multimap& m) - noexcept( - __is_nothrow_swappable<key_compare>::value && - (!allocator_type::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value)); + noexcept(allocator_traits<allocator_type>::is_always_equal::value && + __is_nothrow_swappable<key_compare>::value); // C++17 // observers: allocator_type get_allocator() const noexcept; @@ -426,6 +441,7 @@ swap(multimap<Key, T, Compare, Allocator>& x, #include <utility> #include <functional> #include <initializer_list> +#include <type_traits> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header @@ -433,10 +449,8 @@ swap(multimap<Key, T, Compare, Allocator>& x, _LIBCPP_BEGIN_NAMESPACE_STD -template <class _Key, class _CP, class _Compare, bool = is_empty<_Compare>::value -#if __has_feature(is_final) - && !__is_final(_Compare) -#endif +template <class _Key, class _CP, class _Compare, + bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value > class __map_value_compare : private _Compare @@ -461,6 +475,12 @@ public: _LIBCPP_INLINE_VISIBILITY bool operator()(const _Key& __x, const _CP& __y) const {return static_cast<const _Compare&>(*this)(__x, __y.__cc.first);} + void swap(__map_value_compare&__y) + _NOEXCEPT_(__is_nothrow_swappable<_Compare>::value) + { + using _VSTD::swap; + swap(static_cast<const _Compare&>(*this), static_cast<const _Compare&>(__y)); + } #if _LIBCPP_STD_VER > 11 template <typename _K2> @@ -503,7 +523,13 @@ public: _LIBCPP_INLINE_VISIBILITY bool operator()(const _Key& __x, const _CP& __y) const {return comp(__x, __y.__cc.first);} - + void swap(__map_value_compare&__y) + _NOEXCEPT_(__is_nothrow_swappable<_Compare>::value) + { + using _VSTD::swap; + swap(comp, __y.comp); + } + #if _LIBCPP_STD_VER > 11 template <typename _K2> _LIBCPP_INLINE_VISIBILITY @@ -519,6 +545,16 @@ public: #endif }; +template <class _Key, class _CP, class _Compare, bool __b> +inline _LIBCPP_INLINE_VISIBILITY +void +swap(__map_value_compare<_Key, _CP, _Compare, __b>& __x, + __map_value_compare<_Key, _CP, _Compare, __b>& __y) + _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) +{ + __x.swap(__y); +} + template <class _Allocator> class __map_node_destructor { @@ -644,14 +680,25 @@ struct __value_type #endif +template <class _Tp> +struct __extract_key_value_types; + +template <class _Key, class _Tp> +struct __extract_key_value_types<__value_type<_Key, _Tp> > +{ + typedef _Key const __key_type; + typedef _Tp __mapped_type; +}; + template <class _TreeIterator> class _LIBCPP_TYPE_VIS_ONLY __map_iterator { _TreeIterator __i_; typedef typename _TreeIterator::__pointer_traits __pointer_traits; - typedef const typename _TreeIterator::value_type::value_type::first_type __key_type; - typedef typename _TreeIterator::value_type::value_type::second_type __mapped_type; + typedef typename _TreeIterator::value_type __value_type; + typedef typename __extract_key_value_types<__value_type>::__key_type __key_type; + typedef typename __extract_key_value_types<__value_type>::__mapped_type __mapped_type; public: typedef bidirectional_iterator_tag iterator_category; typedef pair<__key_type, __mapped_type> value_type; @@ -715,8 +762,9 @@ class _LIBCPP_TYPE_VIS_ONLY __map_const_iterator _TreeIterator __i_; typedef typename _TreeIterator::__pointer_traits __pointer_traits; - typedef const typename _TreeIterator::value_type::value_type::first_type __key_type; - typedef typename _TreeIterator::value_type::value_type::second_type __mapped_type; + typedef typename _TreeIterator::value_type __value_type; + typedef typename __extract_key_value_types<__value_type>::__key_type __key_type; + typedef typename __extract_key_value_types<__value_type>::__mapped_type __mapped_type; public: typedef bidirectional_iterator_tag iterator_category; typedef pair<__key_type, __mapped_type> value_type; @@ -736,10 +784,9 @@ public: _LIBCPP_INLINE_VISIBILITY __map_const_iterator(_TreeIterator __i) _NOEXCEPT : __i_(__i) {} _LIBCPP_INLINE_VISIBILITY - __map_const_iterator( - __map_iterator<typename _TreeIterator::__non_const_iterator> __i) - _NOEXCEPT - : __i_(__i.__i_) {} + __map_const_iterator(__map_iterator< + typename _TreeIterator::__non_const_iterator> __i) _NOEXCEPT + : __i_(__i.__i_) {} _LIBCPP_INLINE_VISIBILITY reference operator*() const {return __i_->__cc;} @@ -811,13 +858,8 @@ private: typedef _VSTD::__value_type<key_type, mapped_type> __value_type; typedef __map_value_compare<key_type, __value_type, key_compare> __vc; - typedef typename allocator_traits<allocator_type>::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__value_type> -#else - rebind_alloc<__value_type>::other -#endif - __allocator_type; + typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, + __value_type>::type __allocator_type; typedef __tree<__value_type, __vc, __allocator_type> __base; typedef typename __base::__node_traits __node_traits; typedef allocator_traits<allocator_type> __alloc_traits; @@ -829,7 +871,7 @@ public: typedef typename __alloc_traits::const_pointer const_pointer; typedef typename __alloc_traits::size_type size_type; typedef typename __alloc_traits::difference_type difference_type; - typedef __map_iterator<typename __base::iterator> iterator; + typedef __map_iterator<typename __base::iterator> iterator; typedef __map_const_iterator<typename __base::const_iterator> const_iterator; typedef _VSTD::reverse_iterator<iterator> reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; @@ -1070,9 +1112,125 @@ public: #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS +#if _LIBCPP_STD_VER > 14 +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +#ifndef _LIBCPP_HAS_NO_VARIADICS + template <class... _Args> + _LIBCPP_INLINE_VISIBILITY + pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args) + { + iterator __p = lower_bound(__k); + if ( __p != end() && !key_comp()(__k, __p->first)) + return _VSTD::make_pair(__p, false); + else + return _VSTD::make_pair( + emplace_hint(__p, + _VSTD::piecewise_construct, _VSTD::forward_as_tuple(__k), + _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)), + true); + } + + template <class... _Args> + _LIBCPP_INLINE_VISIBILITY + pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args) + { + iterator __p = lower_bound(__k); + if ( __p != end() && !key_comp()(__k, __p->first)) + return _VSTD::make_pair(__p, false); + else + return _VSTD::make_pair( + emplace_hint(__p, + _VSTD::piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), + _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)), + true); + } + + template <class... _Args> + _LIBCPP_INLINE_VISIBILITY + iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args) + { + iterator __p = lower_bound(__k); + if ( __p != end() && !key_comp()(__k, __p->first)) + return __p; + else + return emplace_hint(__p, + _VSTD::piecewise_construct, _VSTD::forward_as_tuple(__k), + _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); + } + + template <class... _Args> + _LIBCPP_INLINE_VISIBILITY + iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args) + { + iterator __p = lower_bound(__k); + if ( __p != end() && !key_comp()(__k, __p->first)) + return __p; + else + return emplace_hint(__p, + _VSTD::piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), + _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); + } + + template <class _Vp> + _LIBCPP_INLINE_VISIBILITY + pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v) + { + iterator __p = lower_bound(__k); + if ( __p != end() && !key_comp()(__k, __p->first)) + { + __p->second = _VSTD::forward<_Vp>(__v); + return _VSTD::make_pair(__p, false); + } + return _VSTD::make_pair(emplace_hint(__p, __k, _VSTD::forward<_Vp>(__v)), true); + } + + template <class _Vp> + _LIBCPP_INLINE_VISIBILITY + pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v) + { + iterator __p = lower_bound(__k); + if ( __p != end() && !key_comp()(__k, __p->first)) + { + __p->second = _VSTD::forward<_Vp>(__v); + return _VSTD::make_pair(__p, false); + } + return _VSTD::make_pair(emplace_hint(__p, _VSTD::move(__k), _VSTD::forward<_Vp>(__v)), true); + } + + template <class _Vp> + _LIBCPP_INLINE_VISIBILITY + iterator insert_or_assign(const_iterator __h, const key_type& __k, _Vp&& __v) + { + iterator __p = lower_bound(__k); + if ( __p != end() && !key_comp()(__k, __p->first)) + { + __p->second = _VSTD::forward<_Vp>(__v); + return __p; + } + return emplace_hint(__h, __k, _VSTD::forward<_Vp>(__v)); + } + + template <class _Vp> + _LIBCPP_INLINE_VISIBILITY + iterator insert_or_assign(const_iterator __h, key_type&& __k, _Vp&& __v) + { + iterator __p = lower_bound(__k); + if ( __p != end() && !key_comp()(__k, __p->first)) + { + __p->second = _VSTD::forward<_Vp>(__v); + return __p; + } + return emplace_hint(__h, _VSTD::move(__k), _VSTD::forward<_Vp>(__v)); + } +#endif +#endif +#endif + _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);} _LIBCPP_INLINE_VISIBILITY + iterator erase(iterator __p) {return __tree_.erase(__p.__i_);} + _LIBCPP_INLINE_VISIBILITY size_type erase(const key_type& __k) {return __tree_.__erase_unique(__k);} _LIBCPP_INLINE_VISIBILITY @@ -1108,7 +1266,7 @@ public: template <typename _K2> _LIBCPP_INLINE_VISIBILITY typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type - count(const _K2& __k) {return __tree_.__count_unique(__k);} + count(const _K2& __k) const {return __tree_.__count_unique(__k);} #endif _LIBCPP_INLINE_VISIBILITY iterator lower_bound(const key_type& __k) @@ -1557,13 +1715,8 @@ private: typedef _VSTD::__value_type<key_type, mapped_type> __value_type; typedef __map_value_compare<key_type, __value_type, key_compare> __vc; - typedef typename allocator_traits<allocator_type>::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__value_type> -#else - rebind_alloc<__value_type>::other -#endif - __allocator_type; + typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, + __value_type>::type __allocator_type; typedef __tree<__value_type, __vc, __allocator_type> __base; typedef typename __base::__node_traits __node_traits; typedef allocator_traits<allocator_type> __alloc_traits; @@ -1810,6 +1963,8 @@ public: _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);} _LIBCPP_INLINE_VISIBILITY + iterator erase(iterator __p) {return __tree_.erase(__p.__i_);} + _LIBCPP_INLINE_VISIBILITY size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);} _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __f, const_iterator __l) @@ -1844,7 +1999,7 @@ public: template <typename _K2> _LIBCPP_INLINE_VISIBILITY typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type - count(const _K2& __k) {return __tree_.__count_multi(__k);} + count(const _K2& __k) const {return __tree_.__count_multi(__k);} #endif _LIBCPP_INLINE_VISIBILITY iterator lower_bound(const key_type& __k) diff --git a/contrib/libc++/include/memory b/contrib/libc++/include/memory index 662faa0a74ff..22311aaace92 100644 --- a/contrib/libc++/include/memory +++ b/contrib/libc++/include/memory @@ -75,6 +75,8 @@ struct allocator_traits | false_type propagate_on_container_move_assignment; typedef Alloc::propagate_on_container_swap | false_type propagate_on_container_swap; + typedef Alloc::is_always_equal + | is_empty is_always_equal; template <class T> using rebind_alloc = Alloc::rebind<U>::other | Alloc<T, Args...>; template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>; @@ -615,6 +617,7 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space); #endif #include <__undef_min_max> +#include <__undef___deallocate> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header @@ -622,6 +625,18 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space); _LIBCPP_BEGIN_NAMESPACE_STD +template <class _ValueType> +inline _LIBCPP_ALWAYS_INLINE +_ValueType __libcpp_relaxed_load(_ValueType const* __value) { +#if !defined(_LIBCPP_HAS_NO_THREADS) && \ + defined(__ATOMIC_RELAXED) && \ + (__has_builtin(__atomic_load_n) || _GNUC_VER >= 407) + return __atomic_load_n(__value, __ATOMIC_RELAXED); +#else + return *__value; +#endif +} + // addressof moved to <__functional_base> template <class _Tp> class allocator; @@ -1143,6 +1158,29 @@ struct __propagate_on_container_swap<_Alloc, true> typedef typename _Alloc::propagate_on_container_swap type; }; +template <class _Tp> +struct __has_is_always_equal +{ +private: + struct __two {char __lx; char __lxx;}; + template <class _Up> static __two __test(...); + template <class _Up> static char __test(typename _Up::is_always_equal* = 0); +public: + static const bool value = sizeof(__test<_Tp>(0)) == 1; +}; + +template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value> +struct __is_always_equal +{ + typedef typename _VSTD::is_empty<_Alloc>::type type; +}; + +template <class _Alloc> +struct __is_always_equal<_Alloc, true> +{ + typedef typename _Alloc::is_always_equal type; +}; + template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> struct __has_rebind_other { @@ -1422,6 +1460,8 @@ struct _LIBCPP_TYPE_VIS_ONLY allocator_traits propagate_on_container_move_assignment; typedef typename __propagate_on_container_swap<allocator_type>::type propagate_on_container_swap; + typedef typename __is_always_equal<allocator_type>::type + is_always_equal; #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES template <class _Tp> using rebind_alloc = @@ -1520,8 +1560,42 @@ struct _LIBCPP_TYPE_VIS_ONLY allocator_traits __construct_forward(allocator_type& __a, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2) { ptrdiff_t _Np = __end1 - __begin1; - _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp)); - __begin2 += _Np; + if (_Np > 0) + { + _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp)); + __begin2 += _Np; + } + } + + template <class _Iter, class _Ptr> + _LIBCPP_INLINE_VISIBILITY + static + void + __construct_range_forward(allocator_type& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2) + { + for (; __begin1 != __end1; ++__begin1, (void) ++__begin2) + construct(__a, _VSTD::__to_raw_pointer(__begin2), *__begin1); + } + + template <class _Tp> + _LIBCPP_INLINE_VISIBILITY + static + typename enable_if + < + (is_same<allocator_type, allocator<_Tp> >::value + || !__has_construct<allocator_type, _Tp*, _Tp>::value) && + is_trivially_move_constructible<_Tp>::value, + void + >::type + __construct_range_forward(allocator_type& __a, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2) + { + typedef typename remove_const<_Tp>::type _Vp; + ptrdiff_t _Np = __end1 - __begin1; + if (_Np > 0) + { + _VSTD::memcpy(const_cast<_Vp*>(__begin2), __begin1, _Np * sizeof(_Tp)); + __begin2 += _Np; + } } template <class _Ptr> @@ -1551,7 +1625,8 @@ struct _LIBCPP_TYPE_VIS_ONLY allocator_traits { ptrdiff_t _Np = __end1 - __begin1; __end2 -= _Np; - _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp)); + if (_Np > 0) + _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp)); } private: @@ -1606,6 +1681,16 @@ private: {return __a;} }; +template <class _Traits, class _Tp> +struct __rebind_alloc_helper +{ +#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES + typedef typename _Traits::template rebind_alloc<_Tp> type; +#else + typedef typename _Traits::template rebind_alloc<_Tp>::other type; +#endif +}; + // allocator template <class _Tp> @@ -1621,6 +1706,7 @@ public: typedef _Tp value_type; typedef true_type propagate_on_container_move_assignment; + typedef true_type is_always_equal; template <class _Up> struct rebind {typedef allocator<_Up> other;}; @@ -1713,6 +1799,7 @@ public: typedef const _Tp value_type; typedef true_type propagate_on_container_move_assignment; + typedef true_type is_always_equal; template <class _Up> struct rebind {typedef allocator<_Up> other;}; @@ -1816,6 +1903,9 @@ public: _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;} _LIBCPP_INLINE_VISIBILITY raw_storage_iterator operator++(int) {raw_storage_iterator __t(*this); ++__x_; return __t;} +#if _LIBCPP_STD_VER >= 14 + _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; } +#endif }; template <class _Tp> @@ -1905,14 +1995,9 @@ public: template <class _T1, class _T2, bool = is_same<typename remove_cv<_T1>::type, typename remove_cv<_T2>::type>::value, bool = is_empty<_T1>::value -#if __has_feature(is_final) - && !__is_final(_T1) -#endif - , + && !__libcpp_is_final<_T1>::value, bool = is_empty<_T2>::value -#if __has_feature(is_final) - && !__is_final(_T2) -#endif + && !__libcpp_is_final<_T2>::value > struct __libcpp_compressed_pair_switch; @@ -1950,11 +2035,11 @@ public: typedef const typename remove_reference<_T1>::type& _T1_const_reference; typedef const typename remove_reference<_T2>::type& _T2_const_reference; - _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} + _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() : __first_(), __second_() {} _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) - : __first_(_VSTD::forward<_T1_param>(__t1)) {} + : __first_(_VSTD::forward<_T1_param>(__t1)), __second_() {} _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) - : __second_(_VSTD::forward<_T2_param>(__t2)) {} + : __first_(), __second_(_VSTD::forward<_T2_param>(__t2)) {} _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) : __first_(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {} @@ -2043,9 +2128,9 @@ public: typedef const _T1& _T1_const_reference; typedef const typename remove_reference<_T2>::type& _T2_const_reference; - _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} + _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() : __second_() {} _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) - : _T1(_VSTD::forward<_T1_param>(__t1)) {} + : _T1(_VSTD::forward<_T1_param>(__t1)), __second_() {} _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) : __second_(_VSTD::forward<_T2_param>(__t2)) {} _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) @@ -2133,11 +2218,11 @@ public: typedef const typename remove_reference<_T1>::type& _T1_const_reference; typedef const _T2& _T2_const_reference; - _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} + _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() : __first_() {} _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) : __first_(_VSTD::forward<_T1_param>(__t1)) {} _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) - : _T2(_VSTD::forward<_T2_param>(__t2)) {} + : _T2(_VSTD::forward<_T2_param>(__t2)), __first_() {} _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value && is_nothrow_move_constructible<_T2>::value) @@ -2890,8 +2975,8 @@ operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) { typedef typename unique_ptr<_T1, _D1>::pointer _P1; typedef typename unique_ptr<_T2, _D2>::pointer _P2; - typedef typename common_type<_P1, _P2>::type _V; - return less<_V>()(__x.get(), __y.get()); + typedef typename common_type<_P1, _P2>::type _Vp; + return less<_Vp>()(__x.get(), __y.get()); } template <class _T1, class _D1, class _T2, class _D2> @@ -3485,8 +3570,8 @@ uninitialized_copy(_InputIterator __f, _InputIterator __l, _ForwardIterator __r) try { #endif - for (; __f != __l; ++__f, ++__r) - ::new(&*__r) value_type(*__f); + for (; __f != __l; ++__f, (void) ++__r) + ::new (static_cast<void*>(_VSTD::addressof(*__r))) value_type(*__f); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -3509,8 +3594,8 @@ uninitialized_copy_n(_InputIterator __f, _Size __n, _ForwardIterator __r) try { #endif - for (; __n > 0; ++__f, ++__r, --__n) - ::new(&*__r) value_type(*__f); + for (; __n > 0; ++__f, (void) ++__r, (void) --__n) + ::new (static_cast<void*>(_VSTD::addressof(*__r))) value_type(*__f); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -3534,7 +3619,7 @@ uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x) { #endif for (; __f != __l; ++__f) - ::new(&*__f) value_type(__x); + ::new (static_cast<void*>(_VSTD::addressof(*__f))) value_type(__x); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -3556,8 +3641,8 @@ uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x) try { #endif - for (; __n > 0; ++__f, --__n) - ::new(&*__f) value_type(__x); + for (; __n > 0; ++__f, (void) --__n) + ::new (static_cast<void*>(_VSTD::addressof(*__f))) value_type(__x); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -3599,7 +3684,9 @@ public: void __add_shared() _NOEXCEPT; bool __release_shared() _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY - long use_count() const _NOEXCEPT {return __shared_owners_ + 1;} + long use_count() const _NOEXCEPT { + return __libcpp_relaxed_load(&__shared_owners_) + 1; + } }; class _LIBCPP_TYPE_VIS __shared_weak_count @@ -3677,11 +3764,11 @@ template <class _Tp, class _Dp, class _Alloc> void __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT { - typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _A; - typedef allocator_traits<_A> _ATraits; + typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al; + typedef allocator_traits<_Al> _ATraits; typedef pointer_traits<typename _ATraits::pointer> _PTraits; - _A __a(__data_.second()); + _Al __a(__data_.second()); __data_.second().~_Alloc(); __a.deallocate(_PTraits::pointer_to(*this), 1); } @@ -3746,10 +3833,10 @@ template <class _Tp, class _Alloc> void __shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT { - typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type _A; - typedef allocator_traits<_A> _ATraits; + typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type _Al; + typedef allocator_traits<_Al> _ATraits; typedef pointer_traits<typename _ATraits::pointer> _PTraits; - _A __a(__data_.first()); + _Al __a(__data_.first()); __data_.first().~_Alloc(); __a.deallocate(_PTraits::pointer_to(*this), 1); } @@ -4001,11 +4088,15 @@ private: __enable_weak_this(const enable_shared_from_this<_Yp>* __e) _NOEXCEPT { if (__e) - __e->__weak_this_ = *this; + { + __e->__weak_this_.__ptr_ = const_cast<_Yp*>(static_cast<const _Yp*>(__e)); + __e->__weak_this_.__cntrl_ = __cntrl_; + __cntrl_->__add_weak(); + } } _LIBCPP_INLINE_VISIBILITY - void __enable_weak_this(const void*) _NOEXCEPT {} + void __enable_weak_this(const volatile void*) _NOEXCEPT {} template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY shared_ptr; template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY weak_ptr; @@ -4235,9 +4326,16 @@ shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r, >::type) : __ptr_(__r.get()) { - typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk; - __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), allocator<_Yp>()); - __enable_weak_this(__r.get()); +#if _LIBCPP_STD_VER > 11 + if (__ptr_ == nullptr) + __cntrl_ = nullptr; + else +#endif + { + typedef __shared_ptr_pointer<_Yp*, _Dp, allocator<_Yp> > _CntrlBlk; + __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), allocator<_Yp>()); + __enable_weak_this(__r.get()); + } __r.release(); } @@ -4257,11 +4355,18 @@ shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r, >::type) : __ptr_(__r.get()) { - typedef __shared_ptr_pointer<_Yp*, - reference_wrapper<typename remove_reference<_Dp>::type>, - allocator<_Yp> > _CntrlBlk; - __cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), allocator<_Yp>()); - __enable_weak_this(__r.get()); +#if _LIBCPP_STD_VER > 11 + if (__ptr_ == nullptr) + __cntrl_ = nullptr; + else +#endif + { + typedef __shared_ptr_pointer<_Yp*, + reference_wrapper<typename remove_reference<_Dp>::type>, + allocator<_Yp> > _CntrlBlk; + __cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), allocator<_Yp>()); + __enable_weak_this(__r.get()); + } __r.release(); } @@ -4745,8 +4850,8 @@ inline _LIBCPP_INLINE_VISIBILITY bool operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT { - typedef typename common_type<_Tp*, _Up*>::type _V; - return less<_V>()(__x.get(), __y.get()); + typedef typename common_type<_Tp*, _Up*>::type _Vp; + return less<_Vp>()(__x.get(), __y.get()); } template<class _Tp, class _Up> @@ -5438,6 +5543,38 @@ undeclare_reachable(_Tp* __p) _LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space); +// --- Helper for container swap -- +template <typename _Alloc> +_LIBCPP_INLINE_VISIBILITY +void __swap_allocator(_Alloc & __a1, _Alloc & __a2) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else + _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) +#endif +{ + __swap_allocator(__a1, __a2, + integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>()); +} + +template <typename _Alloc> +_LIBCPP_INLINE_VISIBILITY +void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else + _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) +#endif +{ + using _VSTD::swap; + swap(__a1, __a2); +} + +template <typename _Alloc> +_LIBCPP_INLINE_VISIBILITY +void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {} + + _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_MEMORY diff --git a/contrib/libc++/include/module.modulemap b/contrib/libc++/include/module.modulemap index 6aeb23f028bf..3c0700eca443 100644 --- a/contrib/libc++/include/module.modulemap +++ b/contrib/libc++/include/module.modulemap @@ -469,4 +469,5 @@ module std [system] { module __tree { header "__tree" export * } module __tuple { header "__tuple" export * } module __undef_min_max { header "__undef_min_max" export * } + module __undef___deallocate { header "__undef___deallocate" export * } } diff --git a/contrib/libc++/include/mutex b/contrib/libc++/include/mutex index e2a0daa3eab5..373d75b09789 100644 --- a/contrib/libc++/include/mutex +++ b/contrib/libc++/include/mutex @@ -175,6 +175,7 @@ template<class Callable, class ...Args> #include <__config> #include <__mutex_base> #include <functional> +#include <memory> #ifndef _LIBCPP_HAS_NO_VARIADICS #include <tuple> #endif @@ -442,7 +443,11 @@ void call_once(once_flag&, _Callable&&, _Args&&...); template<class _Callable> _LIBCPP_INLINE_VISIBILITY -void call_once(once_flag&, _Callable); +void call_once(once_flag&, _Callable&); + +template<class _Callable> +_LIBCPP_INLINE_VISIBILITY +void call_once(once_flag&, const _Callable&); #endif // _LIBCPP_HAS_NO_VARIADICS @@ -465,7 +470,11 @@ private: #else // _LIBCPP_HAS_NO_VARIADICS template<class _Callable> friend - void call_once(once_flag&, _Callable); + void call_once(once_flag&, _Callable&); + + template<class _Callable> + friend + void call_once(once_flag&, const _Callable&); #endif // _LIBCPP_HAS_NO_VARIADICS }; @@ -474,15 +483,10 @@ private: template <class _Fp> class __call_once_param { - _Fp __f_; + _Fp& __f_; public: -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY - explicit __call_once_param(_Fp&& __f) : __f_(_VSTD::move(__f)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit __call_once_param(const _Fp& __f) : __f_(__f) {} -#endif + explicit __call_once_param(_Fp& __f) : __f_(__f) {} _LIBCPP_INLINE_VISIBILITY void operator()() @@ -496,7 +500,7 @@ private: _LIBCPP_INLINE_VISIBILITY void __execute(__tuple_indices<_Indices...>) { - __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...); + __invoke(_VSTD::get<0>(_VSTD::move(__f_)), _VSTD::get<_Indices>(_VSTD::move(__f_))...); } }; @@ -505,15 +509,10 @@ private: template <class _Fp> class __call_once_param { - _Fp __f_; + _Fp& __f_; public: -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY - explicit __call_once_param(_Fp&& __f) : __f_(_VSTD::move(__f)) {} -#else - _LIBCPP_INLINE_VISIBILITY - explicit __call_once_param(const _Fp& __f) : __f_(__f) {} -#endif + explicit __call_once_param(_Fp& __f) : __f_(__f) {} _LIBCPP_INLINE_VISIBILITY void operator()() @@ -541,11 +540,11 @@ inline _LIBCPP_INLINE_VISIBILITY void call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args) { - if (__flag.__state_ != ~0ul) + if (__libcpp_relaxed_load(&__flag.__state_) != ~0ul) { - typedef tuple<typename decay<_Callable>::type, typename decay<_Args>::type...> _Gp; - __call_once_param<_Gp> __p(_Gp(__decay_copy(_VSTD::forward<_Callable>(__func)), - __decay_copy(_VSTD::forward<_Args>(__args))...)); + typedef tuple<_Callable&&, _Args&&...> _Gp; + _Gp __f(_VSTD::forward<_Callable>(__func), _VSTD::forward<_Args>(__args)...); + __call_once_param<_Gp> __p(__f); __call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>); } } @@ -555,15 +554,27 @@ call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args) template<class _Callable> inline _LIBCPP_INLINE_VISIBILITY void -call_once(once_flag& __flag, _Callable __func) +call_once(once_flag& __flag, _Callable& __func) { - if (__flag.__state_ != ~0ul) + if (__libcpp_relaxed_load(&__flag.__state_) != ~0ul) { __call_once_param<_Callable> __p(__func); __call_once(__flag.__state_, &__p, &__call_once_proxy<_Callable>); } } +template<class _Callable> +inline _LIBCPP_INLINE_VISIBILITY +void +call_once(once_flag& __flag, const _Callable& __func) +{ + if (__flag.__state_ != ~0ul) + { + __call_once_param<const _Callable> __p(__func); + __call_once(__flag.__state_, &__p, &__call_once_proxy<const _Callable>); + } +} + #endif // _LIBCPP_HAS_NO_VARIADICS _LIBCPP_END_NAMESPACE_STD diff --git a/contrib/libc++/include/new b/contrib/libc++/include/new index a710ed93fb43..d2b2ae648b48 100644 --- a/contrib/libc++/include/new +++ b/contrib/libc++/include/new @@ -50,11 +50,13 @@ new_handler get_new_handler() noexcept; void* operator new(std::size_t size); // replaceable void* operator new(std::size_t size, const std::nothrow_t&) noexcept; // replaceable void operator delete(void* ptr) noexcept; // replaceable +void operator delete(void* ptr, std::size_t size) noexcept; // replaceable, C++14 void operator delete(void* ptr, const std::nothrow_t&) noexcept; // replaceable void* operator new[](std::size_t size); // replaceable void* operator new[](std::size_t size, const std::nothrow_t&) noexcept; // replaceable void operator delete[](void* ptr) noexcept; // replaceable +void operator delete[](void* ptr, std::size_t size) noexcept; // replaceable, C++14 void operator delete[](void* ptr, const std::nothrow_t&) noexcept; // replaceable void* operator new (std::size_t size, void* ptr) noexcept; @@ -68,6 +70,8 @@ void operator delete[](void* ptr, void*) noexcept; #include <exception> #include <cstddef> +#include <__undef___deallocate> + #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif @@ -132,6 +136,10 @@ _LIBCPP_NEW_DELETE_VIS void* operator new(std::size_t __sz) _LIBCPP_NEW_DELETE_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS; _LIBCPP_NEW_DELETE_VIS void operator delete(void* __p) _NOEXCEPT; _LIBCPP_NEW_DELETE_VIS void operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT; +#if defined(_LIBCPP_BUILDING_NEW) || _LIBCPP_STD_VER >= 14 || \ + (defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 201309) +_LIBCPP_NEW_DELETE_VIS void operator delete(void* __p, std::size_t __sz) _NOEXCEPT; +#endif _LIBCPP_NEW_DELETE_VIS void* operator new[](std::size_t __sz) #if !__has_feature(cxx_noexcept) @@ -141,6 +149,10 @@ _LIBCPP_NEW_DELETE_VIS void* operator new[](std::size_t __sz) _LIBCPP_NEW_DELETE_VIS void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS; _LIBCPP_NEW_DELETE_VIS void operator delete[](void* __p) _NOEXCEPT; _LIBCPP_NEW_DELETE_VIS void operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT; +#if defined(_LIBCPP_BUILDING_NEW) || _LIBCPP_STD_VER >= 14 || \ + (defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 201309) +_LIBCPP_NEW_DELETE_VIS void operator delete[](void* __p, std::size_t __sz) _NOEXCEPT; +#endif inline _LIBCPP_INLINE_VISIBILITY void* operator new (std::size_t, void* __p) _NOEXCEPT {return __p;} inline _LIBCPP_INLINE_VISIBILITY void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;} diff --git a/contrib/libc++/include/ostream b/contrib/libc++/include/ostream index a7af2994b6b9..f55fd40856ec 100644 --- a/contrib/libc++/include/ostream +++ b/contrib/libc++/include/ostream @@ -1004,7 +1004,7 @@ basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(pos_type __pos) { sentry __s(*this); - if (__s) + if (!this->fail()) { if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1)) this->setstate(ios_base::failbit); @@ -1018,7 +1018,7 @@ basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir) { sentry __s(*this); - if (__s) + if (!this->fail()) { if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1)) this->setstate(ios_base::failbit); diff --git a/contrib/libc++/include/queue b/contrib/libc++/include/queue index bdfd70603553..6f49c87acdc5 100644 --- a/contrib/libc++/include/queue +++ b/contrib/libc++/include/queue @@ -177,7 +177,7 @@ template <class T, class Container, class Compare> _LIBCPP_BEGIN_NAMESPACE_STD -template <class _Tp, class _Container> class _LIBCPP_TYPE_VIS_ONLY queue; +template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TYPE_VIS_ONLY queue; template <class _Tp, class _Container> _LIBCPP_INLINE_VISIBILITY @@ -189,7 +189,7 @@ _LIBCPP_INLINE_VISIBILITY bool operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y); -template <class _Tp, class _Container = deque<_Tp> > +template <class _Tp, class _Container /*= deque<_Tp>*/> class _LIBCPP_TYPE_VIS_ONLY queue { public: diff --git a/contrib/libc++/include/random b/contrib/libc++/include/random index a8d21a224dfa..64382a3d9aa6 100644 --- a/contrib/libc++/include/random +++ b/contrib/libc++/include/random @@ -1634,9 +1634,10 @@ class piecewise_linear_distribution #include <__config> #include <cstddef> +#include <cstdint> +#include <cmath> #include <type_traits> #include <initializer_list> -#include <cstdint> #include <limits> #include <algorithm> #include <numeric> @@ -1644,7 +1645,6 @@ class piecewise_linear_distribution #include <string> #include <istream> #include <ostream> -#include <cmath> #include <__undef_min_max> @@ -3475,9 +3475,9 @@ typedef shuffle_order_engine<minstd_rand0, 256> knuth_b; class _LIBCPP_TYPE_VIS random_device { -#if !(defined(_WIN32) || defined(_LIBCPP_USING_NACL_RANDOM)) +#ifdef _LIBCPP_USING_DEV_RANDOM int __f_; -#endif // !(defined(_WIN32) || defined(_LIBCPP_USING_NACL_RANDOM)) +#endif // defined(_LIBCPP_USING_DEV_RANDOM) public: // types typedef unsigned result_type; diff --git a/contrib/libc++/include/ratio b/contrib/libc++/include/ratio index 48dcd81c1a72..f623a062f2ce 100644 --- a/contrib/libc++/include/ratio +++ b/contrib/libc++/include/ratio @@ -21,8 +21,8 @@ template <intmax_t N, intmax_t D = 1> class ratio { public: - static const intmax_t num; - static const intmax_t den; + static constexpr intmax_t num; + static constexpr intmax_t den; typedef ratio<num, den> type; }; @@ -236,19 +236,22 @@ class _LIBCPP_TYPE_VIS_ONLY ratio static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range"); static_assert(_Den != 0, "ratio divide by 0"); static_assert(__static_abs<_Den>::value > 0, "ratio denominator is out of range"); - static const intmax_t __na = __static_abs<_Num>::value; - static const intmax_t __da = __static_abs<_Den>::value; - static const intmax_t __s = __static_sign<_Num>::value * __static_sign<_Den>::value; - static const intmax_t __gcd = __static_gcd<__na, __da>::value; + static _LIBCPP_CONSTEXPR const intmax_t __na = __static_abs<_Num>::value; + static _LIBCPP_CONSTEXPR const intmax_t __da = __static_abs<_Den>::value; + static _LIBCPP_CONSTEXPR const intmax_t __s = __static_sign<_Num>::value * __static_sign<_Den>::value; + static _LIBCPP_CONSTEXPR const intmax_t __gcd = __static_gcd<__na, __da>::value; public: - static const intmax_t num = __s * __na / __gcd; - static const intmax_t den = __da / __gcd; + static _LIBCPP_CONSTEXPR const intmax_t num = __s * __na / __gcd; + static _LIBCPP_CONSTEXPR const intmax_t den = __da / __gcd; typedef ratio<num, den> type; }; -template <intmax_t _Num, intmax_t _Den> const intmax_t ratio<_Num, _Den>::num; -template <intmax_t _Num, intmax_t _Den> const intmax_t ratio<_Num, _Den>::den; +template <intmax_t _Num, intmax_t _Den> +_LIBCPP_CONSTEXPR const intmax_t ratio<_Num, _Den>::num; + +template <intmax_t _Num, intmax_t _Den> +_LIBCPP_CONSTEXPR const intmax_t ratio<_Num, _Den>::den; template <class _Tp> struct __is_ratio : false_type {}; template <intmax_t _Num, intmax_t _Den> struct __is_ratio<ratio<_Num, _Den> > : true_type {}; @@ -398,11 +401,11 @@ struct _LIBCPP_TYPE_VIS_ONLY ratio_subtract template <class _R1, class _R2> struct _LIBCPP_TYPE_VIS_ONLY ratio_equal - : public integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> {}; + : public _LIBCPP_BOOL_CONSTANT((_R1::num == _R2::num && _R1::den == _R2::den)) {}; template <class _R1, class _R2> struct _LIBCPP_TYPE_VIS_ONLY ratio_not_equal - : public integral_constant<bool, !ratio_equal<_R1, _R2>::value> {}; + : public _LIBCPP_BOOL_CONSTANT((!ratio_equal<_R1, _R2>::value)) {}; // ratio_less @@ -461,19 +464,19 @@ struct __ratio_less<_R1, _R2, -1LL, -1LL> template <class _R1, class _R2> struct _LIBCPP_TYPE_VIS_ONLY ratio_less - : public integral_constant<bool, __ratio_less<_R1, _R2>::value> {}; + : public _LIBCPP_BOOL_CONSTANT((__ratio_less<_R1, _R2>::value)) {}; template <class _R1, class _R2> struct _LIBCPP_TYPE_VIS_ONLY ratio_less_equal - : public integral_constant<bool, !ratio_less<_R2, _R1>::value> {}; + : public _LIBCPP_BOOL_CONSTANT((!ratio_less<_R2, _R1>::value)) {}; template <class _R1, class _R2> struct _LIBCPP_TYPE_VIS_ONLY ratio_greater - : public integral_constant<bool, ratio_less<_R2, _R1>::value> {}; + : public _LIBCPP_BOOL_CONSTANT((ratio_less<_R2, _R1>::value)) {}; template <class _R1, class _R2> struct _LIBCPP_TYPE_VIS_ONLY ratio_greater_equal - : public integral_constant<bool, !ratio_less<_R1, _R2>::value> {}; + : public _LIBCPP_BOOL_CONSTANT((!ratio_less<_R1, _R2>::value)) {}; template <class _R1, class _R2> struct __ratio_gcd diff --git a/contrib/libc++/include/regex b/contrib/libc++/include/regex index 690213a978d8..bd48fb8da04b 100644 --- a/contrib/libc++/include/regex +++ b/contrib/libc++/include/regex @@ -1947,7 +1947,8 @@ template <class _CharT> void __l_anchor<_CharT>::__exec(__state& __s) const { - if (__s.__at_first_ && __s.__current_ == __s.__first_) + if (__s.__at_first_ && __s.__current_ == __s.__first_ && + !(__s.__flags_ & regex_constants::match_not_bol)) { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); @@ -1981,7 +1982,8 @@ template <class _CharT> void __r_anchor<_CharT>::__exec(__state& __s) const { - if (__s.__current_ == __s.__last_) + if (__s.__current_ == __s.__last_ && + !(__s.__flags_ & regex_constants::match_not_eol)) { __s.__do_ = __state::__accept_but_not_consume; __s.__node_ = this->first(); @@ -2599,9 +2601,7 @@ public: assign(_ForwardIterator __first, _ForwardIterator __last, flag_type __f = regex_constants::ECMAScript) { - __member_init(__f); - __parse(__first, __last); - return *this; + return assign(basic_regex(__first, __last, __f)); } #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS @@ -5603,12 +5603,17 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma( __node* __st = __start_.get(); if (__st) { + sub_match<const _CharT*> __unmatched; + __unmatched.first = __last; + __unmatched.second = __last; + __unmatched.matched = false; + __states.push_back(__state()); __states.back().__do_ = 0; __states.back().__first_ = __first; __states.back().__current_ = __first; __states.back().__last_ = __last; - __states.back().__sub_matches_.resize(mark_count()); + __states.back().__sub_matches_.resize(mark_count(), __unmatched); __states.back().__loop_data_.resize(__loop_count()); __states.back().__node_ = __st; __states.back().__flags_ = __flags; @@ -5748,12 +5753,17 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs( __node* __st = __start_.get(); if (__st) { + sub_match<const _CharT*> __unmatched; + __unmatched.first = __last; + __unmatched.second = __last; + __unmatched.matched = false; + __states.push_back(__state()); __states.back().__do_ = 0; __states.back().__first_ = __first; __states.back().__current_ = __first; __states.back().__last_ = __last; - __states.back().__sub_matches_.resize(mark_count()); + __states.back().__sub_matches_.resize(mark_count(), __unmatched); __states.back().__loop_data_.resize(__loop_count()); __states.back().__node_ = __st; __states.back().__flags_ = __flags; diff --git a/contrib/libc++/include/scoped_allocator b/contrib/libc++/include/scoped_allocator index aa8bece6d331..cd4987ad9bb6 100644 --- a/contrib/libc++/include/scoped_allocator +++ b/contrib/libc++/include/scoped_allocator @@ -38,6 +38,7 @@ public: typedef see below propagate_on_container_copy_assignment; typedef see below propagate_on_container_move_assignment; typedef see below propagate_on_container_swap; + typedef see below is_always_equal; template <class Tp> struct rebind @@ -170,6 +171,22 @@ struct __get_poc_swap<_A0, _Allocs...> __get_poc_swap<_Allocs...>::value; }; +template <class ..._Allocs> struct __get_is_always_equal; + +template <class _A0> +struct __get_is_always_equal<_A0> +{ + static const bool value = allocator_traits<_A0>::is_always_equal::value; +}; + +template <class _A0, class ..._Allocs> +struct __get_is_always_equal<_A0, _Allocs...> +{ + static const bool value = + allocator_traits<_A0>::is_always_equal::value && + __get_is_always_equal<_Allocs...>::value; +}; + template <class ..._Allocs> class __scoped_allocator_storage; @@ -397,6 +414,11 @@ public: bool, __get_poc_swap<outer_allocator_type, _InnerAllocs...>::value > propagate_on_container_swap; + typedef integral_constant + < + bool, + __get_is_always_equal<outer_allocator_type, _InnerAllocs...>::value + > is_always_equal; template <class _Tp> struct rebind diff --git a/contrib/libc++/include/set b/contrib/libc++/include/set index 22d794da547a..9d64a521da11 100644 --- a/contrib/libc++/include/set +++ b/contrib/libc++/include/set @@ -116,6 +116,7 @@ public: void insert(initializer_list<value_type> il); iterator erase(const_iterator position); + iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; @@ -297,6 +298,7 @@ public: void insert(initializer_list<value_type> il); iterator erase(const_iterator position); + iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; diff --git a/contrib/libc++/include/shared_mutex b/contrib/libc++/include/shared_mutex index 9b7f0bf77354..dcb93949e30d 100644 --- a/contrib/libc++/include/shared_mutex +++ b/contrib/libc++/include/shared_mutex @@ -19,6 +19,29 @@ namespace std { +class shared_mutex // C++17 +{ +public: + shared_mutex(); + ~shared_mutex(); + + shared_mutex(const shared_mutex&) = delete; + shared_mutex& operator=(const shared_mutex&) = delete; + + // Exclusive ownership + void lock(); // blocking + bool try_lock(); + void unlock(); + + // Shared ownership + void lock_shared(); // blocking + bool try_lock_shared(); + void unlock_shared(); + + typedef implementation-defined native_handle_type; // See 30.2.3 + native_handle_type native_handle(); // See 30.2.3 +}; + class shared_timed_mutex { public: @@ -118,7 +141,7 @@ template <class Mutex> _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_TYPE_VIS shared_timed_mutex +struct _LIBCPP_TYPE_VIS __shared_mutex_base { mutex __mut_; condition_variable __gate1_; @@ -127,6 +150,58 @@ class _LIBCPP_TYPE_VIS shared_timed_mutex static const unsigned __write_entered_ = 1U << (sizeof(unsigned)*__CHAR_BIT__ - 1); static const unsigned __n_readers_ = ~__write_entered_; + + __shared_mutex_base(); + _LIBCPP_INLINE_VISIBILITY ~__shared_mutex_base() = default; + + __shared_mutex_base(const __shared_mutex_base&) = delete; + __shared_mutex_base& operator=(const __shared_mutex_base&) = delete; + + // Exclusive ownership + void lock(); // blocking + bool try_lock(); + void unlock(); + + // Shared ownership + void lock_shared(); // blocking + bool try_lock_shared(); + void unlock_shared(); + +// typedef implementation-defined native_handle_type; // See 30.2.3 +// native_handle_type native_handle(); // See 30.2.3 +}; + + +#if _LIBCPP_STD_VER > 14 +class _LIBCPP_TYPE_VIS shared_mutex +{ + __shared_mutex_base __base; +public: + shared_mutex() : __base() {} + _LIBCPP_INLINE_VISIBILITY ~shared_mutex() = default; + + shared_mutex(const shared_mutex&) = delete; + shared_mutex& operator=(const shared_mutex&) = delete; + + // Exclusive ownership + _LIBCPP_INLINE_VISIBILITY void lock() { return __base.lock(); } + _LIBCPP_INLINE_VISIBILITY bool try_lock() { return __base.try_lock(); } + _LIBCPP_INLINE_VISIBILITY void unlock() { return __base.unlock(); } + + // Shared ownership + _LIBCPP_INLINE_VISIBILITY void lock_shared() { return __base.lock_shared(); } + _LIBCPP_INLINE_VISIBILITY bool try_lock_shared() { return __base.try_lock_shared(); } + _LIBCPP_INLINE_VISIBILITY void unlock_shared() { return __base.unlock_shared(); } + +// typedef __shared_mutex_base::native_handle_type native_handle_type; +// _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() { return __base::unlock_shared(); } +}; +#endif + + +class _LIBCPP_TYPE_VIS shared_timed_mutex +{ + __shared_mutex_base __base; public: shared_timed_mutex(); _LIBCPP_INLINE_VISIBILITY ~shared_timed_mutex() = default; @@ -170,29 +245,30 @@ bool shared_timed_mutex::try_lock_until( const chrono::time_point<_Clock, _Duration>& __abs_time) { - unique_lock<mutex> __lk(__mut_); - if (__state_ & __write_entered_) + unique_lock<mutex> __lk(__base.__mut_); + if (__base.__state_ & __base.__write_entered_) { while (true) { - cv_status __status = __gate1_.wait_until(__lk, __abs_time); - if ((__state_ & __write_entered_) == 0) + cv_status __status = __base.__gate1_.wait_until(__lk, __abs_time); + if ((__base.__state_ & __base.__write_entered_) == 0) break; if (__status == cv_status::timeout) return false; } } - __state_ |= __write_entered_; - if (__state_ & __n_readers_) + __base.__state_ |= __base.__write_entered_; + if (__base.__state_ & __base.__n_readers_) { while (true) { - cv_status __status = __gate2_.wait_until(__lk, __abs_time); - if ((__state_ & __n_readers_) == 0) + cv_status __status = __base.__gate2_.wait_until(__lk, __abs_time); + if ((__base.__state_ & __base.__n_readers_) == 0) break; if (__status == cv_status::timeout) { - __state_ &= ~__write_entered_; + __base.__state_ &= ~__base.__write_entered_; + __base.__gate1_.notify_all(); return false; } } @@ -205,22 +281,22 @@ bool shared_timed_mutex::try_lock_shared_until( const chrono::time_point<_Clock, _Duration>& __abs_time) { - unique_lock<mutex> __lk(__mut_); - if ((__state_ & __write_entered_) || (__state_ & __n_readers_) == __n_readers_) + unique_lock<mutex> __lk(__base.__mut_); + if ((__base.__state_ & __base.__write_entered_) || (__base.__state_ & __base.__n_readers_) == __base.__n_readers_) { while (true) { - cv_status status = __gate1_.wait_until(__lk, __abs_time); - if ((__state_ & __write_entered_) == 0 && - (__state_ & __n_readers_) < __n_readers_) + cv_status status = __base.__gate1_.wait_until(__lk, __abs_time); + if ((__base.__state_ & __base.__write_entered_) == 0 && + (__base.__state_ & __base.__n_readers_) < __base.__n_readers_) break; if (status == cv_status::timeout) return false; } } - unsigned __num_readers = (__state_ & __n_readers_) + 1; - __state_ &= ~__n_readers_; - __state_ |= __num_readers; + unsigned __num_readers = (__base.__state_ & __base.__n_readers_) + 1; + __base.__state_ &= ~__base.__n_readers_; + __base.__state_ |= __num_readers; return true; } diff --git a/contrib/libc++/include/stack b/contrib/libc++/include/stack index 30909c1ee3bd..2992b091ee51 100644 --- a/contrib/libc++/include/stack +++ b/contrib/libc++/include/stack @@ -91,7 +91,7 @@ template <class T, class Container> _LIBCPP_BEGIN_NAMESPACE_STD -template <class _Tp, class _Container> class _LIBCPP_TYPE_VIS_ONLY stack; +template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TYPE_VIS_ONLY stack; template <class _Tp, class _Container> _LIBCPP_INLINE_VISIBILITY @@ -103,7 +103,7 @@ _LIBCPP_INLINE_VISIBILITY bool operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y); -template <class _Tp, class _Container = deque<_Tp> > +template <class _Tp, class _Container /*= deque<_Tp>*/> class _LIBCPP_TYPE_VIS_ONLY stack { public: diff --git a/contrib/libc++/include/streambuf b/contrib/libc++/include/streambuf index 6adfc9237c7d..603c68038796 100644 --- a/contrib/libc++/include/streambuf +++ b/contrib/libc++/include/streambuf @@ -536,12 +536,23 @@ basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n) { streamsize __i = 0; int_type __eof = traits_type::eof(); - for (; __i < __n; ++__s, ++__i) + while( __i < __n) { - if (__nout_ < __eout_) - *__nout_++ = *__s; - else if (overflow(traits_type::to_int_type(*__s)) == __eof) - break; + if (__nout_ >= __eout_) + { + if (overflow(traits_type::to_int_type(*__s)) == __eof) + break; + ++__s; + ++__i; + } + else + { + streamsize __chunk_size = _VSTD::min(__eout_ - __nout_, __n - __i); + traits_type::copy(__nout_, __s, __chunk_size); + __nout_ += __chunk_size; + __s += __chunk_size; + __i += __chunk_size; + } } return __i; } diff --git a/contrib/libc++/include/string b/contrib/libc++/include/string index fe42bbf1d998..6be21955b146 100644 --- a/contrib/libc++/include/string +++ b/contrib/libc++/include/string @@ -220,8 +220,8 @@ public: basic_string substr(size_type pos = 0, size_type n = npos) const; void swap(basic_string& str) - noexcept(!allocator_type::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) + noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value || + allocator_traits<allocator_type>::is_always_equal::value); // C++17 const value_type* c_str() const noexcept; const value_type* data() const noexcept; @@ -636,19 +636,19 @@ struct _LIBCPP_TYPE_VIS_ONLY char_traits<char> {return (unsigned char)__c1 < (unsigned char)__c2;} static inline int compare(const char_type* __s1, const char_type* __s2, size_t __n) - {return memcmp(__s1, __s2, __n);} + {return __n == 0 ? 0 : memcmp(__s1, __s2, __n);} static inline size_t length(const char_type* __s) {return strlen(__s);} static inline const char_type* find(const char_type* __s, size_t __n, const char_type& __a) - {return (const char_type*)memchr(__s, to_int_type(__a), __n);} + {return __n == 0 ? NULL : (const char_type*) memchr(__s, to_int_type(__a), __n);} static inline char_type* move(char_type* __s1, const char_type* __s2, size_t __n) - {return (char_type*)memmove(__s1, __s2, __n);} + {return __n == 0 ? __s1 : (char_type*) memmove(__s1, __s2, __n);} static inline char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) { _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range"); - return (char_type*)memcpy(__s1, __s2, __n); + return __n == 0 ? __s1 : (char_type*)memcpy(__s1, __s2, __n); } static inline char_type* assign(char_type* __s, size_t __n, char_type __a) - {return (char_type*)memset(__s, to_int_type(__a), __n);} + {return __n == 0 ? __s : (char_type*)memset(__s, to_int_type(__a), __n);} static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT {return eq_int_type(__c, eof()) ? ~eof() : __c;} @@ -681,20 +681,20 @@ struct _LIBCPP_TYPE_VIS_ONLY char_traits<wchar_t> {return __c1 < __c2;} static inline int compare(const char_type* __s1, const char_type* __s2, size_t __n) - {return wmemcmp(__s1, __s2, __n);} + {return __n == 0 ? 0 : wmemcmp(__s1, __s2, __n);} static inline size_t length(const char_type* __s) {return wcslen(__s);} static inline const char_type* find(const char_type* __s, size_t __n, const char_type& __a) - {return (const char_type*)wmemchr(__s, __a, __n);} + {return __n == 0 ? NULL : (const char_type*)wmemchr(__s, __a, __n);} static inline char_type* move(char_type* __s1, const char_type* __s2, size_t __n) - {return (char_type*)wmemmove(__s1, __s2, __n);} + {return __n == 0 ? __s1 : (char_type*)wmemmove(__s1, __s2, __n);} static inline char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) { _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range"); - return (char_type*)wmemcpy(__s1, __s2, __n); + return __n == 0 ? __s1 : (char_type*)wmemcpy(__s1, __s2, __n); } static inline char_type* assign(char_type* __s, size_t __n, char_type __a) - {return (char_type*)wmemset(__s, __a, __n);} + {return __n == 0 ? __s : (char_type*)wmemset(__s, __a, __n);} static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT {return eq_int_type(__c, eof()) ? ~eof() : __c;} @@ -1322,13 +1322,26 @@ public: _LIBCPP_INLINE_VISIBILITY basic_string() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value); - _LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a); + + _LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a) +#if _LIBCPP_STD_VER <= 14 + _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value); +#else + _NOEXCEPT; +#endif + basic_string(const basic_string& __str); basic_string(const basic_string& __str, const allocator_type& __a); + #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY basic_string(basic_string&& __str) +#if _LIBCPP_STD_VER <= 14 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); +#else + _NOEXCEPT; +#endif + _LIBCPP_INLINE_VISIBILITY basic_string(basic_string&& __str, const allocator_type& __a); #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -1591,8 +1604,12 @@ public: _LIBCPP_INLINE_VISIBILITY void swap(basic_string& __str) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value); +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT; +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value); +#endif _LIBCPP_INLINE_VISIBILITY const value_type* c_str() const _NOEXCEPT {return data();} @@ -1855,24 +1872,6 @@ private: _NOEXCEPT {} - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(allocator_type& __x, allocator_type& __y) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) - {__swap_alloc(__x, __y, integral_constant<bool, - __alloc_traits::propagate_on_container_swap::value>());} - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type) - _NOEXCEPT_(__is_nothrow_swappable<allocator_type>::value) - { - using _VSTD::swap; - swap(__x, __y); - } - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(allocator_type&, allocator_type&, false_type) _NOEXCEPT - {} - _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators(); _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type); @@ -2070,7 +2069,11 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st template <class _CharT, class _Traits, class _Allocator> inline _LIBCPP_INLINE_VISIBILITY basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str) +#if _LIBCPP_STD_VER <= 14 _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) +#else + _NOEXCEPT +#endif : __r_(_VSTD::move(__str.__r_)) { __str.__zero(); @@ -3349,8 +3352,12 @@ template <class _CharT, class _Traits, class _Allocator> inline _LIBCPP_INLINE_VISIBILITY void basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value) +#endif { #if _LIBCPP_DEBUG_LEVEL >= 2 if (!__is_long()) @@ -3360,7 +3367,7 @@ basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str) __get_db()->swap(this, &__str); #endif _VSTD::swap(__r_.first(), __str.__r_.first()); - __swap_alloc(__alloc(), __str.__alloc()); + __swap_allocator(__alloc(), __str.__alloc()); } // find diff --git a/contrib/libc++/include/tuple b/contrib/libc++/include/tuple index 5fc27f982790..3a22aa5ff5ac 100644 --- a/contrib/libc++/include/tuple +++ b/contrib/libc++/include/tuple @@ -161,10 +161,8 @@ using tuple_element_t = typename tuple_element <_Ip, _Tp...>::type; // __tuple_leaf -template <size_t _Ip, class _Hp, bool=is_empty<_Hp>::value -#if __has_feature(is_final) - && !__is_final(_Hp) -#endif +template <size_t _Ip, class _Hp, + bool=is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value > class __tuple_leaf; @@ -511,8 +509,8 @@ class _LIBCPP_TYPE_VIS_ONLY tuple typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT; public: - template <bool _Dummy = true, class _Up = typename enable_if< - __all<(_Dummy && is_default_constructible<_Tp>::value)...>::value + template <bool _Dummy = true, class = typename enable_if< + __all<__dependent_type<is_default_constructible<_Tp>, _Dummy>::value...>::value >::type> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR tuple() @@ -846,8 +844,6 @@ struct __ignore_t namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); } -template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper; - template <class _Tp> struct __make_tuple_return_impl { @@ -927,8 +923,12 @@ struct __tuple_less _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _Tp& __x, const _Up& __y) { - return __tuple_less<_Ip-1>()(__x, __y) || - (!__tuple_less<_Ip-1>()(__y, __x) && _VSTD::get<_Ip-1>(__x) < _VSTD::get<_Ip-1>(__y)); + const size_t __idx = tuple_size<_Tp>::value - _Ip; + if (_VSTD::get<__idx>(__x) < _VSTD::get<__idx>(__y)) + return true; + if (_VSTD::get<__idx>(__y) < _VSTD::get<__idx>(__x)) + return false; + return __tuple_less<_Ip-1>()(__x, __y); } }; diff --git a/contrib/libc++/include/type_traits b/contrib/libc++/include/type_traits index 8612e57b77da..a0c1bc565c04 100644 --- a/contrib/libc++/include/type_traits +++ b/contrib/libc++/include/type_traits @@ -19,8 +19,13 @@ namespace std // helper class: template <class T, T v> struct integral_constant; - typedef integral_constant<bool, true> true_type; - typedef integral_constant<bool, false> false_type; + typedef integral_constant<bool, true> true_type; // C++11 + typedef integral_constant<bool, false> false_type; // C++11 + + template <bool B> // C++14 + using bool_constant = integral_constant<bool, B>; // C++14 + typedef bool_constant<true> true_type; // C++14 + typedef bool_constant<false> false_type; // C++14 // helper traits template <bool, class T = void> struct enable_if; @@ -211,10 +216,14 @@ namespace std _LIBCPP_BEGIN_NAMESPACE_STD -#ifndef _LIBCPP_HAS_NO_VARIADICS -template <class...> +template <class> struct __void_t { typedef void type; }; -#endif + +template <class _Tp> +struct __identity { typedef _Tp type; }; + +template <class _Tp, bool> +struct _LIBCPP_TYPE_VIS_ONLY __dependent_type : public _Tp {}; template <bool _Bp, class _If, class _Then> struct _LIBCPP_TYPE_VIS_ONLY conditional {typedef _If type;}; @@ -257,8 +266,16 @@ struct _LIBCPP_TYPE_VIS_ONLY integral_constant template <class _Tp, _Tp __v> _LIBCPP_CONSTEXPR const _Tp integral_constant<_Tp, __v>::value; -typedef integral_constant<bool, true> true_type; -typedef integral_constant<bool, false> false_type; +#if _LIBCPP_STD_VER > 14 +template <bool __b> +using bool_constant = integral_constant<bool, __b>; +#define _LIBCPP_BOOL_CONSTANT(__b) bool_constant<(__b)> +#else +#define _LIBCPP_BOOL_CONSTANT(__b) integral_constant<bool,(__b)> +#endif + +typedef _LIBCPP_BOOL_CONSTANT(true) true_type; +typedef _LIBCPP_BOOL_CONSTANT(false) false_type; // is_const @@ -430,9 +447,12 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_same<_Tp, _Tp> : namespace __libcpp_is_function_imp { +struct __dummy_type {}; template <class _Tp> char __test(_Tp*); +template <class _Tp> char __test(__dummy_type); template <class _Tp> __two __test(...); -template <class _Tp> _Tp& __source(); +template <class _Tp> _Tp& __source(int); +template <class _Tp> __dummy_type __source(...); } template <class _Tp, bool = is_class<_Tp>::value || @@ -441,7 +461,7 @@ template <class _Tp, bool = is_class<_Tp>::value || is_reference<_Tp>::value || __is_nullptr_t<_Tp>::value > struct __libcpp_is_function - : public integral_constant<bool, sizeof(__libcpp_is_function_imp::__test<_Tp>(__libcpp_is_function_imp::__source<_Tp>())) == 1> + : public integral_constant<bool, sizeof(__libcpp_is_function_imp::__test<_Tp>(__libcpp_is_function_imp::__source<_Tp>(0))) == 1> {}; template <class _Tp> struct __libcpp_is_function<_Tp, true> : public false_type {}; @@ -460,19 +480,15 @@ struct __member_pointer_traits_imp }; -namespace __libcpp_is_member_function_pointer_imp { - template <typename _Tp> - char __test(typename std::__member_pointer_traits_imp<_Tp, true, false>::_FnType *); - - template <typename> - std::__two __test(...); -}; - template <class _Tp> struct __libcpp_is_member_function_pointer - : public integral_constant<bool, sizeof(__libcpp_is_member_function_pointer_imp::__test<_Tp>(nullptr)) == 1> {}; + : public false_type {}; + +template <class _Ret, class _Class> +struct __libcpp_is_member_function_pointer<_Ret _Class::*> + : public is_function<_Ret> {}; template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_member_function_pointer - : public __libcpp_is_member_function_pointer<typename remove_cv<_Tp>::type> {}; + : public __libcpp_is_member_function_pointer<typename remove_cv<_Tp>::type>::type {}; // is_member_pointer @@ -673,7 +689,7 @@ template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type; // is_signed template <class _Tp, bool = is_integral<_Tp>::value> -struct __libcpp_is_signed_impl : public integral_constant<bool, _Tp(-1) < _Tp(0)> {}; +struct __libcpp_is_signed_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(-1) < _Tp(0)) {}; template <class _Tp> struct __libcpp_is_signed_impl<_Tp, false> : public true_type {}; // floating point @@ -688,7 +704,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_signed : public __libcpp_is // is_unsigned template <class _Tp, bool = is_integral<_Tp>::value> -struct __libcpp_is_unsigned_impl : public integral_constant<bool, _Tp(0) < _Tp(-1)> {}; +struct __libcpp_is_unsigned_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(0) < _Tp(-1)) {}; template <class _Tp> struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {}; // floating point @@ -790,8 +806,16 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_abstract : public __libcpp_ // is_final -#if _LIBCPP_STD_VER > 11 && __has_feature(is_final) -template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY +#if defined(_LIBCPP_HAS_IS_FINAL) +template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY +__libcpp_is_final : public integral_constant<bool, __is_final(_Tp)> {}; +#else +template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY +__libcpp_is_final : public false_type {}; +#endif + +#if defined(_LIBCPP_HAS_IS_FINAL) && _LIBCPP_STD_VER > 11 +template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_final : public integral_constant<bool, __is_final(_Tp)> {}; #endif @@ -832,7 +856,7 @@ struct _LIBCPP_TYPE_VIS_ONLY is_base_of // is_convertible -#if __has_feature(is_convertible_to) +#if __has_feature(is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK) template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY is_convertible : public integral_constant<bool, __is_convertible_to(_T1, _T2) && @@ -901,6 +925,7 @@ struct __is_convertible template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 0> : false_type {}; template <class _T1> struct __is_convertible<_T1, const _T1&, 1, 0> : true_type {}; +template <class _T1> struct __is_convertible<const _T1, const _T1&, 1, 0> : true_type {}; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template <class _T1> struct __is_convertible<_T1, _T1&&, 1, 0> : true_type {}; template <class _T1> struct __is_convertible<_T1, const _T1&&, 1, 0> : true_type {}; @@ -1440,11 +1465,11 @@ template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type; #ifdef _LIBCPP_HAS_NO_VARIADICS -template <class _Tp, class _Up = void, class V = void> +template <class _Tp, class _Up = void, class _Vp = void> struct _LIBCPP_TYPE_VIS_ONLY common_type { public: - typedef typename common_type<typename common_type<_Tp, _Up>::type, V>::type type; + typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp>::type type; }; template <class _Tp> @@ -1526,7 +1551,7 @@ template <class _Tp, class _Arg, bool = is_void<_Tp>::value || is_void<_Arg>::va struct __is_assignable_imp : public common_type < - decltype(__is_assignable_test(declval<_Tp>(), declval<_Arg>())) + decltype(_VSTD::__is_assignable_test(declval<_Tp>(), declval<_Arg>())) >::type {}; template <class _Tp, class _Arg> @@ -1773,7 +1798,8 @@ struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatil typedef _Rp (_FnType) (_Param..., ...); }; -#if __has_feature(cxx_reference_qualified_functions) +#if __has_feature(cxx_reference_qualified_functions) || \ + (defined(_GNUC_VER) && _GNUC_VER >= 409) template <class _Rp, class _Class, class ..._Param> struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &, true, false> @@ -1903,7 +1929,7 @@ struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatil typedef _Rp (_FnType) (_Param..., ...); }; -#endif // __has_feature(cxx_reference_qualified_functions) +#endif // __has_feature(cxx_reference_qualified_functions) || _GNUC_VER >= 409 #else // _LIBCPP_HAS_NO_VARIADICS @@ -2229,7 +2255,7 @@ struct __result_of_mp; template <class _MP, class _Tp> struct __result_of_mp<_MP, _Tp, true> - : public common_type<typename __member_pointer_traits<_MP>::_ReturnType> + : public __identity<typename __member_pointer_traits<_MP>::_ReturnType> { }; @@ -2297,7 +2323,7 @@ template <class _Fn> class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn()> : public __result_of<_Fn(), is_class<typename remove_reference<_Fn>::type>::value || - is_function<typename remove_reference<_Fn>::type>::value, + is_function<typename remove_pointer<typename remove_reference<_Fn>::type>::type>::value, is_member_pointer<typename remove_reference<_Fn>::type>::value > { @@ -2307,7 +2333,7 @@ template <class _Fn, class _A0> class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0)> : public __result_of<_Fn(_A0), is_class<typename remove_reference<_Fn>::type>::value || - is_function<typename remove_reference<_Fn>::type>::value, + is_function<typename remove_pointer<typename remove_reference<_Fn>::type>::type>::value, is_member_pointer<typename remove_reference<_Fn>::type>::value > { @@ -2317,7 +2343,7 @@ template <class _Fn, class _A0, class _A1> class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0, _A1)> : public __result_of<_Fn(_A0, _A1), is_class<typename remove_reference<_Fn>::type>::value || - is_function<typename remove_reference<_Fn>::type>::value, + is_function<typename remove_pointer<typename remove_reference<_Fn>::type>::type>::value, is_member_pointer<typename remove_reference<_Fn>::type>::value > { @@ -2327,7 +2353,7 @@ template <class _Fn, class _A0, class _A1, class _A2> class _LIBCPP_TYPE_VIS_ONLY result_of<_Fn(_A0, _A1, _A2)> : public __result_of<_Fn(_A0, _A1, _A2), is_class<typename remove_reference<_Fn>::type>::value || - is_function<typename remove_reference<_Fn>::type>::value, + is_function<typename remove_pointer<typename remove_reference<_Fn>::type>::type>::value, is_member_pointer<typename remove_reference<_Fn>::type>::value > { @@ -2675,7 +2701,7 @@ struct _LIBCPP_TYPE_VIS_ONLY is_move_constructible #ifndef _LIBCPP_HAS_NO_VARIADICS -#if __has_feature(is_trivially_constructible) +#if __has_feature(is_trivially_constructible) || _GNUC_VER >= 501 template <class _Tp, class... _Args> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible @@ -2734,7 +2760,7 @@ struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible { }; -#if __has_feature(is_trivially_constructible) +#if __has_feature(is_trivially_constructible) || _GNUC_VER >= 501 template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_constructible<_Tp, __is_construct::__nat, @@ -2822,7 +2848,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_move_constructibl // is_trivially_assignable -#if __has_feature(is_trivially_assignable) +#if __has_feature(is_trivially_assignable) || _GNUC_VER >= 501 template <class _Tp, class _Arg> struct is_trivially_assignable @@ -3260,6 +3286,8 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_standard_layout template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copyable #if __has_feature(is_trivially_copyable) : public integral_constant<bool, __is_trivially_copyable(_Tp)> +#elif _GNUC_VER >= 501 + : public integral_constant<bool, !is_volatile<_Tp>::value && __is_trivially_copyable(_Tp)> #else : integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value> #endif @@ -3268,7 +3296,7 @@ template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_copyable // is_trivial; template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivial -#if __has_feature(is_trivial) || (_GNUC_VER >= 407) +#if __has_feature(is_trivial) || _GNUC_VER >= 407 : public integral_constant<bool, __is_trivial(_Tp)> #else : integral_constant<bool, is_trivially_copyable<_Tp>::value && @@ -3653,6 +3681,48 @@ struct underlying_type #endif // _LIBCPP_UNDERLYING_TYPE + +template <class _Tp, bool = std::is_enum<_Tp>::value> +struct __sfinae_underlying_type +{ + typedef typename underlying_type<_Tp>::type type; + typedef decltype(((type)1) + 0) __promoted_type; +}; + +template <class _Tp> +struct __sfinae_underlying_type<_Tp, false> {}; + +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE +int __convert_to_integral(int __val) { return __val; } + +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE +unsigned __convert_to_integral(unsigned __val) { return __val; } + +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE +long __convert_to_integral(long __val) { return __val; } + +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE +unsigned long __convert_to_integral(unsigned long __val) { return __val; } + +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE +long long __convert_to_integral(long long __val) { return __val; } + +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE +unsigned long long __convert_to_integral(unsigned long long __val) {return __val; } + +#ifndef _LIBCPP_HAS_NO_INT128 +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE +__int128_t __convert_to_integral(__int128_t __val) { return __val; } + +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE +__uint128_t __convert_to_integral(__uint128_t __val) { return __val; } +#endif + +template <class _Tp> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE +typename __sfinae_underlying_type<_Tp>::__promoted_type +__convert_to_integral(_Tp __val) { return __val; } + #ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE template <class _Tp> diff --git a/contrib/libc++/include/unordered_map b/contrib/libc++/include/unordered_map index 0fa87d19ad03..cf70ab62f69e 100644 --- a/contrib/libc++/include/unordered_map +++ b/contrib/libc++/include/unordered_map @@ -122,7 +122,25 @@ public: void insert(InputIterator first, InputIterator last); void insert(initializer_list<value_type>); + template <class... Args> + pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); // C++17 + template <class... Args> + pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); // C++17 + template <class... Args> + iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17 + template <class... Args> + iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); // C++17 + template <class M> + pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); // C++17 + template <class M> + pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); // C++17 + template <class M> + iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); // C++17 + template <class M> + iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); // C++17 + iterator erase(const_iterator position); + iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; @@ -287,6 +305,7 @@ public: void insert(initializer_list<value_type>); iterator erase(const_iterator position); + iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; @@ -359,10 +378,8 @@ template <class Key, class T, class Hash, class Pred, class Alloc> _LIBCPP_BEGIN_NAMESPACE_STD -template <class _Key, class _Cp, class _Hash, bool = is_empty<_Hash>::value -#if __has_feature(is_final) - && !__is_final(_Hash) -#endif +template <class _Key, class _Cp, class _Hash, + bool = is_empty<_Hash>::value && !__libcpp_is_final<_Hash>::value > class __unordered_map_hasher : private _Hash @@ -384,6 +401,12 @@ public: _LIBCPP_INLINE_VISIBILITY size_t operator()(const _Key& __x) const {return static_cast<const _Hash&>(*this)(__x);} + void swap(__unordered_map_hasher&__y) + _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value) + { + using _VSTD::swap; + swap(static_cast<const _Hash&>(*this), static_cast<const _Hash&>(__y)); + } }; template <class _Key, class _Cp, class _Hash> @@ -408,12 +431,26 @@ public: _LIBCPP_INLINE_VISIBILITY size_t operator()(const _Key& __x) const {return __hash_(__x);} + void swap(__unordered_map_hasher&__y) + _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value) + { + using _VSTD::swap; + swap(__hash_, __y.__hash_); + } }; -template <class _Key, class _Cp, class _Pred, bool = is_empty<_Pred>::value -#if __has_feature(is_final) - && !__is_final(_Pred) -#endif +template <class _Key, class _Cp, class _Hash, bool __b> +inline _LIBCPP_INLINE_VISIBILITY +void +swap(__unordered_map_hasher<_Key, _Cp, _Hash, __b>& __x, + __unordered_map_hasher<_Key, _Cp, _Hash, __b>& __y) + _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) +{ + __x.swap(__y); +} + +template <class _Key, class _Cp, class _Pred, + bool = is_empty<_Pred>::value && !__libcpp_is_final<_Pred>::value > class __unordered_map_equal : private _Pred @@ -438,6 +475,12 @@ public: _LIBCPP_INLINE_VISIBILITY bool operator()(const _Key& __x, const _Cp& __y) const {return static_cast<const _Pred&>(*this)(__x, __y.__cc.first);} + void swap(__unordered_map_equal&__y) + _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value) + { + using _VSTD::swap; + swap(static_cast<const _Pred&>(*this), static_cast<const _Pred&>(__y)); + } }; template <class _Key, class _Cp, class _Pred> @@ -465,8 +508,24 @@ public: _LIBCPP_INLINE_VISIBILITY bool operator()(const _Key& __x, const _Cp& __y) const {return __pred_(__x, __y.__cc.first);} + void swap(__unordered_map_equal&__y) + _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value) + { + using _VSTD::swap; + swap(__pred_, __y.__pred_); + } }; +template <class _Key, class _Cp, class _Pred, bool __b> +inline _LIBCPP_INLINE_VISIBILITY +void +swap(__unordered_map_equal<_Key, _Cp, _Pred, __b>& __x, + __unordered_map_equal<_Key, _Cp, _Pred, __b>& __y) + _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) +{ + __x.swap(__y); +} + template <class _Alloc> class __hash_map_node_destructor { @@ -551,7 +610,7 @@ union __hash_value_type _LIBCPP_INLINE_VISIBILITY __hash_value_type(__hash_value_type&& __v) - : __nc(std::move(__v.__nc)) {} + : __nc(_VSTD::move(__v.__nc)) {} _LIBCPP_INLINE_VISIBILITY __hash_value_type& operator=(const __hash_value_type& __v) @@ -559,7 +618,7 @@ union __hash_value_type _LIBCPP_INLINE_VISIBILITY __hash_value_type& operator=(__hash_value_type&& __v) - {__nc = std::move(__v.__nc); return *this;} + {__nc = _VSTD::move(__v.__nc); return *this;} _LIBCPP_INLINE_VISIBILITY ~__hash_value_type() {__cc.~value_type();} @@ -730,13 +789,8 @@ private: typedef __hash_value_type<key_type, mapped_type> __value_type; typedef __unordered_map_hasher<key_type, __value_type, hasher> __hasher; typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal; - typedef typename allocator_traits<allocator_type>::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__value_type> -#else - rebind_alloc<__value_type>::other -#endif - __allocator_type; + typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, + __value_type>::type __allocator_type; typedef __hash_table<__value_type, __hasher, __key_equal, __allocator_type> __table; @@ -946,9 +1000,125 @@ public: {insert(__il.begin(), __il.end());} #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS +#if _LIBCPP_STD_VER > 14 +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +#ifndef _LIBCPP_HAS_NO_VARIADICS + template <class... _Args> + _LIBCPP_INLINE_VISIBILITY + pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args) + { + iterator __p = __table_.find(__k); + if ( __p != end()) + return _VSTD::make_pair(__p, false); + else + return _VSTD::make_pair( + emplace_hint(__p, + _VSTD::piecewise_construct, _VSTD::forward_as_tuple(__k), + _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)), + true); + } + + template <class... _Args> + _LIBCPP_INLINE_VISIBILITY + pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args) + { + iterator __p = __table_.find(__k); + if ( __p != end()) + return _VSTD::make_pair(__p, false); + else + return _VSTD::make_pair( + emplace_hint(__p, + _VSTD::piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), + _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)), + true); + } + + template <class... _Args> + _LIBCPP_INLINE_VISIBILITY + iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args) + { + iterator __p = __table_.find(__k); + if ( __p != end()) + return __p; + else + return emplace_hint(__h, + _VSTD::piecewise_construct, _VSTD::forward_as_tuple(__k), + _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); + } + + template <class... _Args> + _LIBCPP_INLINE_VISIBILITY + iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args) + { + iterator __p = __table_.find(__k); + if ( __p != end()) + return __p; + else + return emplace_hint(__h, + _VSTD::piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)), + _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); + } + + template <class _Vp> + _LIBCPP_INLINE_VISIBILITY + pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v) + { + iterator __p = __table_.find(__k); + if ( __p != end()) + { + __p->second = _VSTD::move(__v); + return _VSTD::make_pair(__p, false); + } + return _VSTD::make_pair(emplace_hint(__p, __k, _VSTD::forward<_Vp>(__v)), true); + } + + template <class _Vp> + _LIBCPP_INLINE_VISIBILITY + pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v) + { + iterator __p = __table_.find(__k); + if ( __p != end()) + { + __p->second = _VSTD::move(__v); + return _VSTD::make_pair(__p, false); + } + return _VSTD::make_pair(emplace_hint(__p, _VSTD::forward<key_type>(__k), _VSTD::forward<_Vp>(__v)), true); + } + + template <class _Vp> + _LIBCPP_INLINE_VISIBILITY + iterator insert_or_assign(const_iterator __h, const key_type& __k, _Vp&& __v) + { + iterator __p = __table_.find(__k); + if ( __p != end()) + { + __p->second = _VSTD::move(__v); + return __p; + } + return emplace_hint(__h, __k, _VSTD::forward<_Vp>(__v)); + } + + template <class _Vp> + _LIBCPP_INLINE_VISIBILITY + iterator insert_or_assign(const_iterator __h, key_type&& __k, _Vp&& __v) + { + iterator __p = __table_.find(__k); + if ( __p != end()) + { + __p->second = _VSTD::move(__v); + return __p; + } + return emplace_hint(__h, _VSTD::forward<key_type>(__k), _VSTD::forward<_Vp>(__v)); + } +#endif +#endif +#endif + _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);} _LIBCPP_INLINE_VISIBILITY + iterator erase(iterator __p) {return __table_.erase(__p.__i_);} + _LIBCPP_INLINE_VISIBILITY size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);} _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __first, const_iterator __last) @@ -1469,13 +1639,8 @@ private: typedef __hash_value_type<key_type, mapped_type> __value_type; typedef __unordered_map_hasher<key_type, __value_type, hasher> __hasher; typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal; - typedef typename allocator_traits<allocator_type>::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__value_type> -#else - rebind_alloc<__value_type>::other -#endif - __allocator_type; + typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, + __value_type>::type __allocator_type; typedef __hash_table<__value_type, __hasher, __key_equal, __allocator_type> __table; @@ -1654,6 +1819,8 @@ public: _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);} _LIBCPP_INLINE_VISIBILITY + iterator erase(iterator __p) {return __table_.erase(__p.__i_);} + _LIBCPP_INLINE_VISIBILITY size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);} _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __first, const_iterator __last) diff --git a/contrib/libc++/include/unordered_set b/contrib/libc++/include/unordered_set index d06629fdcd47..f6ccdc3734f2 100644 --- a/contrib/libc++/include/unordered_set +++ b/contrib/libc++/include/unordered_set @@ -114,16 +114,15 @@ public: void insert(initializer_list<value_type>); iterator erase(const_iterator position); + iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; void swap(unordered_set&) - noexcept( - (!allocator_type::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) && - __is_nothrow_swappable<hasher>::value && - __is_nothrow_swappable<key_equal>::value); + noexcept(allocator_traits<Allocator>::is_always_equal::value && + noexcept(swap(declval<hasher&>(), declval<hasher&>())) && + noexcept(swap(declval<key_equal&>(), declval<key_equal&>()))); // C++17 hasher hash_function() const; key_equal key_eq() const; @@ -263,16 +262,15 @@ public: void insert(initializer_list<value_type>); iterator erase(const_iterator position); + iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; void swap(unordered_multiset&) - noexcept( - (!allocator_type::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) && - __is_nothrow_swappable<hasher>::value && - __is_nothrow_swappable<key_equal>::value); + noexcept(allocator_traits<Allocator>::is_always_equal::value && + noexcept(swap(declval<hasher&>(), declval<hasher&>())) && + noexcept(swap(declval<key_equal&>(), declval<key_equal&>()))); // C++17 hasher hash_function() const; key_equal key_eq() const; diff --git a/contrib/libc++/include/utility b/contrib/libc++/include/utility index 6f324dbd6f94..54cfc8bc1592 100644 --- a/contrib/libc++/include/utility +++ b/contrib/libc++/include/utility @@ -202,6 +202,11 @@ operator>=(const _Tp& __x, const _Tp& __y) // swap_ranges +// forward +template<class _Tp, size_t _Np> +inline _LIBCPP_INLINE_VISIBILITY +void swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value); + template <class _ForwardIterator1, class _ForwardIterator2> inline _LIBCPP_INLINE_VISIBILITY _ForwardIterator2 @@ -508,10 +513,6 @@ template <class _T1, class _T2> : public integral_constant<size_t, 2> {}; template <class _T1, class _T2> - class _LIBCPP_TYPE_VIS_ONLY tuple_size<const pair<_T1, _T2> > - : public integral_constant<size_t, 2> {}; - -template <class _T1, class _T2> class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, pair<_T1, _T2> > { public: @@ -525,20 +526,6 @@ public: typedef _T2 type; }; -template <class _T1, class _T2> -class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, const pair<_T1, _T2> > -{ -public: - typedef const _T1 type; -}; - -template <class _T1, class _T2> -class _LIBCPP_TYPE_VIS_ONLY tuple_element<1, const pair<_T1, _T2> > -{ -public: - typedef const _T2 type; -}; - template <size_t _Ip> struct __get_pair; template <> diff --git a/contrib/libc++/include/valarray b/contrib/libc++/include/valarray index 2b942046db9d..bdaa58836f39 100644 --- a/contrib/libc++/include/valarray +++ b/contrib/libc++/include/valarray @@ -348,6 +348,7 @@ template <class T> unspecified2 end(const valarray<T>& v); #include <new> #include <__undef_min_max> +#include <__undef___deallocate> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header diff --git a/contrib/libc++/include/vector b/contrib/libc++/include/vector index 22a63439a763..c168c8ea60ad 100644 --- a/contrib/libc++/include/vector +++ b/contrib/libc++/include/vector @@ -119,8 +119,8 @@ public: void resize(size_type sz, const value_type& c); void swap(vector&) - noexcept(!allocator_type::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value); + noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value || + allocator_traits<allocator_type>::is_always_equal::value); // C++17 bool __invariants() const; }; @@ -237,8 +237,8 @@ public: void resize(size_type sz, value_type x); void swap(vector&) - noexcept(!allocator_type::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value); + noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value || + allocator_traits<allocator_type>::is_always_equal::value); // C++17 void flip() noexcept; bool __invariants() const; @@ -385,14 +385,6 @@ protected: is_nothrow_move_assignable<allocator_type>::value) {__move_assign_alloc(__c, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());} - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(allocator_type& __x, allocator_type& __y) - _NOEXCEPT_( - !__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) - {__swap_alloc(__x, __y, integral_constant<bool, - __alloc_traits::propagate_on_container_swap::value>());} private: _LIBCPP_INLINE_VISIBILITY void __copy_assign_alloc(const __vector_base& __c, true_type) @@ -421,18 +413,6 @@ private: void __move_assign_alloc(__vector_base&, false_type) _NOEXCEPT {} - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type) - _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) - { - using _VSTD::swap; - swap(__x, __y); - } - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(allocator_type&, allocator_type&, false_type) - _NOEXCEPT - {} }; template <class _Tp, class _Allocator> @@ -500,14 +480,18 @@ public: "Allocator::value_type must be same type as value_type"); _LIBCPP_INLINE_VISIBILITY - vector() - _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) + vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); #endif } _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a) +#if _LIBCPP_STD_VER <= 14 + _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value) +#else + _NOEXCEPT +#endif : __base(__a) { #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -569,7 +553,11 @@ public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY vector(vector&& __x) +#if _LIBCPP_STD_VER > 14 + _NOEXCEPT; +#else _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); +#endif _LIBCPP_INLINE_VISIBILITY vector(vector&& __x, const allocator_type& __a); _LIBCPP_INLINE_VISIBILITY @@ -756,8 +744,12 @@ public: void resize(size_type __sz, const_reference __x); void swap(vector&) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value); +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT; +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value); +#endif bool __invariants() const; @@ -783,7 +775,7 @@ private: __is_forward_iterator<_ForwardIterator>::value, void >::type - __construct_at_end(_ForwardIterator __first, _ForwardIterator __last); + __construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n); void __append(size_type __n); void __append(size_type __n, const_reference __x); _LIBCPP_INLINE_VISIBILITY @@ -868,17 +860,17 @@ private: // but if an exception is thrown after that the annotation has to be undone. struct __RAII_IncreaseAnnotator { __RAII_IncreaseAnnotator(const vector &__v, size_type __n = 1) - : __commit(false), __v(__v), __n(__n) { + : __commit(false), __v(__v), __old_size(__v.size() + __n) { __v.__annotate_increase(__n); } void __done() { __commit = true; } ~__RAII_IncreaseAnnotator() { if (__commit) return; - __v.__annotate_shrink(__v.size() + __n); + __v.__annotate_shrink(__old_size); } bool __commit; - size_type __n; const vector &__v; + size_type __old_size; }; #else struct __RAII_IncreaseAnnotator { @@ -1021,16 +1013,12 @@ typename enable_if __is_forward_iterator<_ForwardIterator>::value, void >::type -vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last) +vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n) { allocator_type& __a = this->__alloc(); - for (; __first != __last; ++__first) - { - __RAII_IncreaseAnnotator __annotator(*this); - __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first); - __annotator.__done(); - ++this->__end_; - } + __RAII_IncreaseAnnotator __annotator(*this, __n); + __alloc_traits::__construct_range_forward(__a, __first, __last, this->__end_); + __annotator.__done(); } // Default constructs __n objects starting at __end_ @@ -1177,7 +1165,7 @@ vector<_Tp, _Allocator>::vector(_ForwardIterator __first, if (__n > 0) { allocate(__n); - __construct_at_end(__first, __last); + __construct_at_end(__first, __last, __n); } } @@ -1197,7 +1185,7 @@ vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __las if (__n > 0) { allocate(__n); - __construct_at_end(__first, __last); + __construct_at_end(__first, __last, __n); } } @@ -1212,7 +1200,7 @@ vector<_Tp, _Allocator>::vector(const vector& __x) if (__n > 0) { allocate(__n); - __construct_at_end(__x.__begin_, __x.__end_); + __construct_at_end(__x.__begin_, __x.__end_, __n); } } @@ -1227,7 +1215,7 @@ vector<_Tp, _Allocator>::vector(const vector& __x, const allocator_type& __a) if (__n > 0) { allocate(__n); - __construct_at_end(__x.__begin_, __x.__end_); + __construct_at_end(__x.__begin_, __x.__end_, __n); } } @@ -1236,7 +1224,11 @@ vector<_Tp, _Allocator>::vector(const vector& __x, const allocator_type& __a) template <class _Tp, class _Allocator> inline _LIBCPP_INLINE_VISIBILITY vector<_Tp, _Allocator>::vector(vector&& __x) +#if _LIBCPP_STD_VER > 14 + _NOEXCEPT +#else _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) +#endif : __base(_VSTD::move(__x.__alloc())) { #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -1286,7 +1278,7 @@ vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il) if (__il.size() > 0) { allocate(__il.size()); - __construct_at_end(__il.begin(), __il.end()); + __construct_at_end(__il.begin(), __il.end(), __il.size()); } } @@ -1301,7 +1293,7 @@ vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il, const allocat if (__il.size() > 0) { allocate(__il.size()); - __construct_at_end(__il.begin(), __il.end()); + __construct_at_end(__il.begin(), __il.end(), __il.size()); } } @@ -1394,12 +1386,12 @@ typename enable_if >::type vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) { - typename iterator_traits<_ForwardIterator>::difference_type __new_size = _VSTD::distance(__first, __last); - if (static_cast<size_type>(__new_size) <= capacity()) + size_type __new_size = static_cast<size_type>(_VSTD::distance(__first, __last)); + if (__new_size <= capacity()) { _ForwardIterator __mid = __last; bool __growing = false; - if (static_cast<size_type>(__new_size) > size()) + if (__new_size > size()) { __growing = true; __mid = __first; @@ -1407,15 +1399,15 @@ vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __las } pointer __m = _VSTD::copy(__first, __mid, this->__begin_); if (__growing) - __construct_at_end(__mid, __last); + __construct_at_end(__mid, __last, __new_size - size()); else this->__destruct_at_end(__m); } else { deallocate(); - allocate(__recommend(static_cast<size_type>(__new_size))); - __construct_at_end(__first, __last); + allocate(__recommend(__new_size)); + __construct_at_end(__first, __last, __new_size); } } @@ -1967,8 +1959,9 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __fi if (__n > __dx) { __m = __first; - _VSTD::advance(__m, this->__end_ - __p); - __construct_at_end(__m, __last); + difference_type __diff = this->__end_ - __p; + _VSTD::advance(__m, __diff); + __construct_at_end(__m, __last, __n - __diff); __n = __dx; } if (__n > 0) @@ -2015,8 +2008,12 @@ vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x) template <class _Tp, class _Allocator> void vector<_Tp, _Allocator>::swap(vector& __x) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value) +#endif { _LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value || this->__alloc() == __x.__alloc(), @@ -2025,7 +2022,8 @@ vector<_Tp, _Allocator>::swap(vector& __x) _VSTD::swap(this->__begin_, __x.__begin_); _VSTD::swap(this->__end_, __x.__end_); _VSTD::swap(this->__end_cap(), __x.__end_cap()); - __base::__swap_alloc(this->__alloc(), __x.__alloc()); + __swap_allocator(this->__alloc(), __x.__alloc(), + integral_constant<bool,__alloc_traits::propagate_on_container_swap::value>()); #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->swap(this, &__x); #endif // _LIBCPP_DEBUG_LEVEL >= 2 @@ -2128,13 +2126,7 @@ public: typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; private: - typedef typename __alloc_traits::template -#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES - rebind_alloc<__storage_type> -#else - rebind_alloc<__storage_type>::other -#endif - __storage_allocator; + typedef typename __rebind_alloc_helper<__alloc_traits, __storage_type>::type __storage_allocator; typedef allocator_traits<__storage_allocator> __storage_traits; typedef typename __storage_traits::pointer __storage_pointer; typedef typename __storage_traits::const_pointer __const_storage_pointer; @@ -2170,9 +2162,14 @@ private: public: _LIBCPP_INLINE_VISIBILITY - vector() - _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value); - _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a); + vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value); + + _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a) +#if _LIBCPP_STD_VER <= 14 + _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value); +#else + _NOEXCEPT; +#endif ~vector(); explicit vector(size_type __n); #if _LIBCPP_STD_VER > 11 @@ -2206,7 +2203,11 @@ public: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY vector(vector&& __v) +#if _LIBCPP_STD_VER > 14 + _NOEXCEPT; +#else _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); +#endif vector(vector&& __v, const allocator_type& __a); _LIBCPP_INLINE_VISIBILITY vector& operator=(vector&& __v) @@ -2354,8 +2355,12 @@ public: void clear() _NOEXCEPT {__size_ = 0;} void swap(vector&) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value); +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT; +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value); +#endif void resize(size_type __sz, value_type __x = false); void flip() _NOEXCEPT; @@ -2433,26 +2438,6 @@ private: _NOEXCEPT {} - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__storage_allocator& __x, __storage_allocator& __y) - _NOEXCEPT_( - !__storage_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) - {__swap_alloc(__x, __y, integral_constant<bool, - __storage_traits::propagate_on_container_swap::value>());} - - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__storage_allocator& __x, __storage_allocator& __y, true_type) - _NOEXCEPT_(__is_nothrow_swappable<allocator_type>::value) - { - using _VSTD::swap; - swap(__x, __y); - } - _LIBCPP_INLINE_VISIBILITY - static void __swap_alloc(__storage_allocator&, __storage_allocator&, false_type) - _NOEXCEPT - {} - size_t __hash_code() const _NOEXCEPT; friend class __bit_reference<vector>; @@ -2559,7 +2544,7 @@ vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardI template <class _Allocator> inline _LIBCPP_INLINE_VISIBILITY vector<bool, _Allocator>::vector() - _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) + _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) : __begin_(nullptr), __size_(0), __cap_alloc_(0) @@ -2569,6 +2554,11 @@ vector<bool, _Allocator>::vector() template <class _Allocator> inline _LIBCPP_INLINE_VISIBILITY vector<bool, _Allocator>::vector(const allocator_type& __a) +#if _LIBCPP_STD_VER <= 14 + _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value) +#else + _NOEXCEPT +#endif : __begin_(nullptr), __size_(0), __cap_alloc_(0, static_cast<__storage_allocator>(__a)) @@ -2807,7 +2797,11 @@ vector<bool, _Allocator>::operator=(const vector& __v) template <class _Allocator> inline _LIBCPP_INLINE_VISIBILITY vector<bool, _Allocator>::vector(vector&& __v) +#if _LIBCPP_STD_VER > 14 + _NOEXCEPT +#else _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) +#endif : __begin_(__v.__begin_), __size_(__v.__size_), __cap_alloc_(__v.__cap_alloc_) @@ -3150,13 +3144,18 @@ vector<bool, _Allocator>::erase(const_iterator __first, const_iterator __last) template <class _Allocator> void vector<bool, _Allocator>::swap(vector& __x) - _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || - __is_nothrow_swappable<allocator_type>::value) +#if _LIBCPP_STD_VER >= 14 + _NOEXCEPT +#else + _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || + __is_nothrow_swappable<allocator_type>::value) +#endif { _VSTD::swap(this->__begin_, __x.__begin_); _VSTD::swap(this->__size_, __x.__size_); _VSTD::swap(this->__cap(), __x.__cap()); - __swap_alloc(this->__alloc(), __x.__alloc()); + __swap_allocator(this->__alloc(), __x.__alloc(), + integral_constant<bool, __alloc_traits::propagate_on_container_swap::value>()); } template <class _Allocator> diff --git a/contrib/libc++/src/chrono.cpp b/contrib/libc++/src/chrono.cpp index 456941144e01..62149fbf420c 100644 --- a/contrib/libc++/src/chrono.cpp +++ b/contrib/libc++/src/chrono.cpp @@ -8,14 +8,21 @@ //===----------------------------------------------------------------------===// #include "chrono" -#include <sys/time.h> //for gettimeofday and timeval -#ifdef __APPLE__ +#include "cerrno" // errno +#include "system_error" // __throw_system_error +#include <time.h> // clock_gettime, CLOCK_MONOTONIC and CLOCK_REALTIME + +#if !defined(CLOCK_REALTIME) +#include <sys/time.h> // for gettimeofday and timeval +#endif + +#if !defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK) && !defined(CLOCK_MONOTONIC) +#if __APPLE__ #include <mach/mach_time.h> // mach_absolute_time, mach_timebase_info_data_t -#else /* !__APPLE__ */ -#include <cerrno> // errno -#include <system_error> // __throw_system_error -#include <time.h> // clock_gettime, CLOCK_MONOTONIC -#endif // __APPLE__ +#else +#error "Monotonic clock not implemented" +#endif +#endif _LIBCPP_BEGIN_NAMESPACE_STD @@ -29,9 +36,16 @@ const bool system_clock::is_steady; system_clock::time_point system_clock::now() _NOEXCEPT { +#ifdef CLOCK_REALTIME + struct timespec tp; + if (0 != clock_gettime(CLOCK_REALTIME, &tp)) + __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed"); + return time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000)); +#else // !CLOCK_REALTIME timeval tv; gettimeofday(&tv, 0); return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec)); +#endif // CLOCK_REALTIME } time_t @@ -48,10 +62,26 @@ system_clock::from_time_t(time_t t) _NOEXCEPT #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK // steady_clock +// +// Warning: If this is not truly steady, then it is non-conforming. It is +// better for it to not exist and have the rest of libc++ use system_clock +// instead. const bool steady_clock::is_steady; -#ifdef __APPLE__ +#ifdef CLOCK_MONOTONIC + +steady_clock::time_point +steady_clock::now() _NOEXCEPT +{ + struct timespec tp; + if (0 != clock_gettime(CLOCK_MONOTONIC, &tp)) + __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed"); + return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec)); +} + +#elif defined(__APPLE__) + // mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of // nanoseconds since the computer booted up. MachInfo.numer and MachInfo.denom // are run time constants supplied by the OS. This clock has no relationship @@ -108,23 +138,9 @@ steady_clock::now() _NOEXCEPT return time_point(duration(fp())); } -#else // __APPLE__ -// FIXME: if _LIBCPP_HAS_NO_MONOTONIC_CLOCK, then clock_gettime isn't going to -// work. It may be possible to fall back on something else, depending on the system. - -// Warning: If this is not truly steady, then it is non-conforming. It is -// better for it to not exist and have the rest of libc++ use system_clock -// instead. - -steady_clock::time_point -steady_clock::now() _NOEXCEPT -{ - struct timespec tp; - if (0 != clock_gettime(CLOCK_MONOTONIC, &tp)) - __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed"); - return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec)); -} -#endif // __APPLE__ +#else +#error "Monotonic clock not implemented" +#endif #endif // !_LIBCPP_HAS_NO_MONOTONIC_CLOCK diff --git a/contrib/libc++/src/config_elast.h b/contrib/libc++/src/config_elast.h new file mode 100644 index 000000000000..9d6a76b0c004 --- /dev/null +++ b/contrib/libc++/src/config_elast.h @@ -0,0 +1,36 @@ +//===----------------------- config_elast.h -------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_CONFIG_ELAST +#define _LIBCPP_CONFIG_ELAST + +#if defined(_WIN32) +#include <stdlib.h> +#else +#include <errno.h> +#endif + +#if defined(ELAST) +#define _LIBCPP_ELAST ELAST +#elif defined(_NEWLIB_VERSION) +#define _LIBCPP_ELAST __ELASTERROR +#elif defined(__linux__) +#define _LIBCPP_ELAST 4095 +#elif defined(__APPLE__) +// No _LIBCPP_ELAST needed on Apple +#elif defined(__sun__) +#define _LIBCPP_ELAST ESTALE +#elif defined(_WIN32) +#define _LIBCPP_ELAST _sys_nerr +#else +// Warn here so that the person doing the libcxx port has an easier time: +#warning ELAST for this platform not yet implemented +#endif + +#endif // _LIBCPP_CONFIG_ELAST diff --git a/contrib/libc++/src/debug.cpp b/contrib/libc++/src/debug.cpp index 60694a3bdb0e..b1a16e6e72d4 100644 --- a/contrib/libc++/src/debug.cpp +++ b/contrib/libc++/src/debug.cpp @@ -214,10 +214,10 @@ __libcpp_db::__erase_i(void* __i) else q->__next_ = p->__next_; __c_node* c = p->__c_; - free(p); --__isz_; if (c != nullptr) c->__remove(p); + free(p); } } } diff --git a/contrib/libc++/src/exception.cpp b/contrib/libc++/src/exception.cpp index b5c46c0805ec..2c16060a7583 100644 --- a/contrib/libc++/src/exception.cpp +++ b/contrib/libc++/src/exception.cpp @@ -29,7 +29,7 @@ #define __terminate_handler __cxxabiapple::__cxa_terminate_handler #define __unexpected_handler __cxxabiapple::__cxa_unexpected_handler #endif // _LIBCPPABI_VERSION -#elif defined(LIBCXXRT) || __has_include(<cxxabi.h>) +#elif defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI) || __has_include(<cxxabi.h>) #include <cxxabi.h> using namespace __cxxabiv1; #if defined(LIBCXXRT) || defined(_LIBCPPABI_VERSION) @@ -90,14 +90,14 @@ terminate() _NOEXCEPT #endif // _LIBCPP_NO_EXCEPTIONS (*get_terminate())(); // handler should not return - printf("terminate_handler unexpectedly returned\n"); + fprintf(stderr, "terminate_handler unexpectedly returned\n"); ::abort(); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { // handler should not throw exception - printf("terminate_handler unexpectedly threw an exception\n"); + fprintf(stderr, "terminate_handler unexpectedly threw an exception\n"); ::abort(); } #endif // _LIBCPP_NO_EXCEPTIONS @@ -106,18 +106,24 @@ terminate() _NOEXCEPT #endif // !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION) #if !defined(LIBCXXRT) && !defined(__GLIBCXX__) && !defined(__EMSCRIPTEN__) -bool uncaught_exception() _NOEXCEPT +bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; } + +int uncaught_exceptions() _NOEXCEPT { #if defined(__APPLE__) || defined(_LIBCPPABI_VERSION) - // on Darwin, there is a helper function so __cxa_get_globals is private - return __cxa_uncaught_exception(); + // on Darwin, there is a helper function so __cxa_get_globals is private +# if _LIBCPPABI_VERSION > 1101 + return __cxa_uncaught_exceptions(); +# else + return __cxa_uncaught_exception() ? 1 : 0; +# endif #else // __APPLE__ # if defined(_MSC_VER) && ! defined(__clang__) - _LIBCPP_WARNING("uncaught_exception not yet implemented") + _LIBCPP_WARNING("uncaught_exceptions not yet implemented") # else # warning uncaught_exception not yet implemented # endif - printf("uncaught_exception not yet implemented\n"); + fprintf(stderr, "uncaught_exceptions not yet implemented\n"); ::abort(); #endif // __APPLE__ } @@ -190,7 +196,7 @@ exception_ptr::~exception_ptr() _NOEXCEPT # else # warning exception_ptr not yet implemented # endif - printf("exception_ptr not yet implemented\n"); + fprintf(stderr, "exception_ptr not yet implemented\n"); ::abort(); #endif } @@ -209,7 +215,7 @@ exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT # else # warning exception_ptr not yet implemented # endif - printf("exception_ptr not yet implemented\n"); + fprintf(stderr, "exception_ptr not yet implemented\n"); ::abort(); #endif } @@ -234,7 +240,7 @@ exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT # else # warning exception_ptr not yet implemented # endif - printf("exception_ptr not yet implemented\n"); + fprintf(stderr, "exception_ptr not yet implemented\n"); ::abort(); #endif } @@ -278,7 +284,7 @@ exception_ptr current_exception() _NOEXCEPT # else # warning exception_ptr not yet implemented # endif - printf("exception_ptr not yet implemented\n"); + fprintf(stderr, "exception_ptr not yet implemented\n"); ::abort(); #endif } @@ -300,7 +306,7 @@ void rethrow_exception(exception_ptr p) # else # warning exception_ptr not yet implemented # endif - printf("exception_ptr not yet implemented\n"); + fprintf(stderr, "exception_ptr not yet implemented\n"); ::abort(); #endif } diff --git a/contrib/libc++/src/future.cpp b/contrib/libc++/src/future.cpp index 0c5c2c4488d2..3132b1861af2 100644 --- a/contrib/libc++/src/future.cpp +++ b/contrib/libc++/src/future.cpp @@ -98,7 +98,6 @@ __assoc_sub_state::set_value() #endif __state_ |= __constructed | ready; __cv_.notify_all(); - __lk.unlock(); } void @@ -111,7 +110,6 @@ __assoc_sub_state::set_value_at_thread_exit() #endif __state_ |= __constructed; __thread_local_data()->__make_ready_at_thread_exit(this); - __lk.unlock(); } void @@ -124,7 +122,6 @@ __assoc_sub_state::set_exception(exception_ptr __p) #endif __exception_ = __p; __state_ |= ready; - __lk.unlock(); __cv_.notify_all(); } @@ -138,7 +135,6 @@ __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p) #endif __exception_ = __p; __thread_local_data()->__make_ready_at_thread_exit(this); - __lk.unlock(); } void @@ -146,7 +142,6 @@ __assoc_sub_state::__make_ready() { unique_lock<mutex> __lk(__mut_); __state_ |= ready; - __lk.unlock(); __cv_.notify_all(); } diff --git a/contrib/libc++/src/ios.cpp b/contrib/libc++/src/ios.cpp index d879beb3801f..90972c407d79 100644 --- a/contrib/libc++/src/ios.cpp +++ b/contrib/libc++/src/ios.cpp @@ -8,16 +8,20 @@ //===----------------------------------------------------------------------===// #include "__config" + #include "ios" -#include "streambuf" -#include "istream" -#include "string" + +#include <stdlib.h> + #include "__locale" #include "algorithm" +#include "config_elast.h" +#include "istream" +#include "limits" #include "memory" #include "new" -#include "limits" -#include <stdlib.h> +#include "streambuf" +#include "string" _LIBCPP_BEGIN_NAMESPACE_STD diff --git a/contrib/libc++/src/iostream.cpp b/contrib/libc++/src/iostream.cpp index 7102e4389e06..e073aec6ead5 100644 --- a/contrib/libc++/src/iostream.cpp +++ b/contrib/libc++/src/iostream.cpp @@ -13,55 +13,75 @@ _LIBCPP_BEGIN_NAMESPACE_STD -static mbstate_t state_types[6] = {}; - +#ifndef _LIBCPP_HAS_NO_STDIN +_ALIGNAS_TYPE (istream) _LIBCPP_FUNC_VIS char cin [sizeof(istream)]; _ALIGNAS_TYPE (__stdinbuf<char> ) static char __cin [sizeof(__stdinbuf <char>)]; -_ALIGNAS_TYPE (__stdoutbuf<char>) static char __cout[sizeof(__stdoutbuf<char>)]; -_ALIGNAS_TYPE (__stdoutbuf<char>) static char __cerr[sizeof(__stdoutbuf<char>)]; +static mbstate_t mb_cin; +_ALIGNAS_TYPE (wistream) _LIBCPP_FUNC_VIS char wcin [sizeof(wistream)]; _ALIGNAS_TYPE (__stdinbuf<wchar_t> ) static char __wcin [sizeof(__stdinbuf <wchar_t>)]; -_ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcout[sizeof(__stdoutbuf<wchar_t>)]; -_ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcerr[sizeof(__stdoutbuf<wchar_t>)]; +static mbstate_t mb_wcin; +#endif -_ALIGNAS_TYPE (istream) _LIBCPP_FUNC_VIS char cin [sizeof(istream)]; +#ifndef _LIBCPP_HAS_NO_STDOUT _ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cout[sizeof(ostream)]; -_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)]; -_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char clog[sizeof(ostream)]; -_ALIGNAS_TYPE (wistream) _LIBCPP_FUNC_VIS char wcin [sizeof(wistream)]; +_ALIGNAS_TYPE (__stdoutbuf<char>) static char __cout[sizeof(__stdoutbuf<char>)]; +static mbstate_t mb_cout; _ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcout[sizeof(wostream)]; +_ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcout[sizeof(__stdoutbuf<wchar_t>)]; +static mbstate_t mb_wcout; +#endif + +_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)]; +_ALIGNAS_TYPE (__stdoutbuf<char>) static char __cerr[sizeof(__stdoutbuf<char>)]; +static mbstate_t mb_cerr; _ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcerr[sizeof(wostream)]; +_ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcerr[sizeof(__stdoutbuf<wchar_t>)]; +static mbstate_t mb_wcerr; + +_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char clog[sizeof(ostream)]; _ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wclog[sizeof(wostream)]; ios_base::Init __start_std_streams; ios_base::Init::Init() { - istream* cin_ptr = ::new(cin) istream(::new(__cin) __stdinbuf <char>(stdin, state_types+0) ); - ostream* cout_ptr = ::new(cout) ostream(::new(__cout) __stdoutbuf<char>(stdout, state_types+1)); - ostream* cerr_ptr = ::new(cerr) ostream(::new(__cerr) __stdoutbuf<char>(stderr, state_types+2)); +#ifndef _LIBCPP_HAS_NO_STDIN + istream* cin_ptr = ::new(cin) istream(::new(__cin) __stdinbuf <char>(stdin, &mb_cin)); + wistream* wcin_ptr = ::new(wcin) wistream(::new(__wcin) __stdinbuf <wchar_t>(stdin, &mb_wcin)); +#endif +#ifndef _LIBCPP_HAS_NO_STDOUT + ostream* cout_ptr = ::new(cout) ostream(::new(__cout) __stdoutbuf<char>(stdout, &mb_cout)); + wostream* wcout_ptr = ::new(wcout) wostream(::new(__wcout) __stdoutbuf<wchar_t>(stdout, &mb_wcout)); +#endif + ostream* cerr_ptr = ::new(cerr) ostream(::new(__cerr) __stdoutbuf<char>(stderr, &mb_cerr)); ::new(clog) ostream(cerr_ptr->rdbuf()); - cin_ptr->tie(cout_ptr); - _VSTD::unitbuf(*cerr_ptr); - cerr_ptr->tie(cout_ptr); - - wistream* wcin_ptr = ::new(wcin) wistream(::new(__wcin) __stdinbuf <wchar_t>(stdin, state_types+3) ); - wostream* wcout_ptr = ::new(wcout) wostream(::new(__wcout) __stdoutbuf<wchar_t>(stdout, state_types+4)); - wostream* wcerr_ptr = ::new(wcerr) wostream(::new(__wcerr) __stdoutbuf<wchar_t>(stderr, state_types+5)); + wostream* wcerr_ptr = ::new(wcerr) wostream(::new(__wcerr) __stdoutbuf<wchar_t>(stderr, &mb_wcerr)); ::new(wclog) wostream(wcerr_ptr->rdbuf()); + +#if !defined(_LIBCPP_HAS_NO_STDIN) && !defined(_LIBCPP_HAS_NO_STDOUT) + cin_ptr->tie(cout_ptr); wcin_ptr->tie(wcout_ptr); +#endif + _VSTD::unitbuf(*cerr_ptr); _VSTD::unitbuf(*wcerr_ptr); +#ifndef _LIBCPP_HAS_NO_STDOUT + cerr_ptr->tie(cout_ptr); wcerr_ptr->tie(wcout_ptr); +#endif } ios_base::Init::~Init() { +#ifndef _LIBCPP_HAS_NO_STDOUT ostream* cout_ptr = reinterpret_cast<ostream*>(cout); - ostream* clog_ptr = reinterpret_cast<ostream*>(clog); + wostream* wcout_ptr = reinterpret_cast<wostream*>(wcout); cout_ptr->flush(); - clog_ptr->flush(); + wcout_ptr->flush(); +#endif - wostream* wcout_ptr = reinterpret_cast<wostream*>(wcout); + ostream* clog_ptr = reinterpret_cast<ostream*>(clog); wostream* wclog_ptr = reinterpret_cast<wostream*>(wclog); - wcout_ptr->flush(); + clog_ptr->flush(); wclog_ptr->flush(); } diff --git a/contrib/libc++/src/locale.cpp b/contrib/libc++/src/locale.cpp index f21e35dd540a..bdc73e1d5379 100644 --- a/contrib/libc++/src/locale.cpp +++ b/contrib/libc++/src/locale.cpp @@ -27,7 +27,7 @@ #include "cwctype" #include "__sso_allocator" #if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__) -#include <support/win32/locale_win32.h> +#include "support/win32/locale_win32.h" #elif !defined(__ANDROID__) #include <langinfo.h> #endif @@ -575,8 +575,10 @@ locale::global(const locale& loc) locale& g = __global(); locale r = g; g = loc; +#ifndef __CloudABI__ if (g.name() != "*") setlocale(LC_ALL, g.name().c_str()); +#endif return r; } @@ -813,7 +815,7 @@ ctype<wchar_t>::do_toupper(char_type c) const #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c; #else - return (isascii(c) && iswlower_l(c, __cloc())) ? c-L'a'+L'A' : c; + return (isascii(c) && iswlower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'a'+L'A' : c; #endif } @@ -827,7 +829,7 @@ ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const *low = isascii(*low) ? ctype<char>::__classic_upper_table()[*low] : *low; #else - *low = (isascii(*low) && islower_l(*low, __cloc())) ? (*low-L'a'+L'A') : *low; + *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? (*low-L'a'+L'A') : *low; #endif return low; } @@ -840,7 +842,7 @@ ctype<wchar_t>::do_tolower(char_type c) const #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c; #else - return (isascii(c) && isupper_l(c, __cloc())) ? c-L'A'+'a' : c; + return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'A'+'a' : c; #endif } @@ -854,7 +856,7 @@ ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const *low = isascii(*low) ? ctype<char>::__classic_lower_table()[*low] : *low; #else - *low = (isascii(*low) && isupper_l(*low, __cloc())) ? *low-L'A'+L'a' : *low; + *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-L'A'+L'a' : *low; #endif return low; } @@ -923,7 +925,7 @@ ctype<char>::do_toupper(char_type c) const return isascii(c) ? static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]) : c; #else - return (isascii(c) && islower_l(c, __cloc())) ? c-'a'+'A' : c; + return (isascii(c) && islower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'a'+'A' : c; #endif } @@ -940,7 +942,7 @@ ctype<char>::do_toupper(char_type* low, const char_type* high) const *low = isascii(*low) ? static_cast<char>(__classic_upper_table()[static_cast<size_t>(*low)]) : *low; #else - *low = (isascii(*low) && islower_l(*low, __cloc())) ? *low-'a'+'A' : *low; + *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'a'+'A' : *low; #endif return low; } @@ -957,7 +959,7 @@ ctype<char>::do_tolower(char_type c) const return isascii(c) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(c)]) : c; #else - return (isascii(c) && isupper_l(c, __cloc())) ? c-'A'+'a' : c; + return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'A'+'a' : c; #endif } @@ -972,7 +974,7 @@ ctype<char>::do_tolower(char_type* low, const char_type* high) const #elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) *low = isascii(*low) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(*low)]) : *low; #else - *low = (isascii(*low) && isupper_l(*low, __cloc())) ? *low-'A'+'a' : *low; + *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'A'+'a' : *low; #endif return low; } @@ -1016,6 +1018,87 @@ extern "C" const int ** __ctype_tolower_loc(); extern "C" const int ** __ctype_toupper_loc(); #endif +#ifdef _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE +const ctype<char>::mask* +ctype<char>::classic_table() _NOEXCEPT +{ + static _LIBCPP_CONSTEXPR const ctype<char>::mask builtin_table[table_size] = { + cntrl, cntrl, + cntrl, cntrl, + cntrl, cntrl, + cntrl, cntrl, + cntrl, cntrl | space | blank, + cntrl | space, cntrl | space, + cntrl | space, cntrl | space, + cntrl, cntrl, + cntrl, cntrl, + cntrl, cntrl, + cntrl, cntrl, + cntrl, cntrl, + cntrl, cntrl, + cntrl, cntrl, + cntrl, cntrl, + cntrl, cntrl, + space | blank | print, punct | print, + punct | print, punct | print, + punct | print, punct | print, + punct | print, punct | print, + punct | print, punct | print, + punct | print, punct | print, + punct | print, punct | print, + punct | print, punct | print, + digit | print | xdigit, digit | print | xdigit, + digit | print | xdigit, digit | print | xdigit, + digit | print | xdigit, digit | print | xdigit, + digit | print | xdigit, digit | print | xdigit, + digit | print | xdigit, digit | print | xdigit, + punct | print, punct | print, + punct | print, punct | print, + punct | print, punct | print, + punct | print, upper | xdigit | print | alpha, + upper | xdigit | print | alpha, upper | xdigit | print | alpha, + upper | xdigit | print | alpha, upper | xdigit | print | alpha, + upper | xdigit | print | alpha, upper | print | alpha, + upper | print | alpha, upper | print | alpha, + upper | print | alpha, upper | print | alpha, + upper | print | alpha, upper | print | alpha, + upper | print | alpha, upper | print | alpha, + upper | print | alpha, upper | print | alpha, + upper | print | alpha, upper | print | alpha, + upper | print | alpha, upper | print | alpha, + upper | print | alpha, upper | print | alpha, + upper | print | alpha, upper | print | alpha, + upper | print | alpha, punct | print, + punct | print, punct | print, + punct | print, punct | print, + punct | print, lower | xdigit | print | alpha, + lower | xdigit | print | alpha, lower | xdigit | print | alpha, + lower | xdigit | print | alpha, lower | xdigit | print | alpha, + lower | xdigit | print | alpha, lower | print | alpha, + lower | print | alpha, lower | print | alpha, + lower | print | alpha, lower | print | alpha, + lower | print | alpha, lower | print | alpha, + lower | print | alpha, lower | print | alpha, + lower | print | alpha, lower | print | alpha, + lower | print | alpha, lower | print | alpha, + lower | print | alpha, lower | print | alpha, + lower | print | alpha, lower | print | alpha, + lower | print | alpha, lower | print | alpha, + lower | print | alpha, punct | print, + punct | print, punct | print, + punct | print, cntrl, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + return builtin_table; +} +#else const ctype<char>::mask* ctype<char>::classic_table() _NOEXCEPT { @@ -1024,7 +1107,7 @@ ctype<char>::classic_table() _NOEXCEPT #elif defined(__NetBSD__) return _C_ctype_tab_ + 1; #elif defined(__GLIBC__) - return __cloc()->__ctype_b; + return _LIBCPP_GET_C_LOCALE->__ctype_b; #elif __sun__ return __ctype_mask; #elif defined(_LIBCPP_MSVCRT) || defined(__MINGW32__) @@ -1033,10 +1116,11 @@ ctype<char>::classic_table() _NOEXCEPT // going to end up dereferencing it later... #elif defined(__EMSCRIPTEN__) return *__ctype_b_loc(); +#elif defined(_NEWLIB_VERSION) + // Newlib has a 257-entry table in ctype_.c, where (char)0 starts at [1]. + return _ctype_ + 1; #elif defined(_AIX) return (const unsigned int *)__lc_ctype_ptr->obj->mask; -#elif defined(__ANDROID__) - return reinterpret_cast<const unsigned char*>(_ctype_) + 1; #else // Platform not supported: abort so the person doing the port knows what to // fix @@ -1046,18 +1130,19 @@ ctype<char>::classic_table() _NOEXCEPT return NULL; #endif } +#endif #if defined(__GLIBC__) const int* ctype<char>::__classic_lower_table() _NOEXCEPT { - return __cloc()->__ctype_tolower; + return _LIBCPP_GET_C_LOCALE->__ctype_tolower; } const int* ctype<char>::__classic_upper_table() _NOEXCEPT { - return __cloc()->__ctype_toupper; + return _LIBCPP_GET_C_LOCALE->__ctype_toupper; } #elif __NetBSD__ const short* @@ -1180,16 +1265,16 @@ ctype_byname<wchar_t>::do_is(mask m, char_type c) const #else bool result = false; wint_t ch = static_cast<wint_t>(c); - if (m & space) result |= (iswspace_l(ch, __l) != 0); - if (m & print) result |= (iswprint_l(ch, __l) != 0); - if (m & cntrl) result |= (iswcntrl_l(ch, __l) != 0); - if (m & upper) result |= (iswupper_l(ch, __l) != 0); - if (m & lower) result |= (iswlower_l(ch, __l) != 0); - if (m & alpha) result |= (iswalpha_l(ch, __l) != 0); - if (m & digit) result |= (iswdigit_l(ch, __l) != 0); - if (m & punct) result |= (iswpunct_l(ch, __l) != 0); - if (m & xdigit) result |= (iswxdigit_l(ch, __l) != 0); - if (m & blank) result |= (iswblank_l(ch, __l) != 0); + if ((m & space) == space) result |= (iswspace_l(ch, __l) != 0); + if ((m & print) == print) result |= (iswprint_l(ch, __l) != 0); + if ((m & cntrl) == cntrl) result |= (iswcntrl_l(ch, __l) != 0); + if ((m & upper) == upper) result |= (iswupper_l(ch, __l) != 0); + if ((m & lower) == lower) result |= (iswlower_l(ch, __l) != 0); + if ((m & alpha) == alpha) result |= (iswalpha_l(ch, __l) != 0); + if ((m & digit) == digit) result |= (iswdigit_l(ch, __l) != 0); + if ((m & punct) == punct) result |= (iswpunct_l(ch, __l) != 0); + if ((m & xdigit) == xdigit) result |= (iswxdigit_l(ch, __l) != 0); + if ((m & blank) == blank) result |= (iswblank_l(ch, __l) != 0); return result; #endif } @@ -1207,22 +1292,32 @@ ctype_byname<wchar_t>::do_is(const char_type* low, const char_type* high, mask* wint_t ch = static_cast<wint_t>(*low); if (iswspace_l(ch, __l)) *vec |= space; +#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT if (iswprint_l(ch, __l)) *vec |= print; +#endif if (iswcntrl_l(ch, __l)) *vec |= cntrl; if (iswupper_l(ch, __l)) *vec |= upper; if (iswlower_l(ch, __l)) *vec |= lower; +#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA if (iswalpha_l(ch, __l)) *vec |= alpha; +#endif if (iswdigit_l(ch, __l)) *vec |= digit; if (iswpunct_l(ch, __l)) *vec |= punct; +#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT if (iswxdigit_l(ch, __l)) *vec |= xdigit; +#endif +#if !defined(__sun__) + if (iswblank_l(ch, __l)) + *vec |= blank; +#endif } } return low; @@ -1238,16 +1333,16 @@ ctype_byname<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* break; #else wint_t ch = static_cast<wint_t>(*low); - if (m & space && iswspace_l(ch, __l)) break; - if (m & print && iswprint_l(ch, __l)) break; - if (m & cntrl && iswcntrl_l(ch, __l)) break; - if (m & upper && iswupper_l(ch, __l)) break; - if (m & lower && iswlower_l(ch, __l)) break; - if (m & alpha && iswalpha_l(ch, __l)) break; - if (m & digit && iswdigit_l(ch, __l)) break; - if (m & punct && iswpunct_l(ch, __l)) break; - if (m & xdigit && iswxdigit_l(ch, __l)) break; - if (m & blank && iswblank_l(ch, __l)) break; + if ((m & space) == space && iswspace_l(ch, __l)) break; + if ((m & print) == print && iswprint_l(ch, __l)) break; + if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l)) break; + if ((m & upper) == upper && iswupper_l(ch, __l)) break; + if ((m & lower) == lower && iswlower_l(ch, __l)) break; + if ((m & alpha) == alpha && iswalpha_l(ch, __l)) break; + if ((m & digit) == digit && iswdigit_l(ch, __l)) break; + if ((m & punct) == punct && iswpunct_l(ch, __l)) break; + if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l)) break; + if ((m & blank) == blank && iswblank_l(ch, __l)) break; #endif } return low; @@ -1263,16 +1358,16 @@ ctype_byname<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type break; #else wint_t ch = static_cast<wint_t>(*low); - if (m & space && iswspace_l(ch, __l)) continue; - if (m & print && iswprint_l(ch, __l)) continue; - if (m & cntrl && iswcntrl_l(ch, __l)) continue; - if (m & upper && iswupper_l(ch, __l)) continue; - if (m & lower && iswlower_l(ch, __l)) continue; - if (m & alpha && iswalpha_l(ch, __l)) continue; - if (m & digit && iswdigit_l(ch, __l)) continue; - if (m & punct && iswpunct_l(ch, __l)) continue; - if (m & xdigit && iswxdigit_l(ch, __l)) continue; - if (m & blank && iswblank_l(ch, __l)) continue; + if ((m & space) == space && iswspace_l(ch, __l)) continue; + if ((m & print) == print && iswprint_l(ch, __l)) continue; + if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l)) continue; + if ((m & upper) == upper && iswupper_l(ch, __l)) continue; + if ((m & lower) == lower && iswlower_l(ch, __l)) continue; + if ((m & alpha) == alpha && iswalpha_l(ch, __l)) continue; + if ((m & digit) == digit && iswdigit_l(ch, __l)) continue; + if ((m & punct) == punct && iswpunct_l(ch, __l)) continue; + if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l)) continue; + if ((m & blank) == blank && iswblank_l(ch, __l)) continue; break; #endif } @@ -1564,7 +1659,7 @@ codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st, frm_nxt = frm; return frm_nxt == frm_end ? ok : partial; } - if (n == 0) + if (n == size_t(-1)) return error; to_nxt += n; if (to_nxt == to_end) @@ -1614,22 +1709,23 @@ codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& st, int codecvt<wchar_t, char, mbstate_t>::do_encoding() const _NOEXCEPT { +#ifndef __CloudABI__ #ifdef _LIBCPP_LOCALE__L_EXTENSIONS - if (mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) == 0) + if (mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) != 0) #else - if (__mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) == 0) + if (__mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) != 0) #endif - { - // stateless encoding + return -1; +#endif + + // stateless encoding #ifdef _LIBCPP_LOCALE__L_EXTENSIONS - if (__l == 0 || MB_CUR_MAX_L(__l) == 1) // there are no known constant length encodings + if (__l == 0 || MB_CUR_MAX_L(__l) == 1) // there are no known constant length encodings #else - if (__l == 0 || __mb_cur_max_l(__l) == 1) // there are no known constant length encodings + if (__l == 0 || __mb_cur_max_l(__l) == 1) // there are no known constant length encodings #endif - return 1; // which take more than 1 char to form a wchar_t - return 0; - } - return -1; + return 1; // which take more than 1 char to form a wchar_t + return 0; } bool diff --git a/contrib/libc++/src/memory.cpp b/contrib/libc++/src/memory.cpp index 8a4eb34811f2..66fb143c6a62 100644 --- a/contrib/libc++/src/memory.cpp +++ b/contrib/libc++/src/memory.cpp @@ -13,24 +13,28 @@ #include "mutex" #include "thread" #endif +#include "support/atomic_support.h" _LIBCPP_BEGIN_NAMESPACE_STD namespace { +// NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively) +// should be sufficient for thread safety. +// See https://llvm.org/bugs/show_bug.cgi?id=22803 template <class T> inline T increment(T& t) _NOEXCEPT { - return __sync_add_and_fetch(&t, 1); + return __libcpp_atomic_add(&t, 1, _AO_Relaxed); } template <class T> inline T decrement(T& t) _NOEXCEPT { - return __sync_add_and_fetch(&t, -1); + return __libcpp_atomic_add(&t, -1, _AO_Acq_Rel); } } // namespace @@ -99,14 +103,13 @@ __shared_weak_count::__release_weak() _NOEXCEPT __shared_weak_count* __shared_weak_count::lock() _NOEXCEPT { - long object_owners = __shared_owners_; + long object_owners = __libcpp_atomic_load(&__shared_owners_); while (object_owners != -1) { - if (__sync_bool_compare_and_swap(&__shared_owners_, - object_owners, - object_owners+1)) + if (__libcpp_atomic_compare_exchange(&__shared_owners_, + &object_owners, + object_owners+1)) return this; - object_owners = __shared_owners_; } return 0; } diff --git a/contrib/libc++/src/mutex.cpp b/contrib/libc++/src/mutex.cpp index e56271d308e6..5f8ba0a08266 100644 --- a/contrib/libc++/src/mutex.cpp +++ b/contrib/libc++/src/mutex.cpp @@ -12,6 +12,7 @@ #include "limits" #include "system_error" #include "cassert" +#include "support/atomic_support.h" _LIBCPP_BEGIN_NAMESPACE_STD #ifndef _LIBCPP_HAS_NO_THREADS @@ -220,6 +221,9 @@ static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t cv = PTHREAD_COND_INITIALIZER; #endif +/// NOTE: Changes to flag are done via relaxed atomic stores +/// even though the accesses are protected by a mutex because threads +/// just entering 'call_once` concurrently read from flag. void __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*)) { @@ -252,11 +256,11 @@ __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*)) try { #endif // _LIBCPP_NO_EXCEPTIONS - flag = 1; + __libcpp_relaxed_store(&flag, 1ul); pthread_mutex_unlock(&mut); func(arg); pthread_mutex_lock(&mut); - flag = ~0ul; + __libcpp_relaxed_store(&flag, ~0ul); pthread_mutex_unlock(&mut); pthread_cond_broadcast(&cv); #ifndef _LIBCPP_NO_EXCEPTIONS @@ -264,7 +268,7 @@ __call_once(volatile unsigned long& flag, void* arg, void(*func)(void*)) catch (...) { pthread_mutex_lock(&mut); - flag = 0ul; + __libcpp_relaxed_store(&flag, 0ul); pthread_mutex_unlock(&mut); pthread_cond_broadcast(&cv); throw; diff --git a/contrib/libc++/src/new.cpp b/contrib/libc++/src/new.cpp index a88d4cc7c249..c28fcb5917cf 100644 --- a/contrib/libc++/src/new.cpp +++ b/contrib/libc++/src/new.cpp @@ -133,9 +133,16 @@ operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS void +operator delete(void* ptr, size_t) _NOEXCEPT +{ + ::operator delete(ptr); +} + +_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS +void operator delete[] (void* ptr) _NOEXCEPT { - ::operator delete (ptr); + ::operator delete(ptr); } _LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS @@ -145,6 +152,13 @@ operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT ::operator delete[](ptr); } +_LIBCPP_WEAK _LIBCPP_NEW_DELETE_VIS +void +operator delete[] (void* ptr, size_t) _NOEXCEPT +{ + ::operator delete[](ptr); +} + #endif // !__GLIBCXX__ namespace std diff --git a/contrib/libc++/src/random.cpp b/contrib/libc++/src/random.cpp index 15ed65b58cf3..4ab424eaa6e5 100644 --- a/contrib/libc++/src/random.cpp +++ b/contrib/libc++/src/random.cpp @@ -7,11 +7,10 @@ // //===----------------------------------------------------------------------===// -#if defined(_WIN32) +#if defined(_LIBCPP_USING_WIN32_RANDOM) // Must be defined before including stdlib.h to enable rand_s(). #define _CRT_RAND_S -#include <stdio.h> -#endif // defined(_WIN32) +#endif // defined(_LIBCPP_USING_WIN32_RANDOM) #include "random" #include "system_error" @@ -19,21 +18,27 @@ #if defined(__sun__) #define rename solaris_headers_are_broken #endif // defined(__sun__) -#if !defined(_WIN32) + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> + +#if defined(_LIBCPP_USING_DEV_RANDOM) #include <fcntl.h> #include <unistd.h> -#endif // !defined(_WIN32) -#include <errno.h> -#if defined(_LIBCPP_USING_NACL_RANDOM) +#elif defined(_LIBCPP_USING_NACL_RANDOM) #include <nacl/nacl_random.h> -#endif // defined(_LIBCPP_USING_NACL_RANDOM) +#endif + _LIBCPP_BEGIN_NAMESPACE_STD -#if defined(_WIN32) +#if defined(_LIBCPP_USING_ARC4_RANDOM) -random_device::random_device(const string&) +random_device::random_device(const string& __token) { + if (__token != "/dev/urandom") + __throw_system_error(ENOENT, ("random device not supported " + __token).c_str()); } random_device::~random_device() @@ -43,10 +48,43 @@ random_device::~random_device() unsigned random_device::operator()() { + return arc4random(); +} + +#elif defined(_LIBCPP_USING_DEV_RANDOM) + +random_device::random_device(const string& __token) + : __f_(open(__token.c_str(), O_RDONLY)) +{ + if (__f_ < 0) + __throw_system_error(errno, ("random_device failed to open " + __token).c_str()); +} + +random_device::~random_device() +{ + close(__f_); +} + +unsigned +random_device::operator()() +{ unsigned r; - errno_t err = rand_s(&r); - if (err) - __throw_system_error(err, "random_device rand_s failed."); + size_t n = sizeof(r); + char* p = reinterpret_cast<char*>(&r); + while (n > 0) + { + ssize_t s = read(__f_, p, n); + if (s == 0) + __throw_system_error(ENODATA, "random_device got EOF"); + if (s == -1) + { + if (errno != EINTR) + __throw_system_error(errno, "random_device got an unexpected error"); + continue; + } + n -= static_cast<size_t>(s); + p += static_cast<size_t>(s); + } return r; } @@ -70,7 +108,6 @@ random_device::operator()() { unsigned r; size_t n = sizeof(r); - char* p = reinterpret_cast<char*>(&r); size_t bytes_written; int error = nacl_secure_random(&r, n, &bytes_written); if (error != 0) @@ -80,44 +117,31 @@ random_device::operator()() return r; } -#else // !defined(_WIN32) && !defined(_LIBCPP_USING_NACL_RANDOM) +#elif defined(_LIBCPP_USING_WIN32_RANDOM) random_device::random_device(const string& __token) - : __f_(open(__token.c_str(), O_RDONLY)) { - if (__f_ < 0) - __throw_system_error(errno, ("random_device failed to open " + __token).c_str()); + if (__token != "/dev/urandom") + __throw_system_error(ENOENT, ("random device not supported " + __token).c_str()); } random_device::~random_device() { - close(__f_); } unsigned random_device::operator()() { unsigned r; - size_t n = sizeof(r); - char* p = reinterpret_cast<char*>(&r); - while (n > 0) - { - ssize_t s = read(__f_, p, n); - if (s == 0) - __throw_system_error(ENODATA, "random_device got EOF"); - if (s == -1) - { - if (errno != EINTR) - __throw_system_error(errno, "random_device got an unexpected error"); - continue; - } - n -= static_cast<size_t>(s); - p += static_cast<size_t>(s); - } + errno_t err = rand_s(&r); + if (err) + __throw_system_error(err, "random_device rand_s failed."); return r; } -#endif // defined(_WIN32) || defined(_LIBCPP_USING_NACL_RANDOM) +#else +#error "Random device not implemented for this architecture" +#endif double random_device::entropy() const _NOEXCEPT diff --git a/contrib/libc++/src/shared_mutex.cpp b/contrib/libc++/src/shared_mutex.cpp index 2b78c1feb9f5..874aceb1b03a 100644 --- a/contrib/libc++/src/shared_mutex.cpp +++ b/contrib/libc++/src/shared_mutex.cpp @@ -15,7 +15,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD -shared_timed_mutex::shared_timed_mutex() +// Shared Mutex Base +__shared_mutex_base::__shared_mutex_base() : __state_(0) { } @@ -23,7 +24,7 @@ shared_timed_mutex::shared_timed_mutex() // Exclusive ownership void -shared_timed_mutex::lock() +__shared_mutex_base::lock() { unique_lock<mutex> lk(__mut_); while (__state_ & __write_entered_) @@ -34,7 +35,7 @@ shared_timed_mutex::lock() } bool -shared_timed_mutex::try_lock() +__shared_mutex_base::try_lock() { unique_lock<mutex> lk(__mut_); if (__state_ == 0) @@ -46,7 +47,7 @@ shared_timed_mutex::try_lock() } void -shared_timed_mutex::unlock() +__shared_mutex_base::unlock() { lock_guard<mutex> _(__mut_); __state_ = 0; @@ -56,7 +57,7 @@ shared_timed_mutex::unlock() // Shared ownership void -shared_timed_mutex::lock_shared() +__shared_mutex_base::lock_shared() { unique_lock<mutex> lk(__mut_); while ((__state_ & __write_entered_) || (__state_ & __n_readers_) == __n_readers_) @@ -67,7 +68,7 @@ shared_timed_mutex::lock_shared() } bool -shared_timed_mutex::try_lock_shared() +__shared_mutex_base::try_lock_shared() { unique_lock<mutex> lk(__mut_); unsigned num_readers = __state_ & __n_readers_; @@ -82,7 +83,7 @@ shared_timed_mutex::try_lock_shared() } void -shared_timed_mutex::unlock_shared() +__shared_mutex_base::unlock_shared() { lock_guard<mutex> _(__mut_); unsigned num_readers = (__state_ & __n_readers_) - 1; @@ -101,6 +102,16 @@ shared_timed_mutex::unlock_shared() } +// Shared Timed Mutex +// These routines are here for ABI stability +shared_timed_mutex::shared_timed_mutex() : __base() {} +void shared_timed_mutex::lock() { return __base.lock(); } +bool shared_timed_mutex::try_lock() { return __base.try_lock(); } +void shared_timed_mutex::unlock() { return __base.unlock(); } +void shared_timed_mutex::lock_shared() { return __base.lock_shared(); } +bool shared_timed_mutex::try_lock_shared() { return __base.try_lock_shared(); } +void shared_timed_mutex::unlock_shared() { return __base.unlock_shared(); } + _LIBCPP_END_NAMESPACE_STD #endif // !_LIBCPP_HAS_NO_THREADS diff --git a/contrib/libc++/src/string.cpp b/contrib/libc++/src/string.cpp index febc53209972..d3f29df639f4 100644 --- a/contrib/libc++/src/string.cpp +++ b/contrib/libc++/src/string.cpp @@ -39,7 +39,7 @@ void throw_helper( const string& msg ) #ifndef _LIBCPP_NO_EXCEPTIONS throw T( msg ); #else - printf("%s\n", msg.c_str()); + fprintf(stderr, "%s\n", msg.c_str()); abort(); #endif } diff --git a/contrib/libc++/src/support/atomic_support.h b/contrib/libc++/src/support/atomic_support.h new file mode 100644 index 000000000000..e738a5154cd3 --- /dev/null +++ b/contrib/libc++/src/support/atomic_support.h @@ -0,0 +1,142 @@ +#ifndef ATOMIC_SUPPORT_H +#define ATOMIC_SUPPORT_H + +#include "__config" +#include "memory" // for __libcpp_relaxed_load + +#if defined(__clang__) && __has_builtin(__atomic_load_n) \ + && __has_builtin(__atomic_store_n) \ + && __has_builtin(__atomic_add_fetch) \ + && __has_builtin(__atomic_compare_exchange_n) \ + && defined(__ATOMIC_RELAXED) \ + && defined(__ATOMIC_CONSUME) \ + && defined(__ATOMIC_ACQUIRE) \ + && defined(__ATOMIC_RELEASE) \ + && defined(__ATOMIC_ACQ_REL) \ + && defined(__ATOMIC_SEQ_CST) +# define _LIBCPP_HAS_ATOMIC_BUILTINS +#elif !defined(__clang__) && defined(_GNUC_VER) && _GNUC_VER >= 407 +# define _LIBCPP_HAS_ATOMIC_BUILTINS +#endif + +#if !defined(_LIBCPP_HAS_ATOMIC_BUILTINS) && !defined(_LIBCPP_HAS_NO_THREADS) +# if defined(_MSC_VER) && !defined(__clang__) + _LIBCPP_WARNING("Building libc++ without __atomic builtins is unsupported") +# else +# warning Building libc++ without __atomic builtins is unsupported +# endif +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +namespace { + +#if defined(_LIBCPP_HAS_ATOMIC_BUILTINS) && !defined(_LIBCPP_HAS_NO_THREADS) + +enum __libcpp_atomic_order { + _AO_Relaxed = __ATOMIC_RELAXED, + _AO_Consume = __ATOMIC_CONSUME, + _AO_Aquire = __ATOMIC_ACQUIRE, + _AO_Release = __ATOMIC_RELEASE, + _AO_Acq_Rel = __ATOMIC_ACQ_REL, + _AO_Seq = __ATOMIC_SEQ_CST +}; + +template <class _ValueType, class _FromType> +inline _LIBCPP_INLINE_VISIBILITY +void __libcpp_atomic_store(_ValueType* __dest, _FromType __val, + int __order = _AO_Seq) +{ + __atomic_store_n(__dest, __val, __order); +} + +template <class _ValueType, class _FromType> +inline _LIBCPP_INLINE_VISIBILITY +void __libcpp_relaxed_store(_ValueType* __dest, _FromType __val) +{ + __atomic_store_n(__dest, __val, _AO_Relaxed); +} + +template <class _ValueType> +inline _LIBCPP_INLINE_VISIBILITY +_ValueType __libcpp_atomic_load(_ValueType const* __val, + int __order = _AO_Seq) +{ + return __atomic_load_n(__val, __order); +} + +template <class _ValueType, class _AddType> +inline _LIBCPP_INLINE_VISIBILITY +_ValueType __libcpp_atomic_add(_ValueType* __val, _AddType __a, + int __order = _AO_Seq) +{ + return __atomic_add_fetch(__val, __a, __order); +} + +template <class _ValueType> +inline _LIBCPP_INLINE_VISIBILITY +bool __libcpp_atomic_compare_exchange(_ValueType* __val, + _ValueType* __expected, _ValueType __after, + int __success_order = _AO_Seq, + int __fail_order = _AO_Seq) +{ + return __atomic_compare_exchange_n(__val, __expected, __after, true, + __success_order, __fail_order); +} + +#else // _LIBCPP_HAS_NO_THREADS + +enum __libcpp_atomic_order { + _AO_Relaxed, + _AO_Consume, + _AO_Acquire, + _AO_Release, + _AO_Acq_Rel, + _AO_Seq +}; + +template <class _ValueType, class _FromType> +inline _LIBCPP_INLINE_VISIBILITY +void __libcpp_atomic_store(_ValueType* __dest, _FromType __val, + int = 0) +{ + *__dest = __val; +} + +template <class _ValueType> +inline _LIBCPP_INLINE_VISIBILITY +_ValueType __libcpp_atomic_load(_ValueType const* __val, + int = 0) +{ + return *__val; +} + +template <class _ValueType, class _AddType> +inline _LIBCPP_INLINE_VISIBILITY +_ValueType __libcpp_atomic_add(_ValueType* __val, _AddType __a, + int = 0) +{ + return *__val += __a; +} + +template <class _ValueType> +inline _LIBCPP_INLINE_VISIBILITY +bool __libcpp_atomic_compare_exchange(_ValueType* __val, + _ValueType* __expected, _ValueType __after, + int = 0, int = 0) +{ + if (*__val == *__expected) { + *__val = __after; + return true; + } + *__expected = *__val; + return false; +} + +#endif // _LIBCPP_HAS_NO_THREADS + +} // end namespace + +_LIBCPP_END_NAMESPACE_STD + +#endif // ATOMIC_SUPPORT_H diff --git a/contrib/libc++/src/system_error.cpp b/contrib/libc++/src/system_error.cpp index 9c8adc4f323e..18f668f071cd 100644 --- a/contrib/libc++/src/system_error.cpp +++ b/contrib/libc++/src/system_error.cpp @@ -7,11 +7,14 @@ // //===----------------------------------------------------------------------===// -#define _LIBCPP_BUILDING_SYSTEM_ERROR #include "__config" + +#define _LIBCPP_BUILDING_SYSTEM_ERROR #include "system_error" -#include "string" + +#include "config_elast.h" #include "cstring" +#include "string" _LIBCPP_BEGIN_NAMESPACE_STD @@ -149,7 +152,7 @@ system_error::__init(const error_code& ec, string what_arg) what_arg += ": "; what_arg += ec.message(); } - return _VSTD::move(what_arg); + return what_arg; } system_error::system_error(error_code ec, const string& what_arg) diff --git a/contrib/libc++/src/thread.cpp b/contrib/libc++/src/thread.cpp index 6aad558abaad..bd27f2878383 100644 --- a/contrib/libc++/src/thread.cpp +++ b/contrib/libc++/src/thread.cpp @@ -17,9 +17,9 @@ #include "limits" #include <sys/types.h> #if !defined(_WIN32) -# if !defined(__sun__) && !defined(__linux__) && !defined(_AIX) && !defined(__native_client__) +# if !defined(__sun__) && !defined(__linux__) && !defined(_AIX) && !defined(__native_client__) && !defined(__CloudABI__) # include <sys/sysctl.h> -# endif // !defined(__sun__) && !defined(__linux__) && !defined(_AIX) && !defined(__native_client__) +# endif // !defined(__sun__) && !defined(__linux__) && !defined(_AIX) && !defined(__native_client__) && !defined(__CloudABI__) # include <unistd.h> #endif // !_WIN32 diff --git a/lib/libc++/Makefile b/lib/libc++/Makefile index 469ee472f500..f9bbf7e89355 100644 --- a/lib/libc++/Makefile +++ b/lib/libc++/Makefile @@ -81,7 +81,7 @@ STD_HEADERS= __bit_reference\ __std_stream\ __tree\ __tuple\ - __tuple_03\ + __undef___deallocate\ __undef_min_max\ algorithm\ array\ @@ -178,9 +178,14 @@ STD+= ${LIBCXXRTDIR}/${hdr} STDDIR= ${CXXINCLUDEDIR} EXP_HEADERS= __config\ + algorithm\ + chrono\ dynarray\ optional\ + ratio\ string_view\ + system_error\ + tuple\ type_traits\ utility diff --git a/tools/build/mk/OptionalObsoleteFiles.inc b/tools/build/mk/OptionalObsoleteFiles.inc index 4c650d0edc22..89b1521c865d 100644 --- a/tools/build/mk/OptionalObsoleteFiles.inc +++ b/tools/build/mk/OptionalObsoleteFiles.inc @@ -3811,7 +3811,7 @@ OLD_FILES+=usr/include/c++/v1/__sso_allocator OLD_FILES+=usr/include/c++/v1/__std_stream OLD_FILES+=usr/include/c++/v1/__tree OLD_FILES+=usr/include/c++/v1/__tuple -OLD_FILES+=usr/include/c++/v1/__tuple_03 +OLD_FILES+=usr/include/c++/v1/__undef___deallocate OLD_FILES+=usr/include/c++/v1/__undef_min_max OLD_FILES+=usr/include/c++/v1/algorithm OLD_FILES+=usr/include/c++/v1/array @@ -3850,9 +3850,14 @@ OLD_FILES+=usr/include/c++/v1/cxxabi.h OLD_FILES+=usr/include/c++/v1/deque OLD_FILES+=usr/include/c++/v1/exception OLD_FILES+=usr/include/c++/v1/experimental/__config +OLD_FILES+=usr/include/c++/v1/experimental/chrono +OLD_FILES+=usr/include/c++/v1/experimental/dynarray OLD_FILES+=usr/include/c++/v1/experimental/dynarray OLD_FILES+=usr/include/c++/v1/experimental/optional +OLD_FILES+=usr/include/c++/v1/experimental/ratio OLD_FILES+=usr/include/c++/v1/experimental/string_view +OLD_FILES+=usr/include/c++/v1/experimental/system_error +OLD_FILES+=usr/include/c++/v1/experimental/tuple OLD_FILES+=usr/include/c++/v1/experimental/type_traits OLD_FILES+=usr/include/c++/v1/experimental/utility OLD_FILES+=usr/include/c++/v1/ext/__hash |