Tagging 17

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/tags/libcpp-17@128700 91177308-0d34-0410-b5e6-96231b3b80d8

include/__config

@@ -184,12 +184,10 @@ namespace std {
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #define _LIBCPP_HAS_NO_VARIADICS
 #define _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#define _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
 
 #else  // __GXX_EXPERIMENTAL_CXX0X__
 
 #define _LIBCPP_HAS_NO_TRAILING_RETURN
-#define _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
 
 #if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
 #define _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -209,6 +207,7 @@ namespace std {
 #endif  // !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 4)
 
 #if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 6)
+#define _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
 #define _LIBCPP_HAS_NO_NULLPTR
 #endif
 

include/__locale

@@ -451,7 +451,7 @@ public:
     _LIBCPP_ALWAYS_INLINE
     bool is(mask __m, char_type __c) const
     {
-        return isascii(__c) ? (__tab_ ? __tab_[__c] & __m : isctype(__c, __m)) : false;
+        return isascii(__c) ? __tab_[__c] & __m : false;
     }
 
     _LIBCPP_ALWAYS_INLINE

include/__std_stream

@@ -288,12 +288,12 @@ __stdoutbuf<_CharT>::sync()
         __r = __cv_->unshift(__st_, __extbuf,
                                     __extbuf + sizeof(__extbuf),
                                     __extbe);
-        if (__r == codecvt_base::error)
-            return -1;
         size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
         if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
             return -1;
     } while (__r == codecvt_base::partial);
+    if (__r == codecvt_base::error)
+        return -1;
     if (fflush(__file_))
         return -1;
     return 0;

include/__tree

@@ -769,7 +769,6 @@ public:
     typedef typename __alloc_traits::difference_type difference_type;
 
     typedef __tree_node<value_type, typename __alloc_traits::void_pointer> __node;
-    typedef __tree_node_base<typename __alloc_traits::void_pointer> __node_base;
     typedef typename __alloc_traits::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
             rebind_alloc<__node>
@@ -780,10 +779,10 @@ public:
     typedef allocator_traits<__node_allocator>       __node_traits;
     typedef typename __node_traits::pointer          __node_pointer;
     typedef typename __node_traits::const_pointer    __node_const_pointer;
-    typedef typename __node_base::pointer            __node_base_pointer;
-    typedef typename __node_base::const_pointer      __node_base_const_pointer;
+    typedef typename __node::base::pointer           __node_base_pointer;
+    typedef typename __node::base::const_pointer     __node_base_const_pointer;
 private:
-    typedef typename __node_base::base __end_node_t;
+    typedef typename __node::base::base __end_node_t;
     typedef typename pointer_traits<__node_pointer>::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
             rebind<__end_node_t>
@@ -997,19 +996,19 @@ public:
 
     __node_holder remove(const_iterator __p);
 private:
-    typename __node_base::pointer&
-        __find_leaf_low(typename __node_base::pointer& __parent, const value_type& __v);
-    typename __node_base::pointer&
-        __find_leaf_high(typename __node_base::pointer& __parent, const value_type& __v);
-    typename __node_base::pointer&
+    typename __node::base::pointer&
+        __find_leaf_low(typename __node::base::pointer& __parent, const value_type& __v);
+    typename __node::base::pointer&
+        __find_leaf_high(typename __node::base::pointer& __parent, const value_type& __v);
+    typename __node::base::pointer&
         __find_leaf(const_iterator __hint,
-                    typename __node_base::pointer& __parent, const value_type& __v);
+                    typename __node::base::pointer& __parent, const value_type& __v);
     template <class _Key>
-        typename __node_base::pointer&
-        __find_equal(typename __node_base::pointer& __parent, const _Key& __v);
+        typename __node::base::pointer&
+        __find_equal(typename __node::base::pointer& __parent, const _Key& __v);
     template <class _Key>
