mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-06-03 03:02:28 +00:00
Release Cosmopolitan v3.6.0
This release is an atomic upgrade to GCC 14.1.0 with C23 and C++23
This commit is contained in:
Justine Tunney
parent
62ace3623a
commit
5660ec4741
1585 changed files with 117353 additions and 271644 deletions
62
third_party/libcxx/__tuple/find_index.h
vendored
Normal file
62
third_party/libcxx/__tuple/find_index.h
vendored
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___TUPLE_FIND_INDEX_H
|
||||
#define _LIBCPP___TUPLE_FIND_INDEX_H
|
||||
|
||||
#include <__config>
|
||||
#include <__type_traits/is_same.h>
|
||||
#include <cstddef>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
# pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#if _LIBCPP_STD_VER >= 14
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
namespace __find_detail {
|
||||
|
||||
static constexpr size_t __not_found = static_cast<size_t>(-1);
|
||||
static constexpr size_t __ambiguous = __not_found - 1;
|
||||
|
||||
inline _LIBCPP_HIDE_FROM_ABI constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
|
||||
return !__matches ? __res : (__res == __not_found ? __curr_i : __ambiguous);
|
||||
}
|
||||
|
||||
template <size_t _Nx>
|
||||
inline _LIBCPP_HIDE_FROM_ABI constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
|
||||
return __i == _Nx
|
||||
? __not_found
|
||||
: __find_detail::__find_idx_return(__i, __find_detail::__find_idx(__i + 1, __matches), __matches[__i]);
|
||||
}
|
||||
|
||||
template <class _T1, class... _Args>
|
||||
struct __find_exactly_one_checked {
|
||||
static constexpr bool __matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...};
|
||||
static constexpr size_t value = __find_detail::__find_idx(0, __matches);
|
||||
static_assert(value != __not_found, "type not found in type list");
|
||||
static_assert(value != __ambiguous, "type occurs more than once in type list");
|
||||
};
|
||||
|
||||
template <class _T1>
|
||||
struct __find_exactly_one_checked<_T1> {
|
||||
static_assert(!is_same<_T1, _T1>::value, "type not in empty type list");
|
||||
};
|
||||
|
||||
} // namespace __find_detail
|
||||
|
||||
template <typename _T1, typename... _Args>
|
||||
struct __find_exactly_one_t : public __find_detail::__find_exactly_one_checked<_T1, _Args...> {};
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP_STD_VER >= 14
|
||||
|
||||
#endif // _LIBCPP___TUPLE_FIND_INDEX_H
|
||||
|
|
@ -6,27 +6,34 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___TUPLE_PAIR_LIKE_H
|
||||
#define _LIBCPP___TUPLE_PAIR_LIKE_H
|
||||
#ifndef _LIBCPP___TUPLE_IGNORE_H
|
||||
#define _LIBCPP___TUPLE_IGNORE_H
|
||||
|
||||
#include <__config>
|
||||
#include <__tuple/tuple_like.h>
|
||||
#include <__tuple/tuple_size.h>
|
||||
#include <__type_traits/remove_cvref.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
# pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
#if _LIBCPP_STD_VER >= 20
|
||||
struct __ignore_type {
|
||||
template <class _Tp>
|
||||
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const __ignore_type& operator=(const _Tp&) const noexcept {
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
concept __pair_like = __tuple_like<_Tp> && tuple_size<remove_cvref_t<_Tp>>::value == 2;
|
||||
|
||||
#endif // _LIBCPP_STD_VER >= 20
|
||||
# if _LIBCPP_STD_VER >= 17
|
||||
inline constexpr __ignore_type ignore;
|
||||
# else
|
||||
constexpr __ignore_type ignore;
|
||||
# endif
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP___TUPLE_PAIR_LIKE_H
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // _LIBCPP___TUPLE_IGNORE_H
|
||||
30
third_party/libcxx/__tuple/make_tuple_types.h
vendored
30
third_party/libcxx/__tuple/make_tuple_types.h
vendored
|
|
@ -16,7 +16,7 @@
|
|||
#include <__tuple/tuple_indices.h>
|
||||
#include <__tuple/tuple_size.h>
|
||||
#include <__tuple/tuple_types.h>
|
||||
#include <__type_traits/apply_cv.h>
|
||||
#include <__type_traits/copy_cvref.h>
|
||||
#include <__type_traits/remove_cv.h>
|
||||
#include <__type_traits/remove_reference.h>
|
||||
#include <cstddef>
|
||||
|
|
@ -37,38 +37,38 @@ _LIBCPP_BEGIN_NAMESPACE_STD
|
|||
template <class _TupleTypes, class _TupleIndices>
|
||||
struct __make_tuple_types_flat;
|
||||
|
||||
template <template <class...> class _Tuple, class ..._Types, size_t ..._Idx>
|
||||
template <template <class...> class _Tuple, class... _Types, size_t... _Idx>
|
||||
struct __make_tuple_types_flat<_Tuple<_Types...>, __tuple_indices<_Idx...>> {
|
||||
// Specialization for pair, tuple, and __tuple_types
|
||||
template <class _Tp>
|
||||
using __apply_quals _LIBCPP_NODEBUG = __tuple_types<__apply_cv_t<_Tp, __type_pack_element<_Idx, _Types...>>...>;
|
||||
using __apply_quals _LIBCPP_NODEBUG = __tuple_types<__copy_cvref_t<_Tp, __type_pack_element<_Idx, _Types...>>...>;
|
||||
};
|
||||
|
||||
template <class _Vt, size_t _Np, size_t ..._Idx>
|
||||
template <class _Vt, size_t _Np, size_t... _Idx>
|
||||
struct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>> {
|
||||
template <size_t>
|
||||
using __value_type = _Vt;
|
||||
template <class _Tp>
|
||||
using __apply_quals = __tuple_types<__apply_cv_t<_Tp, __value_type<_Idx>>...>;
|
||||
using __apply_quals = __tuple_types<__copy_cvref_t<_Tp, __value_type<_Idx>>...>;
|
||||
};
|
||||
|
||||
template <class _Tp, size_t _Ep = tuple_size<__libcpp_remove_reference_t<_Tp> >::value,
|
||||
size_t _Sp = 0,
|
||||
template <class _Tp,
|
||||
size_t _Ep = tuple_size<__libcpp_remove_reference_t<_Tp> >::value,
|
||||
size_t _Sp = 0,
|
||||
bool _SameSize = (_Ep == tuple_size<__libcpp_remove_reference_t<_Tp> >::value)>
|
||||
struct __make_tuple_types
|
||||
{
|
||||
static_assert(_Sp <= _Ep, "__make_tuple_types input error");
|
||||
using _RawTp = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >;
|
||||
using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>;
|
||||
using type = typename _Maker::template __apply_quals<_Tp>;
|
||||
struct __make_tuple_types {
|
||||
static_assert(_Sp <= _Ep, "__make_tuple_types input error");
|
||||
using _RawTp = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >;
|
||||
using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>;
|
||||
using type = typename _Maker::template __apply_quals<_Tp>;
|
||||
};
|
||||
|
||||
template <class ..._Types, size_t _Ep>
|
||||
template <class... _Types, size_t _Ep>
|
||||
struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> {
|
||||
typedef _LIBCPP_NODEBUG __tuple_types<_Types...> type;
|
||||
};
|
||||
|
||||
template <class ..._Types, size_t _Ep>
|
||||
template <class... _Types, size_t _Ep>
|
||||
struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> {
|
||||
typedef _LIBCPP_NODEBUG __tuple_types<_Types...> type;
|
||||
};
|
||||
|
|
|
|||
147
third_party/libcxx/__tuple/sfinae_helpers.h
vendored
147
third_party/libcxx/__tuple/sfinae_helpers.h
vendored
|
|
@ -16,11 +16,10 @@
|
|||
#include <__tuple/tuple_like_ext.h>
|
||||
#include <__tuple/tuple_size.h>
|
||||
#include <__tuple/tuple_types.h>
|
||||
#include <__type_traits/conjunction.h>
|
||||
#include <__type_traits/enable_if.h>
|
||||
#include <__type_traits/integral_constant.h>
|
||||
#include <__type_traits/is_assignable.h>
|
||||
#include <__type_traits/is_constructible.h>
|
||||
#include <__type_traits/is_convertible.h>
|
||||
#include <__type_traits/is_same.h>
|
||||
#include <__type_traits/remove_cvref.h>
|
||||
#include <__type_traits/remove_reference.h>
|
||||
|
|
@ -34,90 +33,50 @@ _LIBCPP_BEGIN_NAMESPACE_STD
|
|||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
template <bool ..._Preds>
|
||||
struct __all_dummy;
|
||||
|
||||
template <bool ..._Pred>
|
||||
struct __all : _IsSame<__all_dummy<_Pred...>, __all_dummy<((void)_Pred, true)...>> {};
|
||||
|
||||
struct __tuple_sfinae_base {
|
||||
template <template <class, class...> class _Trait,
|
||||
class ..._LArgs, class ..._RArgs>
|
||||
static auto __do_test(__tuple_types<_LArgs...>, __tuple_types<_RArgs...>)
|
||||
-> __all<__enable_if_t<_Trait<_LArgs, _RArgs>::value, bool>{true}...>;
|
||||
template <template <class, class...> class _Trait, class... _LArgs, class... _RArgs>
|
||||
static auto __do_test(__tuple_types<_LArgs...>,
|
||||
__tuple_types<_RArgs...>) -> __all<__enable_if_t<_Trait<_LArgs, _RArgs>::value, bool>{true}...>;
|
||||
template <template <class...> class>
|
||||
static auto __do_test(...) -> false_type;
|
||||
|
||||
template <class _FromArgs, class _ToArgs>
|
||||
using __constructible = decltype(__do_test<is_constructible>(_ToArgs{}, _FromArgs{}));
|
||||
template <class _FromArgs, class _ToArgs>
|
||||
using __convertible = decltype(__do_test<is_convertible>(_FromArgs{}, _ToArgs{}));
|
||||
template <class _FromArgs, class _ToArgs>
|
||||
using __assignable = decltype(__do_test<is_assignable>(_ToArgs{}, _FromArgs{}));
|
||||
};
|
||||
|
||||
// __tuple_convertible
|
||||
|
||||
template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
|
||||
bool = __tuple_like_ext<_Up>::value>
|
||||
struct __tuple_convertible
|
||||
: public false_type {};
|
||||
|
||||
template <class _Tp, class _Up>
|
||||
struct __tuple_convertible<_Tp, _Up, true, true>
|
||||
: public __tuple_sfinae_base::__convertible<
|
||||
typename __make_tuple_types<_Tp>::type
|
||||
, typename __make_tuple_types<_Up>::type
|
||||
>
|
||||
{};
|
||||
|
||||
// __tuple_constructible
|
||||
|
||||
template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
|
||||
bool = __tuple_like_ext<_Up>::value>
|
||||
struct __tuple_constructible
|
||||
: public false_type {};
|
||||
template <class _Tp,
|
||||
class _Up,
|
||||
bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
|
||||
bool = __tuple_like_ext<_Up>::value>
|
||||
struct __tuple_constructible : public false_type {};
|
||||
|
||||
template <class _Tp, class _Up>
|
||||
struct __tuple_constructible<_Tp, _Up, true, true>
|
||||
: public __tuple_sfinae_base::__constructible<
|
||||
typename __make_tuple_types<_Tp>::type
|
||||
, typename __make_tuple_types<_Up>::type
|
||||
>
|
||||
{};
|
||||
: public __tuple_sfinae_base::__constructible< typename __make_tuple_types<_Tp>::type,
|
||||
typename __make_tuple_types<_Up>::type > {};
|
||||
|
||||
// __tuple_assignable
|
||||
|
||||
template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
|
||||
bool = __tuple_like_ext<_Up>::value>
|
||||
struct __tuple_assignable
|
||||
: public false_type {};
|
||||
|
||||
template <class _Tp, class _Up>
|
||||
struct __tuple_assignable<_Tp, _Up, true, true>
|
||||
: public __tuple_sfinae_base::__assignable<
|
||||
typename __make_tuple_types<_Tp>::type
|
||||
, typename __make_tuple_types<_Up&>::type
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template <size_t _Ip, class ..._Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> >
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
|
||||
template <size_t _Ip, class... _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> > {
|
||||
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
|
||||
};
|
||||
|
||||
struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
|
||||
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() { return false; }
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() { return false; }
|
||||
template <class ...>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit() { return false; }
|
||||
template <class ...>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit() { return false; }
|
||||
template <class ...>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_assign() { return false; }
|
||||
struct _LIBCPP_EXPORTED_FROM_ABI __check_tuple_constructor_fail {
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() { return false; }
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() { return false; }
|
||||
template <class...>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit() {
|
||||
return false;
|
||||
}
|
||||
template <class...>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit() {
|
||||
return false;
|
||||
}
|
||||
template <class...>
|
||||
static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_assign() {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
#endif // !defined(_LIBCPP_CXX03_LANG)
|
||||
|
||||
|
|
@ -127,54 +86,54 @@ template <bool _CanCopy, bool _CanMove>
|
|||
struct __sfinae_ctor_base {};
|
||||
template <>
|
||||
struct __sfinae_ctor_base<false, false> {
|
||||
__sfinae_ctor_base() = default;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base &&) = delete;
|
||||
__sfinae_ctor_base() = default;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base&&) = delete;
|
||||
__sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
|
||||
__sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
|
||||
__sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
|
||||
};
|
||||
template <>
|
||||
struct __sfinae_ctor_base<true, false> {
|
||||
__sfinae_ctor_base() = default;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base const&) = default;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base &&) = delete;
|
||||
__sfinae_ctor_base() = default;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base const&) = default;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base&&) = delete;
|
||||
__sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
|
||||
__sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
|
||||
__sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
|
||||
};
|
||||
template <>
|
||||
struct __sfinae_ctor_base<false, true> {
|
||||
__sfinae_ctor_base() = default;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base &&) = default;
|
||||
__sfinae_ctor_base() = default;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
|
||||
__sfinae_ctor_base(__sfinae_ctor_base&&) = default;
|
||||
__sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
|
||||
__sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
|
||||
__sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
|
||||
};
|
||||
|
||||
template <bool _CanCopy, bool _CanMove>
|
||||
struct __sfinae_assign_base {};
|
||||
template <>
|
||||
struct __sfinae_assign_base<false, false> {
|
||||
__sfinae_assign_base() = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base const&) = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base &&) = default;
|
||||
__sfinae_assign_base() = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base const&) = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base&&) = default;
|
||||
__sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
|
||||
__sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete;
|
||||
__sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete;
|
||||
};
|
||||
template <>
|
||||
struct __sfinae_assign_base<true, false> {
|
||||
__sfinae_assign_base() = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base const&) = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base &&) = default;
|
||||
__sfinae_assign_base() = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base const&) = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base&&) = default;
|
||||
__sfinae_assign_base& operator=(__sfinae_assign_base const&) = default;
|
||||
__sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete;
|
||||
__sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete;
|
||||
};
|
||||
template <>
|
||||
struct __sfinae_assign_base<false, true> {
|
||||
__sfinae_assign_base() = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base const&) = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base &&) = default;
|
||||
__sfinae_assign_base() = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base const&) = default;
|
||||
__sfinae_assign_base(__sfinae_assign_base&&) = default;
|
||||
__sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
|
||||
__sfinae_assign_base& operator=(__sfinae_assign_base&&) = default;
|
||||
__sfinae_assign_base& operator=(__sfinae_assign_base&&) = default;
|
||||
};
|
||||
#endif // _LIBCPP_STD_VER >= 17
|
||||
|
||||
|
|
|
|||
67
third_party/libcxx/__tuple/tuple_element.h
vendored
67
third_party/libcxx/__tuple/tuple_element.h
vendored
|
|
@ -12,9 +12,6 @@
|
|||
#include <__config>
|
||||
#include <__tuple/tuple_indices.h>
|
||||
#include <__tuple/tuple_types.h>
|
||||
#include <__type_traits/add_const.h>
|
||||
#include <__type_traits/add_cv.h>
|
||||
#include <__type_traits/add_volatile.h>
|
||||
#include <cstddef>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
|
|
@ -23,68 +20,36 @@
|
|||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <size_t _Ip, class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_element;
|
||||
template <size_t _Ip, class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element;
|
||||
|
||||
template <size_t _Ip, class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp> {
|
||||
typedef _LIBCPP_NODEBUG const typename tuple_element<_Ip, _Tp>::type type;
|
||||
};
|
||||
|
||||
template <size_t _Ip, class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp> {
|
||||
typedef _LIBCPP_NODEBUG volatile typename tuple_element<_Ip, _Tp>::type type;
|
||||
};
|
||||
|
||||
template <size_t _Ip, class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp>
|
||||
{
|
||||
typedef _LIBCPP_NODEBUG typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp> {
|
||||
typedef _LIBCPP_NODEBUG const volatile typename tuple_element<_Ip, _Tp>::type type;
|
||||
};
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
#if !__has_builtin(__type_pack_element)
|
||||
|
||||
namespace __indexer_detail {
|
||||
|
||||
template <size_t _Idx, class _Tp>
|
||||
struct __indexed { using type _LIBCPP_NODEBUG = _Tp; };
|
||||
|
||||
template <class _Types, class _Indexes> struct __indexer;
|
||||
|
||||
template <class ..._Types, size_t ..._Idx>
|
||||
struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>>
|
||||
: __indexed<_Idx, _Types>...
|
||||
{};
|
||||
|
||||
template <size_t _Idx, class _Tp>
|
||||
__indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&);
|
||||
|
||||
} // namespace __indexer_detail
|
||||
|
||||
template <size_t _Idx, class ..._Types>
|
||||
using __type_pack_element _LIBCPP_NODEBUG = typename decltype(
|
||||
__indexer_detail::__at_index<_Idx>(
|
||||
__indexer_detail::__indexer<
|
||||
__tuple_types<_Types...>,
|
||||
typename __make_tuple_indices<sizeof...(_Types)>::type
|
||||
>{})
|
||||
)::type;
|
||||
#endif
|
||||
|
||||
template <size_t _Ip, class ..._Types>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...> >
|
||||
{
|
||||
static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
|
||||
typedef _LIBCPP_NODEBUG __type_pack_element<_Ip, _Types...> type;
|
||||
template <size_t _Ip, class... _Types>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...> > {
|
||||
static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
|
||||
typedef _LIBCPP_NODEBUG __type_pack_element<_Ip, _Types...> type;
|
||||
};
|
||||
|
||||
#if _LIBCPP_STD_VER >= 14
|
||||
template <size_t _Ip, class ..._Tp>
|
||||
using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element <_Ip, _Tp...>::type;
|
||||
#endif
|
||||
# if _LIBCPP_STD_VER >= 14
|
||||
template <size_t _Ip, class... _Tp>
|
||||
using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element<_Ip, _Tp...>::type;
|
||||
# endif
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
|
|
|
|||
10
third_party/libcxx/__tuple/tuple_indices.h
vendored
10
third_party/libcxx/__tuple/tuple_indices.h
vendored
|
|
@ -21,13 +21,13 @@
|
|||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <size_t...> struct __tuple_indices {};
|
||||
template <size_t...>
|
||||
struct __tuple_indices {};
|
||||
|
||||
template <size_t _Ep, size_t _Sp = 0>
|
||||
struct __make_tuple_indices
|
||||
{
|
||||
static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
|
||||
typedef __make_indices_imp<_Ep, _Sp> type;
|
||||
struct __make_tuple_indices {
|
||||
static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
|
||||
typedef __make_indices_imp<_Ep, _Sp> type;
|
||||
};
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
|
|
|||
27
third_party/libcxx/__tuple/tuple_like.h
vendored
27
third_party/libcxx/__tuple/tuple_like.h
vendored
|
|
@ -10,13 +10,10 @@
|
|||
#define _LIBCPP___TUPLE_TUPLE_LIKE_H
|
||||
|
||||
#include <__config>
|
||||
#include <__fwd/array.h>
|
||||
#include <__fwd/pair.h>
|
||||
#include <__fwd/subrange.h>
|
||||
#include <__fwd/tuple.h>
|
||||
#include <__type_traits/integral_constant.h>
|
||||
#include <__tuple/tuple_like_no_subrange.h>
|
||||
#include <__tuple/tuple_size.h>
|
||||
#include <__type_traits/remove_cvref.h>
|
||||
#include <cstddef>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
# pragma GCC system_header
|
||||
|
|
@ -27,22 +24,16 @@ _LIBCPP_BEGIN_NAMESPACE_STD
|
|||
#if _LIBCPP_STD_VER >= 20
|
||||
|
||||
template <class _Tp>
|
||||
struct __tuple_like_impl : false_type {};
|
||||
inline constexpr bool __is_ranges_subrange_v = false;
|
||||
|
||||
template <class... _Tp>
|
||||
struct __tuple_like_impl<tuple<_Tp...> > : true_type {};
|
||||
|
||||
template <class _T1, class _T2>
|
||||
struct __tuple_like_impl<pair<_T1, _T2> > : true_type {};
|
||||
|
||||
template <class _Tp, size_t _Size>
|
||||
struct __tuple_like_impl<array<_Tp, _Size> > : true_type {};
|
||||
|
||||
template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
|
||||
struct __tuple_like_impl<ranges::subrange<_Ip, _Sp, _Kp> > : true_type {};
|
||||
template <class _Iter, class _Sent, ranges::subrange_kind _Kind>
|
||||
inline constexpr bool __is_ranges_subrange_v<ranges::subrange<_Iter, _Sent, _Kind>> = true;
|
||||
|
||||
template <class _Tp>
|
||||
concept __tuple_like = __tuple_like_impl<remove_cvref_t<_Tp>>::value;
|
||||
concept __tuple_like = __tuple_like_no_subrange<_Tp> || __is_ranges_subrange_v<remove_cvref_t<_Tp>>;
|
||||
|
||||
// As of writing this comment every use of `pair-like` in the standard excludes `ranges::subrange`, so
|
||||
// you most likely want to use `__pair_like_no_subrange` if you're looking for `pair-like`.
|
||||
|
||||
#endif // _LIBCPP_STD_VER >= 20
|
||||
|
||||
|
|
|
|||
24
third_party/libcxx/__tuple/tuple_like_ext.h
vendored
24
third_party/libcxx/__tuple/tuple_like_ext.h
vendored
|
|
@ -23,21 +23,29 @@
|
|||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp> struct __tuple_like_ext : false_type {};
|
||||
template <class _Tp>
|
||||
struct __tuple_like_ext : false_type {};
|
||||
|
||||
template <class _Tp> struct __tuple_like_ext<const _Tp> : public __tuple_like_ext<_Tp> {};
|
||||
template <class _Tp> struct __tuple_like_ext<volatile _Tp> : public __tuple_like_ext<_Tp> {};
|
||||
template <class _Tp> struct __tuple_like_ext<const volatile _Tp> : public __tuple_like_ext<_Tp> {};
|
||||
template <class _Tp>
|
||||
struct __tuple_like_ext<const _Tp> : public __tuple_like_ext<_Tp> {};
|
||||
template <class _Tp>
|
||||
struct __tuple_like_ext<volatile _Tp> : public __tuple_like_ext<_Tp> {};
|
||||
template <class _Tp>
|
||||
struct __tuple_like_ext<const volatile _Tp> : public __tuple_like_ext<_Tp> {};
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
template <class... _Tp> struct __tuple_like_ext<tuple<_Tp...> > : true_type {};
|
||||
template <class... _Tp>
|
||||
struct __tuple_like_ext<tuple<_Tp...> > : true_type {};
|
||||
#endif
|
||||
|
||||
template <class _T1, class _T2> struct __tuple_like_ext<pair<_T1, _T2> > : true_type {};
|
||||
template <class _T1, class _T2>
|
||||
struct __tuple_like_ext<pair<_T1, _T2> > : true_type {};
|
||||
|
||||
template <class _Tp, size_t _Size> struct __tuple_like_ext<array<_Tp, _Size> > : true_type {};
|
||||
template <class _Tp, size_t _Size>
|
||||
struct __tuple_like_ext<array<_Tp, _Size> > : true_type {};
|
||||
|
||||
template <class... _Tp> struct __tuple_like_ext<__tuple_types<_Tp...> > : true_type {};
|
||||
template <class... _Tp>
|
||||
struct __tuple_like_ext<__tuple_types<_Tp...> > : true_type {};
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
|
|
|
|||
61
third_party/libcxx/__tuple/tuple_like_no_subrange.h
vendored
Normal file
61
third_party/libcxx/__tuple/tuple_like_no_subrange.h
vendored
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||||
// See https://llvm.org/LICENSE.txt for license information.
|
||||
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP___TUPLE_TUPLE_LIKE_NO_SUBRANGE_H
|
||||
#define _LIBCPP___TUPLE_TUPLE_LIKE_NO_SUBRANGE_H
|
||||
|
||||
#include <__config>
|
||||
#include <__fwd/array.h>
|
||||
#include <__fwd/complex.h>
|
||||
#include <__fwd/pair.h>
|
||||
#include <__fwd/tuple.h>
|
||||
#include <__tuple/tuple_size.h>
|
||||
#include <__type_traits/remove_cvref.h>
|
||||
#include <cstddef>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
# pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
#if _LIBCPP_STD_VER >= 20
|
||||
|
||||
template <class _Tp>
|
||||
inline constexpr bool __tuple_like_no_subrange_impl = false;
|
||||
|
||||
template <class... _Tp>
|
||||
inline constexpr bool __tuple_like_no_subrange_impl<tuple<_Tp...>> = true;
|
||||
|
||||
template <class _T1, class _T2>
|
||||
inline constexpr bool __tuple_like_no_subrange_impl<pair<_T1, _T2>> = true;
|
||||
|
||||
template <class _Tp, size_t _Size>
|
||||
inline constexpr bool __tuple_like_no_subrange_impl<array<_Tp, _Size>> = true;
|
||||
|
||||
# if _LIBCPP_STD_VER >= 26
|
||||
|
||||
template <class _Tp>
|
||||
inline constexpr bool __tuple_like_no_subrange_impl<complex<_Tp>> = true;
|
||||
|
||||
# endif
|
||||
|
||||
template <class _Tp>
|
||||
concept __tuple_like_no_subrange = __tuple_like_no_subrange_impl<remove_cvref_t<_Tp>>;
|
||||
|
||||
// This is equivalent to the exposition-only type trait `pair-like`, except that it is false for specializations of
|
||||
// `ranges::subrange`. This is more useful than the pair-like concept in the standard because every use of `pair-like`
|
||||
// excludes `ranges::subrange`.
|
||||
template <class _Tp>
|
||||
concept __pair_like_no_subrange = __tuple_like_no_subrange<_Tp> && tuple_size<remove_cvref_t<_Tp>>::value == 2;
|
||||
|
||||
#endif // _LIBCPP_STD_VER >= 20
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP___TUPLE_TUPLE_LIKE_NO_SUBRANGE_H
|
||||
50
third_party/libcxx/__tuple/tuple_size.h
vendored
50
third_party/libcxx/__tuple/tuple_size.h
vendored
|
|
@ -22,51 +22,51 @@
|
|||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size;
|
||||
template <class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size;
|
||||
|
||||
#if !defined(_LIBCPP_CXX03_LANG)
|
||||
template <class _Tp, class...>
|
||||
using __enable_if_tuple_size_imp = _Tp;
|
||||
|
||||
template <class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
|
||||
const _Tp,
|
||||
__enable_if_t<!is_volatile<_Tp>::value>,
|
||||
integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< const _Tp,
|
||||
__enable_if_t<!is_volatile<_Tp>::value>,
|
||||
integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
|
||||
: public integral_constant<size_t, tuple_size<_Tp>::value> {};
|
||||
|
||||
template <class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
|
||||
volatile _Tp,
|
||||
__enable_if_t<!is_const<_Tp>::value>,
|
||||
integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< volatile _Tp,
|
||||
__enable_if_t<!is_const<_Tp>::value>,
|
||||
integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
|
||||
: public integral_constant<size_t, tuple_size<_Tp>::value> {};
|
||||
|
||||
template <class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
|
||||
const volatile _Tp,
|
||||
integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
|
||||
struct _LIBCPP_TEMPLATE_VIS
|
||||
tuple_size<__enable_if_tuple_size_imp<const volatile _Tp, integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
|
||||
: public integral_constant<size_t, tuple_size<_Tp>::value> {};
|
||||
|
||||
#else
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {};
|
||||
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};
|
||||
template <class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {};
|
||||
template <class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {};
|
||||
template <class _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};
|
||||
#endif
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
template <class ..._Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> >
|
||||
: public integral_constant<size_t, sizeof...(_Tp)>
|
||||
{
|
||||
};
|
||||
template <class... _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> {};
|
||||
|
||||
template <class ..._Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> >
|
||||
: public integral_constant<size_t, sizeof...(_Tp)>
|
||||
{
|
||||
};
|
||||
template <class... _Tp>
|
||||
struct _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> {};
|
||||
|
||||
# if _LIBCPP_STD_VER >= 17
|
||||
template <class _Tp>
|
||||
inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
|
||||
# endif
|
||||
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
|
|
|
|||
3
third_party/libcxx/__tuple/tuple_types.h
vendored
3
third_party/libcxx/__tuple/tuple_types.h
vendored
|
|
@ -17,7 +17,8 @@
|
|||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class ..._Tp> struct __tuple_types {};
|
||||
template <class... _Tp>
|
||||
struct __tuple_types {};
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue