9#ifndef LLVM_ADT_STRINGREF_H
10#define LLVM_ADT_STRINGREF_H
30 template <
typename T>
class SmallVectorImpl;
35 unsigned long long &Result);
40 unsigned long long &Result);
52 static constexpr size_t npos = ~size_t(0);
60 const char *
Data =
nullptr;
67 static int compareMemory(
const char *Lhs,
const char *Rhs,
size_t Length) {
68 if (
Length == 0) {
return 0; }
69 return ::memcmp(Lhs,Rhs,
Length);
87#
if defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE < 8
90 std::char_traits<
char>::length(Str)
96 constexpr StringRef(
const char *data,
size_t length)
116 return reinterpret_cast<const unsigned char *
>(begin());
119 return reinterpret_cast<const unsigned char *
>(end());
122 return make_range(bytes_begin(), bytes_end());
131 [[nodiscard]]
const char *
data()
const {
return Data; }
134 [[nodiscard]]
constexpr bool empty()
const {
return Length == 0; }
137 [[nodiscard]]
constexpr size_t size()
const {
return Length; }
146 [[nodiscard]]
char back()
const {
152 template <
typename Allocator>
157 char *S =
A.template Allocate<char>(
Length);
158 std::copy(begin(), end(), S);
166 compareMemory(
Data,
RHS.Data,
RHS.Length) == 0);
171 return Length ==
RHS.Length && compare_insensitive(
RHS) == 0;
180 return Res < 0 ? -1 : 1;
189 [[nodiscard]]
int compare_insensitive(
StringRef RHS)
const;
214 bool AllowReplacements =
true,
215 unsigned MaxEditDistance = 0)
const;
217 [[nodiscard]]
unsigned
218 edit_distance_insensitive(
StringRef Other,
bool AllowReplacements =
true,
219 unsigned MaxEditDistance = 0)
const;
222 [[nodiscard]] std::string
str()
const {
223 if (!
Data)
return std::string();
240 template <
typename T>
241 std::enable_if_t<std::is_same<T, std::string>::value,
StringRef> &
248 operator std::string_view()
const {
249 return std::string_view(data(),
size());
258 return Length >= Prefix.Length &&
259 compareMemory(
Data, Prefix.Data, Prefix.Length) == 0;
262 return starts_with(Prefix);
266 [[nodiscard]]
bool starts_with_insensitive(
StringRef Prefix)
const;
268 return starts_with_insensitive(Prefix);
273 return Length >= Suffix.Length &&
274 compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) ==
278 return ends_with(Suffix);
282 [[nodiscard]]
bool ends_with_insensitive(
StringRef Suffix)
const;
284 return ends_with_insensitive(Suffix);
295 [[nodiscard]]
size_t find(
char C,
size_t From = 0)
const {
296 return std::string_view(*this).find(
C,
From);
303 [[nodiscard]]
size_t find_insensitive(
char C,
size_t From = 0)
const;
310 size_t From = 0)
const {
325 size_t From = 0)
const {
339 [[nodiscard]]
size_t find_insensitive(
StringRef Str,
size_t From = 0)
const;
345 [[nodiscard]]
size_t rfind(
char C,
size_t From = npos)
const {
359 [[nodiscard]]
size_t rfind_insensitive(
char C,
size_t From = npos)
const;
365 [[nodiscard]]
size_t rfind(
StringRef Str)
const;
371 [[nodiscard]]
size_t rfind_insensitive(
StringRef Str)
const;
383 [[nodiscard]]
size_t find_first_of(
StringRef Chars,
size_t From = 0)
const;
387 [[nodiscard]]
size_t find_first_not_of(
char C,
size_t From = 0)
const;
393 [[nodiscard]]
size_t find_first_not_of(
StringRef Chars,
394 size_t From = 0)
const;
399 return rfind(
C,
From);
406 [[nodiscard]]
size_t find_last_of(
StringRef Chars,
407 size_t From = npos)
const;
411 [[nodiscard]]
size_t find_last_not_of(
char C,
size_t From = npos)
const;
417 [[nodiscard]]
size_t find_last_not_of(
StringRef Chars,
418 size_t From = npos)
const;
429 return find_first_of(
C) != npos;
435 return find_insensitive(
Other) != npos;
441 return find_insensitive(
C) != npos;
449 [[nodiscard]]
size_t count(
char C)
const {
469 if constexpr (std::numeric_limits<T>::is_signed) {
472 static_cast<T>(LLVal) != LLVal)
476 unsigned long long ULLVal;
481 static_cast<unsigned long long>(
static_cast<T>(ULLVal)) != ULLVal)
498 if constexpr (std::numeric_limits<T>::is_signed) {
501 static_cast<long long>(
static_cast<T>(LLVal)) != LLVal)
505 unsigned long long ULLVal;
507 static_cast<unsigned long long>(
static_cast<T>(ULLVal)) != ULLVal)
524 bool getAsInteger(
unsigned Radix,
APInt &Result)
const;
533 bool getAsDouble(
double &Result,
bool AllowInexact =
true)
const;
540 [[nodiscard]] std::string lower()
const;
543 [[nodiscard]] std::string upper()
const;
559 size_t N = npos)
const {
560 Start = std::min(Start,
Length);
570 return drop_back(
size() -
N);
579 return drop_front(
size() -
N);
597 assert(
size() >=
N &&
"Dropping more elements than exist");
604 assert(
size() >=
N &&
"Dropping more elements than exist");
623 if (!starts_with(Prefix))
626 *
this =
substr(Prefix.size());
633 if (!startswith_insensitive(Prefix))
636 *
this =
substr(Prefix.size());
643 if (!ends_with(Suffix))
653 if (!endswith_insensitive(Suffix))
672 Start = std::min(Start,
Length);
673 End = std::clamp(End, Start,
Length);
687 [[nodiscard]] std::pair<StringRef, StringRef>
split(
char Separator)
const {
701 [[nodiscard]] std::pair<StringRef, StringRef>
705 return std::make_pair(*
this,
StringRef());
706 return std::make_pair(slice(0,
Idx), slice(
Idx + Separator.
size(), npos));
719 [[nodiscard]] std::pair<StringRef, StringRef>
721 size_t Idx = rfind(Separator);
723 return std::make_pair(*
this,
StringRef());
724 return std::make_pair(slice(0,
Idx), slice(
Idx + Separator.
size(), npos));
743 bool KeepEmpty =
true)
const;
760 bool KeepEmpty =
true)
const;
772 [[nodiscard]] std::pair<StringRef, StringRef>
rsplit(
char Separator)
const {
779 return drop_front(std::min(
Length, find_first_not_of(Char)));
785 return drop_front(std::min(
Length, find_first_not_of(Chars)));
791 return drop_back(
Length - std::min(
Length, find_last_not_of(Char) + 1));
797 return drop_back(
Length - std::min(
Length, find_last_not_of(Chars) + 1));
803 return ltrim(Char).
rtrim(Char);
809 return ltrim(Chars).
rtrim(Chars);
819 size_t Pos =
find(
'\r');
824 if (Pos + 1 <
Length &&
Data[Pos + 1] ==
'\n')
826 if (Pos > 0 &&
Data[Pos - 1] ==
'\n')
848#if defined(__clang__) && __has_attribute(enable_if)
849#pragma clang diagnostic push
850#pragma clang diagnostic ignored "-Wgcc-compat"
851 __attribute((enable_if(__builtin_strlen(Str) ==
N - 1,
852 "invalid string literal")))
853#pragma clang diagnostic pop
875 return LHS.compare(
RHS) < 0;
879 return LHS.compare(
RHS) <= 0;
883 return LHS.compare(
RHS) > 0;
887 return LHS.compare(
RHS) >= 0;
891 return buffer.append(
string.data(),
string.
size());
897 [[nodiscard]] hash_code
hash_value(StringRef S);
903 reinterpret_cast<const char *
>(~
static_cast<uintptr_t
>(0)), 0);
908 reinterpret_cast<const char *
>(~
static_cast<uintptr_t
>(1)), 0);
914 if (
RHS.data() == getEmptyKey().data())
915 return LHS.data() == getEmptyKey().data();
916 if (
RHS.data() == getTombstoneKey().data())
917 return LHS.data() == getTombstoneKey().data();
BlockVerifier::State From
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
#define LLVM_GSL_POINTER
LLVM_GSL_POINTER - Apply this to non-owning classes like StringRef to enable lifetime warnings.
static Error split(StringRef Str, char Separator, std::pair< StringRef, StringRef > &Split)
Checked version of split, to ensure mandatory subparts.
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines DenseMapInfo traits for DenseMap.
std::optional< std::vector< StOtherPiece > > Other
return ToRemove size() > 0
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static StringRef substr(StringRef Str, uint64_t Len)
Class for arbitrary precision integers.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
constexpr StringLiteral(const char(&Str)[N])
static constexpr StringLiteral withInnerNUL(const char(&Str)[N])
StringRef - Represent a constant reference to a string, i.e.
bool endswith_insensitive(StringRef Suffix) const
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
StringRef trim(StringRef Chars=" \t\n\v\f\r") const
Return string with consecutive characters in Chars starting from the left and right removed.
bool consume_back(StringRef Suffix)
Returns true if this StringRef has the given suffix and removes that suffix.
bool consumeInteger(unsigned Radix, T &Result)
Parse the current string as an integer of the specified radix.
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
iterator_range< const unsigned char * > bytes() const
std::string str() const
str - Get the contents as an std::string.
size_t find_if(function_ref< bool(char)> F, size_t From=0) const
Search for the first character satisfying the predicate F.
const unsigned char * bytes_end() const
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
constexpr bool empty() const
empty - Check if the string is empty.
bool contains_insensitive(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
StringRef take_while(function_ref< bool(char)> F) const
Return the longest prefix of 'this' such that every character in the prefix satisfies the given predi...
char operator[](size_t Index) const
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
bool contains_insensitive(char C) const
Return true if the given character is contained in *this, and false otherwise.
std::pair< StringRef, StringRef > rsplit(char Separator) const
Split into two substrings around the last occurrence of a separator character.
StringRef drop_until(function_ref< bool(char)> F) const
Return a StringRef equal to 'this', but with all characters not satisfying the given predicate droppe...
char back() const
back - Get the last character in the string.
StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
constexpr size_t size() const
size - Get the string size.
char front() const
front - Get the first character in the string.
size_t find_last_of(char C, size_t From=npos) const
Find the last character in the string that is C, or npos if not found.
StringRef ltrim(char Char) const
Return string with consecutive Char characters starting from the the left removed.
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
bool startswith(StringRef Prefix) const
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
StringRef detectEOL() const
Detect the line ending style of the string.
size_t find_first_of(char C, size_t From=0) const
Find the first character in the string that is C, or npos if not found.
StringRef()=default
Construct an empty string ref.
size_t rfind(char C, size_t From=npos) const
Search for the last character C in the string.
StringRef rtrim(char Char) const
Return string with consecutive Char characters starting from the right removed.
bool contains(char C) const
Return true if the given character is contained in *this, and false otherwise.
StringRef(std::nullptr_t)=delete
Disable conversion from nullptr.
StringRef take_back(size_t N=1) const
Return a StringRef equal to 'this' but with only the last N elements remaining.
StringRef take_front(size_t N=1) const
Return a StringRef equal to 'this' but with only the first N elements remaining.
bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
StringRef take_until(function_ref< bool(char)> F) const
Return the longest prefix of 'this' such that no character in the prefix satisfies the given predicat...
bool startswith_insensitive(StringRef Prefix) const
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
constexpr StringRef(const char *data, size_t length)
Construct a string ref from a pointer and length.
StringRef trim(char Char) const
Return string with consecutive Char characters starting from the left and right removed.
size_t count(char C) const
Return the number of occurrences of C in the string.
bool consume_back_insensitive(StringRef Suffix)
Returns true if this StringRef has the given suffix, ignoring case, and removes that suffix.
bool endswith(StringRef Suffix) const
StringRef copy(Allocator &A) const
bool ends_with(StringRef Suffix) const
Check if this string ends with the given Suffix.
std::pair< StringRef, StringRef > rsplit(StringRef Separator) const
Split into two substrings around the last occurrence of a separator string.
constexpr StringRef(const char *Str)
Construct a string ref from a cstring.
std::pair< StringRef, StringRef > split(StringRef Separator) const
Split into two substrings around the first occurrence of a separator string.
StringRef ltrim(StringRef Chars=" \t\n\v\f\r") const
Return string with consecutive characters in Chars starting from the left removed.
std::enable_if_t< std::is_same< T, std::string >::value, StringRef > & operator=(T &&Str)=delete
Disallow accidental assignment from a temporary std::string.
StringRef rtrim(StringRef Chars=" \t\n\v\f\r") const
Return string with consecutive characters in Chars starting from the right removed.
StringRef drop_while(function_ref< bool(char)> F) const
Return a StringRef equal to 'this', but with all characters satisfying the given predicate dropped fr...
const unsigned char * bytes_begin() const
int compare(StringRef RHS) const
compare - Compare two strings; the result is negative, zero, or positive if this string is lexicograp...
StringRef drop_back(size_t N=1) const
Return a StringRef equal to 'this' but with the last N elements dropped.
bool equals_insensitive(StringRef RHS) const
Check for string equality, ignoring case.
bool consume_front_insensitive(StringRef Prefix)
Returns true if this StringRef has the given prefix, ignoring case, and removes that prefix.
StringRef(const std::string &Str)
Construct a string ref from an std::string.
constexpr StringRef(std::string_view Str)
Construct a string ref from an std::string_view.
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
size_t find_if_not(function_ref< bool(char)> F, size_t From=0) const
Search for the first character not satisfying the predicate F.
An efficient, type-erasing, non-owning reference to a callable.
A range adaptor for a pair of iterators.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
This is an optimization pass for GlobalISel generic memory operations.
bool operator<(int64_t V1, const APSInt &V2)
auto find(R &&Range, const T &Val)
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.
bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result)
hash_code hash_value(const FixedPointSemantics &Val)
bool operator!=(uint64_t V1, const APInt &V2)
bool operator>=(int64_t V1, const APSInt &V2)
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
std::string & operator+=(std::string &buffer, StringRef string)
bool operator==(const AddressRangeValuePair &LHS, const AddressRangeValuePair &RHS)
bool consumeUnsignedInteger(StringRef &Str, unsigned Radix, unsigned long long &Result)
bool operator>(int64_t V1, const APSInt &V2)
auto find_if_not(R &&Range, UnaryPredicate P)
bool consumeSignedInteger(StringRef &Str, unsigned Radix, long long &Result)
auto count(R &&Range, const E &Element)
Wrapper function around std::count to count the number of times an element Element occurs in the give...
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
bool getAsUnsignedInteger(StringRef Str, unsigned Radix, unsigned long long &Result)
Helper functions for StringRef::getAsInteger.
bool operator<=(int64_t V1, const APSInt &V2)
static StringRef getEmptyKey()
static bool isEqual(StringRef LHS, StringRef RHS)
static unsigned getHashValue(StringRef Val)
static StringRef getTombstoneKey()
An information struct used to provide DenseMap with the various necessary components for a given valu...