-        typename __node_base::pointer&
-        __find_equal(const_iterator __hint, typename __node_base::pointer& __parent,
+        typename __node::base::pointer&
+        __find_equal(const_iterator __hint, typename __node::base::pointer& __parent,
                      const _Key& __v);
 
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
@@ -1411,8 +1410,8 @@ __tree<_Tp, _Compare, _Allocator>::clear()
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node_base::pointer& __parent,
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node::base::pointer& __parent,
                                                    const value_type& __v)
 {
     __node_pointer __nd = __root();
@@ -1450,8 +1449,8 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node_base::pointer
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node_base::pointer& __parent,
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node::base::pointer& __parent,
                                                     const value_type& __v)
 {
     __node_pointer __nd = __root();
@@ -1492,9 +1491,9 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node_base::pointe
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
 __tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
-                                               typename __node_base::pointer& __parent,
+                                               typename __node::base::pointer& __parent,
                                                const value_type& __v)
 {
     if (__hint == end() || !value_comp()(*__hint, __v))  // check before
@@ -1528,8 +1527,8 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
 // If __v exists, set parent to node of __v and return reference to node of __v
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node_base::pointer& __parent,
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node::base::pointer& __parent,
                                                 const _Key& __v)
 {
     __node_pointer __nd = __root();
@@ -1577,9 +1576,9 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node_base::pointer& _
 // If __v exists, set parent to node of __v and return reference to node of __v
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
 __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
-                                                typename __node_base::pointer& __parent,
+                                                typename __node::base::pointer& __parent,
                                                 const _Key& __v)
 {
     if (__hint == end() || value_comp()(__v, *__hint))  // check before
@@ -1609,7 +1608,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
         const_iterator __next = _STD::next(__hint);
         if (__next == end() || value_comp()(__v, *__next))
         {
-            // *__hint < __v < *_STD::next(__hint)
+            // *__hint < __v < *next(__hint)
             if (__hint.__ptr_->__right_ == nullptr)
             {
                 __parent = const_cast<__node_pointer&>(__hint.__ptr_);

include/cerrno

@@ -30,43 +30,25 @@ Macros:
 
 #if !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
 
-#ifdef ELAST
-
 const int __elast1 = ELAST+1;
 const int __elast2 = ELAST+2;
-
-#else
-
-const int __elast1 = 104;
-const int __elast2 = 105;
-
-#endif
+#undef ELAST
 
 #ifdef ENOTRECOVERABLE
 
 #define EOWNERDEAD __elast1
-
-#ifdef ELAST
-#undef ELAST
 #define ELAST EOWNERDEAD
-#endif
 
 #elif defined(EOWNERDEAD)
 
 #define ENOTRECOVERABLE __elast1
-#ifdef ELAST
-#undef ELAST
 #define ELAST ENOTRECOVERABLE
-#endif
 
 #else  // defined(EOWNERDEAD)
 
 #define EOWNERDEAD __elast1
 #define ENOTRECOVERABLE __elast2
-#ifdef ELAST
-#undef ELAST
 #define ELAST ENOTRECOVERABLE
-#endif
 
 #endif  // defined(EOWNERDEAD)
 

include/deque

@@ -1787,7 +1787,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
             --__base::__start_;
             ++__base::size();
             if (__pos > 1)
-                __b = __move_and_check(_STD::next(__b), __b + __pos, __b, __vt);
+                __b = __move_and_check(next(__b), __b + __pos, __b, __vt);
             *__b = *__vt;
         }
     }
@@ -1847,7 +1847,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
             --__base::__start_;
             ++__base::size();
             if (__pos > 1)
-                __b = _STD::move(_STD::next(__b), __b + __pos, __b);
+                __b = _STD::move(next(__b), __b + __pos, __b);
             *__b = _STD::move(__v);
         }
     }
@@ -1905,7 +1905,7 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
             --__base::__start_;
             ++__base::size();
             if (__pos > 1)
-                __b = _STD::move(_STD::next(__b), __b + __pos, __b);
+                __b = _STD::move(next(__b), __b + __pos, __b);
             *__b = value_type(_STD::forward<_Args>(__args)...);
         }
     }
