2009-09-17 06:38:48 +08:00
|
|
|
//===-- StringRef.cpp - Lightweight String References ---------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
2017-02-15 03:06:37 +08:00
|
|
|
#include "llvm/ADT/APFloat.h"
|
2010-02-28 17:55:58 +08:00
|
|
|
#include "llvm/ADT/APInt.h"
|
2012-03-04 18:55:27 +08:00
|
|
|
#include "llvm/ADT/Hashing.h"
|
2017-11-28 22:22:27 +08:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2012-02-16 06:13:07 +08:00
|
|
|
#include "llvm/ADT/edit_distance.h"
|
2010-08-24 02:16:08 +08:00
|
|
|
#include <bitset>
|
2010-01-07 08:51:54 +08:00
|
|
|
|
2009-09-17 06:38:48 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2009-09-22 11:34:40 +08:00
|
|
|
// MSVC emits references to this into the translation units which reference it.
|
|
|
|
#ifndef _MSC_VER
|
2009-09-17 06:38:48 +08:00
|
|
|
const size_t StringRef::npos;
|
2009-09-22 11:34:40 +08:00
|
|
|
#endif
|
2009-09-20 03:47:14 +08:00
|
|
|
|
2013-10-31 02:32:26 +08:00
|
|
|
// strncasecmp() is not available on non-POSIX systems, so define an
|
|
|
|
// alternative function here.
|
|
|
|
static int ascii_strncasecmp(const char *LHS, const char *RHS, size_t Length) {
|
|
|
|
for (size_t I = 0; I < Length; ++I) {
|
2017-11-28 22:22:27 +08:00
|
|
|
unsigned char LHC = toLower(LHS[I]);
|
|
|
|
unsigned char RHC = toLower(RHS[I]);
|
2009-11-13 04:36:59 +08:00
|
|
|
if (LHC != RHC)
|
|
|
|
return LHC < RHC ? -1 : 1;
|
|
|
|
}
|
2013-10-31 02:32:26 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2009-11-13 04:36:59 +08:00
|
|
|
|
2013-10-31 02:32:26 +08:00
|
|
|
/// compare_lower - Compare strings, ignoring case.
|
|
|
|
int StringRef::compare_lower(StringRef RHS) const {
|
2014-08-21 12:31:10 +08:00
|
|
|
if (int Res = ascii_strncasecmp(Data, RHS.Data, std::min(Length, RHS.Length)))
|
2013-10-31 02:32:26 +08:00
|
|
|
return Res;
|
2009-11-13 04:36:59 +08:00
|
|
|
if (Length == RHS.Length)
|
2010-08-26 22:21:08 +08:00
|
|
|
return 0;
|
2009-11-13 04:36:59 +08:00
|
|
|
return Length < RHS.Length ? -1 : 1;
|
|
|
|
}
|
|
|
|
|
2013-10-31 02:32:26 +08:00
|
|
|
/// Check if this string starts with the given \p Prefix, ignoring case.
|
|
|
|
bool StringRef::startswith_lower(StringRef Prefix) const {
|
|
|
|
return Length >= Prefix.Length &&
|
|
|
|
ascii_strncasecmp(Data, Prefix.Data, Prefix.Length) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Check if this string ends with the given \p Suffix, ignoring case.
|
|
|
|
bool StringRef::endswith_lower(StringRef Suffix) const {
|
|
|
|
return Length >= Suffix.Length &&
|
|
|
|
ascii_strncasecmp(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 0;
|
|
|
|
}
|
|
|
|
|
2016-11-13 01:17:12 +08:00
|
|
|
size_t StringRef::find_lower(char C, size_t From) const {
|
2017-11-28 22:22:27 +08:00
|
|
|
char L = toLower(C);
|
|
|
|
return find_if([L](char D) { return toLower(D) == L; }, From);
|
2016-11-13 01:17:12 +08:00
|
|
|
}
|
|
|
|
|
Add StringRef::compare_numeric and use it to sort TableGen register records.
This means that our Registers are now ordered R7, R8, R9, R10, R12, ...
Not R1, R10, R11, R12, R2, R3, ...
llvm-svn: 104745
2010-05-27 05:47:28 +08:00
|
|
|
/// compare_numeric - Compare strings, handle embedded numbers.
|
|
|
|
int StringRef::compare_numeric(StringRef RHS) const {
|
2014-08-21 12:31:10 +08:00
|
|
|
for (size_t I = 0, E = std::min(Length, RHS.Length); I != E; ++I) {
|
2011-10-01 01:03:55 +08:00
|
|
|
// Check for sequences of digits.
|
2017-11-28 22:22:27 +08:00
|
|
|
if (isDigit(Data[I]) && isDigit(RHS.Data[I])) {
|
2011-10-01 01:03:55 +08:00
|
|
|
// The longer sequence of numbers is considered larger.
|
|
|
|
// This doesn't really handle prefixed zeros well.
|
|
|
|
size_t J;
|
|
|
|
for (J = I + 1; J != E + 1; ++J) {
|
2017-11-28 22:22:27 +08:00
|
|
|
bool ld = J < Length && isDigit(Data[J]);
|
|
|
|
bool rd = J < RHS.Length && isDigit(RHS.Data[J]);
|
Add StringRef::compare_numeric and use it to sort TableGen register records.
This means that our Registers are now ordered R7, R8, R9, R10, R12, ...
Not R1, R10, R11, R12, R2, R3, ...
llvm-svn: 104745
2010-05-27 05:47:28 +08:00
|
|
|
if (ld != rd)
|
|
|
|
return rd ? -1 : 1;
|
|
|
|
if (!rd)
|
|
|
|
break;
|
|
|
|
}
|
2011-10-01 01:03:55 +08:00
|
|
|
// The two number sequences have the same length (J-I), just memcmp them.
|
|
|
|
if (int Res = compareMemory(Data + I, RHS.Data + I, J - I))
|
|
|
|
return Res < 0 ? -1 : 1;
|
|
|
|
// Identical number sequences, continue search after the numbers.
|
|
|
|
I = J - 1;
|
|
|
|
continue;
|
Add StringRef::compare_numeric and use it to sort TableGen register records.
This means that our Registers are now ordered R7, R8, R9, R10, R12, ...
Not R1, R10, R11, R12, R2, R3, ...
llvm-svn: 104745
2010-05-27 05:47:28 +08:00
|
|
|
}
|
2011-10-01 01:03:55 +08:00
|
|
|
if (Data[I] != RHS.Data[I])
|
|
|
|
return (unsigned char)Data[I] < (unsigned char)RHS.Data[I] ? -1 : 1;
|
Add StringRef::compare_numeric and use it to sort TableGen register records.
This means that our Registers are now ordered R7, R8, R9, R10, R12, ...
Not R1, R10, R11, R12, R2, R3, ...
llvm-svn: 104745
2010-05-27 05:47:28 +08:00
|
|
|
}
|
|
|
|
if (Length == RHS.Length)
|
2010-08-26 22:21:08 +08:00
|
|
|
return 0;
|
Add StringRef::compare_numeric and use it to sort TableGen register records.
This means that our Registers are now ordered R7, R8, R9, R10, R12, ...
Not R1, R10, R11, R12, R2, R3, ...
llvm-svn: 104745
2010-05-27 05:47:28 +08:00
|
|
|
return Length < RHS.Length ? -1 : 1;
|
|
|
|
}
|
|
|
|
|
2009-12-31 12:24:34 +08:00
|
|
|
// Compute the edit distance between the two given strings.
|
2010-11-26 12:16:08 +08:00
|
|
|
unsigned StringRef::edit_distance(llvm::StringRef Other,
|
2010-10-20 06:13:48 +08:00
|
|
|
bool AllowReplacements,
|
2013-08-24 09:50:41 +08:00
|
|
|
unsigned MaxEditDistance) const {
|
2012-02-16 06:13:07 +08:00
|
|
|
return llvm::ComputeEditDistance(
|
2014-08-27 13:25:25 +08:00
|
|
|
makeArrayRef(data(), size()),
|
|
|
|
makeArrayRef(Other.data(), Other.size()),
|
2012-02-16 06:13:07 +08:00
|
|
|
AllowReplacements, MaxEditDistance);
|
2009-12-31 01:23:44 +08:00
|
|
|
}
|
|
|
|
|
2011-11-07 02:04:43 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// String Operations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
std::string StringRef::lower() const {
|
|
|
|
std::string Result(size(), char());
|
|
|
|
for (size_type i = 0, e = size(); i != e; ++i) {
|
2017-11-28 22:22:27 +08:00
|
|
|
Result[i] = toLower(Data[i]);
|
2011-11-07 02:04:43 +08:00
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string StringRef::upper() const {
|
|
|
|
std::string Result(size(), char());
|
|
|
|
for (size_type i = 0, e = size(); i != e; ++i) {
|
2017-11-28 22:22:27 +08:00
|
|
|
Result[i] = toUpper(Data[i]);
|
2011-11-07 02:04:43 +08:00
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2009-09-20 09:22:16 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// String Searching
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
|
|
|
/// find - Search for the first string \arg Str in the string.
|
|
|
|
///
|
2011-04-15 13:18:47 +08:00
|
|
|
/// \return - The index of the first occurrence of \arg Str, or npos if not
|
2009-09-20 09:22:16 +08:00
|
|
|
/// found.
|
2009-11-11 08:28:53 +08:00
|
|
|
size_t StringRef::find(StringRef Str, size_t From) const {
|
2015-09-10 19:17:49 +08:00
|
|
|
if (From > Length)
|
|
|
|
return npos;
|
|
|
|
|
Tweak the core loop in StringRef::find to avoid calling memcmp on every
iteration.
Instead, load the byte at the needle length, compare it directly, and
save it to use in the lookup table of lengths we can skip forward.
I also added an annotation to expect that the comparison fails so that
the loop gets laid out contiguously without the call to memcpy (and the
substantial register shuffling that the ABI requires of that call).
Finally, because this behaves especially badly with a needle length of
one (by calling memcmp with a zero length) special case that to directly
call memchr, which is what we should have been doing anyways.
This was motivated by the fact that there are a large number of test
cases in 'check-llvm' where FileCheck's performance is dominated by
calls to StringRef::find (in a release, no-asserts build). I'm working
on patches to generally improve matters there, but this alone was worth
a 12.5% improvement in one test case where FileCheck spent 92% of its
time in this routine.
I experimented a bunch with different minor variations on this theme,
for example setting the pointer *at* the last byte and indexing
backwards for the call to memcmp. That didn't improve anything on this
version and seemed more complex. I also tried other things to make the
loop flow more nicely and none worked. =/ It is a bit unfortunate, the
generated code here remains pretty gross, but I don't see any obvious
ways to improve it. At this point, most of my ideas would be really
elaborate:
1) While the remainder of the string is long enough, we could load
a 16-byte or 32-byte vector at the address of the last byte and use
palignr to rotate that and check the first 15- or 31-bytes at the
front of the next segment, essentially pre-loading the first several
bytes of the next iteration so we could quickly detect a mismatch in
those bytes without an additional memory access. Down side would be
the code complexity, having a fallback loop, and likely misaligned
vector load. Plus it would make the common case of the last byte not
matching somewhat slower (need some extraction from a vector).
2) While we have space, we could do an aligned load of a 16- or 32-byte
vector that *contains* the end byte, and use any peceding bytes to
have a more precise "no" test, and any subsequent bytes could be
saved for the next iteration. This remove any unaligned load penalty,
but still requires us to pay the overhead of vector extraction for
the cases where we didn't need to do anything other than load and
compare the last byte.
3) Try to walk from the last byte in a way that is more friendly to
cache and/or memory pre-fetcher considering we have to poke the last
byte anyways.
No idea if any of these are really worth pursuing though. They all seem
somewhat unlikely to yield big wins in practice and to be a lot of work
and complexity. So I settled here, which at least seems like a strict
improvement over the previous version.
llvm-svn: 289373
2016-12-11 15:46:21 +08:00
|
|
|
const char *Start = Data + From;
|
|
|
|
size_t Size = Length - From;
|
|
|
|
|
2015-09-10 19:17:49 +08:00
|
|
|
const char *Needle = Str.data();
|
2009-09-20 09:22:16 +08:00
|
|
|
size_t N = Str.size();
|
2015-09-10 19:17:49 +08:00
|
|
|
if (N == 0)
|
|
|
|
return From;
|
|
|
|
if (Size < N)
|
2009-09-20 09:22:16 +08:00
|
|
|
return npos;
|
Tweak the core loop in StringRef::find to avoid calling memcmp on every
iteration.
Instead, load the byte at the needle length, compare it directly, and
save it to use in the lookup table of lengths we can skip forward.
I also added an annotation to expect that the comparison fails so that
the loop gets laid out contiguously without the call to memcpy (and the
substantial register shuffling that the ABI requires of that call).
Finally, because this behaves especially badly with a needle length of
one (by calling memcmp with a zero length) special case that to directly
call memchr, which is what we should have been doing anyways.
This was motivated by the fact that there are a large number of test
cases in 'check-llvm' where FileCheck's performance is dominated by
calls to StringRef::find (in a release, no-asserts build). I'm working
on patches to generally improve matters there, but this alone was worth
a 12.5% improvement in one test case where FileCheck spent 92% of its
time in this routine.
I experimented a bunch with different minor variations on this theme,
for example setting the pointer *at* the last byte and indexing
backwards for the call to memcmp. That didn't improve anything on this
version and seemed more complex. I also tried other things to make the
loop flow more nicely and none worked. =/ It is a bit unfortunate, the
generated code here remains pretty gross, but I don't see any obvious
ways to improve it. At this point, most of my ideas would be really
elaborate:
1) While the remainder of the string is long enough, we could load
a 16-byte or 32-byte vector at the address of the last byte and use
palignr to rotate that and check the first 15- or 31-bytes at the
front of the next segment, essentially pre-loading the first several
bytes of the next iteration so we could quickly detect a mismatch in
those bytes without an additional memory access. Down side would be
the code complexity, having a fallback loop, and likely misaligned
vector load. Plus it would make the common case of the last byte not
matching somewhat slower (need some extraction from a vector).
2) While we have space, we could do an aligned load of a 16- or 32-byte
vector that *contains* the end byte, and use any peceding bytes to
have a more precise "no" test, and any subsequent bytes could be
saved for the next iteration. This remove any unaligned load penalty,
but still requires us to pay the overhead of vector extraction for
the cases where we didn't need to do anything other than load and
compare the last byte.
3) Try to walk from the last byte in a way that is more friendly to
cache and/or memory pre-fetcher considering we have to poke the last
byte anyways.
No idea if any of these are really worth pursuing though. They all seem
somewhat unlikely to yield big wins in practice and to be a lot of work
and complexity. So I settled here, which at least seems like a strict
improvement over the previous version.
llvm-svn: 289373
2016-12-11 15:46:21 +08:00
|
|
|
if (N == 1) {
|
|
|
|
const char *Ptr = (const char *)::memchr(Start, Needle[0], Size);
|
|
|
|
return Ptr == nullptr ? npos : Ptr - Data;
|
|
|
|
}
|
2011-10-15 18:08:31 +08:00
|
|
|
|
2015-09-10 19:17:49 +08:00
|
|
|
const char *Stop = Start + (Size - N + 1);
|
|
|
|
|
2011-10-15 18:08:31 +08:00
|
|
|
// For short haystacks or unsupported needles fall back to the naive algorithm
|
2015-09-10 19:17:49 +08:00
|
|
|
if (Size < 16 || N > 255) {
|
|
|
|
do {
|
|
|
|
if (std::memcmp(Start, Needle, N) == 0)
|
|
|
|
return Start - Data;
|
|
|
|
++Start;
|
|
|
|
} while (Start < Stop);
|
2011-10-15 18:08:31 +08:00
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build the bad char heuristic table, with uint8_t to reduce cache thrashing.
|
|
|
|
uint8_t BadCharSkip[256];
|
|
|
|
std::memset(BadCharSkip, N, 256);
|
|
|
|
for (unsigned i = 0; i != N-1; ++i)
|
|
|
|
BadCharSkip[(uint8_t)Str[i]] = N-1-i;
|
|
|
|
|
2015-09-10 19:17:49 +08:00
|
|
|
do {
|
Tweak the core loop in StringRef::find to avoid calling memcmp on every
iteration.
Instead, load the byte at the needle length, compare it directly, and
save it to use in the lookup table of lengths we can skip forward.
I also added an annotation to expect that the comparison fails so that
the loop gets laid out contiguously without the call to memcpy (and the
substantial register shuffling that the ABI requires of that call).
Finally, because this behaves especially badly with a needle length of
one (by calling memcmp with a zero length) special case that to directly
call memchr, which is what we should have been doing anyways.
This was motivated by the fact that there are a large number of test
cases in 'check-llvm' where FileCheck's performance is dominated by
calls to StringRef::find (in a release, no-asserts build). I'm working
on patches to generally improve matters there, but this alone was worth
a 12.5% improvement in one test case where FileCheck spent 92% of its
time in this routine.
I experimented a bunch with different minor variations on this theme,
for example setting the pointer *at* the last byte and indexing
backwards for the call to memcmp. That didn't improve anything on this
version and seemed more complex. I also tried other things to make the
loop flow more nicely and none worked. =/ It is a bit unfortunate, the
generated code here remains pretty gross, but I don't see any obvious
ways to improve it. At this point, most of my ideas would be really
elaborate:
1) While the remainder of the string is long enough, we could load
a 16-byte or 32-byte vector at the address of the last byte and use
palignr to rotate that and check the first 15- or 31-bytes at the
front of the next segment, essentially pre-loading the first several
bytes of the next iteration so we could quickly detect a mismatch in
those bytes without an additional memory access. Down side would be
the code complexity, having a fallback loop, and likely misaligned
vector load. Plus it would make the common case of the last byte not
matching somewhat slower (need some extraction from a vector).
2) While we have space, we could do an aligned load of a 16- or 32-byte
vector that *contains* the end byte, and use any peceding bytes to
have a more precise "no" test, and any subsequent bytes could be
saved for the next iteration. This remove any unaligned load penalty,
but still requires us to pay the overhead of vector extraction for
the cases where we didn't need to do anything other than load and
compare the last byte.
3) Try to walk from the last byte in a way that is more friendly to
cache and/or memory pre-fetcher considering we have to poke the last
byte anyways.
No idea if any of these are really worth pursuing though. They all seem
somewhat unlikely to yield big wins in practice and to be a lot of work
and complexity. So I settled here, which at least seems like a strict
improvement over the previous version.
llvm-svn: 289373
2016-12-11 15:46:21 +08:00
|
|
|
uint8_t Last = Start[N - 1];
|
|
|
|
if (LLVM_UNLIKELY(Last == (uint8_t)Needle[N - 1]))
|
|
|
|
if (std::memcmp(Start, Needle, N - 1) == 0)
|
|
|
|
return Start - Data;
|
2011-10-15 18:08:31 +08:00
|
|
|
|
|
|
|
// Otherwise skip the appropriate number of bytes.
|
Tweak the core loop in StringRef::find to avoid calling memcmp on every
iteration.
Instead, load the byte at the needle length, compare it directly, and
save it to use in the lookup table of lengths we can skip forward.
I also added an annotation to expect that the comparison fails so that
the loop gets laid out contiguously without the call to memcpy (and the
substantial register shuffling that the ABI requires of that call).
Finally, because this behaves especially badly with a needle length of
one (by calling memcmp with a zero length) special case that to directly
call memchr, which is what we should have been doing anyways.
This was motivated by the fact that there are a large number of test
cases in 'check-llvm' where FileCheck's performance is dominated by
calls to StringRef::find (in a release, no-asserts build). I'm working
on patches to generally improve matters there, but this alone was worth
a 12.5% improvement in one test case where FileCheck spent 92% of its
time in this routine.
I experimented a bunch with different minor variations on this theme,
for example setting the pointer *at* the last byte and indexing
backwards for the call to memcmp. That didn't improve anything on this
version and seemed more complex. I also tried other things to make the
loop flow more nicely and none worked. =/ It is a bit unfortunate, the
generated code here remains pretty gross, but I don't see any obvious
ways to improve it. At this point, most of my ideas would be really
elaborate:
1) While the remainder of the string is long enough, we could load
a 16-byte or 32-byte vector at the address of the last byte and use
palignr to rotate that and check the first 15- or 31-bytes at the
front of the next segment, essentially pre-loading the first several
bytes of the next iteration so we could quickly detect a mismatch in
those bytes without an additional memory access. Down side would be
the code complexity, having a fallback loop, and likely misaligned
vector load. Plus it would make the common case of the last byte not
matching somewhat slower (need some extraction from a vector).
2) While we have space, we could do an aligned load of a 16- or 32-byte
vector that *contains* the end byte, and use any peceding bytes to
have a more precise "no" test, and any subsequent bytes could be
saved for the next iteration. This remove any unaligned load penalty,
but still requires us to pay the overhead of vector extraction for
the cases where we didn't need to do anything other than load and
compare the last byte.
3) Try to walk from the last byte in a way that is more friendly to
cache and/or memory pre-fetcher considering we have to poke the last
byte anyways.
No idea if any of these are really worth pursuing though. They all seem
somewhat unlikely to yield big wins in practice and to be a lot of work
and complexity. So I settled here, which at least seems like a strict
improvement over the previous version.
llvm-svn: 289373
2016-12-11 15:46:21 +08:00
|
|
|
Start += BadCharSkip[Last];
|
2015-09-10 19:17:49 +08:00
|
|
|
} while (Start < Stop);
|
2011-10-15 18:08:31 +08:00
|
|
|
|
2009-09-20 09:22:16 +08:00
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
2016-11-13 01:17:12 +08:00
|
|
|
size_t StringRef::find_lower(StringRef Str, size_t From) const {
|
|
|
|
StringRef This = substr(From);
|
|
|
|
while (This.size() >= Str.size()) {
|
|
|
|
if (This.startswith_lower(Str))
|
|
|
|
return From;
|
|
|
|
This = This.drop_front();
|
|
|
|
++From;
|
|
|
|
}
|
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t StringRef::rfind_lower(char C, size_t From) const {
|
|
|
|
From = std::min(From, Length);
|
|
|
|
size_t i = From;
|
|
|
|
while (i != 0) {
|
|
|
|
--i;
|
2017-11-28 22:22:27 +08:00
|
|
|
if (toLower(Data[i]) == toLower(C))
|
2016-11-13 01:17:12 +08:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
2009-09-20 09:22:16 +08:00
|
|
|
/// rfind - Search for the last string \arg Str in the string.
|
|
|
|
///
|
2011-04-15 13:18:47 +08:00
|
|
|
/// \return - The index of the last occurrence of \arg Str, or npos if not
|
2009-09-20 09:22:16 +08:00
|
|
|
/// found.
|
2009-11-06 18:58:06 +08:00
|
|
|
size_t StringRef::rfind(StringRef Str) const {
|
2009-09-20 09:22:16 +08:00
|
|
|
size_t N = Str.size();
|
|
|
|
if (N > Length)
|
|
|
|
return npos;
|
|
|
|
for (size_t i = Length - N + 1, e = 0; i != e;) {
|
|
|
|
--i;
|
|
|
|
if (substr(i, N).equals(Str))
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
2016-11-13 01:17:12 +08:00
|
|
|
size_t StringRef::rfind_lower(StringRef Str) const {
|
|
|
|
size_t N = Str.size();
|
|
|
|
if (N > Length)
|
|
|
|
return npos;
|
|
|
|
for (size_t i = Length - N + 1, e = 0; i != e;) {
|
|
|
|
--i;
|
|
|
|
if (substr(i, N).equals_lower(Str))
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
2009-11-11 08:28:53 +08:00
|
|
|
/// find_first_of - Find the first character in the string that is in \arg
|
|
|
|
/// Chars, or npos if not found.
|
|
|
|
///
|
2010-08-24 02:16:08 +08:00
|
|
|
/// Note: O(size() + Chars.size())
|
2009-11-11 08:28:53 +08:00
|
|
|
StringRef::size_type StringRef::find_first_of(StringRef Chars,
|
|
|
|
size_t From) const {
|
2010-08-24 02:16:08 +08:00
|
|
|
std::bitset<1 << CHAR_BIT> CharBits;
|
|
|
|
for (size_type i = 0; i != Chars.size(); ++i)
|
|
|
|
CharBits.set((unsigned char)Chars[i]);
|
|
|
|
|
2014-08-21 12:31:10 +08:00
|
|
|
for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
|
2010-08-24 02:16:08 +08:00
|
|
|
if (CharBits.test((unsigned char)Data[i]))
|
2009-09-20 09:22:16 +08:00
|
|
|
return i;
|
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// find_first_not_of - Find the first character in the string that is not
|
2009-11-11 08:28:53 +08:00
|
|
|
/// \arg C or npos if not found.
|
|
|
|
StringRef::size_type StringRef::find_first_not_of(char C, size_t From) const {
|
2014-08-21 12:31:10 +08:00
|
|
|
for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
|
2009-11-11 08:28:53 +08:00
|
|
|
if (Data[i] != C)
|
|
|
|
return i;
|
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// find_first_not_of - Find the first character in the string that is not
|
|
|
|
/// in the string \arg Chars, or npos if not found.
|
|
|
|
///
|
2010-08-24 02:16:08 +08:00
|
|
|
/// Note: O(size() + Chars.size())
|
2009-11-11 08:28:53 +08:00
|
|
|
StringRef::size_type StringRef::find_first_not_of(StringRef Chars,
|
|
|
|
size_t From) const {
|
2010-08-24 02:16:08 +08:00
|
|
|
std::bitset<1 << CHAR_BIT> CharBits;
|
|
|
|
for (size_type i = 0; i != Chars.size(); ++i)
|
|
|
|
CharBits.set((unsigned char)Chars[i]);
|
|
|
|
|
2014-08-21 12:31:10 +08:00
|
|
|
for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
|
2010-08-24 02:16:08 +08:00
|
|
|
if (!CharBits.test((unsigned char)Data[i]))
|
2009-09-20 09:22:16 +08:00
|
|
|
return i;
|
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
2010-12-01 07:27:35 +08:00
|
|
|
/// find_last_of - Find the last character in the string that is in \arg C,
|
|
|
|
/// or npos if not found.
|
|
|
|
///
|
|
|
|
/// Note: O(size() + Chars.size())
|
|
|
|
StringRef::size_type StringRef::find_last_of(StringRef Chars,
|
|
|
|
size_t From) const {
|
|
|
|
std::bitset<1 << CHAR_BIT> CharBits;
|
|
|
|
for (size_type i = 0; i != Chars.size(); ++i)
|
|
|
|
CharBits.set((unsigned char)Chars[i]);
|
|
|
|
|
2014-08-21 12:31:10 +08:00
|
|
|
for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
|
2010-12-01 07:27:35 +08:00
|
|
|
if (CharBits.test((unsigned char)Data[i]))
|
|
|
|
return i;
|
|
|
|
return npos;
|
|
|
|
}
|
2009-09-20 09:22:16 +08:00
|
|
|
|
2012-05-12 06:08:50 +08:00
|
|
|
/// find_last_not_of - Find the last character in the string that is not
|
|
|
|
/// \arg C, or npos if not found.
|
|
|
|
StringRef::size_type StringRef::find_last_not_of(char C, size_t From) const {
|
2014-08-21 12:31:10 +08:00
|
|
|
for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
|
2012-05-12 06:08:50 +08:00
|
|
|
if (Data[i] != C)
|
|
|
|
return i;
|
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// find_last_not_of - Find the last character in the string that is not in
|
|
|
|
/// \arg Chars, or npos if not found.
|
|
|
|
///
|
|
|
|
/// Note: O(size() + Chars.size())
|
|
|
|
StringRef::size_type StringRef::find_last_not_of(StringRef Chars,
|
|
|
|
size_t From) const {
|
|
|
|
std::bitset<1 << CHAR_BIT> CharBits;
|
|
|
|
for (size_type i = 0, e = Chars.size(); i != e; ++i)
|
|
|
|
CharBits.set((unsigned char)Chars[i]);
|
|
|
|
|
2014-08-21 12:31:10 +08:00
|
|
|
for (size_type i = std::min(From, Length) - 1, e = -1; i != e; --i)
|
2012-05-12 06:08:50 +08:00
|
|
|
if (!CharBits.test((unsigned char)Data[i]))
|
|
|
|
return i;
|
|
|
|
return npos;
|
|
|
|
}
|
|
|
|
|
2012-02-21 20:00:25 +08:00
|
|
|
void StringRef::split(SmallVectorImpl<StringRef> &A,
|
2015-09-10 15:51:37 +08:00
|
|
|
StringRef Separator, int MaxSplit,
|
2012-02-21 20:00:25 +08:00
|
|
|
bool KeepEmpty) const {
|
2015-09-10 15:51:37 +08:00
|
|
|
StringRef S = *this;
|
|
|
|
|
|
|
|
// Count down from MaxSplit. When MaxSplit is -1, this will just split
|
|
|
|
// "forever". This doesn't support splitting more than 2^31 times
|
|
|
|
// intentionally; if we ever want that we can make MaxSplit a 64-bit integer
|
|
|
|
// but that seems unlikely to be useful.
|
|
|
|
while (MaxSplit-- != 0) {
|
|
|
|
size_t Idx = S.find(Separator);
|
|
|
|
if (Idx == npos)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Push this split.
|
|
|
|
if (KeepEmpty || Idx > 0)
|
|
|
|
A.push_back(S.slice(0, Idx));
|
|
|
|
|
|
|
|
// Jump forward.
|
|
|
|
S = S.slice(Idx + Separator.size(), npos);
|
2012-02-21 20:00:25 +08:00
|
|
|
}
|
2015-09-10 15:51:37 +08:00
|
|
|
|
|
|
|
// Push the tail.
|
|
|
|
if (KeepEmpty || !S.empty())
|
|
|
|
A.push_back(S);
|
2015-09-10 14:07:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void StringRef::split(SmallVectorImpl<StringRef> &A, char Separator,
|
|
|
|
int MaxSplit, bool KeepEmpty) const {
|
2015-09-10 15:51:37 +08:00
|
|
|
StringRef S = *this;
|
|
|
|
|
|
|
|
// Count down from MaxSplit. When MaxSplit is -1, this will just split
|
|
|
|
// "forever". This doesn't support splitting more than 2^31 times
|
|
|
|
// intentionally; if we ever want that we can make MaxSplit a 64-bit integer
|
|
|
|
// but that seems unlikely to be useful.
|
|
|
|
while (MaxSplit-- != 0) {
|
|
|
|
size_t Idx = S.find(Separator);
|
|
|
|
if (Idx == npos)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Push this split.
|
|
|
|
if (KeepEmpty || Idx > 0)
|
|
|
|
A.push_back(S.slice(0, Idx));
|
|
|
|
|
|
|
|
// Jump forward.
|
|
|
|
S = S.slice(Idx + 1, npos);
|
2015-09-10 14:07:03 +08:00
|
|
|
}
|
2015-09-10 15:51:37 +08:00
|
|
|
|
|
|
|
// Push the tail.
|
|
|
|
if (KeepEmpty || !S.empty())
|
|
|
|
A.push_back(S);
|
2012-02-21 20:00:25 +08:00
|
|
|
}
|
|
|
|
|
2009-09-20 09:22:16 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Helpful Algorithms
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// count - Return the number of non-overlapped occurrences of \arg Str in
|
|
|
|
/// the string.
|
2009-11-06 18:58:06 +08:00
|
|
|
size_t StringRef::count(StringRef Str) const {
|
2009-09-20 09:22:16 +08:00
|
|
|
size_t Count = 0;
|
|
|
|
size_t N = Str.size();
|
|
|
|
if (N > Length)
|
|
|
|
return 0;
|
|
|
|
for (size_t i = 0, e = Length - N + 1; i != e; ++i)
|
|
|
|
if (substr(i, N).equals(Str))
|
|
|
|
++Count;
|
|
|
|
return Count;
|
|
|
|
}
|
|
|
|
|
2010-02-28 17:55:58 +08:00
|
|
|
static unsigned GetAutoSenseRadix(StringRef &Str) {
|
2016-09-22 23:55:05 +08:00
|
|
|
if (Str.empty())
|
|
|
|
return 10;
|
|
|
|
|
2016-03-19 02:22:07 +08:00
|
|
|
if (Str.startswith("0x") || Str.startswith("0X")) {
|
2010-02-28 17:55:58 +08:00
|
|
|
Str = Str.substr(2);
|
|
|
|
return 16;
|
2012-04-22 06:03:05 +08:00
|
|
|
}
|
|
|
|
|
2016-03-19 02:22:07 +08:00
|
|
|
if (Str.startswith("0b") || Str.startswith("0B")) {
|
2010-02-28 17:55:58 +08:00
|
|
|
Str = Str.substr(2);
|
|
|
|
return 2;
|
2012-04-22 06:03:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Str.startswith("0o")) {
|
|
|
|
Str = Str.substr(2);
|
2010-02-28 17:55:58 +08:00
|
|
|
return 8;
|
|
|
|
}
|
2012-04-22 06:03:05 +08:00
|
|
|
|
2017-11-28 22:22:27 +08:00
|
|
|
if (Str[0] == '0' && Str.size() > 1 && isDigit(Str[1])) {
|
2016-09-22 23:05:19 +08:00
|
|
|
Str = Str.substr(1);
|
2012-04-22 06:03:05 +08:00
|
|
|
return 8;
|
2016-09-22 23:05:19 +08:00
|
|
|
}
|
|
|
|
|
2012-04-22 06:03:05 +08:00
|
|
|
return 10;
|
2010-02-28 17:55:58 +08:00
|
|
|
}
|
|
|
|
|
2016-09-22 23:05:19 +08:00
|
|
|
bool llvm::consumeUnsignedInteger(StringRef &Str, unsigned Radix,
|
|
|
|
unsigned long long &Result) {
|
2009-09-20 03:47:14 +08:00
|
|
|
// Autosense radix if not specified.
|
2010-02-28 17:55:58 +08:00
|
|
|
if (Radix == 0)
|
|
|
|
Radix = GetAutoSenseRadix(Str);
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2009-09-20 03:47:14 +08:00
|
|
|
// Empty strings (after the radix autosense) are invalid.
|
|
|
|
if (Str.empty()) return true;
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2009-09-20 03:47:14 +08:00
|
|
|
// Parse all the bytes of the string given this radix. Watch for overflow.
|
2016-09-22 23:05:19 +08:00
|
|
|
StringRef Str2 = Str;
|
2009-09-20 03:47:14 +08:00
|
|
|
Result = 0;
|
2016-09-22 23:05:19 +08:00
|
|
|
while (!Str2.empty()) {
|
2009-09-20 03:47:14 +08:00
|
|
|
unsigned CharVal;
|
2016-09-22 23:05:19 +08:00
|
|
|
if (Str2[0] >= '0' && Str2[0] <= '9')
|
|
|
|
CharVal = Str2[0] - '0';
|
|
|
|
else if (Str2[0] >= 'a' && Str2[0] <= 'z')
|
|
|
|
CharVal = Str2[0] - 'a' + 10;
|
|
|
|
else if (Str2[0] >= 'A' && Str2[0] <= 'Z')
|
|
|
|
CharVal = Str2[0] - 'A' + 10;
|
2009-09-20 03:47:14 +08:00
|
|
|
else
|
2016-09-22 23:05:19 +08:00
|
|
|
break;
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2016-09-22 23:05:19 +08:00
|
|
|
// If the parsed value is larger than the integer radix, we cannot
|
|
|
|
// consume any more characters.
|
2009-09-20 03:47:14 +08:00
|
|
|
if (CharVal >= Radix)
|
2016-09-22 23:05:19 +08:00
|
|
|
break;
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2009-09-20 03:47:14 +08:00
|
|
|
// Add in this character.
|
|
|
|
unsigned long long PrevResult = Result;
|
2016-09-22 23:05:19 +08:00
|
|
|
Result = Result * Radix + CharVal;
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2012-10-03 04:01:48 +08:00
|
|
|
// Check for overflow by shifting back and seeing if bits were lost.
|
2016-09-22 23:05:19 +08:00
|
|
|
if (Result / Radix < PrevResult)
|
2009-09-20 03:47:14 +08:00
|
|
|
return true;
|
|
|
|
|
2016-09-22 23:05:19 +08:00
|
|
|
Str2 = Str2.substr(1);
|
2009-09-20 03:47:14 +08:00
|
|
|
}
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2016-09-22 23:05:19 +08:00
|
|
|
// We consider the operation a failure if no characters were consumed
|
|
|
|
// successfully.
|
|
|
|
if (Str.size() == Str2.size())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
Str = Str2;
|
2009-09-20 03:47:14 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-09-22 23:05:19 +08:00
|
|
|
bool llvm::consumeSignedInteger(StringRef &Str, unsigned Radix,
|
|
|
|
long long &Result) {
|
2009-09-20 07:58:48 +08:00
|
|
|
unsigned long long ULLVal;
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2009-09-20 07:58:48 +08:00
|
|
|
// Handle positive strings first.
|
2012-03-11 07:02:54 +08:00
|
|
|
if (Str.empty() || Str.front() != '-') {
|
2016-09-22 23:05:19 +08:00
|
|
|
if (consumeUnsignedInteger(Str, Radix, ULLVal) ||
|
2009-09-20 07:58:48 +08:00
|
|
|
// Check for value so large it overflows a signed value.
|
|
|
|
(long long)ULLVal < 0)
|
|
|
|
return true;
|
|
|
|
Result = ULLVal;
|
|
|
|
return false;
|
|
|
|
}
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2009-09-20 07:58:48 +08:00
|
|
|
// Get the positive part of the value.
|
2016-09-22 23:05:19 +08:00
|
|
|
StringRef Str2 = Str.drop_front(1);
|
|
|
|
if (consumeUnsignedInteger(Str2, Radix, ULLVal) ||
|
2009-09-20 07:58:48 +08:00
|
|
|
// Reject values so large they'd overflow as negative signed, but allow
|
|
|
|
// "-0". This negates the unsigned so that the negative isn't undefined
|
|
|
|
// on signed overflow.
|
|
|
|
(long long)-ULLVal > 0)
|
|
|
|
return true;
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2016-09-22 23:05:19 +08:00
|
|
|
Str = Str2;
|
2009-09-20 07:58:48 +08:00
|
|
|
Result = -ULLVal;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-09-22 23:05:19 +08:00
|
|
|
/// GetAsUnsignedInteger - Workhorse method that converts a integer character
|
|
|
|
/// sequence of radix up to 36 to an unsigned long long value.
|
|
|
|
bool llvm::getAsUnsignedInteger(StringRef Str, unsigned Radix,
|
|
|
|
unsigned long long &Result) {
|
|
|
|
if (consumeUnsignedInteger(Str, Radix, Result))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// For getAsUnsignedInteger, we require the whole string to be consumed or
|
|
|
|
// else we consider it a failure.
|
|
|
|
return !Str.empty();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool llvm::getAsSignedInteger(StringRef Str, unsigned Radix,
|
|
|
|
long long &Result) {
|
|
|
|
if (consumeSignedInteger(Str, Radix, Result))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// For getAsSignedInteger, we require the whole string to be consumed or else
|
|
|
|
// we consider it a failure.
|
|
|
|
return !Str.empty();
|
|
|
|
}
|
|
|
|
|
2010-02-28 17:55:58 +08:00
|
|
|
bool StringRef::getAsInteger(unsigned Radix, APInt &Result) const {
|
|
|
|
StringRef Str = *this;
|
|
|
|
|
|
|
|
// Autosense radix if not specified.
|
|
|
|
if (Radix == 0)
|
|
|
|
Radix = GetAutoSenseRadix(Str);
|
|
|
|
|
|
|
|
assert(Radix > 1 && Radix <= 36);
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2010-02-28 17:55:58 +08:00
|
|
|
// Empty strings (after the radix autosense) are invalid.
|
|
|
|
if (Str.empty()) return true;
|
|
|
|
|
|
|
|
// Skip leading zeroes. This can be a significant improvement if
|
|
|
|
// it means we don't need > 64 bits.
|
|
|
|
while (!Str.empty() && Str.front() == '0')
|
|
|
|
Str = Str.substr(1);
|
|
|
|
|
|
|
|
// If it was nothing but zeroes....
|
|
|
|
if (Str.empty()) {
|
|
|
|
Result = APInt(64, 0);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// (Over-)estimate the required number of bits.
|
|
|
|
unsigned Log2Radix = 0;
|
|
|
|
while ((1U << Log2Radix) < Radix) Log2Radix++;
|
|
|
|
bool IsPowerOf2Radix = ((1U << Log2Radix) == Radix);
|
|
|
|
|
|
|
|
unsigned BitWidth = Log2Radix * Str.size();
|
|
|
|
if (BitWidth < Result.getBitWidth())
|
|
|
|
BitWidth = Result.getBitWidth(); // don't shrink the result
|
2012-04-23 08:27:54 +08:00
|
|
|
else if (BitWidth > Result.getBitWidth())
|
2010-12-07 16:25:19 +08:00
|
|
|
Result = Result.zext(BitWidth);
|
2010-02-28 17:55:58 +08:00
|
|
|
|
|
|
|
APInt RadixAP, CharAP; // unused unless !IsPowerOf2Radix
|
|
|
|
if (!IsPowerOf2Radix) {
|
|
|
|
// These must have the same bit-width as Result.
|
|
|
|
RadixAP = APInt(BitWidth, Radix);
|
|
|
|
CharAP = APInt(BitWidth, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Parse all the bytes of the string given this radix.
|
|
|
|
Result = 0;
|
|
|
|
while (!Str.empty()) {
|
|
|
|
unsigned CharVal;
|
|
|
|
if (Str[0] >= '0' && Str[0] <= '9')
|
|
|
|
CharVal = Str[0]-'0';
|
|
|
|
else if (Str[0] >= 'a' && Str[0] <= 'z')
|
|
|
|
CharVal = Str[0]-'a'+10;
|
|
|
|
else if (Str[0] >= 'A' && Str[0] <= 'Z')
|
|
|
|
CharVal = Str[0]-'A'+10;
|
|
|
|
else
|
|
|
|
return true;
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2010-02-28 17:55:58 +08:00
|
|
|
// If the parsed value is larger than the integer radix, the string is
|
|
|
|
// invalid.
|
|
|
|
if (CharVal >= Radix)
|
|
|
|
return true;
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2010-02-28 17:55:58 +08:00
|
|
|
// Add in this character.
|
|
|
|
if (IsPowerOf2Radix) {
|
|
|
|
Result <<= Log2Radix;
|
|
|
|
Result |= CharVal;
|
|
|
|
} else {
|
|
|
|
Result *= RadixAP;
|
|
|
|
CharAP = CharVal;
|
|
|
|
Result += CharAP;
|
|
|
|
}
|
|
|
|
|
|
|
|
Str = Str.substr(1);
|
|
|
|
}
|
2010-11-26 12:16:08 +08:00
|
|
|
|
2010-02-28 17:55:58 +08:00
|
|
|
return false;
|
|
|
|
}
|
2012-03-04 18:55:27 +08:00
|
|
|
|
2017-02-15 03:06:37 +08:00
|
|
|
bool StringRef::getAsDouble(double &Result, bool AllowInexact) const {
|
|
|
|
APFloat F(0.0);
|
|
|
|
APFloat::opStatus Status =
|
|
|
|
F.convertFromString(*this, APFloat::rmNearestTiesToEven);
|
|
|
|
if (Status != APFloat::opOK) {
|
Fix APFloat from string conversion for Inf
The method IEEEFloat::convertFromStringSpecials() does not recognize
the "+Inf" and "-Inf" strings but these strings are printed for
the double Infinities by the IEEEFloat::toString().
This patch adds the "+Inf" and "-Inf" strings to the list of recognized
patterns in IEEEFloat::convertFromStringSpecials().
Re-landing after fix.
Reviewers: sberg, bogner, majnemer, timshen, rnk, skatkov, gottesmm, bkramer, scanon, anna
Reviewed By: anna
Subscribers: mkazantsev, FlameTop, llvm-commits, reames, apilipenko
Differential Revision: https://reviews.llvm.org/D38030
llvm-svn: 321054
2017-12-19 12:27:39 +08:00
|
|
|
if (!AllowInexact || !(Status & APFloat::opInexact))
|
2017-02-15 03:06:37 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
Result = F.convertToDouble();
|
|
|
|
return false;
|
|
|
|
}
|
2012-03-04 18:55:27 +08:00
|
|
|
|
|
|
|
// Implementation of StringRef hashing.
|
|
|
|
hash_code llvm::hash_value(StringRef S) {
|
|
|
|
return hash_combine_range(S.begin(), S.end());
|
|
|
|
}
|