From 6e41256f6803ae236c51748c1b3472443b14c639 Mon Sep 17 00:00:00 2001 From: Howard Hinnant Date: Wed, 6 Mar 2013 23:30:19 +0000 Subject: [PATCH] No functionality change at this time. I've split _LIBCPP_VISIBLE up into two flags: _LIBCPP_TYPE_VIS and _LIBCPP_FUNC_VIS. This is in preparation for taking advantage of clang's new __type_visibility__ attribute. llvm-svn: 176593 --- libcxx/include/__config | 23 ++- libcxx/include/__debug | 14 +- libcxx/include/__functional_03 | 14 +- libcxx/include/__functional_base | 10 +- libcxx/include/__functional_base_03 | 2 +- libcxx/include/__hash_table | 40 ++-- libcxx/include/__locale | 66 +++---- libcxx/include/__mutex_base | 16 +- libcxx/include/__tree | 42 ++--- libcxx/include/__tuple | 30 +-- libcxx/include/__tuple_03 | 4 +- libcxx/include/array | 10 +- libcxx/include/bitset | 8 +- libcxx/include/chrono | 18 +- libcxx/include/codecvt | 6 +- libcxx/include/complex | 14 +- libcxx/include/condition_variable | 4 +- libcxx/include/cstddef | 2 +- libcxx/include/deque | 10 +- libcxx/include/exception | 18 +- libcxx/include/ext/__hash | 6 +- libcxx/include/ext/hash_map | 26 +-- libcxx/include/ext/hash_set | 4 +- libcxx/include/forward_list | 14 +- libcxx/include/fstream | 8 +- libcxx/include/functional | 106 +++++------ libcxx/include/future | 38 ++-- libcxx/include/initializer_list | 2 +- libcxx/include/ios | 16 +- libcxx/include/iosfwd | 40 ++-- libcxx/include/iostream | 16 +- libcxx/include/istream | 8 +- libcxx/include/iterator | 34 ++-- libcxx/include/limits | 8 +- libcxx/include/list | 10 +- libcxx/include/locale | 34 ++-- libcxx/include/map | 24 +-- libcxx/include/memory | 62 +++---- libcxx/include/mutex | 10 +- libcxx/include/new | 24 +-- libcxx/include/ostream | 6 +- libcxx/include/queue | 10 +- libcxx/include/random | 98 +++++----- libcxx/include/ratio | 22 +-- libcxx/include/regex | 16 +- libcxx/include/scoped_allocator | 2 +- libcxx/include/set | 4 +- libcxx/include/sstream | 8 +- libcxx/include/stack | 6 +- libcxx/include/streambuf | 2 +- libcxx/include/string | 16 +- libcxx/include/strstream | 8 +- libcxx/include/system_error | 22 +-- libcxx/include/thread | 18 +- libcxx/include/tuple | 16 +- libcxx/include/type_traits | 360 ++++++++++++++++++------------------ libcxx/include/typeindex | 6 +- libcxx/include/unordered_map | 26 +-- libcxx/include/unordered_set | 4 +- libcxx/include/utility | 18 +- libcxx/include/valarray | 40 ++-- libcxx/include/vector | 8 +- libcxx/src/debug.cpp | 4 +- 63 files changed, 784 insertions(+), 777 deletions(-) diff --git a/libcxx/include/__config b/libcxx/include/__config index 8617b86..ce0858f 100644 --- a/libcxx/include/__config +++ b/libcxx/include/__config @@ -102,14 +102,17 @@ #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 @@ -121,7 +124,7 @@ #endif #ifndef _LIBCPP_EXCEPTION_ABI -#define _LIBCPP_EXCEPTION_ABI _LIBCPP_VISIBLE +#define _LIBCPP_EXCEPTION_ABI _LIBCPP_TYPE_VIS #endif #ifndef _LIBCPP_ALWAYS_INLINE @@ -136,8 +139,12 @@ #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 +#define _LIBCPP_TYPE_VIS __attribute__ ((__visibility__("default"))) #endif #ifndef _LIBCPP_INLINE_VISIBILITY @@ -424,7 +431,7 @@ template 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 +439,7 @@ template 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 diff --git a/libcxx/include/__debug b/libcxx/include/__debug index 4a0e3ce..c7bd5d0 100644 --- a/libcxx/include/__debug +++ b/libcxx/include/__debug @@ -24,9 +24,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 +40,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 +117,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 +176,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/libcxx/include/__functional_03 b/libcxx/include/__functional_03 index 3a5397d..b52d692 100644 --- a/libcxx/include/__functional_03 +++ b/libcxx/include/__functional_03 @@ -203,7 +203,7 @@ class _LIBCPP_EXCEPTION_ABI bad_function_call { }; -template class _LIBCPP_VISIBLE function; // undefined +template 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 _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 _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 _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 _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 struct __is_bind_expression : public false_type {}; -template struct _LIBCPP_VISIBLE is_bind_expression +template struct _LIBCPP_TYPE_VIS is_bind_expression : public __is_bind_expression::type> {}; template struct __is_placeholder : public integral_constant {}; -template struct _LIBCPP_VISIBLE is_placeholder +template struct _LIBCPP_TYPE_VIS is_placeholder : public __is_placeholder::type> {}; namespace placeholders diff --git a/libcxx/include/__functional_base b/libcxx/include/__functional_base index 2385459..40a63a8 100644 --- a/libcxx/include/__functional_base +++ b/libcxx/include/__functional_base @@ -23,21 +23,21 @@ _LIBCPP_BEGIN_NAMESPACE_STD template -struct _LIBCPP_VISIBLE unary_function +struct _LIBCPP_TYPE_VIS unary_function { typedef _Arg argument_type; typedef _Result result_type; }; template -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 struct _LIBCPP_VISIBLE hash; +template struct _LIBCPP_TYPE_VIS hash; template struct __has_result_type @@ -51,7 +51,7 @@ public: }; template -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 _LIBCPP_VISIBLE reference_wrapper +class _LIBCPP_TYPE_VIS reference_wrapper : public __weak_result_type<_Tp> { public: diff --git a/libcxx/include/__functional_base_03 b/libcxx/include/__functional_base_03 index a1005bf..11165a9 100644 --- a/libcxx/include/__functional_base_03 +++ b/libcxx/include/__functional_base_03 @@ -996,7 +996,7 @@ struct __invoke_return2 }; template -class _LIBCPP_VISIBLE reference_wrapper +class _LIBCPP_TYPE_VIS reference_wrapper : public __weak_result_type<_Tp> { public: diff --git a/libcxx/include/__hash_table b/libcxx/include/__hash_table index ba04b3e..6f6050d 100644 --- a/libcxx/include/__hash_table +++ b/libcxx/include/__hash_table @@ -26,7 +26,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD -_LIBCPP_VISIBLE +_LIBCPP_FUNC_VIS size_t __next_prime(size_t __n); template @@ -80,14 +80,14 @@ __next_pow2(size_t __n) } template class __hash_table; -template class _LIBCPP_VISIBLE __hash_const_iterator; -template class _LIBCPP_VISIBLE __hash_map_iterator; -template class _LIBCPP_VISIBLE __hash_map_const_iterator; +template class _LIBCPP_TYPE_VIS __hash_const_iterator; +template class _LIBCPP_TYPE_VIS __hash_map_iterator; +template class _LIBCPP_TYPE_VIS __hash_map_const_iterator; template - class _LIBCPP_VISIBLE unordered_map; + class _LIBCPP_TYPE_VIS unordered_map; template -class _LIBCPP_VISIBLE __hash_iterator +class _LIBCPP_TYPE_VIS __hash_iterator { typedef _NodePtr __node_pointer; @@ -142,14 +142,14 @@ private: {} template friend class __hash_table; - template friend class _LIBCPP_VISIBLE __hash_const_iterator; - template friend class _LIBCPP_VISIBLE __hash_map_iterator; - template friend class _LIBCPP_VISIBLE unordered_map; - template friend class _LIBCPP_VISIBLE unordered_multimap; + template friend class _LIBCPP_TYPE_VIS __hash_const_iterator; + template friend class _LIBCPP_TYPE_VIS __hash_map_iterator; + template friend class _LIBCPP_TYPE_VIS unordered_map; + template friend class _LIBCPP_TYPE_VIS unordered_multimap; }; template -class _LIBCPP_VISIBLE __hash_const_iterator +class _LIBCPP_TYPE_VIS __hash_const_iterator { typedef _ConstNodePtr __node_pointer; @@ -220,15 +220,15 @@ private: {} template friend class __hash_table; - template friend class _LIBCPP_VISIBLE __hash_map_const_iterator; - template friend class _LIBCPP_VISIBLE unordered_map; - template friend class _LIBCPP_VISIBLE unordered_multimap; + template friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator; + template friend class _LIBCPP_TYPE_VIS unordered_map; + template friend class _LIBCPP_TYPE_VIS unordered_multimap; }; -template class _LIBCPP_VISIBLE __hash_const_local_iterator; +template class _LIBCPP_TYPE_VIS __hash_const_local_iterator; template -class _LIBCPP_VISIBLE __hash_local_iterator +class _LIBCPP_TYPE_VIS __hash_local_iterator { typedef _NodePtr __node_pointer; @@ -294,12 +294,12 @@ private: } template friend class __hash_table; - template friend class _LIBCPP_VISIBLE __hash_const_local_iterator; - template friend class _LIBCPP_VISIBLE __hash_map_iterator; + template friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator; + template friend class _LIBCPP_TYPE_VIS __hash_map_iterator; }; template -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 friend class __hash_table; - template friend class _LIBCPP_VISIBLE __hash_map_const_iterator; + template friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator; }; template diff --git a/libcxx/include/__locale b/libcxx/include/__locale index 4176720..cfa3fda 100644 --- a/libcxx/include/__locale +++ b/libcxx/include/__locale @@ -31,7 +31,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE locale; +class _LIBCPP_TYPE_VIS locale; template _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 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 collate; template -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(__h); } -_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_VISIBLE collate) -_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_VISIBLE collate) +_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS collate) +_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS collate) // template class collate_byname; -template class _LIBCPP_VISIBLE collate_byname; +template class _LIBCPP_TYPE_VIS collate_byname; template <> -class _LIBCPP_VISIBLE collate_byname +class _LIBCPP_TYPE_VIS collate_byname : public collate { locale_t __l; @@ -281,7 +281,7 @@ protected: }; template <> -class _LIBCPP_VISIBLE collate_byname +class _LIBCPP_TYPE_VIS collate_byname : public collate { locale_t __l; @@ -312,7 +312,7 @@ locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x, // template class ctype -class _LIBCPP_VISIBLE ctype_base +class _LIBCPP_TYPE_VIS ctype_base { public: #if __GLIBC__ @@ -386,10 +386,10 @@ public: _LIBCPP_ALWAYS_INLINE ctype_base() {} }; -template class _LIBCPP_VISIBLE ctype; +template class _LIBCPP_TYPE_VIS ctype; template <> -class _LIBCPP_VISIBLE ctype +class _LIBCPP_TYPE_VIS ctype : public locale::facet, public ctype_base { @@ -491,7 +491,7 @@ protected: }; template <> -class _LIBCPP_VISIBLE ctype +class _LIBCPP_TYPE_VIS ctype : public locale::facet, public ctype_base { const mask* __tab_; @@ -609,10 +609,10 @@ protected: // template class ctype_byname; -template class _LIBCPP_VISIBLE ctype_byname; +template class _LIBCPP_TYPE_VIS ctype_byname; template <> -class _LIBCPP_VISIBLE ctype_byname +class _LIBCPP_TYPE_VIS ctype_byname : public ctype { locale_t __l; @@ -630,7 +630,7 @@ protected: }; template <> -class _LIBCPP_VISIBLE ctype_byname +class _LIBCPP_TYPE_VIS ctype_byname : public ctype { locale_t __l; @@ -761,7 +761,7 @@ tolower(_CharT __c, const locale& __loc) // codecvt_base -class _LIBCPP_VISIBLE codecvt_base +class _LIBCPP_TYPE_VIS codecvt_base { public: _LIBCPP_ALWAYS_INLINE codecvt_base() {} @@ -770,12 +770,12 @@ public: // template class codecvt; -template class _LIBCPP_VISIBLE codecvt; +template class _LIBCPP_TYPE_VIS codecvt; // template <> class codecvt template <> -class _LIBCPP_VISIBLE codecvt +class _LIBCPP_TYPE_VIS codecvt : public locale::facet, public codecvt_base { @@ -861,7 +861,7 @@ protected: // template <> class codecvt template <> -class _LIBCPP_VISIBLE codecvt +class _LIBCPP_TYPE_VIS codecvt : public locale::facet, public codecvt_base { @@ -944,7 +944,7 @@ protected: // template <> class codecvt template <> -class _LIBCPP_VISIBLE codecvt +class _LIBCPP_TYPE_VIS codecvt : public locale::facet, public codecvt_base { @@ -1030,7 +1030,7 @@ protected: // template <> class codecvt template <> -class _LIBCPP_VISIBLE codecvt +class _LIBCPP_TYPE_VIS codecvt : public locale::facet, public codecvt_base { @@ -1116,7 +1116,7 @@ protected: // template class codecvt_byname template -class _LIBCPP_VISIBLE codecvt_byname +class _LIBCPP_TYPE_VIS codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> { public: @@ -1140,7 +1140,7 @@ _LIBCPP_EXTERN_TEMPLATE(class codecvt_byname) _LIBCPP_EXTERN_TEMPLATE(class codecvt_byname) _LIBCPP_EXTERN_TEMPLATE(class codecvt_byname) -_LIBCPP_VISIBLE void __throw_runtime_error(const char*); +_LIBCPP_FUNC_VIS void __throw_runtime_error(const char*); template struct __narrow_to_utf8 @@ -1324,10 +1324,10 @@ struct __widen_from_utf8<32> // template class numpunct -template class _LIBCPP_VISIBLE numpunct; +template class _LIBCPP_TYPE_VIS numpunct; template <> -class _LIBCPP_VISIBLE numpunct +class _LIBCPP_TYPE_VIS numpunct : public locale::facet { public: @@ -1358,7 +1358,7 @@ protected: }; template <> -class _LIBCPP_VISIBLE numpunct +class _LIBCPP_TYPE_VIS numpunct : public locale::facet { public: @@ -1390,10 +1390,10 @@ protected: // template class numpunct_byname -template class _LIBCPP_VISIBLE numpunct_byname; +template class _LIBCPP_TYPE_VIS numpunct_byname; template <> -class _LIBCPP_VISIBLE numpunct_byname +class _LIBCPP_TYPE_VIS numpunct_byname : public numpunct { public: @@ -1411,7 +1411,7 @@ private: }; template <> -class _LIBCPP_VISIBLE numpunct_byname +class _LIBCPP_TYPE_VIS numpunct_byname : public numpunct { public: diff --git a/libcxx/include/__mutex_base b/libcxx/include/__mutex_base index e936ad3..0583df9 100644 --- a/libcxx/include/__mutex_base +++ b/libcxx/include/__mutex_base @@ -32,7 +32,7 @@ template 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 _LIBCPP_VISIBLE lock_guard +class _LIBCPP_TYPE_VIS lock_guard { public: typedef _Mutex mutex_type; @@ -101,7 +101,7 @@ private: }; template -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/libcxx/include/__tree b/libcxx/include/__tree index bd38b4f..cd6d7ef 100644 --- a/libcxx/include/__tree +++ b/libcxx/include/__tree @@ -25,17 +25,17 @@ _LIBCPP_BEGIN_NAMESPACE_STD template class __tree; template - class _LIBCPP_VISIBLE __tree_iterator; + class _LIBCPP_TYPE_VIS __tree_iterator; template - class _LIBCPP_VISIBLE __tree_const_iterator; + class _LIBCPP_TYPE_VIS __tree_const_iterator; template - class _LIBCPP_VISIBLE map; + class _LIBCPP_TYPE_VIS map; template - class _LIBCPP_VISIBLE multimap; + class _LIBCPP_TYPE_VIS multimap; template - class _LIBCPP_VISIBLE set; + class _LIBCPP_TYPE_VIS set; template - 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 _LIBCPP_VISIBLE __map_iterator; -template class _LIBCPP_VISIBLE __map_const_iterator; +template class _LIBCPP_TYPE_VIS __map_iterator; +template class _LIBCPP_TYPE_VIS __map_const_iterator; template -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 friend class __tree; - template friend class _LIBCPP_VISIBLE __tree_const_iterator; - template friend class _LIBCPP_VISIBLE __map_iterator; - template friend class _LIBCPP_VISIBLE map; - template friend class _LIBCPP_VISIBLE multimap; - template friend class _LIBCPP_VISIBLE set; - template friend class _LIBCPP_VISIBLE multiset; + template friend class _LIBCPP_TYPE_VIS __tree_const_iterator; + template friend class _LIBCPP_TYPE_VIS __map_iterator; + template friend class _LIBCPP_TYPE_VIS map; + template friend class _LIBCPP_TYPE_VIS multimap; + template friend class _LIBCPP_TYPE_VIS set; + template friend class _LIBCPP_TYPE_VIS multiset; }; template -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 friend class __tree; - template friend class _LIBCPP_VISIBLE map; - template friend class _LIBCPP_VISIBLE multimap; - template friend class _LIBCPP_VISIBLE set; - template friend class _LIBCPP_VISIBLE multiset; - template friend class _LIBCPP_VISIBLE __map_const_iterator; + template friend class _LIBCPP_TYPE_VIS map; + template friend class _LIBCPP_TYPE_VIS multimap; + template friend class _LIBCPP_TYPE_VIS set; + template friend class _LIBCPP_TYPE_VIS multiset; + template friend class _LIBCPP_TYPE_VIS __map_const_iterator; }; template diff --git a/libcxx/include/__tuple b/libcxx/include/__tuple index 1fa90a0..1213262 100644 --- a/libcxx/include/__tuple +++ b/libcxx/include/__tuple @@ -27,46 +27,46 @@ _LIBCPP_BEGIN_NAMESPACE_STD -template class _LIBCPP_VISIBLE tuple_size; +template class _LIBCPP_TYPE_VIS tuple_size; template -class _LIBCPP_VISIBLE tuple_size +class _LIBCPP_TYPE_VIS tuple_size : public tuple_size<_Tp> {}; template -class _LIBCPP_VISIBLE tuple_size +class _LIBCPP_TYPE_VIS tuple_size : public tuple_size<_Tp> {}; template -class _LIBCPP_VISIBLE tuple_size +class _LIBCPP_TYPE_VIS tuple_size : public tuple_size<_Tp> {}; -template class _LIBCPP_VISIBLE tuple_element; +template class _LIBCPP_TYPE_VIS tuple_element; template -class _LIBCPP_VISIBLE tuple_element<_Ip, const _Tp> +class _LIBCPP_TYPE_VIS tuple_element<_Ip, const _Tp> { public: typedef typename add_const::type>::type type; }; template -class _LIBCPP_VISIBLE tuple_element<_Ip, volatile _Tp> +class _LIBCPP_TYPE_VIS tuple_element<_Ip, volatile _Tp> { public: typedef typename add_volatile::type>::type type; }; template -class _LIBCPP_VISIBLE tuple_element<_Ip, const volatile _Tp> +class _LIBCPP_TYPE_VIS tuple_element<_Ip, const volatile _Tp> { public: typedef typename add_cv::type>::type type; }; -template class _LIBCPP_VISIBLE tuple; -template struct _LIBCPP_VISIBLE pair; -template struct _LIBCPP_VISIBLE array; +template class _LIBCPP_TYPE_VIS tuple; +template struct _LIBCPP_TYPE_VIS pair; +template struct _LIBCPP_TYPE_VIS array; template struct __tuple_like : false_type {}; @@ -154,7 +154,7 @@ struct __make_tuple_indices template struct __tuple_types {}; template -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 _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 -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 _LIBCPP_VISIBLE tuple_size<__tuple_types<_Tp...> > +class _LIBCPP_TYPE_VIS tuple_size<__tuple_types<_Tp...> > : public integral_constant { }; diff --git a/libcxx/include/__tuple_03 b/libcxx/include/__tuple_03 index a28ac08..605d84d 100644 --- a/libcxx/include/__tuple_03 +++ b/libcxx/include/__tuple_03 @@ -19,8 +19,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD -template class _LIBCPP_VISIBLE tuple_size; -template class _LIBCPP_VISIBLE tuple_element; +template class _LIBCPP_TYPE_VIS tuple_size; +template class _LIBCPP_TYPE_VIS tuple_element; _LIBCPP_END_NAMESPACE_STD diff --git a/libcxx/include/array b/libcxx/include/array index f4a3020..bcf5347 100644 --- a/libcxx/include/array +++ b/libcxx/include/array @@ -118,7 +118,7 @@ template T&& get(array&&) noexcept; _LIBCPP_BEGIN_NAMESPACE_STD template -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 _LIBCPP_VISIBLE tuple_size > +class _LIBCPP_TYPE_VIS tuple_size > : public integral_constant {}; template -class _LIBCPP_VISIBLE tuple_size > +class _LIBCPP_TYPE_VIS tuple_size > : public integral_constant {}; template -class _LIBCPP_VISIBLE tuple_element<_Ip, array<_Tp, _Size> > +class _LIBCPP_TYPE_VIS tuple_element<_Ip, array<_Tp, _Size> > { public: typedef _Tp type; }; template -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/libcxx/include/bitset b/libcxx/include/bitset index aa7a596..dd9be4f 100644 --- a/libcxx/include/bitset +++ b/libcxx/include/bitset @@ -632,11 +632,11 @@ __bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT { } -template class _LIBCPP_VISIBLE bitset; -template struct hash >; +template class _LIBCPP_TYPE_VIS bitset; +template struct _LIBCPP_TYPE_VIS hash >; template -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 -struct _LIBCPP_VISIBLE hash > +struct _LIBCPP_TYPE_VIS hash > : public unary_function, size_t> { _LIBCPP_INLINE_VISIBILITY diff --git a/libcxx/include/chrono b/libcxx/include/chrono index 508c1f3..3b96e81 100644 --- a/libcxx/include/chrono +++ b/libcxx/include/chrono @@ -279,7 +279,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD namespace chrono { -template > class _LIBCPP_VISIBLE duration; +template > class _LIBCPP_TYPE_VIS duration; template struct __is_duration : false_type {}; @@ -299,7 +299,7 @@ struct __is_duration > : true_type {}; } // chrono template -struct _LIBCPP_VISIBLE common_type, +struct _LIBCPP_TYPE_VIS common_type, chrono::duration<_Rep2, _Period2> > { typedef chrono::duration::type, @@ -377,10 +377,10 @@ duration_cast(const duration<_Rep, _Period>& __fd) } template -struct _LIBCPP_VISIBLE treat_as_floating_point : is_floating_point<_Rep> {}; +struct _LIBCPP_TYPE_VIS treat_as_floating_point : is_floating_point<_Rep> {}; template -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 _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 _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 -struct _LIBCPP_VISIBLE common_type, +struct _LIBCPP_TYPE_VIS common_type, 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/libcxx/include/codecvt b/libcxx/include/codecvt index 6c44e34..a6e4308 100644 --- a/libcxx/include/codecvt +++ b/libcxx/include/codecvt @@ -179,7 +179,7 @@ protected: template -class _LIBCPP_VISIBLE codecvt_utf8 +class _LIBCPP_TYPE_VIS codecvt_utf8 : public __codecvt_utf8<_Elem> { public: @@ -407,7 +407,7 @@ protected: template -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 _LIBCPP_VISIBLE codecvt_utf8_utf16 +class _LIBCPP_TYPE_VIS codecvt_utf8_utf16 : public __codecvt_utf8_utf16<_Elem> { public: diff --git a/libcxx/include/complex b/libcxx/include/complex index 07d3754..a09bf70 100644 --- a/libcxx/include/complex +++ b/libcxx/include/complex @@ -255,13 +255,13 @@ template _LIBCPP_BEGIN_NAMESPACE_STD -template class _LIBCPP_VISIBLE complex; +template class _LIBCPP_TYPE_VIS complex; template complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w); template complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y); template -class _LIBCPP_VISIBLE complex +class _LIBCPP_TYPE_VIS complex { public: typedef _Tp value_type; @@ -319,11 +319,11 @@ public: } }; -template<> class _LIBCPP_VISIBLE complex; -template<> class _LIBCPP_VISIBLE complex; +template<> class _LIBCPP_TYPE_VIS complex; +template<> class _LIBCPP_TYPE_VIS complex; template<> -class _LIBCPP_VISIBLE complex +class _LIBCPP_TYPE_VIS complex { float __re_; float __im_; @@ -379,7 +379,7 @@ public: }; template<> -class _LIBCPP_VISIBLE complex +class _LIBCPP_TYPE_VIS complex { double __re_; double __im_; @@ -435,7 +435,7 @@ public: }; template<> -class _LIBCPP_VISIBLE complex +class _LIBCPP_TYPE_VIS complex { long double __re_; long double __im_; diff --git a/libcxx/include/condition_variable b/libcxx/include/condition_variable index b1a50ee..dc67266 100644 --- a/libcxx/include/condition_variable +++ b/libcxx/include/condition_variable @@ -117,7 +117,7 @@ public: _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE condition_variable_any +class _LIBCPP_TYPE_VIS condition_variable_any { condition_variable __cv_; shared_ptr __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 lk); _LIBCPP_END_NAMESPACE_STD diff --git a/libcxx/include/cstddef b/libcxx/include/cstddef index 2467089..c263772 100644 --- a/libcxx/include/cstddef +++ b/libcxx/include/cstddef @@ -56,7 +56,7 @@ typedef long double max_align_t; #ifdef _LIBCPP_HAS_NO_NULLPTR -struct _LIBCPP_VISIBLE nullptr_t +struct _LIBCPP_TYPE_VIS nullptr_t { void* __lx; diff --git a/libcxx/include/deque b/libcxx/include/deque index b86d77f..8e09822 100644 --- a/libcxx/include/deque +++ b/libcxx/include/deque @@ -170,7 +170,7 @@ template class __deque_base; template -class _LIBCPP_VISIBLE __deque_iterator; +class _LIBCPP_TYPE_VIS __deque_iterator; template @@ -262,7 +262,7 @@ move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f, template -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 friend class __deque_base; - template friend class _LIBCPP_VISIBLE deque; + template friend class _LIBCPP_TYPE_VIS deque; template - friend class _LIBCPP_VISIBLE __deque_iterator; + friend class _LIBCPP_TYPE_VIS __deque_iterator; template @@ -1167,7 +1167,7 @@ __deque_base<_Tp, _Allocator>::clear() _NOEXCEPT } template > -class _LIBCPP_VISIBLE deque +class _LIBCPP_TYPE_VIS deque : private __deque_base<_Tp, _Allocator> { public: diff --git a/libcxx/include/exception b/libcxx/include/exception index 51a48c8..37bfc57 100644 --- a/libcxx/include/exception +++ b/libcxx/include/exception @@ -105,23 +105,23 @@ public: }; typedef void (*unexpected_handler)(); -_LIBCPP_VISIBLE unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT; -_LIBCPP_VISIBLE unexpected_handler get_unexpected() _NOEXCEPT; -_LIBCPP_NORETURN _LIBCPP_VISIBLE void unexpected(); +_LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT; +_LIBCPP_FUNC_VIS unexpected_handler get_unexpected() _NOEXCEPT; +_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void unexpected(); typedef void (*terminate_handler)(); -_LIBCPP_VISIBLE terminate_handler set_terminate(terminate_handler) _NOEXCEPT; -_LIBCPP_VISIBLE terminate_handler get_terminate() _NOEXCEPT; -_LIBCPP_NORETURN _LIBCPP_VISIBLE void terminate() _NOEXCEPT; +_LIBCPP_FUNC_VIS terminate_handler set_terminate(terminate_handler) _NOEXCEPT; +_LIBCPP_FUNC_VIS terminate_handler get_terminate() _NOEXCEPT; +_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void terminate() _NOEXCEPT; -_LIBCPP_VISIBLE bool uncaught_exception() _NOEXCEPT; +_LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT; -class _LIBCPP_VISIBLE exception_ptr; +class _LIBCPP_TYPE_VIS exception_ptr; exception_ptr current_exception() _NOEXCEPT; _LIBCPP_NORETURN void rethrow_exception(exception_ptr); -class _LIBCPP_VISIBLE exception_ptr +class _LIBCPP_TYPE_VIS exception_ptr { void* __ptr_; public: diff --git a/libcxx/include/ext/__hash b/libcxx/include/ext/__hash index 21500e8..f6ecfe3 100644 --- a/libcxx/include/ext/__hash +++ b/libcxx/include/ext/__hash @@ -19,10 +19,10 @@ namespace __gnu_cxx { using namespace std; -template struct _LIBCPP_VISIBLE hash : public std::hash +template struct _LIBCPP_TYPE_VIS hash : public std::hash { }; -template <> struct _LIBCPP_VISIBLE hash +template <> struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -32,7 +32,7 @@ template <> struct _LIBCPP_VISIBLE hash } }; -template <> struct _LIBCPP_VISIBLE hash +template <> struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY diff --git a/libcxx/include/ext/hash_map b/libcxx/include/ext/hash_map index bebdccb..a6fe894 100644 --- a/libcxx/include/ext/hash_map +++ b/libcxx/include/ext/hash_map @@ -361,7 +361,7 @@ public: }; template -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 friend class _LIBCPP_VISIBLE hash_map; - template friend class _LIBCPP_VISIBLE hash_multimap; - template friend class _LIBCPP_VISIBLE __hash_const_iterator; - template friend class _LIBCPP_VISIBLE __hash_const_local_iterator; - template friend class _LIBCPP_VISIBLE __hash_map_const_iterator; + template friend class _LIBCPP_TYPE_VIS hash_map; + template friend class _LIBCPP_TYPE_VIS hash_multimap; + template friend class _LIBCPP_TYPE_VIS __hash_const_iterator; + template friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator; + template friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator; }; template -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 friend class _LIBCPP_VISIBLE hash_map; - template friend class _LIBCPP_VISIBLE hash_multimap; - template friend class _LIBCPP_VISIBLE __hash_const_iterator; - template friend class _LIBCPP_VISIBLE __hash_const_local_iterator; + template friend class _LIBCPP_TYPE_VIS hash_map; + template friend class _LIBCPP_TYPE_VIS hash_multimap; + template friend class _LIBCPP_TYPE_VIS __hash_const_iterator; + template friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator; }; template , class _Pred = equal_to<_Key>, class _Alloc = allocator > > -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 _Pred = equal_to<_Key>, class _Alloc = allocator > > -class _LIBCPP_VISIBLE hash_multimap +class _LIBCPP_TYPE_VIS hash_multimap { public: // types diff --git a/libcxx/include/ext/hash_set b/libcxx/include/ext/hash_set index 14daf7b..52bbeee 100644 --- a/libcxx/include/ext/hash_set +++ b/libcxx/include/ext/hash_set @@ -208,7 +208,7 @@ using namespace std; template , 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 _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> > -class _LIBCPP_VISIBLE hash_multiset +class _LIBCPP_TYPE_VIS hash_multiset { public: // types diff --git a/libcxx/include/forward_list b/libcxx/include/forward_list index 404c6eb..0cbf2fd 100644 --- a/libcxx/include/forward_list +++ b/libcxx/include/forward_list @@ -212,11 +212,11 @@ struct __forward_list_node value_type __value_; }; -template class _LIBCPP_VISIBLE forward_list; -template class _LIBCPP_VISIBLE __forward_list_const_iterator; +template class _LIBCPP_TYPE_VIS forward_list; +template class _LIBCPP_TYPE_VIS __forward_list_const_iterator; template -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 friend class _LIBCPP_VISIBLE forward_list; - template friend class _LIBCPP_VISIBLE __forward_list_const_iterator; + template friend class _LIBCPP_TYPE_VIS forward_list; + template friend class _LIBCPP_TYPE_VIS __forward_list_const_iterator; public: typedef forward_iterator_tag iterator_category; @@ -276,7 +276,7 @@ public: }; template -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 _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/libcxx/include/fstream b/libcxx/include/fstream index 1b8e7a0..0a5cf92 100644 --- a/libcxx/include/fstream +++ b/libcxx/include/fstream @@ -180,7 +180,7 @@ typedef basic_fstream wfstream; _LIBCPP_BEGIN_NAMESPACE_STD template -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 _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 _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 _LIBCPP_VISIBLE basic_fstream +class _LIBCPP_TYPE_VIS basic_fstream : public basic_iostream<_CharT, _Traits> { public: diff --git a/libcxx/include/functional b/libcxx/include/functional index 2582782..995db56 100644 --- a/libcxx/include/functional +++ b/libcxx/include/functional @@ -474,63 +474,63 @@ POLICY: For non-variadic implementations, the number of arguments is limited _LIBCPP_BEGIN_NAMESPACE_STD template -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 -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 _LIBCPP_VISIBLE unary_negate +class _LIBCPP_TYPE_VIS unary_negate : public unary_function { _Predicate __pred_; @@ -612,7 +612,7 @@ unary_negate<_Predicate> not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);} template -class _LIBCPP_VISIBLE binary_negate +class _LIBCPP_TYPE_VIS binary_negate : public binary_function @@ -632,7 +632,7 @@ binary_negate<_Predicate> not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);} template -class _LIBCPP_VISIBLE binder1st +class _LIBCPP_TYPE_VIS binder1st : public unary_function { @@ -658,7 +658,7 @@ bind1st(const __Operation& __op, const _Tp& __x) {return binder1st<__Operation>(__op, __x);} template -class _LIBCPP_VISIBLE binder2nd +class _LIBCPP_TYPE_VIS binder2nd : public unary_function { @@ -684,7 +684,7 @@ bind2nd(const __Operation& __op, const _Tp& __x) {return binder2nd<__Operation>(__op, __x);} template -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 _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 _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 _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 _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 _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 _LIBCPP_VISIBLE const_mem_fun_t : public unary_function +class _LIBCPP_TYPE_VIS const_mem_fun_t : public unary_function { _Sp (_Tp::*__p_)() const; public: @@ -799,7 +799,7 @@ public: }; template -class _LIBCPP_VISIBLE const_mem_fun1_t : public binary_function +class _LIBCPP_TYPE_VIS const_mem_fun1_t : public binary_function { _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 _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 _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 _LIBCPP_VISIBLE function; // undefined +template class _LIBCPP_TYPE_VIS function; // undefined namespace __function { @@ -1083,7 +1083,7 @@ __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT } // __function template -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 struct __is_bind_expression : public false_type {}; -template struct _LIBCPP_VISIBLE is_bind_expression +template struct _LIBCPP_TYPE_VIS is_bind_expression : public __is_bind_expression::type> {}; template struct __is_placeholder : public integral_constant {}; -template struct _LIBCPP_VISIBLE is_placeholder +template struct _LIBCPP_TYPE_VIS is_placeholder : public __is_placeholder::type> {}; namespace placeholders @@ -1859,7 +1859,7 @@ bind(_Fp&& __f, _BoundArgs&&... __bound_args) #endif // _LIBCPP_HAS_NO_VARIADICS template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1867,7 +1867,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1875,7 +1875,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1883,7 +1883,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1893,7 +1893,7 @@ struct _LIBCPP_VISIBLE hash #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1901,7 +1901,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1911,7 +1911,7 @@ struct _LIBCPP_VISIBLE hash #endif // _LIBCPP_HAS_NO_UNICODE_CHARS template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1919,7 +1919,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1927,7 +1927,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1935,7 +1935,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1943,7 +1943,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1951,7 +1951,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1959,7 +1959,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -1967,19 +1967,19 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public __scalar_hash { }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public __scalar_hash { }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public __scalar_hash { _LIBCPP_INLINE_VISIBILITY @@ -1993,7 +1993,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public __scalar_hash { _LIBCPP_INLINE_VISIBILITY @@ -2007,7 +2007,7 @@ struct _LIBCPP_VISIBLE hash }; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public __scalar_hash { _LIBCPP_INLINE_VISIBILITY diff --git a/libcxx/include/future b/libcxx/include/future index fa605e7..3d7bb6c 100644 --- a/libcxx/include/future +++ b/libcxx/include/future @@ -387,11 +387,11 @@ _LIBCPP_DECLARE_STRONG_ENUM(future_errc) _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc) template <> -struct _LIBCPP_VISIBLE is_error_code_enum : public true_type {}; +struct _LIBCPP_TYPE_VIS is_error_code_enum : public true_type {}; #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS template <> -struct _LIBCPP_VISIBLE is_error_code_enum : public true_type { }; +struct _LIBCPP_TYPE_VIS is_error_code_enum : 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::__on_zero_shared() _NOEXCEPT base::__on_zero_shared(); } -template class _LIBCPP_VISIBLE promise; -template class _LIBCPP_VISIBLE shared_future; +template class _LIBCPP_TYPE_VIS promise; +template class _LIBCPP_TYPE_VIS shared_future; // future -template class _LIBCPP_VISIBLE future; +template class _LIBCPP_TYPE_VIS future; template future<_Rp> @@ -990,7 +990,7 @@ __make_async_assoc_state(_Fp __f); #endif template -class _LIBCPP_VISIBLE future +class _LIBCPP_TYPE_VIS future { __assoc_state<_Rp>* __state_; @@ -1094,7 +1094,7 @@ future<_Rp>::get() } template -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 +class _LIBCPP_TYPE_VIS future { __assoc_sub_state* __state_; @@ -1275,7 +1275,7 @@ swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT template class packaged_task; template -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 template -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 template <> -class _LIBCPP_VISIBLE promise +class _LIBCPP_TYPE_VIS promise { __assoc_sub_state* __state_; @@ -1670,7 +1670,7 @@ swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT } template - struct _LIBCPP_VISIBLE uses_allocator, _Alloc> + struct _LIBCPP_TYPE_VIS uses_allocator, _Alloc> : public true_type {}; #ifndef _LIBCPP_HAS_NO_VARIADICS @@ -1934,7 +1934,7 @@ __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) cons } template -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 _LIBCPP_VISIBLE packaged_task +class _LIBCPP_TYPE_VIS packaged_task { public: typedef void result_type; @@ -2174,7 +2174,7 @@ swap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) _NOEXCEPT } template -struct _LIBCPP_VISIBLE uses_allocator, _Alloc> +struct _LIBCPP_TYPE_VIS uses_allocator, _Alloc> : public true_type {}; template @@ -2263,7 +2263,7 @@ async(_Fp&& __f, _Args&&... __args) // shared_future template -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 _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 +class _LIBCPP_TYPE_VIS shared_future { __assoc_sub_state* __state_; diff --git a/libcxx/include/initializer_list b/libcxx/include/initializer_list index 2f88514..181313d 100644 --- a/libcxx/include/initializer_list +++ b/libcxx/include/initializer_list @@ -56,7 +56,7 @@ namespace std // purposefully not versioned #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS template -class _LIBCPP_VISIBLE initializer_list +class _LIBCPP_TYPE_VIS initializer_list { const _Ep* __begin_; size_t __size_; diff --git a/libcxx/include/ios b/libcxx/include/ios index 1474deb..25bbfc0 100644 --- a/libcxx/include/ios +++ b/libcxx/include/ios @@ -224,10 +224,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD typedef ptrdiff_t streamsize; -class _LIBCPP_VISIBLE ios_base +class _LIBCPP_TYPE_VIS ios_base { public: - class _LIBCPP_VISIBLE failure; + class _LIBCPP_TYPE_VIS failure; typedef unsigned int fmtflags; static const fmtflags boolalpha = 0x0001; @@ -271,7 +271,7 @@ public: typedef _VSTD::streamoff streamoff; typedef _VSTD::streampos streampos; - class _LIBCPP_VISIBLE Init; + class _LIBCPP_TYPE_VIS Init; // 27.5.2.2 fmtflags state: _LIBCPP_INLINE_VISIBILITY fmtflags flags() const; @@ -380,14 +380,14 @@ _LIBCPP_DECLARE_STRONG_ENUM(io_errc) _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc) template <> -struct _LIBCPP_VISIBLE is_error_code_enum : public true_type { }; +struct _LIBCPP_TYPE_VIS is_error_code_enum : public true_type { }; #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS template <> -struct _LIBCPP_VISIBLE is_error_code_enum : public true_type { }; +struct _LIBCPP_TYPE_VIS is_error_code_enum : 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 _LIBCPP_VISIBLE basic_ios +class _LIBCPP_TYPE_VIS basic_ios : public ios_base { public: diff --git a/libcxx/include/iosfwd b/libcxx/include/iosfwd index efdff5f..849d7e5 100644 --- a/libcxx/include/iosfwd +++ b/libcxx/include/iosfwd @@ -95,49 +95,49 @@ typedef fpos::state_type> wstreampos; _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE ios_base; +class _LIBCPP_TYPE_VIS ios_base; -template struct _LIBCPP_VISIBLE char_traits; -template class _LIBCPP_VISIBLE allocator; +template struct _LIBCPP_TYPE_VIS char_traits; +template class _LIBCPP_TYPE_VIS allocator; template > - class _LIBCPP_VISIBLE basic_ios; + class _LIBCPP_TYPE_VIS basic_ios; template > - class _LIBCPP_VISIBLE basic_streambuf; + class _LIBCPP_TYPE_VIS basic_streambuf; template > - class _LIBCPP_VISIBLE basic_istream; + class _LIBCPP_TYPE_VIS basic_istream; template > - class _LIBCPP_VISIBLE basic_ostream; + class _LIBCPP_TYPE_VIS basic_ostream; template > - class _LIBCPP_VISIBLE basic_iostream; + class _LIBCPP_TYPE_VIS basic_iostream; template , class _Allocator = allocator<_CharT> > - class _LIBCPP_VISIBLE basic_stringbuf; + class _LIBCPP_TYPE_VIS basic_stringbuf; template , class _Allocator = allocator<_CharT> > - class _LIBCPP_VISIBLE basic_istringstream; + class _LIBCPP_TYPE_VIS basic_istringstream; template , class _Allocator = allocator<_CharT> > - class _LIBCPP_VISIBLE basic_ostringstream; + class _LIBCPP_TYPE_VIS basic_ostringstream; template , class _Allocator = allocator<_CharT> > - class _LIBCPP_VISIBLE basic_stringstream; + class _LIBCPP_TYPE_VIS basic_stringstream; template > - class _LIBCPP_VISIBLE basic_filebuf; + class _LIBCPP_TYPE_VIS basic_filebuf; template > - class _LIBCPP_VISIBLE basic_ifstream; + class _LIBCPP_TYPE_VIS basic_ifstream; template > - class _LIBCPP_VISIBLE basic_ofstream; + class _LIBCPP_TYPE_VIS basic_ofstream; template > - class _LIBCPP_VISIBLE basic_fstream; + class _LIBCPP_TYPE_VIS basic_fstream; template > - class _LIBCPP_VISIBLE istreambuf_iterator; + class _LIBCPP_TYPE_VIS istreambuf_iterator; template > - class _LIBCPP_VISIBLE ostreambuf_iterator; + class _LIBCPP_TYPE_VIS ostreambuf_iterator; typedef basic_ios ios; typedef basic_ios wios; @@ -172,7 +172,7 @@ typedef basic_ifstream wifstream; typedef basic_ofstream wofstream; typedef basic_fstream wfstream; -template class _LIBCPP_VISIBLE fpos; +template class _LIBCPP_TYPE_VIS fpos; typedef fpos streampos; typedef fpos wstreampos; #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS @@ -185,7 +185,7 @@ typedef long long streamoff; // for char_traits in template class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> > - class _LIBCPP_VISIBLE basic_string; + class _LIBCPP_TYPE_VIS basic_string; typedef basic_string, allocator > string; typedef basic_string, allocator > wstring; diff --git a/libcxx/include/iostream b/libcxx/include/iostream index 53cd146..ddf2484 100644 --- a/libcxx/include/iostream +++ b/libcxx/include/iostream @@ -46,14 +46,14 @@ extern wostream wclog; _LIBCPP_BEGIN_NAMESPACE_STD -extern _LIBCPP_VISIBLE istream cin; -extern _LIBCPP_VISIBLE ostream cout; -extern _LIBCPP_VISIBLE ostream cerr; -extern _LIBCPP_VISIBLE ostream clog; -extern _LIBCPP_VISIBLE wistream wcin; -extern _LIBCPP_VISIBLE wostream wcout; -extern _LIBCPP_VISIBLE wostream wcerr; -extern _LIBCPP_VISIBLE wostream wclog; +extern _LIBCPP_FUNC_VIS istream cin; +extern _LIBCPP_FUNC_VIS ostream cout; +extern _LIBCPP_FUNC_VIS ostream cerr; +extern _LIBCPP_FUNC_VIS ostream clog; +extern _LIBCPP_FUNC_VIS wistream wcin; +extern _LIBCPP_FUNC_VIS wostream wcout; +extern _LIBCPP_FUNC_VIS wostream wcerr; +extern _LIBCPP_FUNC_VIS wostream wclog; _LIBCPP_END_NAMESPACE_STD diff --git a/libcxx/include/istream b/libcxx/include/istream index e484571..3f629f6 100644 --- a/libcxx/include/istream +++ b/libcxx/include/istream @@ -164,7 +164,7 @@ template _LIBCPP_BEGIN_NAMESPACE_STD template -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 _LIBCPP_VISIBLE basic_istream<_CharT, _Traits>::sentry +class _LIBCPP_TYPE_VIS basic_istream<_CharT, _Traits>::sentry { bool __ok_; @@ -1453,7 +1453,7 @@ operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x) #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES template -class _LIBCPP_VISIBLE basic_iostream +class _LIBCPP_TYPE_VIS basic_iostream : public basic_istream<_CharT, _Traits>, public basic_ostream<_CharT, _Traits> { diff --git a/libcxx/include/iterator b/libcxx/include/iterator index b23310b..59e3390 100644 --- a/libcxx/include/iterator +++ b/libcxx/include/iterator @@ -331,11 +331,11 @@ template 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 struct __has_iterator_category @@ -378,11 +378,11 @@ struct __iterator_traits<_Iter, true> // the client expects instead of failing at compile time. template -struct _LIBCPP_VISIBLE iterator_traits +struct _LIBCPP_TYPE_VIS iterator_traits : __iterator_traits<_Iter, __has_iterator_category<_Iter>::value> {}; template -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 -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 _LIBCPP_VISIBLE reverse_iterator +class _LIBCPP_TYPE_VIS reverse_iterator : public iterator::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 _LIBCPP_VISIBLE back_insert_iterator +class _LIBCPP_TYPE_VIS back_insert_iterator : public iterator -class _LIBCPP_VISIBLE front_insert_iterator +class _LIBCPP_TYPE_VIS front_insert_iterator : public iterator -class _LIBCPP_VISIBLE insert_iterator +class _LIBCPP_TYPE_VIS insert_iterator : public iterator, class _Distance = ptrdiff_t> -class _LIBCPP_VISIBLE istream_iterator +class _LIBCPP_TYPE_VIS istream_iterator : public iterator { public: @@ -758,7 +758,7 @@ public: }; template > -class _LIBCPP_VISIBLE ostream_iterator +class _LIBCPP_TYPE_VIS ostream_iterator : public iterator { public: @@ -787,7 +787,7 @@ public: }; template -class _LIBCPP_VISIBLE istreambuf_iterator +class _LIBCPP_TYPE_VIS istreambuf_iterator : public iterator @@ -858,7 +858,7 @@ bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a, {return !__a.equal(__b);} template -class _LIBCPP_VISIBLE ostreambuf_iterator +class _LIBCPP_TYPE_VIS ostreambuf_iterator : public iterator { public: @@ -899,7 +899,7 @@ public: }; template -class _LIBCPP_VISIBLE move_iterator +class _LIBCPP_TYPE_VIS move_iterator { private: _Iter __i; diff --git a/libcxx/include/limits b/libcxx/include/limits index f089a79..9b9d7a6 100644 --- a/libcxx/include/limits +++ b/libcxx/include/limits @@ -433,7 +433,7 @@ protected: }; template -class _LIBCPP_VISIBLE numeric_limits +class _LIBCPP_TYPE_VIS numeric_limits : private __libcpp_numeric_limits::type> { typedef __libcpp_numeric_limits::type> __base; @@ -526,7 +526,7 @@ template _LIBCPP_CONSTEXPR const float_round_style numeric_limits<_Tp>::round_style; template -class _LIBCPP_VISIBLE numeric_limits +class _LIBCPP_TYPE_VIS numeric_limits : private numeric_limits<_Tp> { typedef numeric_limits<_Tp> __base; @@ -619,7 +619,7 @@ template _LIBCPP_CONSTEXPR const float_round_style numeric_limits::round_style; template -class _LIBCPP_VISIBLE numeric_limits +class _LIBCPP_TYPE_VIS numeric_limits : private numeric_limits<_Tp> { typedef numeric_limits<_Tp> __base; @@ -712,7 +712,7 @@ template _LIBCPP_CONSTEXPR const float_round_style numeric_limits::round_style; template -class _LIBCPP_VISIBLE numeric_limits +class _LIBCPP_TYPE_VIS numeric_limits : private numeric_limits<_Tp> { typedef numeric_limits<_Tp> __base; diff --git a/libcxx/include/list b/libcxx/include/list index 8125886..06904d9 100644 --- a/libcxx/include/list +++ b/libcxx/include/list @@ -213,12 +213,12 @@ struct __list_node _Tp __value_; }; -template class _LIBCPP_VISIBLE list; +template class _LIBCPP_TYPE_VIS list; template class __list_imp; -template class _LIBCPP_VISIBLE __list_const_iterator; +template class _LIBCPP_TYPE_VIS __list_const_iterator; template -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 _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 _LIBCPP_VISIBLE list +class _LIBCPP_TYPE_VIS list : private __list_imp<_Tp, _Alloc> { typedef __list_imp<_Tp, _Alloc> base; diff --git a/libcxx/include/locale b/libcxx/include/locale index 9189375..39aba84 100644 --- a/libcxx/include/locale +++ b/libcxx/include/locale @@ -700,7 +700,7 @@ _LIBCPP_EXTERN_TEMPLATE(struct __num_get) _LIBCPP_EXTERN_TEMPLATE(struct __num_get) template > -class _LIBCPP_VISIBLE num_get +class _LIBCPP_TYPE_VIS num_get : public locale::facet, private __num_get<_CharT> { @@ -1472,7 +1472,7 @@ _LIBCPP_EXTERN_TEMPLATE(struct __num_put) _LIBCPP_EXTERN_TEMPLATE(struct __num_put) template > -class _LIBCPP_VISIBLE num_put +class _LIBCPP_TYPE_VIS num_put : public locale::facet, private __num_put<_CharT> { @@ -1984,7 +1984,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 +2006,7 @@ protected: }; template > -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 +2656,7 @@ private: }; template > -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 +2716,7 @@ protected: }; template > -class _LIBCPP_VISIBLE time_put +class _LIBCPP_TYPE_VIS time_put : public locale::facet, private __time_put { @@ -2815,7 +2815,7 @@ _LIBCPP_EXTERN_TEMPLATE(class time_put) _LIBCPP_EXTERN_TEMPLATE(class time_put) template > -class _LIBCPP_VISIBLE time_put_byname +class _LIBCPP_TYPE_VIS time_put_byname : public time_put<_CharT, _OutputIterator> { public: @@ -2837,7 +2837,7 @@ _LIBCPP_EXTERN_TEMPLATE(class time_put_byname) // money_base -class _LIBCPP_VISIBLE money_base +class _LIBCPP_TYPE_VIS money_base { public: enum part {none, space, symbol, sign, value}; @@ -2849,7 +2849,7 @@ public: // moneypunct template -class _LIBCPP_VISIBLE moneypunct +class _LIBCPP_TYPE_VIS moneypunct : public locale::facet, public money_base { @@ -2907,7 +2907,7 @@ _LIBCPP_EXTERN_TEMPLATE(class moneypunct) // moneypunct_byname template -class _LIBCPP_VISIBLE moneypunct_byname +class _LIBCPP_TYPE_VIS moneypunct_byname : public moneypunct<_CharT, _International> { public: @@ -3019,7 +3019,7 @@ _LIBCPP_EXTERN_TEMPLATE(class __money_get) _LIBCPP_EXTERN_TEMPLATE(class __money_get) template > -class _LIBCPP_VISIBLE money_get +class _LIBCPP_TYPE_VIS money_get : public locale::facet, private __money_get<_CharT> { @@ -3575,7 +3575,7 @@ _LIBCPP_EXTERN_TEMPLATE(class __money_put) _LIBCPP_EXTERN_TEMPLATE(class __money_put) template > -class _LIBCPP_VISIBLE money_put +class _LIBCPP_TYPE_VIS money_put : public locale::facet, private __money_put<_CharT> { @@ -3733,7 +3733,7 @@ _LIBCPP_EXTERN_TEMPLATE(class money_put) // messages -class _LIBCPP_VISIBLE messages_base +class _LIBCPP_TYPE_VIS messages_base { public: typedef ptrdiff_t catalog; @@ -3742,7 +3742,7 @@ public: }; template -class _LIBCPP_VISIBLE messages +class _LIBCPP_TYPE_VIS messages : public locale::facet, public messages_base { @@ -3842,7 +3842,7 @@ _LIBCPP_EXTERN_TEMPLATE(class messages) _LIBCPP_EXTERN_TEMPLATE(class messages) template -class _LIBCPP_VISIBLE messages_byname +class _LIBCPP_TYPE_VIS messages_byname : public messages<_CharT> { public: @@ -3868,7 +3868,7 @@ _LIBCPP_EXTERN_TEMPLATE(class messages_byname) template, class _Byte_alloc = allocator > -class _LIBCPP_VISIBLE wstring_convert +class _LIBCPP_TYPE_VIS wstring_convert { public: typedef basic_string, _Byte_alloc> byte_string; @@ -4121,7 +4121,7 @@ wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>:: } template > -class _LIBCPP_VISIBLE wbuffer_convert +class _LIBCPP_TYPE_VIS wbuffer_convert : public basic_streambuf<_Elem, _Tr> { public: diff --git a/libcxx/include/map b/libcxx/include/map index dd98da5..abc07a3 100644 --- a/libcxx/include/map +++ b/libcxx/include/map @@ -537,7 +537,7 @@ template template class __map_const_iterator; template -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 friend class _LIBCPP_VISIBLE map; - template friend class _LIBCPP_VISIBLE multimap; - template friend class _LIBCPP_VISIBLE __map_const_iterator; + template friend class _LIBCPP_TYPE_VIS map; + template friend class _LIBCPP_TYPE_VIS multimap; + template friend class _LIBCPP_TYPE_VIS __map_const_iterator; }; template -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 friend class _LIBCPP_VISIBLE map; - template friend class _LIBCPP_VISIBLE multimap; - template friend class _LIBCPP_VISIBLE __tree_const_iterator; + template friend class _LIBCPP_TYPE_VIS map; + template friend class _LIBCPP_TYPE_VIS multimap; + template friend class _LIBCPP_TYPE_VIS __tree_const_iterator; }; template , class _Allocator = allocator > > -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 { friend class map; @@ -1422,7 +1422,7 @@ swap(map<_Key, _Tp, _Compare, _Allocator>& __x, template , class _Allocator = allocator > > -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 { friend class multimap; diff --git a/libcxx/include/memory b/libcxx/include/memory index 4e1f704..fe35238 100644 --- a/libcxx/include/memory +++ b/libcxx/include/memory @@ -667,7 +667,7 @@ addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT template class allocator; template <> -class _LIBCPP_VISIBLE allocator +class _LIBCPP_TYPE_VIS allocator { public: typedef void* pointer; @@ -678,7 +678,7 @@ public: }; template <> -class _LIBCPP_VISIBLE allocator +class _LIBCPP_TYPE_VIS allocator { 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 -struct _LIBCPP_VISIBLE pointer_traits +struct _LIBCPP_TYPE_VIS pointer_traits { typedef _Ptr pointer; typedef typename __pointer_traits_element_type::type element_type; @@ -936,7 +936,7 @@ public: }; template -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 -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 _LIBCPP_VISIBLE allocator +class _LIBCPP_TYPE_VIS allocator { public: typedef size_t size_type; @@ -1741,7 +1741,7 @@ public: }; template -class _LIBCPP_VISIBLE allocator +class _LIBCPP_TYPE_VIS allocator { 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 _LIBCPP_VISIBLE raw_storage_iterator +class _LIBCPP_TYPE_VIS raw_storage_iterator : public iterator -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 +class _LIBCPP_TYPE_VIS auto_ptr { public: typedef void element_type; @@ -2472,7 +2472,7 @@ struct __same_or_less_cv_qualified<_Ptr1, _Ptr2, true> // default_delete template -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 -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 _LIBCPP_VISIBLE unique_ptr +class _LIBCPP_TYPE_VIS unique_ptr { public: typedef _Tp element_type; @@ -2691,7 +2691,7 @@ public: }; template -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 -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 -struct _LIBCPP_VISIBLE hash > +struct _LIBCPP_TYPE_VIS hash > { 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 _LIBCPP_VISIBLE weak_ptr; +template 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 _LIBCPP_VISIBLE enable_shared_from_this; +template class _LIBCPP_TYPE_VIS enable_shared_from_this; template -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 friend class _LIBCPP_VISIBLE shared_ptr; - template friend class _LIBCPP_VISIBLE weak_ptr; + template friend class _LIBCPP_TYPE_VIS shared_ptr; + template friend class _LIBCPP_TYPE_VIS weak_ptr; }; template @@ -4921,7 +4921,7 @@ get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT #endif // _LIBCPP_NO_RTTI template -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 friend class _LIBCPP_VISIBLE weak_ptr; - template friend class _LIBCPP_VISIBLE shared_ptr; + template friend class _LIBCPP_TYPE_VIS weak_ptr; + template friend class _LIBCPP_TYPE_VIS shared_ptr; }; template @@ -5197,7 +5197,7 @@ weak_ptr<_Tp>::lock() const _NOEXCEPT template struct owner_less; template -struct _LIBCPP_VISIBLE owner_less > +struct _LIBCPP_TYPE_VIS owner_less > : binary_function, shared_ptr<_Tp>, bool> { typedef bool result_type; @@ -5213,7 +5213,7 @@ struct _LIBCPP_VISIBLE owner_less > }; template -struct _LIBCPP_VISIBLE owner_less > +struct _LIBCPP_TYPE_VIS owner_less > : binary_function, weak_ptr<_Tp>, bool> { typedef bool result_type; @@ -5229,7 +5229,7 @@ struct _LIBCPP_VISIBLE owner_less > }; template -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 -struct _LIBCPP_VISIBLE hash > +struct _LIBCPP_TYPE_VIS hash > { 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 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/libcxx/include/mutex b/libcxx/include/mutex index ee20f02..e2b5d6b 100644 --- a/libcxx/include/mutex +++ b/libcxx/include/mutex @@ -187,7 +187,7 @@ template _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/libcxx/include/new b/libcxx/include/new index ae0951a..1e85798 100644 --- a/libcxx/include/new +++ b/libcxx/include/new @@ -83,31 +83,31 @@ public: void __throw_bad_alloc(); // not in C++ spec -struct _LIBCPP_VISIBLE nothrow_t {}; -extern _LIBCPP_VISIBLE const nothrow_t nothrow; +struct _LIBCPP_TYPE_VIS nothrow_t {}; +extern _LIBCPP_FUNC_VIS const nothrow_t nothrow; typedef void (*new_handler)(); -_LIBCPP_VISIBLE new_handler set_new_handler(new_handler) _NOEXCEPT; -_LIBCPP_VISIBLE new_handler get_new_handler() _NOEXCEPT; +_LIBCPP_FUNC_VIS new_handler set_new_handler(new_handler) _NOEXCEPT; +_LIBCPP_FUNC_VIS new_handler get_new_handler() _NOEXCEPT; } // std -_LIBCPP_VISIBLE void* operator new(std::size_t __sz) +_LIBCPP_FUNC_VIS void* operator new(std::size_t __sz) #if !__has_feature(cxx_noexcept) throw(std::bad_alloc) #endif ; -_LIBCPP_VISIBLE void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS; -_LIBCPP_VISIBLE void operator delete(void* __p) _NOEXCEPT; -_LIBCPP_VISIBLE void operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT; +_LIBCPP_FUNC_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS; +_LIBCPP_FUNC_VIS void operator delete(void* __p) _NOEXCEPT; +_LIBCPP_FUNC_VIS void operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT; -_LIBCPP_VISIBLE void* operator new[](std::size_t __sz) +_LIBCPP_FUNC_VIS void* operator new[](std::size_t __sz) #if !__has_feature(cxx_noexcept) throw(std::bad_alloc) #endif ; -_LIBCPP_VISIBLE void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS; -_LIBCPP_VISIBLE void operator delete[](void* __p) _NOEXCEPT; -_LIBCPP_VISIBLE void operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT; +_LIBCPP_FUNC_VIS void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS; +_LIBCPP_FUNC_VIS void operator delete[](void* __p) _NOEXCEPT; +_LIBCPP_FUNC_VIS void operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY inline void* operator new (std::size_t, void* __p) _NOEXCEPT {return __p;} _LIBCPP_INLINE_VISIBILITY inline void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;} diff --git a/libcxx/include/ostream b/libcxx/include/ostream index b3b6df5..eac9c8f 100644 --- a/libcxx/include/ostream +++ b/libcxx/include/ostream @@ -140,7 +140,7 @@ template _LIBCPP_BEGIN_NAMESPACE_STD template -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 _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/libcxx/include/queue b/libcxx/include/queue index 4741f00..8d1a9df 100644 --- a/libcxx/include/queue +++ b/libcxx/include/queue @@ -177,7 +177,7 @@ template _LIBCPP_BEGIN_NAMESPACE_STD -template class _LIBCPP_VISIBLE queue; +template class _LIBCPP_TYPE_VIS queue; template _LIBCPP_INLINE_VISIBILITY @@ -190,7 +190,7 @@ bool operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y); template > -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 -struct _LIBCPP_VISIBLE uses_allocator, _Alloc> +struct _LIBCPP_TYPE_VIS uses_allocator, _Alloc> : public uses_allocator<_Container, _Alloc> { }; template , class _Compare = less > -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 -struct _LIBCPP_VISIBLE uses_allocator, _Alloc> +struct _LIBCPP_TYPE_VIS uses_allocator, _Alloc> : public uses_allocator<_Container, _Alloc> { }; diff --git a/libcxx/include/random b/libcxx/include/random index 04d942b..92722ea 100644 --- a/libcxx/include/random +++ b/libcxx/include/random @@ -1813,7 +1813,7 @@ struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b> }; template -class _LIBCPP_VISIBLE linear_congruential_engine; +class _LIBCPP_TYPE_VIS linear_congruential_engine; template @@ -1829,7 +1829,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x); template -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 _LIBCPP_VISIBLE mersenne_twister_engine; +class _LIBCPP_TYPE_VIS mersenne_twister_engine; template >(basic_istream<_CharT, _Traits>& __is, template -class _LIBCPP_VISIBLE mersenne_twister_engine +class _LIBCPP_TYPE_VIS mersenne_twister_engine { public: // types @@ -2526,7 +2526,7 @@ typedef mersenne_twister_engine -class _LIBCPP_VISIBLE subtract_with_carry_engine; +class _LIBCPP_TYPE_VIS subtract_with_carry_engine; template bool @@ -2554,7 +2554,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is, subtract_with_carry_engine<_UI, _Wp, _Sp, _Rp>& __x); template -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 ranlux48_base; // discard_block_engine template -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; // independent_bits_engine template -class _LIBCPP_VISIBLE independent_bits_engine +class _LIBCPP_TYPE_VIS independent_bits_engine { template class __get_n @@ -3273,7 +3273,7 @@ public: }; template -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 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 _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 _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 _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 _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 _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 __nd_; public: @@ -4514,13 +4514,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // poisson_distribution template -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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 __p_; public: @@ -6084,13 +6084,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // piecewise_constant_distribution template -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 __b_; vector __densities_; @@ -6408,13 +6408,13 @@ operator>>(basic_istream<_CharT, _Traits>& __is, // piecewise_linear_distribution template -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 __b_; vector __densities_; diff --git a/libcxx/include/ratio b/libcxx/include/ratio index 23f2267..f4e741e 100644 --- a/libcxx/include/ratio +++ b/libcxx/include/ratio @@ -231,7 +231,7 @@ public: }; template -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 using ratio_multiply #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES template -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 using ratio_divide #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES template -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 using ratio_add #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES template -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 using ratio_subtract #else // _LIBCPP_HAS_NO_TEMPLATE_ALIASES template -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 -struct _LIBCPP_VISIBLE ratio_equal +struct _LIBCPP_TYPE_VIS ratio_equal : public integral_constant {}; template -struct _LIBCPP_VISIBLE ratio_not_equal +struct _LIBCPP_TYPE_VIS ratio_not_equal : public integral_constant::value> {}; // ratio_less @@ -460,19 +460,19 @@ struct __ratio_less<_R1, _R2, -1LL, -1LL> }; template -struct _LIBCPP_VISIBLE ratio_less +struct _LIBCPP_TYPE_VIS ratio_less : public integral_constant::value> {}; template -struct _LIBCPP_VISIBLE ratio_less_equal +struct _LIBCPP_TYPE_VIS ratio_less_equal : public integral_constant::value> {}; template -struct _LIBCPP_VISIBLE ratio_greater +struct _LIBCPP_TYPE_VIS ratio_greater : public integral_constant::value> {}; template -struct _LIBCPP_VISIBLE ratio_greater_equal +struct _LIBCPP_TYPE_VIS ratio_greater_equal : public integral_constant::value> {}; template diff --git a/libcxx/include/regex b/libcxx/include/regex index 982500f..efd91ee 100644 --- a/libcxx/include/regex +++ b/libcxx/include/regex @@ -925,7 +925,7 @@ public: }; template -struct _LIBCPP_VISIBLE regex_traits +struct _LIBCPP_TYPE_VIS regex_traits { public: typedef _CharT char_type; @@ -1231,11 +1231,11 @@ regex_traits<_CharT>::__value(wchar_t __ch, int __radix) const template class __node; -template class _LIBCPP_VISIBLE sub_match; +template class _LIBCPP_TYPE_VIS sub_match; template > > -class _LIBCPP_VISIBLE match_results; +class _LIBCPP_TYPE_VIS match_results; template struct __state @@ -2411,7 +2411,7 @@ __exit: template class __lookahead; template > -class _LIBCPP_VISIBLE basic_regex +class _LIBCPP_TYPE_VIS basic_regex { public: // types: @@ -4749,7 +4749,7 @@ typedef basic_regex wregex; // sub_match template -class _LIBCPP_VISIBLE sub_match +class _LIBCPP_TYPE_VIS sub_match : public pair<_BidirectionalIterator, _BidirectionalIterator> { public: @@ -5172,7 +5172,7 @@ operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m) } template -class _LIBCPP_VISIBLE match_results +class _LIBCPP_TYPE_VIS match_results { public: typedef _Allocator allocator_type; @@ -5958,7 +5958,7 @@ regex_match(const basic_string<_CharT, _ST, _SA>& __s, template ::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 +6070,7 @@ typedef regex_iterator wsregex_iterator; template ::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/libcxx/include/scoped_allocator b/libcxx/include/scoped_allocator index cd05102..9253234 100644 --- a/libcxx/include/scoped_allocator +++ b/libcxx/include/scoped_allocator @@ -365,7 +365,7 @@ struct __outermost<_Alloc, true> }; template -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/libcxx/include/set b/libcxx/include/set index 36d3dd4..11ea965 100644 --- a/libcxx/include/set +++ b/libcxx/include/set @@ -346,7 +346,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD template , 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 _Allocator = allocator<_Key> > -class _LIBCPP_VISIBLE multiset +class _LIBCPP_TYPE_VIS multiset { public: // types: diff --git a/libcxx/include/sstream b/libcxx/include/sstream index 22450f0..c431fec 100644 --- a/libcxx/include/sstream +++ b/libcxx/include/sstream @@ -186,7 +186,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD // basic_stringbuf template -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 _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 _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 _LIBCPP_VISIBLE basic_stringstream +class _LIBCPP_TYPE_VIS basic_stringstream : public basic_iostream<_CharT, _Traits> { public: diff --git a/libcxx/include/stack b/libcxx/include/stack index 12fb35b..b8a7f4c 100644 --- a/libcxx/include/stack +++ b/libcxx/include/stack @@ -91,7 +91,7 @@ template _LIBCPP_BEGIN_NAMESPACE_STD -template class _LIBCPP_VISIBLE stack; +template class _LIBCPP_TYPE_VIS stack; template _LIBCPP_INLINE_VISIBILITY @@ -104,7 +104,7 @@ bool operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y); template > -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 -struct _LIBCPP_VISIBLE uses_allocator, _Alloc> +struct _LIBCPP_TYPE_VIS uses_allocator, _Alloc> : public uses_allocator<_Container, _Alloc> { }; diff --git a/libcxx/include/streambuf b/libcxx/include/streambuf index d688024..8261594 100644 --- a/libcxx/include/streambuf +++ b/libcxx/include/streambuf @@ -119,7 +119,7 @@ protected: _LIBCPP_BEGIN_NAMESPACE_STD template -class _LIBCPP_VISIBLE basic_streambuf +class _LIBCPP_TYPE_VIS basic_streambuf { public: // types: diff --git a/libcxx/include/string b/libcxx/include/string index 1a70467..de668bb 100644 --- a/libcxx/include/string +++ b/libcxx/include/string @@ -457,7 +457,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD // fpos template -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 -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 template <> -struct _LIBCPP_VISIBLE char_traits +struct _LIBCPP_TYPE_VIS char_traits { typedef char char_type; typedef int int_type; @@ -676,7 +676,7 @@ struct _LIBCPP_VISIBLE char_traits // char_traits template <> -struct _LIBCPP_VISIBLE char_traits +struct _LIBCPP_TYPE_VIS char_traits { typedef wchar_t char_type; typedef wint_t int_type; @@ -733,7 +733,7 @@ struct _LIBCPP_VISIBLE char_traits #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS template <> -struct _LIBCPP_VISIBLE char_traits +struct _LIBCPP_TYPE_VIS char_traits { typedef char16_t char_type; typedef uint_least16_t int_type; @@ -853,7 +853,7 @@ char_traits::assign(char_type* __s, size_t __n, char_type __a) } template <> -struct _LIBCPP_VISIBLE char_traits +struct _LIBCPP_TYPE_VIS char_traits { typedef char32_t char_type; typedef uint_least32_t int_type; @@ -1037,7 +1037,7 @@ _LIBCPP_EXTERN_TEMPLATE(class __basic_string_common) #endif // _MSC_VER template -class _LIBCPP_VISIBLE basic_string +class _LIBCPP_TYPE_VIS basic_string : private __basic_string_common { public: @@ -3923,7 +3923,7 @@ size_t _LIBCPP_INLINE_VISIBILITY __do_string_hash(_Ptr __p, _Ptr __e) } template -struct _LIBCPP_VISIBLE hash > +struct _LIBCPP_TYPE_VIS hash > : public unary_function, size_t> { size_t diff --git a/libcxx/include/strstream b/libcxx/include/strstream index 5eadefd..81eef2a 100644 --- a/libcxx/include/strstream +++ b/libcxx/include/strstream @@ -137,7 +137,7 @@ private: _LIBCPP_BEGIN_NAMESPACE_STD -class _LIBCPP_VISIBLE strstreambuf +class _LIBCPP_TYPE_VIS strstreambuf : public streambuf { public: @@ -228,7 +228,7 @@ strstreambuf::operator=(strstreambuf&& __rhs) #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES -class _LIBCPP_VISIBLE istrstream +class _LIBCPP_TYPE_VIS istrstream : public istream { public: @@ -281,7 +281,7 @@ private: strstreambuf __sb_; }; -class _LIBCPP_VISIBLE ostrstream +class _LIBCPP_TYPE_VIS ostrstream : public ostream { public: @@ -334,7 +334,7 @@ private: strstreambuf __sb_; // exposition only }; -class _LIBCPP_VISIBLE strstream +class _LIBCPP_TYPE_VIS strstream : public iostream { public: diff --git a/libcxx/include/system_error b/libcxx/include/system_error index cbc52fb..1c1c7eb 100644 --- a/libcxx/include/system_error +++ b/libcxx/include/system_error @@ -232,13 +232,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD // is_error_code_enum template -struct _LIBCPP_VISIBLE is_error_code_enum +struct _LIBCPP_TYPE_VIS is_error_code_enum : public false_type {}; // is_error_condition_enum template -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 +struct _LIBCPP_TYPE_VIS is_error_condition_enum : true_type { }; #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS template <> -struct _LIBCPP_VISIBLE is_error_condition_enum +struct _LIBCPP_TYPE_VIS is_error_condition_enum : 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 +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY @@ -609,7 +609,7 @@ struct _LIBCPP_VISIBLE hash // system_error -class _LIBCPP_VISIBLE system_error +class _LIBCPP_TYPE_VIS system_error : public runtime_error { error_code __ec_; diff --git a/libcxx/include/thread b/libcxx/include/thread index 60d8885..e21a09f 100644 --- a/libcxx/include/thread +++ b/libcxx/include/thread @@ -173,8 +173,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 +183,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 +228,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 +255,7 @@ get_id() _NOEXCEPT } // this_thread -class _LIBCPP_VISIBLE thread +class _LIBCPP_TYPE_VIS thread { pthread_t __t_; diff --git a/libcxx/include/tuple b/libcxx/include/tuple index 3fa6730..7f299e9 100644 --- a/libcxx/include/tuple +++ b/libcxx/include/tuple @@ -128,7 +128,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD // allocator_arg_t -struct _LIBCPP_VISIBLE allocator_arg_t { }; +struct _LIBCPP_TYPE_VIS allocator_arg_t { }; #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MEMORY) extern const allocator_arg_t allocator_arg; @@ -163,7 +163,7 @@ struct __uses_allocator<_Tp, _Alloc, false> }; template -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 _LIBCPP_VISIBLE tuple_size > +class _LIBCPP_TYPE_VIS tuple_size > : public integral_constant { }; @@ -201,7 +201,7 @@ class _LIBCPP_VISIBLE tuple_size > // tuple_element template -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 _LIBCPP_VISIBLE tuple +class _LIBCPP_TYPE_VIS tuple { typedef __tuple_impl::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 ignore = __ignore_t(); } -template class _LIBCPP_VISIBLE reference_wrapper; +template class _LIBCPP_TYPE_VIS reference_wrapper; template struct ___make_tuple_return @@ -1071,7 +1071,7 @@ tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls) } template -struct _LIBCPP_VISIBLE uses_allocator, _Alloc> +struct _LIBCPP_TYPE_VIS uses_allocator, _Alloc> : true_type {}; template diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits index 8f1c602..f60f71b 100644 --- a/libcxx/include/type_traits +++ b/libcxx/include/type_traits @@ -149,19 +149,19 @@ namespace std _LIBCPP_BEGIN_NAMESPACE_STD template - struct _LIBCPP_VISIBLE conditional {typedef _If type;}; + struct _LIBCPP_TYPE_VIS conditional {typedef _If type;}; template - struct _LIBCPP_VISIBLE conditional {typedef _Then type;}; + struct _LIBCPP_TYPE_VIS conditional {typedef _Then type;}; -template struct _LIBCPP_VISIBLE enable_if {}; -template struct _LIBCPP_VISIBLE enable_if {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS enable_if {}; +template struct _LIBCPP_TYPE_VIS enable_if {typedef _Tp type;}; struct __two {char __lx[2];}; // helper class: template -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 false_type; // is_const -template struct _LIBCPP_VISIBLE is_const : public false_type {}; -template struct _LIBCPP_VISIBLE is_const<_Tp const> : public true_type {}; +template struct _LIBCPP_TYPE_VIS is_const : public false_type {}; +template struct _LIBCPP_TYPE_VIS is_const<_Tp const> : public true_type {}; // is_volatile -template struct _LIBCPP_VISIBLE is_volatile : public false_type {}; -template struct _LIBCPP_VISIBLE is_volatile<_Tp volatile> : public true_type {}; +template struct _LIBCPP_TYPE_VIS is_volatile : public false_type {}; +template struct _LIBCPP_TYPE_VIS is_volatile<_Tp volatile> : public true_type {}; // remove_const -template struct _LIBCPP_VISIBLE remove_const {typedef _Tp type;}; -template struct _LIBCPP_VISIBLE remove_const {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_const {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_const {typedef _Tp type;}; // remove_volatile -template struct _LIBCPP_VISIBLE remove_volatile {typedef _Tp type;}; -template struct _LIBCPP_VISIBLE remove_volatile {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_volatile {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_volatile {typedef _Tp type;}; // remove_cv -template struct _LIBCPP_VISIBLE remove_cv +template struct _LIBCPP_TYPE_VIS remove_cv {typedef typename remove_volatile::type>::type type;}; // is_void @@ -206,7 +206,7 @@ template struct _LIBCPP_VISIBLE remove_cv template struct __is_void : public false_type {}; template <> struct __is_void : public true_type {}; -template struct _LIBCPP_VISIBLE is_void +template struct _LIBCPP_TYPE_VIS is_void : public __is_void::type> {}; // __is_nullptr_t @@ -214,7 +214,7 @@ template struct _LIBCPP_VISIBLE is_void template struct ____is_nullptr_t : public false_type {}; template <> struct ____is_nullptr_t : public true_type {}; -template struct _LIBCPP_VISIBLE __is_nullptr_t +template struct _LIBCPP_TYPE_VIS __is_nullptr_t : public ____is_nullptr_t::type> {}; // is_integral @@ -238,7 +238,7 @@ template <> struct __is_integral : public true_type template <> struct __is_integral : public true_type {}; template <> struct __is_integral : public true_type {}; -template struct _LIBCPP_VISIBLE is_integral +template struct _LIBCPP_TYPE_VIS is_integral : public __is_integral::type> {}; // is_floating_point @@ -248,16 +248,16 @@ template <> struct __is_floating_point : public true_type template <> struct __is_floating_point : public true_type {}; template <> struct __is_floating_point : public true_type {}; -template struct _LIBCPP_VISIBLE is_floating_point +template struct _LIBCPP_TYPE_VIS is_floating_point : public __is_floating_point::type> {}; // is_array -template struct _LIBCPP_VISIBLE is_array +template struct _LIBCPP_TYPE_VIS is_array : public false_type {}; -template struct _LIBCPP_VISIBLE is_array<_Tp[]> +template struct _LIBCPP_TYPE_VIS is_array<_Tp[]> : public true_type {}; -template struct _LIBCPP_VISIBLE is_array<_Tp[_Np]> +template struct _LIBCPP_TYPE_VIS is_array<_Tp[_Np]> : public true_type {}; // is_pointer @@ -265,23 +265,23 @@ template struct _LIBCPP_VISIBLE is_array<_Tp[_Np]> template struct __is_pointer : public false_type {}; template struct __is_pointer<_Tp*> : public true_type {}; -template struct _LIBCPP_VISIBLE is_pointer +template struct _LIBCPP_TYPE_VIS is_pointer : public __is_pointer::type> {}; // is_reference -template struct _LIBCPP_VISIBLE is_lvalue_reference : public false_type {}; -template struct _LIBCPP_VISIBLE is_lvalue_reference<_Tp&> : public true_type {}; +template struct _LIBCPP_TYPE_VIS is_lvalue_reference : public false_type {}; +template struct _LIBCPP_TYPE_VIS is_lvalue_reference<_Tp&> : public true_type {}; -template struct _LIBCPP_VISIBLE is_rvalue_reference : public false_type {}; +template struct _LIBCPP_TYPE_VIS is_rvalue_reference : public false_type {}; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template struct _LIBCPP_VISIBLE is_rvalue_reference<_Tp&&> : public true_type {}; +template struct _LIBCPP_TYPE_VIS is_rvalue_reference<_Tp&&> : public true_type {}; #endif -template struct _LIBCPP_VISIBLE is_reference : public false_type {}; -template struct _LIBCPP_VISIBLE is_reference<_Tp&> : public true_type {}; +template struct _LIBCPP_TYPE_VIS is_reference : public false_type {}; +template struct _LIBCPP_TYPE_VIS is_reference<_Tp&> : public true_type {}; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template struct _LIBCPP_VISIBLE is_reference<_Tp&&> : public true_type {}; +template 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 struct _LIBCPP_VISIBLE is_reference<_Tp&&> : public true_ty #if __has_feature(is_union) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template struct _LIBCPP_VISIBLE is_union +template struct _LIBCPP_TYPE_VIS is_union : public integral_constant {}; #else template struct __libcpp_union : public false_type {}; -template struct _LIBCPP_VISIBLE is_union +template struct _LIBCPP_TYPE_VIS is_union : public __libcpp_union::type> {}; #endif @@ -307,7 +307,7 @@ template struct _LIBCPP_VISIBLE is_union #if __has_feature(is_class) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template struct _LIBCPP_VISIBLE is_class +template struct _LIBCPP_TYPE_VIS is_class : public integral_constant {}; #else @@ -318,15 +318,15 @@ template char __test(int _Tp::*); template __two __test(...); } -template struct _LIBCPP_VISIBLE is_class +template struct _LIBCPP_TYPE_VIS is_class : public integral_constant(0)) == 1 && !is_union<_Tp>::value> {}; #endif // is_same -template struct _LIBCPP_VISIBLE is_same : public false_type {}; -template struct _LIBCPP_VISIBLE is_same<_Tp, _Tp> : public true_type {}; +template struct _LIBCPP_TYPE_VIS is_same : public false_type {}; +template struct _LIBCPP_TYPE_VIS is_same<_Tp, _Tp> : public true_type {}; // is_function @@ -347,7 +347,7 @@ struct __is_function {}; template struct __is_function<_Tp, true> : public false_type {}; -template struct _LIBCPP_VISIBLE is_function +template struct _LIBCPP_TYPE_VIS is_function : public __is_function<_Tp> {}; // is_member_function_pointer @@ -355,7 +355,7 @@ template struct _LIBCPP_VISIBLE is_function template struct __is_member_function_pointer : public false_type {}; template struct __is_member_function_pointer<_Tp _Up::*> : public is_function<_Tp> {}; -template struct _LIBCPP_VISIBLE is_member_function_pointer +template struct _LIBCPP_TYPE_VIS is_member_function_pointer : public __is_member_function_pointer::type> {}; // is_member_pointer @@ -363,12 +363,12 @@ template struct _LIBCPP_VISIBLE is_member_function_pointer template struct __is_member_pointer : public false_type {}; template struct __is_member_pointer<_Tp _Up::*> : public true_type {}; -template struct _LIBCPP_VISIBLE is_member_pointer +template struct _LIBCPP_TYPE_VIS is_member_pointer : public __is_member_pointer::type> {}; // is_member_object_pointer -template struct _LIBCPP_VISIBLE is_member_object_pointer +template struct _LIBCPP_TYPE_VIS is_member_object_pointer : public integral_constant::value && !is_member_function_pointer<_Tp>::value> {}; @@ -376,12 +376,12 @@ template struct _LIBCPP_VISIBLE is_member_object_pointer #if __has_feature(is_enum) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template struct _LIBCPP_VISIBLE is_enum +template struct _LIBCPP_TYPE_VIS is_enum : public integral_constant {}; #else -template struct _LIBCPP_VISIBLE is_enum +template struct _LIBCPP_TYPE_VIS is_enum : public integral_constant::value && !is_integral<_Tp>::value && !is_floating_point<_Tp>::value && @@ -397,31 +397,31 @@ template struct _LIBCPP_VISIBLE is_enum // is_arithmetic -template struct _LIBCPP_VISIBLE is_arithmetic +template struct _LIBCPP_TYPE_VIS is_arithmetic : public integral_constant::value || is_floating_point<_Tp>::value> {}; // is_fundamental -template struct _LIBCPP_VISIBLE is_fundamental +template struct _LIBCPP_TYPE_VIS is_fundamental : public integral_constant::value || __is_nullptr_t<_Tp>::value || is_arithmetic<_Tp>::value> {}; // is_scalar -template struct _LIBCPP_VISIBLE is_scalar +template struct _LIBCPP_TYPE_VIS is_scalar : public integral_constant::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 : public true_type {}; +template <> struct _LIBCPP_TYPE_VIS is_scalar : public true_type {}; // is_object -template struct _LIBCPP_VISIBLE is_object +template struct _LIBCPP_TYPE_VIS is_object : public integral_constant::value || is_array<_Tp>::value || is_union<_Tp>::value || @@ -429,7 +429,7 @@ template struct _LIBCPP_VISIBLE is_object // is_compound -template struct _LIBCPP_VISIBLE is_compound +template struct _LIBCPP_TYPE_VIS is_compound : public integral_constant::value> {}; // add_const @@ -442,7 +442,7 @@ struct __add_const {typedef _Tp type;}; template struct __add_const<_Tp, false> {typedef const _Tp type;}; -template struct _LIBCPP_VISIBLE add_const +template 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 struct __add_volatile<_Tp, false> {typedef volatile _Tp type;}; -template struct _LIBCPP_VISIBLE add_volatile +template struct _LIBCPP_TYPE_VIS add_volatile {typedef typename __add_volatile<_Tp>::type type;}; // add_cv -template struct _LIBCPP_VISIBLE add_cv +template struct _LIBCPP_TYPE_VIS add_cv {typedef typename add_const::type>::type type;}; // remove_reference -template struct _LIBCPP_VISIBLE remove_reference {typedef _Tp type;}; -template struct _LIBCPP_VISIBLE remove_reference<_Tp&> {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_reference {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_reference<_Tp&> {typedef _Tp type;}; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template struct _LIBCPP_VISIBLE remove_reference<_Tp&&> {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_reference<_Tp&&> {typedef _Tp type;}; #endif // add_lvalue_reference -template struct _LIBCPP_VISIBLE add_lvalue_reference {typedef _Tp& type;}; -template struct _LIBCPP_VISIBLE add_lvalue_reference<_Tp&> {typedef _Tp& type;}; // for older compiler -template <> struct _LIBCPP_VISIBLE add_lvalue_reference {typedef void type;}; -template <> struct _LIBCPP_VISIBLE add_lvalue_reference {typedef const void type;}; -template <> struct _LIBCPP_VISIBLE add_lvalue_reference {typedef volatile void type;}; -template <> struct _LIBCPP_VISIBLE add_lvalue_reference {typedef const volatile void type;}; +template struct _LIBCPP_TYPE_VIS add_lvalue_reference {typedef _Tp& type;}; +template struct _LIBCPP_TYPE_VIS add_lvalue_reference<_Tp&> {typedef _Tp& type;}; // for older compiler +template <> struct _LIBCPP_TYPE_VIS add_lvalue_reference {typedef void type;}; +template <> struct _LIBCPP_TYPE_VIS add_lvalue_reference {typedef const void type;}; +template <> struct _LIBCPP_TYPE_VIS add_lvalue_reference {typedef volatile void type;}; +template <> struct _LIBCPP_TYPE_VIS add_lvalue_reference {typedef const volatile void type;}; #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES -template struct _LIBCPP_VISIBLE add_rvalue_reference {typedef _Tp&& type;}; -template <> struct _LIBCPP_VISIBLE add_rvalue_reference {typedef void type;}; -template <> struct _LIBCPP_VISIBLE add_rvalue_reference {typedef const void type;}; -template <> struct _LIBCPP_VISIBLE add_rvalue_reference {typedef volatile void type;}; -template <> struct _LIBCPP_VISIBLE add_rvalue_reference {typedef const volatile void type;}; +template struct _LIBCPP_TYPE_VIS add_rvalue_reference {typedef _Tp&& type;}; +template <> struct _LIBCPP_TYPE_VIS add_rvalue_reference {typedef void type;}; +template <> struct _LIBCPP_TYPE_VIS add_rvalue_reference {typedef const void type;}; +template <> struct _LIBCPP_TYPE_VIS add_rvalue_reference {typedef volatile void type;}; +template <> struct _LIBCPP_TYPE_VIS add_rvalue_reference {typedef const volatile void type;}; #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -511,15 +511,15 @@ struct __any // remove_pointer -template struct _LIBCPP_VISIBLE remove_pointer {typedef _Tp type;}; -template struct _LIBCPP_VISIBLE remove_pointer<_Tp*> {typedef _Tp type;}; -template struct _LIBCPP_VISIBLE remove_pointer<_Tp* const> {typedef _Tp type;}; -template struct _LIBCPP_VISIBLE remove_pointer<_Tp* volatile> {typedef _Tp type;}; -template struct _LIBCPP_VISIBLE remove_pointer<_Tp* const volatile> {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_pointer {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_pointer<_Tp*> {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* const> {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* volatile> {typedef _Tp type;}; +template struct _LIBCPP_TYPE_VIS remove_pointer<_Tp* const volatile> {typedef _Tp type;}; // add_pointer -template struct _LIBCPP_VISIBLE add_pointer +template 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 struct __is_signed<_Tp, false> : public false_type {}; -template struct _LIBCPP_VISIBLE is_signed : public __is_signed<_Tp> {}; +template struct _LIBCPP_TYPE_VIS is_signed : public __is_signed<_Tp> {}; // is_unsigned @@ -550,46 +550,46 @@ struct __is_unsigned : public ___is_unsigned<_Tp> {}; template struct __is_unsigned<_Tp, false> : public false_type {}; -template struct _LIBCPP_VISIBLE is_unsigned : public __is_unsigned<_Tp> {}; +template struct _LIBCPP_TYPE_VIS is_unsigned : public __is_unsigned<_Tp> {}; // rank -template struct _LIBCPP_VISIBLE rank +template struct _LIBCPP_TYPE_VIS rank : public integral_constant {}; -template struct _LIBCPP_VISIBLE rank<_Tp[]> +template struct _LIBCPP_TYPE_VIS rank<_Tp[]> : public integral_constant::value + 1> {}; -template struct _LIBCPP_VISIBLE rank<_Tp[_Np]> +template struct _LIBCPP_TYPE_VIS rank<_Tp[_Np]> : public integral_constant::value + 1> {}; // extent -template struct _LIBCPP_VISIBLE extent +template struct _LIBCPP_TYPE_VIS extent : public integral_constant {}; -template struct _LIBCPP_VISIBLE extent<_Tp[], 0> +template struct _LIBCPP_TYPE_VIS extent<_Tp[], 0> : public integral_constant {}; -template struct _LIBCPP_VISIBLE extent<_Tp[], _Ip> +template struct _LIBCPP_TYPE_VIS extent<_Tp[], _Ip> : public integral_constant::value> {}; -template struct _LIBCPP_VISIBLE extent<_Tp[_Np], 0> +template struct _LIBCPP_TYPE_VIS extent<_Tp[_Np], 0> : public integral_constant {}; -template struct _LIBCPP_VISIBLE extent<_Tp[_Np], _Ip> +template struct _LIBCPP_TYPE_VIS extent<_Tp[_Np], _Ip> : public integral_constant::value> {}; // remove_extent -template struct _LIBCPP_VISIBLE remove_extent +template struct _LIBCPP_TYPE_VIS remove_extent {typedef _Tp type;}; -template struct _LIBCPP_VISIBLE remove_extent<_Tp[]> +template struct _LIBCPP_TYPE_VIS remove_extent<_Tp[]> {typedef _Tp type;}; -template struct _LIBCPP_VISIBLE remove_extent<_Tp[_Np]> +template struct _LIBCPP_TYPE_VIS remove_extent<_Tp[_Np]> {typedef _Tp type;}; // remove_all_extents -template struct _LIBCPP_VISIBLE remove_all_extents +template struct _LIBCPP_TYPE_VIS remove_all_extents {typedef _Tp type;}; -template struct _LIBCPP_VISIBLE remove_all_extents<_Tp[]> +template struct _LIBCPP_TYPE_VIS remove_all_extents<_Tp[]> {typedef typename remove_all_extents<_Tp>::type type;}; -template struct _LIBCPP_VISIBLE remove_all_extents<_Tp[_Np]> +template 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 struct __libcpp_abstract<_Tp, false> : public false_type {}; -template struct _LIBCPP_VISIBLE is_abstract : public __libcpp_abstract<_Tp> {}; +template struct _LIBCPP_TYPE_VIS is_abstract : public __libcpp_abstract<_Tp> {}; // is_base_of #ifdef _LIBCP_HAS_IS_BASE_OF template -struct _LIBCPP_VISIBLE is_base_of +struct _LIBCPP_TYPE_VIS is_base_of : public integral_constant {}; #else // __has_feature(is_base_of) @@ -636,7 +636,7 @@ template __two __test(...); } template -struct _LIBCPP_VISIBLE is_base_of +struct _LIBCPP_TYPE_VIS is_base_of : public integral_constant::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 struct _LIBCPP_VISIBLE is_convertible +template struct _LIBCPP_TYPE_VIS is_convertible : public integral_constant::value> {}; @@ -752,7 +752,7 @@ template struct __is_convertible<_T1, _T2, 1, 3> : public template struct __is_convertible<_T1, _T2, 2, 3> : public false_type {}; template struct __is_convertible<_T1, _T2, 3, 3> : public true_type {}; -template struct _LIBCPP_VISIBLE is_convertible +template 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 struct _LIBCPP_VISIBLE is_convertible #if __has_feature(is_empty) template -struct _LIBCPP_VISIBLE is_empty +struct _LIBCPP_TYPE_VIS is_empty : public integral_constant {}; #else // __has_feature(is_empty) @@ -788,7 +788,7 @@ struct __libcpp_empty : public integral_constant) template struct __libcpp_empty<_Tp, false> : public false_type {}; -template struct _LIBCPP_VISIBLE is_empty : public __libcpp_empty<_Tp> {}; +template struct _LIBCPP_TYPE_VIS is_empty : public __libcpp_empty<_Tp> {}; #endif // __has_feature(is_empty) @@ -797,7 +797,7 @@ template struct _LIBCPP_VISIBLE is_empty : public __libcpp_empty<_Tp #if __has_feature(is_polymorphic) template -struct _LIBCPP_VISIBLE is_polymorphic +struct _LIBCPP_TYPE_VIS is_polymorphic : public integral_constant {}; #else @@ -811,7 +811,7 @@ struct __libcpp_polymorphic template struct __libcpp_polymorphic<_Tp, false> : public false_type {}; -template struct _LIBCPP_VISIBLE is_polymorphic +template struct _LIBCPP_TYPE_VIS is_polymorphic : public __libcpp_polymorphic<_Tp> {}; #endif // __has_feature(is_polymorphic) @@ -820,12 +820,12 @@ template struct _LIBCPP_VISIBLE is_polymorphic #if __has_feature(has_virtual_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template struct _LIBCPP_VISIBLE has_virtual_destructor +template struct _LIBCPP_TYPE_VIS has_virtual_destructor : public integral_constant {}; #else // _LIBCPP_HAS_TYPE_TRAITS -template struct _LIBCPP_VISIBLE has_virtual_destructor +template struct _LIBCPP_TYPE_VIS has_virtual_destructor : public false_type {}; #endif // _LIBCPP_HAS_TYPE_TRAITS @@ -834,7 +834,7 @@ template struct _LIBCPP_VISIBLE has_virtual_destructor template struct __alignment_of {_Tp __lx;}; -template struct _LIBCPP_VISIBLE alignment_of +template struct _LIBCPP_TYPE_VIS alignment_of : public integral_constant::type>)> {}; // aligned_storage @@ -922,7 +922,7 @@ struct __find_max_align<__type_list<_Hp, _Tp>, _Len> : public integral_constant::value>::value> {}; template ::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 \ -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 {typedef long long type;}; template -struct _LIBCPP_VISIBLE make_signed +struct _LIBCPP_TYPE_VIS make_signed { typedef typename __apply_cv<_Tp, typename __make_signed::type>::type>::type type; }; @@ -1143,7 +1143,7 @@ template <> struct __make_unsigned< signed long long, true> {typedef unsigned l template <> struct __make_unsigned {typedef unsigned long long type;}; template -struct _LIBCPP_VISIBLE make_unsigned +struct _LIBCPP_TYPE_VIS make_unsigned { typedef typename __apply_cv<_Tp, typename __make_unsigned::type>::type>::type type; }; @@ -1151,21 +1151,21 @@ struct _LIBCPP_VISIBLE make_unsigned #ifdef _LIBCPP_HAS_NO_VARIADICS template -struct _LIBCPP_VISIBLE common_type +struct _LIBCPP_TYPE_VIS common_type { public: typedef typename common_type::type, V>::type type; }; template -struct _LIBCPP_VISIBLE common_type<_Tp, void, void> +struct _LIBCPP_TYPE_VIS common_type<_Tp, void, void> { public: typedef _Tp type; }; template -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 struct common_type; template -struct _LIBCPP_VISIBLE common_type<_Tp> +struct _LIBCPP_TYPE_VIS common_type<_Tp> { typedef _Tp type; }; template -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 -struct _LIBCPP_VISIBLE common_type<_Tp, _Up, _Vp...> +struct _LIBCPP_TYPE_VIS common_type<_Tp, _Up, _Vp...> { typedef typename common_type::type, _Vp...>::type type; }; @@ -1245,13 +1245,13 @@ struct is_assignable // is_copy_assignable -template struct _LIBCPP_VISIBLE is_copy_assignable +template struct _LIBCPP_TYPE_VIS is_copy_assignable : public is_assignable::type, const typename add_lvalue_reference<_Tp>::type> {}; // is_move_assignable -template struct _LIBCPP_VISIBLE is_move_assignable +template struct _LIBCPP_TYPE_VIS is_move_assignable #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES : public is_assignable::type, const typename add_rvalue_reference<_Tp>::type> {}; @@ -1366,7 +1366,7 @@ public: #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES template -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 _LIBCPP_VISIBLE result_of<_Fn()> +class _LIBCPP_TYPE_VIS result_of<_Fn()> : public __result_of<_Fn(), is_class::type>::value || is_function::type>::value, @@ -1755,7 +1755,7 @@ class _LIBCPP_VISIBLE result_of<_Fn()> }; template -class _LIBCPP_VISIBLE result_of<_Fn(_A0)> +class _LIBCPP_TYPE_VIS result_of<_Fn(_A0)> : public __result_of<_Fn(_A0), is_class::type>::value || is_function::type>::value, @@ -1765,7 +1765,7 @@ class _LIBCPP_VISIBLE result_of<_Fn(_A0)> }; template -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::type>::value || is_function::type>::value, @@ -1775,7 +1775,7 @@ class _LIBCPP_VISIBLE result_of<_Fn(_A0, _A1)> }; template -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::type>::value || is_function::type>::value, @@ -1880,7 +1880,7 @@ struct __contains_void<_A0, _Args...> // is_constructible entry point template -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 -struct _LIBCPP_VISIBLE is_constructible +struct _LIBCPP_TYPE_VIS is_constructible : public __is_constructible2_void_check::value || is_abstract<_Tp>::value || is_function<_Tp>::value @@ -2038,7 +2038,7 @@ struct _LIBCPP_VISIBLE is_constructible {}; template -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::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 -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::value || is_abstract<_Tp>::value || is_function<_Tp>::value @@ -2094,21 +2094,21 @@ struct __is_constructible2_imp // is_default_constructible template -struct _LIBCPP_VISIBLE is_default_constructible +struct _LIBCPP_TYPE_VIS is_default_constructible : public is_constructible<_Tp> {}; // is_copy_constructible template -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 -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 -struct _LIBCPP_VISIBLE is_trivially_constructible +struct _LIBCPP_TYPE_VIS is_trivially_constructible : integral_constant { }; @@ -2131,13 +2131,13 @@ struct _LIBCPP_VISIBLE is_trivially_constructible #else // !__has_feature(is_trivially_constructible) template -struct _LIBCPP_VISIBLE is_trivially_constructible +struct _LIBCPP_TYPE_VIS is_trivially_constructible : false_type { }; template -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 #else @@ -2148,22 +2148,22 @@ struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp> template #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::value> { }; template -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&> +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, const _Tp&> : integral_constant::value> { }; template -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&> +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&> : integral_constant::value> { }; @@ -2174,7 +2174,7 @@ struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&> template -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 -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 { }; template -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp, __is_construct::__nat> : integral_constant { }; template -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, const _Tp&, __is_construct::__nat> : integral_constant { }; template -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&, __is_construct::__nat> : integral_constant { @@ -2212,28 +2212,28 @@ struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&, #else // !__has_feature(is_trivially_constructible) template -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::value> { }; template -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp, __is_construct::__nat> : integral_constant::value> { }; template -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, const _Tp&, __is_construct::__nat> : integral_constant::value> { }; template -struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&, +struct _LIBCPP_TYPE_VIS is_trivially_constructible<_Tp, _Tp&, __is_construct::__nat> : integral_constant::value> { @@ -2245,19 +2245,19 @@ struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&, // is_trivially_default_constructible -template struct _LIBCPP_VISIBLE is_trivially_default_constructible +template struct _LIBCPP_TYPE_VIS is_trivially_default_constructible : public is_trivially_constructible<_Tp> {}; // is_trivially_copy_constructible -template struct _LIBCPP_VISIBLE is_trivially_copy_constructible +template 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 struct _LIBCPP_VISIBLE is_trivially_move_constructible +template 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 struct _LIBCPP_VISIBLE is_trivially_copy_assignable +template struct _LIBCPP_TYPE_VIS is_trivially_copy_assignable : public is_trivially_assignable::type, const typename add_lvalue_reference<_Tp>::type> {}; // is_trivially_move_assignable -template struct _LIBCPP_VISIBLE is_trivially_move_assignable +template struct _LIBCPP_TYPE_VIS is_trivially_move_assignable : public is_trivially_assignable::type, #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES typename add_rvalue_reference<_Tp>::type> @@ -2325,7 +2325,7 @@ template struct _LIBCPP_VISIBLE is_trivially_move_assignable #if __has_feature(has_trivial_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template struct _LIBCPP_VISIBLE is_trivially_destructible +template struct _LIBCPP_TYPE_VIS is_trivially_destructible : public integral_constant {}; #else // _LIBCPP_HAS_TYPE_TRAITS @@ -2334,7 +2334,7 @@ template struct __libcpp_trivial_destructor : public integral_constant::value || is_reference<_Tp>::value> {}; -template struct _LIBCPP_VISIBLE is_trivially_destructible +template struct _LIBCPP_TYPE_VIS is_trivially_destructible : public __libcpp_trivial_destructor::type> {}; #endif // _LIBCPP_HAS_TYPE_TRAITS @@ -2360,13 +2360,13 @@ struct __is_nothrow_constructible }; template -struct _LIBCPP_VISIBLE is_nothrow_constructible +struct _LIBCPP_TYPE_VIS is_nothrow_constructible : __is_nothrow_constructible::value, _Tp, _Args...> { }; template -struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp[_Ns]> +struct _LIBCPP_TYPE_VIS is_nothrow_constructible<_Tp[_Ns]> : __is_nothrow_constructible::value, _Tp> { }; @@ -2374,13 +2374,13 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp[_Ns]> #else // __has_feature(cxx_noexcept) template -struct _LIBCPP_VISIBLE is_nothrow_constructible +struct _LIBCPP_TYPE_VIS is_nothrow_constructible : false_type { }; template -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 #else @@ -2391,9 +2391,9 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp> template #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 @@ -2404,7 +2404,7 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp> }; template -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 #else @@ -2414,7 +2414,7 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&> }; template -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 #else @@ -2429,13 +2429,13 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&> template -struct _LIBCPP_VISIBLE is_nothrow_constructible +struct _LIBCPP_TYPE_VIS is_nothrow_constructible : false_type { }; template -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 @@ -2446,7 +2446,7 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, __is_construct::__nat, }; template -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 @@ -2457,7 +2457,7 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp, }; template -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 @@ -2468,7 +2468,7 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&, }; template -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 @@ -2482,19 +2482,19 @@ struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&, // is_nothrow_default_constructible -template struct _LIBCPP_VISIBLE is_nothrow_default_constructible +template struct _LIBCPP_TYPE_VIS is_nothrow_default_constructible : public is_nothrow_constructible<_Tp> {}; // is_nothrow_copy_constructible -template struct _LIBCPP_VISIBLE is_nothrow_copy_constructible +template 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 struct _LIBCPP_VISIBLE is_nothrow_move_constructible +template 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 }; template -struct _LIBCPP_VISIBLE is_nothrow_assignable +struct _LIBCPP_TYPE_VIS is_nothrow_assignable : public __is_nothrow_assignable::value, _Tp, _Arg> { }; @@ -2529,11 +2529,11 @@ struct _LIBCPP_VISIBLE is_nothrow_assignable #else // __has_feature(cxx_noexcept) template -struct _LIBCPP_VISIBLE is_nothrow_assignable +struct _LIBCPP_TYPE_VIS is_nothrow_assignable : public false_type {}; template -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 {}; #else @@ -2541,7 +2541,7 @@ struct _LIBCPP_VISIBLE is_nothrow_assignable<_Tp&, _Tp> #endif template -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 {}; #else @@ -2549,7 +2549,7 @@ struct _LIBCPP_VISIBLE is_nothrow_assignable<_Tp&, _Tp&> #endif template -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 {}; #else @@ -2572,14 +2572,14 @@ struct is_nothrow_assignable<_Tp&, _Tp&&> // is_nothrow_copy_assignable -template struct _LIBCPP_VISIBLE is_nothrow_copy_assignable +template struct _LIBCPP_TYPE_VIS is_nothrow_copy_assignable : public is_nothrow_assignable::type, const typename add_lvalue_reference<_Tp>::type> {}; // is_nothrow_move_assignable -template struct _LIBCPP_VISIBLE is_nothrow_move_assignable +template struct _LIBCPP_TYPE_VIS is_nothrow_move_assignable : public is_nothrow_assignable::type, #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES typename add_rvalue_reference<_Tp>::type> @@ -2607,19 +2607,19 @@ struct __is_nothrow_destructible }; template -struct _LIBCPP_VISIBLE is_nothrow_destructible +struct _LIBCPP_TYPE_VIS is_nothrow_destructible : public __is_nothrow_destructible::value, _Tp> { }; template -struct _LIBCPP_VISIBLE is_nothrow_destructible<_Tp[_Ns]> +struct _LIBCPP_TYPE_VIS is_nothrow_destructible<_Tp[_Ns]> : public is_nothrow_destructible<_Tp> { }; template -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 -struct _LIBCPP_VISIBLE is_nothrow_destructible<_Tp&&> +struct _LIBCPP_TYPE_VIS is_nothrow_destructible<_Tp&&> : public true_type { }; @@ -2640,7 +2640,7 @@ template struct __libcpp_nothrow_destructor : public integral_constant::value || is_reference<_Tp>::value> {}; -template struct _LIBCPP_VISIBLE is_nothrow_destructible +template struct _LIBCPP_TYPE_VIS is_nothrow_destructible : public __libcpp_nothrow_destructor::type> {}; #endif @@ -2649,12 +2649,12 @@ template struct _LIBCPP_VISIBLE is_nothrow_destructible #if __has_feature(is_pod) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) -template struct _LIBCPP_VISIBLE is_pod +template struct _LIBCPP_TYPE_VIS is_pod : public integral_constant {}; #else // _LIBCPP_HAS_TYPE_TRAITS -template struct _LIBCPP_VISIBLE is_pod +template struct _LIBCPP_TYPE_VIS is_pod : public integral_constant::value && is_trivially_copy_constructible<_Tp>::value && is_trivially_copy_assignable<_Tp>::value && @@ -2664,7 +2664,7 @@ template struct _LIBCPP_VISIBLE is_pod // is_literal_type; -template struct _LIBCPP_VISIBLE is_literal_type +template struct _LIBCPP_TYPE_VIS is_literal_type #if __has_feature(is_literal) : public integral_constant #else @@ -2675,7 +2675,7 @@ template struct _LIBCPP_VISIBLE is_literal_type // is_standard_layout; -template struct _LIBCPP_VISIBLE is_standard_layout +template struct _LIBCPP_TYPE_VIS is_standard_layout #if __has_feature(is_standard_layout) : public integral_constant #else @@ -2685,7 +2685,7 @@ template struct _LIBCPP_VISIBLE is_standard_layout // is_trivially_copyable; -template struct _LIBCPP_VISIBLE is_trivially_copyable +template struct _LIBCPP_TYPE_VIS is_trivially_copyable #if __has_feature(is_trivially_copyable) : public integral_constant #else @@ -2695,7 +2695,7 @@ template struct _LIBCPP_VISIBLE is_trivially_copyable // is_trivial; -template struct _LIBCPP_VISIBLE is_trivial +template struct _LIBCPP_TYPE_VIS is_trivial #if __has_feature(is_trivial) : public integral_constant #else @@ -2924,7 +2924,7 @@ struct __invoke_of }; template -class _LIBCPP_VISIBLE result_of<_Fp(_Args...)> +class _LIBCPP_TYPE_VIS result_of<_Fp(_Args...)> : public __invoke_of<_Fp, _Args...> { }; diff --git a/libcxx/include/typeindex b/libcxx/include/typeindex index 398b528..67462b7 100644 --- a/libcxx/include/typeindex +++ b/libcxx/include/typeindex @@ -55,7 +55,7 @@ struct hash _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 struct _LIBCPP_VISIBLE hash; +template struct _LIBCPP_TYPE_VIS hash; template <> -struct _LIBCPP_VISIBLE hash +struct _LIBCPP_TYPE_VIS hash : public unary_function { _LIBCPP_INLINE_VISIBILITY diff --git a/libcxx/include/unordered_map b/libcxx/include/unordered_map index cb2ab42..235b2ea 100644 --- a/libcxx/include/unordered_map +++ b/libcxx/include/unordered_map @@ -544,7 +544,7 @@ public: }; template -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 friend class _LIBCPP_VISIBLE unordered_map; - template friend class _LIBCPP_VISIBLE unordered_multimap; - template friend class _LIBCPP_VISIBLE __hash_const_iterator; - template friend class _LIBCPP_VISIBLE __hash_const_local_iterator; - template friend class _LIBCPP_VISIBLE __hash_map_const_iterator; + template friend class _LIBCPP_TYPE_VIS unordered_map; + template friend class _LIBCPP_TYPE_VIS unordered_multimap; + template friend class _LIBCPP_TYPE_VIS __hash_const_iterator; + template friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator; + template friend class _LIBCPP_TYPE_VIS __hash_map_const_iterator; }; template -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 friend class _LIBCPP_VISIBLE unordered_map; - template friend class _LIBCPP_VISIBLE unordered_multimap; - template friend class _LIBCPP_VISIBLE __hash_const_iterator; - template friend class _LIBCPP_VISIBLE __hash_const_local_iterator; + template friend class _LIBCPP_TYPE_VIS unordered_map; + template friend class _LIBCPP_TYPE_VIS unordered_multimap; + template friend class _LIBCPP_TYPE_VIS __hash_const_iterator; + template friend class _LIBCPP_TYPE_VIS __hash_const_local_iterator; }; template , class _Pred = equal_to<_Key>, class _Alloc = allocator > > -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 _Pred = equal_to<_Key>, class _Alloc = allocator > > -class _LIBCPP_VISIBLE unordered_multimap +class _LIBCPP_TYPE_VIS unordered_multimap { public: // types diff --git a/libcxx/include/unordered_set b/libcxx/include/unordered_set index 279e907..119251d 100644 --- a/libcxx/include/unordered_set +++ b/libcxx/include/unordered_set @@ -313,7 +313,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD template , 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 _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> > -class _LIBCPP_VISIBLE unordered_multiset +class _LIBCPP_TYPE_VIS unordered_multiset { public: // types diff --git a/libcxx/include/utility b/libcxx/include/utility index 514ce17..2df4b36 100644 --- a/libcxx/include/utility +++ b/libcxx/include/utility @@ -205,7 +205,7 @@ move_if_noexcept(_Tp& __x) _NOEXCEPT return _VSTD::move(__x); } -struct _LIBCPP_VISIBLE piecewise_construct_t { }; +struct _LIBCPP_TYPE_VIS piecewise_construct_t { }; #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_UTILITY) extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t(); #else @@ -213,7 +213,7 @@ constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); #endif template -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 _LIBCPP_VISIBLE reference_wrapper; +template class _LIBCPP_TYPE_VIS reference_wrapper; template struct ___make_pair_return @@ -461,36 +461,36 @@ make_pair(_T1 __x, _T2 __y) #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES template - class _LIBCPP_VISIBLE tuple_size > + class _LIBCPP_TYPE_VIS tuple_size > : public integral_constant {}; template - class _LIBCPP_VISIBLE tuple_size > + class _LIBCPP_TYPE_VIS tuple_size > : public integral_constant {}; template -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 _LIBCPP_VISIBLE tuple_element<1, pair<_T1, _T2> > +class _LIBCPP_TYPE_VIS tuple_element<1, pair<_T1, _T2> > { public: typedef _T2 type; }; template -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 _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/libcxx/include/valarray b/libcxx/include/valarray index c56dd12..71c8a74 100644 --- a/libcxx/include/valarray +++ b/libcxx/include/valarray @@ -354,9 +354,9 @@ template unspecified2 end(const valarray& v); _LIBCPP_BEGIN_NAMESPACE_STD -template class _LIBCPP_VISIBLE valarray; +template 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 _LIBCPP_VISIBLE slice_array; -class _LIBCPP_VISIBLE gslice; -template class _LIBCPP_VISIBLE gslice_array; -template class _LIBCPP_VISIBLE mask_array; -template class _LIBCPP_VISIBLE indirect_array; +template class _LIBCPP_TYPE_VIS slice_array; +class _LIBCPP_TYPE_VIS gslice; +template class _LIBCPP_TYPE_VIS gslice_array; +template class _LIBCPP_TYPE_VIS mask_array; +template class _LIBCPP_TYPE_VIS indirect_array; template _LIBCPP_INLINE_VISIBILITY @@ -671,7 +671,7 @@ public: _LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;} - template friend class _LIBCPP_VISIBLE valarray; + template friend class _LIBCPP_TYPE_VIS valarray; }; template @@ -786,7 +786,7 @@ template struct __is_val_expr > : true_type {}; template -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 friend class _LIBCPP_VISIBLE valarray; - template friend class _LIBCPP_VISIBLE slice_array; - template friend class _LIBCPP_VISIBLE gslice_array; - template friend class _LIBCPP_VISIBLE mask_array; + template friend class _LIBCPP_TYPE_VIS valarray; + template friend class _LIBCPP_TYPE_VIS slice_array; + template friend class _LIBCPP_TYPE_VIS gslice_array; + template friend class _LIBCPP_TYPE_VIS mask_array; template friend class __mask_expr; - template friend class _LIBCPP_VISIBLE indirect_array; + template friend class _LIBCPP_TYPE_VIS indirect_array; template friend class __indirect_expr; template friend class __val_expr; @@ -1091,7 +1091,7 @@ struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > // slice_array template -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_; valarray __stride_; @@ -1461,7 +1461,7 @@ private: // gslice_array template -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 _LIBCPP_VISIBLE mask_array +class _LIBCPP_TYPE_VIS mask_array { public: typedef _Tp value_type; @@ -2134,7 +2134,7 @@ public: // indirect_array template -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 friend class _LIBCPP_VISIBLE valarray; + template friend class _LIBCPP_TYPE_VIS valarray; }; template diff --git a/libcxx/include/vector b/libcxx/include/vector index 876b7e5..d9c5c2f 100644 --- a/libcxx/include/vector +++ b/libcxx/include/vector @@ -481,7 +481,7 @@ __vector_base<_Tp, _Allocator>::~__vector_base() } template > -class _LIBCPP_VISIBLE vector +class _LIBCPP_TYPE_VIS vector : private __vector_base<_Tp, _Allocator> { private: @@ -1963,7 +1963,7 @@ struct __has_storage_type > }; template -class _LIBCPP_VISIBLE vector +class _LIBCPP_TYPE_VIS vector : private __vector_base_common { public: @@ -2321,7 +2321,7 @@ private: friend class __bit_iterator; friend class __bit_iterator; friend struct __bit_array; - friend struct _LIBCPP_VISIBLE hash; + friend struct _LIBCPP_TYPE_VIS hash; }; template @@ -3104,7 +3104,7 @@ vector::__hash_code() const _NOEXCEPT } template -struct _LIBCPP_VISIBLE hash > +struct _LIBCPP_TYPE_VIS hash > : public unary_function, size_t> { _LIBCPP_INLINE_VISIBILITY diff --git a/libcxx/src/debug.cpp b/libcxx/src/debug.cpp index f3a0262..2d4b094 100644 --- a/libcxx/src/debug.cpp +++ b/libcxx/src/debug.cpp @@ -17,7 +17,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD -_LIBCPP_VISIBLE +_LIBCPP_FUNC_VIS __libcpp_db* __get_db() { @@ -25,7 +25,7 @@ __get_db() return &db; } -_LIBCPP_VISIBLE +_LIBCPP_FUNC_VIS const __libcpp_db* __get_const_db() { -- 2.7.4