@@ -2621,7 +2621,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)
     }
     else
     {   // erase from back
-        iterator __i = _STD::move(_STD::next(__p), __base::end(), __p);
+        iterator __i = _STD::move(next(__p), __base::end(), __p);
         __alloc_traits::destroy(__a, _STD::addressof(*__i));
         --__base::size();
         if (__back_spare() >= 2 * __base::__block_size)

include/locale

@@ -2346,12 +2346,6 @@ time_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
         __b = get(__b, __e, __iob, __err, __tm, __fmt, __fmt + sizeof(__fmt)/sizeof(__fmt[0]));
         }
         break;
-    case 'F':
-        {
-        const char_type __fmt[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd'};
-        __b = get(__b, __e, __iob, __err, __tm, __fmt, __fmt + sizeof(__fmt)/sizeof(__fmt[0]));
-        }
-        break;
     case 'H':
         __get_hour(__tm->tm_hour, __b, __e, __err, __ct);
         break;

include/map

@@ -567,9 +567,9 @@ public:
     typedef const value_type&                                    reference;
     typedef typename __pointer_traits::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-            rebind<const value_type>
+            rebind<value_type>
 #else
-            rebind<const value_type>::other
+            rebind<value_type>::other
 #endif
                                                                  pointer;
 

include/ostream

@@ -1276,7 +1276,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Y> const& __p)
 
 template <class _CharT, class _Traits, size_t _Size>
 basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
+operator<<(basic_ostream<_CharT, _Traits>& __os, bitset<_Size>& __x)
 {
     return __os << __x.template to_string<_CharT, _Traits>
                         (use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),

include/random

@@ -1650,16 +1650,6 @@ class piecewise_linear_distribution
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-// __is_seed_sequence
-
-template <class _Sseq, class _Engine>
-struct __is_seed_sequence
-{
-    static const bool value =
-              !is_convertible<_Sseq, typename _Engine::result_type>::value &&
-              !is_same<typename remove_cv<_Sseq>::type, _Engine>::value;
-};
-
 // linear_congruential_engine
 
 template <unsigned long long __a, unsigned long long __c,
@@ -1858,7 +1848,7 @@ public:
         {seed(__s);}
     template<class _Sseq> explicit linear_congruential_engine(_Sseq& __q,
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
+        typename enable_if<!is_convertible<_Sseq, result_type>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __s = default_seed)
@@ -1868,7 +1858,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
-            __is_seed_sequence<_Sseq, linear_congruential_engine>::value,
+            !is_convertible<_Sseq, result_type>::value,
             void
         >::type
         seed(_Sseq& __q)
@@ -2114,14 +2104,14 @@ public:
         {seed(__sd);}
     template<class _Sseq> explicit mersenne_twister_engine(_Sseq& __q,
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
+        typename enable_if<!is_convertible<_Sseq, result_type>::value>::type* = 0)
         {seed(__q);}
     void seed(result_type __sd = default_seed);
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
-            __is_seed_sequence<_Sseq, mersenne_twister_engine>::value,
+            !is_convertible<_Sseq, result_type>::value,
             void
         >::type
         seed(_Sseq& __q)
@@ -2483,7 +2473,7 @@ public:
         {seed(__sd);}
     template<class _Sseq> explicit subtract_with_carry_engine(_Sseq& __q,
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
+        typename enable_if<!is_convertible<_Sseq, result_type>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __sd = default_seed)
@@ -2492,7 +2482,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
-            __is_seed_sequence<_Sseq, subtract_with_carry_engine>::value,
+            !is_convertible<_Sseq, result_type>::value,
             void
         >::type
         seed(_Sseq& __q)
@@ -2751,7 +2741,7 @@ public:
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit discard_block_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value &&
+        typename enable_if<!is_convertible<_Sseq, result_type>::value &&
                            !is_convertible<_Sseq, _Engine>::value>::type* = 0)
         : __e_(__q), __n_(0) {}
     _LIBCPP_INLINE_VISIBILITY
@@ -2762,7 +2752,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
-            __is_seed_sequence<_Sseq, discard_block_engine>::value,
+            !is_convertible<_Sseq, result_type>::value,
             void
         >::type
         seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;}
