diff options
Diffstat (limited to 'clang/www/libstdc++4.4-clang0x.patch')
| -rw-r--r-- | clang/www/libstdc++4.4-clang0x.patch | 608 |
1 files changed, 608 insertions, 0 deletions
diff --git a/clang/www/libstdc++4.4-clang0x.patch b/clang/www/libstdc++4.4-clang0x.patch new file mode 100644 index 0000000..db43583 --- /dev/null +++ b/clang/www/libstdc++4.4-clang0x.patch @@ -0,0 +1,608 @@ +This patch was generated from the headers installed by MacPorts +gcc-4.4 on OS X 10.6. You can apply it there with +`cd /opt/local/include/gcc44/c++ ; sudo patch -p1 <this_patch`, or similar +on other operating systems. Mail cfe-dev if you find other problems in the +standard headers. + +This patch is offered under the same modified GPLv3 as libstdc++-4.4. + +diff -ur a/bits/forward_list.h b/bits/forward_list.h +--- a/bits/forward_list.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/forward_list.h 2011-05-02 23:51:33.000000000 -0700 +@@ -983,7 +983,7 @@ + * function. + */ + void +- swap(forward_list&& __list) ++ swap(forward_list& __list) + { _Node_base::swap(this->_M_impl._M_head, __list._M_impl._M_head); } + + /** +diff -ur a/bits/move.h b/bits/move.h +--- a/bits/move.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/move.h 2011-03-29 10:33:39.000000000 -0700 +@@ -48,13 +48,35 @@ + + template<typename _Tp> + inline _Tp&& +- forward(typename std::identity<_Tp>::type&& __t) ++ forward(typename std::remove_reference<_Tp>::type& __t) ++#ifdef __clang__ ++ { return static_cast<_Tp&&>(__t); } ++#else + { return __t; } ++#endif ++ ++ template<typename _Tp> ++ inline _Tp&& ++ forward(typename std::remove_reference<_Tp>::type&& __t) ++ { ++#ifdef __clang__ ++ static_assert(!std::is_lvalue_reference<_Tp>::value, ++ "Can't instantiate this forward() with an" ++ " lvalue reference type."); ++ return static_cast<_Tp&&>(__t); ++#else ++ return __t; ++#endif ++ } + + template<typename _Tp> + inline typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) ++#ifdef __clang__ ++ { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); } ++#else + { return __t; } ++#endif + + _GLIBCXX_END_NAMESPACE + +diff -ur a/bits/shared_ptr.h b/bits/shared_ptr.h +--- a/bits/shared_ptr.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/shared_ptr.h 2011-03-31 16:40:45.000000000 -0700 +@@ -833,7 +833,7 @@ + { return _M_refcount._M_get_use_count(); } + + void +- swap(__shared_ptr<_Tp, _Lp>&& __other) // never throws ++ swap(__shared_ptr<_Tp, _Lp>& __other) // never throws + { + std::swap(_M_ptr, __other._M_ptr); + _M_refcount._M_swap(__other._M_refcount); +@@ -943,16 +943,6 @@ + swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) + { __a.swap(__b); } + +- template<typename _Tp, _Lock_policy _Lp> +- inline void +- swap(__shared_ptr<_Tp, _Lp>&& __a, __shared_ptr<_Tp, _Lp>& __b) +- { __a.swap(__b); } +- +- template<typename _Tp, _Lock_policy _Lp> +- inline void +- swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>&& __b) +- { __a.swap(__b); } +- + // 2.2.3.9 shared_ptr casts + /** @warning The seemingly equivalent + * <code>shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))</code> +@@ -1372,16 +1362,6 @@ + swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) + { __a.swap(__b); } + +- template<typename _Tp> +- inline void +- swap(shared_ptr<_Tp>&& __a, shared_ptr<_Tp>& __b) +- { __a.swap(__b); } +- +- template<typename _Tp> +- inline void +- swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>&& __b) +- { __a.swap(__b); } +- + // 20.8.13.2.10 shared_ptr casts. + template<typename _Tp, typename _Tp1> + inline shared_ptr<_Tp> +diff -ur a/bits/stl_bvector.h b/bits/stl_bvector.h +--- a/bits/stl_bvector.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_bvector.h 2011-05-02 23:34:46.000000000 -0700 +@@ -743,11 +743,7 @@ + } + + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(vector&& __x) +-#else + swap(vector& __x) +-#endif + { + std::swap(this->_M_impl._M_start, __x._M_impl._M_start); + std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); +diff -ur a/bits/stl_deque.h b/bits/stl_deque.h +--- a/bits/stl_deque.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_deque.h 2011-03-29 10:33:39.000000000 -0700 +@@ -1395,11 +1395,7 @@ + * std::swap(d1,d2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(deque&& __x) +-#else + swap(deque& __x) +-#endif + { + std::swap(this->_M_impl._M_start, __x._M_impl._M_start); + std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); +diff -ur a/bits/stl_iterator.h b/bits/stl_iterator.h +--- a/bits/stl_iterator.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_iterator.h 2011-03-29 10:33:39.000000000 -0700 +@@ -913,7 +913,7 @@ + + reference + operator*() const +- { return *_M_current; } ++ { return std::move(*_M_current); } + + pointer + operator->() const +diff -ur a/bits/stl_list.h b/bits/stl_list.h +--- a/bits/stl_list.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_list.h 2011-03-29 10:33:39.000000000 -0700 +@@ -1106,11 +1106,7 @@ + * function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(list&& __x) +-#else + swap(list& __x) +-#endif + { + _List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node); + +@@ -1160,6 +1156,12 @@ + } + } + ++#ifdef __GXX_EXPERIMENTAL_CXX0X__ ++ void ++ splice(iterator __position, list& __x) ++ { splice(__position, std::move(__x)); } ++#endif ++ + /** + * @brief Insert element from another %list. + * @param position Iterator referencing the element to insert before. +@@ -1187,6 +1189,12 @@ + this->_M_transfer(__position, __i, __j); + } + ++#ifdef __GXX_EXPERIMENTAL_CXX0X__ ++ void ++ splice(iterator __position, list& __x, iterator __i) ++ { splice(__position, std::move(__x), __i); } ++#endif ++ + /** + * @brief Insert range from another %list. + * @param position Iterator referencing the element to insert before. +@@ -1217,6 +1225,13 @@ + } + } + ++#ifdef __GXX_EXPERIMENTAL_CXX0X__ ++ void ++ splice(iterator __position, list& __x, iterator __first, ++ iterator __last) ++ { splice(__position, std::move(__x), __first, __last); } ++#endif ++ + /** + * @brief Remove all elements equal to value. + * @param value The value to remove. +@@ -1287,6 +1302,10 @@ + void + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + merge(list&& __x); ++ ++ void ++ merge(list& __x) ++ { merge(std::move(__x)); } + #else + merge(list& __x); + #endif +@@ -1307,6 +1326,11 @@ + void + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + merge(list&&, _StrictWeakOrdering); ++ ++ template<typename _StrictWeakOrdering> ++ void ++ merge(list& __l, _StrictWeakOrdering __comp) ++ { merge(std::move(__l), __comp); } + #else + merge(list&, _StrictWeakOrdering); + #endif +diff -ur a/bits/stl_map.h b/bits/stl_map.h +--- a/bits/stl_map.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_map.h 2011-03-29 10:33:39.000000000 -0700 +@@ -608,11 +608,7 @@ + * that std::swap(m1,m2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(map&& __x) +-#else + swap(map& __x) +-#endif + { _M_t.swap(__x._M_t); } + + /** +diff -ur a/bits/stl_multimap.h b/bits/stl_multimap.h +--- a/bits/stl_multimap.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_multimap.h 2011-03-29 10:33:39.000000000 -0700 +@@ -544,11 +544,7 @@ + * std::swap(m1,m2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(multimap&& __x) +-#else + swap(multimap& __x) +-#endif + { _M_t.swap(__x._M_t); } + + /** +diff -ur a/bits/stl_multiset.h b/bits/stl_multiset.h +--- a/bits/stl_multiset.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_multiset.h 2011-03-29 10:33:39.000000000 -0700 +@@ -376,11 +376,7 @@ + * std::swap(s1,s2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(multiset&& __x) +-#else + swap(multiset& __x) +-#endif + { _M_t.swap(__x._M_t); } + + // insert/erase +diff -ur a/bits/stl_pair.h b/bits/stl_pair.h +--- a/bits/stl_pair.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_pair.h 2011-03-29 10:33:39.000000000 -0700 +@@ -84,10 +84,21 @@ + : first(__a), second(__b) { } + + #ifdef __GXX_EXPERIMENTAL_CXX0X__ +- template<class _U1, class _U2> ++ template<class _U1, class = typename ++ std::enable_if<std::is_convertible<_U1, _T1>::value>::type> ++ pair(_U1&& __x, const _T2& __y) ++ : first(std::forward<_U1>(__x)), second(__y) { } ++ ++ template<class _U2, class = typename ++ std::enable_if<std::is_convertible<_U2, _T2>::value>::type> ++ pair(const _T1& __x, _U2&& __y) ++ : first(__x), second(std::forward<_U2>(__y)) { } ++ ++ template<class _U1, class _U2, class = typename ++ std::enable_if<std::is_convertible<_U1, _T1>::value ++ && std::is_convertible<_U2, _T2>::value>::type> + pair(_U1&& __x, _U2&& __y) +- : first(std::forward<_U1>(__x)), +- second(std::forward<_U2>(__y)) { } ++ : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } + + pair(pair&& __p) + : first(std::move(__p.first)), +@@ -107,11 +118,19 @@ + second(std::move(__p.second)) { } + + // http://gcc.gnu.org/ml/libstdc++/2007-08/msg00052.html ++ ++#if 0 ++ // This constructor is incompatible with libstdc++-4.6, and it ++ // interferes with passing NULL pointers to the 2-argument ++ // constructors, so we disable it. map::emplace isn't ++ // implemented in libstdc++-4.4 anyway, and that's what this ++ // constructor was here for. + template<class _U1, class _Arg0, class... _Args> + pair(_U1&& __x, _Arg0&& __arg0, _Args&&... __args) + : first(std::forward<_U1>(__x)), + second(std::forward<_Arg0>(__arg0), + std::forward<_Args>(__args)...) { } ++#endif + + pair& + operator=(pair&& __p) +@@ -131,7 +150,7 @@ + } + + void +- swap(pair&& __p) ++ swap(pair& __p) + { + using std::swap; + swap(first, __p.first); +diff -ur a/bits/stl_queue.h b/bits/stl_queue.h +--- a/bits/stl_queue.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_queue.h 2011-05-02 23:36:15.000000000 -0700 +@@ -249,7 +249,7 @@ + + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + void +- swap(queue&& __q) ++ swap(queue& __q) + { c.swap(__q.c); } + #endif + }; +@@ -550,7 +550,7 @@ + + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + void +- swap(priority_queue&& __pq) ++ swap(priority_queue& __pq) + { + using std::swap; + c.swap(__pq.c); +diff -ur a/bits/stl_set.h b/bits/stl_set.h +--- a/bits/stl_set.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_set.h 2011-03-29 10:33:39.000000000 -0700 +@@ -383,11 +383,7 @@ + * std::swap(s1,s2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(set&& __x) +-#else + swap(set& __x) +-#endif + { _M_t.swap(__x._M_t); } + + // insert/erase +diff -ur a/bits/stl_stack.h b/bits/stl_stack.h +--- a/bits/stl_stack.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_stack.h 2011-05-02 23:36:36.000000000 -0700 +@@ -213,7 +213,7 @@ + + #ifdef __GXX_EXPERIMENTAL_CXX0X__ + void +- swap(stack&& __s) ++ swap(stack& __s) + { c.swap(__s.c); } + #endif + }; +diff -ur a/bits/stl_tree.h b/bits/stl_tree.h +--- a/bits/stl_tree.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_tree.h 2011-03-29 10:33:39.000000000 -0700 +@@ -675,11 +675,7 @@ + { return _M_get_Node_allocator().max_size(); } + + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(_Rb_tree&& __t); +-#else + swap(_Rb_tree& __t); +-#endif + + // Insert/erase. + pair<iterator, bool> +@@ -1104,11 +1100,7 @@ + typename _Compare, typename _Alloc> + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&& __t) +-#else + swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t) +-#endif + { + if (_M_root() == 0) + { +diff -ur a/bits/stl_vector.h b/bits/stl_vector.h +--- a/bits/stl_vector.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/stl_vector.h 2011-03-29 10:33:39.000000000 -0700 +@@ -923,11 +923,7 @@ + * std::swap(v1,v2) will feed to this function. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(vector&& __x) +-#else + swap(vector& __x) +-#endif + { + std::swap(this->_M_impl._M_start, __x._M_impl._M_start); + std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); +diff -ur a/bits/unique_ptr.h b/bits/unique_ptr.h +--- a/bits/unique_ptr.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/bits/unique_ptr.h 2011-03-31 16:40:45.000000000 -0700 +@@ -204,7 +204,7 @@ + } + + void +- swap(unique_ptr&& __u) ++ swap(unique_ptr& __u) + { + using std::swap; + swap(_M_t, __u._M_t); +@@ -350,7 +350,7 @@ + void reset(_Up) = delete; + + void +- swap(unique_ptr&& __u) ++ swap(unique_ptr& __u) + { + using std::swap; + swap(_M_t, __u._M_t); +@@ -389,18 +389,6 @@ + unique_ptr<_Tp, _Tp_Deleter>& __y) + { __x.swap(__y); } + +- template<typename _Tp, typename _Tp_Deleter> +- inline void +- swap(unique_ptr<_Tp, _Tp_Deleter>&& __x, +- unique_ptr<_Tp, _Tp_Deleter>& __y) +- { __x.swap(__y); } +- +- template<typename _Tp, typename _Tp_Deleter> +- inline void +- swap(unique_ptr<_Tp, _Tp_Deleter>& __x, +- unique_ptr<_Tp, _Tp_Deleter>&& __y) +- { __x.swap(__y); } +- + template<typename _Tp, typename _Tp_Deleter, + typename _Up, typename _Up_Deleter> + inline bool +diff -ur a/exception_ptr.h b/exception_ptr.h +--- a/exception_ptr.h 2011-03-15 14:49:08.000000000 -0700 ++++ b/exception_ptr.h 2011-03-29 10:33:39.000000000 -0700 +@@ -140,7 +140,7 @@ + friend bool + operator==(const exception_ptr&, const exception_ptr&) throw(); + +- const type_info* ++ const class type_info* + __cxa_exception_type() const throw(); + }; + +diff -ur a/ext/algorithm b/ext/algorithm +--- a/ext/algorithm 2011-03-15 14:49:05.000000000 -0700 ++++ b/ext/algorithm 2011-03-29 10:33:39.000000000 -0700 +@@ -423,6 +423,9 @@ + __out_last - __out_first); + } + ++#ifdef __GXX_EXPERIMENTAL_CXX0X__ ++ using std::is_heap; ++#else + /** + * This is an SGI extension. + * @ingroup SGIextensions +@@ -462,6 +465,7 @@ + + return std::__is_heap(__first, __comp, __last - __first); + } ++#endif + + // is_sorted, a predicated testing whether a range is sorted in + // nondescending order. This is an extension, not part of the C++ +diff -ur a/ext/vstring.h b/ext/vstring.h +--- a/ext/vstring.h 2011-03-15 14:49:05.000000000 -0700 ++++ b/ext/vstring.h 2011-03-29 10:33:39.000000000 -0700 +@@ -152,7 +152,7 @@ + * string. + */ + __versa_string(__versa_string&& __str) +- : __vstring_base(std::forward<__vstring_base>(__str)) { } ++ : __vstring_base(std::move(__str)) { } + + /** + * @brief Construct string from an initializer list. +@@ -1439,11 +1439,7 @@ + * constant time. + */ + void +-#ifdef __GXX_EXPERIMENTAL_CXX0X__ +- swap(__versa_string&& __s) +-#else + swap(__versa_string& __s) +-#endif + { this->_M_swap(__s); } + + // String operations: +diff -ur a/tr1_impl/hashtable b/tr1_impl/hashtable +--- a/tr1_impl/hashtable 2011-03-15 14:49:07.000000000 -0700 ++++ b/tr1_impl/hashtable 2011-05-02 23:41:55.000000000 -0700 +@@ -225,11 +225,7 @@ + + ~_Hashtable(); + +-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X +- void swap(_Hashtable&&); +-#else + void swap(_Hashtable&); +-#endif + + // Basic container operations + iterator +@@ -732,11 +728,7 @@ + void + _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: +-#ifdef _GLIBCXX_INCLUDE_AS_CXX0X +- swap(_Hashtable&& __x) +-#else + swap(_Hashtable& __x) +-#endif + { + // The only base class with member variables is hash_code_base. We + // define _Hash_code_base::_M_swap because different specializations +diff -ur a/tuple b/tuple +--- a/tuple 2011-03-15 14:49:07.000000000 -0700 ++++ b/tuple 2011-05-02 23:33:23.000000000 -0700 +@@ -77,7 +77,7 @@ + _Head& _M_head() { return *this; } + const _Head& _M_head() const { return *this; } + +- void _M_swap_impl(_Head&&) { /* no-op */ } ++ void _M_swap_impl(_Head&) { /* no-op */ } + }; + + template<std::size_t _Idx, typename _Head> +@@ -97,7 +97,7 @@ + const _Head& _M_head() const { return _M_head_impl; } + + void +- _M_swap_impl(_Head&& __h) ++ _M_swap_impl(_Head& __h) + { + using std::swap; + swap(__h, _M_head_impl); +@@ -125,7 +125,7 @@ + struct _Tuple_impl<_Idx> + { + protected: +- void _M_swap_impl(_Tuple_impl&&) { /* no-op */ } ++ void _M_swap_impl(_Tuple_impl&) { /* no-op */ } + }; + + /** +@@ -214,7 +214,7 @@ + + protected: + void +- _M_swap_impl(_Tuple_impl&& __in) ++ _M_swap_impl(_Tuple_impl& __in) + { + _Base::_M_swap_impl(__in._M_head()); + _Inherited::_M_swap_impl(__in._M_tail()); +@@ -292,7 +292,7 @@ + } + + void +- swap(tuple&& __in) ++ swap(tuple& __in) + { _Inherited::_M_swap_impl(__in); } + }; + +@@ -301,7 +301,7 @@ + class tuple<> + { + public: +- void swap(tuple&&) { /* no-op */ } ++ void swap(tuple&) { /* no-op */ } + }; + + /// tuple (2-element), with construction and assignment from a pair. +@@ -394,7 +394,7 @@ + } + + void +- swap(tuple&& __in) ++ swap(tuple& __in) + { + using std::swap; + swap(this->_M_head(), __in._M_head()); |