mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-06-27 06:48:31 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Release Cosmopolitan v3.6.0

Browse source 
This release is an atomic upgrade to GCC 14.1.0 with C23 and C++23
This commit is contained in:
Justine Tunney 2024-07-23 03:16:17 -07:00
parent 62ace3623a
commit 5660ec4741
No known key found for this signature in database
GPG key ID: BE714B4575D6E328
1585 changed files with 117353 additions and 271644 deletions
Download patch file Download diff file Expand all files Collapse all files

78
third_party/libcxx/functional vendored
View file

@ -34,7 +34,7 @@ struct binary_function
template <class T>
class reference_wrapper
: public unary_function<T1, R> // if wrapping a unary functor
: public binary_function<T1, T2, R> // if wraping a binary functor
: public binary_function<T1, T2, R> // if wrapping a binary functor
{
public:
// types
@ -77,6 +77,15 @@ template <class T> struct unwrap_ref_decay : unwrap_reference<decay_t<T>> { };
template <class T> using unwrap_reference_t = typename unwrap_reference<T>::type; // since C++20
template <class T> using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type; // since C++20
// [refwrap.comparisons], comparisons
friend constexpr bool operator==(reference_wrapper, reference_wrapper); // Since C++26
friend constexpr bool operator==(reference_wrapper, const T&); // Since C++26
friend constexpr bool operator==(reference_wrapper, reference_wrapper<const T>); // Since C++26
friend constexpr auto operator<=>(reference_wrapper, reference_wrapper); // Since C++26
friend constexpr auto operator<=>(reference_wrapper, const T&); // Since C++26
friend constexpr auto operator<=>(reference_wrapper, reference_wrapper<const T>); // Since C++26
template <class T> // <class T=void> in C++14
struct plus {
T operator()(const T& x, const T& y) const;
@ -207,6 +216,12 @@ binary_negate<Predicate> not2(const Predicate& pred);
template <class F>
constexpr unspecified not_fn(F&& f); // C++17, constexpr in C++20
// [func.bind.partial], function templates bind_front and bind_back
template<class F, class... Args>
constexpr unspecified bind_front(F&&, Args&&...); // C++20
template<class F, class... Args>
constexpr unspecified bind_back(F&&, Args&&...); // C++23
template<class T> struct is_bind_expression;
template<class T> struct is_placeholder;
@ -456,13 +471,13 @@ template <class R, class ... ArgTypes>
bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
template <class R, class ... ArgTypes>
bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept; // removed in C++20
template <class R, class ... ArgTypes>
bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept; // removed in C++20
template <class R, class ... ArgTypes>
bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept; // removed in C++20
// specialized algorithms:
template <class R, class ... ArgTypes>
@ -512,52 +527,71 @@ POLICY: For non-variadic implementations, the number of arguments is limited
*/
#include <__algorithm/search.h>
#include <__assert> // all public C++ headers provide the assertion handler
#include <__compare/compare_three_way.h>
#include <__config>
#include <__debug>
#include <__functional/binary_function.h>
#include <__functional/binary_negate.h>
#include <__functional/bind.h>
#include <__functional/bind_back.h>
#include <__functional/bind_front.h>
#include <__functional/binder1st.h>
#include <__functional/binder2nd.h>
#include <__functional/boyer_moore_searcher.h>
#include <__functional/compose.h>
#include <__functional/default_searcher.h>
#include <__functional/function.h>
#include <__functional/hash.h>
#include <__functional/identity.h>
#include <__functional/invoke.h>
#include <__functional/mem_fn.h> // TODO: deprecate
#include <__functional/mem_fun_ref.h>
#include <__functional/not_fn.h>
#include <__functional/operations.h>
#include <__functional/pointer_to_binary_function.h>
#include <__functional/pointer_to_unary_function.h>
#include <__functional/ranges_operations.h>
#include <__functional/reference_wrapper.h>
#include <__functional/unary_function.h>
#include <__functional/unary_negate.h>
#include <__type_traits/unwrap_ref.h>
#include <__utility/forward.h>
#include <memory> // TODO: find out why removing this breaks the modules build
#include <typeinfo>
#ifndef _LIBCPP_CXX03_LANG
# include <__functional/function.h>
#endif
#if _LIBCPP_STD_VER >= 17
# include <__functional/boyer_moore_searcher.h>
# include <__functional/default_searcher.h>
# include <__functional/invoke.h>
# include <__functional/not_fn.h>
#endif
#if _LIBCPP_STD_VER >= 20
# include <__functional/bind_back.h>
# include <__functional/bind_front.h>
# include <__functional/identity.h>
# include <__functional/ranges_operations.h>
# include <__type_traits/unwrap_ref.h>
#endif
#include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && defined(_LIBCPP_CXX03_LANG)
# include <limits>
# include <new>
#endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 14
# include <array>
# include <initializer_list>
# include <unordered_map>
# include <vector>
#endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <atomic>
# include <concepts>
# include <cstdlib>
# include <exception>
# include <iosfwd>
# include <memory>
# include <stdexcept>
# include <tuple>
# include <type_traits>
# include <typeinfo>
# include <utility>
#endif