@@ -2950,7 +2940,7 @@ public:
     explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
     template<class _Sseq> explicit independent_bits_engine(_Sseq& __q,
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value &&
+        typename enable_if<!is_convertible<_Sseq, result_type>::value &&
                            !is_convertible<_Sseq, _Engine>::value>::type* = 0)
          : __e_(__q) {}
     _LIBCPP_INLINE_VISIBILITY
@@ -2961,7 +2951,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
-            __is_seed_sequence<_Sseq, independent_bits_engine>::value,
+            !is_convertible<_Sseq, result_type>::value,
             void
         >::type
         seed(_Sseq& __q) {__e_.seed(__q);}
@@ -3173,7 +3163,7 @@ public:
     explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
     template<class _Sseq> explicit shuffle_order_engine(_Sseq& __q,
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value &&
+        typename enable_if<!is_convertible<_Sseq, result_type>::value &&
                            !is_convertible<_Sseq, _Engine>::value>::type* = 0)
          : __e_(__q) {__init();}
     _LIBCPP_INLINE_VISIBILITY
@@ -3184,7 +3174,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
-            __is_seed_sequence<_Sseq, shuffle_order_engine>::value,
+            !is_convertible<_Sseq, result_type>::value,
             void
         >::type
         seed(_Sseq& __q) {__e_.seed(__q); __init();}
@@ -4477,7 +4467,7 @@ poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr
 {
     result_type __x;
     uniform_real_distribution<double> __urd;
-    if (__pr.__mean_ < 10)
+    if (__pr.__mean_ <= 10)
     {
          __x = 0;
         for (double __p = __urd(__urng); __p > __pr.__l_; ++__x)

include/regex

@@ -1264,7 +1264,6 @@ struct __state
     vector<pair<size_t, const _CharT*> > __loop_data_;
     const __node<_CharT>* __node_;
     regex_constants::match_flag_type __flags_;
-    bool __at_first_;
 
     _LIBCPP_INLINE_VISIBILITY
     __state()
@@ -1891,40 +1890,6 @@ __word_boundary<_CharT, _Traits>::__exec(__state& __s) const
     }
 }
 
