| // Components for manipulating non-owning sequences of characters -*- C++ -*- |
| |
| #ifndef COMMON_GDB_STRING_VIEW_H |
| #define COMMON_GDB_STRING_VIEW_H |
| |
| // Note: This file has been stolen from the gcc repo |
| // (libstdc++-v3/include/experimental/string_view) and has local modifications. |
| |
| // Copyright (C) 2013-2023 Free Software Foundation, Inc. |
| // |
| // This file is part of the GNU ISO C++ Library. This library is free |
| // software; you can redistribute it and/or modify it under the |
| // terms of the GNU General Public License as published by the |
| // Free Software Foundation; either version 3, or (at your option) |
| // any later version. |
| |
| // This library is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. |
| |
| // Under Section 7 of GPL version 3, you are granted additional |
| // permissions described in the GCC Runtime Library Exception, version |
| // 3.1, as published by the Free Software Foundation. |
| |
| // You should have received a copy of the GNU General Public License and |
| // a copy of the GCC Runtime Library Exception along with this program; |
| // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| // <http://www.gnu.org/licenses/>. |
| |
| // |
| // N3762 basic_string_view library |
| // |
| |
| #if __cplusplus >= 201703L |
| |
| #include <string_view> |
| |
| namespace gdb |
| { |
| using string_view = std::string_view; |
| } /* namespace gdb */ |
| |
| #else /* __cplusplus < 201703L */ |
| |
| #include <string> |
| #include <limits> |
| #include "gdb_assert.h" |
| |
| namespace gdb |
| { |
| |
| /** |
| * @class basic_string_view <experimental/string_view> |
| * @brief A non-owning reference to a string. |
| * |
| * @ingroup strings |
| * @ingroup sequences |
| * @ingroup experimental |
| * |
| * @tparam _CharT Type of character |
| * @tparam _Traits Traits for character type, defaults to |
| * char_traits<_CharT>. |
| * |
| * A basic_string_view looks like this: |
| * |
| * @code |
| * _CharT* _M_str |
| * size_t _M_len |
| * @endcode |
| */ |
| template<typename _CharT, typename _Traits = std::char_traits<_CharT>> |
| class basic_string_view |
| { |
| public: |
| // types |
| using traits_type = _Traits; |
| using value_type = _CharT; |
| using pointer = const _CharT *; |
| using const_pointer = const _CharT *; |
| using reference = const _CharT &; |
| using const_reference = const _CharT &; |
| using const_iterator = const _CharT *; |
| using iterator = const_iterator; |
| using const_reverse_iterator = std::reverse_iterator<const_iterator>; |
| using reverse_iterator = const_reverse_iterator; |
| using size_type = size_t; |
| using difference_type = ptrdiff_t; |
| static constexpr size_type npos = size_type (-1); |
| |
| // [string.view.cons], construct/copy |
| |
| constexpr basic_string_view () noexcept : _M_len { 0 }, _M_str { nullptr } {} |
| |
| constexpr basic_string_view (const basic_string_view &) noexcept = default; |
| |
| template<typename _Allocator> |
| basic_string_view ( |
| const std::basic_string<_CharT, _Traits, _Allocator> &__str) noexcept |
| : _M_len { __str.length () }, |
| _M_str { __str.data () } |
| { |
| } |
| |
| /*constexpr*/ basic_string_view (const _CharT *__str) |
| : _M_len { __str == nullptr ? 0 : traits_type::length (__str) }, |
| _M_str { __str } |
| { |
| } |
| |
| constexpr basic_string_view (const _CharT *__str, size_type __len) |
| : _M_len { __len }, |
| _M_str { __str } |
| { |
| } |
| |
| basic_string_view &operator= (const basic_string_view &) noexcept = default; |
| |
| // [string.view.iterators], iterators |
| |
| constexpr const_iterator begin () const noexcept { return this->_M_str; } |
| |
| constexpr const_iterator end () const noexcept |
| { |
| return this->_M_str + this->_M_len; |
| } |
| |
| constexpr const_iterator cbegin () const noexcept { return this->_M_str; } |
| |
| constexpr const_iterator cend () const noexcept |
| { |
| return this->_M_str + this->_M_len; |
| } |
| |
| const_reverse_iterator rbegin () const noexcept |
| { |
| return const_reverse_iterator (this->end ()); |
| } |
| |
| const_reverse_iterator rend () const noexcept |
| { |
| return const_reverse_iterator (this->begin ()); |
| } |
| |
| const_reverse_iterator crbegin () const noexcept |
| { |
| return const_reverse_iterator (this->end ()); |
| } |
| |
| const_reverse_iterator crend () const noexcept |
| { |
| return const_reverse_iterator (this->begin ()); |
| } |
| |
| // [string.view.capacity], capacity |
| |
| constexpr size_type size () const noexcept { return this->_M_len; } |
| |
| constexpr size_type length () const noexcept { return _M_len; } |
| |
| constexpr size_type max_size () const noexcept |
| { |
| return (npos - sizeof (size_type) - sizeof (void *)) / sizeof (value_type) |
| / 4; |
| } |
| |
| constexpr bool empty () const noexcept { return this->_M_len == 0; } |
| |
| // [string.view.access], element access |
| |
| constexpr const _CharT &operator[] (size_type __pos) const |
| { |
| // TODO: Assert to restore in a way compatible with the constexpr. |
| // __glibcxx_assert(__pos < this->_M_len); |
| return *(this->_M_str + __pos); |
| } |
| |
| constexpr const _CharT &at (size_type __pos) const |
| { |
| return __pos < this->_M_len ? *(this->_M_str + __pos) |
| : (error (_ ("basic_string_view::at: __pos " |
| "(which is %zu) >= this->size() " |
| "(which is %zu)"), |
| __pos, this->size ()), |
| *this->_M_str); |
| } |
| |
| constexpr const _CharT &front () const |
| { |
| // TODO: Assert to restore in a way compatible with the constexpr. |
| // __glibcxx_assert(this->_M_len > 0); |
| return *this->_M_str; |
| } |
| |
| constexpr const _CharT &back () const |
| { |
| // TODO: Assert to restore in a way compatible with the constexpr. |
| // __glibcxx_assert(this->_M_len > 0); |
| return *(this->_M_str + this->_M_len - 1); |
| } |
| |
| constexpr const _CharT *data () const noexcept { return this->_M_str; } |
| |
| // [string.view.modifiers], modifiers: |
| |
| /*constexpr*/ void remove_prefix (size_type __n) |
| { |
| gdb_assert (this->_M_len >= __n); |
| this->_M_str += __n; |
| this->_M_len -= __n; |
| } |
| |
| /*constexpr*/ void remove_suffix (size_type __n) { this->_M_len -= __n; } |
| |
| /*constexpr*/ void swap (basic_string_view &__sv) noexcept |
| { |
| auto __tmp = *this; |
| *this = __sv; |
| __sv = __tmp; |
| } |
| |
| // [string.view.ops], string operations: |
| |
| template<typename _Allocator> |
| explicit operator std::basic_string<_CharT, _Traits, _Allocator> () const |
| { |
| return { this->_M_str, this->_M_len }; |
| } |
| |
| size_type copy (_CharT *__str, size_type __n, size_type __pos = 0) const |
| { |
| gdb_assert (__str != nullptr || __n == 0); |
| if (__pos > this->_M_len) |
| error (_ ("basic_string_view::copy: __pos " |
| "(which is %zu) > this->size() " |
| "(which is %zu)"), |
| __pos, this->size ()); |
| size_type __rlen { std::min (__n, size_type { this->_M_len - __pos }) }; |
| for (auto __begin = this->_M_str + __pos, __end = __begin + __rlen; |
| __begin != __end;) |
| *__str++ = *__begin++; |
| return __rlen; |
| } |
| |
| // [string.view.ops], string operations: |
| |
| /*constexpr*/ basic_string_view substr (size_type __pos, |
| size_type __n = npos) const |
| { |
| return __pos <= this->_M_len |
| ? basic_string_view { this->_M_str + __pos, |
| std::min (__n, size_type { this->_M_len |
| - __pos }) } |
| : (error (_ ("basic_string_view::substr: __pos " |
| "(which is %zu) > this->size() " |
| "(which is %zu)"), |
| __pos, this->size ()), |
| basic_string_view {}); |
| } |
| |
| /*constexpr*/ int compare (basic_string_view __str) const noexcept |
| { |
| int __ret = traits_type::compare (this->_M_str, __str._M_str, |
| std::min (this->_M_len, __str._M_len)); |
| if (__ret == 0) |
| __ret = _S_compare (this->_M_len, __str._M_len); |
| return __ret; |
| } |
| |
| /*constexpr*/ int compare (size_type __pos1, size_type __n1, |
| basic_string_view __str) const |
| { |
| return this->substr (__pos1, __n1).compare (__str); |
| } |
| |
| /*constexpr*/ int compare (size_type __pos1, size_type __n1, |
| basic_string_view __str, size_type __pos2, |
| size_type __n2) const |
| { |
| return this->substr (__pos1, __n1).compare (__str.substr (__pos2, __n2)); |
| } |
| |
| /*constexpr*/ int compare (const _CharT *__str) const noexcept |
| { |
| return this->compare (basic_string_view { __str }); |
| } |
| |
| /*constexpr*/ int compare (size_type __pos1, size_type __n1, |
| const _CharT *__str) const |
| { |
| return this->substr (__pos1, __n1).compare (basic_string_view { __str }); |
| } |
| |
| /*constexpr*/ int compare (size_type __pos1, size_type __n1, |
| const _CharT *__str, size_type __n2) const |
| { |
| return this->substr (__pos1, __n1) |
| .compare (basic_string_view (__str, __n2)); |
| } |
| |
| /*constexpr*/ size_type find (basic_string_view __str, |
| size_type __pos = 0) const noexcept |
| { |
| return this->find (__str._M_str, __pos, __str._M_len); |
| } |
| |
| /*constexpr*/ size_type find (_CharT __c, |
| size_type __pos = 0) const noexcept; |
| |
| /*constexpr*/ size_type find (const _CharT *__str, size_type __pos, |
| size_type __n) const noexcept; |
| |
| /*constexpr*/ size_type find (const _CharT *__str, |
| size_type __pos = 0) const noexcept |
| { |
| return this->find (__str, __pos, traits_type::length (__str)); |
| } |
| |
| /*constexpr*/ size_type rfind (basic_string_view __str, |
| size_type __pos = npos) const noexcept |
| { |
| return this->rfind (__str._M_str, __pos, __str._M_len); |
| } |
| |
| /*constexpr*/ size_type rfind (_CharT __c, |
| size_type __pos = npos) const noexcept; |
| |
| /*constexpr*/ size_type rfind (const _CharT *__str, size_type __pos, |
| size_type __n) const noexcept; |
| |
| /*constexpr*/ size_type rfind (const _CharT *__str, |
| size_type __pos = npos) const noexcept |
| { |
| return this->rfind (__str, __pos, traits_type::length (__str)); |
| } |
| |
| /*constexpr*/ size_type find_first_of (basic_string_view __str, |
| size_type __pos = 0) const noexcept |
| { |
| return this->find_first_of (__str._M_str, __pos, __str._M_len); |
| } |
| |
| /*constexpr*/ size_type find_first_of (_CharT __c, |
| size_type __pos = 0) const noexcept |
| { |
| return this->find (__c, __pos); |
| } |
| |
| /*constexpr*/ size_type find_first_of (const _CharT *__str, size_type __pos, |
| size_type __n) const; |
| |
| /*constexpr*/ size_type find_first_of (const _CharT *__str, |
| size_type __pos = 0) const noexcept |
| { |
| return this->find_first_of (__str, __pos, traits_type::length (__str)); |
| } |
| |
| /*constexpr*/ size_type find_last_of (basic_string_view __str, |
| size_type __pos = npos) const noexcept |
| { |
| return this->find_last_of (__str._M_str, __pos, __str._M_len); |
| } |
| |
| size_type find_last_of (_CharT __c, size_type __pos = npos) const noexcept |
| { |
| return this->rfind (__c, __pos); |
| } |
| |
| /*constexpr*/ size_type find_last_of (const _CharT *__str, size_type __pos, |
| size_type __n) const; |
| |
| /*constexpr*/ size_type find_last_of (const _CharT *__str, |
| size_type __pos = npos) const noexcept |
| { |
| return this->find_last_of (__str, __pos, traits_type::length (__str)); |
| } |
| |
| /*constexpr*/ size_type find_first_not_of (basic_string_view __str, |
| size_type __pos |
| = 0) const noexcept |
| { |
| return this->find_first_not_of (__str._M_str, __pos, __str._M_len); |
| } |
| |
| /*constexpr*/ size_type find_first_not_of (_CharT __c, size_type __pos |
| = 0) const noexcept; |
| |
| /*constexpr*/ size_type find_first_not_of (const _CharT *__str, |
| size_type __pos, |
| size_type __n) const; |
| |
| /*constexpr*/ size_type |
| find_first_not_of (const _CharT *__str, size_type __pos = 0) const noexcept |
| { |
| return this->find_first_not_of (__str, __pos, traits_type::length (__str)); |
| } |
| |
| /*constexpr*/ size_type find_last_not_of (basic_string_view __str, |
| size_type __pos |
| = npos) const noexcept |
| { |
| return this->find_last_not_of (__str._M_str, __pos, __str._M_len); |
| } |
| |
| /*constexpr*/ size_type find_last_not_of (_CharT __c, size_type __pos |
| = npos) const noexcept; |
| |
| /*constexpr*/ size_type |
| find_last_not_of (const _CharT *__str, size_type __pos, size_type __n) const; |
| |
| /*constexpr*/ size_type |
| find_last_not_of (const _CharT *__str, size_type __pos = npos) const noexcept |
| { |
| return this->find_last_not_of (__str, __pos, traits_type::length (__str)); |
| } |
| |
| private: |
| static constexpr int _S_compare (size_type __n1, size_type __n2) noexcept |
| { |
| return difference_type (__n1 - __n2) > std::numeric_limits<int>::max () |
| ? std::numeric_limits<int>::max () |
| : difference_type (__n1 - __n2) < std::numeric_limits<int>::min () |
| ? std::numeric_limits<int>::min () |
| : static_cast<int> (difference_type (__n1 - __n2)); |
| } |
| |
| size_t _M_len; |
| const _CharT *_M_str; |
| }; |
| |
| // [string.view.comparison], non-member basic_string_view comparison functions |
| |
| namespace __detail |
| { |
| // Identity transform to create a non-deduced context, so that only one |
| // argument participates in template argument deduction and the other |
| // argument gets implicitly converted to the deduced type. See n3766.html. |
| template<typename _Tp> |
| using __idt = typename std::common_type<_Tp>::type; |
| } // namespace __detail |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator== (basic_string_view<_CharT, _Traits> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return __x.size () == __y.size () && __x.compare (__y) == 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator== (basic_string_view<_CharT, _Traits> __x, |
| __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept |
| { |
| return __x.size () == __y.size () && __x.compare (__y) == 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator== (__detail::__idt<basic_string_view<_CharT, _Traits>> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return __x.size () == __y.size () && __x.compare (__y) == 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator!= (basic_string_view<_CharT, _Traits> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return !(__x == __y); |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator!= (basic_string_view<_CharT, _Traits> __x, |
| __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept |
| { |
| return !(__x == __y); |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator!= (__detail::__idt<basic_string_view<_CharT, _Traits>> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return !(__x == __y); |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator<(basic_string_view<_CharT, _Traits> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return __x.compare (__y) < 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator<(basic_string_view<_CharT, _Traits> __x, |
| __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept |
| { |
| return __x.compare (__y) < 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator<(__detail::__idt<basic_string_view<_CharT, _Traits>> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return __x.compare (__y) < 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator> (basic_string_view<_CharT, _Traits> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return __x.compare (__y) > 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator> (basic_string_view<_CharT, _Traits> __x, |
| __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept |
| { |
| return __x.compare (__y) > 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator> (__detail::__idt<basic_string_view<_CharT, _Traits>> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return __x.compare (__y) > 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator<= (basic_string_view<_CharT, _Traits> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return __x.compare (__y) <= 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator<= (basic_string_view<_CharT, _Traits> __x, |
| __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept |
| { |
| return __x.compare (__y) <= 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator<= (__detail::__idt<basic_string_view<_CharT, _Traits>> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return __x.compare (__y) <= 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator>= (basic_string_view<_CharT, _Traits> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return __x.compare (__y) >= 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator>= (basic_string_view<_CharT, _Traits> __x, |
| __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept |
| { |
| return __x.compare (__y) >= 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| /*constexpr*/ bool |
| operator>= (__detail::__idt<basic_string_view<_CharT, _Traits>> __x, |
| basic_string_view<_CharT, _Traits> __y) noexcept |
| { |
| return __x.compare (__y) >= 0; |
| } |
| |
| // basic_string_view typedef names |
| |
| using string_view = basic_string_view<char>; |
| } /* namespace gdb */ |
| |
| #include "gdb_string_view.tcc" |
| |
| #endif // __cplusplus < 201703L |
| |
| namespace gdb |
| { |
| |
| static inline std::string |
| to_string (const gdb::string_view &view) |
| { |
| return { view.data (), view.size () }; |
| } |
| |
| } // namespace gdb |
| |
| #endif /* COMMON_GDB_STRING_VIEW_H */ |
