2016-07-21 13:31:24 +08:00
|
|
|
// -*- C++ -*-
|
|
|
|
|
//===-------------------------- __string ----------------------------------===//
|
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// 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
|
2016-07-21 13:31:24 +08:00
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
|
#ifndef _LIBCPP___STRING
|
|
|
|
|
#define _LIBCPP___STRING
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
string synopsis
|
|
|
|
|
|
|
|
|
|
namespace std
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
template <class charT>
|
|
|
|
|
struct char_traits
|
|
|
|
|
{
|
|
|
|
|
typedef charT char_type;
|
|
|
|
|
typedef ... int_type;
|
|
|
|
|
typedef streamoff off_type;
|
|
|
|
|
typedef streampos pos_type;
|
|
|
|
|
typedef mbstate_t state_type;
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
|
2016-07-21 13:31:24 +08:00
|
|
|
static constexpr bool eq(char_type c1, char_type c2) noexcept;
|
|
|
|
|
static constexpr bool lt(char_type c1, char_type c2) noexcept;
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
static constexpr int compare(const char_type* s1, const char_type* s2, size_t n);
|
|
|
|
|
static constexpr size_t length(const char_type* s);
|
2019-10-24 01:40:15 +08:00
|
|
|
static constexpr const char_type*
|
2017-01-12 12:37:14 +08:00
|
|
|
find(const char_type* s, size_t n, const char_type& a);
|
2019-11-08 21:42:26 +08:00
|
|
|
|
|
|
|
|
static constexpr char_type* move(char_type* s1, const char_type* s2, size_t n); // constexpr in C++20
|
|
|
|
|
static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n); // constexpr in C++20
|
|
|
|
|
static constexpr char_type* assign(char_type* s, size_t n, char_type a); // constexpr in C++20
|
2016-07-21 13:31:24 +08:00
|
|
|
|
|
|
|
|
static constexpr int_type not_eof(int_type c) noexcept;
|
|
|
|
|
static constexpr char_type to_char_type(int_type c) noexcept;
|
|
|
|
|
static constexpr int_type to_int_type(char_type c) noexcept;
|
|
|
|
|
static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
|
|
|
|
|
static constexpr int_type eof() noexcept;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <> struct char_traits<char>;
|
|
|
|
|
template <> struct char_traits<wchar_t>;
|
2018-12-11 12:35:44 +08:00
|
|
|
template <> struct char_traits<char8_t>; // c++20
|
2016-07-21 13:31:24 +08:00
|
|
|
|
|
|
|
|
} // std
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <__config>
|
|
|
|
|
#include <algorithm> // for search and min
|
2020-12-08 10:50:15 +08:00
|
|
|
#include <cstdio> // for EOF
|
|
|
|
|
#include <cstring> // for memcpy
|
|
|
|
|
#include <cwchar> // for wmemcpy
|
2016-07-21 13:31:24 +08:00
|
|
|
#include <memory> // for __murmur2_or_cityhash
|
|
|
|
|
|
|
|
|
|
#include <__debug>
|
|
|
|
|
|
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
|
|
|
#pragma GCC system_header
|
|
|
|
|
#endif
|
|
|
|
|
|
2017-06-01 06:07:49 +08:00
|
|
|
_LIBCPP_PUSH_MACROS
|
|
|
|
|
#include <__undef_macros>
|
|
|
|
|
|
|
|
|
|
|
2016-07-21 13:31:24 +08:00
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
|
|
2020-01-16 06:12:09 +08:00
|
|
|
// The the extern template ABI lists are kept outside of <string> to improve the
|
|
|
|
|
// readability of that header.
|
2020-02-20 05:27:50 +08:00
|
|
|
|
|
|
|
|
// The extern template ABI lists are kept outside of <string> to improve the
|
|
|
|
|
// readability of that header. We maintain 2 ABI lists:
|
|
|
|
|
// - _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST
|
|
|
|
|
// - _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST
|
|
|
|
|
// As the name implies, the ABI lists define the V1 (Stable) and unstable ABI.
|
|
|
|
|
//
|
|
|
|
|
// For unstable, we may explicitly remove function that are external in V1,
|
|
|
|
|
// and add (new) external functions to better control inlining and compiler
|
|
|
|
|
// optimization opportunities.
|
|
|
|
|
//
|
|
|
|
|
// For stable, the ABI list should rarely change, except for adding new
|
|
|
|
|
// functions supporting new c++ version / API changes. Typically entries
|
|
|
|
|
// must never be removed from the stable list.
|
|
|
|
|
#define _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
|
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI.
I used a lot of `git grep` to find places where `std::` was being used
outside of comments and assert-messages. There were three outcomes:
- Qualified function calls, e.g. `std::move` becomes `_VSTD::move`.
This is the most common case.
- Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`.
Leaving these as `_VSTD::allocator` would also be fine, but I decided
that removing the qualification is more consistent with existing practice.
- Names that specifically need un-versioned `std::` qualification,
or that I wasn't sure about. For example, I didn't touch any code in
<atomic>, <math.h>, <new>, or any ext/ or experimental/ headers;
and I didn't touch any instances of `std::type_info`.
In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`,
despite `std::allocator<T>`'s type-ness not being template-dependent.
Because `std::allocator` is a qualified name, this did parse as we intended;
but what we meant was simply `class Alloc = allocator<T>`.
Differential Revision: https://reviews.llvm.org/D92250
2020-11-28 00:02:06 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&, allocator<_CharType> const&)) \
|
2020-02-20 05:27:50 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::~basic_string()) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_not_of(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, size_type, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::operator=(value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS const _CharType& basic_string<_CharType>::at(size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_of(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, size_type, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(value_type const*, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::reserve(size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(basic_string const&, size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::copy(value_type*, size_type, size_type) const) \
|
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI.
I used a lot of `git grep` to find places where `std::` was being used
outside of comments and assert-messages. There were three outcomes:
- Qualified function calls, e.g. `std::move` becomes `_VSTD::move`.
This is the most common case.
- Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`.
Leaving these as `_VSTD::allocator` would also be fine, but I decided
that removing the qualification is more consistent with existing practice.
- Names that specifically need un-versioned `std::` qualification,
or that I wasn't sure about. For example, I didn't touch any code in
<atomic>, <math.h>, <new>, or any ext/ or experimental/ headers;
and I didn't touch any instances of `std::type_info`.
In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`,
despite `std::allocator<T>`'s type-ness not being template-dependent.
Because `std::allocator` is a qualified name, this did parse as we intended;
but what we meant was simply `class Alloc = allocator<T>`.
Differential Revision: https://reviews.llvm.org/D92250
2020-11-28 00:02:06 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&, size_type, size_type, allocator<_CharType> const&)) \
|
2020-02-20 05:27:50 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(size_type, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_of(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by(size_type, size_type, size_type, size_type, size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by_and_replace(size_type, size_type, size_type, size_type, size_type, size_type, value_type const*)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::push_back(value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(size_type, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS const basic_string<_CharType>::size_type basic_string<_CharType>::npos) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(size_type, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::erase(size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(basic_string const&, size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(value_type const*) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS _CharType& basic_string<_CharType>::at(size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(value_type const*)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, basic_string const&, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::operator=(basic_string const&)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::resize(size_type, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
|
|
|
|
|
|
|
|
|
|
#define _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
|
2020-01-16 06:12:09 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::~basic_string()) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_not_of(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, size_type, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::operator=(value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type)) \
|
2020-03-05 06:52:46 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init_copy_ctor_external(value_type const*, size_type)) \
|
2020-01-16 06:12:09 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS const _CharType& basic_string<_CharType>::at(size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_of(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, size_type, value_type)) \
|
2020-06-20 02:24:03 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_external(value_type const*, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_external(value_type const*)) \
|
2020-01-16 06:12:09 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::reserve(size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(basic_string const&, size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::copy(value_type*, size_type, size_type) const) \
|
[libc++] Consistently replace `std::` qualification with `_VSTD::` or nothing. NFCI.
I used a lot of `git grep` to find places where `std::` was being used
outside of comments and assert-messages. There were three outcomes:
- Qualified function calls, e.g. `std::move` becomes `_VSTD::move`.
This is the most common case.
- Typenames that don't need qualification, e.g. `std::allocator` becomes `allocator`.
Leaving these as `_VSTD::allocator` would also be fine, but I decided
that removing the qualification is more consistent with existing practice.
- Names that specifically need un-versioned `std::` qualification,
or that I wasn't sure about. For example, I didn't touch any code in
<atomic>, <math.h>, <new>, or any ext/ or experimental/ headers;
and I didn't touch any instances of `std::type_info`.
In some deduction guides, we were accidentally using `class Alloc = typename std::allocator<T>`,
despite `std::allocator<T>`'s type-ness not being template-dependent.
Because `std::allocator` is a qualified name, this did parse as we intended;
but what we meant was simply `class Alloc = allocator<T>`.
Differential Revision: https://reviews.llvm.org/D92250
2020-11-28 00:02:06 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&, size_type, size_type, allocator<_CharType> const&)) \
|
2020-01-16 06:12:09 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(size_type, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_of(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by(size_type, size_type, size_type, size_type, size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by_and_replace(size_type, size_type, size_type, size_type, size_type, size_type, value_type const*)) \
|
2020-04-11 06:36:31 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_no_alias<false>(value_type const*, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_no_alias<true>(value_type const*, size_type)) \
|
2020-01-16 06:12:09 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::push_back(value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(size_type, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS const basic_string<_CharType>::size_type basic_string<_CharType>::npos) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(size_type, value_type)) \
|
Inline basic_string::erase for fastpath where __n == npos
Summary:
This change checks for the case where people want to erase a string to the end, i.e., __n == npos, and inlines the call if so.
This also demonstrates keeping the ABI intact for V1, but inlining the erase() method for unstable.
Reviewers: EricWF, mclow.lists, ldionne
Reviewed By: EricWF, ldionne
Subscribers: smeenai, dexonsmith, christof, libcxx-commits
Tags: #libc
Differential Revision: https://reviews.llvm.org/D73743
2020-02-27 02:25:43 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__erase_external_with_move(size_type, size_type)) \
|
2020-01-16 06:12:09 +08:00
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(basic_string const&, size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(value_type const*) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS _CharType& basic_string<_CharType>::at(size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type const*, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, basic_string const&, size_type, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::resize(size_type, value_type)) \
|
|
|
|
|
_Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
|
|
|
|
|
|
|
|
|
|
|
2016-07-21 13:31:24 +08:00
|
|
|
// char_traits
|
|
|
|
|
|
|
|
|
|
template <class _CharT>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS char_traits
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
typedef _CharT char_type;
|
|
|
|
|
typedef int int_type;
|
|
|
|
|
typedef streamoff off_type;
|
|
|
|
|
typedef streampos pos_type;
|
|
|
|
|
typedef mbstate_t state_type;
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
static inline void _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
|
2016-07-21 13:31:24 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 < __c2;}
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
int compare(const char_type* __s1, const char_type* __s2, size_t __n);
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
size_t length(const char_type* __s);
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
|
2019-11-08 21:42:26 +08:00
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
|
|
|
char_type* move(char_type* __s1, const char_type* __s2, size_t __n);
|
2016-07-21 13:31:24 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2019-11-08 21:42:26 +08:00
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
|
|
|
char_type* copy(char_type* __s1, const char_type* __s2, size_t __n);
|
2016-07-21 13:31:24 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2019-11-08 21:42:26 +08:00
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
|
|
|
char_type* assign(char_type* __s, size_t __n, char_type __a);
|
2016-07-21 13:31:24 +08:00
|
|
|
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
|
|
|
|
|
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
|
|
|
|
|
{return char_type(__c);}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
|
|
|
|
|
{return int_type(__c);}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
|
|
|
|
|
{return int_type(EOF);}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <class _CharT>
|
2017-01-12 12:37:14 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX14 int
|
2016-07-21 13:31:24 +08:00
|
|
|
char_traits<_CharT>::compare(const char_type* __s1, const char_type* __s2, size_t __n)
|
|
|
|
|
{
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
{
|
|
|
|
|
if (lt(*__s1, *__s2))
|
|
|
|
|
return -1;
|
|
|
|
|
if (lt(*__s2, *__s1))
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _CharT>
|
|
|
|
|
inline
|
2017-01-12 12:37:14 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX14 size_t
|
2016-07-21 13:31:24 +08:00
|
|
|
char_traits<_CharT>::length(const char_type* __s)
|
|
|
|
|
{
|
|
|
|
|
size_t __len = 0;
|
|
|
|
|
for (; !eq(*__s, char_type(0)); ++__s)
|
|
|
|
|
++__len;
|
|
|
|
|
return __len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _CharT>
|
|
|
|
|
inline
|
2017-01-12 12:37:14 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX14 const _CharT*
|
2016-07-21 13:31:24 +08:00
|
|
|
char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a)
|
|
|
|
|
{
|
|
|
|
|
for (; __n; --__n)
|
|
|
|
|
{
|
|
|
|
|
if (eq(*__s, __a))
|
|
|
|
|
return __s;
|
|
|
|
|
++__s;
|
|
|
|
|
}
|
2020-11-25 01:53:53 +08:00
|
|
|
return nullptr;
|
2016-07-21 13:31:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _CharT>
|
2019-11-08 21:42:26 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX17 _CharT*
|
2016-07-21 13:31:24 +08:00
|
|
|
char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
|
|
|
|
|
{
|
2019-11-08 21:42:26 +08:00
|
|
|
if (__n == 0) return __s1;
|
2016-07-21 13:31:24 +08:00
|
|
|
char_type* __r = __s1;
|
|
|
|
|
if (__s1 < __s2)
|
|
|
|
|
{
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
assign(*__s1, *__s2);
|
|
|
|
|
}
|
|
|
|
|
else if (__s2 < __s1)
|
|
|
|
|
{
|
|
|
|
|
__s1 += __n;
|
|
|
|
|
__s2 += __n;
|
|
|
|
|
for (; __n; --__n)
|
|
|
|
|
assign(*--__s1, *--__s2);
|
|
|
|
|
}
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _CharT>
|
2019-11-08 21:42:26 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-21 13:31:24 +08:00
|
|
|
_CharT*
|
|
|
|
|
char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
|
|
|
|
|
{
|
|
|
|
|
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
|
|
|
|
|
char_type* __r = __s1;
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
assign(*__s1, *__s2);
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _CharT>
|
2019-11-08 21:42:26 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-21 13:31:24 +08:00
|
|
|
_CharT*
|
|
|
|
|
char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
|
|
|
|
|
{
|
|
|
|
|
char_type* __r = __s;
|
|
|
|
|
for (; __n; --__n, ++__s)
|
|
|
|
|
assign(*__s, __a);
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-08 21:42:26 +08:00
|
|
|
// constexpr versions of move/copy/assign.
|
|
|
|
|
|
|
|
|
|
template <class _CharT>
|
2020-11-24 01:44:41 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
_CharT* __move_constexpr(_CharT* __s1, const _CharT* __s2, size_t __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__n == 0) return __s1;
|
|
|
|
|
if (__s1 < __s2) {
|
|
|
|
|
_VSTD::copy(__s2, __s2 + __n, __s1);
|
|
|
|
|
} else if (__s2 < __s1) {
|
|
|
|
|
_VSTD::copy_backward(__s2, __s2 + __n, __s1 + __n);
|
|
|
|
|
}
|
|
|
|
|
return __s1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _CharT>
|
2020-11-24 01:44:41 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
_CharT* __copy_constexpr(_CharT* __s1, const _CharT* __s2, size_t __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
_VSTD::copy_n(__s2, __n, __s1);
|
|
|
|
|
return __s1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _CharT>
|
2020-11-24 01:44:41 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
_CharT* __assign_constexpr(_CharT* __s, size_t __n, _CharT __a) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
_VSTD::fill_n(__s, __n, __a);
|
|
|
|
|
return __s;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-21 13:31:24 +08:00
|
|
|
// char_traits<char>
|
|
|
|
|
|
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS char_traits<char>
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
typedef char char_type;
|
|
|
|
|
typedef int int_type;
|
|
|
|
|
typedef streamoff off_type;
|
|
|
|
|
typedef streampos pos_type;
|
|
|
|
|
typedef mbstate_t state_type;
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
|
2016-07-21 13:31:24 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
|
|
|
|
{return (unsigned char)__c1 < (unsigned char)__c2;}
|
|
|
|
|
|
2017-01-12 13:40:58 +08:00
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
|
2017-01-12 12:37:14 +08:00
|
|
|
static inline size_t _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
length(const char_type* __s) _NOEXCEPT {return __builtin_strlen(__s);}
|
|
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
|
2020-11-24 01:44:41 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
return __libcpp_is_constant_evaluated()
|
2020-11-23 02:21:11 +08:00
|
|
|
? _VSTD::__move_constexpr(__s1, __s2, __n)
|
2020-12-08 10:50:15 +08:00
|
|
|
: __n == 0 ? __s1 : (char_type*)_VSTD::memmove(__s1, __s2, __n);
|
2019-11-08 21:42:26 +08:00
|
|
|
}
|
2020-11-24 01:44:41 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
|
2019-11-08 21:42:26 +08:00
|
|
|
return __libcpp_is_constant_evaluated()
|
2020-11-23 02:21:11 +08:00
|
|
|
? _VSTD::__copy_constexpr(__s1, __s2, __n)
|
2020-12-08 10:50:15 +08:00
|
|
|
: __n == 0 ? __s1 : (char_type*)_VSTD::memcpy(__s1, __s2, __n);
|
2019-11-08 21:42:26 +08:00
|
|
|
}
|
2020-11-24 01:44:41 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
return __libcpp_is_constant_evaluated()
|
2020-11-23 02:21:11 +08:00
|
|
|
? _VSTD::__assign_constexpr(__s, __n, __a)
|
2020-12-08 10:50:15 +08:00
|
|
|
: __n == 0 ? __s : (char_type*)_VSTD::memset(__s, to_int_type(__a), __n);
|
2016-07-21 13:31:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
|
|
|
|
|
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
|
|
|
|
|
{return char_type(__c);}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
|
|
|
|
|
{return int_type((unsigned char)__c);}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
|
|
|
|
|
{return int_type(EOF);}
|
|
|
|
|
};
|
|
|
|
|
|
2017-01-12 13:40:58 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
int
|
|
|
|
|
char_traits<char>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__n == 0)
|
|
|
|
|
return 0;
|
2017-01-26 14:58:29 +08:00
|
|
|
#if __has_feature(cxx_constexpr_string_builtins)
|
2017-01-12 13:40:58 +08:00
|
|
|
return __builtin_memcmp(__s1, __s2, __n);
|
|
|
|
|
#elif _LIBCPP_STD_VER <= 14
|
2020-12-08 10:50:15 +08:00
|
|
|
return _VSTD::memcmp(__s1, __s2, __n);
|
2017-01-12 13:40:58 +08:00
|
|
|
#else
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
{
|
|
|
|
|
if (lt(*__s1, *__s2))
|
|
|
|
|
return -1;
|
|
|
|
|
if (lt(*__s2, *__s1))
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
const char*
|
|
|
|
|
char_traits<char>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__n == 0)
|
2018-02-07 02:58:05 +08:00
|
|
|
return nullptr;
|
2017-01-26 14:58:29 +08:00
|
|
|
#if __has_feature(cxx_constexpr_string_builtins)
|
|
|
|
|
return __builtin_char_memchr(__s, to_int_type(__a), __n);
|
|
|
|
|
#elif _LIBCPP_STD_VER <= 14
|
2020-12-08 10:50:15 +08:00
|
|
|
return (const char_type*) _VSTD::memchr(__s, to_int_type(__a), __n);
|
2017-01-12 12:37:14 +08:00
|
|
|
#else
|
|
|
|
|
for (; __n; --__n)
|
|
|
|
|
{
|
|
|
|
|
if (eq(*__s, __a))
|
|
|
|
|
return __s;
|
|
|
|
|
++__s;
|
|
|
|
|
}
|
2018-02-07 02:58:05 +08:00
|
|
|
return nullptr;
|
2017-01-12 12:37:14 +08:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-07-21 13:31:24 +08:00
|
|
|
// char_traits<wchar_t>
|
|
|
|
|
|
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
typedef wchar_t char_type;
|
|
|
|
|
typedef wint_t int_type;
|
|
|
|
|
typedef streamoff off_type;
|
|
|
|
|
typedef streampos pos_type;
|
|
|
|
|
typedef mbstate_t state_type;
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
|
2016-07-21 13:31:24 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 < __c2;}
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
|
|
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
size_t length(const char_type* __s) _NOEXCEPT;
|
|
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
|
2020-11-24 01:44:41 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
return __libcpp_is_constant_evaluated()
|
2020-11-23 02:21:11 +08:00
|
|
|
? _VSTD::__move_constexpr(__s1, __s2, __n)
|
2020-12-08 10:50:15 +08:00
|
|
|
: __n == 0 ? __s1 : _VSTD::wmemmove(__s1, __s2, __n);
|
2019-11-08 21:42:26 +08:00
|
|
|
}
|
2020-11-24 01:44:41 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
|
2019-11-08 21:42:26 +08:00
|
|
|
return __libcpp_is_constant_evaluated()
|
2020-11-23 02:21:11 +08:00
|
|
|
? _VSTD::__copy_constexpr(__s1, __s2, __n)
|
2020-12-08 10:50:15 +08:00
|
|
|
: __n == 0 ? __s1 : _VSTD::wmemcpy(__s1, __s2, __n);
|
2019-11-08 21:42:26 +08:00
|
|
|
}
|
2020-11-24 01:44:41 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
return __libcpp_is_constant_evaluated()
|
2020-11-23 02:21:11 +08:00
|
|
|
? _VSTD::__assign_constexpr(__s, __n, __a)
|
2020-12-08 10:50:15 +08:00
|
|
|
: __n == 0 ? __s : _VSTD::wmemset(__s, __a, __n);
|
2016-07-21 13:31:24 +08:00
|
|
|
}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
|
|
|
|
|
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
|
|
|
|
|
{return char_type(__c);}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
|
|
|
|
|
{return int_type(__c);}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
|
|
|
|
|
{return int_type(WEOF);}
|
|
|
|
|
};
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
int
|
|
|
|
|
char_traits<wchar_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__n == 0)
|
|
|
|
|
return 0;
|
2017-01-26 14:58:29 +08:00
|
|
|
#if __has_feature(cxx_constexpr_string_builtins)
|
2017-01-12 12:37:14 +08:00
|
|
|
return __builtin_wmemcmp(__s1, __s2, __n);
|
|
|
|
|
#elif _LIBCPP_STD_VER <= 14
|
2020-12-08 10:50:15 +08:00
|
|
|
return _VSTD::wmemcmp(__s1, __s2, __n);
|
2017-01-12 12:37:14 +08:00
|
|
|
#else
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
{
|
|
|
|
|
if (lt(*__s1, *__s2))
|
|
|
|
|
return -1;
|
|
|
|
|
if (lt(*__s2, *__s1))
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-15 03:55:28 +08:00
|
|
|
|
|
|
|
|
template <class _Traits>
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
_LIBCPP_CONSTEXPR
|
|
|
|
|
inline size_t __char_traits_length_checked(const typename _Traits::char_type* __s) _NOEXCEPT {
|
|
|
|
|
#if _LIBCPP_DEBUG_LEVEL >= 1
|
|
|
|
|
return __s ? _Traits::length(__s) : (_VSTD::__libcpp_debug_function(_VSTD::__libcpp_debug_info(__FILE__, __LINE__, "p == nullptr", "null pointer pass to non-null argument of char_traits<...>::length")), 0);
|
|
|
|
|
#else
|
|
|
|
|
return _Traits::length(__s);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
size_t
|
|
|
|
|
char_traits<wchar_t>::length(const char_type* __s) _NOEXCEPT
|
|
|
|
|
{
|
2017-01-26 14:58:29 +08:00
|
|
|
#if __has_feature(cxx_constexpr_string_builtins)
|
2017-01-12 12:37:14 +08:00
|
|
|
return __builtin_wcslen(__s);
|
|
|
|
|
#elif _LIBCPP_STD_VER <= 14
|
2020-12-08 10:50:15 +08:00
|
|
|
return _VSTD::wcslen(__s);
|
2017-01-12 12:37:14 +08:00
|
|
|
#else
|
|
|
|
|
size_t __len = 0;
|
|
|
|
|
for (; !eq(*__s, char_type(0)); ++__s)
|
|
|
|
|
++__len;
|
|
|
|
|
return __len;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
const wchar_t*
|
|
|
|
|
char_traits<wchar_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__n == 0)
|
2018-02-07 02:58:05 +08:00
|
|
|
return nullptr;
|
2017-01-26 14:58:29 +08:00
|
|
|
#if __has_feature(cxx_constexpr_string_builtins)
|
2018-02-07 02:58:05 +08:00
|
|
|
return __builtin_wmemchr(__s, __a, __n);
|
2017-01-12 12:37:14 +08:00
|
|
|
#elif _LIBCPP_STD_VER <= 14
|
2020-12-08 10:50:15 +08:00
|
|
|
return _VSTD::wmemchr(__s, __a, __n);
|
2017-01-12 12:37:14 +08:00
|
|
|
#else
|
|
|
|
|
for (; __n; --__n)
|
|
|
|
|
{
|
|
|
|
|
if (eq(*__s, __a))
|
|
|
|
|
return __s;
|
|
|
|
|
++__s;
|
|
|
|
|
}
|
2018-02-07 02:58:05 +08:00
|
|
|
return nullptr;
|
2017-01-12 12:37:14 +08:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2018-12-11 12:35:44 +08:00
|
|
|
#ifndef _LIBCPP_NO_HAS_CHAR8_T
|
|
|
|
|
|
|
|
|
|
template <>
|
|
|
|
|
struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t>
|
|
|
|
|
{
|
|
|
|
|
typedef char8_t char_type;
|
|
|
|
|
typedef unsigned int int_type;
|
|
|
|
|
typedef streamoff off_type;
|
|
|
|
|
typedef u8streampos pos_type;
|
|
|
|
|
typedef mbstate_t state_type;
|
|
|
|
|
|
|
|
|
|
static inline constexpr void assign(char_type& __c1, const char_type& __c2) noexcept
|
|
|
|
|
{__c1 = __c2;}
|
|
|
|
|
static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
|
|
|
|
|
{return __c1 < __c2;}
|
|
|
|
|
|
|
|
|
|
static constexpr
|
|
|
|
|
int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
|
|
|
|
|
|
|
|
|
|
static constexpr
|
|
|
|
|
size_t length(const char_type* __s) _NOEXCEPT;
|
2019-10-24 01:40:15 +08:00
|
|
|
|
2018-12-11 12:35:44 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY static constexpr
|
|
|
|
|
const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
|
2019-10-24 01:40:15 +08:00
|
|
|
|
2020-11-24 01:44:41 +08:00
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
return __libcpp_is_constant_evaluated()
|
2020-11-23 02:21:11 +08:00
|
|
|
? _VSTD::__move_constexpr(__s1, __s2, __n)
|
2020-12-08 10:50:15 +08:00
|
|
|
: __n == 0 ? __s1 : (char_type*)_VSTD::memmove(__s1, __s2, __n);
|
2019-11-08 21:42:26 +08:00
|
|
|
}
|
2019-10-24 01:40:15 +08:00
|
|
|
|
2020-11-24 01:44:41 +08:00
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
2018-12-11 12:35:44 +08:00
|
|
|
{
|
|
|
|
|
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
|
2019-11-08 21:42:26 +08:00
|
|
|
return __libcpp_is_constant_evaluated()
|
2020-11-23 02:21:11 +08:00
|
|
|
? _VSTD::__copy_constexpr(__s1, __s2, __n)
|
2020-12-08 10:50:15 +08:00
|
|
|
: __n == 0 ? __s1 : (char_type*)_VSTD::memcpy(__s1, __s2, __n);
|
2019-11-08 21:42:26 +08:00
|
|
|
}
|
2019-10-24 01:40:15 +08:00
|
|
|
|
2020-11-24 01:44:41 +08:00
|
|
|
static _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2019-11-08 21:42:26 +08:00
|
|
|
char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
return __libcpp_is_constant_evaluated()
|
2020-11-23 02:21:11 +08:00
|
|
|
? _VSTD::__assign_constexpr(__s, __n, __a)
|
2020-12-08 10:50:15 +08:00
|
|
|
: __n == 0 ? __s : (char_type*)_VSTD::memset(__s, to_int_type(__a), __n);
|
2019-11-08 21:42:26 +08:00
|
|
|
}
|
2018-12-11 12:35:44 +08:00
|
|
|
|
|
|
|
|
static inline constexpr int_type not_eof(int_type __c) noexcept
|
|
|
|
|
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
|
|
|
|
static inline constexpr char_type to_char_type(int_type __c) noexcept
|
|
|
|
|
{return char_type(__c);}
|
|
|
|
|
static inline constexpr int_type to_int_type(char_type __c) noexcept
|
|
|
|
|
{return int_type(__c);}
|
|
|
|
|
static inline constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline constexpr int_type eof() noexcept
|
|
|
|
|
{return int_type(EOF);}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// TODO use '__builtin_strlen' if it ever supports char8_t ??
|
|
|
|
|
inline constexpr
|
|
|
|
|
size_t
|
|
|
|
|
char_traits<char8_t>::length(const char_type* __s) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
size_t __len = 0;
|
|
|
|
|
for (; !eq(*__s, char_type(0)); ++__s)
|
|
|
|
|
++__len;
|
|
|
|
|
return __len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline constexpr
|
|
|
|
|
int
|
|
|
|
|
char_traits<char8_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
#if __has_feature(cxx_constexpr_string_builtins)
|
|
|
|
|
return __builtin_memcmp(__s1, __s2, __n);
|
|
|
|
|
#else
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
{
|
|
|
|
|
if (lt(*__s1, *__s2))
|
|
|
|
|
return -1;
|
|
|
|
|
if (lt(*__s2, *__s1))
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// TODO use '__builtin_char_memchr' if it ever supports char8_t ??
|
|
|
|
|
inline constexpr
|
|
|
|
|
const char8_t*
|
|
|
|
|
char_traits<char8_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
for (; __n; --__n)
|
|
|
|
|
{
|
|
|
|
|
if (eq(*__s, __a))
|
|
|
|
|
return __s;
|
|
|
|
|
++__s;
|
|
|
|
|
}
|
2020-11-25 01:53:53 +08:00
|
|
|
return nullptr;
|
2018-12-11 12:35:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif // #_LIBCPP_NO_HAS_CHAR8_T
|
|
|
|
|
|
2016-07-21 13:31:24 +08:00
|
|
|
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
|
|
|
|
|
|
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
typedef char16_t char_type;
|
|
|
|
|
typedef uint_least16_t int_type;
|
|
|
|
|
typedef streamoff off_type;
|
|
|
|
|
typedef u16streampos pos_type;
|
|
|
|
|
typedef mbstate_t state_type;
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
|
2016-07-21 13:31:24 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 < __c2;}
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
size_t length(const char_type* __s) _NOEXCEPT;
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
|
2019-11-08 21:42:26 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-28 12:52:02 +08:00
|
|
|
static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
|
2019-11-08 21:42:26 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-28 12:52:02 +08:00
|
|
|
static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
|
2019-11-08 21:42:26 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-28 12:52:02 +08:00
|
|
|
static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT;
|
2016-07-21 13:31:24 +08:00
|
|
|
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
|
|
|
|
|
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
|
|
|
|
|
{return char_type(__c);}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
|
|
|
|
|
{return int_type(__c);}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
|
|
|
|
|
{return int_type(0xFFFF);}
|
|
|
|
|
};
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
2016-07-21 13:31:24 +08:00
|
|
|
int
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char16_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
{
|
|
|
|
|
if (lt(*__s1, *__s2))
|
|
|
|
|
return -1;
|
|
|
|
|
if (lt(*__s2, *__s1))
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
2016-07-21 13:31:24 +08:00
|
|
|
size_t
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char16_t>::length(const char_type* __s) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
size_t __len = 0;
|
|
|
|
|
for (; !eq(*__s, char_type(0)); ++__s)
|
|
|
|
|
++__len;
|
|
|
|
|
return __len;
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
2016-07-21 13:31:24 +08:00
|
|
|
const char16_t*
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char16_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
for (; __n; --__n)
|
|
|
|
|
{
|
|
|
|
|
if (eq(*__s, __a))
|
|
|
|
|
return __s;
|
|
|
|
|
++__s;
|
|
|
|
|
}
|
2020-11-25 01:53:53 +08:00
|
|
|
return nullptr;
|
2016-07-21 13:31:24 +08:00
|
|
|
}
|
|
|
|
|
|
2019-11-08 21:42:26 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-21 13:31:24 +08:00
|
|
|
char16_t*
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char16_t>::move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
2019-11-08 21:42:26 +08:00
|
|
|
if (__n == 0) return __s1;
|
2016-07-21 13:31:24 +08:00
|
|
|
char_type* __r = __s1;
|
|
|
|
|
if (__s1 < __s2)
|
|
|
|
|
{
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
assign(*__s1, *__s2);
|
|
|
|
|
}
|
|
|
|
|
else if (__s2 < __s1)
|
|
|
|
|
{
|
|
|
|
|
__s1 += __n;
|
|
|
|
|
__s2 += __n;
|
|
|
|
|
for (; __n; --__n)
|
|
|
|
|
assign(*--__s1, *--__s2);
|
|
|
|
|
}
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-08 21:42:26 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-21 13:31:24 +08:00
|
|
|
char16_t*
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char16_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
|
|
|
|
|
char_type* __r = __s1;
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
assign(*__s1, *__s2);
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-08 21:42:26 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-21 13:31:24 +08:00
|
|
|
char16_t*
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char16_t>::assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
char_type* __r = __s;
|
|
|
|
|
for (; __n; --__n, ++__s)
|
|
|
|
|
assign(*__s, __a);
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t>
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
typedef char32_t char_type;
|
|
|
|
|
typedef uint_least32_t int_type;
|
|
|
|
|
typedef streamoff off_type;
|
|
|
|
|
typedef u32streampos pos_type;
|
|
|
|
|
typedef mbstate_t state_type;
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
|
2016-07-21 13:31:24 +08:00
|
|
|
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 < __c2;}
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
size_t length(const char_type* __s) _NOEXCEPT;
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
|
|
|
|
|
const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
|
2019-11-08 21:42:26 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-28 12:52:02 +08:00
|
|
|
static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
|
2019-11-08 21:42:26 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-28 12:52:02 +08:00
|
|
|
static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
|
2019-11-08 21:42:26 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-28 12:52:02 +08:00
|
|
|
static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT;
|
2016-07-21 13:31:24 +08:00
|
|
|
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
|
|
|
|
|
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
|
|
|
|
|
{return char_type(__c);}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
|
|
|
|
|
{return int_type(__c);}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
|
|
|
|
{return __c1 == __c2;}
|
|
|
|
|
static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
|
|
|
|
|
{return int_type(0xFFFFFFFF);}
|
|
|
|
|
};
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
2016-07-21 13:31:24 +08:00
|
|
|
int
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char32_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
{
|
|
|
|
|
if (lt(*__s1, *__s2))
|
|
|
|
|
return -1;
|
|
|
|
|
if (lt(*__s2, *__s1))
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
2016-07-21 13:31:24 +08:00
|
|
|
size_t
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char32_t>::length(const char_type* __s) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
size_t __len = 0;
|
|
|
|
|
for (; !eq(*__s, char_type(0)); ++__s)
|
|
|
|
|
++__len;
|
|
|
|
|
return __len;
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-12 12:37:14 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX14
|
2016-07-21 13:31:24 +08:00
|
|
|
const char32_t*
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char32_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
for (; __n; --__n)
|
|
|
|
|
{
|
|
|
|
|
if (eq(*__s, __a))
|
|
|
|
|
return __s;
|
|
|
|
|
++__s;
|
|
|
|
|
}
|
2020-11-25 01:53:53 +08:00
|
|
|
return nullptr;
|
2016-07-21 13:31:24 +08:00
|
|
|
}
|
|
|
|
|
|
2019-11-08 21:42:26 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-21 13:31:24 +08:00
|
|
|
char32_t*
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char32_t>::move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
2019-11-08 21:42:26 +08:00
|
|
|
if (__n == 0) return __s1;
|
2016-07-21 13:31:24 +08:00
|
|
|
char_type* __r = __s1;
|
|
|
|
|
if (__s1 < __s2)
|
|
|
|
|
{
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
assign(*__s1, *__s2);
|
|
|
|
|
}
|
|
|
|
|
else if (__s2 < __s1)
|
|
|
|
|
{
|
|
|
|
|
__s1 += __n;
|
|
|
|
|
__s2 += __n;
|
|
|
|
|
for (; __n; --__n)
|
|
|
|
|
assign(*--__s1, *--__s2);
|
|
|
|
|
}
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-08 21:42:26 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-21 13:31:24 +08:00
|
|
|
char32_t*
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char32_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
_LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
|
|
|
|
|
char_type* __r = __s1;
|
|
|
|
|
for (; __n; --__n, ++__s1, ++__s2)
|
|
|
|
|
assign(*__s1, *__s2);
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-08 21:42:26 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX17
|
2016-07-21 13:31:24 +08:00
|
|
|
char32_t*
|
2016-07-28 12:52:02 +08:00
|
|
|
char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
char_type* __r = __s;
|
|
|
|
|
for (; __n; --__n, ++__s)
|
|
|
|
|
assign(*__s, __a);
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
|
|
|
|
|
|
|
|
|
|
// helper fns for basic_string and string_view
|
|
|
|
|
|
|
|
|
|
// __str_find
|
|
|
|
|
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
|
|
|
|
|
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2019-10-24 01:40:15 +08:00
|
|
|
__str_find(const _CharT *__p, _SizeT __sz,
|
2016-07-21 13:31:24 +08:00
|
|
|
_CharT __c, _SizeT __pos) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__pos >= __sz)
|
|
|
|
|
return __npos;
|
|
|
|
|
const _CharT* __r = _Traits::find(__p + __pos, __sz - __pos, __c);
|
2020-11-25 01:53:53 +08:00
|
|
|
if (__r == nullptr)
|
2016-07-21 13:31:24 +08:00
|
|
|
return __npos;
|
|
|
|
|
return static_cast<_SizeT>(__r - __p);
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-31 02:01:36 +08:00
|
|
|
template <class _CharT, class _Traits>
|
|
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX11 const _CharT *
|
|
|
|
|
__search_substring(const _CharT *__first1, const _CharT *__last1,
|
|
|
|
|
const _CharT *__first2, const _CharT *__last2) {
|
|
|
|
|
// Take advantage of knowing source and pattern lengths.
|
|
|
|
|
// Stop short when source is smaller than pattern.
|
|
|
|
|
const ptrdiff_t __len2 = __last2 - __first2;
|
|
|
|
|
if (__len2 == 0)
|
|
|
|
|
return __first1;
|
|
|
|
|
|
|
|
|
|
ptrdiff_t __len1 = __last1 - __first1;
|
|
|
|
|
if (__len1 < __len2)
|
|
|
|
|
return __last1;
|
|
|
|
|
|
|
|
|
|
// First element of __first2 is loop invariant.
|
|
|
|
|
_CharT __f2 = *__first2;
|
|
|
|
|
while (true) {
|
|
|
|
|
__len1 = __last1 - __first1;
|
|
|
|
|
// Check whether __first1 still has at least __len2 bytes.
|
|
|
|
|
if (__len1 < __len2)
|
|
|
|
|
return __last1;
|
|
|
|
|
|
|
|
|
|
// Find __f2 the first byte matching in __first1.
|
|
|
|
|
__first1 = _Traits::find(__first1, __len1 - __len2 + 1, __f2);
|
2020-11-25 01:53:53 +08:00
|
|
|
if (__first1 == nullptr)
|
2016-12-31 02:01:36 +08:00
|
|
|
return __last1;
|
|
|
|
|
|
|
|
|
|
// It is faster to compare from the first byte of __first1 even if we
|
|
|
|
|
// already know that it matches the first byte of __first2: this is because
|
|
|
|
|
// __first2 is most likely aligned, as it is user's "pattern" string, and
|
|
|
|
|
// __first1 + 1 is most likely not aligned, as the match is in the middle of
|
|
|
|
|
// the string.
|
|
|
|
|
if (_Traits::compare(__first1, __first2, __len2) == 0)
|
|
|
|
|
return __first1;
|
|
|
|
|
|
|
|
|
|
++__first1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-21 13:31:24 +08:00
|
|
|
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
|
|
|
|
|
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2019-10-24 01:40:15 +08:00
|
|
|
__str_find(const _CharT *__p, _SizeT __sz,
|
2016-07-21 13:31:24 +08:00
|
|
|
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
|
|
|
|
|
{
|
2016-12-31 02:01:36 +08:00
|
|
|
if (__pos > __sz)
|
2016-07-21 13:31:24 +08:00
|
|
|
return __npos;
|
2016-12-31 02:01:36 +08:00
|
|
|
|
|
|
|
|
if (__n == 0) // There is nothing to search, just return __pos.
|
2016-07-21 13:31:24 +08:00
|
|
|
return __pos;
|
2016-12-31 02:01:36 +08:00
|
|
|
|
|
|
|
|
const _CharT *__r = __search_substring<_CharT, _Traits>(
|
|
|
|
|
__p + __pos, __p + __sz, __s, __s + __n);
|
|
|
|
|
|
2016-07-21 13:31:24 +08:00
|
|
|
if (__r == __p + __sz)
|
|
|
|
|
return __npos;
|
|
|
|
|
return static_cast<_SizeT>(__r - __p);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// __str_rfind
|
|
|
|
|
|
|
|
|
|
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
|
|
|
|
|
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2019-10-24 01:40:15 +08:00
|
|
|
__str_rfind(const _CharT *__p, _SizeT __sz,
|
2016-07-21 13:31:24 +08:00
|
|
|
_CharT __c, _SizeT __pos) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__sz < 1)
|
|
|
|
|
return __npos;
|
|
|
|
|
if (__pos < __sz)
|
|
|
|
|
++__pos;
|
|
|
|
|
else
|
|
|
|
|
__pos = __sz;
|
|
|
|
|
for (const _CharT* __ps = __p + __pos; __ps != __p;)
|
|
|
|
|
{
|
|
|
|
|
if (_Traits::eq(*--__ps, __c))
|
|
|
|
|
return static_cast<_SizeT>(__ps - __p);
|
|
|
|
|
}
|
|
|
|
|
return __npos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
|
|
|
|
|
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2019-10-24 01:40:15 +08:00
|
|
|
__str_rfind(const _CharT *__p, _SizeT __sz,
|
2016-07-21 13:31:24 +08:00
|
|
|
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
__pos = _VSTD::min(__pos, __sz);
|
|
|
|
|
if (__n < __sz - __pos)
|
|
|
|
|
__pos += __n;
|
|
|
|
|
else
|
|
|
|
|
__pos = __sz;
|
|
|
|
|
const _CharT* __r = _VSTD::__find_end(
|
2019-10-24 01:40:15 +08:00
|
|
|
__p, __p + __pos, __s, __s + __n, _Traits::eq,
|
2016-07-21 13:31:24 +08:00
|
|
|
random_access_iterator_tag(), random_access_iterator_tag());
|
|
|
|
|
if (__n > 0 && __r == __p + __pos)
|
|
|
|
|
return __npos;
|
|
|
|
|
return static_cast<_SizeT>(__r - __p);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// __str_find_first_of
|
|
|
|
|
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
|
|
|
|
|
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__str_find_first_of(const _CharT *__p, _SizeT __sz,
|
|
|
|
|
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__pos >= __sz || __n == 0)
|
|
|
|
|
return __npos;
|
|
|
|
|
const _CharT* __r = _VSTD::__find_first_of_ce
|
|
|
|
|
(__p + __pos, __p + __sz, __s, __s + __n, _Traits::eq );
|
|
|
|
|
if (__r == __p + __sz)
|
|
|
|
|
return __npos;
|
|
|
|
|
return static_cast<_SizeT>(__r - __p);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// __str_find_last_of
|
|
|
|
|
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
|
|
|
|
|
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__str_find_last_of(const _CharT *__p, _SizeT __sz,
|
|
|
|
|
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__n != 0)
|
|
|
|
|
{
|
|
|
|
|
if (__pos < __sz)
|
|
|
|
|
++__pos;
|
|
|
|
|
else
|
|
|
|
|
__pos = __sz;
|
|
|
|
|
for (const _CharT* __ps = __p + __pos; __ps != __p;)
|
|
|
|
|
{
|
|
|
|
|
const _CharT* __r = _Traits::find(__s, __n, *--__ps);
|
|
|
|
|
if (__r)
|
|
|
|
|
return static_cast<_SizeT>(__ps - __p);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return __npos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// __str_find_first_not_of
|
|
|
|
|
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
|
|
|
|
|
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__str_find_first_not_of(const _CharT *__p, _SizeT __sz,
|
|
|
|
|
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__pos < __sz)
|
|
|
|
|
{
|
|
|
|
|
const _CharT* __pe = __p + __sz;
|
|
|
|
|
for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
|
2020-11-25 01:53:53 +08:00
|
|
|
if (_Traits::find(__s, __n, *__ps) == nullptr)
|
2016-07-21 13:31:24 +08:00
|
|
|
return static_cast<_SizeT>(__ps - __p);
|
|
|
|
|
}
|
|
|
|
|
return __npos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
|
|
|
|
|
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__str_find_first_not_of(const _CharT *__p, _SizeT __sz,
|
|
|
|
|
_CharT __c, _SizeT __pos) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__pos < __sz)
|
|
|
|
|
{
|
|
|
|
|
const _CharT* __pe = __p + __sz;
|
|
|
|
|
for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
|
|
|
|
|
if (!_Traits::eq(*__ps, __c))
|
|
|
|
|
return static_cast<_SizeT>(__ps - __p);
|
|
|
|
|
}
|
|
|
|
|
return __npos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// __str_find_last_not_of
|
|
|
|
|
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
|
|
|
|
|
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__str_find_last_not_of(const _CharT *__p, _SizeT __sz,
|
|
|
|
|
const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__pos < __sz)
|
|
|
|
|
++__pos;
|
|
|
|
|
else
|
|
|
|
|
__pos = __sz;
|
|
|
|
|
for (const _CharT* __ps = __p + __pos; __ps != __p;)
|
2020-11-25 01:53:53 +08:00
|
|
|
if (_Traits::find(__s, __n, *--__ps) == nullptr)
|
2016-07-21 13:31:24 +08:00
|
|
|
return static_cast<_SizeT>(__ps - __p);
|
|
|
|
|
return __npos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
|
|
|
|
|
inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__str_find_last_not_of(const _CharT *__p, _SizeT __sz,
|
|
|
|
|
_CharT __c, _SizeT __pos) _NOEXCEPT
|
|
|
|
|
{
|
|
|
|
|
if (__pos < __sz)
|
|
|
|
|
++__pos;
|
|
|
|
|
else
|
|
|
|
|
__pos = __sz;
|
|
|
|
|
for (const _CharT* __ps = __p + __pos; __ps != __p;)
|
|
|
|
|
if (!_Traits::eq(*--__ps, __c))
|
|
|
|
|
return static_cast<_SizeT>(__ps - __p);
|
|
|
|
|
return __npos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<class _Ptr>
|
2016-09-16 06:27:07 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
size_t __do_string_hash(_Ptr __p, _Ptr __e)
|
2016-07-21 13:31:24 +08:00
|
|
|
{
|
|
|
|
|
typedef typename iterator_traits<_Ptr>::value_type value_type;
|
|
|
|
|
return __murmur2_or_cityhash<size_t>()(__p, (__e-__p)*sizeof(value_type));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _CharT, class _Iter, class _Traits=char_traits<_CharT> >
|
|
|
|
|
struct __quoted_output_proxy
|
|
|
|
|
{
|
|
|
|
|
_Iter __first;
|
|
|
|
|
_Iter __last;
|
|
|
|
|
_CharT __delim;
|
|
|
|
|
_CharT __escape;
|
|
|
|
|
|
|
|
|
|
__quoted_output_proxy(_Iter __f, _Iter __l, _CharT __d, _CharT __e)
|
|
|
|
|
: __first(__f), __last(__l), __delim(__d), __escape(__e) {}
|
2019-10-24 01:40:15 +08:00
|
|
|
// This would be a nice place for a string_ref
|
2016-07-21 13:31:24 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
|
|
2017-06-01 06:07:49 +08:00
|
|
|
_LIBCPP_POP_MACROS
|
|
|
|
|
|
2016-07-21 13:31:24 +08:00
|
|
|
#endif // _LIBCPP___STRING
|