-// __l_anchor
-
-template <class _CharT>
-class __l_anchor
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
-
-public:
-    typedef _STD::__state<_CharT> __state;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __l_anchor(__node<_CharT>* __s)
-        : base(__s) {}
-
-    virtual void __exec(__state&) const;
-};
-
-template <class _CharT>
-void
-__l_anchor<_CharT>::__exec(__state& __s) const
-{
-    if (__s.__at_first_ && __s.__current_ == __s.__first_)
-    {
-        __s.__do_ = __state::__accept_but_not_consume;
-        __s.__node_ = this->first();
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
-}
-
 // __r_anchor
 
 template <class _CharT>
@@ -2429,6 +2394,7 @@ private:
     int __open_count_;
     shared_ptr<__empty_state<_CharT> > __start_;
     __owns_one_state<_CharT>* __end_;
+    bool __left_anchor_;
 
     typedef _STD::__state<_CharT> __state;
     typedef _STD::__node<_CharT> __node;
@@ -2450,17 +2416,17 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     basic_regex()
         : __flags_(), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
         {}
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
         {__parse(__p, __p + __traits_.length(__p));}
     _LIBCPP_INLINE_VISIBILITY
     basic_regex(const value_type* __p, size_t __len, flag_type __f)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
         {__parse(__p, __p + __len);}
 //     basic_regex(const basic_regex&) = default;
 //     basic_regex(basic_regex&&) = default;
@@ -2469,20 +2435,20 @@ public:
         explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p,
                              flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
         {__parse(__p.begin(), __p.end());}
     template <class _ForwardIterator>
         _LIBCPP_INLINE_VISIBILITY
         basic_regex(_ForwardIterator __first, _ForwardIterator __last,
                     flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
         {__parse(__first, __last);}
     _LIBCPP_INLINE_VISIBILITY
     basic_regex(initializer_list<value_type> __il,
                 flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
         {__parse(__il.begin(), __il.end());}
 
 //    ~basic_regex() = default;
@@ -2540,6 +2506,7 @@ private:
         __loop_count_ = 0;
         __open_count_ = 0;
         __end_ = nullptr;
+        __left_anchor_ = false;
     }
 public:
 
@@ -2727,7 +2694,7 @@ private:
                           basic_string<_CharT>* __str = nullptr);
 
     _LIBCPP_INLINE_VISIBILITY
-    void __push_l_anchor();
+    void __push_l_anchor() {__left_anchor_ = true;}
     void __push_r_anchor();
     void __push_match_any();
     void __push_match_any_but_newline();
@@ -2765,22 +2732,22 @@ private:
         bool
         __match_at_start(const _CharT* __first, const _CharT* __last,
                  match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
+                 regex_constants::match_flag_type __flags) const;
     template <class _Allocator>
         bool
         __match_at_start_ecma(const _CharT* __first, const _CharT* __last,
                  match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
+                 regex_constants::match_flag_type __flags) const;
     template <class _Allocator>
         bool
         __match_at_start_posix_nosubs(const _CharT* __first, const _CharT* __last,
                  match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
+                 regex_constants::match_flag_type __flags) const;
     template <class _Allocator>
         bool
         __match_at_start_posix_subs(const _CharT* __first, const _CharT* __last,
                  match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
+                 regex_constants::match_flag_type __flags) const;
 
     template <class _B, class _A, class _C, class _T>
     friend
@@ -2842,6 +2809,7 @@ basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
     swap(__open_count_, __r.__open_count_);
     swap(__start_, __r.__start_);
     swap(__end_, __r.__end_);
+    swap(__left_anchor_, __r.__left_anchor_);
 }
 
 template <class _CharT, class _Traits>
@@ -2882,9 +2850,7 @@ __lookahead<_CharT, _Traits>::__exec(__state& __s) const
     match_results<const _CharT*> __m;
     __m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_);
     bool __matched = __exp_.__match_at_start_ecma(__s.__current_, __s.__last_,
-                                                  __m,
-                                                  __s.__flags_ | regex_constants::match_continuous,
-                                                  true);
+                                                  __m, __s.__flags_);
     if (__matched != __invert_)
     {
         __s.__do_ = __state::__accept_but_not_consume;
@@ -4121,6 +4087,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
                                 basic_regex __exp;
                                 __exp.__flags_ = __flags_;
                                 __temp = __exp.__parse(++__temp, __last);
+                                __exp.__push_l_anchor();
                                 __push_lookahead(_STD::move(__exp), false);
 #ifndef _LIBCPP_NO_EXCEPTIONS
                                 if (__temp == __last || *__temp != ')')
@@ -4134,6 +4101,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
                                 basic_regex __exp;
                                 __exp.__flags_ = __flags_;
                                 __temp = __exp.__parse(++__temp, __last);
+                                __exp.__push_l_anchor();
                                 __push_lookahead(_STD::move(__exp), true);
 #ifndef _LIBCPP_NO_EXCEPTIONS
                                 if (__temp == __last || *__temp != ')')
@@ -4608,14 +4576,6 @@ basic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub)
     }
 }
 
