diff options
Diffstat (limited to 'system')
80 files changed, 990 insertions, 897 deletions
diff --git a/system/include/libcxx/__bit_reference b/system/include/libcxx/__bit_reference index 8180295b..1621deb8 100644 --- a/system/include/libcxx/__bit_reference +++ b/system/include/libcxx/__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/system/include/libcxx/__config b/system/include/libcxx/__config index 8617b866..959390d5 100644 --- a/system/include/libcxx/__config +++ b/system/include/libcxx/__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/system/include/libcxx/__debug b/system/include/libcxx/__debug index 4a0e3cec..0d631bf0 100644 --- a/system/include/libcxx/__debug +++ b/system/include/libcxx/__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/system/include/libcxx/__functional_03 b/system/include/libcxx/__functional_03 index 3a5397d8..b52d6926 100644 --- a/system/include/libcxx/__functional_03 +++ b/system/include/libcxx/__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/system/include/libcxx/__functional_base b/system/include/libcxx/__functional_base index 2385459c..40a63a85 100644 --- a/system/include/libcxx/__functional_base +++ b/system/include/libcxx/__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/system/include/libcxx/__functional_base_03 b/system/include/libcxx/__functional_base_03 index a1005bf7..11165a96 100644 --- a/system/include/libcxx/__functional_base_03 +++ b/system/include/libcxx/__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/system/include/libcxx/__hash_table b/system/include/libcxx/__hash_table index ba04b3e5..6f6050d3 100644 --- a/system/include/libcxx/__hash_table +++ b/system/include/libcxx/__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/system/include/libcxx/__locale b/system/include/libcxx/__locale index 0805ad86..24d565b6 100644 --- a/system/include/libcxx/__locale +++ b/system/include/libcxx/__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__ || EMSCRIPTEN) +#elif (defined(__GLIBC__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__)) || defined(EMSCRIPTEN) # include <xlocale.h> -#endif // _WIN32 || __GLIBC__ || __APPLE__ || __FreeBSD__ || EMSCRIPTEN +#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,12 +339,12 @@ public: static const mask punct = _PUNCT; static const mask xdigit = _HEX; static const mask blank = _BLANK; -#elif (__APPLE__ || __FreeBSD__ || EMSCRIPTEN) -#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 EMSCRIPTEN +#elif defined(EMSCRIPTEN) typedef unsigned short mask; #endif static const mask space = _CTYPE_S; @@ -357,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; @@ -388,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 { @@ -493,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_; @@ -611,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; @@ -632,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; @@ -763,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() {} @@ -772,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 { @@ -863,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 { @@ -946,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 { @@ -1032,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 { @@ -1118,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: @@ -1142,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 @@ -1326,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: @@ -1360,7 +1360,7 @@ protected: }; template <> -class _LIBCPP_VISIBLE numpunct<wchar_t> +class _LIBCPP_TYPE_VIS numpunct<wchar_t> : public locale::facet { public: @@ -1392,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: @@ -1413,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/system/include/libcxx/__mutex_base b/system/include/libcxx/__mutex_base index e936ad30..0583df93 100644 --- a/system/include/libcxx/__mutex_base +++ b/system/include/libcxx/__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/system/include/libcxx/__std_stream b/system/include/libcxx/__std_stream index e562e2c4..8ca413eb 100644 --- a/system/include/libcxx/__std_stream +++ b/system/include/libcxx/__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/system/include/libcxx/__tree b/system/include/libcxx/__tree index bd38b4f2..cd6d7efa 100644 --- a/system/include/libcxx/__tree +++ b/system/include/libcxx/__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/system/include/libcxx/__tuple b/system/include/libcxx/__tuple index 1fa90a00..1213262d 100644 --- a/system/include/libcxx/__tuple +++ b/system/include/libcxx/__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/system/include/libcxx/__tuple_03 b/system/include/libcxx/__tuple_03 index a28ac080..605d84df 100644 --- a/system/include/libcxx/__tuple_03 +++ b/system/include/libcxx/__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/system/include/libcxx/array b/system/include/libcxx/array index f4a3020a..bcf53478 100644 --- a/system/include/libcxx/array +++ b/system/include/libcxx/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/system/include/libcxx/bitset b/system/include/libcxx/bitset index 06fd729e..dd9be4fc 100644 --- a/system/include/libcxx/bitset +++ b/system/include/libcxx/bitset @@ -253,7 +253,7 @@ __bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT : __first_{__v} #elif __SIZE_WIDTH__ == 32 : __first_{__v, __v >> __bits_per_word} -#elif +#else #error This constructor has not been ported to this platform #endif #endif @@ -632,11 +632,11 @@ __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: @@ -1060,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/system/include/libcxx/chrono b/system/include/libcxx/chrono index 508c1f37..3b96e816 100644 --- a/system/include/libcxx/chrono +++ b/system/include/libcxx/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/system/include/libcxx/codecvt b/system/include/libcxx/codecvt index 6c44e343..a6e4308e 100644 --- a/system/include/libcxx/codecvt +++ b/system/include/libcxx/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/system/include/libcxx/complex b/system/include/libcxx/complex index 07d37546..a09bf70f 100644 --- a/system/include/libcxx/complex +++ b/system/include/libcxx/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/system/include/libcxx/condition_variable b/system/include/libcxx/condition_variable index b1a50ee5..dc67266a 100644 --- a/system/include/libcxx/condition_variable +++ b/system/include/libcxx/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/system/include/libcxx/cstddef b/system/include/libcxx/cstddef index 24670897..c2637721 100644 --- a/system/include/libcxx/cstddef +++ b/system/include/libcxx/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/system/include/libcxx/cwchar b/system/include/libcxx/cwchar index eed6de18..caed08de 100644 --- a/system/include/libcxx/cwchar +++ b/system/include/libcxx/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 diff --git a/system/include/libcxx/deque b/system/include/libcxx/deque index b86d77f9..8e098223 100644 --- a/system/include/libcxx/deque +++ b/system/include/libcxx/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/system/include/libcxx/exception b/system/include/libcxx/exception index 51a48c82..37bfc57e 100644 --- a/system/include/libcxx/exception +++ b/system/include/libcxx/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/system/include/libcxx/ext/__hash b/system/include/libcxx/ext/__hash index 21500e89..f6ecfe36 100644 --- a/system/include/libcxx/ext/__hash +++ b/system/include/libcxx/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/system/include/libcxx/ext/hash_map b/system/include/libcxx/ext/hash_map index bebdccb3..a6fe894e 100644 --- a/system/include/libcxx/ext/hash_map +++ b/system/include/libcxx/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/system/include/libcxx/ext/hash_set b/system/include/libcxx/ext/hash_set index 14daf7bc..52bbeee1 100644 --- a/system/include/libcxx/ext/hash_set +++ b/system/include/libcxx/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/system/include/libcxx/forward_list b/system/include/libcxx/forward_list index 404c6eb1..0cbf2fdb 100644 --- a/system/include/libcxx/forward_list +++ b/system/include/libcxx/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/system/include/libcxx/fstream b/system/include/libcxx/fstream index 1b8e7a0a..0a5cf92a 100644 --- a/system/include/libcxx/fstream +++ b/system/include/libcxx/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: @@ -978,7 +978,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 +1123,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 +1268,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/system/include/libcxx/functional b/system/include/libcxx/functional index 25827822..995db564 100644 --- a/system/include/libcxx/functional +++ b/system/include/libcxx/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 @@ -1859,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 @@ -1867,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 @@ -1875,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 @@ -1883,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 @@ -1893,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 @@ -1901,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 @@ -1911,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 @@ -1919,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 @@ -1927,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 @@ -1935,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 @@ -1943,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 @@ -1951,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 @@ -1959,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 @@ -1967,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 @@ -1993,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 @@ -2007,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/system/include/libcxx/future b/system/include/libcxx/future index fa605e7d..3d7bb6c9 100644 --- a/system/include/libcxx/future +++ b/system/include/libcxx/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/system/include/libcxx/initializer_list b/system/include/libcxx/initializer_list index 2f88514b..181313d1 100644 --- a/system/include/libcxx/initializer_list +++ b/system/include/libcxx/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/system/include/libcxx/ios b/system/include/libcxx/ios index 1474deb4..25bbfc0b 100644 --- a/system/include/libcxx/ios +++ b/system/include/libcxx/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/system/include/libcxx/iosfwd b/system/include/libcxx/iosfwd index efdff5f3..849d7e51 100644 --- a/system/include/libcxx/iosfwd +++ b/system/include/libcxx/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/system/include/libcxx/iostream b/system/include/libcxx/iostream index 53cd146c..ddf24841 100644 --- a/system/include/libcxx/iostream +++ b/system/include/libcxx/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/system/include/libcxx/istream b/system/include/libcxx/istream index 3979e140..3f629f68 100644 --- a/system/include/libcxx/istream +++ b/system/include/libcxx/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/system/include/libcxx/iterator b/system/include/libcxx/iterator index b23310b0..3b078a2a 100644 --- a/system/include/libcxx/iterator +++ b/system/include/libcxx/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/system/include/libcxx/limits b/system/include/libcxx/limits index f089a794..9b9d7a6f 100644 --- a/system/include/libcxx/limits +++ b/system/include/libcxx/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/system/include/libcxx/list b/system/include/libcxx/list index 81258869..06904d96 100644 --- a/system/include/libcxx/list +++ b/system/include/libcxx/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 @@ -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; diff --git a/system/include/libcxx/locale b/system/include/libcxx/locale index 83259214..05020e17 100644 --- a/system/include/libcxx/locale +++ b/system/include/libcxx/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() @@ -646,6 +646,8 @@ __num_get<_CharT>::__stage2_float_loop(_CharT __ct, bool& __in_units, char& __ex _CharT __decimal_point, _CharT __thousands_sep, const string& __grouping, unsigned* __g, unsigned*& __g_end, unsigned& __dc, _CharT* __atoms) { + if (__a_end-__a >= __num_get_buf_sz - 1) + return -1; if (__ct == __decimal_point) { if (!__in_units) @@ -673,23 +675,27 @@ __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; + } } + if (__a_end-__a < __num_get_buf_sz - ((__exp & 0x80) ? 1 : 11)) + *__a_end++ = __x; if (__f >= 22) return 0; ++__dc; @@ -700,7 +706,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> { @@ -1472,7 +1478,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 +1990,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 +2012,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 +2662,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 +2722,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 +2821,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 +2843,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 +2855,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 +2913,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 +3025,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 +3359,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 +3581,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 +3739,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 +3748,7 @@ public: }; template <class _CharT> -class _LIBCPP_VISIBLE messages +class _LIBCPP_TYPE_VIS messages : public locale::facet, public messages_base { @@ -3793,7 +3799,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 +3814,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 +3836,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 +3848,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 +3874,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 +4127,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/system/include/libcxx/map b/system/include/libcxx/map index dd98da5e..abc07a35 100644 --- a/system/include/libcxx/map +++ b/system/include/libcxx/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/system/include/libcxx/memory b/system/include/libcxx/memory index 4e1f7046..fe352382 100644 --- a/system/include/libcxx/memory +++ b/system/include/libcxx/memory @@ -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; @@ -2490,7 +2490,7 @@ struct _LIBCPP_VISIBLE default_delete }; template <class _Tp> -struct _LIBCPP_VISIBLE default_delete<_Tp[]> +struct _LIBCPP_TYPE_VIS default_delete<_Tp[]> { public: #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS @@ -2512,7 +2512,7 @@ public: }; 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 +2691,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 +3393,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 +3410,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 +3583,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 { @@ -3752,10 +3752,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; @@ -4024,8 +4024,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> @@ -4921,7 +4921,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; @@ -4996,8 +4996,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> @@ -5197,7 +5197,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; @@ -5213,7 +5213,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; @@ -5229,7 +5229,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: @@ -5254,7 +5254,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; @@ -5284,10 +5284,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 @@ -5399,7 +5399,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/system/include/libcxx/mutex b/system/include/libcxx/mutex index ee20f021..e2b5d6bf 100644 --- a/system/include/libcxx/mutex +++ b/system/include/libcxx/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/system/include/libcxx/new b/system/include/libcxx/new index ae0951a7..1e85798b 100644 --- a/system/include/libcxx/new +++ b/system/include/libcxx/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/system/include/libcxx/ostream b/system/include/libcxx/ostream index b3b6df57..eac9c8f0 100644 --- a/system/include/libcxx/ostream +++ b/system/include/libcxx/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/system/include/libcxx/queue b/system/include/libcxx/queue index 4741f003..8d1a9dfc 100644 --- a/system/include/libcxx/queue +++ b/system/include/libcxx/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/system/include/libcxx/random b/system/include/libcxx/random index 04d942bc..92722ea6 100644 --- a/system/include/libcxx/random +++ b/system/include/libcxx/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/system/include/libcxx/ratio b/system/include/libcxx/ratio index 23f22679..f4e741e8 100644 --- a/system/include/libcxx/ratio +++ b/system/include/libcxx/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/system/include/libcxx/readme.txt b/system/include/libcxx/readme.txt index c0c90c3a..97d8db86 100644 --- a/system/include/libcxx/readme.txt +++ b/system/include/libcxx/readme.txt @@ -1 +1 @@ -These files are from libc++, svn revision 176559, Mar 7 2013 +These files are from libc++, svn revision 178253, Mar 29 2013 diff --git a/system/include/libcxx/regex b/system/include/libcxx/regex index 982500f3..d1afa54a 100644 --- a/system/include/libcxx/regex +++ b/system/include/libcxx/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/system/include/libcxx/scoped_allocator b/system/include/libcxx/scoped_allocator index cd051020..92532342 100644 --- a/system/include/libcxx/scoped_allocator +++ b/system/include/libcxx/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/system/include/libcxx/set b/system/include/libcxx/set index 36d3dd49..11ea9658 100644 --- a/system/include/libcxx/set +++ b/system/include/libcxx/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/system/include/libcxx/sstream b/system/include/libcxx/sstream index 22450f0a..c431fec0 100644 --- a/system/include/libcxx/sstream +++ b/system/include/libcxx/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: @@ -529,7 +529,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 +648,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 +767,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/system/include/libcxx/stack b/system/include/libcxx/stack index 12fb35b7..b8a7f4c0 100644 --- a/system/include/libcxx/stack +++ b/system/include/libcxx/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/system/include/libcxx/streambuf b/system/include/libcxx/streambuf index d6880241..82615942 100644 --- a/system/include/libcxx/streambuf +++ b/system/include/libcxx/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/system/include/libcxx/string b/system/include/libcxx/string index 1a704679..de668bba 100644 --- a/system/include/libcxx/string +++ b/system/include/libcxx/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: @@ -3923,7 +3923,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/system/include/libcxx/strstream b/system/include/libcxx/strstream index 5eadefd1..81eef2ab 100644 --- a/system/include/libcxx/strstream +++ b/system/include/libcxx/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/system/include/libcxx/system_error b/system/include/libcxx/system_error index cbc52fb7..1c1c7ebd 100644 --- a/system/include/libcxx/system_error +++ b/system/include/libcxx/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/system/include/libcxx/thread b/system/include/libcxx/thread index 60d88859..8d3aab2a 100644 --- a/system/include/libcxx/thread +++ b/system/include/libcxx/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_; diff --git a/system/include/libcxx/tuple b/system/include/libcxx/tuple index 3fa6730c..7f299e9d 100644 --- a/system/include/libcxx/tuple +++ b/system/include/libcxx/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; @@ -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/system/include/libcxx/type_traits b/system/include/libcxx/type_traits index 8f1c6024..f60f71b5 100644 --- a/system/include/libcxx/type_traits +++ b/system/include/libcxx/type_traits @@ -149,19 +149,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 +178,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 +206,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 +214,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 +238,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 +248,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 +265,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 +292,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 +307,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 +318,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 +347,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 +355,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 +363,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 +376,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 +397,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 +429,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 +442,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 +455,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 +511,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 +535,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 +550,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 +605,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 +636,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 +646,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 +752,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 +766,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 +788,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,7 +797,7 @@ 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 @@ -811,7 +811,7 @@ struct __libcpp_polymorphic template <class _Tp> struct __libcpp_polymorphic<_Tp, false> : public false_type {}; -template <class _Tp> struct _LIBCPP_VISIBLE is_polymorphic +template <class _Tp> struct _LIBCPP_TYPE_VIS is_polymorphic : public __libcpp_polymorphic<_Tp> {}; #endif // __has_feature(is_polymorphic) @@ -820,12 +820,12 @@ 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 @@ -834,7 +834,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE has_virtual_destructor template <class _Tp> struct __alignment_of {_Tp __lx;}; -template <class _Tp> struct _LIBCPP_VISIBLE alignment_of +template <class _Tp> struct _LIBCPP_TYPE_VIS alignment_of : public integral_constant<size_t, __alignof__(__alignment_of<typename remove_all_extents<_Tp>::type>)> {}; // aligned_storage @@ -922,7 +922,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 +935,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\ {\ @@ -1118,7 +1118,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 +1143,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 +1151,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 +1184,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 +1201,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 +1245,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 +1366,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 +1745,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 +1755,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 +1765,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 +1775,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 +1880,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 +2028,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 +2038,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 +2046,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 +2094,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 +2123,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 +2131,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 +2148,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 +2174,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 +2182,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 +2212,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 +2245,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 +2305,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 +2325,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 +2334,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 +2360,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 +2374,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 +2391,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 +2404,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 +2414,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 +2429,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 +2446,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 +2457,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 +2468,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 +2482,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 +2521,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 +2529,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 +2541,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 +2549,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 +2572,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 +2607,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 +2627,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 +2640,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 +2649,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 +2664,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 +2675,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 +2685,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 +2695,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 +2924,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/system/include/libcxx/typeindex b/system/include/libcxx/typeindex index 398b5288..67462b74 100644 --- a/system/include/libcxx/typeindex +++ b/system/include/libcxx/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/system/include/libcxx/unordered_map b/system/include/libcxx/unordered_map index cb2ab42a..235b2eab 100644 --- a/system/include/libcxx/unordered_map +++ b/system/include/libcxx/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/system/include/libcxx/unordered_set b/system/include/libcxx/unordered_set index 279e9072..119251dc 100644 --- a/system/include/libcxx/unordered_set +++ b/system/include/libcxx/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/system/include/libcxx/utility b/system/include/libcxx/utility index 514ce17f..2df4b361 100644 --- a/system/include/libcxx/utility +++ b/system/include/libcxx/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/system/include/libcxx/valarray b/system/include/libcxx/valarray index c56dd125..71c8a74e 100644 --- a/system/include/libcxx/valarray +++ b/system/include/libcxx/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/system/include/libcxx/vector b/system/include/libcxx/vector index 876b7e56..d1bc23e6 100644 --- a/system/include/libcxx/vector +++ b/system/include/libcxx/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)); @@ -1748,7 +1795,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 +1850,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 +2016,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 +2374,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 +3157,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/system/lib/libcxx/chrono.cpp b/system/lib/libcxx/chrono.cpp index 1ce2e280..15a6f466 100644 --- a/system/lib/libcxx/chrono.cpp +++ b/system/lib/libcxx/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/system/lib/libcxx/debug.cpp b/system/lib/libcxx/debug.cpp index f3a0262d..2d4b094b 100644 --- a/system/lib/libcxx/debug.cpp +++ b/system/lib/libcxx/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() { diff --git a/system/lib/libcxx/exception.cpp b/system/lib/libcxx/exception.cpp index 8d5ded4d..1d2f6b25 100644 --- a/system/lib/libcxx/exception.cpp +++ b/system/lib/libcxx/exception.cpp @@ -14,7 +14,7 @@ #define __has_include(inc) 0 #endif -#if __APPLE__ +#ifdef __APPLE__ #include <cxxabi.h> using namespace __cxxabiv1; @@ -104,7 +104,7 @@ terminate() _NOEXCEPT #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/system/lib/libcxx/iostream.cpp b/system/lib/libcxx/iostream.cpp index f5b959b4..7fc71df4 100644 --- a/system/lib/libcxx/iostream.cpp +++ b/system/lib/libcxx/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/system/lib/libcxx/locale.cpp b/system/lib/libcxx/locale.cpp index 35a65086..d9bc6f9a 100644 --- a/system/lib/libcxx/locale.cpp +++ b/system/lib/libcxx/locale.cpp @@ -25,7 +25,7 @@ #include "cstring" #include "cwctype" #include "__sso_allocator" -#if _WIN32 +#ifdef _WIN32 #include <support/win32/locale_win32.h> #else // _WIN32 #include <langinfo.h> @@ -993,11 +993,11 @@ 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 EMSCRIPTEN +#elif defined(EMSCRIPTEN) return *__ctype_b_loc(); #else // Platform not supported: abort so the person doing the port knows what to @@ -5801,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) @@ -5809,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) @@ -5821,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, @@ -5960,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) @@ -5980,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) @@ -6004,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, diff --git a/system/lib/libcxx/memory.cpp b/system/lib/libcxx/memory.cpp index 14084a52..98bcc864 100644 --- a/system/lib/libcxx/memory.cpp +++ b/system/lib/libcxx/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/system/lib/libcxx/new.cpp b/system/lib/libcxx/new.cpp index 3ad593a3..b23a516f 100644 --- a/system/lib/libcxx/new.cpp +++ b/system/lib/libcxx/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/system/lib/libcxx/readme.txt b/system/lib/libcxx/readme.txt index c0c90c3a..97d8db86 100644 --- a/system/lib/libcxx/readme.txt +++ b/system/lib/libcxx/readme.txt @@ -1 +1 @@ -These files are from libc++, svn revision 176559, Mar 7 2013 +These files are from libc++, svn revision 178253, Mar 29 2013 diff --git a/system/lib/libcxx/stdexcept.cpp b/system/lib/libcxx/stdexcept.cpp index 660ebfe2..0c4e8323 100644 --- a/system/lib/libcxx/stdexcept.cpp +++ b/system/lib/libcxx/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/system/lib/libcxx/string.cpp b/system/lib/libcxx/string.cpp index 40723e74..c71af4fe 100644 --- a/system/lib/libcxx/string.cpp +++ b/system/lib/libcxx/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/system/lib/libcxx/strstream.cpp b/system/lib/libcxx/strstream.cpp index 8cd19e6a..518422bd 100644 --- a/system/lib/libcxx/strstream.cpp +++ b/system/lib/libcxx/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/system/lib/libcxx/symbols b/system/lib/libcxx/symbols index 7e2072bc..93dfda65 100644 --- a/system/lib/libcxx/symbols +++ b/system/lib/libcxx/symbols @@ -766,8 +766,8 @@ C _ZNSt3__110__stdinbufIcE9__getcharEb C _ZNSt3__110__stdinbufIcE9pbackfailEi C _ZNSt3__110__stdinbufIcE9underflowEv - C _ZNSt3__110__stdinbufIcEC1EP7__sFILE - C _ZNSt3__110__stdinbufIcEC2EP7__sFILE + C _ZNSt3__110__stdinbufIcEC1EP7__sFILEP10_mbstate_t + C _ZNSt3__110__stdinbufIcEC2EP7__sFILEP10_mbstate_t C _ZNSt3__110__stdinbufIcED0Ev C _ZNSt3__110__stdinbufIcED1Ev C _ZNSt3__110__stdinbufIcED2Ev @@ -776,8 +776,8 @@ C _ZNSt3__110__stdinbufIwE9__getcharEb C _ZNSt3__110__stdinbufIwE9pbackfailEj C _ZNSt3__110__stdinbufIwE9underflowEv - C _ZNSt3__110__stdinbufIwEC1EP7__sFILE - C _ZNSt3__110__stdinbufIwEC2EP7__sFILE + C _ZNSt3__110__stdinbufIwEC1EP7__sFILEP10_mbstate_t + C _ZNSt3__110__stdinbufIwEC2EP7__sFILEP10_mbstate_t C _ZNSt3__110__stdinbufIwED0Ev C _ZNSt3__110__stdinbufIwED1Ev C _ZNSt3__110__stdinbufIwED2Ev @@ -882,16 +882,16 @@ C _ZNSt3__111__stdoutbufIcE4syncEv C _ZNSt3__111__stdoutbufIcE5imbueERKNS_6localeE C _ZNSt3__111__stdoutbufIcE8overflowEi - C _ZNSt3__111__stdoutbufIcEC1EP7__sFILE - C _ZNSt3__111__stdoutbufIcEC2EP7__sFILE + C _ZNSt3__111__stdoutbufIcEC1EP7__sFILEP10_mbstate_t + C _ZNSt3__111__stdoutbufIcEC2EP7__sFILEP10_mbstate_t C _ZNSt3__111__stdoutbufIcED0Ev C _ZNSt3__111__stdoutbufIcED1Ev C _ZNSt3__111__stdoutbufIcED2Ev C _ZNSt3__111__stdoutbufIwE4syncEv C _ZNSt3__111__stdoutbufIwE5imbueERKNS_6localeE C _ZNSt3__111__stdoutbufIwE8overflowEj - C _ZNSt3__111__stdoutbufIwEC1EP7__sFILE - C _ZNSt3__111__stdoutbufIwEC2EP7__sFILE + C _ZNSt3__111__stdoutbufIwEC1EP7__sFILEP10_mbstate_t + C _ZNSt3__111__stdoutbufIwEC2EP7__sFILEP10_mbstate_t C _ZNSt3__111__stdoutbufIwED0Ev C _ZNSt3__111__stdoutbufIwED1Ev C _ZNSt3__111__stdoutbufIwED2Ev @@ -2146,7 +2146,7 @@ C _ZNSt3__16vectorIPNS_6locale5facetENS_15__sso_allocatorIS3_Lj28EEEE18__construct_at_endEj C _ZNSt3__16vectorIPNS_6locale5facetENS_15__sso_allocatorIS3_Lj28EEEE18__construct_at_endIPS3_EENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESA_SA_ C _ZNSt3__16vectorIPNS_6locale5facetENS_15__sso_allocatorIS3_Lj28EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE - C _ZNSt3__16vectorIPNS_6locale5facetENS_15__sso_allocatorIS3_Lj28EEEE6assignIPS3_EENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESA_SA_ + C _ZNSt3__16vectorIPNS_6locale5facetENS_15__sso_allocatorIS3_Lj28EEEE6assignIPS3_EENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIS3_NS_15iterator_traitsISA_E9referenceEEE5valueEvE4typeESA_SA_ C _ZNSt3__16vectorIPNS_6locale5facetENS_15__sso_allocatorIS3_Lj28EEEE6resizeEj C _ZNSt3__16vectorIPNS_6locale5facetENS_15__sso_allocatorIS3_Lj28EEEE8__appendEj C _ZNSt3__16vectorIPNS_6locale5facetENS_15__sso_allocatorIS3_Lj28EEEE8allocateEj diff --git a/system/lib/libcxx/thread.cpp b/system/lib/libcxx/thread.cpp index a2d95bb2..76af3d0c 100644 --- a/system/lib/libcxx/thread.cpp +++ b/system/lib/libcxx/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> diff --git a/system/lib/libcxx/typeinfo.cpp b/system/lib/libcxx/typeinfo.cpp index 6bab0771..7b47d741 100644 --- a/system/lib/libcxx/typeinfo.cpp +++ b/system/lib/libcxx/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,7 +50,7 @@ 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(); } |