@zigc/lib 0.17.0-dev.135 → 0.17.0-dev.215

package/libcxx/include/__bit/rotate.h

@@ -22,46 +22,35 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // Writing two full functions for rotl and rotr makes it easier for the compiler
 // to optimize the code. On x86 this function becomes the ROL instruction and
 // the rotr function becomes the ROR instruction.
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __rotl(_Tp __x, int __s) _NOEXCEPT {
-  static_assert(__is_unsigned_integer_v<_Tp>, "__rotl requires an unsigned integer type");
+
+#if _LIBCPP_STD_VER >= 20
+
+template <__unsigned_integer _Tp>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotl(_Tp __t, int __cnt) noexcept {
   const int __n = numeric_limits<_Tp>::digits;
-  int __r       = __s % __n;
+  int __r       = __cnt % __n;
 
   if (__r == 0)
-    return __x;
+    return __t;
 
   if (__r > 0)
-    return (__x << __r) | (__x >> (__n - __r));
+    return (__t << __r) | (__t >> (__n - __r));
 
-  return (__x >> -__r) | (__x << (__n + __r));
+  return (__t >> -__r) | (__t << (__n + __r));
 }
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __rotr(_Tp __x, int __s) _NOEXCEPT {
-  static_assert(__is_unsigned_integer_v<_Tp>, "__rotr requires an unsigned integer type");
+template <__unsigned_integer _Tp>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotr(_Tp __t, int __cnt) noexcept {
   const int __n = numeric_limits<_Tp>::digits;
-  int __r       = __s % __n;
+  int __r       = __cnt % __n;
 
   if (__r == 0)
-    return __x;
+    return __t;
 
   if (__r > 0)
-    return (__x >> __r) | (__x << (__n - __r));
-
-  return (__x << -__r) | (__x >> (__n + __r));
-}
+    return (__t >> __r) | (__t << (__n - __r));
 
-#if _LIBCPP_STD_VER >= 20
-
-template <__unsigned_integer _Tp>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotl(_Tp __t, int __cnt) noexcept {
-  return std::__rotl(__t, __cnt);
-}
-
-template <__unsigned_integer _Tp>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotr(_Tp __t, int __cnt) noexcept {
-  return std::__rotr(__t, __cnt);
+  return (__t << -__r) | (__t >> (__n + __r));
 }
 
 #endif // _LIBCPP_STD_VER >= 20

package/libcxx/include/__bit_reference

@@ -15,8 +15,10 @@
 #include <__algorithm/copy_backward.h>
 #include <__algorithm/copy_n.h>
 #include <__algorithm/equal.h>
+#include <__algorithm/fill_n.h>
 #include <__algorithm/min.h>
 #include <__algorithm/rotate.h>
+#include <__algorithm/specialized_algorithms.h>
 #include <__algorithm/swap_ranges.h>
 #include <__assert>
 #include <__bit/countr.h>
@@ -137,7 +139,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 operator bool() const _NOEXCEPT {
     return static_cast<bool>(*__seg_ & __mask_);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool operator~() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool operator~() const _NOEXCEPT {
     return !static_cast<bool>(*this);
   }
 
@@ -307,6 +309,15 @@ public:
   {
   }
 
+#ifdef _LIBCPP_ABI_TRIVIALLY_COPYABLE_BIT_ITERATOR
+  template <bool _IsConstDep = _IsConst, __enable_if_t<_IsConstDep, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
+      : __seg_(__it.__seg_),
+        __ctz_(__it.__ctz_) {}
+
+  _LIBCPP_HIDE_FROM_ABI __bit_iterator(const __bit_iterator&)            = default;
+  _LIBCPP_HIDE_FROM_ABI __bit_iterator& operator=(const __bit_iterator&) = default;
+#else
   // When _IsConst=false, this is the copy constructor.
   // It is non-trivial. Making it trivial would break ABI.
   // When _IsConst=true, this is a converting constructor;
@@ -327,6 +338,7 @@ public:
     __ctz_ = __it.__ctz_;
     return *this;
   }
+#endif
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator*() const _NOEXCEPT {
     _LIBCPP_ASSERT_INTERNAL(__ctz_ < __bits_per_word, "Dereferencing an invalid __bit_iterator.");
@@ -467,20 +479,6 @@ private:
   template <class _Dp>
   friend struct __bit_array;
 
-  template <bool _FillVal, class _Dp>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend void
-  __fill_n_bool(__bit_iterator<_Dp, false> __first, typename __size_difference_type_traits<_Dp>::size_type __n);
-
-  template <class _Dp, bool _IC>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_aligned(
-      __bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
-  template <class _Dp, bool _IC>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_unaligned(
-      __bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
-  template <class _Dp, bool _IC>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend pair<__bit_iterator<_Dp, _IC>, __bit_iterator<_Dp, false> >
-  __copy_impl::operator()(
-      __bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result) const;
   template <class _Dp, bool _IC>
   _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_backward_aligned(
       __bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
@@ -511,10 +509,20 @@ private:
             bool _IsConst1,
             bool _IsConst2,
             class _BinaryPredicate,
-            __enable_if_t<__desugars_to_v<__equal_tag, _BinaryPredicate, bool, bool>, int> >
+            class _Proj1,
+            class _Proj2,
+            __enable_if_t<__is_identity<_Proj1>::value && __is_identity<_Proj2>::value &&
+                              __desugars_to_v<__equal_tag, _BinaryPredicate, bool, bool>,
+                          int> >
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool __equal_iter_impl(
-      __bit_iterator<_Dp, _IsConst1>, __bit_iterator<_Dp, _IsConst1>, __bit_iterator<_Dp, _IsConst2>, _BinaryPredicate);
-  template <class _Dp,
+      __bit_iterator<_Dp, _IsConst1>,
+      __bit_iterator<_Dp, _IsConst1>,
+      __bit_iterator<_Dp, _IsConst2>,
+      _BinaryPredicate,
+      _Proj1&,
+      _Proj2&);
+  template <bool,
+            class _Dp,
             bool _IsConst1,
             bool _IsConst2,
             class _Pred,
@@ -537,6 +545,187 @@ private:
   template <bool _ToCount, class _Dp, bool _IC>
   friend typename __bit_iterator<_Dp, _IC>::difference_type _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
   __count_bool(__bit_iterator<_Dp, _IC>, typename __size_difference_type_traits<_Dp>::size_type);
+
+  template <class, class...>
+  friend struct __specialized_algorithm;
+};
+
+template <class _Cp>
+struct __specialized_algorithm<_Algorithm::__fill_n, __single_iterator<__bit_iterator<_Cp, false> > > {
+  static const bool __has_algorithm = true;
+
+  template <bool _FillVal>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void
+  __impl(__bit_iterator<_Cp, false> __first, typename __size_difference_type_traits<_Cp>::size_type __n) {
+    using _It            = __bit_iterator<_Cp, false>;
+    using __storage_type = typename _It::__storage_type;
+
+    const int __bits_per_word = _It::__bits_per_word;
+    // do first partial word
+    if (__first.__ctz_ != 0) {
+      __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+      __storage_type __dn    = std::min(__clz_f, __n);
+      std::__fill_masked_range(std::__to_address(__first.__seg_), __clz_f - __dn, __first.__ctz_, _FillVal);
+      __n -= __dn;
+      ++__first.__seg_;
+    }
+    // do middle whole words
+    __storage_type __nw = __n / __bits_per_word;
+    std::__fill_n(std::__to_address(__first.__seg_), __nw, _FillVal ? static_cast<__storage_type>(-1) : 0);
+    __n -= __nw * __bits_per_word;
+    // do last partial word
+    if (__n > 0) {
+      __first.__seg_ += __nw;
+      std::__fill_masked_range(std::__to_address(__first.__seg_), __bits_per_word - __n, 0u, _FillVal);
+    }
+  }
+
+  template <class _Size, class _Tp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static __bit_iterator<_Cp, false>
+  operator()(__bit_iterator<_Cp, false> __first, _Size __n, const _Tp& __value) {
+    if (__n > 0) {
+      if (__value)
+        __impl<true>(__first, __n);
+      else
+        __impl<false>(__first, __n);
+    }
+    return __first + __n;
+  }
+};
+
+template <class _Cp, bool _IsConst>
+struct __specialized_algorithm<_Algorithm::__copy,
+                               __iterator_pair<__bit_iterator<_Cp, _IsConst>, __bit_iterator<_Cp, _IsConst> >,
+                               __single_iterator<__bit_iterator<_Cp, false> > > {
+  static const bool __has_algorithm = true;
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static __bit_iterator<_Cp, false>
+  __aligned_impl(__bit_iterator<_Cp, _IsConst> __first,
+                 __bit_iterator<_Cp, _IsConst> __last,
+                 __bit_iterator<_Cp, false> __result) {
+    using _In             = __bit_iterator<_Cp, _IsConst>;
+    using difference_type = typename _In::difference_type;
+    using __storage_type  = typename _In::__storage_type;
+
+    const int __bits_per_word = _In::__bits_per_word;
+    difference_type __n       = __last - __first;
+    if (__n > 0) {
+      // do first word
+      if (__first.__ctz_ != 0) {
+        unsigned __clz       = __bits_per_word - __first.__ctz_;
+        difference_type __dn = std::min(static_cast<difference_type>(__clz), __n);
+        __n -= __dn;
+        __storage_type __m = std::__middle_mask<__storage_type>(__clz - __dn, __first.__ctz_);
+        __storage_type __b = *__first.__seg_ & __m;
+        *__result.__seg_ &= ~__m;
+        *__result.__seg_ |= __b;
+        __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+        __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
+        ++__first.__seg_;
+        // __first.__ctz_ = 0;
+      }
+      // __first.__ctz_ == 0;
+      // do middle words
+      __storage_type __nw = __n / __bits_per_word;
+      std::copy(std::__to_address(__first.__seg_),
+                std::__to_address(__first.__seg_ + __nw),
+                std::__to_address(__result.__seg_));
+      __n -= __nw * __bits_per_word;
+      __result.__seg_ += __nw;
+      // do last word
+      if (__n > 0) {
+        __first.__seg_ += __nw;
+        __storage_type __m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
+        __storage_type __b = *__first.__seg_ & __m;
+        *__result.__seg_ &= ~__m;
+        *__result.__seg_ |= __b;
+        __result.__ctz_ = static_cast<unsigned>(__n);
+      }
+    }
+    return __result;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static __bit_iterator<_Cp, false>
+  __unaligned_impl(__bit_iterator<_Cp, _IsConst> __first,
+                   __bit_iterator<_Cp, _IsConst> __last,
+                   __bit_iterator<_Cp, false> __result) {
+    using _In             = __bit_iterator<_Cp, _IsConst>;
+    using difference_type = typename _In::difference_type;
+    using __storage_type  = typename _In::__storage_type;
+
+    const int __bits_per_word = _In::__bits_per_word;
+    difference_type __n       = __last - __first;
+    if (__n > 0) {
+      // do first word
+      if (__first.__ctz_ != 0) {
+        unsigned __clz_f     = __bits_per_word - __first.__ctz_;
+        difference_type __dn = std::min(static_cast<difference_type>(__clz_f), __n);
+        __n -= __dn;
+        __storage_type __m   = std::__middle_mask<__storage_type>(__clz_f - __dn, __first.__ctz_);
+        __storage_type __b   = *__first.__seg_ & __m;
+        unsigned __clz_r     = __bits_per_word - __result.__ctz_;
+        __storage_type __ddn = std::min<__storage_type>(__dn, __clz_r);
+        __m                  = std::__middle_mask<__storage_type>(__clz_r - __ddn, __result.__ctz_);
+        *__result.__seg_ &= ~__m;
+        if (__result.__ctz_ > __first.__ctz_)
+          *__result.__seg_ |= __b << (__result.__ctz_ - __first.__ctz_);
+        else
+          *__result.__seg_ |= __b >> (__first.__ctz_ - __result.__ctz_);
+        __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
+        __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);
+        __dn -= __ddn;
+        if (__dn > 0) {
+          __m = std::__trailing_mask<__storage_type>(__bits_per_word - __dn);
+          *__result.__seg_ &= ~__m;
+          *__result.__seg_ |= __b >> (__first.__ctz_ + __ddn);
+          __result.__ctz_ = static_cast<unsigned>(__dn);
+        }
+        ++__first.__seg_;
+        // __first.__ctz_ = 0;
+      }
+      // __first.__ctz_ == 0;
+      // do middle words
+      unsigned __clz_r   = __bits_per_word - __result.__ctz_;
+      __storage_type __m = std::__leading_mask<__storage_type>(__result.__ctz_);
+      for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_) {
+        __storage_type __b = *__first.__seg_;
+        *__result.__seg_ &= ~__m;
+        *__result.__seg_ |= __b << __result.__ctz_;
+        ++__result.__seg_;
+        *__result.__seg_ &= __m;
+        *__result.__seg_ |= __b >> __clz_r;
+      }
+      // do last word
+      if (__n > 0) {
+        __m                 = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
+        __storage_type __b  = *__first.__seg_ & __m;
+        __storage_type __dn = std::min(__n, static_cast<difference_type>(__clz_r));
+        __m                 = std::__middle_mask<__storage_type>(__clz_r - __dn, __result.__ctz_);
+        *__result.__seg_ &= ~__m;
+        *__result.__seg_ |= __b << __result.__ctz_;
+        __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+        __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
+        __n -= __dn;
+        if (__n > 0) {
+          __m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
+          *__result.__seg_ &= ~__m;
+          *__result.__seg_ |= __b >> __dn;
+          __result.__ctz_ = static_cast<unsigned>(__n);
+        }
+      }
+    }
+    return __result;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 static pair<__bit_iterator<_Cp, _IsConst>, __bit_iterator<_Cp, false> >
+  operator()(__bit_iterator<_Cp, _IsConst> __first,
+             __bit_iterator<_Cp, _IsConst> __last,
+             __bit_iterator<_Cp, false> __result) {
+    if (__first.__ctz_ == __result.__ctz_)
+      return std::make_pair(__last, __aligned_impl(__first, __last, __result));
+    return std::make_pair(__last, __unaligned_impl(__first, __last, __result));
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD

package/libcxx/include/__charconv/from_chars_integral.h

@@ -18,8 +18,8 @@
 #include <__memory/addressof.h>
 #include <__system_error/errc.h>
 #include <__type_traits/enable_if.h>
-#include <__type_traits/integral_constant.h>
 #include <__type_traits/is_integral.h>
+#include <__type_traits/is_signed.h>
 #include <__type_traits/is_unsigned.h>
 #include <__type_traits/make_unsigned.h>
 #include <limits>

package/libcxx/include/__charconv/from_chars_result.h

@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-struct _LIBCPP_EXPORTED_FROM_ABI from_chars_result {
+struct from_chars_result {
   const char* ptr;
   errc ec;
 #  if _LIBCPP_STD_VER >= 20

package/libcxx/include/__charconv/to_chars_integral.h

@@ -24,6 +24,7 @@
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_integral.h>
 #include <__type_traits/is_same.h>
+#include <__type_traits/is_signed.h>
 #include <__type_traits/make_32_64_or_128_bit.h>
 #include <__type_traits/make_unsigned.h>
 #include <__utility/unreachable.h>

package/libcxx/include/__charconv/to_chars_result.h

@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-struct _LIBCPP_EXPORTED_FROM_ABI to_chars_result {
+struct to_chars_result {
   char* ptr;
   errc ec;
 #  if _LIBCPP_STD_VER >= 20

package/libcxx/include/__charconv/traits.h

@@ -113,31 +113,10 @@ struct _LIBCPP_HIDDEN __traits_base<_Tp, __enable_if_t<sizeof(_Tp) == sizeof(__u
 };
 #  endif
 
-template <typename _Tp>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool
-__mul_overflowed(unsigned char __a, _Tp __b, unsigned char& __r) {
-  auto __c = __a * __b;
-  __r      = __c;
-  return __c > numeric_limits<unsigned char>::max();
-}
-
-template <typename _Tp>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool
-__mul_overflowed(unsigned short __a, _Tp __b, unsigned short& __r) {
-  auto __c = __a * __b;
-  __r      = __c;
-  return __c > numeric_limits<unsigned short>::max();
-}
-
-template <typename _Tp>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool __mul_overflowed(_Tp __a, _Tp __b, _Tp& __r) {
-  static_assert(is_unsigned<_Tp>::value, "");
-  return __builtin_mul_overflow(__a, __b, std::addressof(__r));
-}
-
 template <typename _Tp, typename _Up>
-inline _LIBCPP_HIDE_FROM_ABI bool _LIBCPP_CONSTEXPR_SINCE_CXX23 __mul_overflowed(_Tp __a, _Up __b, _Tp& __r) {
-  return __itoa::__mul_overflowed(__a, static_cast<_Tp>(__b), __r);
+_LIBCPP_HIDE_FROM_ABI bool _LIBCPP_CONSTEXPR_SINCE_CXX23 __mul_overflowed(_Tp __a, _Up __b, _Tp& __r) {
+  static_assert(is_unsigned<_Tp>::value);
+  return __builtin_mul_overflow(__a, static_cast<_Tp>(__b), std::addressof(__r));
 }
 
 template <typename _Tp>

package/libcxx/include/__chrono/day.h

@@ -13,6 +13,8 @@
 #include <__chrono/duration.h>
 #include <__compare/ordering.h>
 #include <__config>
+#include <__cstddef/size_t.h>
+#include <__functional/hash.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -92,6 +94,15 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr day& day::operator-=(const days& __dd) no
 
 } // namespace chrono
 
+#  if _LIBCPP_STD_VER >= 26
+
+template <>
+struct hash<chrono::day> {
+  _LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::day& __d) noexcept { return static_cast<unsigned>(__d); }
+};
+
+#  endif // _LIBCPP_STD_VER >= 26
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20