-template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_l_anchor()
-{
-    __end_->first() = new __l_anchor<_CharT>(__end_->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
-}
-
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_r_anchor()
@@ -5481,7 +5441,7 @@ bool
 basic_regex<_CharT, _Traits>::__match_at_start_ecma(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
+        regex_constants::match_flag_type __flags) const
 {
     vector<__state> __states;
     ptrdiff_t __j = 0;
@@ -5498,7 +5458,6 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
         __states.back().__loop_data_.resize(__loop_count());
         __states.back().__node_ = __st;
         __states.back().__flags_ = __flags;
-        __states.back().__at_first_ = __at_first;
         bool __matched = false;
         do
         {
@@ -5547,7 +5506,7 @@ bool
 basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
+        regex_constants::match_flag_type __flags) const
 {
     deque<__state> __states;
     ptrdiff_t __highest_j = 0;
@@ -5563,7 +5522,6 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
         __states.back().__loop_data_.resize(__loop_count());
         __states.back().__node_ = __st;
         __states.back().__flags_ = __flags;
-        __states.back().__at_first_ = __at_first;
         bool __matched = false;
         do
         {
@@ -5625,7 +5583,7 @@ bool
 basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
+        regex_constants::match_flag_type __flags) const
 {
     vector<__state> __states;
     __state __best_state;
@@ -5644,7 +5602,6 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
         __states.back().__loop_data_.resize(__loop_count());
         __states.back().__node_ = __st;
         __states.back().__flags_ = __flags;
-        __states.back().__at_first_ = __at_first;
         const _CharT* __current = __first;
         bool __matched = false;
         do
@@ -5710,13 +5667,13 @@ bool
 basic_regex<_CharT, _Traits>::__match_at_start(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
+        regex_constants::match_flag_type __flags) const
 {
     if ((__flags_ & 0x1F0) == ECMAScript)
-        return __match_at_start_ecma(__first, __last, __m, __flags, __at_first);
+        return __match_at_start_ecma(__first, __last, __m, __flags);
     if (mark_count() == 0)
-        return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first);
-    return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first);
+        return __match_at_start_posix_nosubs(__first, __last, __m, __flags);
+    return __match_at_start_posix_subs(__first, __last, __m, __flags);
 }
 
 template <class _CharT, class _Traits>
@@ -5727,9 +5684,11 @@ basic_regex<_CharT, _Traits>::__search(
         match_results<const _CharT*, _Allocator>& __m,
         regex_constants::match_flag_type __flags) const
 {
+    if (__left_anchor_)
+        __flags |= regex_constants::match_continuous;
     __m.__init(1 + mark_count(), __first, __last,
                                     __flags & regex_constants::__no_update_pos);
-    if (__match_at_start(__first, __last, __m, __flags, true))
+    if (__match_at_start(__first, __last, __m, __flags))
     {
         __m.__prefix_.second = __m[0].first;
         __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
@@ -5743,7 +5702,7 @@ basic_regex<_CharT, _Traits>::__search(
         for (++__first; __first != __last; ++__first)
         {
             __m.__matches_.assign(__m.size(), __m.__unmatched_);
-            if (__match_at_start(__first, __last, __m, __flags, false))
+            if (__match_at_start(__first, __last, __m, __flags))
             {
                 __m.__prefix_.second = __m[0].first;
                 __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;

include/utility

@@ -211,13 +211,6 @@ struct _LIBCPP_VISIBLE pair
     _LIBCPP_INLINE_VISIBILITY pair(const _T1& __x, const _T2& __y)
         : first(__x), second(__y) {}
 
-    template<class _U1, class _U2>
-        _LIBCPP_INLINE_VISIBILITY
-        pair(const pair<_U1, _U2>& __p,
-                 typename enable_if<is_convertible<_U1, _T1>::value &&
-                                    is_convertible<_U2, _T2>::value>::type* = 0)
-            : first(__p.first), second(__p.second) {}
-
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     template <class _U1, class _U2,
@@ -229,14 +222,6 @@ struct _LIBCPP_VISIBLE pair
               second(_STD::forward<_U2>(__u2))
             {}
 
-    template<class _U1, class _U2>
-        _LIBCPP_INLINE_VISIBILITY
-        pair(pair<_U1, _U2>&& __p,
-                 typename enable_if<is_convertible<_U1, _T1>::value &&
-                                    is_convertible<_U2, _T2>::value>::type* = 0)
-            : first(_STD::forward<_U1>(__p.first)),
-              second(_STD::forward<_U2>(__p.second)) {}
-
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     template<class _Tuple,
@@ -276,6 +261,10 @@ struct _LIBCPP_VISIBLE pair
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
+#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    template<class _U1, class _U2>
+        _LIBCPP_INLINE_VISIBILITY pair(const pair<_U1, _U2>& __p)
+            : first(__p.first), second(__p.second) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void _LIBCPP_INLINE_VISIBILITY swap(pair& __p) {_STD::swap(*this, __p);}
 private:

lib/buildit

@@ -17,11 +17,6 @@ then
 	CXX=clang++
 fi
 
-if [ -z "$CC" ]
-then
-    CC=clang
-fi
-
 if [ -z $MACOSX_DEPLOYMENT_TARGET ]
 then
   MACOSX_DEPLOYMENT_TARGET=10.6
@@ -34,7 +29,7 @@ fi
 
 case $TRIPLE in
   *-apple-*)
-    if [ -z $RC_XBS ]
+    if [ -z $RC_BUILDIT ]
     then
       RC_CFLAGS="-arch i386 -arch x86_64"
     fi
@@ -50,24 +45,16 @@ case $TRIPLE in
 			-Wl,-unexported_symbols_list,libc++unexp.exp  \
 			/usr/lib/libSystem.B.dylib"
 	else
-		EXTRA_FLAGS="-std=c++0x "
-		RE_EXPORT_FILE="libc++abi.exp"
-		if [ -n "$SDKROOT" ]
-		then
-			EXTRA_FLAGS+="-isysroot ${SDKROOT}"
-			RE_EXPORT_FILE="libc++sjlj-abi.exp"
-			CXX=`xcrun -sdk "${SDKROOT}"  -find clang++`
-			CC=`xcrun -sdk "${SDKROOT}"  -find clang`
-		fi
-	    LDSHARED_FLAGS="-o libc++.1.dylib \
+	    EXTRA_FLAGS="-std=c++0x"
+		LDSHARED_FLAGS="-o libc++.1.dylib \
 			-dynamiclib -nodefaultlibs  \
 			-current_version ${RC_ProjectSourceVersion} -compatibility_version 1 \
 			-install_name /usr/lib/libc++.1.dylib \
 			${SDKROOT}/usr/lib/libc++abi.dylib \
 			-lSystem  \
 			-Wl,-unexported_symbols_list,libc++unexp.exp  \
-                        -Wl,-reexported_symbols_list,${RE_EXPORT_FILE}  \
-			-Wl,-force_symbols_not_weak_list,notweak.exp "
+			-Wl,-reexported_symbols_list,libc++abi.exp \
+			-Wl,-force_symbols_not_weak_list,notweak.exp"
 	fi
     ;;
   *)
@@ -79,7 +66,7 @@ case $TRIPLE in
     ;;
 esac
 
-if [ -z $RC_XBS ]
+if [ -z $RC_BUILDIT ]
 then
     rm -f libc++.1.$SOEXT*
 fi
@@ -91,11 +78,11 @@ for FILE in ../src/*.cpp; do
 done
 
 
-$CC *.o $RC_CFLAGS $LDSHARED_FLAGS $EXTRA_FLAGS
+cc *.o $RC_CFLAGS $LDSHARED_FLAGS
 
 #libtool -static -o libc++.a *.o
 
-if [ -z $RC_XBS ]
+if [ -z $RC_BUILDIT ]
 then
     rm *.o
 fi

lib/libc++sjlj-abi.exp

@@ -1,159 +0,0 @@
-___cxa_allocate_exception
-___cxa_end_catch
-___cxa_demangle
-___cxa_current_exception_type
-___cxa_call_unexpected
-___cxa_free_exception
-___cxa_get_exception_ptr
-___cxa_get_globals
-___cxa_get_globals_fast
-___cxa_guard_abort
-___cxa_guard_acquire
-___cxa_guard_release
-___cxa_rethrow
-___cxa_pure_virtual
-___cxa_begin_catch
-___cxa_throw
-___cxa_vec_cctor
-___cxa_vec_cleanup
-___cxa_vec_ctor
-___cxa_vec_delete
-___cxa_vec_delete2
-___cxa_vec_delete3
-___cxa_vec_dtor
-___cxa_vec_new
-___cxa_vec_new2
-___cxa_vec_new3
-___dynamic_cast
-___gxx_personality_sj0
-#__ZTIDi
-#__ZTIDn
-#__ZTIDs
-#__ZTIPDi
-#__ZTIPDn
-#__ZTIPDs
-#__ZTIPKDi
-#__ZTIPKDn
-#__ZTIPKDs
-__ZTSPm
-__ZTSPl
-__ZTSPj
-__ZTSPi
-__ZTSPh
-__ZTSPf
-__ZTSPe
-__ZTSPd
-__ZTSPc
-__ZTSPb
-__ZTSPa
-__ZTSPKc
-__ZTSPKy
-__ZTSPKx
-__ZTSPKw
-__ZTSPKv
-__ZTSPKt
-__ZTSPKs
-__ZTSPKm
-__ZTSPKl
-__ZTSPKi
-__ZTSPKh
-__ZTSPs
-__ZTSPt
-__ZTSPv
-__ZTSPw
-__ZTSPKa
-__ZTSPx
-__ZTSPy
-__ZTSPKd
-__ZTSPKe
-__ZTSPKj
-__ZTSPKb
-__ZTSPKf
-__ZTSv
-__ZTSt
-__ZTSs
-__ZTSm
-__ZTSl
-__ZTSj
-__ZTSi
-__ZTSh
-__ZTSf
-__ZTSe
-__ZTSd
-__ZTSc
-__ZTSw
-__ZTSx
-__ZTSy
-__ZTSb
-__ZTSa
-__ZTIPKh
-__ZTIPKf
-__ZTIPKe
-__ZTIPKd
-__ZTIPKc
-__ZTIPKb
-__ZTIPKa
-__ZTIPy
-__ZTIPx
-__ZTIPw
-__ZTIPv
-__ZTIPt
-__ZTIPs
-__ZTIPm
-__ZTIPl
-__ZTIPj
-__ZTIPi
-__ZTIPKi
-__ZTIPKj
-__ZTIPKl
-__ZTIPKm
-__ZTIPKs
-__ZTIPKt
-__ZTIPKv
-__ZTIPKw
-__ZTIPKx
-__ZTIPKy
-__ZTIPa
-__ZTIPb
-__ZTIPc
-__ZTIPd
-__ZTIPe
-__ZTIPf
-__ZTIPh
-__ZTVN10__cxxabiv129__pointer_to_member_type_infoE
-__ZTVN10__cxxabiv116__enum_type_infoE
-__ZTVN10__cxxabiv117__array_type_infoE
-__ZTVN10__cxxabiv117__class_type_infoE
-__ZTVN10__cxxabiv117__pbase_type_infoE
-__ZTVN10__cxxabiv119__pointer_type_infoE
-__ZTVN10__cxxabiv120__function_type_infoE
-__ZTVN10__cxxabiv120__si_class_type_infoE
-__ZTVN10__cxxabiv121__vmi_class_type_infoE
-__ZTVN10__cxxabiv123__fundamental_type_infoE
-__ZTIa
-__ZTIb
-__ZTIc
-__ZTId
-__ZTIe
-__ZTIf
-__ZTIh
-__ZTIi
-__ZTIj
-__ZTIl
-__ZTIm
-__ZTIs
-__ZTIt
-__ZTSN10__cxxabiv129__pointer_to_member_type_infoE
-__ZTSN10__cxxabiv123__fundamental_type_infoE
-__ZTSN10__cxxabiv121__vmi_class_type_infoE
-__ZTSN10__cxxabiv120__si_class_type_infoE
-__ZTSN10__cxxabiv120__function_type_infoE
-__ZTSN10__cxxabiv119__pointer_type_infoE
-__ZTSN10__cxxabiv117__pbase_type_infoE
-__ZTSN10__cxxabiv117__class_type_infoE
-__ZTSN10__cxxabiv117__array_type_infoE
-__ZTSN10__cxxabiv116__enum_type_infoE
-__ZTIy
-__ZTIx
-__ZTIw
-__ZTIv