29 unsigned char LHC = toLower(
LHS[
I]);
30 unsigned char RHC = toLower(
RHS[
I]);
32 return LHC < RHC ? -1 : 1;
40 if (Length ==
RHS.Length)
42 return Length <
RHS.Length ? -1 : 1;
46 return Length >= Prefix.Length &&
51 return Length >= Suffix.Length &&
57 return find_if([L](
char D) {
return toLower(
D) == L; },
From);
62 for (
size_t I = 0, E = std::min(Length,
RHS.Length);
I != E; ++
I) {
68 for (J =
I + 1; J != E + 1; ++J) {
69 bool ld = J < Length &&
isDigit(Data[J]);
77 if (
int Res = compareMemory(Data +
I,
RHS.Data +
I, J -
I))
78 return Res < 0 ? -1 : 1;
83 if (Data[
I] !=
RHS.Data[
I])
84 return (
unsigned char)Data[
I] < (
unsigned char)
RHS.Data[
I] ? -1 : 1;
86 if (Length ==
RHS.Length)
88 return Length <
RHS.Length ? -1 : 1;
93 bool AllowReplacements,
94 unsigned MaxEditDistance)
const {
97 AllowReplacements, MaxEditDistance);
101 StringRef Other,
bool AllowReplacements,
unsigned MaxEditDistance)
const {
104 llvm::toLower, AllowReplacements, MaxEditDistance);
134 const char *Start = Data +
From;
137 const char *Needle = Str.data();
138 size_t N = Str.size();
144 const char *
Ptr = (
const char *)::memchr(Start, Needle[0],
Size);
148 const char *Stop = Start + (
Size -
N + 1);
155 if (std::memcmp(Start, Needle, 2) == 0)
158 }
while (Start < Stop);
163 if (Size < 16 || N > 255) {
165 if (std::memcmp(Start, Needle,
N) == 0)
168 }
while (Start < Stop);
173 uint8_t BadCharSkip[256];
174 std::memset(BadCharSkip,
N, 256);
175 for (
unsigned i = 0; i !=
N-1; ++i)
176 BadCharSkip[(uint8_t)Str[i]] =
N-1-i;
179 uint8_t
Last = Start[
N - 1];
181 if (std::memcmp(Start, Needle,
N - 1) == 0)
185 Start += BadCharSkip[
Last];
186 }
while (Start < Stop);
193 while (This.size() >= Str.size()) {
194 if (This.starts_with_insensitive(Str))
196 This = This.drop_front();
207 if (toLower(Data[i]) == toLower(
C))
218 return std::string_view(*this).rfind(Str);
222 size_t N = Str.size();
225 for (
size_t i = Length -
N + 1, e = 0; i != e;) {
239 std::bitset<1 << CHAR_BIT> CharBits;
241 CharBits.set((
unsigned char)
C);
243 for (
size_type i = std::min(
From, Length), e = Length; i != e; ++i)
244 if (CharBits.test((
unsigned char)Data[i]))
252 return std::string_view(*this).find_first_not_of(
C,
From);
261 std::bitset<1 << CHAR_BIT> CharBits;
263 CharBits.set((
unsigned char)
C);
265 for (
size_type i = std::min(
From, Length), e = Length; i != e; ++i)
266 if (!CharBits.test((
unsigned char)Data[i]))
277 std::bitset<1 << CHAR_BIT> CharBits;
279 CharBits.set((
unsigned char)
C);
281 for (
size_type i = std::min(
From, Length) - 1, e = -1; i != e; --i)
282 if (CharBits.test((
unsigned char)Data[i]))
290 for (
size_type i = std::min(
From, Length) - 1, e = -1; i != e; --i)
302 std::bitset<1 << CHAR_BIT> CharBits;
304 CharBits.set((
unsigned char)
C);
306 for (
size_type i = std::min(
From, Length) - 1, e = -1; i != e; --i)
307 if (!CharBits.test((
unsigned char)Data[i]))
314 bool KeepEmpty)
const {
321 while (MaxSplit-- != 0) {
322 size_t Idx = S.
find(Separator);
327 if (KeepEmpty ||
Idx > 0)
335 if (KeepEmpty || !S.
empty())
340 int MaxSplit,
bool KeepEmpty)
const {
347 while (MaxSplit-- != 0) {
348 size_t Idx = S.
find(Separator);
353 if (KeepEmpty ||
Idx > 0)
361 if (KeepEmpty || !S.
empty())
374 size_t N = Str.size();
380 while ((Pos =
find(Str, Pos)) !=
npos) {
391 if (Str.consume_front_insensitive(
"0x"))
394 if (Str.consume_front_insensitive(
"0b"))
397 if (Str.consume_front(
"0o"))
400 if (Str[0] ==
'0' && Str.size() > 1 &&
isDigit(Str[1])) {
409 unsigned long long &Result) {
415 if (Str.empty())
return true;
420 while (!Str2.
empty()) {
422 if (Str2[0] >=
'0' && Str2[0] <=
'9')
423 CharVal = Str2[0] -
'0';
424 else if (Str2[0] >=
'a' && Str2[0] <=
'z')
425 CharVal = Str2[0] -
'a' + 10;
426 else if (Str2[0] >=
'A' && Str2[0] <=
'Z')
427 CharVal = Str2[0] -
'A' + 10;
433 if (CharVal >= Radix)
437 unsigned long long PrevResult = Result;
438 Result = Result * Radix + CharVal;
441 if (Result / Radix < PrevResult)
449 if (Str.size() == Str2.
size())
458 unsigned long long ULLVal;
461 if (!Str.starts_with(
"-")) {
464 (
long long)ULLVal < 0)
476 (
long long)-ULLVal > 0)
487 unsigned long long &Result) {
513 assert(Radix > 1 && Radix <= 36);
516 if (Str.empty())
return true;
520 Str = Str.ltrim(
'0');
524 Result =
APInt(64, 0);
530 unsigned Log2Radix = 0;
531 while ((1U << Log2Radix) < Radix) Log2Radix++;
532 bool IsPowerOf2Radix = ((1U << Log2Radix) == Radix);
534 unsigned BitWidth = Log2Radix * Str.size();
535 if (
BitWidth < Result.getBitWidth())
537 else if (
BitWidth > Result.getBitWidth())
540 APInt RadixAP, CharAP;
541 if (!IsPowerOf2Radix) {
549 while (!Str.empty()) {
551 if (Str[0] >=
'0' && Str[0] <=
'9')
552 CharVal = Str[0]-
'0';
553 else if (Str[0] >=
'a' && Str[0] <=
'z')
554 CharVal = Str[0]-
'a'+10;
555 else if (Str[0] >=
'A' && Str[0] <=
'Z')
556 CharVal = Str[0]-
'A'+10;
562 if (CharVal >= Radix)
566 if (IsPowerOf2Radix) {
567 Result <<= Log2Radix;
580 if (
size() == Str.size())
589 if (Str.consumeInteger(Radix, Result))
609 Result =
F.convertToDouble();
620 "Cannot hash the empty key!");
621 assert(Val.
data() != getTombstoneKey().data() &&
622 "Cannot hash the tombstone key!");
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
BlockVerifier::State From
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
#define LLVM_UNLIKELY(EXPR)
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
static bool isDigit(const char C)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static unsigned GetAutoSenseRadix(StringRef &Str)
static int ascii_strncasecmp(const char *LHS, const char *RHS, size_t Length)
Class for arbitrary precision integers.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
StringRef - Represent a constant reference to a string, i.e.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
size_t find_last_not_of(char C, size_t From=npos) const
Find the last character in the string that is not C, or npos if not found.
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.
bool getAsDouble(double &Result, bool AllowInexact=true) const
Parse the current string as an IEEE double-precision floating point value.
size_t find_if(function_ref< bool(char)> F, size_t From=0) const
Search for the first character satisfying the predicate F.
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
constexpr bool empty() const
empty - Check if the string is empty.
bool starts_with_insensitive(StringRef Prefix) const
Check if this string starts with the given Prefix, ignoring case.
std::string upper() const
Convert the given ASCII string to uppercase.
unsigned edit_distance(StringRef Other, bool AllowReplacements=true, unsigned MaxEditDistance=0) const
Determine the edit distance between this string and another 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.
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.
constexpr const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
int compare_numeric(StringRef RHS) const
compare_numeric - Compare two strings, treating sequences of digits as numbers.
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.
size_t rfind(char C, size_t From=npos) const
Search for the last character C in the string.
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
size_t rfind_insensitive(char C, size_t From=npos) const
Search for the last character C in the string, ignoring case.
std::string lower() const
size_t find_insensitive(char C, size_t From=0) const
Search for the first character C in the string, ignoring case.
size_t count(char C) const
Return the number of occurrences of C in the string.
static constexpr size_t npos
bool equals_insensitive(StringRef RHS) const
Check for string equality, ignoring case.
bool ends_with_insensitive(StringRef Suffix) const
Check if this string ends with the given Suffix, ignoring case.
size_t find_first_not_of(char C, size_t From=0) const
Find the first character in the string that is not C or npos if not found.
int compare_insensitive(StringRef RHS) const
Compare two strings, ignoring case.
unsigned edit_distance_insensitive(StringRef Other, bool AllowReplacements=true, unsigned MaxEditDistance=0) const
An opaque object representing a hash code.
This file defines a Levenshtein distance function that works for any two sequences,...
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
bool errorToBool(Error Err)
Helper for converting an Error to a bool.
bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result)
hash_code hash_value(const FixedPointSemantics &Val)
mapped_iterator< ItTy, FuncTy > map_iterator(ItTy I, FuncTy F)
bool consumeUnsignedInteger(StringRef &Str, unsigned Radix, unsigned long long &Result)
unsigned ComputeEditDistance(ArrayRef< T > FromArray, ArrayRef< T > ToArray, bool AllowReplacements=true, unsigned MaxEditDistance=0)
bool consumeSignedInteger(StringRef &Str, unsigned Radix, long long &Result)
constexpr unsigned BitWidth
bool getAsUnsignedInteger(StringRef Str, unsigned Radix, unsigned long long &Result)
Helper functions for StringRef::getAsInteger.
unsigned ComputeMappedEditDistance(ArrayRef< T > FromArray, ArrayRef< T > ToArray, Functor Map, bool AllowReplacements=true, unsigned MaxEditDistance=0)
Determine the edit distance between two sequences.
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
static constexpr roundingMode rmNearestTiesToEven
opStatus
IEEE-754R 7: Default exception handling.
An information struct used to provide DenseMap with the various necessary components for a given valu...