diff options
| author | dim <dim@FreeBSD.org> | 2013-04-27 22:47:52 +0000 |
|---|---|---|
| committer | dim <dim@FreeBSD.org> | 2013-04-27 22:47:52 +0000 |
| commit | 815a6cc1e325a4e8596b91756039a7d699471b11 (patch) | |
| tree | e5a6a26d0973c6968273f6fabb61cb3d624be555 /contrib/libc++ | |
| parent | 1497a98f71419ff66d08ad2b8c90530e65521ac2 (diff) | |
| download | FreeBSD-src-815a6cc1e325a4e8596b91756039a7d699471b11.zip FreeBSD-src-815a6cc1e325a4e8596b91756039a7d699471b11.tar.gz | |
Merge libc++ trunk r180598. Contains several minor cleanups and bug
fixes, no major changes.
MFC after: 2 weeks
Diffstat (limited to 'contrib/libc++')
83 files changed, 1601 insertions, 1090 deletions
diff --git a/contrib/libc++/CREDITS.TXT b/contrib/libc++/CREDITS.TXT index f2ca38f..c34e219 100644 --- a/contrib/libc++/CREDITS.TXT +++ b/contrib/libc++/CREDITS.TXT @@ -8,69 +8,88 @@ beautification by scripts. The fields are: name (N), email (E), web-address (W), PGP key ID and fingerprint (P), description (D), and snail-mail address (S). -N: Howard Hinnant -E: hhinnant@apple.com -D: Architect and primary author of libc++ +N: Saleem Abdulrasool +E: compnerd@compnerd.org +D: Minor patches and Linux fixes. + +N: Dimitry Andric +E: dimitry@andric.com +D: Visibility fixes, minor FreeBSD portability patches. + +N: Holger Arnold +E: holgerar@gmail.com +D: Minor fix. + +N: Ruben Van Boxem +E: vanboxem dot ruben at gmail dot com +D: Initial Windows patches. + +N: David Chisnall +E: theraven at theravensnest dot org +D: FreeBSD and Solaris ports, libcxxrt support, some atomics work. N: Marshall Clow E: mclow.lists@gmail.com E: marshall@idio.com D: Minor patches and bug fixes. -N: Bjorn Reese -E: breese@users.sourceforge.net -D: Initial regex prototype +N: Google Inc. +D: Copyright owner and contributor of the CityHash algorithm -N: David Chisnall -E: theraven at theravensnest dot org -D: FreeBSD and Solaris ports, libcxxrt support, some atomics work. +N: Howard Hinnant +E: hhinnant@apple.com +D: Architect and primary author of libc++ -N: Ruben Van Boxem -E: vanboxem dot ruben at gmail dot com -D: Initial Windows patches. +N: Hyeon-bin Jeong +E: tuhertz@gmail.com +D: Minor patches and bug fixes. + +N: Argyrios Kyrtzidis +E: kyrtzidis@apple.com +D: Bug fixes. + +N: Michel Morin +E: mimomorin@gmail.com +D: Minor patches to is_convertible. + +N: Andrew Morrow +E: andrew.c.morrow@gmail.com +D: Minor patches and Linux fixes. N: Arvid Picciani E: aep at exys dot org D: Minor patches and musl port. -N: Craig Silverstein -E: csilvers@google.com -D: Implemented Cityhash as the string hash function on 64-bit machines - -N: Google Inc. -D: Copyright owner and contributor of the CityHash algorithm - -N: Jeffrey Yasskin -E: jyasskin@gmail.com -E: jyasskin@google.com -D: Linux fixes. +N: Bjorn Reese +E: breese@users.sourceforge.net +D: Initial regex prototype N: Jonathan Sauer D: Minor patches, mostly related to constexpr +N: Craig Silverstein +E: csilvers@google.com +D: Implemented Cityhash as the string hash function on 64-bit machines + N: Richard Smith D: Minor patches. -N: Andrew Morrow -E: andrew.c.morrow@gmail.com -D: Minor patches and Linux fixes. +N: Michael van der Westhuizen +E: r1mikey at gmail dot com -N: Hyeon-bin Jeong -E: tuhertz@gmail.com -D: Minor patches and bug fixes. +N: Klaas de Vries +E: klaas at klaasgaaf dot nl +D: Minor bug fix. -N: Michel Morin -E: mimomorin@gmail.com -D: Minor patches to is_convertible. - -N: Dimitry Andric -E: dimitry@andric.com -D: Visibility fixes, minor FreeBSD portability patches. +N: Zhang Xiongpang +E: zhangxiongpang@gmail.com +D: Minor patches and bug fixes. -N: Holger Arnold -E: holgerar@gmail.com -D: Minor fix. +N: Jeffrey Yasskin +E: jyasskin@gmail.com +E: jyasskin@google.com +D: Linux fixes. -N: Argyrios Kyrtzidis -E: kyrtzidis@apple.com -D: Bug fixes. +N: Bruce Mitchener, Jr. +E: bruce.mitchener@gmail.com +D: Emscripten-related changes. diff --git a/contrib/libc++/LICENSE.TXT b/contrib/libc++/LICENSE.TXT index 14645d0..5ed8ec2 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-2012 by the contributors listed in CREDITS.TXT +Copyright (c) 2009-2013 by the contributors listed in CREDITS.TXT All rights reserved. @@ -55,7 +55,7 @@ SOFTWARE. ============================================================================== -Copyright (c) 2009-2012 by the contributors listed in CREDITS.TXT +Copyright (c) 2009-2013 by the contributors listed in CREDITS.TXT Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/contrib/libc++/include/__bit_reference b/contrib/libc++/include/__bit_reference index 8180295..1621deb 100644 --- a/contrib/libc++/include/__bit_reference +++ b/contrib/libc++/include/__bit_reference @@ -81,6 +81,16 @@ class __bit_reference<_Cp, false> { }; +template <class _Cp> +_LIBCPP_INLINE_VISIBILITY inline +void +swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) _NOEXCEPT +{ + bool __t = __x; + __x = __y; + __y = __t; +} + template <class _Cp, class _Dp> _LIBCPP_INLINE_VISIBILITY inline void diff --git a/contrib/libc++/include/__config b/contrib/libc++/include/__config index 8617b86..959390d 100644 --- a/contrib/libc++/include/__config +++ b/contrib/libc++/include/__config @@ -11,7 +11,7 @@ #ifndef _LIBCPP_CONFIG #define _LIBCPP_CONFIG -#if !_MSC_VER // explicit macro necessary because it is only defined below in this file +#ifndef _MSC_VER // explicit macro necessary because it is only defined below in this file #pragma GCC system_header #endif @@ -96,24 +96,27 @@ # endif #endif // !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN) -#if _WIN32 +#ifdef _WIN32 // only really useful for a DLL #ifdef _LIBCPP_DLL // this should be a compiler builtin define ideally... # ifdef cxx_EXPORTS # define _LIBCPP_HIDDEN -# define _LIBCPP_VISIBLE __declspec(dllexport) +# define _LIBCPP_FUNC_VIS __declspec(dllexport) +# define _LIBCPP_TYPE_VIS __declspec(dllexport) # else # define _LIBCPP_HIDDEN -# define _LIBCPP_VISIBLE __declspec(dllimport) +# define _LIBCPP_FUNC_VIS __declspec(dllimport) +# define _LIBCPP_TYPE_VIS __declspec(dllimport) # endif #else # define _LIBCPP_HIDDEN -# define _LIBCPP_VISIBLE +# define _LIBCPP_FUNC_VIS +# define _LIBCPP_TYPE_VIS #endif #ifndef _LIBCPP_INLINE_VISIBILITY -# if _MSC_VER +# ifdef _MSC_VER # define _LIBCPP_INLINE_VISIBILITY __forceinline # else // MinGW GCC and Clang # define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__always_inline__)) @@ -121,11 +124,11 @@ #endif #ifndef _LIBCPP_EXCEPTION_ABI -#define _LIBCPP_EXCEPTION_ABI _LIBCPP_VISIBLE +#define _LIBCPP_EXCEPTION_ABI _LIBCPP_TYPE_VIS #endif #ifndef _LIBCPP_ALWAYS_INLINE -# if _MSC_VER +# ifdef _MSC_VER # define _LIBCPP_ALWAYS_INLINE __forceinline # endif #endif @@ -136,8 +139,16 @@ #define _LIBCPP_HIDDEN __attribute__ ((__visibility__("hidden"))) #endif -#ifndef _LIBCPP_VISIBLE -#define _LIBCPP_VISIBLE __attribute__ ((__visibility__("default"))) +#ifndef _LIBCPP_FUNC_VIS +#define _LIBCPP_FUNC_VIS __attribute__ ((__visibility__("default"))) +#endif + +#ifndef _LIBCPP_TYPE_VIS +# if __has_attribute(type_visibility) +# define _LIBCPP_TYPE_VIS __attribute__ ((__type_visibility__("default"))) +# else +# define _LIBCPP_TYPE_VIS __attribute__ ((__visibility__("default"))) +# endif #endif #ifndef _LIBCPP_INLINE_VISIBILITY @@ -145,7 +156,7 @@ #endif #ifndef _LIBCPP_EXCEPTION_ABI -#define _LIBCPP_EXCEPTION_ABI __attribute__ ((__visibility__("default"))) +#define _LIBCPP_EXCEPTION_ABI _LIBCPP_TYPE_VIS #endif #ifndef _LIBCPP_CANTTHROW @@ -261,7 +272,7 @@ typedef __char32_t char32_t; #define _LIBCPP_HAS_NO_CONSTEXPR #endif -#if __FreeBSD__ && (__ISO_C_VISIBLE >= 2011 || __cplusplus >= 201103L) +#if defined(__FreeBSD__) && (__ISO_C_VISIBLE >= 2011 || __cplusplus >= 201103L) #define _LIBCPP_HAS_QUICK_EXIT #define _LIBCPP_HAS_C11_FEATURES #endif @@ -424,7 +435,7 @@ template <unsigned> struct __static_assert_check {}; #endif #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS -#define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_VISIBLE x { enum __lx +#define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_TYPE_VIS x { enum __lx #define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \ __lx __v_; \ _LIBCPP_ALWAYS_INLINE x(__lx __v) : __v_(__v) {} \ @@ -432,7 +443,7 @@ template <unsigned> struct __static_assert_check {}; _LIBCPP_ALWAYS_INLINE operator int() const {return __v_;} \ }; #else // _LIBCPP_HAS_NO_STRONG_ENUMS -#define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_VISIBLE x +#define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_TYPE_VIS x #define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) #endif // _LIBCPP_HAS_NO_STRONG_ENUMS @@ -440,18 +451,18 @@ template <unsigned> struct __static_assert_check {}; #define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__; #endif -#if __APPLE__ || __FreeBSD__ || _WIN32 || __sun__ +#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_WIN32) || defined(__sun__) #define _LIBCPP_LOCALE__L_EXTENSIONS 1 #endif -#if __FreeBSD__ +#ifdef __FreeBSD__ #define _DECLARE_C99_LDBL_MATH 1 #endif -#if __APPLE__ || __FreeBSD__ +#if defined(__APPLE__) || defined(__FreeBSD__) #define _LIBCPP_HAS_DEFAULTRUNELOCALE #endif -#if __APPLE__ || __FreeBSD__ || __sun__ +#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__) #define _LIBCPP_WCTYPE_IS_MASK #endif diff --git a/contrib/libc++/include/__debug b/contrib/libc++/include/__debug index 4a0e3ce..0d631bf 100644 --- a/contrib/libc++/include/__debug +++ b/contrib/libc++/include/__debug @@ -16,7 +16,9 @@ # include <cstdlib> # include <cstdio> # include <cstddef> -# define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (_VSTD::printf("%s\n", m), _VSTD::abort())) +# ifndef _LIBCPP_ASSERT +# define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (_VSTD::printf("%s\n", m), _VSTD::abort())) +# endif #endif @@ -24,9 +26,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD -struct _LIBCPP_VISIBLE __c_node; +struct _LIBCPP_TYPE_VIS __c_node; -struct _LIBCPP_VISIBLE __i_node +struct _LIBCPP_TYPE_VIS __i_node { void* __i_; __i_node* __next_; @@ -40,7 +42,7 @@ struct _LIBCPP_VISIBLE __i_node ~__i_node(); }; -struct _LIBCPP_VISIBLE __c_node +struct _LIBCPP_TYPE_VIS __c_node { void* __c_; __c_node* __next_; @@ -117,7 +119,7 @@ _C_node<_Cont>::__subscriptable(const void* __i, ptrdiff_t __n) const return _Cp->__subscriptable(__j, __n); } -class _LIBCPP_VISIBLE __libcpp_db +class _LIBCPP_TYPE_VIS __libcpp_db { __c_node** __cbeg_; __c_node** __cend_; @@ -176,11 +178,11 @@ private: _LIBCPP_HIDDEN __i_node* __find_iterator(const void* __i) const; - friend _LIBCPP_VISIBLE __libcpp_db* __get_db(); + friend _LIBCPP_FUNC_VIS __libcpp_db* __get_db(); }; -_LIBCPP_VISIBLE __libcpp_db* __get_db(); -_LIBCPP_VISIBLE const __libcpp_db* __get_const_db(); +_LIBCPP_FUNC_VIS __libcpp_db* __get_db(); +_LIBCPP_FUNC_VIS const __libcpp_db* __get_const_db(); _LIBCPP_END_NAMESPACE_STD diff --git a/contrib/libc++/include/__functional_03 b/contrib/libc++/include/__functional_03 index 3a5397d..b52d692 100644 --- a/contrib/libc++/include/__functional_03 +++ b/contrib/libc++/include/__functional_03 @@ -203,7 +203,7 @@ class _LIBCPP_EXCEPTION_ABI bad_function_call { }; -template<class _Fp> class _LIBCPP_VISIBLE function; // undefined +template<class _Fp> class _LIBCPP_TYPE_VIS function; // undefined namespace __function { @@ -644,7 +644,7 @@ __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::target_type() const } // __function template<class _Rp> -class _LIBCPP_VISIBLE function<_Rp()> +class _LIBCPP_TYPE_VIS function<_Rp()> { typedef __function::__base<_Rp()> __base; aligned_storage<3*sizeof(void*)>::type __buf_; @@ -928,7 +928,7 @@ function<_Rp()>::target() const #endif // _LIBCPP_NO_RTTI template<class _Rp, class _A0> -class _LIBCPP_VISIBLE function<_Rp(_A0)> +class _LIBCPP_TYPE_VIS function<_Rp(_A0)> : public unary_function<_A0, _Rp> { typedef __function::__base<_Rp(_A0)> __base; @@ -1230,7 +1230,7 @@ function<_Rp(_A0)>::target() const #endif // _LIBCPP_NO_RTTI template<class _Rp, class _A0, class _A1> -class _LIBCPP_VISIBLE function<_Rp(_A0, _A1)> +class _LIBCPP_TYPE_VIS function<_Rp(_A0, _A1)> : public binary_function<_A0, _A1, _Rp> { typedef __function::__base<_Rp(_A0, _A1)> __base; @@ -1532,7 +1532,7 @@ function<_Rp(_A0, _A1)>::target() const #endif // _LIBCPP_NO_RTTI template<class _Rp, class _A0, class _A1, class _A2> -class _LIBCPP_VISIBLE function<_Rp(_A0, _A1, _A2)> +class _LIBCPP_TYPE_VIS function<_Rp(_A0, _A1, _A2)> { typedef __function::__base<_Rp(_A0, _A1, _A2)> __base; aligned_storage<3*sizeof(void*)>::type __buf_; @@ -1860,11 +1860,11 @@ swap(function<_Fp>& __x, function<_Fp>& __y) {return __x.swap(__y);} template<class _Tp> struct __is_bind_expression : public false_type {}; -template<class _Tp> struct _LIBCPP_VISIBLE is_bind_expression +template<class _Tp> struct _LIBCPP_TYPE_VIS is_bind_expression : public __is_bind_expression<typename remove_cv<_Tp>::type> {}; template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {}; -template<class _Tp> struct _LIBCPP_VISIBLE is_placeholder +template<class _Tp> struct _LIBCPP_TYPE_VIS is_placeholder : public __is_placeholder<typename remove_cv<_Tp>::type> {}; namespace placeholders diff --git a/contrib/libc++/include/__functional_base b/contrib/libc++/include/__functional_base index 2385459..40a63a8 100644 --- a/contrib/libc++/include/__functional_base +++ b/contrib/libc++/include/__functional_base @@ -23,21 +23,21 @@ _LIBCPP_BEGIN_NAMESPACE_STD template <class _Arg, class _Result> -struct _LIBCPP_VISIBLE unary_function +struct _LIBCPP_TYPE_VIS unary_function { typedef _Arg argument_type; typedef _Result result_type; }; template <class _Arg1, class _Arg2, class _Result> -struct _LIBCPP_VISIBLE binary_function +struct _LIBCPP_TYPE_VIS binary_function { typedef _Arg1 first_argument_type; typedef _Arg2 second_argument_type; typedef _Result result_type; }; -template <class _Tp> struct _LIBCPP_VISIBLE hash; +template <class _Tp> struct _LIBCPP_TYPE_VIS hash; template <class _Tp> struct __has_result_type @@ -51,7 +51,7 @@ public: }; template <class _Tp> -struct _LIBCPP_VISIBLE less : binary_function<_Tp, _Tp, bool> +struct _LIBCPP_TYPE_VIS less : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x < __y;} @@ -348,7 +348,7 @@ struct __invoke_return }; template <class _Tp> -class _LIBCPP_VISIBLE reference_wrapper +class _LIBCPP_TYPE_VIS reference_wrapper : public __weak_result_type<_Tp> { public: diff --git a/contrib/libc++/include/__functional_base_03 b/contrib/libc++/include/__functional_base_03 index a1005bf..11165a9 100644 --- a/contrib/libc++/include/__functional_base_03 +++ b/contrib/libc++/include/__functional_base_03 @@ -996,7 +996,7 @@ struct __invoke_return2 }; template <class _Tp> -class _LIBCPP_VISIBLE reference_wrapper +class _LIBCPP_TYPE_VIS reference_wrapper : public __weak_result_type<_Tp> { public: diff --git a/contrib/libc++/include/__hash_table b/contrib/libc++/include/__hash_table index ba04b3e..6f6050d 100644 --- a/contrib/libc++/include/__hash_table +++ b/contrib/libc++/include/__hash_table @@ -26,7 +26,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD -_LIBCPP_VISIBLE +_LIBCPP_FUNC_VIS size_t __next_prime(size_t __n); template <class _NodePtr> @@ -80,14 +80,14 @@ __next_pow2(size_t __n) } template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table; -template <class _ConstNodePtr> class _LIBCPP_VISIBLE __hash_const_iterator; -template <class _HashIterator> class _LIBCPP_VISIBLE __hash_map_iterator; -template <class _HashIterator> class _LIBCPP_VISIBLE __hash_map_const_iterator; +template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS __hash_const_iterator; +template <class _HashIterator> class _LIBCPP_TYPE_VIS __hash_map_iterator; +template <class _HashIterator> class _LIBCPP_TYPE_VIS __hash_map_const_iterator; template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> - class _LIBCPP_VISIBLE unordered_map; + class _LIBCPP_TYPE_VIS unordered_map; template <class _NodePtr> -class _LIBCPP_VISIBLE __hash_iterator +class _LIBCPP_TYPE_VIS __hash_iterator { typedef _NodePtr __node_pointer; @@ -142,14 +142,14 @@ private: {} template <class, class, class, class> friend class __hash_table; - template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator; - template <class> friend class _LIBCPP_VISIBLE __hash_map_iterator; - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_map; - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap; + template <class> friend class _LIBCPP_TYPE_VIS __hash_const_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __hash_map_iterator; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_map; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_multimap; }; template <class _ConstNodePtr> -class _LIBCPP_VISIBLE __hash_const_iterator +class _LIBCPP_TYPE_VIS __hash_const_iterator { typedef _ConstNodePtr __node_pointer; @@ -220,15 +220,15 @@ private: {} template <class, class, class, class> friend class __hash_table; - template <class> friend class _LIBCPP_VISIBLE __hash_map_const_iterator; - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_map; - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap; + template <class> friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_map; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_multimap; }; -template <class _ConstNodePtr> class _LIBCPP_VISIBLE __hash_const_local_iterator; +template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS __hash_const_local_iterator; template <class _NodePtr> -class _LIBCPP_VISIBLE __hash_local_iterator +class _LIBCPP_TYPE_VIS __hash_local_iterator { typedef _NodePtr __node_pointer; @@ -294,12 +294,12 @@ private: } template <class, class, class, class> friend class __hash_table; - template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator; - template <class> friend class _LIBCPP_VISIBLE __hash_map_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __hash_map_iterator; }; template <class _ConstNodePtr> -class _LIBCPP_VISIBLE __hash_const_local_iterator +class _LIBCPP_TYPE_VIS __hash_const_local_iterator { typedef _ConstNodePtr __node_pointer; @@ -384,7 +384,7 @@ private: } template <class, class, class, class> friend class __hash_table; - template <class> friend class _LIBCPP_VISIBLE __hash_map_const_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator; }; template <class _Alloc> diff --git a/contrib/libc++/include/__locale b/contrib/libc++/include/__locale index 4176720..24d565b 100644 --- a/contrib/libc++/include/__locale +++ b/contrib/libc++/include/__locale @@ -19,11 +19,11 @@ #include <cstdint> #include <cctype> #include <locale.h> -#if _WIN32 +#ifdef _WIN32 # include <support/win32/locale_win32.h> -#elif (__GLIBC__ || __APPLE__ || __FreeBSD__ || __sun__) +#elif (defined(__GLIBC__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__)) || defined(EMSCRIPTEN) # include <xlocale.h> -#endif // _WIN32 || __GLIBC__ || __APPLE__ || __FreeBSD_ +#endif // _WIN32 || __GLIBC__ || __APPLE__ || __FreeBSD__ || __sun__ || EMSCRIPTEN #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header @@ -31,7 +31,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE locale; +class _LIBCPP_TYPE_VIS locale; template <class _Facet> _LIBCPP_INLINE_VISIBILITY @@ -43,12 +43,12 @@ _LIBCPP_INLINE_VISIBILITY const _Facet& use_facet(const locale&); -class _LIBCPP_VISIBLE locale +class _LIBCPP_TYPE_VIS locale { public: // types: - class _LIBCPP_VISIBLE facet; - class _LIBCPP_VISIBLE id; + class _LIBCPP_TYPE_VIS facet; + class _LIBCPP_TYPE_VIS id; typedef int category; static const category // values assigned here are for exposition only @@ -103,7 +103,7 @@ private: template <class _Facet> friend const _Facet& use_facet(const locale&); }; -class _LIBCPP_VISIBLE locale::facet +class _LIBCPP_TYPE_VIS locale::facet : public __shared_count { protected: @@ -119,7 +119,7 @@ private: virtual void __on_zero_shared() _NOEXCEPT; }; -class _LIBCPP_VISIBLE locale::id +class _LIBCPP_TYPE_VIS locale::id { once_flag __flag_; int32_t __id_; @@ -175,7 +175,7 @@ use_facet(const locale& __l) // template <class _CharT> class collate; template <class _CharT> -class _LIBCPP_VISIBLE collate +class _LIBCPP_TYPE_VIS collate : public locale::facet { public: @@ -254,15 +254,15 @@ collate<_CharT>::do_hash(const char_type* __lo, const char_type* __hi) const return static_cast<long>(__h); } -_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_VISIBLE collate<char>) -_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_VISIBLE collate<wchar_t>) +_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS collate<char>) +_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS collate<wchar_t>) // template <class CharT> class collate_byname; -template <class _CharT> class _LIBCPP_VISIBLE collate_byname; +template <class _CharT> class _LIBCPP_TYPE_VIS collate_byname; template <> -class _LIBCPP_VISIBLE collate_byname<char> +class _LIBCPP_TYPE_VIS collate_byname<char> : public collate<char> { locale_t __l; @@ -281,7 +281,7 @@ protected: }; template <> -class _LIBCPP_VISIBLE collate_byname<wchar_t> +class _LIBCPP_TYPE_VIS collate_byname<wchar_t> : public collate<wchar_t> { locale_t __l; @@ -312,10 +312,10 @@ locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x, // template <class charT> class ctype -class _LIBCPP_VISIBLE ctype_base +class _LIBCPP_TYPE_VIS ctype_base { public: -#if __GLIBC__ +#ifdef __GLIBC__ typedef unsigned short mask; static const mask space = _ISspace; static const mask print = _ISprint; @@ -327,7 +327,7 @@ public: static const mask punct = _ISpunct; static const mask xdigit = _ISxdigit; static const mask blank = _ISblank; -#elif _WIN32 +#elif defined(_WIN32) typedef unsigned short mask; static const mask space = _SPACE; static const mask print = _BLANK|_PUNCT|_ALPHA|_DIGIT; @@ -339,11 +339,13 @@ public: static const mask punct = _PUNCT; static const mask xdigit = _HEX; static const mask blank = _BLANK; -#elif (__APPLE__ || __FreeBSD__) -#if __APPLE__ +#elif (defined(__APPLE__) || defined(__FreeBSD__)) || defined(EMSCRIPTEN) +#ifdef __APPLE__ typedef __uint32_t mask; -#elif __FreeBSD__ +#elif defined(__FreeBSD__) typedef unsigned long mask; +#elif defined(EMSCRIPTEN) + typedef unsigned short mask; #endif static const mask space = _CTYPE_S; static const mask print = _CTYPE_R; @@ -355,7 +357,7 @@ public: static const mask punct = _CTYPE_P; static const mask xdigit = _CTYPE_X; static const mask blank = _CTYPE_B; -#elif __sun__ +#elif defined(__sun__) typedef unsigned int mask; static const mask space = _ISSPACE; static const mask print = _ISPRINT; @@ -367,7 +369,7 @@ public: static const mask punct = _ISPUNCT; static const mask xdigit = _ISXDIGIT; static const mask blank = _ISBLANK; -#else // __GLIBC__ || _WIN32 || __APPLE__ || __FreeBSD__ || __sun__ +#else // __GLIBC__ || _WIN32 || __APPLE__ || __FreeBSD__ || EMSCRIPTEN || __sun__ typedef unsigned long mask; static const mask space = 1<<0; static const mask print = 1<<1; @@ -386,10 +388,10 @@ public: _LIBCPP_ALWAYS_INLINE ctype_base() {} }; -template <class _CharT> class _LIBCPP_VISIBLE ctype; +template <class _CharT> class _LIBCPP_TYPE_VIS ctype; template <> -class _LIBCPP_VISIBLE ctype<wchar_t> +class _LIBCPP_TYPE_VIS ctype<wchar_t> : public locale::facet, public ctype_base { @@ -491,7 +493,7 @@ protected: }; template <> -class _LIBCPP_VISIBLE ctype<char> +class _LIBCPP_TYPE_VIS ctype<char> : public locale::facet, public ctype_base { const mask* __tab_; @@ -590,7 +592,7 @@ public: #endif _LIBCPP_ALWAYS_INLINE const mask* table() const _NOEXCEPT {return __tab_;} static const mask* classic_table() _NOEXCEPT; -#if defined(__GLIBC__) +#if defined(__GLIBC__) || defined(EMSCRIPTEN) static const int* __classic_upper_table() _NOEXCEPT; static const int* __classic_lower_table() _NOEXCEPT; #endif @@ -609,10 +611,10 @@ protected: // template <class CharT> class ctype_byname; -template <class _CharT> class _LIBCPP_VISIBLE ctype_byname; +template <class _CharT> class _LIBCPP_TYPE_VIS ctype_byname; template <> -class _LIBCPP_VISIBLE ctype_byname<char> +class _LIBCPP_TYPE_VIS ctype_byname<char> : public ctype<char> { locale_t __l; @@ -630,7 +632,7 @@ protected: }; template <> -class _LIBCPP_VISIBLE ctype_byname<wchar_t> +class _LIBCPP_TYPE_VIS ctype_byname<wchar_t> : public ctype<wchar_t> { locale_t __l; @@ -761,7 +763,7 @@ tolower(_CharT __c, const locale& __loc) // codecvt_base -class _LIBCPP_VISIBLE codecvt_base +class _LIBCPP_TYPE_VIS codecvt_base { public: _LIBCPP_ALWAYS_INLINE codecvt_base() {} @@ -770,12 +772,12 @@ public: // template <class internT, class externT, class stateT> class codecvt; -template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_VISIBLE codecvt; +template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_TYPE_VIS codecvt; // template <> class codecvt<char, char, mbstate_t> template <> -class _LIBCPP_VISIBLE codecvt<char, char, mbstate_t> +class _LIBCPP_TYPE_VIS codecvt<char, char, mbstate_t> : public locale::facet, public codecvt_base { @@ -861,7 +863,7 @@ protected: // template <> class codecvt<wchar_t, char, mbstate_t> template <> -class _LIBCPP_VISIBLE codecvt<wchar_t, char, mbstate_t> +class _LIBCPP_TYPE_VIS codecvt<wchar_t, char, mbstate_t> : public locale::facet, public codecvt_base { @@ -944,7 +946,7 @@ protected: // template <> class codecvt<char16_t, char, mbstate_t> template <> -class _LIBCPP_VISIBLE codecvt<char16_t, char, mbstate_t> +class _LIBCPP_TYPE_VIS codecvt<char16_t, char, mbstate_t> : public locale::facet, public codecvt_base { @@ -1030,7 +1032,7 @@ protected: // template <> class codecvt<char32_t, char, mbstate_t> template <> -class _LIBCPP_VISIBLE codecvt<char32_t, char, mbstate_t> +class _LIBCPP_TYPE_VIS codecvt<char32_t, char, mbstate_t> : public locale::facet, public codecvt_base { @@ -1116,7 +1118,7 @@ protected: // template <class _InternT, class _ExternT, class _StateT> class codecvt_byname template <class _InternT, class _ExternT, class _StateT> -class _LIBCPP_VISIBLE codecvt_byname +class _LIBCPP_TYPE_VIS codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> { public: @@ -1140,7 +1142,7 @@ _LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<wchar_t, char, mbstate_t>) _LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<char16_t, char, mbstate_t>) _LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<char32_t, char, mbstate_t>) -_LIBCPP_VISIBLE void __throw_runtime_error(const char*); +_LIBCPP_FUNC_VIS void __throw_runtime_error(const char*); template <size_t _Np> struct __narrow_to_utf8 @@ -1324,10 +1326,10 @@ struct __widen_from_utf8<32> // template <class charT> class numpunct -template <class _CharT> class _LIBCPP_VISIBLE numpunct; +template <class _CharT> class _LIBCPP_TYPE_VIS numpunct; template <> -class _LIBCPP_VISIBLE numpunct<char> +class _LIBCPP_TYPE_VIS numpunct<char> : public locale::facet { public: @@ -1358,7 +1360,7 @@ protected: }; template <> -class _LIBCPP_VISIBLE numpunct<wchar_t> +class _LIBCPP_TYPE_VIS numpunct<wchar_t> : public locale::facet { public: @@ -1390,10 +1392,10 @@ protected: // template <class charT> class numpunct_byname -template <class charT> class _LIBCPP_VISIBLE numpunct_byname; +template <class charT> class _LIBCPP_TYPE_VIS numpunct_byname; template <> -class _LIBCPP_VISIBLE numpunct_byname<char> +class _LIBCPP_TYPE_VIS numpunct_byname<char> : public numpunct<char> { public: @@ -1411,7 +1413,7 @@ private: }; template <> -class _LIBCPP_VISIBLE numpunct_byname<wchar_t> +class _LIBCPP_TYPE_VIS numpunct_byname<wchar_t> : public numpunct<wchar_t> { public: diff --git a/contrib/libc++/include/__mutex_base b/contrib/libc++/include/__mutex_base index e936ad3..0583df9 100644 --- a/contrib/libc++/include/__mutex_base +++ b/contrib/libc++/include/__mutex_base @@ -32,7 +32,7 @@ template <class _Mutex> class upgrade_lock; _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE mutex +class _LIBCPP_TYPE_VIS mutex { pthread_mutex_t __m_; @@ -58,9 +58,9 @@ public: _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;} }; -struct _LIBCPP_VISIBLE defer_lock_t {}; -struct _LIBCPP_VISIBLE try_to_lock_t {}; -struct _LIBCPP_VISIBLE adopt_lock_t {}; +struct _LIBCPP_TYPE_VIS defer_lock_t {}; +struct _LIBCPP_TYPE_VIS try_to_lock_t {}; +struct _LIBCPP_TYPE_VIS adopt_lock_t {}; #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MUTEX) @@ -77,7 +77,7 @@ constexpr adopt_lock_t adopt_lock = adopt_lock_t(); #endif template <class _Mutex> -class _LIBCPP_VISIBLE lock_guard +class _LIBCPP_TYPE_VIS lock_guard { public: typedef _Mutex mutex_type; @@ -101,7 +101,7 @@ private: }; template <class _Mutex> -class _LIBCPP_VISIBLE unique_lock +class _LIBCPP_TYPE_VIS unique_lock { public: typedef _Mutex mutex_type; @@ -285,7 +285,7 @@ void swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) _NOEXCEPT {__x.swap(__y);} -struct _LIBCPP_VISIBLE cv_status +struct _LIBCPP_TYPE_VIS cv_status { enum __lx { no_timeout, @@ -299,7 +299,7 @@ struct _LIBCPP_VISIBLE cv_status }; -class _LIBCPP_VISIBLE condition_variable +class _LIBCPP_TYPE_VIS condition_variable { pthread_cond_t __cv_; public: diff --git a/contrib/libc++/include/__std_stream b/contrib/libc++/include/__std_stream index e562e2c..8ca413e 100644 --- a/contrib/libc++/include/__std_stream +++ b/contrib/libc++/include/__std_stream @@ -41,7 +41,7 @@ public: typedef typename traits_type::off_type off_type; typedef typename traits_type::state_type state_type; - explicit __stdinbuf(FILE* __fp); + __stdinbuf(FILE* __fp, state_type* __st); protected: virtual int_type underflow(); @@ -53,7 +53,7 @@ private: FILE* __file_; const codecvt<char_type, char, state_type>* __cv_; - state_type __st_; + state_type* __st_; int __encoding_; bool __always_noconv_; @@ -64,9 +64,9 @@ private: }; template <class _CharT> -__stdinbuf<_CharT>::__stdinbuf(FILE* __fp) +__stdinbuf<_CharT>::__stdinbuf(FILE* __fp, state_type* __st) : __file_(__fp), - __st_() + __st_(__st) { imbue(this->getloc()); } @@ -119,15 +119,15 @@ __stdinbuf<_CharT>::__getchar(bool __consume) codecvt_base::result __r; do { - state_type __sv_st = __st_; - __r = __cv_->in(__st_, __extbuf, __extbuf + __nread, __enxt, + state_type __sv_st = *__st_; + __r = __cv_->in(*__st_, __extbuf, __extbuf + __nread, __enxt, &__1buf, &__1buf + 1, __inxt); switch (__r) { case _VSTD::codecvt_base::ok: break; case codecvt_base::partial: - __st_ = __sv_st; + *__st_ = __sv_st; if (__nread == sizeof(__extbuf)) return traits_type::eof(); { @@ -150,7 +150,7 @@ __stdinbuf<_CharT>::__getchar(bool __consume) { for (int __i = __nread; __i > 0;) { - if (ungetc(__extbuf[--__i], __file_) == EOF) + if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF) return traits_type::eof(); } } @@ -167,7 +167,7 @@ __stdinbuf<_CharT>::pbackfail(int_type __c) char* __enxt; const char_type __ci = traits_type::to_char_type(__c); const char_type* __inxt; - switch (__cv_->out(__st_, &__ci, &__ci + 1, __inxt, + switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt, __extbuf, __extbuf + sizeof(__extbuf), __enxt)) { case _VSTD::codecvt_base::ok: @@ -200,7 +200,7 @@ public: typedef typename traits_type::off_type off_type; typedef typename traits_type::state_type state_type; - explicit __stdoutbuf(FILE* __fp); + __stdoutbuf(FILE* __fp, state_type* __st); protected: virtual int_type overflow (int_type __c = traits_type::eof()); @@ -210,7 +210,7 @@ protected: private: FILE* __file_; const codecvt<char_type, char, state_type>* __cv_; - state_type __st_; + state_type* __st_; bool __always_noconv_; __stdoutbuf(const __stdoutbuf&); @@ -218,10 +218,10 @@ private: }; template <class _CharT> -__stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp) +__stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st) : __file_(__fp), __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())), - __st_(), + __st_(__st), __always_noconv_(__cv_->always_noconv()) { } @@ -249,7 +249,7 @@ __stdoutbuf<_CharT>::overflow(int_type __c) do { const char_type* __e; - __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, + __r = __cv_->out(*__st_, this->pbase(), this->pptr(), __e, __extbuf, __extbuf + sizeof(__extbuf), __extbe); @@ -289,7 +289,7 @@ __stdoutbuf<_CharT>::sync() do { char* __extbe; - __r = __cv_->unshift(__st_, __extbuf, + __r = __cv_->unshift(*__st_, __extbuf, __extbuf + sizeof(__extbuf), __extbe); size_t __nmemb = static_cast<size_t>(__extbe - __extbuf); diff --git a/contrib/libc++/include/__tree b/contrib/libc++/include/__tree index bd38b4f..cd6d7ef 100644 --- a/contrib/libc++/include/__tree +++ b/contrib/libc++/include/__tree @@ -25,17 +25,17 @@ _LIBCPP_BEGIN_NAMESPACE_STD template <class _Tp, class _Compare, class _Allocator> class __tree; template <class _Tp, class _NodePtr, class _DiffType> - class _LIBCPP_VISIBLE __tree_iterator; + class _LIBCPP_TYPE_VIS __tree_iterator; template <class _Tp, class _ConstNodePtr, class _DiffType> - class _LIBCPP_VISIBLE __tree_const_iterator; + class _LIBCPP_TYPE_VIS __tree_const_iterator; template <class _Key, class _Tp, class _Compare, class _Allocator> - class _LIBCPP_VISIBLE map; + class _LIBCPP_TYPE_VIS map; template <class _Key, class _Tp, class _Compare, class _Allocator> - class _LIBCPP_VISIBLE multimap; + class _LIBCPP_TYPE_VIS multimap; template <class _Key, class _Compare, class _Allocator> - class _LIBCPP_VISIBLE set; + class _LIBCPP_TYPE_VIS set; template <class _Key, class _Compare, class _Allocator> - class _LIBCPP_VISIBLE multiset; + class _LIBCPP_TYPE_VIS multiset; /* @@ -614,11 +614,11 @@ public: #endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) }; -template <class _TreeIterator> class _LIBCPP_VISIBLE __map_iterator; -template <class _TreeIterator> class _LIBCPP_VISIBLE __map_const_iterator; +template <class _TreeIterator> class _LIBCPP_TYPE_VIS __map_iterator; +template <class _TreeIterator> class _LIBCPP_TYPE_VIS __map_const_iterator; template <class _Tp, class _NodePtr, class _DiffType> -class _LIBCPP_VISIBLE __tree_iterator +class _LIBCPP_TYPE_VIS __tree_iterator { typedef _NodePtr __node_pointer; typedef typename pointer_traits<__node_pointer>::element_type __node; @@ -673,16 +673,16 @@ private: _LIBCPP_INLINE_VISIBILITY explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {} template <class, class, class> friend class __tree; - template <class, class, class> friend class _LIBCPP_VISIBLE __tree_const_iterator; - template <class> friend class _LIBCPP_VISIBLE __map_iterator; - template <class, class, class, class> friend class _LIBCPP_VISIBLE map; - template <class, class, class, class> friend class _LIBCPP_VISIBLE multimap; - template <class, class, class> friend class _LIBCPP_VISIBLE set; - template <class, class, class> friend class _LIBCPP_VISIBLE multiset; + template <class, class, class> friend class _LIBCPP_TYPE_VIS __tree_const_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __map_iterator; + template <class, class, class, class> friend class _LIBCPP_TYPE_VIS map; + template <class, class, class, class> friend class _LIBCPP_TYPE_VIS multimap; + template <class, class, class> friend class _LIBCPP_TYPE_VIS set; + template <class, class, class> friend class _LIBCPP_TYPE_VIS multiset; }; template <class _Tp, class _ConstNodePtr, class _DiffType> -class _LIBCPP_VISIBLE __tree_const_iterator +class _LIBCPP_TYPE_VIS __tree_const_iterator { typedef _ConstNodePtr __node_pointer; typedef typename pointer_traits<__node_pointer>::element_type __node; @@ -759,11 +759,11 @@ private: explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {} template <class, class, class> friend class __tree; - template <class, class, class, class> friend class _LIBCPP_VISIBLE map; - template <class, class, class, class> friend class _LIBCPP_VISIBLE multimap; - template <class, class, class> friend class _LIBCPP_VISIBLE set; - template <class, class, class> friend class _LIBCPP_VISIBLE multiset; - template <class> friend class _LIBCPP_VISIBLE __map_const_iterator; + template <class, class, class, class> friend class _LIBCPP_TYPE_VIS map; + template <class, class, class, class> friend class _LIBCPP_TYPE_VIS multimap; + template <class, class, class> friend class _LIBCPP_TYPE_VIS set; + template <class, class, class> friend class _LIBCPP_TYPE_VIS multiset; + template <class> friend class _LIBCPP_TYPE_VIS __map_const_iterator; }; template <class _Tp, class _Compare, class _Allocator> diff --git a/contrib/libc++/include/__tuple b/contrib/libc++/include/__tuple index 1fa90a0..1213262 100644 --- a/contrib/libc++/include/__tuple +++ b/contrib/libc++/include/__tuple @@ -27,46 +27,46 @@ _LIBCPP_BEGIN_NAMESPACE_STD -template <class _Tp> class _LIBCPP_VISIBLE tuple_size; +template <class _Tp> class _LIBCPP_TYPE_VIS tuple_size; template <class _Tp> -class _LIBCPP_VISIBLE tuple_size<const _Tp> +class _LIBCPP_TYPE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {}; template <class _Tp> -class _LIBCPP_VISIBLE tuple_size<volatile _Tp> +class _LIBCPP_TYPE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {}; template <class _Tp> -class _LIBCPP_VISIBLE tuple_size<const volatile _Tp> +class _LIBCPP_TYPE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {}; -template <size_t _Ip, class _Tp> class _LIBCPP_VISIBLE tuple_element; +template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS tuple_element; template <size_t _Ip, class _Tp> -class _LIBCPP_VISIBLE tuple_element<_Ip, const _Tp> +class _LIBCPP_TYPE_VIS tuple_element<_Ip, const _Tp> { public: typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type; }; template <size_t _Ip, class _Tp> -class _LIBCPP_VISIBLE tuple_element<_Ip, volatile _Tp> +class _LIBCPP_TYPE_VIS tuple_element<_Ip, volatile _Tp> { public: typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type; }; template <size_t _Ip, class _Tp> -class _LIBCPP_VISIBLE tuple_element<_Ip, const volatile _Tp> +class _LIBCPP_TYPE_VIS tuple_element<_Ip, const volatile _Tp> { public: typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type; }; -template <class ..._Tp> class _LIBCPP_VISIBLE tuple; -template <class _T1, class _T2> struct _LIBCPP_VISIBLE pair; -template <class _Tp, size_t _Size> struct _LIBCPP_VISIBLE array; +template <class ..._Tp> class _LIBCPP_TYPE_VIS tuple; +template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS pair; +template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS array; template <class _Tp> struct __tuple_like : false_type {}; @@ -154,7 +154,7 @@ struct __make_tuple_indices template <class ..._Tp> struct __tuple_types {}; template <size_t _Ip> -class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<> > +class _LIBCPP_TYPE_VIS tuple_element<_Ip, __tuple_types<> > { public: static_assert(_Ip == 0, "tuple_element index out of range"); @@ -162,21 +162,21 @@ public: }; template <class _Hp, class ..._Tp> -class _LIBCPP_VISIBLE tuple_element<0, __tuple_types<_Hp, _Tp...> > +class _LIBCPP_TYPE_VIS tuple_element<0, __tuple_types<_Hp, _Tp...> > { public: typedef _Hp type; }; template <size_t _Ip, class _Hp, class ..._Tp> -class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<_Hp, _Tp...> > +class _LIBCPP_TYPE_VIS tuple_element<_Ip, __tuple_types<_Hp, _Tp...> > { public: typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...> >::type type; }; template <class ..._Tp> -class _LIBCPP_VISIBLE tuple_size<__tuple_types<_Tp...> > +class _LIBCPP_TYPE_VIS tuple_size<__tuple_types<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> { }; diff --git a/contrib/libc++/include/__tuple_03 b/contrib/libc++/include/__tuple_03 index a28ac08..605d84d 100644 --- a/contrib/libc++/include/__tuple_03 +++ b/contrib/libc++/include/__tuple_03 @@ -19,8 +19,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD -template <class _Tp> class _LIBCPP_VISIBLE tuple_size; -template <size_t _Ip, class _Tp> class _LIBCPP_VISIBLE tuple_element; +template <class _Tp> class _LIBCPP_TYPE_VIS tuple_size; +template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS tuple_element; _LIBCPP_END_NAMESPACE_STD diff --git a/contrib/libc++/include/algorithm b/contrib/libc++/include/algorithm index e24f979..39191db 100644 --- a/contrib/libc++/include/algorithm +++ b/contrib/libc++/include/algorithm @@ -1398,7 +1398,7 @@ __search_n(_RandomAccessIterator __first, _RandomAccessIterator __last, // Find first element in sequence that matchs __value_, with a mininum of loop checks while (true) { - if (__first == __s) // return __last if no element matches __value_ + if (__first >= __s) // return __last if no element matches __value_ return __last; if (__pred(*__first, __value_)) break; @@ -2764,7 +2764,7 @@ class __rs_default __rs_default(); public: - typedef unsigned result_type; + typedef uint_fast32_t result_type; static const result_type _Min = 0; static const result_type _Max = 0xFFFFFFFF; diff --git a/contrib/libc++/include/array b/contrib/libc++/include/array index f4a3020..bcf5347 100644 --- a/contrib/libc++/include/array +++ b/contrib/libc++/include/array @@ -118,7 +118,7 @@ template <int I, class T, size_t N> T&& get(array<T, N>&&) noexcept; _LIBCPP_BEGIN_NAMESPACE_STD template <class _Tp, size_t _Size> -struct _LIBCPP_VISIBLE array +struct _LIBCPP_TYPE_VIS array { // types: typedef array __self; @@ -284,22 +284,22 @@ swap(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) } template <class _Tp, size_t _Size> -class _LIBCPP_VISIBLE tuple_size<array<_Tp, _Size> > +class _LIBCPP_TYPE_VIS tuple_size<array<_Tp, _Size> > : public integral_constant<size_t, _Size> {}; template <class _Tp, size_t _Size> -class _LIBCPP_VISIBLE tuple_size<const array<_Tp, _Size> > +class _LIBCPP_TYPE_VIS tuple_size<const array<_Tp, _Size> > : public integral_constant<size_t, _Size> {}; template <size_t _Ip, class _Tp, size_t _Size> -class _LIBCPP_VISIBLE tuple_element<_Ip, array<_Tp, _Size> > +class _LIBCPP_TYPE_VIS tuple_element<_Ip, array<_Tp, _Size> > { public: typedef _Tp type; }; template <size_t _Ip, class _Tp, size_t _Size> -class _LIBCPP_VISIBLE tuple_element<_Ip, const array<_Tp, _Size> > +class _LIBCPP_TYPE_VIS tuple_element<_Ip, const array<_Tp, _Size> > { public: typedef const _Tp type; diff --git a/contrib/libc++/include/bitset b/contrib/libc++/include/bitset index 1167f50..dd9be4f 100644 --- a/contrib/libc++/include/bitset +++ b/contrib/libc++/include/bitset @@ -249,7 +249,13 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT #ifndef _LIBCPP_HAS_NO_CONSTEXPR +#if __SIZE_WIDTH__ == 64 : __first_{__v} +#elif __SIZE_WIDTH__ == 32 + : __first_{__v, __v >> __bits_per_word} +#else +#error This constructor has not been ported to this platform +#endif #endif { #ifdef _LIBCPP_HAS_NO_CONSTEXPR @@ -626,13 +632,14 @@ __bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT { } -template <size_t _Size> class _LIBCPP_VISIBLE bitset; -template <size_t _Size> struct hash<bitset<_Size> >; +template <size_t _Size> class _LIBCPP_TYPE_VIS bitset; +template <size_t _Size> struct _LIBCPP_TYPE_VIS hash<bitset<_Size> >; template <size_t _Size> -class _LIBCPP_VISIBLE bitset +class _LIBCPP_TYPE_VIS bitset : private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size> { +public: static const unsigned __n_words = _Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1; typedef __bitset<__n_words, _Size> base; @@ -1053,7 +1060,7 @@ operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT } template <size_t _Size> -struct _LIBCPP_VISIBLE hash<bitset<_Size> > +struct _LIBCPP_TYPE_VIS hash<bitset<_Size> > : public unary_function<bitset<_Size>, size_t> { _LIBCPP_INLINE_VISIBILITY diff --git a/contrib/libc++/include/chrono b/contrib/libc++/include/chrono index 508c1f3..3b96e816 100644 --- a/contrib/libc++/include/chrono +++ b/contrib/libc++/include/chrono @@ -279,7 +279,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD namespace chrono { -template <class _Rep, class _Period = ratio<1> > class _LIBCPP_VISIBLE duration; +template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TYPE_VIS duration; template <class _Tp> struct __is_duration : false_type {}; @@ -299,7 +299,7 @@ struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {}; } // chrono template <class _Rep1, class _Period1, class _Rep2, class _Period2> -struct _LIBCPP_VISIBLE common_type<chrono::duration<_Rep1, _Period1>, +struct _LIBCPP_TYPE_VIS common_type<chrono::duration<_Rep1, _Period1>, chrono::duration<_Rep2, _Period2> > { typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type, @@ -377,10 +377,10 @@ duration_cast(const duration<_Rep, _Period>& __fd) } template <class _Rep> -struct _LIBCPP_VISIBLE treat_as_floating_point : is_floating_point<_Rep> {}; +struct _LIBCPP_TYPE_VIS treat_as_floating_point : is_floating_point<_Rep> {}; template <class _Rep> -struct _LIBCPP_VISIBLE duration_values +struct _LIBCPP_TYPE_VIS duration_values { public: _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);} @@ -391,7 +391,7 @@ public: // duration template <class _Rep, class _Period> -class _LIBCPP_VISIBLE duration +class _LIBCPP_TYPE_VIS duration { static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration"); static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio"); @@ -696,7 +696,7 @@ operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2 ////////////////////////////////////////////////////////// template <class _Clock, class _Duration = typename _Clock::duration> -class _LIBCPP_VISIBLE time_point +class _LIBCPP_TYPE_VIS time_point { static_assert(__is_duration<_Duration>::value, "Second template parameter of time_point must be a std::chrono::duration"); @@ -740,7 +740,7 @@ public: } // chrono template <class _Clock, class _Duration1, class _Duration2> -struct _LIBCPP_VISIBLE common_type<chrono::time_point<_Clock, _Duration1>, +struct _LIBCPP_TYPE_VIS common_type<chrono::time_point<_Clock, _Duration1>, chrono::time_point<_Clock, _Duration2> > { typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type; @@ -863,7 +863,7 @@ operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, /////////////////////// clocks /////////////////////////// ////////////////////////////////////////////////////////// -class _LIBCPP_VISIBLE system_clock +class _LIBCPP_TYPE_VIS system_clock { public: typedef microseconds duration; @@ -877,7 +877,7 @@ public: static time_point from_time_t(time_t __t) _NOEXCEPT; }; -class _LIBCPP_VISIBLE steady_clock +class _LIBCPP_TYPE_VIS steady_clock { public: typedef nanoseconds duration; diff --git a/contrib/libc++/include/codecvt b/contrib/libc++/include/codecvt index 6c44e34..a6e4308 100644 --- a/contrib/libc++/include/codecvt +++ b/contrib/libc++/include/codecvt @@ -179,7 +179,7 @@ protected: template <class _Elem, unsigned long _Maxcode = 0x10ffff, codecvt_mode _Mode = (codecvt_mode)0> -class _LIBCPP_VISIBLE codecvt_utf8 +class _LIBCPP_TYPE_VIS codecvt_utf8 : public __codecvt_utf8<_Elem> { public: @@ -407,7 +407,7 @@ protected: template <class _Elem, unsigned long _Maxcode = 0x10ffff, codecvt_mode _Mode = (codecvt_mode)0> -class _LIBCPP_VISIBLE codecvt_utf16 +class _LIBCPP_TYPE_VIS codecvt_utf16 : public __codecvt_utf16<_Elem, _Mode & little_endian> { public: @@ -530,7 +530,7 @@ protected: template <class _Elem, unsigned long _Maxcode = 0x10ffff, codecvt_mode _Mode = (codecvt_mode)0> -class _LIBCPP_VISIBLE codecvt_utf8_utf16 +class _LIBCPP_TYPE_VIS codecvt_utf8_utf16 : public __codecvt_utf8_utf16<_Elem> { public: diff --git a/contrib/libc++/include/complex b/contrib/libc++/include/complex index 07d3754..a09bf70 100644 --- a/contrib/libc++/include/complex +++ b/contrib/libc++/include/complex @@ -255,13 +255,13 @@ template<class T, class charT, class traits> _LIBCPP_BEGIN_NAMESPACE_STD -template<class _Tp> class _LIBCPP_VISIBLE complex; +template<class _Tp> class _LIBCPP_TYPE_VIS complex; template<class _Tp> complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w); template<class _Tp> complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y); template<class _Tp> -class _LIBCPP_VISIBLE complex +class _LIBCPP_TYPE_VIS complex { public: typedef _Tp value_type; @@ -319,11 +319,11 @@ public: } }; -template<> class _LIBCPP_VISIBLE complex<double>; -template<> class _LIBCPP_VISIBLE complex<long double>; +template<> class _LIBCPP_TYPE_VIS complex<double>; +template<> class _LIBCPP_TYPE_VIS complex<long double>; template<> -class _LIBCPP_VISIBLE complex<float> +class _LIBCPP_TYPE_VIS complex<float> { float __re_; float __im_; @@ -379,7 +379,7 @@ public: }; template<> -class _LIBCPP_VISIBLE complex<double> +class _LIBCPP_TYPE_VIS complex<double> { double __re_; double __im_; @@ -435,7 +435,7 @@ public: }; template<> -class _LIBCPP_VISIBLE complex<long double> +class _LIBCPP_TYPE_VIS complex<long double> { long double __re_; long double __im_; diff --git a/contrib/libc++/include/condition_variable b/contrib/libc++/include/condition_variable index b1a50ee..dc67266 100644 --- a/contrib/libc++/include/condition_variable +++ b/contrib/libc++/include/condition_variable @@ -117,7 +117,7 @@ public: _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE condition_variable_any +class _LIBCPP_TYPE_VIS condition_variable_any { condition_variable __cv_; shared_ptr<mutex> __mut_; @@ -248,7 +248,7 @@ condition_variable_any::wait_for(_Lock& __lock, _VSTD::move(__pred)); } -_LIBCPP_VISIBLE +_LIBCPP_FUNC_VIS void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); _LIBCPP_END_NAMESPACE_STD diff --git a/contrib/libc++/include/cstddef b/contrib/libc++/include/cstddef index 2467089..c263772 100644 --- a/contrib/libc++/include/cstddef +++ b/contrib/libc++/include/cstddef @@ -56,7 +56,7 @@ typedef long double max_align_t; #ifdef _LIBCPP_HAS_NO_NULLPTR -struct _LIBCPP_VISIBLE nullptr_t +struct _LIBCPP_TYPE_VIS nullptr_t { void* __lx; diff --git a/contrib/libc++/include/cstring b/contrib/libc++/include/cstring index 13bb118..45075b3 100644 --- a/contrib/libc++/include/cstring +++ b/contrib/libc++/include/cstring @@ -94,7 +94,7 @@ using ::strspn; using ::strstr; // MSVC, GNU libc and its derivates already have the correct prototype in <string.h> #ifdef __cplusplus -#if !defined(__GLIBC__) && !defined(_MSC_VER) && !defined(__sun__) +#if !defined(__GLIBC__) && !defined(_MSC_VER) && !defined(__sun__) && !defined(_STRING_H_CPLUSPLUS_98_CONFORMANCE_) inline _LIBCPP_INLINE_VISIBILITY char* strchr( char* __s, int __c) {return ::strchr(__s, __c);} inline _LIBCPP_INLINE_VISIBILITY char* strpbrk( char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);} inline _LIBCPP_INLINE_VISIBILITY char* strrchr( char* __s, int __c) {return ::strrchr(__s, __c);} diff --git a/contrib/libc++/include/cwchar b/contrib/libc++/include/cwchar index eed6de1..845ccec 100644 --- a/contrib/libc++/include/cwchar +++ b/contrib/libc++/include/cwchar @@ -106,7 +106,7 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len, #include <__config> #include <cwctype> #include <wchar.h> -#if _WIN32 +#ifdef _WIN32 #include <support/win32/support.h> // pull in *swprintf defines #endif // _WIN32 @@ -167,28 +167,37 @@ using ::wcscoll; using ::wcsncmp; using ::wcsxfrm; +#if defined(_WCHAR_H_CPLUSPLUS_98_CONFORMANCE_) + +using ::wcschr; +using ::wcspbrk; +using ::wcsrchr; +using ::wcsstr; +using ::wmemchr; + +#else + inline _LIBCPP_INLINE_VISIBILITY const wchar_t* wcschr(const wchar_t* __s, wchar_t __c) {return ::wcschr(__s, __c);} inline _LIBCPP_INLINE_VISIBILITY wchar_t* wcschr( wchar_t* __s, wchar_t __c) {return ::wcschr(__s, __c);} -using ::wcscspn; -using ::wcslen; - inline _LIBCPP_INLINE_VISIBILITY const wchar_t* wcspbrk(const wchar_t* __s1, const wchar_t* __s2) {return ::wcspbrk(__s1, __s2);} inline _LIBCPP_INLINE_VISIBILITY wchar_t* wcspbrk( wchar_t* __s1, const wchar_t* __s2) {return ::wcspbrk(__s1, __s2);} inline _LIBCPP_INLINE_VISIBILITY const wchar_t* wcsrchr(const wchar_t* __s, wchar_t __c) {return ::wcsrchr(__s, __c);} inline _LIBCPP_INLINE_VISIBILITY wchar_t* wcsrchr( wchar_t* __s, wchar_t __c) {return ::wcsrchr(__s, __c);} -using ::wcsspn; - inline _LIBCPP_INLINE_VISIBILITY const wchar_t* wcsstr(const wchar_t* __s1, const wchar_t* __s2) {return ::wcsstr(__s1, __s2);} inline _LIBCPP_INLINE_VISIBILITY wchar_t* wcsstr( wchar_t* __s1, const wchar_t* __s2) {return ::wcsstr(__s1, __s2);} -using ::wcstok; - inline _LIBCPP_INLINE_VISIBILITY const wchar_t* wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return ::wmemchr(__s, __c, __n);} inline _LIBCPP_INLINE_VISIBILITY wchar_t* wmemchr( wchar_t* __s, wchar_t __c, size_t __n) {return ::wmemchr(__s, __c, __n);} +#endif + +using ::wcscspn; +using ::wcslen; +using ::wcsspn; +using ::wcstok; using ::wmemcmp; using ::wmemcpy; using ::wmemmove; diff --git a/contrib/libc++/include/deque b/contrib/libc++/include/deque index b86d77f..8e09822 100644 --- a/contrib/libc++/include/deque +++ b/contrib/libc++/include/deque @@ -170,7 +170,7 @@ template <class _Tp, class _Allocator> class __deque_base; template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize> -class _LIBCPP_VISIBLE __deque_iterator; +class _LIBCPP_TYPE_VIS __deque_iterator; template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2> @@ -262,7 +262,7 @@ move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f, template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize> -class _LIBCPP_VISIBLE __deque_iterator +class _LIBCPP_TYPE_VIS __deque_iterator { typedef _MapPointer __map_iterator; public: @@ -410,9 +410,9 @@ private: : __m_iter_(__m), __ptr_(__p) {} template <class _Tp, class _Ap> friend class __deque_base; - template <class _Tp, class _Ap> friend class _LIBCPP_VISIBLE deque; + template <class _Tp, class _Ap> friend class _LIBCPP_TYPE_VIS deque; template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp> - friend class _LIBCPP_VISIBLE __deque_iterator; + friend class _LIBCPP_TYPE_VIS __deque_iterator; template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2> @@ -1167,7 +1167,7 @@ __deque_base<_Tp, _Allocator>::clear() _NOEXCEPT } template <class _Tp, class _Allocator = allocator<_Tp> > -class _LIBCPP_VISIBLE deque +class _LIBCPP_TYPE_VIS deque : private __deque_base<_Tp, _Allocator> { public: diff --git a/contrib/libc++/include/exception b/contrib/libc++/include/exception index 51a48c8..37bfc57 100644 --- a/contrib/libc++/include/exception +++ b/contrib/libc++/include/exception @@ -105,23 +105,23 @@ public: }; typedef void (*unexpected_handler)(); -_LIBCPP_VISIBLE unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT; -_LIBCPP_VISIBLE unexpected_handler get_unexpected() _NOEXCEPT; -_LIBCPP_NORETURN _LIBCPP_VISIBLE void unexpected(); +_LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT; +_LIBCPP_FUNC_VIS unexpected_handler get_unexpected() _NOEXCEPT; +_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void unexpected(); typedef void (*terminate_handler)(); -_LIBCPP_VISIBLE terminate_handler set_terminate(terminate_handler) _NOEXCEPT; -_LIBCPP_VISIBLE terminate_handler get_terminate() _NOEXCEPT; -_LIBCPP_NORETURN _LIBCPP_VISIBLE void terminate() _NOEXCEPT; +_LIBCPP_FUNC_VIS terminate_handler set_terminate(terminate_handler) _NOEXCEPT; +_LIBCPP_FUNC_VIS terminate_handler get_terminate() _NOEXCEPT; +_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void terminate() _NOEXCEPT; -_LIBCPP_VISIBLE bool uncaught_exception() _NOEXCEPT; +_LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT; -class _LIBCPP_VISIBLE exception_ptr; +class _LIBCPP_TYPE_VIS exception_ptr; exception_ptr current_exception() _NOEXCEPT; _LIBCPP_NORETURN void rethrow_exception(exception_ptr); -class _LIBCPP_VISIBLE exception_ptr +class _LIBCPP_TYPE_VIS exception_ptr { void* __ptr_; public: diff --git a/contrib/libc++/include/ext/__hash b/contrib/libc++/include/ext/__hash index 21500e8..f6ecfe3 100644 --- a/contrib/libc++/include/ext/__hash +++ b/contrib/libc++/include/ext/__hash @@ -19,10 +19,10 @@ namespace __gnu_cxx { using namespace std; -template <typename T> struct _LIBCPP_VISIBLE hash : public std::hash<T> +template <typename T> struct _LIBCPP_TYPE_VIS hash : public std::hash<T> { }; -template <> struct _LIBCPP_VISIBLE hash<const char*> +template <> struct _LIBCPP_TYPE_VIS hash<const char*> : public unary_function<const char*, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -32,7 +32,7 @@ template <> struct _LIBCPP_VISIBLE hash<const char*> } }; -template <> struct _LIBCPP_VISIBLE hash<char *> +template <> struct _LIBCPP_TYPE_VIS hash<char *> : public unary_function<char*, size_t> { _LIBCPP_INLINE_VISIBILITY diff --git a/contrib/libc++/include/ext/hash_map b/contrib/libc++/include/ext/hash_map index bebdccb..a6fe894 100644 --- a/contrib/libc++/include/ext/hash_map +++ b/contrib/libc++/include/ext/hash_map @@ -361,7 +361,7 @@ public: }; template <class _HashIterator> -class _LIBCPP_VISIBLE __hash_map_iterator +class _LIBCPP_TYPE_VIS __hash_map_iterator { _HashIterator __i_; @@ -404,15 +404,15 @@ public: bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y) {return __x.__i_ != __y.__i_;} - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_map; - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_multimap; - template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator; - template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator; - template <class> friend class _LIBCPP_VISIBLE __hash_map_const_iterator; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS hash_map; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS hash_multimap; + template <class> friend class _LIBCPP_TYPE_VIS __hash_const_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator; }; template <class _HashIterator> -class _LIBCPP_VISIBLE __hash_map_const_iterator +class _LIBCPP_TYPE_VIS __hash_map_const_iterator { _HashIterator __i_; @@ -463,15 +463,15 @@ public: bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) {return __x.__i_ != __y.__i_;} - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_map; - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE hash_multimap; - template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator; - template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS hash_map; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS hash_multimap; + template <class> friend class _LIBCPP_TYPE_VIS __hash_const_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator; }; template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>, class _Alloc = allocator<pair<const _Key, _Tp> > > -class _LIBCPP_VISIBLE hash_map +class _LIBCPP_TYPE_VIS hash_map { public: // types @@ -750,7 +750,7 @@ operator!=(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>, class _Alloc = allocator<pair<const _Key, _Tp> > > -class _LIBCPP_VISIBLE hash_multimap +class _LIBCPP_TYPE_VIS hash_multimap { public: // types diff --git a/contrib/libc++/include/ext/hash_set b/contrib/libc++/include/ext/hash_set index 14daf7b..52bbeee 100644 --- a/contrib/libc++/include/ext/hash_set +++ b/contrib/libc++/include/ext/hash_set @@ -208,7 +208,7 @@ using namespace std; template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> > -class _LIBCPP_VISIBLE hash_set +class _LIBCPP_TYPE_VIS hash_set { public: // types @@ -429,7 +429,7 @@ operator!=(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x, template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> > -class _LIBCPP_VISIBLE hash_multiset +class _LIBCPP_TYPE_VIS hash_multiset { public: // types diff --git a/contrib/libc++/include/forward_list b/contrib/libc++/include/forward_list index 404c6eb..0cbf2fd 100644 --- a/contrib/libc++/include/forward_list +++ b/contrib/libc++/include/forward_list @@ -212,11 +212,11 @@ struct __forward_list_node value_type __value_; }; -template<class _Tp, class _Alloc> class _LIBCPP_VISIBLE forward_list; -template<class _NodeConstPtr> class _LIBCPP_VISIBLE __forward_list_const_iterator; +template<class _Tp, class _Alloc> class _LIBCPP_TYPE_VIS forward_list; +template<class _NodeConstPtr> class _LIBCPP_TYPE_VIS __forward_list_const_iterator; template <class _NodePtr> -class _LIBCPP_VISIBLE __forward_list_iterator +class _LIBCPP_TYPE_VIS __forward_list_iterator { typedef _NodePtr __node_pointer; @@ -225,8 +225,8 @@ class _LIBCPP_VISIBLE __forward_list_iterator _LIBCPP_INLINE_VISIBILITY explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {} - template<class, class> friend class _LIBCPP_VISIBLE forward_list; - template<class> friend class _LIBCPP_VISIBLE __forward_list_const_iterator; + template<class, class> friend class _LIBCPP_TYPE_VIS forward_list; + template<class> friend class _LIBCPP_TYPE_VIS __forward_list_const_iterator; public: typedef forward_iterator_tag iterator_category; @@ -276,7 +276,7 @@ public: }; template <class _NodeConstPtr> -class _LIBCPP_VISIBLE __forward_list_const_iterator +class _LIBCPP_TYPE_VIS __forward_list_const_iterator { typedef _NodeConstPtr __node_const_pointer; @@ -533,7 +533,7 @@ __forward_list_base<_Tp, _Alloc>::clear() _NOEXCEPT } template <class _Tp, class _Alloc = allocator<_Tp> > -class _LIBCPP_VISIBLE forward_list +class _LIBCPP_TYPE_VIS forward_list : private __forward_list_base<_Tp, _Alloc> { typedef __forward_list_base<_Tp, _Alloc> base; diff --git a/contrib/libc++/include/fstream b/contrib/libc++/include/fstream index 1b8e7a0..e3f8306 100644 --- a/contrib/libc++/include/fstream +++ b/contrib/libc++/include/fstream @@ -180,7 +180,7 @@ typedef basic_fstream<wchar_t> wfstream; _LIBCPP_BEGIN_NAMESPACE_STD template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_filebuf +class _LIBCPP_TYPE_VIS basic_filebuf : public basic_streambuf<_CharT, _Traits> { public: @@ -807,9 +807,15 @@ basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way, default: return pos_type(off_type(-1)); } +#if _WIN32 + if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence)) + return pos_type(off_type(-1)); + pos_type __r = ftell(__file_); +#else if (fseeko(__file_, __width > 0 ? __width * __off : 0, __whence)) return pos_type(off_type(-1)); pos_type __r = ftello(__file_); +#endif __r.state(__st_); return __r; } @@ -820,8 +826,13 @@ basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode) { if (__file_ == 0 || sync()) return pos_type(off_type(-1)); +#if _WIN32 + if (fseek(__file_, __sp, SEEK_SET)) + return pos_type(off_type(-1)); +#else if (fseeko(__file_, __sp, SEEK_SET)) return pos_type(off_type(-1)); +#endif __st_ = __sp.state(); return __sp; } @@ -880,8 +891,13 @@ basic_filebuf<_CharT, _Traits>::sync() } } } +#if _WIN32 + if (fseek(__file_, -__c, SEEK_CUR)) + return -1; +#else if (fseeko(__file_, -__c, SEEK_CUR)) return -1; +#endif if (__update_st) __st_ = __state; __extbufnext_ = __extbufend_ = __extbuf_; @@ -978,7 +994,7 @@ basic_filebuf<_CharT, _Traits>::__write_mode() // basic_ifstream template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_ifstream +class _LIBCPP_TYPE_VIS basic_ifstream : public basic_istream<_CharT, _Traits> { public: @@ -1123,7 +1139,7 @@ basic_ifstream<_CharT, _Traits>::close() // basic_ofstream template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_ofstream +class _LIBCPP_TYPE_VIS basic_ofstream : public basic_ostream<_CharT, _Traits> { public: @@ -1268,7 +1284,7 @@ basic_ofstream<_CharT, _Traits>::close() // basic_fstream template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_fstream +class _LIBCPP_TYPE_VIS basic_fstream : public basic_iostream<_CharT, _Traits> { public: diff --git a/contrib/libc++/include/functional b/contrib/libc++/include/functional index 3bee1ed..995db56 100644 --- a/contrib/libc++/include/functional +++ b/contrib/libc++/include/functional @@ -474,63 +474,63 @@ POLICY: For non-variadic implementations, the number of arguments is limited _LIBCPP_BEGIN_NAMESPACE_STD template <class _Tp> -struct _LIBCPP_VISIBLE plus : binary_function<_Tp, _Tp, _Tp> +struct _LIBCPP_TYPE_VIS plus : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x + __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE minus : binary_function<_Tp, _Tp, _Tp> +struct _LIBCPP_TYPE_VIS minus : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x - __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE multiplies : binary_function<_Tp, _Tp, _Tp> +struct _LIBCPP_TYPE_VIS multiplies : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x * __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE divides : binary_function<_Tp, _Tp, _Tp> +struct _LIBCPP_TYPE_VIS divides : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x / __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE modulus : binary_function<_Tp, _Tp, _Tp> +struct _LIBCPP_TYPE_VIS modulus : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x % __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE negate : unary_function<_Tp, _Tp> +struct _LIBCPP_TYPE_VIS negate : unary_function<_Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return -__x;} }; template <class _Tp> -struct _LIBCPP_VISIBLE equal_to : binary_function<_Tp, _Tp, bool> +struct _LIBCPP_TYPE_VIS equal_to : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x == __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE not_equal_to : binary_function<_Tp, _Tp, bool> +struct _LIBCPP_TYPE_VIS not_equal_to : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x != __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE greater : binary_function<_Tp, _Tp, bool> +struct _LIBCPP_TYPE_VIS greater : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x > __y;} @@ -539,63 +539,63 @@ struct _LIBCPP_VISIBLE greater : binary_function<_Tp, _Tp, bool> // less in <__functional_base> template <class _Tp> -struct _LIBCPP_VISIBLE greater_equal : binary_function<_Tp, _Tp, bool> +struct _LIBCPP_TYPE_VIS greater_equal : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x >= __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE less_equal : binary_function<_Tp, _Tp, bool> +struct _LIBCPP_TYPE_VIS less_equal : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x <= __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE logical_and : binary_function<_Tp, _Tp, bool> +struct _LIBCPP_TYPE_VIS logical_and : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x && __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE logical_or : binary_function<_Tp, _Tp, bool> +struct _LIBCPP_TYPE_VIS logical_or : binary_function<_Tp, _Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const {return __x || __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE logical_not : unary_function<_Tp, bool> +struct _LIBCPP_TYPE_VIS logical_not : unary_function<_Tp, bool> { _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x) const {return !__x;} }; template <class _Tp> -struct _LIBCPP_VISIBLE bit_and : binary_function<_Tp, _Tp, _Tp> +struct _LIBCPP_TYPE_VIS bit_and : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x & __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE bit_or : binary_function<_Tp, _Tp, _Tp> +struct _LIBCPP_TYPE_VIS bit_or : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x | __y;} }; template <class _Tp> -struct _LIBCPP_VISIBLE bit_xor : binary_function<_Tp, _Tp, _Tp> +struct _LIBCPP_TYPE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp> { _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x ^ __y;} }; template <class _Predicate> -class _LIBCPP_VISIBLE unary_negate +class _LIBCPP_TYPE_VIS unary_negate : public unary_function<typename _Predicate::argument_type, bool> { _Predicate __pred_; @@ -612,7 +612,7 @@ unary_negate<_Predicate> not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);} template <class _Predicate> -class _LIBCPP_VISIBLE binary_negate +class _LIBCPP_TYPE_VIS binary_negate : public binary_function<typename _Predicate::first_argument_type, typename _Predicate::second_argument_type, bool> @@ -632,7 +632,7 @@ binary_negate<_Predicate> not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);} template <class __Operation> -class _LIBCPP_VISIBLE binder1st +class _LIBCPP_TYPE_VIS binder1st : public unary_function<typename __Operation::second_argument_type, typename __Operation::result_type> { @@ -658,7 +658,7 @@ bind1st(const __Operation& __op, const _Tp& __x) {return binder1st<__Operation>(__op, __x);} template <class __Operation> -class _LIBCPP_VISIBLE binder2nd +class _LIBCPP_TYPE_VIS binder2nd : public unary_function<typename __Operation::first_argument_type, typename __Operation::result_type> { @@ -684,7 +684,7 @@ bind2nd(const __Operation& __op, const _Tp& __x) {return binder2nd<__Operation>(__op, __x);} template <class _Arg, class _Result> -class _LIBCPP_VISIBLE pointer_to_unary_function +class _LIBCPP_TYPE_VIS pointer_to_unary_function : public unary_function<_Arg, _Result> { _Result (*__f_)(_Arg); @@ -702,7 +702,7 @@ ptr_fun(_Result (*__f)(_Arg)) {return pointer_to_unary_function<_Arg,_Result>(__f);} template <class _Arg1, class _Arg2, class _Result> -class _LIBCPP_VISIBLE pointer_to_binary_function +class _LIBCPP_TYPE_VIS pointer_to_binary_function : public binary_function<_Arg1, _Arg2, _Result> { _Result (*__f_)(_Arg1, _Arg2); @@ -720,7 +720,7 @@ ptr_fun(_Result (*__f)(_Arg1,_Arg2)) {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);} template<class _Sp, class _Tp> -class _LIBCPP_VISIBLE mem_fun_t : public unary_function<_Tp*, _Sp> +class _LIBCPP_TYPE_VIS mem_fun_t : public unary_function<_Tp*, _Sp> { _Sp (_Tp::*__p_)(); public: @@ -731,7 +731,7 @@ public: }; template<class _Sp, class _Tp, class _Ap> -class _LIBCPP_VISIBLE mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp> +class _LIBCPP_TYPE_VIS mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp> { _Sp (_Tp::*__p_)(_Ap); public: @@ -754,7 +754,7 @@ mem_fun(_Sp (_Tp::*__f)(_Ap)) {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);} template<class _Sp, class _Tp> -class _LIBCPP_VISIBLE mem_fun_ref_t : public unary_function<_Tp, _Sp> +class _LIBCPP_TYPE_VIS mem_fun_ref_t : public unary_function<_Tp, _Sp> { _Sp (_Tp::*__p_)(); public: @@ -765,7 +765,7 @@ public: }; template<class _Sp, class _Tp, class _Ap> -class _LIBCPP_VISIBLE mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp> +class _LIBCPP_TYPE_VIS mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp> { _Sp (_Tp::*__p_)(_Ap); public: @@ -788,7 +788,7 @@ mem_fun_ref(_Sp (_Tp::*__f)(_Ap)) {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);} template <class _Sp, class _Tp> -class _LIBCPP_VISIBLE const_mem_fun_t : public unary_function<const _Tp*, _Sp> +class _LIBCPP_TYPE_VIS const_mem_fun_t : public unary_function<const _Tp*, _Sp> { _Sp (_Tp::*__p_)() const; public: @@ -799,7 +799,7 @@ public: }; template <class _Sp, class _Tp, class _Ap> -class _LIBCPP_VISIBLE const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp> +class _LIBCPP_TYPE_VIS const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp> { _Sp (_Tp::*__p_)(_Ap) const; public: @@ -822,7 +822,7 @@ mem_fun(_Sp (_Tp::*__f)(_Ap) const) {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);} template <class _Sp, class _Tp> -class _LIBCPP_VISIBLE const_mem_fun_ref_t : public unary_function<_Tp, _Sp> +class _LIBCPP_TYPE_VIS const_mem_fun_ref_t : public unary_function<_Tp, _Sp> { _Sp (_Tp::*__p_)() const; public: @@ -833,7 +833,7 @@ public: }; template <class _Sp, class _Tp, class _Ap> -class _LIBCPP_VISIBLE const_mem_fun1_ref_t +class _LIBCPP_TYPE_VIS const_mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp> { _Sp (_Tp::*__p_)(_Ap) const; @@ -932,7 +932,7 @@ class _LIBCPP_EXCEPTION_ABI bad_function_call { }; -template<class _Fp> class _LIBCPP_VISIBLE function; // undefined +template<class _Fp> class _LIBCPP_TYPE_VIS function; // undefined namespace __function { @@ -1083,7 +1083,7 @@ __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT } // __function template<class _Rp, class ..._ArgTypes> -class _LIBCPP_VISIBLE function<_Rp(_ArgTypes...)> +class _LIBCPP_TYPE_VIS function<_Rp(_ArgTypes...)> : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>, public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)> { @@ -1496,11 +1496,11 @@ swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCE {return __x.swap(__y);} template<class _Tp> struct __is_bind_expression : public false_type {}; -template<class _Tp> struct _LIBCPP_VISIBLE is_bind_expression +template<class _Tp> struct _LIBCPP_TYPE_VIS is_bind_expression : public __is_bind_expression<typename remove_cv<_Tp>::type> {}; template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {}; -template<class _Tp> struct _LIBCPP_VISIBLE is_placeholder +template<class _Tp> struct _LIBCPP_TYPE_VIS is_placeholder : public __is_placeholder<typename remove_cv<_Tp>::type> {}; namespace placeholders @@ -1624,16 +1624,38 @@ struct __mu_return : public ____mu_return<_Ti, __is_reference_wrapper<_Ti>::value, is_bind_expression<_Ti>::value, - 0 < is_placeholder<_Ti>::value, + 0 < is_placeholder<_Ti>::value && + is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value, _TupleUj> { }; template <class _Fp, class _BoundArgs, class _TupleUj> +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> +{ + 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> +{ + 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> struct __bind_return; template <class _Fp, class ..._BoundArgs, class _TupleUj> -struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> +struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true> { typedef typename __invoke_of < @@ -1647,7 +1669,7 @@ struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> }; template <class _Fp, class ..._BoundArgs, class _TupleUj> -struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> +struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true> { typedef typename __invoke_of < @@ -1673,8 +1695,10 @@ template<class _Fp, class ..._BoundArgs> class __bind : public __weak_result_type<typename decay<_Fp>::type> { +protected: typedef typename decay<_Fp>::type _Fd; typedef tuple<typename decay<_BoundArgs>::type...> _Td; +private: _Fd __f_; _Td __bound_args_; @@ -1731,7 +1755,7 @@ public: template <class ..._Args> _LIBCPP_INLINE_VISIBILITY - typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type + typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type operator()(_Args&& ...__args) const { return __apply_functor(__f_, __bound_args_, __indices(), @@ -1747,6 +1771,8 @@ class __bind_r : public __bind<_Fp, _BoundArgs...> { typedef __bind<_Fp, _BoundArgs...> base; + typedef typename base::_Fd _Fd; + typedef typename base::_Td _Td; public: typedef _Rp result_type; @@ -1784,7 +1810,12 @@ public: template <class ..._Args> _LIBCPP_INLINE_VISIBILITY - result_type + typename enable_if + < + is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type, + result_type>::value, + result_type + >::type operator()(_Args&& ...__args) { return base::operator()(_VSTD::forward<_Args>(__args)...); @@ -1792,7 +1823,12 @@ public: template <class ..._Args> _LIBCPP_INLINE_VISIBILITY - result_type + typename enable_if + < + is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type, + result_type>::value, + result_type + >::type operator()(_Args&& ...__args) const { return base::operator()(_VSTD::forward<_Args>(__args)...); @@ -1823,7 +1859,7 @@ bind(_Fp&& __f, _BoundArgs&&... __bound_args) #endif // _LIBCPP_HAS_NO_VARIADICS template <> -struct _LIBCPP_VISIBLE hash<bool> +struct _LIBCPP_TYPE_VIS hash<bool> : public unary_function<bool, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1831,7 +1867,7 @@ struct _LIBCPP_VISIBLE hash<bool> }; template <> -struct _LIBCPP_VISIBLE hash<char> +struct _LIBCPP_TYPE_VIS hash<char> : public unary_function<char, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1839,7 +1875,7 @@ struct _LIBCPP_VISIBLE hash<char> }; template <> -struct _LIBCPP_VISIBLE hash<signed char> +struct _LIBCPP_TYPE_VIS hash<signed char> : public unary_function<signed char, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1847,7 +1883,7 @@ struct _LIBCPP_VISIBLE hash<signed char> }; template <> -struct _LIBCPP_VISIBLE hash<unsigned char> +struct _LIBCPP_TYPE_VIS hash<unsigned char> : public unary_function<unsigned char, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1857,7 +1893,7 @@ struct _LIBCPP_VISIBLE hash<unsigned char> #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS template <> -struct _LIBCPP_VISIBLE hash<char16_t> +struct _LIBCPP_TYPE_VIS hash<char16_t> : public unary_function<char16_t, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1865,7 +1901,7 @@ struct _LIBCPP_VISIBLE hash<char16_t> }; template <> -struct _LIBCPP_VISIBLE hash<char32_t> +struct _LIBCPP_TYPE_VIS hash<char32_t> : public unary_function<char32_t, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1875,7 +1911,7 @@ struct _LIBCPP_VISIBLE hash<char32_t> #endif // _LIBCPP_HAS_NO_UNICODE_CHARS template <> -struct _LIBCPP_VISIBLE hash<wchar_t> +struct _LIBCPP_TYPE_VIS hash<wchar_t> : public unary_function<wchar_t, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1883,7 +1919,7 @@ struct _LIBCPP_VISIBLE hash<wchar_t> }; template <> -struct _LIBCPP_VISIBLE hash<short> +struct _LIBCPP_TYPE_VIS hash<short> : public unary_function<short, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1891,7 +1927,7 @@ struct _LIBCPP_VISIBLE hash<short> }; template <> -struct _LIBCPP_VISIBLE hash<unsigned short> +struct _LIBCPP_TYPE_VIS hash<unsigned short> : public unary_function<unsigned short, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1899,7 +1935,7 @@ struct _LIBCPP_VISIBLE hash<unsigned short> }; template <> -struct _LIBCPP_VISIBLE hash<int> +struct _LIBCPP_TYPE_VIS hash<int> : public unary_function<int, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1907,7 +1943,7 @@ struct _LIBCPP_VISIBLE hash<int> }; template <> -struct _LIBCPP_VISIBLE hash<unsigned int> +struct _LIBCPP_TYPE_VIS hash<unsigned int> : public unary_function<unsigned int, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1915,7 +1951,7 @@ struct _LIBCPP_VISIBLE hash<unsigned int> }; template <> -struct _LIBCPP_VISIBLE hash<long> +struct _LIBCPP_TYPE_VIS hash<long> : public unary_function<long, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1923,7 +1959,7 @@ struct _LIBCPP_VISIBLE hash<long> }; template <> -struct _LIBCPP_VISIBLE hash<unsigned long> +struct _LIBCPP_TYPE_VIS hash<unsigned long> : public unary_function<unsigned long, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -1931,19 +1967,19 @@ struct _LIBCPP_VISIBLE hash<unsigned long> }; template <> -struct _LIBCPP_VISIBLE hash<long long> +struct _LIBCPP_TYPE_VIS hash<long long> : public __scalar_hash<long long> { }; template <> -struct _LIBCPP_VISIBLE hash<unsigned long long> +struct _LIBCPP_TYPE_VIS hash<unsigned long long> : public __scalar_hash<unsigned long long> { }; template <> -struct _LIBCPP_VISIBLE hash<float> +struct _LIBCPP_TYPE_VIS hash<float> : public __scalar_hash<float> { _LIBCPP_INLINE_VISIBILITY @@ -1957,7 +1993,7 @@ struct _LIBCPP_VISIBLE hash<float> }; template <> -struct _LIBCPP_VISIBLE hash<double> +struct _LIBCPP_TYPE_VIS hash<double> : public __scalar_hash<double> { _LIBCPP_INLINE_VISIBILITY @@ -1971,7 +2007,7 @@ struct _LIBCPP_VISIBLE hash<double> }; template <> -struct _LIBCPP_VISIBLE hash<long double> +struct _LIBCPP_TYPE_VIS hash<long double> : public __scalar_hash<long double> { _LIBCPP_INLINE_VISIBILITY diff --git a/contrib/libc++/include/future b/contrib/libc++/include/future index fa605e7..3d7bb6c 100644 --- a/contrib/libc++/include/future +++ b/contrib/libc++/include/future @@ -387,11 +387,11 @@ _LIBCPP_DECLARE_STRONG_ENUM(future_errc) _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc) template <> -struct _LIBCPP_VISIBLE is_error_code_enum<future_errc> : public true_type {}; +struct _LIBCPP_TYPE_VIS is_error_code_enum<future_errc> : public true_type {}; #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS template <> -struct _LIBCPP_VISIBLE is_error_code_enum<future_errc::__lx> : public true_type { }; +struct _LIBCPP_TYPE_VIS is_error_code_enum<future_errc::__lx> : public true_type { }; #endif //enum class launch @@ -412,7 +412,7 @@ _LIBCPP_DECLARE_STRONG_ENUM(future_status) }; _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status) -_LIBCPP_VISIBLE +_LIBCPP_FUNC_VIS const error_category& future_category() _NOEXCEPT; inline _LIBCPP_INLINE_VISIBILITY @@ -966,12 +966,12 @@ __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT base::__on_zero_shared(); } -template <class _Rp> class _LIBCPP_VISIBLE promise; -template <class _Rp> class _LIBCPP_VISIBLE shared_future; +template <class _Rp> class _LIBCPP_TYPE_VIS promise; +template <class _Rp> class _LIBCPP_TYPE_VIS shared_future; // future -template <class _Rp> class _LIBCPP_VISIBLE future; +template <class _Rp> class _LIBCPP_TYPE_VIS future; template <class _Rp, class _Fp> future<_Rp> @@ -990,7 +990,7 @@ __make_async_assoc_state(_Fp __f); #endif template <class _Rp> -class _LIBCPP_VISIBLE future +class _LIBCPP_TYPE_VIS future { __assoc_state<_Rp>* __state_; @@ -1094,7 +1094,7 @@ future<_Rp>::get() } template <class _Rp> -class _LIBCPP_VISIBLE future<_Rp&> +class _LIBCPP_TYPE_VIS future<_Rp&> { __assoc_state<_Rp&>* __state_; @@ -1193,7 +1193,7 @@ future<_Rp&>::get() } template <> -class _LIBCPP_VISIBLE future<void> +class _LIBCPP_TYPE_VIS future<void> { __assoc_sub_state* __state_; @@ -1275,7 +1275,7 @@ swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT template <class _Callable> class packaged_task; template <class _Rp> -class _LIBCPP_VISIBLE promise +class _LIBCPP_TYPE_VIS promise { __assoc_state<_Rp>* __state_; @@ -1453,7 +1453,7 @@ promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p) // promise<R&> template <class _Rp> -class _LIBCPP_VISIBLE promise<_Rp&> +class _LIBCPP_TYPE_VIS promise<_Rp&> { __assoc_state<_Rp&>* __state_; @@ -1596,7 +1596,7 @@ promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p) // promise<void> template <> -class _LIBCPP_VISIBLE promise<void> +class _LIBCPP_TYPE_VIS promise<void> { __assoc_sub_state* __state_; @@ -1670,7 +1670,7 @@ swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT } template <class _Rp, class _Alloc> - struct _LIBCPP_VISIBLE uses_allocator<promise<_Rp>, _Alloc> + struct _LIBCPP_TYPE_VIS uses_allocator<promise<_Rp>, _Alloc> : public true_type {}; #ifndef _LIBCPP_HAS_NO_VARIADICS @@ -1934,7 +1934,7 @@ __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) cons } template<class _Rp, class ..._ArgTypes> -class _LIBCPP_VISIBLE packaged_task<_Rp(_ArgTypes...)> +class _LIBCPP_TYPE_VIS packaged_task<_Rp(_ArgTypes...)> { public: typedef _Rp result_type; @@ -2049,7 +2049,7 @@ packaged_task<_Rp(_ArgTypes...)>::reset() } template<class ..._ArgTypes> -class _LIBCPP_VISIBLE packaged_task<void(_ArgTypes...)> +class _LIBCPP_TYPE_VIS packaged_task<void(_ArgTypes...)> { public: typedef void result_type; @@ -2174,7 +2174,7 @@ swap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) _NOEXCEPT } template <class _Callable, class _Alloc> -struct _LIBCPP_VISIBLE uses_allocator<packaged_task<_Callable>, _Alloc> +struct _LIBCPP_TYPE_VIS uses_allocator<packaged_task<_Callable>, _Alloc> : public true_type {}; template <class _Rp, class _Fp> @@ -2263,7 +2263,7 @@ async(_Fp&& __f, _Args&&... __args) // shared_future template <class _Rp> -class _LIBCPP_VISIBLE shared_future +class _LIBCPP_TYPE_VIS shared_future { __assoc_state<_Rp>* __state_; @@ -2337,7 +2337,7 @@ shared_future<_Rp>::operator=(const shared_future& __rhs) } template <class _Rp> -class _LIBCPP_VISIBLE shared_future<_Rp&> +class _LIBCPP_TYPE_VIS shared_future<_Rp&> { __assoc_state<_Rp&>* __state_; @@ -2411,7 +2411,7 @@ shared_future<_Rp&>::operator=(const shared_future& __rhs) } template <> -class _LIBCPP_VISIBLE shared_future<void> +class _LIBCPP_TYPE_VIS shared_future<void> { __assoc_sub_state* __state_; diff --git a/contrib/libc++/include/initializer_list b/contrib/libc++/include/initializer_list index 2f88514..181313d 100644 --- a/contrib/libc++/include/initializer_list +++ b/contrib/libc++/include/initializer_list @@ -56,7 +56,7 @@ namespace std // purposefully not versioned #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS template<class _Ep> -class _LIBCPP_VISIBLE initializer_list +class _LIBCPP_TYPE_VIS initializer_list { const _Ep* __begin_; size_t __size_; diff --git a/contrib/libc++/include/ios b/contrib/libc++/include/ios index 1474deb..25bbfc0 100644 --- a/contrib/libc++/include/ios +++ b/contrib/libc++/include/ios @@ -224,10 +224,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD typedef ptrdiff_t streamsize; -class _LIBCPP_VISIBLE ios_base +class _LIBCPP_TYPE_VIS ios_base { public: - class _LIBCPP_VISIBLE failure; + class _LIBCPP_TYPE_VIS failure; typedef unsigned int fmtflags; static const fmtflags boolalpha = 0x0001; @@ -271,7 +271,7 @@ public: typedef _VSTD::streamoff streamoff; typedef _VSTD::streampos streampos; - class _LIBCPP_VISIBLE Init; + class _LIBCPP_TYPE_VIS Init; // 27.5.2.2 fmtflags state: _LIBCPP_INLINE_VISIBILITY fmtflags flags() const; @@ -380,14 +380,14 @@ _LIBCPP_DECLARE_STRONG_ENUM(io_errc) _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc) template <> -struct _LIBCPP_VISIBLE is_error_code_enum<io_errc> : public true_type { }; +struct _LIBCPP_TYPE_VIS is_error_code_enum<io_errc> : public true_type { }; #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS template <> -struct _LIBCPP_VISIBLE is_error_code_enum<io_errc::__lx> : public true_type { }; +struct _LIBCPP_TYPE_VIS is_error_code_enum<io_errc::__lx> : public true_type { }; #endif -_LIBCPP_VISIBLE +_LIBCPP_FUNC_VIS const error_category& iostream_category(); inline _LIBCPP_INLINE_VISIBILITY @@ -413,7 +413,7 @@ public: virtual ~failure() throw(); }; -class _LIBCPP_VISIBLE ios_base::Init +class _LIBCPP_TYPE_VIS ios_base::Init { public: Init(); @@ -560,7 +560,7 @@ ios_base::exceptions(iostate __except) } template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_ios +class _LIBCPP_TYPE_VIS basic_ios : public ios_base { public: diff --git a/contrib/libc++/include/iosfwd b/contrib/libc++/include/iosfwd index efdff5f..849d7e5 100644 --- a/contrib/libc++/include/iosfwd +++ b/contrib/libc++/include/iosfwd @@ -95,49 +95,49 @@ typedef fpos<char_traits<wchar_t>::state_type> wstreampos; _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE ios_base; +class _LIBCPP_TYPE_VIS ios_base; -template<class _CharT> struct _LIBCPP_VISIBLE char_traits; -template<class _Tp> class _LIBCPP_VISIBLE allocator; +template<class _CharT> struct _LIBCPP_TYPE_VIS char_traits; +template<class _Tp> class _LIBCPP_TYPE_VIS allocator; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE basic_ios; + class _LIBCPP_TYPE_VIS basic_ios; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE basic_streambuf; + class _LIBCPP_TYPE_VIS basic_streambuf; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE basic_istream; + class _LIBCPP_TYPE_VIS basic_istream; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE basic_ostream; + class _LIBCPP_TYPE_VIS basic_ostream; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE basic_iostream; + class _LIBCPP_TYPE_VIS basic_iostream; template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > - class _LIBCPP_VISIBLE basic_stringbuf; + class _LIBCPP_TYPE_VIS basic_stringbuf; template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > - class _LIBCPP_VISIBLE basic_istringstream; + class _LIBCPP_TYPE_VIS basic_istringstream; template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > - class _LIBCPP_VISIBLE basic_ostringstream; + class _LIBCPP_TYPE_VIS basic_ostringstream; template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > - class _LIBCPP_VISIBLE basic_stringstream; + class _LIBCPP_TYPE_VIS basic_stringstream; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE basic_filebuf; + class _LIBCPP_TYPE_VIS basic_filebuf; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE basic_ifstream; + class _LIBCPP_TYPE_VIS basic_ifstream; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE basic_ofstream; + class _LIBCPP_TYPE_VIS basic_ofstream; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE basic_fstream; + class _LIBCPP_TYPE_VIS basic_fstream; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE istreambuf_iterator; + class _LIBCPP_TYPE_VIS istreambuf_iterator; template <class _CharT, class _Traits = char_traits<_CharT> > - class _LIBCPP_VISIBLE ostreambuf_iterator; + class _LIBCPP_TYPE_VIS ostreambuf_iterator; typedef basic_ios<char> ios; typedef basic_ios<wchar_t> wios; @@ -172,7 +172,7 @@ typedef basic_ifstream<wchar_t> wifstream; typedef basic_ofstream<wchar_t> wofstream; typedef basic_fstream<wchar_t> wfstream; -template <class _State> class _LIBCPP_VISIBLE fpos; +template <class _State> class _LIBCPP_TYPE_VIS fpos; typedef fpos<mbstate_t> streampos; typedef fpos<mbstate_t> wstreampos; #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS @@ -185,7 +185,7 @@ typedef long long streamoff; // for char_traits in <string> template <class _CharT, // for <stdexcept> class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > - class _LIBCPP_VISIBLE basic_string; + class _LIBCPP_TYPE_VIS basic_string; typedef basic_string<char, char_traits<char>, allocator<char> > string; typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring; diff --git a/contrib/libc++/include/iostream b/contrib/libc++/include/iostream index 53cd146..ddf2484 100644 --- a/contrib/libc++/include/iostream +++ b/contrib/libc++/include/iostream @@ -46,14 +46,14 @@ extern wostream wclog; _LIBCPP_BEGIN_NAMESPACE_STD -extern _LIBCPP_VISIBLE istream cin; -extern _LIBCPP_VISIBLE ostream cout; -extern _LIBCPP_VISIBLE ostream cerr; -extern _LIBCPP_VISIBLE ostream clog; -extern _LIBCPP_VISIBLE wistream wcin; -extern _LIBCPP_VISIBLE wostream wcout; -extern _LIBCPP_VISIBLE wostream wcerr; -extern _LIBCPP_VISIBLE wostream wclog; +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; +extern _LIBCPP_FUNC_VIS wostream wcout; +extern _LIBCPP_FUNC_VIS wostream wcerr; +extern _LIBCPP_FUNC_VIS wostream wclog; _LIBCPP_END_NAMESPACE_STD diff --git a/contrib/libc++/include/istream b/contrib/libc++/include/istream index 3979e14..3f629f6 100644 --- a/contrib/libc++/include/istream +++ b/contrib/libc++/include/istream @@ -164,7 +164,7 @@ template <class charT, class traits, class T> _LIBCPP_BEGIN_NAMESPACE_STD template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_istream +class _LIBCPP_TYPE_VIS basic_istream : virtual public basic_ios<_CharT, _Traits> { streamsize __gc_; @@ -194,7 +194,7 @@ protected: public: // 27.7.1.1.3 Prefix/suffix: - class _LIBCPP_VISIBLE sentry; + class _LIBCPP_TYPE_VIS sentry; // 27.7.1.2 Formatted input: basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&)); @@ -244,7 +244,7 @@ public: }; template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_istream<_CharT, _Traits>::sentry +class _LIBCPP_TYPE_VIS basic_istream<_CharT, _Traits>::sentry { bool __ok_; @@ -1216,16 +1216,9 @@ basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) sentry __sen(*this, true); if (__sen) { - for (; __gc_ < __n; ++__gc_) - { - typename traits_type::int_type __i = this->rdbuf()->sbumpc(); - if (traits_type::eq_int_type(__i, traits_type::eof())) - { - this->setstate(ios_base::failbit | ios_base::eofbit); - break; - } - *__s++ = traits_type::to_char_type(__i); - } + __gc_ = this->rdbuf()->sgetn(__s, __n); + if (__gc_ != __n) + this->setstate(ios_base::failbit | ios_base::eofbit); } else this->setstate(ios_base::failbit); @@ -1460,7 +1453,7 @@ operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x) #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_iostream +class _LIBCPP_TYPE_VIS basic_iostream : public basic_istream<_CharT, _Traits>, public basic_ostream<_CharT, _Traits> { diff --git a/contrib/libc++/include/iterator b/contrib/libc++/include/iterator index b23310b..3b078a2 100644 --- a/contrib/libc++/include/iterator +++ b/contrib/libc++/include/iterator @@ -317,7 +317,7 @@ template <class T, size_t N> T* end(T (&array)[N]); #include <type_traits> #include <cstddef> #include <iosfwd> -#if __APPLE__ +#ifdef __APPLE__ #include <Availability.h> #endif @@ -331,11 +331,11 @@ template <class T, size_t N> T* end(T (&array)[N]); _LIBCPP_BEGIN_NAMESPACE_STD -struct _LIBCPP_VISIBLE input_iterator_tag {}; -struct _LIBCPP_VISIBLE output_iterator_tag {}; -struct _LIBCPP_VISIBLE forward_iterator_tag : public input_iterator_tag {}; -struct _LIBCPP_VISIBLE bidirectional_iterator_tag : public forward_iterator_tag {}; -struct _LIBCPP_VISIBLE random_access_iterator_tag : public bidirectional_iterator_tag {}; +struct _LIBCPP_TYPE_VIS input_iterator_tag {}; +struct _LIBCPP_TYPE_VIS output_iterator_tag {}; +struct _LIBCPP_TYPE_VIS forward_iterator_tag : public input_iterator_tag {}; +struct _LIBCPP_TYPE_VIS bidirectional_iterator_tag : public forward_iterator_tag {}; +struct _LIBCPP_TYPE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {}; template <class _Tp> struct __has_iterator_category @@ -378,11 +378,11 @@ struct __iterator_traits<_Iter, true> // the client expects instead of failing at compile time. template <class _Iter> -struct _LIBCPP_VISIBLE iterator_traits +struct _LIBCPP_TYPE_VIS iterator_traits : __iterator_traits<_Iter, __has_iterator_category<_Iter>::value> {}; template<class _Tp> -struct _LIBCPP_VISIBLE iterator_traits<_Tp*> +struct _LIBCPP_TYPE_VIS iterator_traits<_Tp*> { typedef ptrdiff_t difference_type; typedef typename remove_const<_Tp>::type value_type; @@ -413,7 +413,7 @@ struct __is_random_access_iterator : public __has_iterator_category_convertible_ template<class _Category, class _Tp, class _Distance = ptrdiff_t, class _Pointer = _Tp*, class _Reference = _Tp&> -struct _LIBCPP_VISIBLE iterator +struct _LIBCPP_TYPE_VIS iterator { typedef _Tp value_type; typedef _Distance difference_type; @@ -510,7 +510,7 @@ prev(_BidiretionalIter __x, } template <class _Iter> -class _LIBCPP_VISIBLE reverse_iterator +class _LIBCPP_TYPE_VIS reverse_iterator : public iterator<typename iterator_traits<_Iter>::iterator_category, typename iterator_traits<_Iter>::value_type, typename iterator_traits<_Iter>::difference_type, @@ -617,7 +617,7 @@ operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_i } template <class _Container> -class _LIBCPP_VISIBLE back_insert_iterator +class _LIBCPP_TYPE_VIS back_insert_iterator : public iterator<output_iterator_tag, void, void, @@ -650,7 +650,7 @@ back_inserter(_Container& __x) } template <class _Container> -class _LIBCPP_VISIBLE front_insert_iterator +class _LIBCPP_TYPE_VIS front_insert_iterator : public iterator<output_iterator_tag, void, void, @@ -683,7 +683,7 @@ front_inserter(_Container& __x) } template <class _Container> -class _LIBCPP_VISIBLE insert_iterator +class _LIBCPP_TYPE_VIS insert_iterator : public iterator<output_iterator_tag, void, void, @@ -719,7 +719,7 @@ inserter(_Container& __x, typename _Container::iterator __i) template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t> -class _LIBCPP_VISIBLE istream_iterator +class _LIBCPP_TYPE_VIS istream_iterator : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&> { public: @@ -758,7 +758,7 @@ public: }; template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> > -class _LIBCPP_VISIBLE ostream_iterator +class _LIBCPP_TYPE_VIS ostream_iterator : public iterator<output_iterator_tag, void, void, void, void> { public: @@ -787,7 +787,7 @@ public: }; template<class _CharT, class _Traits> -class _LIBCPP_VISIBLE istreambuf_iterator +class _LIBCPP_TYPE_VIS istreambuf_iterator : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type, _CharT*, _CharT> @@ -858,7 +858,7 @@ bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a, {return !__a.equal(__b);} template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE ostreambuf_iterator +class _LIBCPP_TYPE_VIS ostreambuf_iterator : public iterator<output_iterator_tag, void, void, void, void> { public: @@ -899,7 +899,7 @@ public: }; template <class _Iter> -class _LIBCPP_VISIBLE move_iterator +class _LIBCPP_TYPE_VIS move_iterator { private: _Iter __i; diff --git a/contrib/libc++/include/limits b/contrib/libc++/include/limits index f089a79..9b9d7a6 100644 --- a/contrib/libc++/include/limits +++ b/contrib/libc++/include/limits @@ -433,7 +433,7 @@ protected: }; template <class _Tp> -class _LIBCPP_VISIBLE numeric_limits +class _LIBCPP_TYPE_VIS numeric_limits : private __libcpp_numeric_limits<typename remove_cv<_Tp>::type> { typedef __libcpp_numeric_limits<typename remove_cv<_Tp>::type> __base; @@ -526,7 +526,7 @@ template <class _Tp> _LIBCPP_CONSTEXPR const float_round_style numeric_limits<_Tp>::round_style; template <class _Tp> -class _LIBCPP_VISIBLE numeric_limits<const _Tp> +class _LIBCPP_TYPE_VIS numeric_limits<const _Tp> : private numeric_limits<_Tp> { typedef numeric_limits<_Tp> __base; @@ -619,7 +619,7 @@ template <class _Tp> _LIBCPP_CONSTEXPR const float_round_style numeric_limits<const _Tp>::round_style; template <class _Tp> -class _LIBCPP_VISIBLE numeric_limits<volatile _Tp> +class _LIBCPP_TYPE_VIS numeric_limits<volatile _Tp> : private numeric_limits<_Tp> { typedef numeric_limits<_Tp> __base; @@ -712,7 +712,7 @@ template <class _Tp> _LIBCPP_CONSTEXPR const float_round_style numeric_limits<volatile _Tp>::round_style; template <class _Tp> -class _LIBCPP_VISIBLE numeric_limits<const volatile _Tp> +class _LIBCPP_TYPE_VIS numeric_limits<const volatile _Tp> : private numeric_limits<_Tp> { typedef numeric_limits<_Tp> __base; diff --git a/contrib/libc++/include/list b/contrib/libc++/include/list index 8125886..c6000c9 100644 --- a/contrib/libc++/include/list +++ b/contrib/libc++/include/list @@ -213,12 +213,12 @@ struct __list_node _Tp __value_; }; -template <class _Tp, class _Alloc> class _LIBCPP_VISIBLE list; +template <class _Tp, class _Alloc> class _LIBCPP_TYPE_VIS list; template <class _Tp, class _Alloc> class __list_imp; -template <class _Tp, class _VoidPtr> class _LIBCPP_VISIBLE __list_const_iterator; +template <class _Tp, class _VoidPtr> class _LIBCPP_TYPE_VIS __list_const_iterator; template <class _Tp, class _VoidPtr> -class _LIBCPP_VISIBLE __list_iterator +class _LIBCPP_TYPE_VIS __list_iterator { typedef typename pointer_traits<_VoidPtr>::template #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES @@ -348,7 +348,7 @@ public: }; template <class _Tp, class _VoidPtr> -class _LIBCPP_VISIBLE __list_const_iterator +class _LIBCPP_TYPE_VIS __list_const_iterator { typedef typename pointer_traits<_VoidPtr>::template #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES @@ -394,7 +394,7 @@ public: #endif } _LIBCPP_INLINE_VISIBILITY - __list_const_iterator(__list_iterator<_Tp, _VoidPtr> __p) _NOEXCEPT + __list_const_iterator(const __list_iterator<_Tp, _VoidPtr>& __p) _NOEXCEPT : __ptr_(__p.__ptr_) { #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -767,7 +767,7 @@ __list_imp<_Tp, _Alloc>::swap(__list_imp& __c) } template <class _Tp, class _Alloc = allocator<_Tp> > -class _LIBCPP_VISIBLE list +class _LIBCPP_TYPE_VIS list : private __list_imp<_Tp, _Alloc> { typedef __list_imp<_Tp, _Alloc> base; @@ -1292,7 +1292,11 @@ list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x) __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); __link_nodes(const_cast<__node&>(*__p.__ptr_), *__hold, *__hold); ++base::__sz(); +#if _LIBCPP_DEBUG_LEVEL >= 2 + return iterator(__hold.release(), this); +#else return iterator(__hold.release()); +#endif } template <class _Tp, class _Alloc> @@ -1518,6 +1522,11 @@ template <class... _Args> typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args) { +#if _LIBCPP_DEBUG_LEVEL >= 2 + _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, + "list::emplace(iterator, args...) called with an iterator not" + " referring to this list"); +#endif __node_allocator& __na = base::__node_alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1)); @@ -1624,6 +1633,8 @@ list<_Tp, _Alloc>::erase(const_iterator __p) "list::erase(iterator) called with an iterator not" " referring to this list"); #endif + _LIBCPP_ASSERT(__p != end(), + "list::erase(iterator) called with a non-dereferenceable iterator"); __node_allocator& __na = base::__node_alloc(); __node& __n = const_cast<__node&>(*__p.__ptr_); __node_pointer __r = __n.__next_; diff --git a/contrib/libc++/include/locale b/contrib/libc++/include/locale index 9189375..49f9c08 100644 --- a/contrib/libc++/include/locale +++ b/contrib/libc++/include/locale @@ -181,18 +181,18 @@ template <class charT> class messages_byname; #include <streambuf> #include <iterator> #include <limits> -#if !__APPLE__ +#ifndef __APPLE__ #include <cstdarg> #endif #include <cstdlib> #include <ctime> -#if _WIN32 +#ifdef _WIN32 #include <support/win32/locale_win32.h> #else // _WIN32 #include <nl_types.h> #endif // !_WIN32 -#if __APPLE__ +#ifdef __APPLE__ #include <Availability.h> #endif @@ -204,7 +204,7 @@ template <class charT> class messages_byname; _LIBCPP_BEGIN_NAMESPACE_STD -#if __APPLE__ || __FreeBSD__ +#if defined(__APPLE__) || defined(__FreeBSD__) # define _LIBCPP_GET_C_LOCALE 0 #else # define _LIBCPP_GET_C_LOCALE __cloc() @@ -222,7 +222,7 @@ typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii; // OSX has nice foo_l() functions that let you turn off use of the global // locale. Linux, not so much. The following functions avoid the locale when // that's possible and otherwise do the wrong thing. FIXME. -#ifdef __linux__ +#if defined(__linux__) || defined(EMSCRIPTEN) #ifdef _LIBCPP_LOCALE__L_EXTENSIONS decltype(MB_CUR_MAX_L(_VSTD::declval<locale_t>())) @@ -634,8 +634,7 @@ __num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& } return -1; } - if (__a_end-__a < __num_get_buf_sz - 1) - *__a_end++ = __src[__f]; + *__a_end++ = __src[__f]; ++__dc; return 0; } @@ -673,23 +672,26 @@ __num_get<_CharT>::__stage2_float_loop(_CharT __ct, bool& __in_units, char& __ex char __x = __src[__f]; if (__x == '-' || __x == '+') { - if (__a_end == __a || (__a_end[-1] & 0xDF) == __exp) + if (__a_end == __a || (__a_end[-1] & 0x5F) == (__exp & 0x7F)) { *__a_end++ = __x; return 0; } return -1; } - if (__a_end-__a < __num_get_buf_sz - 1) - *__a_end++ = __x; if (__x == 'x' || __x == 'X') __exp = 'P'; - else if ((__x & 0xDF) == __exp) + else if ((__x & 0x5F) == __exp) { - __in_units = false; - if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz) - *__g_end++ = __dc; + __exp |= 0x80; + if (__in_units) + { + __in_units = false; + if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz) + *__g_end++ = __dc; + } } + *__a_end++ = __x; if (__f >= 22) return 0; ++__dc; @@ -700,7 +702,7 @@ _LIBCPP_EXTERN_TEMPLATE(struct __num_get<char>) _LIBCPP_EXTERN_TEMPLATE(struct __num_get<wchar_t>) template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > -class _LIBCPP_VISIBLE num_get +class _LIBCPP_TYPE_VIS num_get : public locale::facet, private __num_get<_CharT> { @@ -900,13 +902,20 @@ __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err) { if (__a != __a_end) { + typename remove_reference<decltype(errno)>::type __save_errno = errno; + errno = 0; char *__p2; long double __ld = strtold_l(__a, &__p2, _LIBCPP_GET_C_LOCALE); + typename remove_reference<decltype(errno)>::type __current_errno = errno; + if (__current_errno == 0) + errno = __save_errno; if (__p2 != __a_end) { __err = ios_base::failbit; return 0; } + else if (__current_errno == ERANGE) + __err = ios_base::failbit; return static_cast<_Tp>(__ld); } __err = ios_base::failbit; @@ -962,16 +971,28 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, char_type __atoms[26]; char_type __thousands_sep; string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); - char __a[__num_get_base::__num_get_buf_sz] = {0}; + string __buf; + __buf.resize(__buf.capacity()); + char* __a = &__buf[0]; char* __a_end = __a; unsigned __g[__num_get_base::__num_get_buf_sz]; unsigned* __g_end = __g; unsigned __dc = 0; for (; __b != __e; ++__b) + { + if (__a_end - __a == __buf.size()) + { + size_t __tmp = __buf.size(); + __buf.resize(2*__buf.size()); + __buf.resize(__buf.capacity()); + __a = &__buf[0]; + __a_end = __a + __tmp; + } if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms)) break; + } if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) *__g_end++ = __dc; // Stage 3 @@ -997,16 +1018,28 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, char_type __atoms[26]; char_type __thousands_sep; string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); - char __a[__num_get_base::__num_get_buf_sz] = {0}; + string __buf; + __buf.resize(__buf.capacity()); + char* __a = &__buf[0]; char* __a_end = __a; unsigned __g[__num_get_base::__num_get_buf_sz]; unsigned* __g_end = __g; unsigned __dc = 0; for (; __b != __e; ++__b) + { + if (__a_end - __a == __buf.size()) + { + size_t __tmp = __buf.size(); + __buf.resize(2*__buf.size()); + __buf.resize(__buf.capacity()); + __a = &__buf[0]; + __a_end = __a + __tmp; + } if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms)) break; + } if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) *__g_end++ = __dc; // Stage 3 @@ -1032,16 +1065,28 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, char_type __atoms[26]; char_type __thousands_sep; string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); - char __a[__num_get_base::__num_get_buf_sz] = {0}; + string __buf; + __buf.resize(__buf.capacity()); + char* __a = &__buf[0]; char* __a_end = __a; unsigned __g[__num_get_base::__num_get_buf_sz]; unsigned* __g_end = __g; unsigned __dc = 0; for (; __b != __e; ++__b) + { + if (__a_end - __a == __buf.size()) + { + size_t __tmp = __buf.size(); + __buf.resize(2*__buf.size()); + __buf.resize(__buf.capacity()); + __a = &__buf[0]; + __a_end = __a + __tmp; + } if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms)) break; + } if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) *__g_end++ = __dc; // Stage 3 @@ -1067,16 +1112,28 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, char_type __atoms[26]; char_type __thousands_sep; string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); - char __a[__num_get_base::__num_get_buf_sz] = {0}; + string __buf; + __buf.resize(__buf.capacity()); + char* __a = &__buf[0]; char* __a_end = __a; unsigned __g[__num_get_base::__num_get_buf_sz]; unsigned* __g_end = __g; unsigned __dc = 0; for (; __b != __e; ++__b) + { + if (__a_end - __a == __buf.size()) + { + size_t __tmp = __buf.size(); + __buf.resize(2*__buf.size()); + __buf.resize(__buf.capacity()); + __a = &__buf[0]; + __a_end = __a + __tmp; + } if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms)) break; + } if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) *__g_end++ = __dc; // Stage 3 @@ -1102,16 +1159,28 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, char_type __atoms[26]; char_type __thousands_sep; string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); - char __a[__num_get_base::__num_get_buf_sz] = {0}; + string __buf; + __buf.resize(__buf.capacity()); + char* __a = &__buf[0]; char* __a_end = __a; unsigned __g[__num_get_base::__num_get_buf_sz]; unsigned* __g_end = __g; unsigned __dc = 0; for (; __b != __e; ++__b) + { + if (__a_end - __a == __buf.size()) + { + size_t __tmp = __buf.size(); + __buf.resize(2*__buf.size()); + __buf.resize(__buf.capacity()); + __a = &__buf[0]; + __a_end = __a + __tmp; + } if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms)) break; + } if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) *__g_end++ = __dc; // Stage 3 @@ -1137,16 +1206,28 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, char_type __atoms[26]; char_type __thousands_sep; string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep); - char __a[__num_get_base::__num_get_buf_sz] = {0}; + string __buf; + __buf.resize(__buf.capacity()); + char* __a = &__buf[0]; char* __a_end = __a; unsigned __g[__num_get_base::__num_get_buf_sz]; unsigned* __g_end = __g; unsigned __dc = 0; for (; __b != __e; ++__b) + { + if (__a_end - __a == __buf.size()) + { + size_t __tmp = __buf.size(); + __buf.resize(2*__buf.size()); + __buf.resize(__buf.capacity()); + __a = &__buf[0]; + __a_end = __a + __tmp; + } if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms)) break; + } if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz) *__g_end++ = __dc; // Stage 3 @@ -1174,7 +1255,9 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, string __grouping = this->__stage2_float_prep(__iob, __atoms, __decimal_point, __thousands_sep); - char __a[__num_get_base::__num_get_buf_sz] = {0}; + string __buf; + __buf.resize(__buf.capacity()); + char* __a = &__buf[0]; char* __a_end = __a; unsigned __g[__num_get_base::__num_get_buf_sz]; unsigned* __g_end = __g; @@ -1182,11 +1265,21 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, bool __in_units = true; char __exp = 'E'; for (; __b != __e; ++__b) + { + if (__a_end - __a == __buf.size()) + { + size_t __tmp = __buf.size(); + __buf.resize(2*__buf.size()); + __buf.resize(__buf.capacity()); + __a = &__buf[0]; + __a_end = __a + __tmp; + } if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end, __decimal_point, __thousands_sep, __grouping, __g, __g_end, __dc, __atoms)) break; + } if (__grouping.size() != 0 && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz) *__g_end++ = __dc; // Stage 3 @@ -1214,7 +1307,9 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, string __grouping = this->__stage2_float_prep(__iob, __atoms, __decimal_point, __thousands_sep); - char __a[__num_get_base::__num_get_buf_sz] = {0}; + string __buf; + __buf.resize(__buf.capacity()); + char* __a = &__buf[0]; char* __a_end = __a; unsigned __g[__num_get_base::__num_get_buf_sz]; unsigned* __g_end = __g; @@ -1222,11 +1317,21 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, bool __in_units = true; char __exp = 'E'; for (; __b != __e; ++__b) + { + if (__a_end - __a == __buf.size()) + { + size_t __tmp = __buf.size(); + __buf.resize(2*__buf.size()); + __buf.resize(__buf.capacity()); + __a = &__buf[0]; + __a_end = __a + __tmp; + } if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end, __decimal_point, __thousands_sep, __grouping, __g, __g_end, __dc, __atoms)) break; + } if (__grouping.size() != 0 && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz) *__g_end++ = __dc; // Stage 3 @@ -1254,7 +1359,9 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, string __grouping = this->__stage2_float_prep(__iob, __atoms, __decimal_point, __thousands_sep); - char __a[__num_get_base::__num_get_buf_sz] = {0}; + string __buf; + __buf.resize(__buf.capacity()); + char* __a = &__buf[0]; char* __a_end = __a; unsigned __g[__num_get_base::__num_get_buf_sz]; unsigned* __g_end = __g; @@ -1262,11 +1369,21 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, bool __in_units = true; char __exp = 'E'; for (; __b != __e; ++__b) + { + if (__a_end - __a == __buf.size()) + { + size_t __tmp = __buf.size(); + __buf.resize(2*__buf.size()); + __buf.resize(__buf.capacity()); + __a = &__buf[0]; + __a_end = __a + __tmp; + } if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end, __decimal_point, __thousands_sep, __grouping, __g, __g_end, __dc, __atoms)) break; + } if (__grouping.size() != 0 && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz) *__g_end++ = __dc; // Stage 3 @@ -1294,16 +1411,28 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, string __grouping; use_facet<ctype<_CharT> >(__iob.getloc()).widen(__num_get_base::__src, __num_get_base::__src + 26, __atoms); - char __a[__num_get_base::__num_get_buf_sz] = {0}; + string __buf; + __buf.resize(__buf.capacity()); + char* __a = &__buf[0]; char* __a_end = __a; unsigned __g[__num_get_base::__num_get_buf_sz]; unsigned* __g_end = __g; unsigned __dc = 0; for (; __b != __e; ++__b) + { + if (__a_end - __a == __buf.size()) + { + size_t __tmp = __buf.size(); + __buf.resize(2*__buf.size()); + __buf.resize(__buf.capacity()); + __a = &__buf[0]; + __a_end = __a + __tmp; + } if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms)) break; + } // Stage 3 __a[sizeof(__a)-1] = 0; #ifdef _LIBCPP_LOCALE__L_EXTENSIONS @@ -1472,7 +1601,7 @@ _LIBCPP_EXTERN_TEMPLATE(struct __num_put<char>) _LIBCPP_EXTERN_TEMPLATE(struct __num_put<wchar_t>) template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > -class _LIBCPP_VISIBLE num_put +class _LIBCPP_TYPE_VIS num_put : public locale::facet, private __num_put<_CharT> { @@ -1984,7 +2113,7 @@ __get_up_to_n_digits(_InputIterator& __b, _InputIterator __e, return __r; } -class _LIBCPP_VISIBLE time_base +class _LIBCPP_TYPE_VIS time_base { public: enum dateorder {no_order, dmy, mdy, ymd, ydm}; @@ -2006,7 +2135,7 @@ protected: }; template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > -class _LIBCPP_VISIBLE time_get +class _LIBCPP_TYPE_VIS time_get : public locale::facet, public time_base, private __time_get_c_storage<_CharT> @@ -2656,7 +2785,7 @@ private: }; template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > -class _LIBCPP_VISIBLE time_get_byname +class _LIBCPP_TYPE_VIS time_get_byname : public time_get<_CharT, _InputIterator>, private __time_get_storage<_CharT> { @@ -2716,7 +2845,7 @@ protected: }; template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > -class _LIBCPP_VISIBLE time_put +class _LIBCPP_TYPE_VIS time_put : public locale::facet, private __time_put { @@ -2815,7 +2944,7 @@ _LIBCPP_EXTERN_TEMPLATE(class time_put<char>) _LIBCPP_EXTERN_TEMPLATE(class time_put<wchar_t>) template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > -class _LIBCPP_VISIBLE time_put_byname +class _LIBCPP_TYPE_VIS time_put_byname : public time_put<_CharT, _OutputIterator> { public: @@ -2837,7 +2966,7 @@ _LIBCPP_EXTERN_TEMPLATE(class time_put_byname<wchar_t>) // money_base -class _LIBCPP_VISIBLE money_base +class _LIBCPP_TYPE_VIS money_base { public: enum part {none, space, symbol, sign, value}; @@ -2849,7 +2978,7 @@ public: // moneypunct template <class _CharT, bool _International = false> -class _LIBCPP_VISIBLE moneypunct +class _LIBCPP_TYPE_VIS moneypunct : public locale::facet, public money_base { @@ -2907,7 +3036,7 @@ _LIBCPP_EXTERN_TEMPLATE(class moneypunct<wchar_t, true>) // moneypunct_byname template <class _CharT, bool _International = false> -class _LIBCPP_VISIBLE moneypunct_byname +class _LIBCPP_TYPE_VIS moneypunct_byname : public moneypunct<_CharT, _International> { public: @@ -3019,7 +3148,7 @@ _LIBCPP_EXTERN_TEMPLATE(class __money_get<char>) _LIBCPP_EXTERN_TEMPLATE(class __money_get<wchar_t>) template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> > -class _LIBCPP_VISIBLE money_get +class _LIBCPP_TYPE_VIS money_get : public locale::facet, private __money_get<_CharT> { @@ -3353,7 +3482,7 @@ money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e, if (__neg) *__nc++ = '-'; for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc) - *__nc = __src[find(__atoms, __atoms+sizeof(__atoms), *__w) - __atoms]; + *__nc = __src[find(__atoms, _VSTD::end(__atoms), *__w) - __atoms]; *__nc = char(); if (sscanf(__nbuf, "%Lf", &__v) != 1) __throw_runtime_error("money_get error"); @@ -3575,7 +3704,7 @@ _LIBCPP_EXTERN_TEMPLATE(class __money_put<char>) _LIBCPP_EXTERN_TEMPLATE(class __money_put<wchar_t>) template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> > -class _LIBCPP_VISIBLE money_put +class _LIBCPP_TYPE_VIS money_put : public locale::facet, private __money_put<_CharT> { @@ -3733,7 +3862,7 @@ _LIBCPP_EXTERN_TEMPLATE(class money_put<wchar_t>) // messages -class _LIBCPP_VISIBLE messages_base +class _LIBCPP_TYPE_VIS messages_base { public: typedef ptrdiff_t catalog; @@ -3742,7 +3871,7 @@ public: }; template <class _CharT> -class _LIBCPP_VISIBLE messages +class _LIBCPP_TYPE_VIS messages : public locale::facet, public messages_base { @@ -3793,7 +3922,7 @@ template <class _CharT> typename messages<_CharT>::catalog messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const { -#if _WIN32 +#ifdef _WIN32 return -1; #else // _WIN32 catalog __cat = (catalog)catopen(__nm.c_str(), NL_CAT_LOCALE); @@ -3808,7 +3937,7 @@ typename messages<_CharT>::string_type messages<_CharT>::do_get(catalog __c, int __set, int __msgid, const string_type& __dflt) const { -#if _WIN32 +#ifdef _WIN32 return __dflt; #else // _WIN32 string __ndflt; @@ -3830,7 +3959,7 @@ template <class _CharT> void messages<_CharT>::do_close(catalog __c) const { -#if !_WIN32 +#if !defined(_WIN32) if (__c != -1) __c <<= 1; nl_catd __cat = (nl_catd)__c; @@ -3842,7 +3971,7 @@ _LIBCPP_EXTERN_TEMPLATE(class messages<char>) _LIBCPP_EXTERN_TEMPLATE(class messages<wchar_t>) template <class _CharT> -class _LIBCPP_VISIBLE messages_byname +class _LIBCPP_TYPE_VIS messages_byname : public messages<_CharT> { public: @@ -3868,7 +3997,7 @@ _LIBCPP_EXTERN_TEMPLATE(class messages_byname<wchar_t>) template<class _Codecvt, class _Elem = wchar_t, class _Wide_alloc = allocator<_Elem>, class _Byte_alloc = allocator<char> > -class _LIBCPP_VISIBLE wstring_convert +class _LIBCPP_TYPE_VIS wstring_convert { public: typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string; @@ -4121,7 +4250,7 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>:: } template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> > -class _LIBCPP_VISIBLE wbuffer_convert +class _LIBCPP_TYPE_VIS wbuffer_convert : public basic_streambuf<_Elem, _Tr> { public: diff --git a/contrib/libc++/include/map b/contrib/libc++/include/map index dd98da5..abc07a3 100644 --- a/contrib/libc++/include/map +++ b/contrib/libc++/include/map @@ -537,7 +537,7 @@ template <class _Key, class _Tp, class _Compare, class _Allocator> template <class _TreeIterator> class __map_const_iterator; template <class _TreeIterator> -class _LIBCPP_VISIBLE __map_iterator +class _LIBCPP_TYPE_VIS __map_iterator { _TreeIterator __i_; @@ -596,13 +596,13 @@ public: bool operator!=(const __map_iterator& __x, const __map_iterator& __y) {return __x.__i_ != __y.__i_;} - template <class, class, class, class> friend class _LIBCPP_VISIBLE map; - template <class, class, class, class> friend class _LIBCPP_VISIBLE multimap; - template <class> friend class _LIBCPP_VISIBLE __map_const_iterator; + template <class, class, class, class> friend class _LIBCPP_TYPE_VIS map; + template <class, class, class, class> friend class _LIBCPP_TYPE_VIS multimap; + template <class> friend class _LIBCPP_TYPE_VIS __map_const_iterator; }; template <class _TreeIterator> -class _LIBCPP_VISIBLE __map_const_iterator +class _LIBCPP_TYPE_VIS __map_const_iterator { _TreeIterator __i_; @@ -665,14 +665,14 @@ public: bool operator!=(const __map_const_iterator& __x, const __map_const_iterator& __y) {return __x.__i_ != __y.__i_;} - template <class, class, class, class> friend class _LIBCPP_VISIBLE map; - template <class, class, class, class> friend class _LIBCPP_VISIBLE multimap; - template <class, class, class> friend class _LIBCPP_VISIBLE __tree_const_iterator; + template <class, class, class, class> friend class _LIBCPP_TYPE_VIS map; + template <class, class, class, class> friend class _LIBCPP_TYPE_VIS multimap; + template <class, class, class> friend class _LIBCPP_TYPE_VIS __tree_const_iterator; }; template <class _Key, class _Tp, class _Compare = less<_Key>, class _Allocator = allocator<pair<const _Key, _Tp> > > -class _LIBCPP_VISIBLE map +class _LIBCPP_TYPE_VIS map { public: // types: @@ -684,7 +684,7 @@ public: typedef value_type& reference; typedef const value_type& const_reference; - class _LIBCPP_VISIBLE value_compare + class _LIBCPP_TYPE_VIS value_compare : public binary_function<value_type, value_type, bool> { friend class map; @@ -1422,7 +1422,7 @@ swap(map<_Key, _Tp, _Compare, _Allocator>& __x, template <class _Key, class _Tp, class _Compare = less<_Key>, class _Allocator = allocator<pair<const _Key, _Tp> > > -class _LIBCPP_VISIBLE multimap +class _LIBCPP_TYPE_VIS multimap { public: // types: @@ -1434,7 +1434,7 @@ public: typedef value_type& reference; typedef const value_type& const_reference; - class _LIBCPP_VISIBLE value_compare + class _LIBCPP_TYPE_VIS value_compare : public binary_function<value_type, value_type, bool> { friend class multimap; diff --git a/contrib/libc++/include/memory b/contrib/libc++/include/memory index f80d699..2a8b7e6 100644 --- a/contrib/libc++/include/memory +++ b/contrib/libc++/include/memory @@ -621,7 +621,7 @@ inline _LIBCPP_INLINE_VISIBILITY _Tp* addressof(_Tp& __x) _NOEXCEPT { - return (_Tp*)&(char&)__x; + return (_Tp*)&reinterpret_cast<const volatile char&>(__x); } #if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF) @@ -667,7 +667,7 @@ addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT template <class _Tp> class allocator; template <> -class _LIBCPP_VISIBLE allocator<void> +class _LIBCPP_TYPE_VIS allocator<void> { public: typedef void* pointer; @@ -678,7 +678,7 @@ public: }; template <> -class _LIBCPP_VISIBLE allocator<const void> +class _LIBCPP_TYPE_VIS allocator<const void> { public: typedef const void* pointer; @@ -913,7 +913,7 @@ struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, false> #endif // _LIBCPP_HAS_NO_VARIADICS template <class _Ptr> -struct _LIBCPP_VISIBLE pointer_traits +struct _LIBCPP_TYPE_VIS pointer_traits { typedef _Ptr pointer; typedef typename __pointer_traits_element_type<pointer>::type element_type; @@ -936,7 +936,7 @@ public: }; template <class _Tp> -struct _LIBCPP_VISIBLE pointer_traits<_Tp*> +struct _LIBCPP_TYPE_VIS pointer_traits<_Tp*> { typedef _Tp* pointer; typedef _Tp element_type; @@ -1443,7 +1443,7 @@ struct __alloc_traits_difference_type<_Alloc, _Ptr, true> }; template <class _Alloc> -struct _LIBCPP_VISIBLE allocator_traits +struct _LIBCPP_TYPE_VIS allocator_traits { typedef _Alloc allocator_type; typedef typename allocator_type::value_type value_type; @@ -1649,7 +1649,7 @@ private: // allocator template <class _Tp> -class _LIBCPP_VISIBLE allocator +class _LIBCPP_TYPE_VIS allocator { public: typedef size_t size_type; @@ -1741,7 +1741,7 @@ public: }; template <class _Tp> -class _LIBCPP_VISIBLE allocator<const _Tp> +class _LIBCPP_TYPE_VIS allocator<const _Tp> { public: typedef size_t size_type; @@ -1839,7 +1839,7 @@ inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;} template <class _OutputIterator, class _Tp> -class _LIBCPP_VISIBLE raw_storage_iterator +class _LIBCPP_TYPE_VIS raw_storage_iterator : public iterator<output_iterator_tag, _Tp, // purposefully not C++03 ptrdiff_t, // purposefully not C++03 @@ -1892,7 +1892,7 @@ struct auto_ptr_ref }; template<class _Tp> -class _LIBCPP_VISIBLE auto_ptr +class _LIBCPP_TYPE_VIS auto_ptr { private: _Tp* __ptr_; @@ -1936,7 +1936,7 @@ public: }; template <> -class _LIBCPP_VISIBLE auto_ptr<void> +class _LIBCPP_TYPE_VIS auto_ptr<void> { public: typedef void element_type; @@ -2472,7 +2472,7 @@ struct __same_or_less_cv_qualified<_Ptr1, _Ptr2, true> // default_delete template <class _Tp> -struct _LIBCPP_VISIBLE default_delete +struct _LIBCPP_TYPE_VIS default_delete { #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT = default; @@ -2485,12 +2485,13 @@ struct _LIBCPP_VISIBLE default_delete _LIBCPP_INLINE_VISIBILITY void operator() (_Tp* __ptr) const _NOEXCEPT { static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type"); + static_assert(!is_void<_Tp>::value, "default_delete can not delete incomplete type"); delete __ptr; } }; template <class _Tp> -struct _LIBCPP_VISIBLE default_delete<_Tp[]> +struct _LIBCPP_TYPE_VIS default_delete<_Tp[]> { public: #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS @@ -2507,12 +2508,13 @@ public: typename enable_if<__same_or_less_cv_qualified<_Up*, _Tp*>::value>::type* = 0) const _NOEXCEPT { static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type"); + static_assert(!is_void<_Tp>::value, "default_delete can not delete incomplete type"); delete [] __ptr; } }; template <class _Tp, class _Dp = default_delete<_Tp> > -class _LIBCPP_VISIBLE unique_ptr +class _LIBCPP_TYPE_VIS unique_ptr { public: typedef _Tp element_type; @@ -2691,7 +2693,7 @@ public: }; template <class _Tp, class _Dp> -class _LIBCPP_VISIBLE unique_ptr<_Tp[], _Dp> +class _LIBCPP_TYPE_VIS unique_ptr<_Tp[], _Dp> { public: typedef _Tp element_type; @@ -3393,7 +3395,7 @@ struct __scalar_hash<_Tp, 4> }; template<class _Tp> -struct _LIBCPP_VISIBLE hash<_Tp*> +struct _LIBCPP_TYPE_VIS hash<_Tp*> : public unary_function<_Tp*, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -3410,7 +3412,7 @@ struct _LIBCPP_VISIBLE hash<_Tp*> }; template <class _Tp, class _Dp> -struct _LIBCPP_VISIBLE hash<unique_ptr<_Tp, _Dp> > +struct _LIBCPP_TYPE_VIS hash<unique_ptr<_Tp, _Dp> > { typedef unique_ptr<_Tp, _Dp> argument_type; typedef size_t result_type; @@ -3583,7 +3585,7 @@ public: virtual const char* what() const _NOEXCEPT; }; -template<class _Tp> class _LIBCPP_VISIBLE weak_ptr; +template<class _Tp> class _LIBCPP_TYPE_VIS weak_ptr; class __shared_count { @@ -3629,10 +3631,13 @@ public: long use_count() const _NOEXCEPT {return __shared_count::use_count();} __shared_weak_count* lock() _NOEXCEPT; - // purposefully not protected with #ifndef _LIBCPP_NO_RTTI because doing so - // breaks ABI for those clients who need to compile their projects with - // -fno-rtti and yet link against a libc++.dylib compiled without -fno-rtti. + // Define the function out only if we build static libc++ without RTTI. + // Otherwise we may break clients who need to compile their projects with + // -fno-rtti and yet link against a libc++.dylib compiled + // without -fno-rtti. +#if !defined(_LIBCPP_NO_RTTI) || !defined(_LIBCPP_BUILD_STATIC) virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; +#endif private: virtual void __on_zero_shared_weak() _NOEXCEPT = 0; }; @@ -3749,10 +3754,10 @@ __shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT __a.deallocate(this, 1); } -template<class _Tp> class _LIBCPP_VISIBLE enable_shared_from_this; +template<class _Tp> class _LIBCPP_TYPE_VIS enable_shared_from_this; template<class _Tp> -class _LIBCPP_VISIBLE shared_ptr +class _LIBCPP_TYPE_VIS shared_ptr { public: typedef _Tp element_type; @@ -4021,8 +4026,8 @@ private: _LIBCPP_INLINE_VISIBILITY void __enable_weak_this(const void*) _NOEXCEPT {} - template <class _Up> friend class _LIBCPP_VISIBLE shared_ptr; - template <class _Up> friend class _LIBCPP_VISIBLE weak_ptr; + template <class _Up> friend class _LIBCPP_TYPE_VIS shared_ptr; + template <class _Up> friend class _LIBCPP_TYPE_VIS weak_ptr; }; template<class _Tp> @@ -4918,7 +4923,7 @@ get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT #endif // _LIBCPP_NO_RTTI template<class _Tp> -class _LIBCPP_VISIBLE weak_ptr +class _LIBCPP_TYPE_VIS weak_ptr { public: typedef _Tp element_type; @@ -4993,8 +4998,8 @@ public: bool owner_before(const weak_ptr<_Up>& __r) const {return __cntrl_ < __r.__cntrl_;} - template <class _Up> friend class _LIBCPP_VISIBLE weak_ptr; - template <class _Up> friend class _LIBCPP_VISIBLE shared_ptr; + template <class _Up> friend class _LIBCPP_TYPE_VIS weak_ptr; + template <class _Up> friend class _LIBCPP_TYPE_VIS shared_ptr; }; template<class _Tp> @@ -5194,7 +5199,7 @@ weak_ptr<_Tp>::lock() const _NOEXCEPT template <class _Tp> struct owner_less; template <class _Tp> -struct _LIBCPP_VISIBLE owner_less<shared_ptr<_Tp> > +struct _LIBCPP_TYPE_VIS owner_less<shared_ptr<_Tp> > : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool> { typedef bool result_type; @@ -5210,7 +5215,7 @@ struct _LIBCPP_VISIBLE owner_less<shared_ptr<_Tp> > }; template <class _Tp> -struct _LIBCPP_VISIBLE owner_less<weak_ptr<_Tp> > +struct _LIBCPP_TYPE_VIS owner_less<weak_ptr<_Tp> > : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool> { typedef bool result_type; @@ -5226,7 +5231,7 @@ struct _LIBCPP_VISIBLE owner_less<weak_ptr<_Tp> > }; template<class _Tp> -class _LIBCPP_VISIBLE enable_shared_from_this +class _LIBCPP_TYPE_VIS enable_shared_from_this { mutable weak_ptr<_Tp> __weak_this_; protected: @@ -5251,7 +5256,7 @@ public: }; template <class _Tp> -struct _LIBCPP_VISIBLE hash<shared_ptr<_Tp> > +struct _LIBCPP_TYPE_VIS hash<shared_ptr<_Tp> > { typedef shared_ptr<_Tp> argument_type; typedef size_t result_type; @@ -5281,10 +5286,10 @@ private: __sp_mut(const __sp_mut&); __sp_mut& operator=(const __sp_mut&); - friend _LIBCPP_VISIBLE __sp_mut& __get_sp_mut(const void*); + friend _LIBCPP_FUNC_VIS __sp_mut& __get_sp_mut(const void*); }; -_LIBCPP_VISIBLE __sp_mut& __get_sp_mut(const void*); +_LIBCPP_FUNC_VIS __sp_mut& __get_sp_mut(const void*); template <class _Tp> inline _LIBCPP_INLINE_VISIBILITY @@ -5396,7 +5401,7 @@ atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v #endif // __has_feature(cxx_atomic) //enum class -struct _LIBCPP_VISIBLE pointer_safety +struct _LIBCPP_TYPE_VIS pointer_safety { enum __lx { diff --git a/contrib/libc++/include/mutex b/contrib/libc++/include/mutex index ee20f02..e2b5d6b 100644 --- a/contrib/libc++/include/mutex +++ b/contrib/libc++/include/mutex @@ -187,7 +187,7 @@ template<class Callable, class ...Args> _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE recursive_mutex +class _LIBCPP_TYPE_VIS recursive_mutex { pthread_mutex_t __m_; @@ -209,7 +209,7 @@ public: native_handle_type native_handle() {return &__m_;} }; -class _LIBCPP_VISIBLE timed_mutex +class _LIBCPP_TYPE_VIS timed_mutex { mutex __m_; condition_variable __cv_; @@ -251,7 +251,7 @@ timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) return false; } -class _LIBCPP_VISIBLE recursive_timed_mutex +class _LIBCPP_TYPE_VIS recursive_timed_mutex { mutex __m_; condition_variable __cv_; @@ -425,7 +425,7 @@ lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3) #endif // _LIBCPP_HAS_NO_VARIADICS -struct _LIBCPP_VISIBLE once_flag; +struct _LIBCPP_TYPE_VIS once_flag; #ifndef _LIBCPP_HAS_NO_VARIADICS @@ -441,7 +441,7 @@ void call_once(once_flag&, _Callable); #endif // _LIBCPP_HAS_NO_VARIADICS -struct _LIBCPP_VISIBLE once_flag +struct _LIBCPP_TYPE_VIS once_flag { _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR diff --git a/contrib/libc++/include/new b/contrib/libc++/include/new index ae0951a..1e85798 100644 --- a/contrib/libc++/include/new +++ b/contrib/libc++/include/new @@ -83,31 +83,31 @@ public: void __throw_bad_alloc(); // not in C++ spec -struct _LIBCPP_VISIBLE nothrow_t {}; -extern _LIBCPP_VISIBLE const nothrow_t nothrow; +struct _LIBCPP_TYPE_VIS nothrow_t {}; +extern _LIBCPP_FUNC_VIS const nothrow_t nothrow; typedef void (*new_handler)(); -_LIBCPP_VISIBLE new_handler set_new_handler(new_handler) _NOEXCEPT; -_LIBCPP_VISIBLE new_handler get_new_handler() _NOEXCEPT; +_LIBCPP_FUNC_VIS new_handler set_new_handler(new_handler) _NOEXCEPT; +_LIBCPP_FUNC_VIS new_handler get_new_handler() _NOEXCEPT; } // std -_LIBCPP_VISIBLE void* operator new(std::size_t __sz) +_LIBCPP_FUNC_VIS void* operator new(std::size_t __sz) #if !__has_feature(cxx_noexcept) throw(std::bad_alloc) #endif ; -_LIBCPP_VISIBLE void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS; -_LIBCPP_VISIBLE void operator delete(void* __p) _NOEXCEPT; -_LIBCPP_VISIBLE void operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT; +_LIBCPP_FUNC_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS; +_LIBCPP_FUNC_VIS void operator delete(void* __p) _NOEXCEPT; +_LIBCPP_FUNC_VIS void operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT; -_LIBCPP_VISIBLE void* operator new[](std::size_t __sz) +_LIBCPP_FUNC_VIS void* operator new[](std::size_t __sz) #if !__has_feature(cxx_noexcept) throw(std::bad_alloc) #endif ; -_LIBCPP_VISIBLE void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS; -_LIBCPP_VISIBLE void operator delete[](void* __p) _NOEXCEPT; -_LIBCPP_VISIBLE void operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT; +_LIBCPP_FUNC_VIS void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS; +_LIBCPP_FUNC_VIS void operator delete[](void* __p) _NOEXCEPT; +_LIBCPP_FUNC_VIS void operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY inline void* operator new (std::size_t, void* __p) _NOEXCEPT {return __p;} _LIBCPP_INLINE_VISIBILITY inline void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;} diff --git a/contrib/libc++/include/ostream b/contrib/libc++/include/ostream index b3b6df5..eac9c8f 100644 --- a/contrib/libc++/include/ostream +++ b/contrib/libc++/include/ostream @@ -140,7 +140,7 @@ template <class charT, class traits, class T> _LIBCPP_BEGIN_NAMESPACE_STD template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_ostream +class _LIBCPP_TYPE_VIS basic_ostream : virtual public basic_ios<_CharT, _Traits> { public: @@ -169,7 +169,7 @@ protected: public: // 27.7.2.4 Prefix/suffix: - class _LIBCPP_VISIBLE sentry; + class _LIBCPP_TYPE_VIS sentry; // 27.7.2.6 Formatted output: basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)); @@ -207,7 +207,7 @@ protected: }; template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_ostream<_CharT, _Traits>::sentry +class _LIBCPP_TYPE_VIS basic_ostream<_CharT, _Traits>::sentry { bool __ok_; basic_ostream<_CharT, _Traits>& __os_; diff --git a/contrib/libc++/include/queue b/contrib/libc++/include/queue index 4741f00..8d1a9df 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_VISIBLE queue; +template <class _Tp, class _Container> class _LIBCPP_TYPE_VIS queue; template <class _Tp, class _Container> _LIBCPP_INLINE_VISIBILITY @@ -190,7 +190,7 @@ bool operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y); template <class _Tp, class _Container = deque<_Tp> > -class _LIBCPP_VISIBLE queue +class _LIBCPP_TYPE_VIS queue { public: typedef _Container container_type; @@ -376,14 +376,14 @@ swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y) } template <class _Tp, class _Container, class _Alloc> -struct _LIBCPP_VISIBLE uses_allocator<queue<_Tp, _Container>, _Alloc> +struct _LIBCPP_TYPE_VIS uses_allocator<queue<_Tp, _Container>, _Alloc> : public uses_allocator<_Container, _Alloc> { }; template <class _Tp, class _Container = vector<_Tp>, class _Compare = less<typename _Container::value_type> > -class _LIBCPP_VISIBLE priority_queue +class _LIBCPP_TYPE_VIS priority_queue { public: typedef _Container container_type; @@ -707,7 +707,7 @@ swap(priority_queue<_Tp, _Container, _Compare>& __x, } template <class _Tp, class _Container, class _Compare, class _Alloc> -struct _LIBCPP_VISIBLE uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc> +struct _LIBCPP_TYPE_VIS uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc> : public uses_allocator<_Container, _Alloc> { }; diff --git a/contrib/libc++/include/random b/contrib/libc++/include/random index 04d942b..92722ea 100644 --- a/contrib/libc++/include/random +++ b/contrib/libc++/include/random @@ -1813,7 +1813,7 @@ struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b> }; template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> -class _LIBCPP_VISIBLE linear_congruential_engine; +class _LIBCPP_TYPE_VIS linear_congruential_engine; template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np> @@ -1829,7 +1829,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x); template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> -class _LIBCPP_VISIBLE linear_congruential_engine +class _LIBCPP_TYPE_VIS linear_congruential_engine { public: // types @@ -2038,7 +2038,7 @@ typedef minstd_rand default_random_engine; template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r, _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> -class _LIBCPP_VISIBLE mersenne_twister_engine; +class _LIBCPP_TYPE_VIS mersenne_twister_engine; template <class _UI, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp, _UI _Ap, size_t _Up, _UI _Dp, size_t _Sp, @@ -2080,7 +2080,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r, _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f> -class _LIBCPP_VISIBLE mersenne_twister_engine +class _LIBCPP_TYPE_VIS mersenne_twister_engine { public: // types @@ -2526,7 +2526,7 @@ typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31, // subtract_with_carry_engine template<class _UIntType, size_t __w, size_t __s, size_t __r> -class _LIBCPP_VISIBLE subtract_with_carry_engine; +class _LIBCPP_TYPE_VIS subtract_with_carry_engine; template<class _UI, size_t _Wp, size_t _Sp, size_t _Rp> bool @@ -2554,7 +2554,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x); template<class _UIntType, size_t __w, size_t __s, size_t __r> -class _LIBCPP_VISIBLE subtract_with_carry_engine +class _LIBCPP_TYPE_VIS subtract_with_carry_engine { public: // types @@ -2837,7 +2837,7 @@ typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base; // discard_block_engine template<class _Engine, size_t __p, size_t __r> -class _LIBCPP_VISIBLE discard_block_engine +class _LIBCPP_TYPE_VIS discard_block_engine { _Engine __e_; int __n_; @@ -3010,7 +3010,7 @@ typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48; // independent_bits_engine template<class _Engine, size_t __w, class _UIntType> -class _LIBCPP_VISIBLE independent_bits_engine +class _LIBCPP_TYPE_VIS independent_bits_engine { template <class _UI, _UI _R0, size_t _Wp, size_t _Mp> class __get_n @@ -3273,7 +3273,7 @@ public: }; template<class _Engine, size_t __k> -class _LIBCPP_VISIBLE shuffle_order_engine +class _LIBCPP_TYPE_VIS shuffle_order_engine { static_assert(0 < __k, "shuffle_order_engine invalid parameters"); public: @@ -3500,7 +3500,7 @@ typedef shuffle_order_engine<minstd_rand0, 256> knuth_b; // random_device -class _LIBCPP_VISIBLE random_device +class _LIBCPP_TYPE_VIS random_device { int __f_; public: @@ -3534,7 +3534,7 @@ private: // seed_seq -class _LIBCPP_VISIBLE seed_seq +class _LIBCPP_TYPE_VIS seed_seq { public: // types @@ -3711,13 +3711,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // uniform_real_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE uniform_real_distribution +class _LIBCPP_TYPE_VIS uniform_real_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __a_; result_type __b_; @@ -3832,13 +3832,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // bernoulli_distribution -class _LIBCPP_VISIBLE bernoulli_distribution +class _LIBCPP_TYPE_VIS bernoulli_distribution { public: // types typedef bool result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { double __p_; public: @@ -3941,13 +3941,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x) // binomial_distribution template<class _IntType = int> -class _LIBCPP_VISIBLE binomial_distribution +class _LIBCPP_TYPE_VIS binomial_distribution { public: // types typedef _IntType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __t_; double __p_; @@ -4106,13 +4106,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // exponential_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE exponential_distribution +class _LIBCPP_TYPE_VIS exponential_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __lambda_; public: @@ -4221,13 +4221,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // normal_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE normal_distribution +class _LIBCPP_TYPE_VIS normal_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __mean_; result_type __stddev_; @@ -4389,13 +4389,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // lognormal_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE lognormal_distribution +class _LIBCPP_TYPE_VIS lognormal_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { normal_distribution<result_type> __nd_; public: @@ -4514,13 +4514,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // poisson_distribution template<class _IntType = int> -class _LIBCPP_VISIBLE poisson_distribution +class _LIBCPP_TYPE_VIS poisson_distribution { public: // types typedef _IntType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { double __mean_; double __s_; @@ -4745,13 +4745,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // weibull_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE weibull_distribution +class _LIBCPP_TYPE_VIS weibull_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __a_; result_type __b_; @@ -4859,13 +4859,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, } template<class _RealType = double> -class _LIBCPP_VISIBLE extreme_value_distribution +class _LIBCPP_TYPE_VIS extreme_value_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __a_; result_type __b_; @@ -4980,13 +4980,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // gamma_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE gamma_distribution +class _LIBCPP_TYPE_VIS gamma_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __alpha_; result_type __beta_; @@ -5152,13 +5152,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // negative_binomial_distribution template<class _IntType = int> -class _LIBCPP_VISIBLE negative_binomial_distribution +class _LIBCPP_TYPE_VIS negative_binomial_distribution { public: // types typedef _IntType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __k_; double __p_; @@ -5287,13 +5287,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // geometric_distribution template<class _IntType = int> -class _LIBCPP_VISIBLE geometric_distribution +class _LIBCPP_TYPE_VIS geometric_distribution { public: // types typedef _IntType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { double __p_; public: @@ -5389,13 +5389,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // chi_squared_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE chi_squared_distribution +class _LIBCPP_TYPE_VIS chi_squared_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __n_; public: @@ -5495,13 +5495,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // cauchy_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE cauchy_distribution +class _LIBCPP_TYPE_VIS cauchy_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __a_; result_type __b_; @@ -5618,13 +5618,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // fisher_f_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE fisher_f_distribution +class _LIBCPP_TYPE_VIS fisher_f_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __m_; result_type __n_; @@ -5740,13 +5740,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // student_t_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE student_t_distribution +class _LIBCPP_TYPE_VIS student_t_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { result_type __n_; public: @@ -5853,13 +5853,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // discrete_distribution template<class _IntType = int> -class _LIBCPP_VISIBLE discrete_distribution +class _LIBCPP_TYPE_VIS discrete_distribution { public: // types typedef _IntType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { vector<double> __p_; public: @@ -6084,13 +6084,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // piecewise_constant_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE piecewise_constant_distribution +class _LIBCPP_TYPE_VIS piecewise_constant_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { vector<result_type> __b_; vector<result_type> __densities_; @@ -6408,13 +6408,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // piecewise_linear_distribution template<class _RealType = double> -class _LIBCPP_VISIBLE piecewise_linear_distribution +class _LIBCPP_TYPE_VIS piecewise_linear_distribution { public: // types typedef _RealType result_type; - class _LIBCPP_VISIBLE param_type + class _LIBCPP_TYPE_VIS param_type { vector<result_type> __b_; vector<result_type> __densities_; diff --git a/contrib/libc++/include/ratio b/contrib/libc++/include/ratio index 23f2267..f4e741e 100644 --- a/contrib/libc++/include/ratio +++ b/contrib/libc++/include/ratio @@ -231,7 +231,7 @@ public: }; template <intmax_t _Num, intmax_t _Den = 1> -class _LIBCPP_VISIBLE ratio +class _LIBCPP_TYPE_VIS ratio { static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range"); static_assert(_Den != 0, "ratio divide by 0"); @@ -292,7 +292,7 @@ template <class _R1, class _R2> using ratio_multiply #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES template <class _R1, class _R2> -struct _LIBCPP_VISIBLE ratio_multiply +struct _LIBCPP_TYPE_VIS ratio_multiply : public __ratio_multiply<_R1, _R2>::type {}; #endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES @@ -319,7 +319,7 @@ template <class _R1, class _R2> using ratio_divide #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES template <class _R1, class _R2> -struct _LIBCPP_VISIBLE ratio_divide +struct _LIBCPP_TYPE_VIS ratio_divide : public __ratio_divide<_R1, _R2>::type {}; #endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES @@ -354,7 +354,7 @@ template <class _R1, class _R2> using ratio_add #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES template <class _R1, class _R2> -struct _LIBCPP_VISIBLE ratio_add +struct _LIBCPP_TYPE_VIS ratio_add : public __ratio_add<_R1, _R2>::type {}; #endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES @@ -389,7 +389,7 @@ template <class _R1, class _R2> using ratio_subtract #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES template <class _R1, class _R2> -struct _LIBCPP_VISIBLE ratio_subtract +struct _LIBCPP_TYPE_VIS ratio_subtract : public __ratio_subtract<_R1, _R2>::type {}; #endif // _LIBCPP_HAS_NO_TEMPLATE_ALIASES @@ -397,11 +397,11 @@ struct _LIBCPP_VISIBLE ratio_subtract // ratio_equal template <class _R1, class _R2> -struct _LIBCPP_VISIBLE ratio_equal +struct _LIBCPP_TYPE_VIS ratio_equal : public integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> {}; template <class _R1, class _R2> -struct _LIBCPP_VISIBLE ratio_not_equal +struct _LIBCPP_TYPE_VIS ratio_not_equal : public integral_constant<bool, !ratio_equal<_R1, _R2>::value> {}; // ratio_less @@ -460,19 +460,19 @@ struct __ratio_less<_R1, _R2, -1LL, -1LL> }; template <class _R1, class _R2> -struct _LIBCPP_VISIBLE ratio_less +struct _LIBCPP_TYPE_VIS ratio_less : public integral_constant<bool, __ratio_less<_R1, _R2>::value> {}; template <class _R1, class _R2> -struct _LIBCPP_VISIBLE ratio_less_equal +struct _LIBCPP_TYPE_VIS ratio_less_equal : public integral_constant<bool, !ratio_less<_R2, _R1>::value> {}; template <class _R1, class _R2> -struct _LIBCPP_VISIBLE ratio_greater +struct _LIBCPP_TYPE_VIS ratio_greater : public integral_constant<bool, ratio_less<_R2, _R1>::value> {}; template <class _R1, class _R2> -struct _LIBCPP_VISIBLE ratio_greater_equal +struct _LIBCPP_TYPE_VIS ratio_greater_equal : public integral_constant<bool, !ratio_less<_R1, _R2>::value> {}; template <class _R1, class _R2> diff --git a/contrib/libc++/include/regex b/contrib/libc++/include/regex index 982500f..d1afa54 100644 --- a/contrib/libc++/include/regex +++ b/contrib/libc++/include/regex @@ -764,7 +764,7 @@ _LIBCPP_CONSTEXPR syntax_option_type operator~(syntax_option_type __x) { - return syntax_option_type(~int(__x)); + return syntax_option_type(~int(__x) & 0x1FF); } inline _LIBCPP_INLINE_VISIBILITY @@ -840,7 +840,7 @@ _LIBCPP_CONSTEXPR match_flag_type operator~(match_flag_type __x) { - return match_flag_type(~int(__x)); + return match_flag_type(~int(__x) & 0x0FFF); } inline _LIBCPP_INLINE_VISIBILITY @@ -925,7 +925,7 @@ public: }; template <class _CharT> -struct _LIBCPP_VISIBLE regex_traits +struct _LIBCPP_TYPE_VIS regex_traits { public: typedef _CharT char_type; @@ -1009,6 +1009,10 @@ private: }; template <class _CharT> +const typename regex_traits<_CharT>::char_class_type +regex_traits<_CharT>::__regex_word; + +template <class _CharT> regex_traits<_CharT>::regex_traits() { __init(); @@ -1231,11 +1235,11 @@ regex_traits<_CharT>::__value(wchar_t __ch, int __radix) const template <class _CharT> class __node; -template <class _BidirectionalIterator> class _LIBCPP_VISIBLE sub_match; +template <class _BidirectionalIterator> class _LIBCPP_TYPE_VIS sub_match; template <class _BidirectionalIterator, class _Allocator = allocator<sub_match<_BidirectionalIterator> > > -class _LIBCPP_VISIBLE match_results; +class _LIBCPP_TYPE_VIS match_results; template <class _CharT> struct __state @@ -2411,7 +2415,7 @@ __exit: template <class _CharT, class _Traits> class __lookahead; template <class _CharT, class _Traits = regex_traits<_CharT> > -class _LIBCPP_VISIBLE basic_regex +class _LIBCPP_TYPE_VIS basic_regex { public: // types: @@ -4749,7 +4753,7 @@ typedef basic_regex<wchar_t> wregex; // sub_match template <class _BidirectionalIterator> -class _LIBCPP_VISIBLE sub_match +class _LIBCPP_TYPE_VIS sub_match : public pair<_BidirectionalIterator, _BidirectionalIterator> { public: @@ -5172,7 +5176,7 @@ operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m) } template <class _BidirectionalIterator, class _Allocator> -class _LIBCPP_VISIBLE match_results +class _LIBCPP_TYPE_VIS match_results { public: typedef _Allocator allocator_type; @@ -5958,7 +5962,7 @@ regex_match(const basic_string<_CharT, _ST, _SA>& __s, template <class _BidirectionalIterator, class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type, class _Traits = regex_traits<_CharT> > -class _LIBCPP_VISIBLE regex_iterator +class _LIBCPP_TYPE_VIS regex_iterator { public: typedef basic_regex<_CharT, _Traits> regex_type; @@ -6070,7 +6074,7 @@ typedef regex_iterator<wstring::const_iterator> wsregex_iterator; template <class _BidirectionalIterator, class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type, class _Traits = regex_traits<_CharT> > -class _LIBCPP_VISIBLE regex_token_iterator +class _LIBCPP_TYPE_VIS regex_token_iterator { public: typedef basic_regex<_CharT, _Traits> regex_type; diff --git a/contrib/libc++/include/scoped_allocator b/contrib/libc++/include/scoped_allocator index cd05102..9253234 100644 --- a/contrib/libc++/include/scoped_allocator +++ b/contrib/libc++/include/scoped_allocator @@ -365,7 +365,7 @@ struct __outermost<_Alloc, true> }; template <class _OuterAlloc, class... _InnerAllocs> -class _LIBCPP_VISIBLE scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...> +class _LIBCPP_TYPE_VIS scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...> : public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> { typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base; diff --git a/contrib/libc++/include/set b/contrib/libc++/include/set index 36d3dd4..11ea965 100644 --- a/contrib/libc++/include/set +++ b/contrib/libc++/include/set @@ -346,7 +346,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD template <class _Key, class _Compare = less<_Key>, class _Allocator = allocator<_Key> > -class _LIBCPP_VISIBLE set +class _LIBCPP_TYPE_VIS set { public: // types: @@ -685,7 +685,7 @@ swap(set<_Key, _Compare, _Allocator>& __x, template <class _Key, class _Compare = less<_Key>, class _Allocator = allocator<_Key> > -class _LIBCPP_VISIBLE multiset +class _LIBCPP_TYPE_VIS multiset { public: // types: diff --git a/contrib/libc++/include/sstream b/contrib/libc++/include/sstream index 22450f0..a8f8148 100644 --- a/contrib/libc++/include/sstream +++ b/contrib/libc++/include/sstream @@ -186,7 +186,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD // basic_stringbuf template <class _CharT, class _Traits, class _Allocator> -class _LIBCPP_VISIBLE basic_stringbuf +class _LIBCPP_TYPE_VIS basic_stringbuf : public basic_streambuf<_CharT, _Traits> { public: @@ -260,17 +260,36 @@ template <class _CharT, class _Traits, class _Allocator> basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(basic_stringbuf&& __rhs) : __mode_(__rhs.__mode_) { - ptrdiff_t __ninp = __rhs.gptr() - __rhs.eback(); - ptrdiff_t __einp = __rhs.egptr() - __rhs.eback(); - ptrdiff_t __nout = __rhs.pptr() - __rhs.pbase(); - ptrdiff_t __eout = __rhs.epptr() - __rhs.pbase(); - ptrdiff_t __hm = __rhs.__hm_ - __rhs.pbase(); + char_type* __p = const_cast<char_type*>(__rhs.__str_.data()); + ptrdiff_t __binp = -1; + ptrdiff_t __ninp = -1; + ptrdiff_t __einp = -1; + if (__rhs.eback() != nullptr) + { + __binp = __rhs.eback() - __p; + __ninp = __rhs.gptr() - __p; + __einp = __rhs.egptr() - __p; + } + ptrdiff_t __bout = -1; + ptrdiff_t __nout = -1; + ptrdiff_t __eout = -1; + if (__rhs.pbase() != nullptr) + { + __bout = __rhs.pbase() - __p; + __nout = __rhs.pptr() - __p; + __eout = __rhs.epptr() - __p; + } + ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p; __str_ = _VSTD::move(__rhs.__str_); - char_type* __p = const_cast<char_type*>(__str_.data()); - this->setg(__p, __p + __ninp, __p + __einp); - this->setp(__p, __p + __eout); - this->pbump(__nout); - __hm_ = __p + __hm; + __p = const_cast<char_type*>(__str_.data()); + if (__binp != -1) + this->setg(__p + __binp, __p + __ninp, __p + __einp); + if (__bout != -1) + { + this->setp(__p + __bout, __p + __eout); + this->pbump(__nout); + } + __hm_ = __hm == -1 ? nullptr : __p + __hm; __p = const_cast<char_type*>(__rhs.__str_.data()); __rhs.setg(__p, __p, __p); __rhs.setp(__p, __p); @@ -282,18 +301,37 @@ template <class _CharT, class _Traits, class _Allocator> basic_stringbuf<_CharT, _Traits, _Allocator>& basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs) { - ptrdiff_t __ninp = __rhs.gptr() - __rhs.eback(); - ptrdiff_t __einp = __rhs.egptr() - __rhs.eback(); - ptrdiff_t __nout = __rhs.pptr() - __rhs.pbase(); - ptrdiff_t __eout = __rhs.epptr() - __rhs.pbase(); - ptrdiff_t __hm = __rhs.__hm_ - __rhs.pbase(); - __mode_ = __rhs.__mode_; + char_type* __p = const_cast<char_type*>(__rhs.__str_.data()); + ptrdiff_t __binp = -1; + ptrdiff_t __ninp = -1; + ptrdiff_t __einp = -1; + if (__rhs.eback() != nullptr) + { + __binp = __rhs.eback() - __p; + __ninp = __rhs.gptr() - __p; + __einp = __rhs.egptr() - __p; + } + ptrdiff_t __bout = -1; + ptrdiff_t __nout = -1; + ptrdiff_t __eout = -1; + if (__rhs.pbase() != nullptr) + { + __bout = __rhs.pbase() - __p; + __nout = __rhs.pptr() - __p; + __eout = __rhs.epptr() - __p; + } + ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p; __str_ = _VSTD::move(__rhs.__str_); - char_type* __p = const_cast<char_type*>(__str_.data()); - this->setg(__p, __p + __ninp, __p + __einp); - this->setp(__p, __p + __eout); - this->pbump(__nout); - __hm_ = __p + __hm; + __p = const_cast<char_type*>(__str_.data()); + if (__binp != -1) + this->setg(__p + __binp, __p + __ninp, __p + __einp); + if (__bout != -1) + { + this->setp(__p + __bout, __p + __eout); + this->pbump(__nout); + } + __hm_ = __hm == -1 ? nullptr : __p + __hm; + __mode_ = __rhs.__mode_; __p = const_cast<char_type*>(__rhs.__str_.data()); __rhs.setg(__p, __p, __p); __rhs.setp(__p, __p); @@ -308,28 +346,74 @@ template <class _CharT, class _Traits, class _Allocator> void basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs) { - ptrdiff_t __rninp = __rhs.gptr() - __rhs.eback(); - ptrdiff_t __reinp = __rhs.egptr() - __rhs.eback(); - ptrdiff_t __rnout = __rhs.pptr() - __rhs.pbase(); - ptrdiff_t __reout = __rhs.epptr() - __rhs.pbase(); - ptrdiff_t __rhm = __rhs.__hm_ - __rhs.pbase(); - ptrdiff_t __lninp = this->gptr() - this->eback(); - ptrdiff_t __leinp = this->egptr() - this->eback(); - ptrdiff_t __lnout = this->pptr() - this->pbase(); - ptrdiff_t __leout = this->epptr() - this->pbase(); - ptrdiff_t __lhm = this->__hm_ - this->pbase(); + char_type* __p = const_cast<char_type*>(__rhs.__str_.data()); + ptrdiff_t __rbinp = -1; + ptrdiff_t __rninp = -1; + ptrdiff_t __reinp = -1; + if (__rhs.eback() != nullptr) + { + __rbinp = __rhs.eback() - __p; + __rninp = __rhs.gptr() - __p; + __reinp = __rhs.egptr() - __p; + } + ptrdiff_t __rbout = -1; + ptrdiff_t __rnout = -1; + ptrdiff_t __reout = -1; + if (__rhs.pbase() != nullptr) + { + __rbout = __rhs.pbase() - __p; + __rnout = __rhs.pptr() - __p; + __reout = __rhs.epptr() - __p; + } + ptrdiff_t __rhm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p; + __p = const_cast<char_type*>(__str_.data()); + ptrdiff_t __lbinp = -1; + ptrdiff_t __lninp = -1; + ptrdiff_t __leinp = -1; + if (this->eback() != nullptr) + { + __lbinp = this->eback() - __p; + __lninp = this->gptr() - __p; + __leinp = this->egptr() - __p; + } + ptrdiff_t __lbout = -1; + ptrdiff_t __lnout = -1; + ptrdiff_t __leout = -1; + if (this->pbase() != nullptr) + { + __lbout = this->pbase() - __p; + __lnout = this->pptr() - __p; + __leout = this->epptr() - __p; + } + ptrdiff_t __lhm = __hm_ == nullptr ? -1 : __hm_ - __p; _VSTD::swap(__mode_, __rhs.__mode_); __str_.swap(__rhs.__str_); - char_type* __p = const_cast<char_type*>(__str_.data()); - this->setg(__p, __p + __rninp, __p + __reinp); - this->setp(__p, __p + __reout); - this->pbump(__rnout); - __hm_ = __p + __rhm; + __p = const_cast<char_type*>(__str_.data()); + if (__rbinp != -1) + this->setg(__p + __rbinp, __p + __rninp, __p + __reinp); + else + this->setg(nullptr, nullptr, nullptr); + if (__rbout != -1) + { + this->setp(__p + __rbout, __p + __reout); + this->pbump(__rnout); + } + else + this->setp(nullptr, nullptr); + __hm_ = __rhm == -1 ? nullptr : __p + __rhm; __p = const_cast<char_type*>(__rhs.__str_.data()); - __rhs.setg(__p, __p + __lninp, __p + __leinp); - __rhs.setp(__p, __p + __leout); - __rhs.pbump(__lnout); - __rhs.__hm_ = __p + __lhm; + if (__lbinp != -1) + __rhs.setg(__p + __lbinp, __p + __lninp, __p + __leinp); + else + __rhs.setg(nullptr, nullptr, nullptr); + if (__lbout != -1) + { + __rhs.setp(__p + __lbout, __p + __leout); + __rhs.pbump(__lnout); + } + else + __rhs.setp(nullptr, nullptr); + __rhs.__hm_ = __lhm == -1 ? nullptr : __p + __lhm; locale __tl = __rhs.getloc(); __rhs.pubimbue(this->getloc()); this->pubimbue(__tl); @@ -529,7 +613,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::seekpos(pos_type __sp, // basic_istringstream template <class _CharT, class _Traits, class _Allocator> -class _LIBCPP_VISIBLE basic_istringstream +class _LIBCPP_TYPE_VIS basic_istringstream : public basic_istream<_CharT, _Traits> { public: @@ -648,7 +732,7 @@ basic_istringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s) // basic_ostringstream template <class _CharT, class _Traits, class _Allocator> -class _LIBCPP_VISIBLE basic_ostringstream +class _LIBCPP_TYPE_VIS basic_ostringstream : public basic_ostream<_CharT, _Traits> { public: @@ -767,7 +851,7 @@ basic_ostringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s) // basic_stringstream template <class _CharT, class _Traits, class _Allocator> -class _LIBCPP_VISIBLE basic_stringstream +class _LIBCPP_TYPE_VIS basic_stringstream : public basic_iostream<_CharT, _Traits> { public: diff --git a/contrib/libc++/include/stack b/contrib/libc++/include/stack index 12fb35b..b8a7f4c 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_VISIBLE stack; +template <class _Tp, class _Container> class _LIBCPP_TYPE_VIS stack; template <class _Tp, class _Container> _LIBCPP_INLINE_VISIBILITY @@ -104,7 +104,7 @@ bool operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y); template <class _Tp, class _Container = deque<_Tp> > -class _LIBCPP_VISIBLE stack +class _LIBCPP_TYPE_VIS stack { public: typedef _Container container_type; @@ -282,7 +282,7 @@ swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y) } template <class _Tp, class _Container, class _Alloc> -struct _LIBCPP_VISIBLE uses_allocator<stack<_Tp, _Container>, _Alloc> +struct _LIBCPP_TYPE_VIS uses_allocator<stack<_Tp, _Container>, _Alloc> : public uses_allocator<_Container, _Alloc> { }; diff --git a/contrib/libc++/include/streambuf b/contrib/libc++/include/streambuf index d688024..8261594 100644 --- a/contrib/libc++/include/streambuf +++ b/contrib/libc++/include/streambuf @@ -119,7 +119,7 @@ protected: _LIBCPP_BEGIN_NAMESPACE_STD template <class _CharT, class _Traits> -class _LIBCPP_VISIBLE basic_streambuf +class _LIBCPP_TYPE_VIS basic_streambuf { public: // types: diff --git a/contrib/libc++/include/string b/contrib/libc++/include/string index 1a70467..fa44f68 100644 --- a/contrib/libc++/include/string +++ b/contrib/libc++/include/string @@ -457,7 +457,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD // fpos template <class _StateT> -class _LIBCPP_VISIBLE fpos +class _LIBCPP_TYPE_VIS fpos { private: _StateT __st_; @@ -494,7 +494,7 @@ bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y) // char_traits template <class _CharT> -struct _LIBCPP_VISIBLE char_traits +struct _LIBCPP_TYPE_VIS char_traits { typedef _CharT char_type; typedef int int_type; @@ -620,7 +620,7 @@ char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a) // char_traits<char> template <> -struct _LIBCPP_VISIBLE char_traits<char> +struct _LIBCPP_TYPE_VIS char_traits<char> { typedef char char_type; typedef int int_type; @@ -676,7 +676,7 @@ struct _LIBCPP_VISIBLE char_traits<char> // char_traits<wchar_t> template <> -struct _LIBCPP_VISIBLE char_traits<wchar_t> +struct _LIBCPP_TYPE_VIS char_traits<wchar_t> { typedef wchar_t char_type; typedef wint_t int_type; @@ -733,7 +733,7 @@ struct _LIBCPP_VISIBLE char_traits<wchar_t> #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS template <> -struct _LIBCPP_VISIBLE char_traits<char16_t> +struct _LIBCPP_TYPE_VIS char_traits<char16_t> { typedef char16_t char_type; typedef uint_least16_t int_type; @@ -853,7 +853,7 @@ char_traits<char16_t>::assign(char_type* __s, size_t __n, char_type __a) } template <> -struct _LIBCPP_VISIBLE char_traits<char32_t> +struct _LIBCPP_TYPE_VIS char_traits<char32_t> { typedef char32_t char_type; typedef uint_least32_t int_type; @@ -1037,7 +1037,7 @@ _LIBCPP_EXTERN_TEMPLATE(class __basic_string_common<true>) #endif // _MSC_VER template<class _CharT, class _Traits, class _Allocator> -class _LIBCPP_VISIBLE basic_string +class _LIBCPP_TYPE_VIS basic_string : private __basic_string_common<true> { public: @@ -1462,6 +1462,11 @@ public: int compare(size_type __pos1, size_type __n1, const_pointer __s, size_type __n2) const; _LIBCPP_INLINE_VISIBILITY bool __invariants() const; + + _LIBCPP_INLINE_VISIBILITY + bool __is_long() const _NOEXCEPT + {return bool(__r_.first().__s.__size_ & __short_mask);} + private: _LIBCPP_INLINE_VISIBILITY allocator_type& __alloc() _NOEXCEPT @@ -1471,10 +1476,6 @@ private: {return __r_.second();} _LIBCPP_INLINE_VISIBILITY - bool __is_long() const _NOEXCEPT - {return bool(__r_.first().__s.__size_ & __short_mask);} - - _LIBCPP_INLINE_VISIBILITY void __set_short_size(size_type __s) _NOEXCEPT #if _LIBCPP_BIG_ENDIAN {__r_.first().__s.__size_ = (unsigned char)(__s);} @@ -3561,9 +3562,29 @@ bool operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT { - return __lhs.size() == __rhs.size() && _Traits::compare(__lhs.data(), - __rhs.data(), - __lhs.size()) == 0; + size_t __lhs_sz = __lhs.size(); + return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(), + __rhs.data(), + __lhs_sz) == 0; +} + +template<class _Allocator> +_LIBCPP_INLINE_VISIBILITY inline +bool +operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs, + const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT +{ + size_t __lhs_sz = __lhs.size(); + if (__lhs_sz != __rhs.size()) + return false; + const char* __lp = __lhs.data(); + const char* __rp = __rhs.data(); + if (__lhs.__is_long()) + return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0; + for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp) + if (*__lp != *__rp) + return false; + return true; } template<class _CharT, class _Traits, class _Allocator> @@ -3923,7 +3944,7 @@ size_t _LIBCPP_INLINE_VISIBILITY __do_string_hash(_Ptr __p, _Ptr __e) } template<class _CharT, class _Traits, class _Allocator> -struct _LIBCPP_VISIBLE hash<basic_string<_CharT, _Traits, _Allocator> > +struct _LIBCPP_TYPE_VIS hash<basic_string<_CharT, _Traits, _Allocator> > : public unary_function<basic_string<_CharT, _Traits, _Allocator>, size_t> { size_t diff --git a/contrib/libc++/include/strstream b/contrib/libc++/include/strstream index 5eadefd..81eef2a 100644 --- a/contrib/libc++/include/strstream +++ b/contrib/libc++/include/strstream @@ -137,7 +137,7 @@ private: _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE strstreambuf +class _LIBCPP_TYPE_VIS strstreambuf : public streambuf { public: @@ -228,7 +228,7 @@ strstreambuf::operator=(strstreambuf&& __rhs) #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES -class _LIBCPP_VISIBLE istrstream +class _LIBCPP_TYPE_VIS istrstream : public istream { public: @@ -281,7 +281,7 @@ private: strstreambuf __sb_; }; -class _LIBCPP_VISIBLE ostrstream +class _LIBCPP_TYPE_VIS ostrstream : public ostream { public: @@ -334,7 +334,7 @@ private: strstreambuf __sb_; // exposition only }; -class _LIBCPP_VISIBLE strstream +class _LIBCPP_TYPE_VIS strstream : public iostream { public: diff --git a/contrib/libc++/include/system_error b/contrib/libc++/include/system_error index cbc52fb..1c1c7eb 100644 --- a/contrib/libc++/include/system_error +++ b/contrib/libc++/include/system_error @@ -232,13 +232,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD // is_error_code_enum template <class _Tp> -struct _LIBCPP_VISIBLE is_error_code_enum +struct _LIBCPP_TYPE_VIS is_error_code_enum : public false_type {}; // is_error_condition_enum template <class _Tp> -struct _LIBCPP_VISIBLE is_error_condition_enum +struct _LIBCPP_TYPE_VIS is_error_condition_enum : public false_type {}; // Some error codes are not present on all platforms, so we provide equivalents @@ -345,23 +345,23 @@ _LIBCPP_DECLARE_STRONG_ENUM(errc) _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc) template <> -struct _LIBCPP_VISIBLE is_error_condition_enum<errc> +struct _LIBCPP_TYPE_VIS is_error_condition_enum<errc> : true_type { }; #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS template <> -struct _LIBCPP_VISIBLE is_error_condition_enum<errc::__lx> +struct _LIBCPP_TYPE_VIS is_error_condition_enum<errc::__lx> : true_type { }; #endif -class _LIBCPP_VISIBLE error_condition; -class _LIBCPP_VISIBLE error_code; +class _LIBCPP_TYPE_VIS error_condition; +class _LIBCPP_TYPE_VIS error_code; // class error_category class _LIBCPP_HIDDEN __do_message; -class _LIBCPP_VISIBLE error_category +class _LIBCPP_TYPE_VIS error_category { public: virtual ~error_category() _NOEXCEPT; @@ -400,7 +400,7 @@ public: const error_category& generic_category() _NOEXCEPT; const error_category& system_category() _NOEXCEPT; -class _LIBCPP_VISIBLE error_condition +class _LIBCPP_TYPE_VIS error_condition { int __val_; const error_category* __cat_; @@ -472,7 +472,7 @@ operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT // error_code -class _LIBCPP_VISIBLE error_code +class _LIBCPP_TYPE_VIS error_code { int __val_; const error_category* __cat_; @@ -597,7 +597,7 @@ operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT {return !(__x == __y);} template <> -struct _LIBCPP_VISIBLE hash<error_code> +struct _LIBCPP_TYPE_VIS hash<error_code> : public unary_function<error_code, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -609,7 +609,7 @@ struct _LIBCPP_VISIBLE hash<error_code> // system_error -class _LIBCPP_VISIBLE system_error +class _LIBCPP_TYPE_VIS system_error : public runtime_error { error_code __ec_; diff --git a/contrib/libc++/include/thread b/contrib/libc++/include/thread index 60d8885..f41ea29 100644 --- a/contrib/libc++/include/thread +++ b/contrib/libc++/include/thread @@ -144,9 +144,11 @@ template <class _Tp> __thread_specific_ptr<_Tp>::__thread_specific_ptr() { int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit); +#ifndef _LIBCPP_NO_EXCEPTIONS if (__ec) throw system_error(error_code(__ec, system_category()), "__thread_specific_ptr construction failed"); +#endif } template <class _Tp> @@ -173,8 +175,8 @@ __thread_specific_ptr<_Tp>::reset(pointer __p) delete __p_old; } -class _LIBCPP_VISIBLE thread; -class _LIBCPP_VISIBLE __thread_id; +class _LIBCPP_TYPE_VIS thread; +class _LIBCPP_TYPE_VIS __thread_id; namespace this_thread { @@ -183,10 +185,10 @@ _LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT; } // this_thread -class _LIBCPP_VISIBLE __thread_id; -template<> struct _LIBCPP_VISIBLE hash<__thread_id>; +class _LIBCPP_TYPE_VIS __thread_id; +template<> struct _LIBCPP_TYPE_VIS hash<__thread_id>; -class _LIBCPP_VISIBLE __thread_id +class _LIBCPP_TYPE_VIS __thread_id { // FIXME: pthread_t is a pointer on Darwin but a long on Linux. // NULL is the no-thread value on Darwin. Someone needs to check @@ -228,12 +230,12 @@ private: __thread_id(pthread_t __id) : __id_(__id) {} friend __thread_id this_thread::get_id() _NOEXCEPT; - friend class _LIBCPP_VISIBLE thread; - friend struct _LIBCPP_VISIBLE hash<__thread_id>; + friend class _LIBCPP_TYPE_VIS thread; + friend struct _LIBCPP_TYPE_VIS hash<__thread_id>; }; template<> -struct _LIBCPP_VISIBLE hash<__thread_id> +struct _LIBCPP_TYPE_VIS hash<__thread_id> : public unary_function<__thread_id, size_t> { _LIBCPP_INLINE_VISIBILITY @@ -255,7 +257,7 @@ get_id() _NOEXCEPT } // this_thread -class _LIBCPP_VISIBLE thread +class _LIBCPP_TYPE_VIS thread { pthread_t __t_; @@ -326,7 +328,7 @@ __thread_specific_ptr<__thread_struct>& __thread_local_data(); template <class _Fp, class ..._Args, size_t ..._Indices> inline _LIBCPP_INLINE_VISIBILITY void -__threaad_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>) +__thread_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>) { __invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...); } @@ -338,7 +340,7 @@ __thread_proxy(void* __vp) __thread_local_data().reset(new __thread_struct); std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp)); typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index; - __threaad_execute(*__p, _Index()); + __thread_execute(*__p, _Index()); return nullptr; } diff --git a/contrib/libc++/include/tuple b/contrib/libc++/include/tuple index 3fa6730..0df315e 100644 --- a/contrib/libc++/include/tuple +++ b/contrib/libc++/include/tuple @@ -128,7 +128,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD // allocator_arg_t -struct _LIBCPP_VISIBLE allocator_arg_t { }; +struct _LIBCPP_TYPE_VIS allocator_arg_t { }; #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY) extern const allocator_arg_t allocator_arg; @@ -163,7 +163,7 @@ struct __uses_allocator<_Tp, _Alloc, false> }; template <class _Tp, class _Alloc> -struct _LIBCPP_VISIBLE uses_allocator +struct _LIBCPP_TYPE_VIS uses_allocator : public __uses_allocator<_Tp, _Alloc> { }; @@ -193,7 +193,7 @@ struct __uses_alloc_ctor // tuple_size template <class ..._Tp> -class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...> > +class _LIBCPP_TYPE_VIS tuple_size<tuple<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> { }; @@ -201,7 +201,7 @@ class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...> > // tuple_element template <size_t _Ip, class ..._Tp> -class _LIBCPP_VISIBLE tuple_element<_Ip, tuple<_Tp...> > +class _LIBCPP_TYPE_VIS tuple_element<_Ip, tuple<_Tp...> > { public: typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type; @@ -477,7 +477,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...> template <class _Tuple, class = typename enable_if < - __tuple_convertible<_Tuple, tuple<_Tp...> >::value + __tuple_constructible<_Tuple, tuple<_Tp...> >::value >::type > _LIBCPP_INLINE_VISIBILITY @@ -533,7 +533,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...> }; template <class ..._Tp> -class _LIBCPP_VISIBLE tuple +class _LIBCPP_TYPE_VIS tuple { typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> base; @@ -721,7 +721,7 @@ public: }; template <> -class _LIBCPP_VISIBLE tuple<> +class _LIBCPP_TYPE_VIS tuple<> { public: _LIBCPP_INLINE_VISIBILITY @@ -803,7 +803,7 @@ struct __ignore_t namespace { const __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>(); } -template <class _Tp> class _LIBCPP_VISIBLE reference_wrapper; +template <class _Tp> class _LIBCPP_TYPE_VIS reference_wrapper; template <class _Tp> struct ___make_tuple_return @@ -1071,7 +1071,7 @@ tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls) } template <class ..._Tp, class _Alloc> -struct _LIBCPP_VISIBLE uses_allocator<tuple<_Tp...>, _Alloc> +struct _LIBCPP_TYPE_VIS uses_allocator<tuple<_Tp...>, _Alloc> : true_type {}; template <class _T1, class _T2> diff --git a/contrib/libc++/include/type_traits b/contrib/libc++/include/type_traits index 8f1c602..ab0e222 100644 --- a/contrib/libc++/include/type_traits +++ b/contrib/libc++/include/type_traits @@ -129,6 +129,7 @@ namespace std template <class T> struct alignment_of; template <size_t Len, size_t Align = most_stringent_alignment_requirement> struct aligned_storage; + template <size_t Len, class... Types> struct aligned_union; template <class T> struct decay; template <class... T> struct common_type; @@ -149,19 +150,19 @@ namespace std _LIBCPP_BEGIN_NAMESPACE_STD template <bool _Bp, class _If, class _Then> - struct _LIBCPP_VISIBLE conditional {typedef _If type;}; + struct _LIBCPP_TYPE_VIS conditional {typedef _If type;}; template <class _If, class _Then> - struct _LIBCPP_VISIBLE conditional<false, _If, _Then> {typedef _Then type;}; + struct _LIBCPP_TYPE_VIS conditional<false, _If, _Then> {typedef _Then type;}; -template <bool, class _Tp = void> struct _LIBCPP_VISIBLE enable_if {}; -template <class _Tp> struct _LIBCPP_VISIBLE enable_if<true, _Tp> {typedef _Tp type;}; +template <bool, class _Tp = void> struct _LIBCPP_TYPE_VIS enable_if {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS enable_if<true, _Tp> {typedef _Tp type;}; struct __two {char __lx[2];}; // helper class: template <class _Tp, _Tp __v> -struct _LIBCPP_VISIBLE integral_constant +struct _LIBCPP_TYPE_VIS integral_constant { static _LIBCPP_CONSTEXPR const _Tp value = __v; typedef _Tp value_type; @@ -178,27 +179,27 @@ typedef integral_constant<bool, false> false_type; // is_const -template <class _Tp> struct _LIBCPP_VISIBLE is_const : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_const<_Tp const> : public true_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_const : public false_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_const<_Tp const> : public true_type {}; // is_volatile -template <class _Tp> struct _LIBCPP_VISIBLE is_volatile : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_volatile<_Tp volatile> : public true_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_volatile : public false_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_volatile<_Tp volatile> : public true_type {}; // remove_const -template <class _Tp> struct _LIBCPP_VISIBLE remove_const {typedef _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE remove_const<const _Tp> {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_const {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_const<const _Tp> {typedef _Tp type;}; // remove_volatile -template <class _Tp> struct _LIBCPP_VISIBLE remove_volatile {typedef _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE remove_volatile<volatile _Tp> {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_volatile {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;}; // remove_cv -template <class _Tp> struct _LIBCPP_VISIBLE remove_cv +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_cv {typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;}; // is_void @@ -206,7 +207,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE remove_cv template <class _Tp> struct __is_void : public false_type {}; template <> struct __is_void<void> : public true_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_void +template <class _Tp> struct _LIBCPP_TYPE_VIS is_void : public __is_void<typename remove_cv<_Tp>::type> {}; // __is_nullptr_t @@ -214,7 +215,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_void template <class _Tp> struct ____is_nullptr_t : public false_type {}; template <> struct ____is_nullptr_t<nullptr_t> : public true_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE __is_nullptr_t +template <class _Tp> struct _LIBCPP_TYPE_VIS __is_nullptr_t : public ____is_nullptr_t<typename remove_cv<_Tp>::type> {}; // is_integral @@ -238,7 +239,7 @@ template <> struct __is_integral<unsigned long> : public true_type template <> struct __is_integral<long long> : public true_type {}; template <> struct __is_integral<unsigned long long> : public true_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_integral +template <class _Tp> struct _LIBCPP_TYPE_VIS is_integral : public __is_integral<typename remove_cv<_Tp>::type> {}; // is_floating_point @@ -248,16 +249,16 @@ template <> struct __is_floating_point<float> : public true_type template <> struct __is_floating_point<double> : public true_type {}; template <> struct __is_floating_point<long double> : public true_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_floating_point +template <class _Tp> struct _LIBCPP_TYPE_VIS is_floating_point : public __is_floating_point<typename remove_cv<_Tp>::type> {}; // is_array -template <class _Tp> struct _LIBCPP_VISIBLE is_array +template <class _Tp> struct _LIBCPP_TYPE_VIS is_array : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_array<_Tp[]> +template <class _Tp> struct _LIBCPP_TYPE_VIS is_array<_Tp[]> : public true_type {}; -template <class _Tp, size_t _Np> struct _LIBCPP_VISIBLE is_array<_Tp[_Np]> +template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS is_array<_Tp[_Np]> : public true_type {}; // is_pointer @@ -265,23 +266,23 @@ template <class _Tp, size_t _Np> struct _LIBCPP_VISIBLE is_array<_Tp[_Np]> template <class _Tp> struct __is_pointer : public false_type {}; template <class _Tp> struct __is_pointer<_Tp*> : public true_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_pointer +template <class _Tp> struct _LIBCPP_TYPE_VIS is_pointer : public __is_pointer<typename remove_cv<_Tp>::type> {}; // is_reference -template <class _Tp> struct _LIBCPP_VISIBLE is_lvalue_reference : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_lvalue_reference<_Tp&> : public true_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_lvalue_reference : public false_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_lvalue_reference<_Tp&> : public true_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_rvalue_reference : public false_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_rvalue_reference : public false_type {}; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _Tp> struct _LIBCPP_VISIBLE is_rvalue_reference<_Tp&&> : public true_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_rvalue_reference<_Tp&&> : public true_type {}; #endif -template <class _Tp> struct _LIBCPP_VISIBLE is_reference : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_reference<_Tp&> : public true_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_reference : public false_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_reference<_Tp&> : public true_type {}; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _Tp> struct _LIBCPP_VISIBLE is_reference<_Tp&&> : public true_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_reference<_Tp&&> : public true_type {}; #endif #if defined(__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) @@ -292,13 +293,13 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_reference<_Tp&&> : public true_ty #if __has_feature(is_union) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template <class _Tp> struct _LIBCPP_VISIBLE is_union +template <class _Tp> struct _LIBCPP_TYPE_VIS is_union : public integral_constant<bool, __is_union(_Tp)> {}; #else template <class _Tp> struct __libcpp_union : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_union +template <class _Tp> struct _LIBCPP_TYPE_VIS is_union : public __libcpp_union<typename remove_cv<_Tp>::type> {}; #endif @@ -307,7 +308,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_union #if __has_feature(is_class) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template <class _Tp> struct _LIBCPP_VISIBLE is_class +template <class _Tp> struct _LIBCPP_TYPE_VIS is_class : public integral_constant<bool, __is_class(_Tp)> {}; #else @@ -318,15 +319,15 @@ template <class _Tp> char __test(int _Tp::*); template <class _Tp> __two __test(...); } -template <class _Tp> struct _LIBCPP_VISIBLE is_class +template <class _Tp> struct _LIBCPP_TYPE_VIS is_class : public integral_constant<bool, sizeof(__is_class_imp::__test<_Tp>(0)) == 1 && !is_union<_Tp>::value> {}; #endif // is_same -template <class _Tp, class _Up> struct _LIBCPP_VISIBLE is_same : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_same<_Tp, _Tp> : public true_type {}; +template <class _Tp, class _Up> struct _LIBCPP_TYPE_VIS is_same : public false_type {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_same<_Tp, _Tp> : public true_type {}; // is_function @@ -347,7 +348,7 @@ struct __is_function {}; template <class _Tp> struct __is_function<_Tp, true> : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_function +template <class _Tp> struct _LIBCPP_TYPE_VIS is_function : public __is_function<_Tp> {}; // is_member_function_pointer @@ -355,7 +356,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_function template <class _Tp> struct __is_member_function_pointer : public false_type {}; template <class _Tp, class _Up> struct __is_member_function_pointer<_Tp _Up::*> : public is_function<_Tp> {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_member_function_pointer +template <class _Tp> struct _LIBCPP_TYPE_VIS is_member_function_pointer : public __is_member_function_pointer<typename remove_cv<_Tp>::type> {}; // is_member_pointer @@ -363,12 +364,12 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_member_function_pointer template <class _Tp> struct __is_member_pointer : public false_type {}; template <class _Tp, class _Up> struct __is_member_pointer<_Tp _Up::*> : public true_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_member_pointer +template <class _Tp> struct _LIBCPP_TYPE_VIS is_member_pointer : public __is_member_pointer<typename remove_cv<_Tp>::type> {}; // is_member_object_pointer -template <class _Tp> struct _LIBCPP_VISIBLE is_member_object_pointer +template <class _Tp> struct _LIBCPP_TYPE_VIS is_member_object_pointer : public integral_constant<bool, is_member_pointer<_Tp>::value && !is_member_function_pointer<_Tp>::value> {}; @@ -376,12 +377,12 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_member_object_pointer #if __has_feature(is_enum) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template <class _Tp> struct _LIBCPP_VISIBLE is_enum +template <class _Tp> struct _LIBCPP_TYPE_VIS is_enum : public integral_constant<bool, __is_enum(_Tp)> {}; #else -template <class _Tp> struct _LIBCPP_VISIBLE is_enum +template <class _Tp> struct _LIBCPP_TYPE_VIS is_enum : public integral_constant<bool, !is_void<_Tp>::value && !is_integral<_Tp>::value && !is_floating_point<_Tp>::value && @@ -397,31 +398,31 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_enum // is_arithmetic -template <class _Tp> struct _LIBCPP_VISIBLE is_arithmetic +template <class _Tp> struct _LIBCPP_TYPE_VIS is_arithmetic : public integral_constant<bool, is_integral<_Tp>::value || is_floating_point<_Tp>::value> {}; // is_fundamental -template <class _Tp> struct _LIBCPP_VISIBLE is_fundamental +template <class _Tp> struct _LIBCPP_TYPE_VIS is_fundamental : public integral_constant<bool, is_void<_Tp>::value || __is_nullptr_t<_Tp>::value || is_arithmetic<_Tp>::value> {}; // is_scalar -template <class _Tp> struct _LIBCPP_VISIBLE is_scalar +template <class _Tp> struct _LIBCPP_TYPE_VIS is_scalar : public integral_constant<bool, is_arithmetic<_Tp>::value || is_member_pointer<_Tp>::value || is_pointer<_Tp>::value || __is_nullptr_t<_Tp>::value || is_enum<_Tp>::value > {}; -template <> struct _LIBCPP_VISIBLE is_scalar<nullptr_t> : public true_type {}; +template <> struct _LIBCPP_TYPE_VIS is_scalar<nullptr_t> : public true_type {}; // is_object -template <class _Tp> struct _LIBCPP_VISIBLE is_object +template <class _Tp> struct _LIBCPP_TYPE_VIS is_object : public integral_constant<bool, is_scalar<_Tp>::value || is_array<_Tp>::value || is_union<_Tp>::value || @@ -429,7 +430,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_object // is_compound -template <class _Tp> struct _LIBCPP_VISIBLE is_compound +template <class _Tp> struct _LIBCPP_TYPE_VIS is_compound : public integral_constant<bool, !is_fundamental<_Tp>::value> {}; // add_const @@ -442,7 +443,7 @@ struct __add_const {typedef _Tp type;}; template <class _Tp> struct __add_const<_Tp, false> {typedef const _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE add_const +template <class _Tp> struct _LIBCPP_TYPE_VIS add_const {typedef typename __add_const<_Tp>::type type;}; // add_volatile @@ -455,38 +456,38 @@ struct __add_volatile {typedef _Tp type;}; template <class _Tp> struct __add_volatile<_Tp, false> {typedef volatile _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE add_volatile +template <class _Tp> struct _LIBCPP_TYPE_VIS add_volatile {typedef typename __add_volatile<_Tp>::type type;}; // add_cv -template <class _Tp> struct _LIBCPP_VISIBLE add_cv +template <class _Tp> struct _LIBCPP_TYPE_VIS add_cv {typedef typename add_const<typename add_volatile<_Tp>::type>::type type;}; // remove_reference -template <class _Tp> struct _LIBCPP_VISIBLE remove_reference {typedef _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE remove_reference<_Tp&> {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_reference {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_reference<_Tp&> {typedef _Tp type;}; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _Tp> struct _LIBCPP_VISIBLE remove_reference<_Tp&&> {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_reference<_Tp&&> {typedef _Tp type;}; #endif // add_lvalue_reference -template <class _Tp> struct _LIBCPP_VISIBLE add_lvalue_reference {typedef _Tp& type;}; -template <class _Tp> struct _LIBCPP_VISIBLE add_lvalue_reference<_Tp&> {typedef _Tp& type;}; // for older compiler -template <> struct _LIBCPP_VISIBLE add_lvalue_reference<void> {typedef void type;}; -template <> struct _LIBCPP_VISIBLE add_lvalue_reference<const void> {typedef const void type;}; -template <> struct _LIBCPP_VISIBLE add_lvalue_reference<volatile void> {typedef volatile void type;}; -template <> struct _LIBCPP_VISIBLE add_lvalue_reference<const volatile void> {typedef const volatile void type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS add_lvalue_reference {typedef _Tp& type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS add_lvalue_reference<_Tp&> {typedef _Tp& type;}; // for older compiler +template <> struct _LIBCPP_TYPE_VIS add_lvalue_reference<void> {typedef void type;}; +template <> struct _LIBCPP_TYPE_VIS add_lvalue_reference<const void> {typedef const void type;}; +template <> struct _LIBCPP_TYPE_VIS add_lvalue_reference<volatile void> {typedef volatile void type;}; +template <> struct _LIBCPP_TYPE_VIS add_lvalue_reference<const volatile void> {typedef const volatile void type;}; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _Tp> struct _LIBCPP_VISIBLE add_rvalue_reference {typedef _Tp&& type;}; -template <> struct _LIBCPP_VISIBLE add_rvalue_reference<void> {typedef void type;}; -template <> struct _LIBCPP_VISIBLE add_rvalue_reference<const void> {typedef const void type;}; -template <> struct _LIBCPP_VISIBLE add_rvalue_reference<volatile void> {typedef volatile void type;}; -template <> struct _LIBCPP_VISIBLE add_rvalue_reference<const volatile void> {typedef const volatile void type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS add_rvalue_reference {typedef _Tp&& type;}; +template <> struct _LIBCPP_TYPE_VIS add_rvalue_reference<void> {typedef void type;}; +template <> struct _LIBCPP_TYPE_VIS add_rvalue_reference<const void> {typedef const void type;}; +template <> struct _LIBCPP_TYPE_VIS add_rvalue_reference<volatile void> {typedef volatile void type;}; +template <> struct _LIBCPP_TYPE_VIS add_rvalue_reference<const volatile void> {typedef const volatile void type;}; #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -511,15 +512,15 @@ struct __any // remove_pointer -template <class _Tp> struct _LIBCPP_VISIBLE remove_pointer {typedef _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE remove_pointer<_Tp*> {typedef _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE remove_pointer<_Tp* const> {typedef _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE remove_pointer<_Tp* volatile> {typedef _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE remove_pointer<_Tp* const volatile> {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer<_Tp*> {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* const> {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* volatile> {typedef _Tp type;}; +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* const volatile> {typedef _Tp type;}; // add_pointer -template <class _Tp> struct _LIBCPP_VISIBLE add_pointer +template <class _Tp> struct _LIBCPP_TYPE_VIS add_pointer {typedef typename remove_reference<_Tp>::type* type;}; // is_signed @@ -535,7 +536,7 @@ struct __is_signed : public ___is_signed<_Tp> {}; template <class _Tp> struct __is_signed<_Tp, false> : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_signed : public __is_signed<_Tp> {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_signed : public __is_signed<_Tp> {}; // is_unsigned @@ -550,46 +551,46 @@ struct __is_unsigned : public ___is_unsigned<_Tp> {}; template <class _Tp> struct __is_unsigned<_Tp, false> : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_unsigned : public __is_unsigned<_Tp> {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_unsigned : public __is_unsigned<_Tp> {}; // rank -template <class _Tp> struct _LIBCPP_VISIBLE rank +template <class _Tp> struct _LIBCPP_TYPE_VIS rank : public integral_constant<size_t, 0> {}; -template <class _Tp> struct _LIBCPP_VISIBLE rank<_Tp[]> +template <class _Tp> struct _LIBCPP_TYPE_VIS rank<_Tp[]> : public integral_constant<size_t, rank<_Tp>::value + 1> {}; -template <class _Tp, size_t _Np> struct _LIBCPP_VISIBLE rank<_Tp[_Np]> +template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS rank<_Tp[_Np]> : public integral_constant<size_t, rank<_Tp>::value + 1> {}; // extent -template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_VISIBLE extent +template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TYPE_VIS extent : public integral_constant<size_t, 0> {}; -template <class _Tp> struct _LIBCPP_VISIBLE extent<_Tp[], 0> +template <class _Tp> struct _LIBCPP_TYPE_VIS extent<_Tp[], 0> : public integral_constant<size_t, 0> {}; -template <class _Tp, unsigned _Ip> struct _LIBCPP_VISIBLE extent<_Tp[], _Ip> +template <class _Tp, unsigned _Ip> struct _LIBCPP_TYPE_VIS extent<_Tp[], _Ip> : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {}; -template <class _Tp, size_t _Np> struct _LIBCPP_VISIBLE extent<_Tp[_Np], 0> +template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS extent<_Tp[_Np], 0> : public integral_constant<size_t, _Np> {}; -template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_VISIBLE extent<_Tp[_Np], _Ip> +template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TYPE_VIS extent<_Tp[_Np], _Ip> : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {}; // remove_extent -template <class _Tp> struct _LIBCPP_VISIBLE remove_extent +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_extent {typedef _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE remove_extent<_Tp[]> +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_extent<_Tp[]> {typedef _Tp type;}; -template <class _Tp, size_t _Np> struct _LIBCPP_VISIBLE remove_extent<_Tp[_Np]> +template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS remove_extent<_Tp[_Np]> {typedef _Tp type;}; // remove_all_extents -template <class _Tp> struct _LIBCPP_VISIBLE remove_all_extents +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_all_extents {typedef _Tp type;}; -template <class _Tp> struct _LIBCPP_VISIBLE remove_all_extents<_Tp[]> +template <class _Tp> struct _LIBCPP_TYPE_VIS remove_all_extents<_Tp[]> {typedef typename remove_all_extents<_Tp>::type type;}; -template <class _Tp, size_t _Np> struct _LIBCPP_VISIBLE remove_all_extents<_Tp[_Np]> +template <class _Tp, size_t _Np> struct _LIBCPP_TYPE_VIS remove_all_extents<_Tp[_Np]> {typedef typename remove_all_extents<_Tp>::type type;}; // is_abstract @@ -605,14 +606,14 @@ struct __libcpp_abstract : public integral_constant<bool, sizeof(__is_abstract_i template <class _Tp> struct __libcpp_abstract<_Tp, false> : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_abstract : public __libcpp_abstract<_Tp> {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_abstract : public __libcpp_abstract<_Tp> {}; // is_base_of #ifdef _LIBCP_HAS_IS_BASE_OF template <class _Bp, class _Dp> -struct _LIBCPP_VISIBLE is_base_of +struct _LIBCPP_TYPE_VIS is_base_of : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {}; #else // __has_feature(is_base_of) @@ -636,7 +637,7 @@ template <class _Bp, class _Dp> __two __test(...); } template <class _Bp, class _Dp> -struct _LIBCPP_VISIBLE is_base_of +struct _LIBCPP_TYPE_VIS is_base_of : public integral_constant<bool, is_class<_Bp>::value && sizeof(__is_base_of_imp::__test<_Bp, _Dp>(0)) == 2> {}; @@ -646,7 +647,7 @@ struct _LIBCPP_VISIBLE is_base_of #if __has_feature(is_convertible_to) -template <class _T1, class _T2> struct _LIBCPP_VISIBLE is_convertible +template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS is_convertible : public integral_constant<bool, __is_convertible_to(_T1, _T2) && !is_abstract<_T2>::value> {}; @@ -752,7 +753,7 @@ template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 3> : public template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {}; template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {}; -template <class _T1, class _T2> struct _LIBCPP_VISIBLE is_convertible +template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS is_convertible : public __is_convertible<_T1, _T2> { static const size_t __complete_check1 = __is_convertible_check<_T1>::__v; @@ -766,7 +767,7 @@ template <class _T1, class _T2> struct _LIBCPP_VISIBLE is_convertible #if __has_feature(is_empty) template <class _Tp> -struct _LIBCPP_VISIBLE is_empty +struct _LIBCPP_TYPE_VIS is_empty : public integral_constant<bool, __is_empty(_Tp)> {}; #else // __has_feature(is_empty) @@ -788,7 +789,7 @@ struct __libcpp_empty : public integral_constant<bool, sizeof(__is_empty1<_Tp>) template <class _Tp> struct __libcpp_empty<_Tp, false> : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_empty : public __libcpp_empty<_Tp> {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_empty : public __libcpp_empty<_Tp> {}; #endif // __has_feature(is_empty) @@ -797,22 +798,18 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_empty : public __libcpp_empty<_Tp #if __has_feature(is_polymorphic) template <class _Tp> -struct _LIBCPP_VISIBLE is_polymorphic +struct _LIBCPP_TYPE_VIS is_polymorphic : public integral_constant<bool, __is_polymorphic(_Tp)> {}; #else -template <class _Tp> struct __is_polymorphic1 : public _Tp {}; -template <class _Tp> struct __is_polymorphic2 : public _Tp {virtual ~__is_polymorphic2() throw();}; +template<typename _Tp> char &__is_polymorphic_impl( + typename enable_if<sizeof((_Tp*)dynamic_cast<const volatile void*>(declval<_Tp*>())) != 0, + int>::type); +template<typename _Tp> __two &__is_polymorphic_impl(...); -template <class _Tp, bool = is_class<_Tp>::value> -struct __libcpp_polymorphic - : public integral_constant<bool, sizeof(__is_polymorphic1<_Tp>) == sizeof(__is_polymorphic2<_Tp>)> {}; - -template <class _Tp> struct __libcpp_polymorphic<_Tp, false> : public false_type {}; - -template <class _Tp> struct _LIBCPP_VISIBLE is_polymorphic - : public __libcpp_polymorphic<_Tp> {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS is_polymorphic + : public integral_constant<bool, sizeof(__is_polymorphic_impl<_Tp>(0)) == 1> {}; #endif // __has_feature(is_polymorphic) @@ -820,22 +817,20 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_polymorphic #if __has_feature(has_virtual_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template <class _Tp> struct _LIBCPP_VISIBLE has_virtual_destructor +template <class _Tp> struct _LIBCPP_TYPE_VIS has_virtual_destructor : public integral_constant<bool, __has_virtual_destructor(_Tp)> {}; #else // _LIBCPP_HAS_TYPE_TRAITS -template <class _Tp> struct _LIBCPP_VISIBLE has_virtual_destructor +template <class _Tp> struct _LIBCPP_TYPE_VIS has_virtual_destructor : public false_type {}; #endif // _LIBCPP_HAS_TYPE_TRAITS // alignment_of -template <class _Tp> struct __alignment_of {_Tp __lx;}; - -template <class _Tp> struct _LIBCPP_VISIBLE alignment_of - : public integral_constant<size_t, __alignof__(__alignment_of<typename remove_all_extents<_Tp>::type>)> {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS alignment_of + : public integral_constant<size_t, __alignof__(_Tp)> {}; // aligned_storage @@ -922,7 +917,7 @@ struct __find_max_align<__type_list<_Hp, _Tp>, _Len> : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {}; template <size_t _Len, const size_t _Align = __find_max_align<__all_types, _Len>::value> -struct _LIBCPP_VISIBLE aligned_storage +struct _LIBCPP_TYPE_VIS aligned_storage { typedef typename __find_pod<__all_types, _Align>::type _Aligner; static_assert(!is_void<_Aligner>::value, ""); @@ -935,7 +930,7 @@ struct _LIBCPP_VISIBLE aligned_storage #define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \ template <size_t _Len>\ -struct _LIBCPP_VISIBLE aligned_storage<_Len, n>\ +struct _LIBCPP_TYPE_VIS aligned_storage<_Len, n>\ {\ struct _ALIGNAS(n) type\ {\ @@ -964,6 +959,38 @@ _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4000); #undef _CREATE_ALIGNED_STORAGE_SPECIALIZATION +#ifndef _LIBCPP_HAS_NO_VARIADICS + +// aligned_union + +template <size_t _I0, size_t ..._In> +struct __static_max; + +template <size_t _I0> +struct __static_max<_I0> +{ + static const size_t value = _I0; +}; + +template <size_t _I0, size_t _I1, size_t ..._In> +struct __static_max<_I0, _I1, _In...> +{ + static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value : + __static_max<_I1, _In...>::value; +}; + +template <size_t _Len, class _Type0, class ..._Types> +struct aligned_union +{ + static const size_t alignment_value = __static_max<__alignof__(_Type0), + __alignof__(_Types)...>::value; + static const size_t __len = __static_max<_Len, sizeof(_Type0), + sizeof(_Types)...>::value; + typedef typename aligned_storage<__len, alignment_value>::type type; +}; + +#endif // _LIBCPP_HAS_NO_VARIADICS + // __promote template <class _A1, class _A2 = void, class _A3 = void, @@ -1118,7 +1145,7 @@ template <> struct __make_signed< signed long long, true> {typedef long long ty template <> struct __make_signed<unsigned long long, true> {typedef long long type;}; template <class _Tp> -struct _LIBCPP_VISIBLE make_signed +struct _LIBCPP_TYPE_VIS make_signed { typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type; }; @@ -1143,7 +1170,7 @@ template <> struct __make_unsigned< signed long long, true> {typedef unsigned l template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;}; template <class _Tp> -struct _LIBCPP_VISIBLE make_unsigned +struct _LIBCPP_TYPE_VIS make_unsigned { typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type; }; @@ -1151,21 +1178,21 @@ struct _LIBCPP_VISIBLE make_unsigned #ifdef _LIBCPP_HAS_NO_VARIADICS template <class _Tp, class _Up = void, class V = void> -struct _LIBCPP_VISIBLE common_type +struct _LIBCPP_TYPE_VIS common_type { public: typedef typename common_type<typename common_type<_Tp, _Up>::type, V>::type type; }; template <class _Tp> -struct _LIBCPP_VISIBLE common_type<_Tp, void, void> +struct _LIBCPP_TYPE_VIS common_type<_Tp, void, void> { public: typedef _Tp type; }; template <class _Tp, class _Up> -struct _LIBCPP_VISIBLE common_type<_Tp, _Up, void> +struct _LIBCPP_TYPE_VIS common_type<_Tp, _Up, void> { private: #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -1184,13 +1211,13 @@ public: template <class ..._Tp> struct common_type; template <class _Tp> -struct _LIBCPP_VISIBLE common_type<_Tp> +struct _LIBCPP_TYPE_VIS common_type<_Tp> { typedef _Tp type; }; template <class _Tp, class _Up> -struct _LIBCPP_VISIBLE common_type<_Tp, _Up> +struct _LIBCPP_TYPE_VIS common_type<_Tp, _Up> { private: static _Tp&& __t(); @@ -1201,7 +1228,7 @@ public: }; template <class _Tp, class _Up, class ..._Vp> -struct _LIBCPP_VISIBLE common_type<_Tp, _Up, _Vp...> +struct _LIBCPP_TYPE_VIS common_type<_Tp, _Up, _Vp...> { typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type; }; @@ -1245,13 +1272,13 @@ struct is_assignable // is_copy_assignable -template <class _Tp> struct _LIBCPP_VISIBLE is_copy_assignable +template <class _Tp> struct _LIBCPP_TYPE_VIS is_copy_assignable : public is_assignable<typename add_lvalue_reference<_Tp>::type, const typename add_lvalue_reference<_Tp>::type> {}; // is_move_assignable -template <class _Tp> struct _LIBCPP_VISIBLE is_move_assignable +template <class _Tp> struct _LIBCPP_TYPE_VIS is_move_assignable #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES : public is_assignable<typename add_lvalue_reference<_Tp>::type, const typename add_rvalue_reference<_Tp>::type> {}; @@ -1366,7 +1393,7 @@ public: #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES template <class _Tp> -struct _LIBCPP_VISIBLE decay +struct _LIBCPP_TYPE_VIS decay { private: typedef typename remove_reference<_Tp>::type _Up; @@ -1745,7 +1772,7 @@ class __result_of<_Fn(_Tp, _A0, _A1, _A2), false, true> // _Fn must be member p // result_of template <class _Fn> -class _LIBCPP_VISIBLE result_of<_Fn()> +class _LIBCPP_TYPE_VIS result_of<_Fn()> : public __result_of<_Fn(), is_class<typename remove_reference<_Fn>::type>::value || is_function<typename remove_reference<_Fn>::type>::value, @@ -1755,7 +1782,7 @@ class _LIBCPP_VISIBLE result_of<_Fn()> }; template <class _Fn, class _A0> -class _LIBCPP_VISIBLE result_of<_Fn(_A0)> +class _LIBCPP_TYPE_VIS 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, @@ -1765,7 +1792,7 @@ class _LIBCPP_VISIBLE result_of<_Fn(_A0)> }; template <class _Fn, class _A0, class _A1> -class _LIBCPP_VISIBLE result_of<_Fn(_A0, _A1)> +class _LIBCPP_TYPE_VIS 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, @@ -1775,7 +1802,7 @@ class _LIBCPP_VISIBLE result_of<_Fn(_A0, _A1)> }; template <class _Fn, class _A0, class _A1, class _A2> -class _LIBCPP_VISIBLE result_of<_Fn(_A0, _A1, _A2)> +class _LIBCPP_TYPE_VIS 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, @@ -1880,7 +1907,7 @@ struct __contains_void<_A0, _Args...> // is_constructible entry point template <class _Tp, class... _Args> -struct _LIBCPP_VISIBLE is_constructible +struct _LIBCPP_TYPE_VIS is_constructible : public __is_constructible_void_check<__contains_void<_Tp, _Args...>::value || is_abstract<_Tp>::value, _Tp, _Args...> @@ -2028,7 +2055,7 @@ struct __nat {}; template <class _Tp, class _A0 = __is_construct::__nat, class _A1 = __is_construct::__nat> -struct _LIBCPP_VISIBLE is_constructible +struct _LIBCPP_TYPE_VIS is_constructible : public __is_constructible2_void_check<is_void<_Tp>::value || is_abstract<_Tp>::value || is_function<_Tp>::value @@ -2038,7 +2065,7 @@ struct _LIBCPP_VISIBLE is_constructible {}; template <class _Tp> -struct _LIBCPP_VISIBLE is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat> +struct _LIBCPP_TYPE_VIS is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat> : public __is_constructible0_void_check<is_void<_Tp>::value || is_abstract<_Tp>::value || is_function<_Tp>::value, @@ -2046,7 +2073,7 @@ struct _LIBCPP_VISIBLE is_constructible<_Tp, __is_construct::__nat, __is_constru {}; template <class _Tp, class _A0> -struct _LIBCPP_VISIBLE is_constructible<_Tp, _A0, __is_construct::__nat> +struct _LIBCPP_TYPE_VIS is_constructible<_Tp, _A0, __is_construct::__nat> : public __is_constructible1_void_check<is_void<_Tp>::value || is_abstract<_Tp>::value || is_function<_Tp>::value @@ -2094,21 +2121,21 @@ struct __is_constructible2_imp<false, _Ap[], _A0, _A1> // is_default_constructible template <class _Tp> -struct _LIBCPP_VISIBLE is_default_constructible +struct _LIBCPP_TYPE_VIS is_default_constructible : public is_constructible<_Tp> {}; // is_copy_constructible template <class _Tp> -struct _LIBCPP_VISIBLE is_copy_constructible +struct _LIBCPP_TYPE_VIS is_copy_constructible : public is_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type> {}; // is_move_constructible template <class _Tp> -struct _LIBCPP_VISIBLE is_move_constructible +struct _LIBCPP_TYPE_VIS is_move_constructible #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES : public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type> #else @@ -2123,7 +2150,7 @@ struct _LIBCPP_VISIBLE is_move_constructible #if __has_feature(is_trivially_constructible) template <class _Tp, class... _Args> -struct _LIBCPP_VISIBLE is_trivially_constructible +struct _LIBCPP_TYPE_VIS is_trivially_constructible : integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)> { }; @@ -2131,13 +2158,13 @@ struct _LIBCPP_VISIBLE is_trivially_constructible #else // !__has_feature(is_trivially_constructible) template <class _Tp, class... _Args> -struct _LIBCPP_VISIBLE is_trivially_constructible +struct _LIBCPP_TYPE_VIS is_trivially_constructible : false_type { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp> +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp> #if __has_feature(has_trivial_constructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_trivial_constructor(_Tp)> #else @@ -2148,22 +2175,22 @@ struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp> template <class _Tp> #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&&> +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&&> #else -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp> +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp> #endif : integral_constant<bool, is_scalar<_Tp>::value> { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&> +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, const _Tp&> : integral_constant<bool, is_scalar<_Tp>::value> { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&> +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&> : integral_constant<bool, is_scalar<_Tp>::value> { }; @@ -2174,7 +2201,7 @@ struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&> template <class _Tp, class _A0 = __is_construct::__nat, class _A1 = __is_construct::__nat> -struct _LIBCPP_VISIBLE is_trivially_constructible +struct _LIBCPP_TYPE_VIS is_trivially_constructible : false_type { }; @@ -2182,28 +2209,28 @@ struct _LIBCPP_VISIBLE is_trivially_constructible #if __has_feature(is_trivially_constructible) template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, __is_construct::__nat, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, __is_construct::__nat, __is_construct::__nat> : integral_constant<bool, __is_trivially_constructible(_Tp)> { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp, __is_construct::__nat> : integral_constant<bool, __is_trivially_constructible(_Tp, _Tp)> { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, const _Tp&, __is_construct::__nat> : integral_constant<bool, __is_trivially_constructible(_Tp, const _Tp&)> { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&, __is_construct::__nat> : integral_constant<bool, __is_trivially_constructible(_Tp, _Tp&)> { @@ -2212,28 +2239,28 @@ struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&, #else // !__has_feature(is_trivially_constructible) template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, __is_construct::__nat, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, __is_construct::__nat, __is_construct::__nat> : integral_constant<bool, is_scalar<_Tp>::value> { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp, __is_construct::__nat> : integral_constant<bool, is_scalar<_Tp>::value> { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, const _Tp&, __is_construct::__nat> : integral_constant<bool, is_scalar<_Tp>::value> { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&, __is_construct::__nat> : integral_constant<bool, is_scalar<_Tp>::value> { @@ -2245,19 +2272,19 @@ struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&, // is_trivially_default_constructible -template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_default_constructible +template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_default_constructible : public is_trivially_constructible<_Tp> {}; // is_trivially_copy_constructible -template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_copy_constructible +template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_copy_constructible : public is_trivially_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type> {}; // is_trivially_move_constructible -template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_move_constructible +template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_move_constructible #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES : public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type> #else @@ -2305,14 +2332,14 @@ struct is_trivially_assignable<_Tp&, _Tp&&> // is_trivially_copy_assignable -template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_copy_assignable +template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_copy_assignable : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type, const typename add_lvalue_reference<_Tp>::type> {}; // is_trivially_move_assignable -template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_move_assignable +template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_move_assignable : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type, #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES typename add_rvalue_reference<_Tp>::type> @@ -2325,7 +2352,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_move_assignable #if __has_feature(has_trivial_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_destructible +template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_destructible : public integral_constant<bool, __has_trivial_destructor(_Tp)> {}; #else // _LIBCPP_HAS_TYPE_TRAITS @@ -2334,7 +2361,7 @@ template <class _Tp> struct __libcpp_trivial_destructor : public integral_constant<bool, is_scalar<_Tp>::value || is_reference<_Tp>::value> {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_destructible +template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_destructible : public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {}; #endif // _LIBCPP_HAS_TYPE_TRAITS @@ -2360,13 +2387,13 @@ struct __is_nothrow_constructible<false, _Tp, _Args...> }; template <class _Tp, class... _Args> -struct _LIBCPP_VISIBLE is_nothrow_constructible +struct _LIBCPP_TYPE_VIS is_nothrow_constructible : __is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, _Tp, _Args...> { }; template <class _Tp, size_t _Ns> -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp[_Ns]> +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp[_Ns]> : __is_nothrow_constructible<is_constructible<_Tp>::value, _Tp> { }; @@ -2374,13 +2401,13 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp[_Ns]> #else // __has_feature(cxx_noexcept) template <class _Tp, class... _Args> -struct _LIBCPP_VISIBLE is_nothrow_constructible +struct _LIBCPP_TYPE_VIS is_nothrow_constructible : false_type { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp> +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp> #if __has_feature(has_nothrow_constructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_constructor(_Tp)> #else @@ -2391,9 +2418,9 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp> template <class _Tp> #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&&> +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp&&> #else -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp> +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp> #endif #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_copy(_Tp)> @@ -2404,7 +2431,7 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp> }; template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&> +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, const _Tp&> #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_copy(_Tp)> #else @@ -2414,7 +2441,7 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&> }; template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&> +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp&> #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_copy(_Tp)> #else @@ -2429,13 +2456,13 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&> template <class _Tp, class _A0 = __is_construct::__nat, class _A1 = __is_construct::__nat> -struct _LIBCPP_VISIBLE is_nothrow_constructible +struct _LIBCPP_TYPE_VIS is_nothrow_constructible : false_type { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, __is_construct::__nat, +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, __is_construct::__nat, __is_construct::__nat> #if __has_feature(has_nothrow_constructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_constructor(_Tp)> @@ -2446,7 +2473,7 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, __is_construct::__nat, }; template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp, +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp, __is_construct::__nat> #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_copy(_Tp)> @@ -2457,7 +2484,7 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp, }; template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&, +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, const _Tp&, __is_construct::__nat> #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_copy(_Tp)> @@ -2468,7 +2495,7 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&, }; template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&, +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp, _Tp&, __is_construct::__nat> #if __has_feature(has_nothrow_copy) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_copy(_Tp)> @@ -2482,19 +2509,19 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&, // is_nothrow_default_constructible -template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_default_constructible +template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_default_constructible : public is_nothrow_constructible<_Tp> {}; // is_nothrow_copy_constructible -template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_copy_constructible +template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_copy_constructible : public is_nothrow_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type> {}; // is_nothrow_move_constructible -template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_move_constructible +template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_move_constructible #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES : public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type> #else @@ -2521,7 +2548,7 @@ struct __is_nothrow_assignable<true, _Tp, _Arg> }; template <class _Tp, class _Arg> -struct _LIBCPP_VISIBLE is_nothrow_assignable +struct _LIBCPP_TYPE_VIS is_nothrow_assignable : public __is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg> { }; @@ -2529,11 +2556,11 @@ struct _LIBCPP_VISIBLE is_nothrow_assignable #else // __has_feature(cxx_noexcept) template <class _Tp, class _Arg> -struct _LIBCPP_VISIBLE is_nothrow_assignable +struct _LIBCPP_TYPE_VIS is_nothrow_assignable : public false_type {}; template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_assignable<_Tp&, _Tp> +struct _LIBCPP_TYPE_VIS is_nothrow_assignable<_Tp&, _Tp> #if __has_feature(has_nothrow_assign) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_assign(_Tp)> {}; #else @@ -2541,7 +2568,7 @@ struct _LIBCPP_VISIBLE is_nothrow_assignable<_Tp&, _Tp> #endif template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_assignable<_Tp&, _Tp&> +struct _LIBCPP_TYPE_VIS is_nothrow_assignable<_Tp&, _Tp&> #if __has_feature(has_nothrow_assign) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_assign(_Tp)> {}; #else @@ -2549,7 +2576,7 @@ struct _LIBCPP_VISIBLE is_nothrow_assignable<_Tp&, _Tp&> #endif template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_assignable<_Tp&, const _Tp&> +struct _LIBCPP_TYPE_VIS is_nothrow_assignable<_Tp&, const _Tp&> #if __has_feature(has_nothrow_assign) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) : integral_constant<bool, __has_nothrow_assign(_Tp)> {}; #else @@ -2572,14 +2599,14 @@ struct is_nothrow_assignable<_Tp&, _Tp&&> // is_nothrow_copy_assignable -template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_copy_assignable +template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_copy_assignable : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type, const typename add_lvalue_reference<_Tp>::type> {}; // is_nothrow_move_assignable -template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_move_assignable +template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_move_assignable : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type, #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES typename add_rvalue_reference<_Tp>::type> @@ -2607,19 +2634,19 @@ struct __is_nothrow_destructible<true, _Tp> }; template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_destructible +struct _LIBCPP_TYPE_VIS is_nothrow_destructible : public __is_nothrow_destructible<is_destructible<_Tp>::value, _Tp> { }; template <class _Tp, size_t _Ns> -struct _LIBCPP_VISIBLE is_nothrow_destructible<_Tp[_Ns]> +struct _LIBCPP_TYPE_VIS is_nothrow_destructible<_Tp[_Ns]> : public is_nothrow_destructible<_Tp> { }; template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_destructible<_Tp&> +struct _LIBCPP_TYPE_VIS is_nothrow_destructible<_Tp&> : public true_type { }; @@ -2627,7 +2654,7 @@ struct _LIBCPP_VISIBLE is_nothrow_destructible<_Tp&> #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template <class _Tp> -struct _LIBCPP_VISIBLE is_nothrow_destructible<_Tp&&> +struct _LIBCPP_TYPE_VIS is_nothrow_destructible<_Tp&&> : public true_type { }; @@ -2640,7 +2667,7 @@ template <class _Tp> struct __libcpp_nothrow_destructor : public integral_constant<bool, is_scalar<_Tp>::value || is_reference<_Tp>::value> {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_destructible +template <class _Tp> struct _LIBCPP_TYPE_VIS is_nothrow_destructible : public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {}; #endif @@ -2649,12 +2676,12 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_destructible #if __has_feature(is_pod) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template <class _Tp> struct _LIBCPP_VISIBLE is_pod +template <class _Tp> struct _LIBCPP_TYPE_VIS is_pod : public integral_constant<bool, __is_pod(_Tp)> {}; #else // _LIBCPP_HAS_TYPE_TRAITS -template <class _Tp> struct _LIBCPP_VISIBLE is_pod +template <class _Tp> struct _LIBCPP_TYPE_VIS is_pod : public integral_constant<bool, is_trivially_default_constructible<_Tp>::value && is_trivially_copy_constructible<_Tp>::value && is_trivially_copy_assignable<_Tp>::value && @@ -2664,7 +2691,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_pod // is_literal_type; -template <class _Tp> struct _LIBCPP_VISIBLE is_literal_type +template <class _Tp> struct _LIBCPP_TYPE_VIS is_literal_type #if __has_feature(is_literal) : public integral_constant<bool, __is_literal(_Tp)> #else @@ -2675,7 +2702,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_literal_type // is_standard_layout; -template <class _Tp> struct _LIBCPP_VISIBLE is_standard_layout +template <class _Tp> struct _LIBCPP_TYPE_VIS is_standard_layout #if __has_feature(is_standard_layout) : public integral_constant<bool, __is_standard_layout(_Tp)> #else @@ -2685,7 +2712,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_standard_layout // is_trivially_copyable; -template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_copyable +template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivially_copyable #if __has_feature(is_trivially_copyable) : public integral_constant<bool, __is_trivially_copyable(_Tp)> #else @@ -2695,7 +2722,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_copyable // is_trivial; -template <class _Tp> struct _LIBCPP_VISIBLE is_trivial +template <class _Tp> struct _LIBCPP_TYPE_VIS is_trivial #if __has_feature(is_trivial) : public integral_constant<bool, __is_trivial(_Tp)> #else @@ -2924,7 +2951,7 @@ struct __invoke_of }; template <class _Fp, class ..._Args> -class _LIBCPP_VISIBLE result_of<_Fp(_Args...)> +class _LIBCPP_TYPE_VIS result_of<_Fp(_Args...)> : public __invoke_of<_Fp, _Args...> { }; diff --git a/contrib/libc++/include/typeindex b/contrib/libc++/include/typeindex index 398b528..67462b7 100644 --- a/contrib/libc++/include/typeindex +++ b/contrib/libc++/include/typeindex @@ -55,7 +55,7 @@ struct hash<type_index> _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE type_index +class _LIBCPP_TYPE_VIS type_index { const type_info* __t_; public: @@ -87,10 +87,10 @@ public: const char* name() const _NOEXCEPT {return __t_->name();} }; -template <class _Tp> struct _LIBCPP_VISIBLE hash; +template <class _Tp> struct _LIBCPP_TYPE_VIS hash; template <> -struct _LIBCPP_VISIBLE hash<type_index> +struct _LIBCPP_TYPE_VIS hash<type_index> : public unary_function<type_index, size_t> { _LIBCPP_INLINE_VISIBILITY diff --git a/contrib/libc++/include/unordered_map b/contrib/libc++/include/unordered_map index cb2ab42..235b2ea 100644 --- a/contrib/libc++/include/unordered_map +++ b/contrib/libc++/include/unordered_map @@ -544,7 +544,7 @@ public: }; template <class _HashIterator> -class _LIBCPP_VISIBLE __hash_map_iterator +class _LIBCPP_TYPE_VIS __hash_map_iterator { _HashIterator __i_; @@ -592,15 +592,15 @@ public: bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y) {return __x.__i_ != __y.__i_;} - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_map; - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap; - template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator; - template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator; - template <class> friend class _LIBCPP_VISIBLE __hash_map_const_iterator; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_map; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_multimap; + template <class> friend class _LIBCPP_TYPE_VIS __hash_const_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator; }; template <class _HashIterator> -class _LIBCPP_VISIBLE __hash_map_const_iterator +class _LIBCPP_TYPE_VIS __hash_map_const_iterator { _HashIterator __i_; @@ -653,15 +653,15 @@ public: bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) {return __x.__i_ != __y.__i_;} - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_map; - template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap; - template <class> friend class _LIBCPP_VISIBLE __hash_const_iterator; - template <class> friend class _LIBCPP_VISIBLE __hash_const_local_iterator; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_map; + template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS unordered_multimap; + template <class> friend class _LIBCPP_TYPE_VIS __hash_const_iterator; + template <class> friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator; }; template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>, class _Alloc = allocator<pair<const _Key, _Tp> > > -class _LIBCPP_VISIBLE unordered_map +class _LIBCPP_TYPE_VIS unordered_map { public: // types @@ -1294,7 +1294,7 @@ operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>, class _Alloc = allocator<pair<const _Key, _Tp> > > -class _LIBCPP_VISIBLE unordered_multimap +class _LIBCPP_TYPE_VIS unordered_multimap { public: // types diff --git a/contrib/libc++/include/unordered_set b/contrib/libc++/include/unordered_set index 279e907..119251d 100644 --- a/contrib/libc++/include/unordered_set +++ b/contrib/libc++/include/unordered_set @@ -313,7 +313,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> > -class _LIBCPP_VISIBLE unordered_set +class _LIBCPP_TYPE_VIS unordered_set { public: // types @@ -725,7 +725,7 @@ operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> > -class _LIBCPP_VISIBLE unordered_multiset +class _LIBCPP_TYPE_VIS unordered_multiset { public: // types diff --git a/contrib/libc++/include/utility b/contrib/libc++/include/utility index 514ce17..2df4b36 100644 --- a/contrib/libc++/include/utility +++ b/contrib/libc++/include/utility @@ -205,7 +205,7 @@ move_if_noexcept(_Tp& __x) _NOEXCEPT return _VSTD::move(__x); } -struct _LIBCPP_VISIBLE piecewise_construct_t { }; +struct _LIBCPP_TYPE_VIS piecewise_construct_t { }; #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_UTILITY) extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t(); #else @@ -213,7 +213,7 @@ constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); #endif template <class _T1, class _T2> -struct _LIBCPP_VISIBLE pair +struct _LIBCPP_TYPE_VIS pair { typedef _T1 first_type; typedef _T2 second_type; @@ -419,7 +419,7 @@ swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template <class _Tp> class _LIBCPP_VISIBLE reference_wrapper; +template <class _Tp> class _LIBCPP_TYPE_VIS reference_wrapper; template <class _Tp> struct ___make_pair_return @@ -461,36 +461,36 @@ make_pair(_T1 __x, _T2 __y) #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES template <class _T1, class _T2> - class _LIBCPP_VISIBLE tuple_size<pair<_T1, _T2> > + class _LIBCPP_TYPE_VIS tuple_size<pair<_T1, _T2> > : public integral_constant<size_t, 2> {}; template <class _T1, class _T2> - class _LIBCPP_VISIBLE tuple_size<const pair<_T1, _T2> > + class _LIBCPP_TYPE_VIS tuple_size<const pair<_T1, _T2> > : public integral_constant<size_t, 2> {}; template <class _T1, class _T2> -class _LIBCPP_VISIBLE tuple_element<0, pair<_T1, _T2> > +class _LIBCPP_TYPE_VIS tuple_element<0, pair<_T1, _T2> > { public: typedef _T1 type; }; template <class _T1, class _T2> -class _LIBCPP_VISIBLE tuple_element<1, pair<_T1, _T2> > +class _LIBCPP_TYPE_VIS tuple_element<1, pair<_T1, _T2> > { public: typedef _T2 type; }; template <class _T1, class _T2> -class _LIBCPP_VISIBLE tuple_element<0, const pair<_T1, _T2> > +class _LIBCPP_TYPE_VIS tuple_element<0, const pair<_T1, _T2> > { public: typedef const _T1 type; }; template <class _T1, class _T2> -class _LIBCPP_VISIBLE tuple_element<1, const pair<_T1, _T2> > +class _LIBCPP_TYPE_VIS tuple_element<1, const pair<_T1, _T2> > { public: typedef const _T2 type; diff --git a/contrib/libc++/include/valarray b/contrib/libc++/include/valarray index c56dd12..71c8a74 100644 --- a/contrib/libc++/include/valarray +++ b/contrib/libc++/include/valarray @@ -354,9 +354,9 @@ template <class T> unspecified2 end(const valarray<T>& v); _LIBCPP_BEGIN_NAMESPACE_STD -template<class _Tp> class _LIBCPP_VISIBLE valarray; +template<class _Tp> class _LIBCPP_TYPE_VIS valarray; -class _LIBCPP_VISIBLE slice +class _LIBCPP_TYPE_VIS slice { size_t __start_; size_t __size_; @@ -381,11 +381,11 @@ public: _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;} }; -template <class _Tp> class _LIBCPP_VISIBLE slice_array; -class _LIBCPP_VISIBLE gslice; -template <class _Tp> class _LIBCPP_VISIBLE gslice_array; -template <class _Tp> class _LIBCPP_VISIBLE mask_array; -template <class _Tp> class _LIBCPP_VISIBLE indirect_array; +template <class _Tp> class _LIBCPP_TYPE_VIS slice_array; +class _LIBCPP_TYPE_VIS gslice; +template <class _Tp> class _LIBCPP_TYPE_VIS gslice_array; +template <class _Tp> class _LIBCPP_TYPE_VIS mask_array; +template <class _Tp> class _LIBCPP_TYPE_VIS indirect_array; template <class _Tp> _LIBCPP_INLINE_VISIBILITY @@ -671,7 +671,7 @@ public: _LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;} - template <class> friend class _LIBCPP_VISIBLE valarray; + template <class> friend class _LIBCPP_TYPE_VIS valarray; }; template <class _ValExpr> @@ -786,7 +786,7 @@ template<class _Tp> struct __is_val_expr<valarray<_Tp> > : true_type {}; template<class _Tp> -class _LIBCPP_VISIBLE valarray +class _LIBCPP_TYPE_VIS valarray { public: typedef _Tp value_type; @@ -976,12 +976,12 @@ public: void resize(size_t __n, value_type __x = value_type()); private: - template <class> friend class _LIBCPP_VISIBLE valarray; - template <class> friend class _LIBCPP_VISIBLE slice_array; - template <class> friend class _LIBCPP_VISIBLE gslice_array; - template <class> friend class _LIBCPP_VISIBLE mask_array; + template <class> friend class _LIBCPP_TYPE_VIS valarray; + template <class> friend class _LIBCPP_TYPE_VIS slice_array; + template <class> friend class _LIBCPP_TYPE_VIS gslice_array; + template <class> friend class _LIBCPP_TYPE_VIS mask_array; template <class> friend class __mask_expr; - template <class> friend class _LIBCPP_VISIBLE indirect_array; + template <class> friend class _LIBCPP_TYPE_VIS indirect_array; template <class> friend class __indirect_expr; template <class> friend class __val_expr; @@ -1091,7 +1091,7 @@ struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > // slice_array template <class _Tp> -class _LIBCPP_VISIBLE slice_array +class _LIBCPP_TYPE_VIS slice_array { public: typedef _Tp value_type; @@ -1394,7 +1394,7 @@ slice_array<_Tp>::operator=(const value_type& __x) const // gslice -class _LIBCPP_VISIBLE gslice +class _LIBCPP_TYPE_VIS gslice { valarray<size_t> __size_; valarray<size_t> __stride_; @@ -1461,7 +1461,7 @@ private: // gslice_array template <class _Tp> -class _LIBCPP_VISIBLE gslice_array +class _LIBCPP_TYPE_VIS gslice_array { public: typedef _Tp value_type; @@ -1790,7 +1790,7 @@ gslice_array<_Tp>::operator=(const value_type& __x) const // mask_array template <class _Tp> -class _LIBCPP_VISIBLE mask_array +class _LIBCPP_TYPE_VIS mask_array { public: typedef _Tp value_type; @@ -2134,7 +2134,7 @@ public: // indirect_array template <class _Tp> -class _LIBCPP_VISIBLE indirect_array +class _LIBCPP_TYPE_VIS indirect_array { public: typedef _Tp value_type; @@ -2485,7 +2485,7 @@ public: _LIBCPP_INLINE_VISIBILITY size_t size() const {return __1d_.size();} - template <class> friend class _LIBCPP_VISIBLE valarray; + template <class> friend class _LIBCPP_TYPE_VIS valarray; }; template<class _ValExpr> diff --git a/contrib/libc++/include/vector b/contrib/libc++/include/vector index 876b7e5..e04c267 100644 --- a/contrib/libc++/include/vector +++ b/contrib/libc++/include/vector @@ -481,7 +481,7 @@ __vector_base<_Tp, _Allocator>::~__vector_base() } template <class _Tp, class _Allocator = allocator<_Tp> > -class _LIBCPP_VISIBLE vector +class _LIBCPP_TYPE_VIS vector : private __vector_base<_Tp, _Allocator> { private: @@ -502,6 +502,9 @@ public: typedef _VSTD::reverse_iterator<iterator> reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; + static_assert((is_same<typename allocator_type::value_type, value_type>::value), + "Allocator::value_type must be same type as value_type"); + _LIBCPP_INLINE_VISIBILITY vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) @@ -523,17 +526,29 @@ public: template <class _InputIterator> vector(_InputIterator __first, _InputIterator __last, typename enable_if<__is_input_iterator <_InputIterator>::value && - !__is_forward_iterator<_InputIterator>::value>::type* = 0); + !__is_forward_iterator<_InputIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_InputIterator>::reference>::value>::type* = 0); template <class _InputIterator> vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, typename enable_if<__is_input_iterator <_InputIterator>::value && - !__is_forward_iterator<_InputIterator>::value>::type* = 0); + !__is_forward_iterator<_InputIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_InputIterator>::reference>::value>::type* = 0); template <class _ForwardIterator> vector(_ForwardIterator __first, _ForwardIterator __last, - typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0); + typename enable_if<__is_forward_iterator<_ForwardIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0); template <class _ForwardIterator> vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, - typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0); + typename enable_if<__is_forward_iterator<_ForwardIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0); #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS _LIBCPP_INLINE_VISIBILITY vector(initializer_list<value_type> __il); @@ -574,14 +589,20 @@ public: typename enable_if < __is_input_iterator <_InputIterator>::value && - !__is_forward_iterator<_InputIterator>::value, + !__is_forward_iterator<_InputIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_InputIterator>::reference>::value, void >::type assign(_InputIterator __first, _InputIterator __last); template <class _ForwardIterator> typename enable_if < - __is_forward_iterator<_ForwardIterator>::value, + __is_forward_iterator<_ForwardIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_ForwardIterator>::reference>::value, void >::type assign(_ForwardIterator __first, _ForwardIterator __last); @@ -697,14 +718,20 @@ public: typename enable_if < __is_input_iterator <_InputIterator>::value && - !__is_forward_iterator<_InputIterator>::value, + !__is_forward_iterator<_InputIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_InputIterator>::reference>::value, iterator >::type insert(const_iterator __position, _InputIterator __first, _InputIterator __last); template <class _ForwardIterator> typename enable_if < - __is_forward_iterator<_ForwardIterator>::value, + __is_forward_iterator<_ForwardIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_ForwardIterator>::reference>::value, iterator >::type insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last); @@ -1031,7 +1058,10 @@ template <class _Tp, class _Allocator> template <class _InputIterator> vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, typename enable_if<__is_input_iterator <_InputIterator>::value && - !__is_forward_iterator<_InputIterator>::value>::type*) + !__is_forward_iterator<_InputIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_InputIterator>::reference>::value>::type*) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1044,7 +1074,10 @@ template <class _Tp, class _Allocator> template <class _InputIterator> vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, typename enable_if<__is_input_iterator <_InputIterator>::value && - !__is_forward_iterator<_InputIterator>::value>::type*) + !__is_forward_iterator<_InputIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_InputIterator>::reference>::value>::type*) : __base(__a) { #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -1057,7 +1090,10 @@ vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, c template <class _Tp, class _Allocator> template <class _ForwardIterator> vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, - typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*) + typename enable_if<__is_forward_iterator<_ForwardIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_ForwardIterator>::reference>::value>::type*) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1073,7 +1109,10 @@ vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __las template <class _Tp, class _Allocator> template <class _ForwardIterator> vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a, - typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*) + typename enable_if<__is_forward_iterator<_ForwardIterator>::value && + is_constructible< + value_type, + typename iterator_traits<_ForwardIterator>::reference>::value>::type*) : __base(__a) { #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -1255,7 +1294,10 @@ template <class _InputIterator> typename enable_if < __is_input_iterator <_InputIterator>::value && - !__is_forward_iterator<_InputIterator>::value, + !__is_forward_iterator<_InputIterator>::value && + is_constructible< + _Tp, + typename iterator_traits<_InputIterator>::reference>::value, void >::type vector<_Tp, _Allocator>::assign(_InputIterator __first, _InputIterator __last) @@ -1269,7 +1311,10 @@ template <class _Tp, class _Allocator> template <class _ForwardIterator> typename enable_if < - __is_forward_iterator<_ForwardIterator>::value, + __is_forward_iterator<_ForwardIterator>::value && + is_constructible< + _Tp, + typename iterator_traits<_ForwardIterator>::reference>::value, void >::type vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) @@ -1550,6 +1595,8 @@ vector<_Tp, _Allocator>::erase(const_iterator __position) "vector::erase(iterator) called with an iterator not" " referring to this vector"); #endif + _LIBCPP_ASSERT(__position != end(), + "vector::erase(iterator) called with a non-dereferenceable iterator"); pointer __p = const_cast<pointer>(&*__position); iterator __r = __make_iter(__p); this->__destruct_at_end(_VSTD::move(__p + 1, this->__end_, __p)); @@ -1568,7 +1615,8 @@ vector<_Tp, _Allocator>::erase(const_iterator __first, const_iterator __last) _LIBCPP_ASSERT(__first <= __last, "vector::erase(first, last) called with invalid range"); pointer __p = this->__begin_ + (__first - begin()); iterator __r = __make_iter(__p); - this->__destruct_at_end(_VSTD::move(__p + (__last - __first), this->__end_, __p)); + if (__first != __last) + this->__destruct_at_end(_VSTD::move(__p + (__last - __first), this->__end_, __p)); return __r; } @@ -1748,7 +1796,10 @@ template <class _InputIterator> typename enable_if < __is_input_iterator <_InputIterator>::value && - !__is_forward_iterator<_InputIterator>::value, + !__is_forward_iterator<_InputIterator>::value && + is_constructible< + _Tp, + typename iterator_traits<_InputIterator>::reference>::value, typename vector<_Tp, _Allocator>::iterator >::type vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last) @@ -1800,7 +1851,10 @@ template <class _Tp, class _Allocator> template <class _ForwardIterator> typename enable_if < - __is_forward_iterator<_ForwardIterator>::value, + __is_forward_iterator<_ForwardIterator>::value && + is_constructible< + _Tp, + typename iterator_traits<_ForwardIterator>::reference>::value, typename vector<_Tp, _Allocator>::iterator >::type vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last) @@ -1963,7 +2017,7 @@ struct __has_storage_type<vector<bool, _Allocator> > }; template <class _Allocator> -class _LIBCPP_VISIBLE vector<bool, _Allocator> +class _LIBCPP_TYPE_VIS vector<bool, _Allocator> : private __vector_base_common<true> { public: @@ -2321,7 +2375,7 @@ private: friend class __bit_iterator<vector, false>; friend class __bit_iterator<vector, true>; friend struct __bit_array<vector>; - friend struct _LIBCPP_VISIBLE hash<vector>; + friend struct _LIBCPP_TYPE_VIS hash<vector>; }; template <class _Allocator> @@ -3104,7 +3158,7 @@ vector<bool, _Allocator>::__hash_code() const _NOEXCEPT } template <class _Allocator> -struct _LIBCPP_VISIBLE hash<vector<bool, _Allocator> > +struct _LIBCPP_TYPE_VIS hash<vector<bool, _Allocator> > : public unary_function<vector<bool, _Allocator>, size_t> { _LIBCPP_INLINE_VISIBILITY diff --git a/contrib/libc++/src/chrono.cpp b/contrib/libc++/src/chrono.cpp index 1ce2e28..15a6f46 100644 --- a/contrib/libc++/src/chrono.cpp +++ b/contrib/libc++/src/chrono.cpp @@ -9,7 +9,7 @@ #include "chrono" #include <sys/time.h> //for gettimeofday and timeval -#if __APPLE__ +#ifdef __APPLE__ #include <mach/mach_time.h> // mach_absolute_time, mach_timebase_info_data_t #else /* !__APPLE__ */ #include <cerrno> // errno @@ -50,7 +50,7 @@ system_clock::from_time_t(time_t t) _NOEXCEPT const bool steady_clock::is_steady; -#if __APPLE__ +#ifdef __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 diff --git a/contrib/libc++/src/debug.cpp b/contrib/libc++/src/debug.cpp index f3a0262..06040af 100644 --- a/contrib/libc++/src/debug.cpp +++ b/contrib/libc++/src/debug.cpp @@ -17,7 +17,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD -_LIBCPP_VISIBLE +_LIBCPP_FUNC_VIS __libcpp_db* __get_db() { @@ -25,7 +25,7 @@ __get_db() return &db; } -_LIBCPP_VISIBLE +_LIBCPP_FUNC_VIS const __libcpp_db* __get_const_db() { @@ -110,8 +110,7 @@ __libcpp_db::__find_c_from_i(void* __i) const { RLock _(mut()); __i_node* i = __find_iterator(__i); - _LIBCPP_ASSERT(i != nullptr, "iterator constructed in translation unit with debug mode not enabled." - " #define _LIBCPP_DEBUG2 1 for that translation unit."); + _LIBCPP_ASSERT(i != nullptr, "iterator not found in debug database."); return i->__c_ != nullptr ? i->__c_->__c_ : nullptr; } @@ -302,7 +301,7 @@ __libcpp_db::__iterator_copy(void* __i, const void* __i0) __i_node* i = __find_iterator(__i); __i_node* i0 = __find_iterator(__i0); __c_node* c0 = i0 != nullptr ? i0->__c_ : nullptr; - if (i == nullptr && c0 != nullptr) + if (i == nullptr && i0 != nullptr) i = __insert_iterator(__i); __c_node* c = i != nullptr ? i->__c_ : nullptr; if (c != c0) diff --git a/contrib/libc++/src/exception.cpp b/contrib/libc++/src/exception.cpp index 0cd182b..1d2f6b2 100644 --- a/contrib/libc++/src/exception.cpp +++ b/contrib/libc++/src/exception.cpp @@ -14,7 +14,7 @@ #define __has_include(inc) 0 #endif -#if __APPLE__ +#ifdef __APPLE__ #include <cxxabi.h> using namespace __cxxabiv1; @@ -77,6 +77,7 @@ get_terminate() _NOEXCEPT return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0); } +#ifndef EMSCRIPTEN // We provide this in JS _LIBCPP_NORETURN void terminate() _NOEXCEPT @@ -97,12 +98,13 @@ terminate() _NOEXCEPT } #endif // _LIBCPP_NO_EXCEPTIONS } +#endif // !EMSCRIPTEN #endif // !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION) -#if !defined(LIBCXXRT) && !defined(__GLIBCXX__) +#if !defined(LIBCXXRT) && !defined(__GLIBCXX__) && !defined(EMSCRIPTEN) bool uncaught_exception() _NOEXCEPT { -#if __APPLE__ || defined(_LIBCPPABI_VERSION) +#if defined(__APPLE__) || defined(_LIBCPPABI_VERSION) // on Darwin, there is a helper function so __cxa_get_globals is private return __cxa_uncaught_exception(); #else // __APPLE__ diff --git a/contrib/libc++/src/hash.cpp b/contrib/libc++/src/hash.cpp index 5587478..65a9d51 100644 --- a/contrib/libc++/src/hash.cpp +++ b/contrib/libc++/src/hash.cpp @@ -160,6 +160,8 @@ __check_for_overflow(size_t N) #ifndef _LIBCPP_NO_EXCEPTIONS if (N > 0xFFFFFFFB) throw overflow_error("__next_prime overflow"); +#else + (void)N; #endif } @@ -171,6 +173,8 @@ __check_for_overflow(size_t N) #ifndef _LIBCPP_NO_EXCEPTIONS if (N > 0xFFFFFFFFFFFFFFC5ull) throw overflow_error("__next_prime overflow"); +#else + (void)N; #endif } diff --git a/contrib/libc++/src/iostream.cpp b/contrib/libc++/src/iostream.cpp index f5b959b..7fc71df 100644 --- a/contrib/libc++/src/iostream.cpp +++ b/contrib/libc++/src/iostream.cpp @@ -13,6 +13,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD +static mbstate_t state_types[6] = {}; + _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>)]; @@ -33,17 +35,17 @@ ios_base::Init __start_std_streams; ios_base::Init::Init() { - istream* cin_ptr = ::new(cin) istream(::new(__cin) __stdinbuf <char>(stdin) ); - ostream* cout_ptr = ::new(cout) ostream(::new(__cout) __stdoutbuf<char>(stdout)); - ostream* cerr_ptr = ::new(cerr) ostream(::new(__cerr) __stdoutbuf<char>(stderr)); + 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)); ::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) ); - wostream* wcout_ptr = ::new(wcout) wostream(::new(__wcout) __stdoutbuf<wchar_t>(stdout)); - wostream* wcerr_ptr = ::new(wcerr) wostream(::new(__wcerr) __stdoutbuf<wchar_t>(stderr)); + 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)); ::new(wclog) wostream(wcerr_ptr->rdbuf()); wcin_ptr->tie(wcout_ptr); _VSTD::unitbuf(*wcerr_ptr); diff --git a/contrib/libc++/src/locale.cpp b/contrib/libc++/src/locale.cpp index 53a8a4c..49c1cf2 100644 --- a/contrib/libc++/src/locale.cpp +++ b/contrib/libc++/src/locale.cpp @@ -25,13 +25,17 @@ #include "cstring" #include "cwctype" #include "__sso_allocator" -#if _WIN32 +#ifdef _WIN32 #include <support/win32/locale_win32.h> #else // _WIN32 #include <langinfo.h> #endif // _!WIN32 #include <stdlib.h> +// On Linux, wint_t and wchar_t have different signed-ness, and this causes +// lots of noise in the build log, but no bugs that I know of. +#pragma clang diagnostic ignored "-Wsign-conversion" + _LIBCPP_BEGIN_NAMESPACE_STD #ifdef __cloc_defined @@ -782,7 +786,7 @@ ctype<wchar_t>::do_toupper(char_type c) const { #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c; -#elif defined(__GLIBC__) +#elif defined(__GLIBC__) || defined(EMSCRIPTEN) return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c; #else return (isascii(c) && iswlower_l(c, __cloc())) ? c-L'a'+L'A' : c; @@ -795,7 +799,7 @@ ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const for (; low != high; ++low) #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low; -#elif defined(__GLIBC__) +#elif defined(__GLIBC__) || defined(EMSCRIPTEN) *low = isascii(*low) ? ctype<char>::__classic_upper_table()[*low] : *low; #else @@ -809,7 +813,7 @@ ctype<wchar_t>::do_tolower(char_type c) const { #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c; -#elif defined(__GLIBC__) +#elif defined(__GLIBC__) || defined(EMSCRIPTEN) return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c; #else return (isascii(c) && isupper_l(c, __cloc())) ? c-L'A'+'a' : c; @@ -822,7 +826,7 @@ ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const for (; low != high; ++low) #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low; -#elif defined(__GLIBC__) +#elif defined(__GLIBC__) || defined(EMSCRIPTEN) *low = isascii(*low) ? ctype<char>::__classic_lower_table()[*low] : *low; #else @@ -889,8 +893,9 @@ ctype<char>::do_toupper(char_type c) const #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE return isascii(c) ? static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(c)]) : c; -#elif defined(__GLIBC__) - return isascii(c) ? __classic_upper_table()[static_cast<size_t>(c)] : c; +#elif defined(__GLIBC__) || defined(EMSCRIPTEN) + return isascii(c) ? + static_cast<char>(__classic_upper_table()[static_cast<size_t>(c)]) : c; #else return (isascii(c) && islower_l(c, __cloc())) ? c-'a'+'A' : c; #endif @@ -903,8 +908,9 @@ ctype<char>::do_toupper(char_type* low, const char_type* high) const #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(*low)]) : *low; -#elif defined(__GLIBC__) - *low = isascii(*low) ? __classic_upper_table()[static_cast<size_t>(*low)] : *low; +#elif defined(__GLIBC__) || defined(EMSCRIPTEN) + *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; #endif @@ -917,8 +923,9 @@ ctype<char>::do_tolower(char_type c) const #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE return isascii(c) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(c)]) : c; -#elif defined(__GLIBC__) - return isascii(c) ? __classic_lower_table()[static_cast<size_t>(c)] : c; +#elif defined(__GLIBC__) || defined(EMSCRIPTEN) + 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; #endif @@ -930,8 +937,8 @@ ctype<char>::do_tolower(char_type* low, const char_type* high) const for (; low != high; ++low) #ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(*low)]) : *low; -#elif defined(__GLIBC__) - *low = isascii(*low) ? __classic_lower_table()[static_cast<size_t>(*low)] : *low; +#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; #endif @@ -971,6 +978,12 @@ ctype<char>::do_narrow(const char_type* low, const char_type* high, char dfault, return low; } +#ifdef EMSCRIPTEN +extern "C" const unsigned short ** __ctype_b_loc(); +extern "C" const int ** __ctype_tolower_loc(); +extern "C" const int ** __ctype_toupper_loc(); +#endif + const ctype<char>::mask* ctype<char>::classic_table() _NOEXCEPT { @@ -980,10 +993,12 @@ ctype<char>::classic_table() _NOEXCEPT return __cloc()->__ctype_b; #elif __sun__ return __ctype_mask; -#elif _WIN32 +#elif defined(_WIN32) return _ctype+1; // internal ctype mask table defined in msvcrt.dll // This is assumed to be safe, which is a nonsense assumption because we're // going to end up dereferencing it later... +#elif defined(EMSCRIPTEN) + return *__ctype_b_loc(); #else // Platform not supported: abort so the person doing the port knows what to // fix @@ -1007,6 +1022,20 @@ ctype<char>::__classic_upper_table() _NOEXCEPT } #endif // __GLIBC__ +#if defined(EMSCRIPTEN) +const int* +ctype<char>::__classic_lower_table() _NOEXCEPT +{ + return *__ctype_tolower_loc(); +} + +const int* +ctype<char>::__classic_upper_table() _NOEXCEPT +{ + return *__ctype_toupper_loc(); +} +#endif // EMSCRIPTEN + // template <> class ctype_byname<char> ctype_byname<char>::ctype_byname(const char* name, size_t refs) @@ -1100,16 +1129,17 @@ ctype_byname<wchar_t>::do_is(mask m, char_type c) const return static_cast<bool>(iswctype_l(c, m, __l)); #else bool result = false; - if (m & space) result |= (iswspace_l(c, __l) != 0); - if (m & print) result |= (iswprint_l(c, __l) != 0); - if (m & cntrl) result |= (iswcntrl_l(c, __l) != 0); - if (m & upper) result |= (iswupper_l(c, __l) != 0); - if (m & lower) result |= (iswlower_l(c, __l) != 0); - if (m & alpha) result |= (iswalpha_l(c, __l) != 0); - if (m & digit) result |= (iswdigit_l(c, __l) != 0); - if (m & punct) result |= (iswpunct_l(c, __l) != 0); - if (m & xdigit) result |= (iswxdigit_l(c, __l) != 0); - if (m & blank) result |= (iswblank_l(c, __l) != 0); + 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); return result; #endif } @@ -1124,23 +1154,24 @@ ctype_byname<wchar_t>::do_is(const char_type* low, const char_type* high, mask* else { *vec = 0; - if (iswspace_l(*low, __l)) + wint_t ch = static_cast<wint_t>(*low); + if (iswspace_l(ch, __l)) *vec |= space; - if (iswprint_l(*low, __l)) + if (iswprint_l(ch, __l)) *vec |= print; - if (iswcntrl_l(*low, __l)) + if (iswcntrl_l(ch, __l)) *vec |= cntrl; - if (iswupper_l(*low, __l)) + if (iswupper_l(ch, __l)) *vec |= upper; - if (iswlower_l(*low, __l)) + if (iswlower_l(ch, __l)) *vec |= lower; - if (iswalpha_l(*low, __l)) + if (iswalpha_l(ch, __l)) *vec |= alpha; - if (iswdigit_l(*low, __l)) + if (iswdigit_l(ch, __l)) *vec |= digit; - if (iswpunct_l(*low, __l)) + if (iswpunct_l(ch, __l)) *vec |= punct; - if (iswxdigit_l(*low, __l)) + if (iswxdigit_l(ch, __l)) *vec |= xdigit; } } @@ -1156,16 +1187,17 @@ ctype_byname<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* if (iswctype_l(*low, m, __l)) break; #else - if (m & space && iswspace_l(*low, __l)) break; - if (m & print && iswprint_l(*low, __l)) break; - if (m & cntrl && iswcntrl_l(*low, __l)) break; - if (m & upper && iswupper_l(*low, __l)) break; - if (m & lower && iswlower_l(*low, __l)) break; - if (m & alpha && iswalpha_l(*low, __l)) break; - if (m & digit && iswdigit_l(*low, __l)) break; - if (m & punct && iswpunct_l(*low, __l)) break; - if (m & xdigit && iswxdigit_l(*low, __l)) break; - if (m & blank && iswblank_l(*low, __l)) break; + 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; #endif } return low; @@ -1180,16 +1212,17 @@ ctype_byname<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type if (!iswctype_l(*low, m, __l)) break; #else - if (m & space && iswspace_l(*low, __l)) continue; - if (m & print && iswprint_l(*low, __l)) continue; - if (m & cntrl && iswcntrl_l(*low, __l)) continue; - if (m & upper && iswupper_l(*low, __l)) continue; - if (m & lower && iswlower_l(*low, __l)) continue; - if (m & alpha && iswalpha_l(*low, __l)) continue; - if (m & digit && iswdigit_l(*low, __l)) continue; - if (m & punct && iswpunct_l(*low, __l)) continue; - if (m & xdigit && iswxdigit_l(*low, __l)) continue; - if (m & blank && iswblank_l(*low, __l)) continue; + 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; break; #endif } @@ -1374,7 +1407,7 @@ codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st, to_nxt = to; for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt) { - // save state in case needed to reover to_nxt on error + // save state in case it is needed to recover to_nxt on error mbstate_t save_state = st; #ifdef _LIBCPP_LOCALE__L_EXTENSIONS size_t n = wcsnrtombs_l(to, &frm_nxt, static_cast<size_t>(fend-frm), @@ -1443,7 +1476,7 @@ codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st, to_nxt = to; for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt) { - // save state in case needed to reover to_nxt on error + // save state in case it is needed to recover to_nxt on error mbstate_t save_state = st; #ifdef _LIBCPP_LOCALE__L_EXTENSIONS size_t n = mbsnrtowcs_l(to, &frm_nxt, static_cast<size_t>(fend-frm), @@ -1589,9 +1622,9 @@ int codecvt<wchar_t, char, mbstate_t>::do_max_length() const _NOEXCEPT { #ifdef _LIBCPP_LOCALE__L_EXTENSIONS - return __l == 0 ? 1 : MB_CUR_MAX_L(__l); + return __l == 0 ? 1 : static_cast<int>( MB_CUR_MAX_L(__l)); #else - return __l == 0 ? 1 : __mb_cur_max_l(__l); + return __l == 0 ? 1 : static_cast<int>(__mb_cur_max_l(__l)); #endif } @@ -5768,7 +5801,7 @@ moneypunct_byname<char, true>::init(const char* nm) __frac_digits_ = lc->int_frac_digits; else __frac_digits_ = base::do_frac_digits(); -#if _WIN32 +#ifdef _WIN32 if (lc->p_sign_posn == 0) #else // _WIN32 if (lc->int_p_sign_posn == 0) @@ -5776,7 +5809,7 @@ moneypunct_byname<char, true>::init(const char* nm) __positive_sign_ = "()"; else __positive_sign_ = lc->positive_sign; -#if _WIN32 +#ifdef _WIN32 if(lc->n_sign_posn == 0) #else // _WIN32 if (lc->int_n_sign_posn == 0) @@ -5788,7 +5821,7 @@ moneypunct_byname<char, true>::init(const char* nm) // the same places in curr_symbol since there's no way to // represent anything else. string_type __dummy_curr_symbol = __curr_symbol_; -#if _WIN32 +#ifdef _WIN32 __init_pat(__pos_format_, __dummy_curr_symbol, true, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' '); __init_pat(__neg_format_, __curr_symbol_, true, @@ -5927,7 +5960,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm) __frac_digits_ = lc->int_frac_digits; else __frac_digits_ = base::do_frac_digits(); -#if _WIN32 +#ifdef _WIN32 if (lc->p_sign_posn == 0) #else // _WIN32 if (lc->int_p_sign_posn == 0) @@ -5947,7 +5980,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm) wbe = wbuf + j; __positive_sign_.assign(wbuf, wbe); } -#if _WIN32 +#ifdef _WIN32 if (lc->n_sign_posn == 0) #else // _WIN32 if (lc->int_n_sign_posn == 0) @@ -5971,7 +6004,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm) // the same places in curr_symbol since there's no way to // represent anything else. string_type __dummy_curr_symbol = __curr_symbol_; -#if _WIN32 +#ifdef _WIN32 __init_pat(__pos_format_, __dummy_curr_symbol, true, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' '); __init_pat(__neg_format_, __curr_symbol_, true, @@ -5992,6 +6025,8 @@ void __throw_runtime_error(const char* msg) { #ifndef _LIBCPP_NO_EXCEPTIONS throw runtime_error(msg); +#else + (void)msg; #endif } diff --git a/contrib/libc++/src/memory.cpp b/contrib/libc++/src/memory.cpp index 14084a5..98bcc86 100644 --- a/contrib/libc++/src/memory.cpp +++ b/contrib/libc++/src/memory.cpp @@ -122,7 +122,15 @@ __shared_weak_count::__get_deleter(const type_info&) const _NOEXCEPT #if __has_feature(cxx_atomic) static const std::size_t __sp_mut_count = 16; -static mutex mut_back[__sp_mut_count]; +static pthread_mutex_t mut_back_imp[__sp_mut_count] = +{ + PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, + PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, + PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, + PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER +}; + +static mutex* mut_back = reinterpret_cast<std::mutex*>(mut_back_imp); _LIBCPP_CONSTEXPR __sp_mut::__sp_mut(void* p) _NOEXCEPT : __lx(p) diff --git a/contrib/libc++/src/new.cpp b/contrib/libc++/src/new.cpp index 3ad593a..b23a516 100644 --- a/contrib/libc++/src/new.cpp +++ b/contrib/libc++/src/new.cpp @@ -15,7 +15,7 @@ #define __has_include(inc) 0 #endif -#if __APPLE__ +#ifdef __APPLE__ #include <cxxabi.h> #ifndef _LIBCPPABI_VERSION diff --git a/contrib/libc++/src/stdexcept.cpp b/contrib/libc++/src/stdexcept.cpp index 660ebfe..0c4e832 100644 --- a/contrib/libc++/src/stdexcept.cpp +++ b/contrib/libc++/src/stdexcept.cpp @@ -20,7 +20,7 @@ #define __has_include(inc) 0 #endif -#if __APPLE__ +#ifdef __APPLE__ #include <cxxabi.h> #elif defined(LIBCXXRT) || __has_include(<cxxabi.h>) #include <cxxabi.h> diff --git a/contrib/libc++/src/string.cpp b/contrib/libc++/src/string.cpp index 40723e7..c71af4f 100644 --- a/contrib/libc++/src/string.cpp +++ b/contrib/libc++/src/string.cpp @@ -11,7 +11,7 @@ #include "cstdlib" #include "cwchar" #include "cerrno" -#if _WIN32 +#ifdef _WIN32 #include "support/win32/support.h" #endif // _WIN32 diff --git a/contrib/libc++/src/strstream.cpp b/contrib/libc++/src/strstream.cpp index 8cd19e6..518422b 100644 --- a/contrib/libc++/src/strstream.cpp +++ b/contrib/libc++/src/strstream.cpp @@ -158,6 +158,8 @@ strstreambuf::overflow(int_type __c) return int_type(EOF); streamsize old_size = (epptr() ? epptr() : egptr()) - eback(); streamsize new_size = max<streamsize>(__alsize_, 2*old_size); + if (new_size == 0) + new_size = __default_alsize; char* buf = nullptr; if (__palloc_) buf = static_cast<char*>(__palloc_(static_cast<size_t>(new_size))); diff --git a/contrib/libc++/src/system_error.cpp b/contrib/libc++/src/system_error.cpp index 763d62c..7376b77 100644 --- a/contrib/libc++/src/system_error.cpp +++ b/contrib/libc++/src/system_error.cpp @@ -195,6 +195,9 @@ __throw_system_error(int ev, const char* what_arg) { #ifndef _LIBCPP_NO_EXCEPTIONS throw system_error(error_code(ev, system_category()), what_arg); +#else + (void)ev; + (void)what_arg; #endif } diff --git a/contrib/libc++/src/thread.cpp b/contrib/libc++/src/thread.cpp index b2bd07e..c6f6748 100644 --- a/contrib/libc++/src/thread.cpp +++ b/contrib/libc++/src/thread.cpp @@ -13,8 +13,8 @@ #include "future" #include "limits" #include <sys/types.h> -#if !_WIN32 -#if !__sun__ && !__linux__ +#if !defined(_WIN32) +#if !defined(__sun__) && !defined(__linux__) #include <sys/sysctl.h> #else #include <unistd.h> @@ -36,6 +36,8 @@ thread::join() #ifndef _LIBCPP_NO_EXCEPTIONS if (ec) throw system_error(error_code(ec, system_category()), "thread::join failed"); +#else + (void)ec; #endif // _LIBCPP_NO_EXCEPTIONS __t_ = 0; } @@ -65,13 +67,15 @@ thread::hardware_concurrency() _NOEXCEPT std::size_t s = sizeof(n); sysctl(mib, 2, &n, &s, 0, 0); return n; -#elif defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L) && defined(_SC_NPROCESSORS_ONLN) +#elif (defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L) && defined(_SC_NPROCESSORS_ONLN)) || defined(EMSCRIPTEN) long result = sysconf(_SC_NPROCESSORS_ONLN); // sysconf returns -1 if the name is invalid, the option does not exist or // does not have a definite limit. - if (result == -1) + // if sysconf returns some other negative number, we have no idea + // what is going on. Default to something safe. + if (result < 0) return 0; - return result; + return static_cast<unsigned>(result); #else // defined(CTL_HW) && defined(HW_NCPU) // TODO: grovel through /proc or check cpuid on x86 and similar // instructions on other architectures. diff --git a/contrib/libc++/src/typeinfo.cpp b/contrib/libc++/src/typeinfo.cpp index 6bab077..6082894 100644 --- a/contrib/libc++/src/typeinfo.cpp +++ b/contrib/libc++/src/typeinfo.cpp @@ -12,7 +12,7 @@ #define __has_include(inc) 0 #endif -#if __APPLE__ +#ifdef __APPLE__ #include <cxxabi.h> #elif defined(LIBCXXRT) || __has_include(<cxxabi.h>) #include <cxxabi.h> @@ -50,11 +50,21 @@ std::bad_typeid::what() const _NOEXCEPT return "std::bad_typeid"; } -#if __APPLE__ +#ifdef __APPLE__ // On Darwin, the cxa_bad_* functions cannot be in the lower level library // because bad_cast and bad_typeid are defined in his higher level library - void __cxxabiv1::__cxa_bad_typeid() { throw std::bad_typeid(); } - void __cxxabiv1::__cxa_bad_cast() { throw std::bad_cast(); } + void __cxxabiv1::__cxa_bad_typeid() + { +#ifndef _LIBCPP_NO_EXCEPTIONS + throw std::bad_typeid(); +#endif + } + void __cxxabiv1::__cxa_bad_cast() + { +#ifndef _LIBCPP_NO_EXCEPTIONS + throw std::bad_cast(); +#endif + } #endif #endif // _LIBCPPABI_VERSION |
