Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-12-25 17:31:02 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Ensure that hash<basic_string> uses char_traits. Fixes PR#41876. Reviewed as https://reviews.llvm.org/D61954

Browse Source 
llvm-svn: 361201
This commit is contained in:
Marshall Clow 2019-05-20 21:56:51 +00:00
parent 54dc01cbfc
commit d75a0450ad
2 changed files with 75 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
libcxx/include/string
View File

@ -1420,7 +1420,7 @@ public:
_LIBCPP_INLINE_VISIBILITY bool __invariants() const;
_LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY
bool __is_long() const _NOEXCEPT
{return bool(__r_.first().__s.__size_ & __short_mask);}
@ -1682,7 +1682,7 @@ basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _
-> basic_string<_CharT, _Traits, _Allocator>;
#endif
template <class _CharT, class _Traits, class _Allocator>
inline
void
@ -4227,21 +4227,17 @@ template<class _CharT, class _Traits, class _Allocator>
const typename basic_string<_CharT, _Traits, _Allocator>::size_type
basic_string<_CharT, _Traits, _Allocator>::npos;
template<class _CharT, class _Traits, class _Allocator>
struct _LIBCPP_TEMPLATE_VIS hash<basic_string<_CharT, _Traits, _Allocator> >
: public unary_function<basic_string<_CharT, _Traits, _Allocator>, size_t>
template <class _CharT, class _Allocator>
struct _LIBCPP_TEMPLATE_VIS
hash<basic_string<_CharT, char_traits<_CharT>, _Allocator> >
: public unary_function<
basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t>
{
size_t
operator()(const basic_string<_CharT, _Traits, _Allocator>& __val) const _NOEXCEPT;
operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT
{ return __do_string_hash(__val.data(), __val.data() + __val.size()); }
};
template<class _CharT, class _Traits, class _Allocator>
size_t
hash<basic_string<_CharT, _Traits, _Allocator> >::operator()(
const basic_string<_CharT, _Traits, _Allocator>& __val) const _NOEXCEPT
{
return __do_string_hash(__val.data(), __val.data() + __val.size());
}
template<class _CharT, class _Traits, class _Allocator>
basic_ostream<_CharT, _Traits>&

66
libcxx/test/std/strings/basic.string.hash/char_type_hash.fail.cpp Normal file
View File

@ -0,0 +1,66 @@
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <string>
// Test that hash specializations for <string> require "char_traits<_CharT>" not just any "_Trait".
#include <string>
template <class _CharT>
struct trait // copied from <__string>
{
typedef _CharT char_type;
typedef int int_type;
typedef std::streamoff off_type;
typedef std::streampos pos_type;
typedef std::mbstate_t state_type;
static inline void assign(char_type& __c1, const char_type& __c2) {
__c1 = __c2;
}
static inline bool eq(char_type __c1, char_type __c2) { return __c1 == __c2; }
static inline bool lt(char_type __c1, char_type __c2) { return __c1 < __c2; }
static int compare(const char_type* __s1, const char_type* __s2, size_t __n);
static size_t length(const char_type* __s);
static const char_type* find(const char_type* __s, size_t __n,
const char_type& __a);
static char_type* move(char_type* __s1, const char_type* __s2, size_t __n);
static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n);
static char_type* assign(char_type* __s, size_t __n, char_type __a);
static inline int_type not_eof(int_type __c) {
return eq_int_type(__c, eof()) ? ~eof() : __c;
}
static inline char_type to_char_type(int_type __c) { return char_type(__c); }
static inline int_type to_int_type(char_type __c) { return int_type(__c); }
static inline bool eq_int_type(int_type __c1, int_type __c2) {
return __c1 == __c2;
}
static inline int_type eof() { return int_type(EOF); }
};
template <class CharT>
void test() {
typedef std::basic_string<CharT, trait<CharT> > str_t;
std::hash<str_t>
h; // call to implicitly-deleted default constructor of 'std::hash<str_t>' {{*}}}}
}
int main(int, char**) {
test<char>();
test<wchar_t>();
test<char16_t>();
test<char32_t>();
return 0;
}