1 //===- StringRef.h - Constant String Reference Wrapper ----------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLVM_ADT_STRINGREF_H 10 #define LLVM_ADT_STRINGREF_H 11 12 #include "llvm/ADT/DenseMapInfo.h" 13 #include "llvm/ADT/STLFunctionalExtras.h" 14 #include "llvm/ADT/iterator_range.h" 15 #include "llvm/Support/Compiler.h" 16 #include <algorithm> 17 #include <cassert> 18 #include <cstddef> 19 #include <cstring> 20 #include <limits> 21 #include <string> 22 #include <string_view> 23 #include <type_traits> 24 #include <utility> 25 26 namespace llvm { 27 28 class APInt; 29 class hash_code; 30 template <typename T> class SmallVectorImpl; 31 class StringRef; 32 33 /// Helper functions for StringRef::getAsInteger. 34 bool getAsUnsignedInteger(StringRef Str, unsigned Radix, 35 unsigned long long &Result); 36 37 bool getAsSignedInteger(StringRef Str, unsigned Radix, long long &Result); 38 39 bool consumeUnsignedInteger(StringRef &Str, unsigned Radix, 40 unsigned long long &Result); 41 bool consumeSignedInteger(StringRef &Str, unsigned Radix, long long &Result); 42 43 /// StringRef - Represent a constant reference to a string, i.e. a character 44 /// array and a length, which need not be null terminated. 45 /// 46 /// This class does not own the string data, it is expected to be used in 47 /// situations where the character data resides in some other buffer, whose 48 /// lifetime extends past that of the StringRef. For this reason, it is not in 49 /// general safe to store a StringRef. 50 class LLVM_GSL_POINTER StringRef { 51 public: 52 static constexpr size_t npos = ~size_t(0); 53 54 using iterator = const char *; 55 using const_iterator = const char *; 56 using size_type = size_t; 57 58 private: 59 /// The start of the string, in an external buffer. 60 const char *Data = nullptr; 61 62 /// The length of the string. 63 size_t Length = 0; 64 65 // Workaround memcmp issue with null pointers (undefined behavior) 66 // by providing a specialized version 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); 70 } 71 72 public: 73 /// @name Constructors 74 /// @{ 75 76 /// Construct an empty string ref. 77 /*implicit*/ StringRef() = default; 78 79 /// Disable conversion from nullptr. This prevents things like 80 /// if (S == nullptr) 81 StringRef(std::nullptr_t) = delete; 82 83 /// Construct a string ref from a cstring. 84 /*implicit*/ constexpr StringRef(const char *Str) 85 : Data(Str), Length(Str ? 86 // GCC 7 doesn't have constexpr char_traits. Fall back to __builtin_strlen. 87 #if defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE < 8 88 __builtin_strlen(Str) 89 #else 90 std::char_traits<char>::length(Str) 91 #endif 92 : 0) { 93 } 94 95 /// Construct a string ref from a pointer and length. 96 /*implicit*/ constexpr StringRef(const char *data, size_t length) 97 : Data(data), Length(length) {} 98 99 /// Construct a string ref from an std::string. 100 /*implicit*/ StringRef(const std::string &Str) 101 : Data(Str.data()), Length(Str.length()) {} 102 103 /// Construct a string ref from an std::string_view. 104 /*implicit*/ constexpr StringRef(std::string_view Str) 105 : Data(Str.data()), Length(Str.size()) {} 106 107 /// @} 108 /// @name Iterators 109 /// @{ 110 111 iterator begin() const { return Data; } 112 113 iterator end() const { return Data + Length; } 114 115 const unsigned char *bytes_begin() const { 116 return reinterpret_cast<const unsigned char *>(begin()); 117 } 118 const unsigned char *bytes_end() const { 119 return reinterpret_cast<const unsigned char *>(end()); 120 } 121 iterator_range<const unsigned char *> bytes() const { 122 return make_range(bytes_begin(), bytes_end()); 123 } 124 125 /// @} 126 /// @name String Operations 127 /// @{ 128 129 /// data - Get a pointer to the start of the string (which may not be null 130 /// terminated). 131 [[nodiscard]] const char *data() const { return Data; } 132 133 /// empty - Check if the string is empty. 134 [[nodiscard]] constexpr bool empty() const { return Length == 0; } 135 136 /// size - Get the string size. 137 [[nodiscard]] constexpr size_t size() const { return Length; } 138 139 /// front - Get the first character in the string. 140 [[nodiscard]] char front() const { 141 assert(!empty()); 142 return Data[0]; 143 } 144 145 /// back - Get the last character in the string. 146 [[nodiscard]] char back() const { 147 assert(!empty()); 148 return Data[Length-1]; 149 } 150 151 // copy - Allocate copy in Allocator and return StringRef to it. 152 template <typename Allocator> 153 [[nodiscard]] StringRef copy(Allocator &A) const { 154 // Don't request a length 0 copy from the allocator. 155 if (empty()) 156 return StringRef(); 157 char *S = A.template Allocate<char>(Length); 158 std::copy(begin(), end(), S); 159 return StringRef(S, Length); 160 } 161 162 /// equals - Check for string equality, this is more efficient than 163 /// compare() when the relative ordering of inequal strings isn't needed. 164 [[nodiscard]] bool equals(StringRef RHS) const { 165 return (Length == RHS.Length && 166 compareMemory(Data, RHS.Data, RHS.Length) == 0); 167 } 168 169 /// Check for string equality, ignoring case. 170 [[nodiscard]] bool equals_insensitive(StringRef RHS) const { 171 return Length == RHS.Length && compare_insensitive(RHS) == 0; 172 } 173 174 /// compare - Compare two strings; the result is negative, zero, or positive 175 /// if this string is lexicographically less than, equal to, or greater than 176 /// the \p RHS. 177 [[nodiscard]] int compare(StringRef RHS) const { 178 // Check the prefix for a mismatch. 179 if (int Res = compareMemory(Data, RHS.Data, std::min(Length, RHS.Length))) 180 return Res < 0 ? -1 : 1; 181 182 // Otherwise the prefixes match, so we only need to check the lengths. 183 if (Length == RHS.Length) 184 return 0; 185 return Length < RHS.Length ? -1 : 1; 186 } 187 188 /// Compare two strings, ignoring case. 189 [[nodiscard]] int compare_insensitive(StringRef RHS) const; 190 191 /// compare_numeric - Compare two strings, treating sequences of digits as 192 /// numbers. 193 [[nodiscard]] int compare_numeric(StringRef RHS) const; 194 195 /// Determine the edit distance between this string and another 196 /// string. 197 /// 198 /// \param Other the string to compare this string against. 199 /// 200 /// \param AllowReplacements whether to allow character 201 /// replacements (change one character into another) as a single 202 /// operation, rather than as two operations (an insertion and a 203 /// removal). 204 /// 205 /// \param MaxEditDistance If non-zero, the maximum edit distance that 206 /// this routine is allowed to compute. If the edit distance will exceed 207 /// that maximum, returns \c MaxEditDistance+1. 208 /// 209 /// \returns the minimum number of character insertions, removals, 210 /// or (if \p AllowReplacements is \c true) replacements needed to 211 /// transform one of the given strings into the other. If zero, 212 /// the strings are identical. 213 [[nodiscard]] unsigned edit_distance(StringRef Other, 214 bool AllowReplacements = true, 215 unsigned MaxEditDistance = 0) const; 216 217 [[nodiscard]] unsigned 218 edit_distance_insensitive(StringRef Other, bool AllowReplacements = true, 219 unsigned MaxEditDistance = 0) const; 220 221 /// str - Get the contents as an std::string. 222 [[nodiscard]] std::string str() const { 223 if (!Data) return std::string(); 224 return std::string(Data, Length); 225 } 226 227 /// @} 228 /// @name Operator Overloads 229 /// @{ 230 231 [[nodiscard]] char operator[](size_t Index) const { 232 assert(Index < Length && "Invalid index!"); 233 return Data[Index]; 234 } 235 236 /// Disallow accidental assignment from a temporary std::string. 237 /// 238 /// The declaration here is extra complicated so that `stringRef = {}` 239 /// and `stringRef = "abc"` continue to select the move assignment operator. 240 template <typename T> 241 std::enable_if_t<std::is_same<T, std::string>::value, StringRef> & 242 operator=(T &&Str) = delete; 243 244 /// @} 245 /// @name Type Conversions 246 /// @{ 247 248 operator std::string_view() const { 249 return std::string_view(data(), size()); 250 } 251 252 /// @} 253 /// @name String Predicates 254 /// @{ 255 256 /// Check if this string starts with the given \p Prefix. 257 [[nodiscard]] bool starts_with(StringRef Prefix) const { 258 return Length >= Prefix.Length && 259 compareMemory(Data, Prefix.Data, Prefix.Length) == 0; 260 } 261 [[nodiscard]] bool startswith(StringRef Prefix) const { 262 return starts_with(Prefix); 263 } 264 265 /// Check if this string starts with the given \p Prefix, ignoring case. 266 [[nodiscard]] bool starts_with_insensitive(StringRef Prefix) const; 267 [[nodiscard]] LLVM_DEPRECATED( 268 "Use starts_with_insensitive instead", 269 "starts_with_insensitive") bool startswith_insensitive(StringRef Prefix) 270 const { 271 return starts_with_insensitive(Prefix); 272 } 273 274 /// Check if this string ends with the given \p Suffix. 275 [[nodiscard]] bool ends_with(StringRef Suffix) const { 276 return Length >= Suffix.Length && 277 compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) == 278 0; 279 } 280 [[nodiscard]] bool endswith(StringRef Suffix) const { 281 return ends_with(Suffix); 282 } 283 284 /// Check if this string ends with the given \p Suffix, ignoring case. 285 [[nodiscard]] bool ends_with_insensitive(StringRef Suffix) const; 286 [[nodiscard]] LLVM_DEPRECATED( 287 "Use ends_with_insensitive instead", 288 "ends_with_insensitive") bool endswith_insensitive(StringRef Suffix) 289 const { 290 return ends_with_insensitive(Suffix); 291 } 292 293 /// @} 294 /// @name String Searching 295 /// @{ 296 297 /// Search for the first character \p C in the string. 298 /// 299 /// \returns The index of the first occurrence of \p C, or npos if not 300 /// found. 301 [[nodiscard]] size_t find(char C, size_t From = 0) const { 302 return std::string_view(*this).find(C, From); 303 } 304 305 /// Search for the first character \p C in the string, ignoring case. 306 /// 307 /// \returns The index of the first occurrence of \p C, or npos if not 308 /// found. 309 [[nodiscard]] size_t find_insensitive(char C, size_t From = 0) const; 310 311 /// Search for the first character satisfying the predicate \p F 312 /// 313 /// \returns The index of the first character satisfying \p F starting from 314 /// \p From, or npos if not found. 315 [[nodiscard]] size_t find_if(function_ref<bool(char)> F, 316 size_t From = 0) const { 317 StringRef S = drop_front(From); 318 while (!S.empty()) { 319 if (F(S.front())) 320 return size() - S.size(); 321 S = S.drop_front(); 322 } 323 return npos; 324 } 325 326 /// Search for the first character not satisfying the predicate \p F 327 /// 328 /// \returns The index of the first character not satisfying \p F starting 329 /// from \p From, or npos if not found. 330 [[nodiscard]] size_t find_if_not(function_ref<bool(char)> F, 331 size_t From = 0) const { 332 return find_if([F](char c) { return !F(c); }, From); 333 } 334 335 /// Search for the first string \p Str in the string. 336 /// 337 /// \returns The index of the first occurrence of \p Str, or npos if not 338 /// found. 339 [[nodiscard]] size_t find(StringRef Str, size_t From = 0) const; 340 341 /// Search for the first string \p Str in the string, ignoring case. 342 /// 343 /// \returns The index of the first occurrence of \p Str, or npos if not 344 /// found. 345 [[nodiscard]] size_t find_insensitive(StringRef Str, size_t From = 0) const; 346 347 /// Search for the last character \p C in the string. 348 /// 349 /// \returns The index of the last occurrence of \p C, or npos if not 350 /// found. 351 [[nodiscard]] size_t rfind(char C, size_t From = npos) const { 352 size_t I = std::min(From, Length); 353 while (I) { 354 --I; 355 if (Data[I] == C) 356 return I; 357 } 358 return npos; 359 } 360 361 /// Search for the last character \p C in the string, ignoring case. 362 /// 363 /// \returns The index of the last occurrence of \p C, or npos if not 364 /// found. 365 [[nodiscard]] size_t rfind_insensitive(char C, size_t From = npos) const; 366 367 /// Search for the last string \p Str in the string. 368 /// 369 /// \returns The index of the last occurrence of \p Str, or npos if not 370 /// found. 371 [[nodiscard]] size_t rfind(StringRef Str) const; 372 373 /// Search for the last string \p Str in the string, ignoring case. 374 /// 375 /// \returns The index of the last occurrence of \p Str, or npos if not 376 /// found. 377 [[nodiscard]] size_t rfind_insensitive(StringRef Str) const; 378 379 /// Find the first character in the string that is \p C, or npos if not 380 /// found. Same as find. 381 [[nodiscard]] size_t find_first_of(char C, size_t From = 0) const { 382 return find(C, From); 383 } 384 385 /// Find the first character in the string that is in \p Chars, or npos if 386 /// not found. 387 /// 388 /// Complexity: O(size() + Chars.size()) 389 [[nodiscard]] size_t find_first_of(StringRef Chars, size_t From = 0) const; 390 391 /// Find the first character in the string that is not \p C or npos if not 392 /// found. 393 [[nodiscard]] size_t find_first_not_of(char C, size_t From = 0) const; 394 395 /// Find the first character in the string that is not in the string 396 /// \p Chars, or npos if not found. 397 /// 398 /// Complexity: O(size() + Chars.size()) 399 [[nodiscard]] size_t find_first_not_of(StringRef Chars, 400 size_t From = 0) const; 401 402 /// Find the last character in the string that is \p C, or npos if not 403 /// found. 404 [[nodiscard]] size_t find_last_of(char C, size_t From = npos) const { 405 return rfind(C, From); 406 } 407 408 /// Find the last character in the string that is in \p C, or npos if not 409 /// found. 410 /// 411 /// Complexity: O(size() + Chars.size()) 412 [[nodiscard]] size_t find_last_of(StringRef Chars, 413 size_t From = npos) const; 414 415 /// Find the last character in the string that is not \p C, or npos if not 416 /// found. 417 [[nodiscard]] size_t find_last_not_of(char C, size_t From = npos) const; 418 419 /// Find the last character in the string that is not in \p Chars, or 420 /// npos if not found. 421 /// 422 /// Complexity: O(size() + Chars.size()) 423 [[nodiscard]] size_t find_last_not_of(StringRef Chars, 424 size_t From = npos) const; 425 426 /// Return true if the given string is a substring of *this, and false 427 /// otherwise. 428 [[nodiscard]] bool contains(StringRef Other) const { 429 return find(Other) != npos; 430 } 431 432 /// Return true if the given character is contained in *this, and false 433 /// otherwise. 434 [[nodiscard]] bool contains(char C) const { 435 return find_first_of(C) != npos; 436 } 437 438 /// Return true if the given string is a substring of *this, and false 439 /// otherwise. 440 [[nodiscard]] bool contains_insensitive(StringRef Other) const { 441 return find_insensitive(Other) != npos; 442 } 443 444 /// Return true if the given character is contained in *this, and false 445 /// otherwise. 446 [[nodiscard]] bool contains_insensitive(char C) const { 447 return find_insensitive(C) != npos; 448 } 449 450 /// @} 451 /// @name Helpful Algorithms 452 /// @{ 453 454 /// Return the number of occurrences of \p C in the string. 455 [[nodiscard]] size_t count(char C) const { 456 size_t Count = 0; 457 for (size_t I = 0; I != Length; ++I) 458 if (Data[I] == C) 459 ++Count; 460 return Count; 461 } 462 463 /// Return the number of non-overlapped occurrences of \p Str in 464 /// the string. 465 size_t count(StringRef Str) const; 466 467 /// Parse the current string as an integer of the specified radix. If 468 /// \p Radix is specified as zero, this does radix autosensing using 469 /// extended C rules: 0 is octal, 0x is hex, 0b is binary. 470 /// 471 /// If the string is invalid or if only a subset of the string is valid, 472 /// this returns true to signify the error. The string is considered 473 /// erroneous if empty or if it overflows T. 474 template <typename T> bool getAsInteger(unsigned Radix, T &Result) const { 475 if constexpr (std::numeric_limits<T>::is_signed) { 476 long long LLVal; 477 if (getAsSignedInteger(*this, Radix, LLVal) || 478 static_cast<T>(LLVal) != LLVal) 479 return true; 480 Result = LLVal; 481 } else { 482 unsigned long long ULLVal; 483 // The additional cast to unsigned long long is required to avoid the 484 // Visual C++ warning C4805: '!=' : unsafe mix of type 'bool' and type 485 // 'unsigned __int64' when instantiating getAsInteger with T = bool. 486 if (getAsUnsignedInteger(*this, Radix, ULLVal) || 487 static_cast<unsigned long long>(static_cast<T>(ULLVal)) != ULLVal) 488 return true; 489 Result = ULLVal; 490 } 491 return false; 492 } 493 494 /// Parse the current string as an integer of the specified radix. If 495 /// \p Radix is specified as zero, this does radix autosensing using 496 /// extended C rules: 0 is octal, 0x is hex, 0b is binary. 497 /// 498 /// If the string does not begin with a number of the specified radix, 499 /// this returns true to signify the error. The string is considered 500 /// erroneous if empty or if it overflows T. 501 /// The portion of the string representing the discovered numeric value 502 /// is removed from the beginning of the string. 503 template <typename T> bool consumeInteger(unsigned Radix, T &Result) { 504 if constexpr (std::numeric_limits<T>::is_signed) { 505 long long LLVal; 506 if (consumeSignedInteger(*this, Radix, LLVal) || 507 static_cast<long long>(static_cast<T>(LLVal)) != LLVal) 508 return true; 509 Result = LLVal; 510 } else { 511 unsigned long long ULLVal; 512 if (consumeUnsignedInteger(*this, Radix, ULLVal) || 513 static_cast<unsigned long long>(static_cast<T>(ULLVal)) != ULLVal) 514 return true; 515 Result = ULLVal; 516 } 517 return false; 518 } 519 520 /// Parse the current string as an integer of the specified \p Radix, or of 521 /// an autosensed radix if the \p Radix given is 0. The current value in 522 /// \p Result is discarded, and the storage is changed to be wide enough to 523 /// store the parsed integer. 524 /// 525 /// \returns true if the string does not solely consist of a valid 526 /// non-empty number in the appropriate base. 527 /// 528 /// APInt::fromString is superficially similar but assumes the 529 /// string is well-formed in the given radix. 530 bool getAsInteger(unsigned Radix, APInt &Result) const; 531 532 /// Parse the current string as an integer of the specified \p Radix. If 533 /// \p Radix is specified as zero, this does radix autosensing using 534 /// extended C rules: 0 is octal, 0x is hex, 0b is binary. 535 /// 536 /// If the string does not begin with a number of the specified radix, 537 /// this returns true to signify the error. The string is considered 538 /// erroneous if empty. 539 /// The portion of the string representing the discovered numeric value 540 /// is removed from the beginning of the string. 541 bool consumeInteger(unsigned Radix, APInt &Result); 542 543 /// Parse the current string as an IEEE double-precision floating 544 /// point value. The string must be a well-formed double. 545 /// 546 /// If \p AllowInexact is false, the function will fail if the string 547 /// cannot be represented exactly. Otherwise, the function only fails 548 /// in case of an overflow or underflow, or an invalid floating point 549 /// representation. 550 bool getAsDouble(double &Result, bool AllowInexact = true) const; 551 552 /// @} 553 /// @name String Operations 554 /// @{ 555 556 // Convert the given ASCII string to lowercase. 557 [[nodiscard]] std::string lower() const; 558 559 /// Convert the given ASCII string to uppercase. 560 [[nodiscard]] std::string upper() const; 561 562 /// @} 563 /// @name Substring Operations 564 /// @{ 565 566 /// Return a reference to the substring from [Start, Start + N). 567 /// 568 /// \param Start The index of the starting character in the substring; if 569 /// the index is npos or greater than the length of the string then the 570 /// empty substring will be returned. 571 /// 572 /// \param N The number of characters to included in the substring. If N 573 /// exceeds the number of characters remaining in the string, the string 574 /// suffix (starting with \p Start) will be returned. 575 [[nodiscard]] constexpr StringRef substr(size_t Start, 576 size_t N = npos) const { 577 Start = std::min(Start, Length); 578 return StringRef(Data + Start, std::min(N, Length - Start)); 579 } 580 581 /// Return a StringRef equal to 'this' but with only the first \p N 582 /// elements remaining. If \p N is greater than the length of the 583 /// string, the entire string is returned. 584 [[nodiscard]] StringRef take_front(size_t N = 1) const { 585 if (N >= size()) 586 return *this; 587 return drop_back(size() - N); 588 } 589 590 /// Return a StringRef equal to 'this' but with only the last \p N 591 /// elements remaining. If \p N is greater than the length of the 592 /// string, the entire string is returned. 593 [[nodiscard]] StringRef take_back(size_t N = 1) const { 594 if (N >= size()) 595 return *this; 596 return drop_front(size() - N); 597 } 598 599 /// Return the longest prefix of 'this' such that every character 600 /// in the prefix satisfies the given predicate. 601 [[nodiscard]] StringRef take_while(function_ref<bool(char)> F) const { 602 return substr(0, find_if_not(F)); 603 } 604 605 /// Return the longest prefix of 'this' such that no character in 606 /// the prefix satisfies the given predicate. 607 [[nodiscard]] StringRef take_until(function_ref<bool(char)> F) const { 608 return substr(0, find_if(F)); 609 } 610 611 /// Return a StringRef equal to 'this' but with the first \p N elements 612 /// dropped. 613 [[nodiscard]] StringRef drop_front(size_t N = 1) const { 614 assert(size() >= N && "Dropping more elements than exist"); 615 return substr(N); 616 } 617 618 /// Return a StringRef equal to 'this' but with the last \p N elements 619 /// dropped. 620 [[nodiscard]] StringRef drop_back(size_t N = 1) const { 621 assert(size() >= N && "Dropping more elements than exist"); 622 return substr(0, size()-N); 623 } 624 625 /// Return a StringRef equal to 'this', but with all characters satisfying 626 /// the given predicate dropped from the beginning of the string. 627 [[nodiscard]] StringRef drop_while(function_ref<bool(char)> F) const { 628 return substr(find_if_not(F)); 629 } 630 631 /// Return a StringRef equal to 'this', but with all characters not 632 /// satisfying the given predicate dropped from the beginning of the string. 633 [[nodiscard]] StringRef drop_until(function_ref<bool(char)> F) const { 634 return substr(find_if(F)); 635 } 636 637 /// Returns true if this StringRef has the given prefix and removes that 638 /// prefix. 639 bool consume_front(StringRef Prefix) { 640 if (!starts_with(Prefix)) 641 return false; 642 643 *this = substr(Prefix.size()); 644 return true; 645 } 646 647 /// Returns true if this StringRef has the given prefix, ignoring case, 648 /// and removes that prefix. 649 bool consume_front_insensitive(StringRef Prefix) { 650 if (!starts_with_insensitive(Prefix)) 651 return false; 652 653 *this = substr(Prefix.size()); 654 return true; 655 } 656 657 /// Returns true if this StringRef has the given suffix and removes that 658 /// suffix. 659 bool consume_back(StringRef Suffix) { 660 if (!ends_with(Suffix)) 661 return false; 662 663 *this = substr(0, size() - Suffix.size()); 664 return true; 665 } 666 667 /// Returns true if this StringRef has the given suffix, ignoring case, 668 /// and removes that suffix. 669 bool consume_back_insensitive(StringRef Suffix) { 670 if (!ends_with_insensitive(Suffix)) 671 return false; 672 673 *this = substr(0, size() - Suffix.size()); 674 return true; 675 } 676 677 /// Return a reference to the substring from [Start, End). 678 /// 679 /// \param Start The index of the starting character in the substring; if 680 /// the index is npos or greater than the length of the string then the 681 /// empty substring will be returned. 682 /// 683 /// \param End The index following the last character to include in the 684 /// substring. If this is npos or exceeds the number of characters 685 /// remaining in the string, the string suffix (starting with \p Start) 686 /// will be returned. If this is less than \p Start, an empty string will 687 /// be returned. 688 [[nodiscard]] StringRef slice(size_t Start, size_t End) const { 689 Start = std::min(Start, Length); 690 End = std::clamp(End, Start, Length); 691 return StringRef(Data + Start, End - Start); 692 } 693 694 /// Split into two substrings around the first occurrence of a separator 695 /// character. 696 /// 697 /// If \p Separator is in the string, then the result is a pair (LHS, RHS) 698 /// such that (*this == LHS + Separator + RHS) is true and RHS is 699 /// maximal. If \p Separator is not in the string, then the result is a 700 /// pair (LHS, RHS) where (*this == LHS) and (RHS == ""). 701 /// 702 /// \param Separator The character to split on. 703 /// \returns The split substrings. 704 [[nodiscard]] std::pair<StringRef, StringRef> split(char Separator) const { 705 return split(StringRef(&Separator, 1)); 706 } 707 708 /// Split into two substrings around the first occurrence of a separator 709 /// string. 710 /// 711 /// If \p Separator is in the string, then the result is a pair (LHS, RHS) 712 /// such that (*this == LHS + Separator + RHS) is true and RHS is 713 /// maximal. If \p Separator is not in the string, then the result is a 714 /// pair (LHS, RHS) where (*this == LHS) and (RHS == ""). 715 /// 716 /// \param Separator - The string to split on. 717 /// \return - The split substrings. 718 [[nodiscard]] std::pair<StringRef, StringRef> 719 split(StringRef Separator) const { 720 size_t Idx = find(Separator); 721 if (Idx == npos) 722 return std::make_pair(*this, StringRef()); 723 return std::make_pair(slice(0, Idx), slice(Idx + Separator.size(), npos)); 724 } 725 726 /// Split into two substrings around the last occurrence of a separator 727 /// string. 728 /// 729 /// If \p Separator is in the string, then the result is a pair (LHS, RHS) 730 /// such that (*this == LHS + Separator + RHS) is true and RHS is 731 /// minimal. If \p Separator is not in the string, then the result is a 732 /// pair (LHS, RHS) where (*this == LHS) and (RHS == ""). 733 /// 734 /// \param Separator - The string to split on. 735 /// \return - The split substrings. 736 [[nodiscard]] std::pair<StringRef, StringRef> 737 rsplit(StringRef Separator) const { 738 size_t Idx = rfind(Separator); 739 if (Idx == npos) 740 return std::make_pair(*this, StringRef()); 741 return std::make_pair(slice(0, Idx), slice(Idx + Separator.size(), npos)); 742 } 743 744 /// Split into substrings around the occurrences of a separator string. 745 /// 746 /// Each substring is stored in \p A. If \p MaxSplit is >= 0, at most 747 /// \p MaxSplit splits are done and consequently <= \p MaxSplit + 1 748 /// elements are added to A. 749 /// If \p KeepEmpty is false, empty strings are not added to \p A. They 750 /// still count when considering \p MaxSplit 751 /// An useful invariant is that 752 /// Separator.join(A) == *this if MaxSplit == -1 and KeepEmpty == true 753 /// 754 /// \param A - Where to put the substrings. 755 /// \param Separator - The string to split on. 756 /// \param MaxSplit - The maximum number of times the string is split. 757 /// \param KeepEmpty - True if empty substring should be added. 758 void split(SmallVectorImpl<StringRef> &A, 759 StringRef Separator, int MaxSplit = -1, 760 bool KeepEmpty = true) const; 761 762 /// Split into substrings around the occurrences of a separator character. 763 /// 764 /// Each substring is stored in \p A. If \p MaxSplit is >= 0, at most 765 /// \p MaxSplit splits are done and consequently <= \p MaxSplit + 1 766 /// elements are added to A. 767 /// If \p KeepEmpty is false, empty strings are not added to \p A. They 768 /// still count when considering \p MaxSplit 769 /// An useful invariant is that 770 /// Separator.join(A) == *this if MaxSplit == -1 and KeepEmpty == true 771 /// 772 /// \param A - Where to put the substrings. 773 /// \param Separator - The string to split on. 774 /// \param MaxSplit - The maximum number of times the string is split. 775 /// \param KeepEmpty - True if empty substring should be added. 776 void split(SmallVectorImpl<StringRef> &A, char Separator, int MaxSplit = -1, 777 bool KeepEmpty = true) const; 778 779 /// Split into two substrings around the last occurrence of a separator 780 /// character. 781 /// 782 /// If \p Separator is in the string, then the result is a pair (LHS, RHS) 783 /// such that (*this == LHS + Separator + RHS) is true and RHS is 784 /// minimal. If \p Separator is not in the string, then the result is a 785 /// pair (LHS, RHS) where (*this == LHS) and (RHS == ""). 786 /// 787 /// \param Separator - The character to split on. 788 /// \return - The split substrings. 789 [[nodiscard]] std::pair<StringRef, StringRef> rsplit(char Separator) const { 790 return rsplit(StringRef(&Separator, 1)); 791 } 792 793 /// Return string with consecutive \p Char characters starting from the 794 /// the left removed. 795 [[nodiscard]] StringRef ltrim(char Char) const { 796 return drop_front(std::min(Length, find_first_not_of(Char))); 797 } 798 799 /// Return string with consecutive characters in \p Chars starting from 800 /// the left removed. 801 [[nodiscard]] StringRef ltrim(StringRef Chars = " \t\n\v\f\r") const { 802 return drop_front(std::min(Length, find_first_not_of(Chars))); 803 } 804 805 /// Return string with consecutive \p Char characters starting from the 806 /// right removed. 807 [[nodiscard]] StringRef rtrim(char Char) const { 808 return drop_back(Length - std::min(Length, find_last_not_of(Char) + 1)); 809 } 810 811 /// Return string with consecutive characters in \p Chars starting from 812 /// the right removed. 813 [[nodiscard]] StringRef rtrim(StringRef Chars = " \t\n\v\f\r") const { 814 return drop_back(Length - std::min(Length, find_last_not_of(Chars) + 1)); 815 } 816 817 /// Return string with consecutive \p Char characters starting from the 818 /// left and right removed. 819 [[nodiscard]] StringRef trim(char Char) const { 820 return ltrim(Char).rtrim(Char); 821 } 822 823 /// Return string with consecutive characters in \p Chars starting from 824 /// the left and right removed. 825 [[nodiscard]] StringRef trim(StringRef Chars = " \t\n\v\f\r") const { 826 return ltrim(Chars).rtrim(Chars); 827 } 828 829 /// Detect the line ending style of the string. 830 /// 831 /// If the string contains a line ending, return the line ending character 832 /// sequence that is detected. Otherwise return '\n' for unix line endings. 833 /// 834 /// \return - The line ending character sequence. 835 [[nodiscard]] StringRef detectEOL() const { 836 size_t Pos = find('\r'); 837 if (Pos == npos) { 838 // If there is no carriage return, assume unix 839 return "\n"; 840 } 841 if (Pos + 1 < Length && Data[Pos + 1] == '\n') 842 return "\r\n"; // Windows 843 if (Pos > 0 && Data[Pos - 1] == '\n') 844 return "\n\r"; // You monster! 845 return "\r"; // Classic Mac 846 } 847 /// @} 848 }; 849 850 /// A wrapper around a string literal that serves as a proxy for constructing 851 /// global tables of StringRefs with the length computed at compile time. 852 /// In order to avoid the invocation of a global constructor, StringLiteral 853 /// should *only* be used in a constexpr context, as such: 854 /// 855 /// constexpr StringLiteral S("test"); 856 /// 857 class StringLiteral : public StringRef { 858 private: 859 constexpr StringLiteral(const char *Str, size_t N) : StringRef(Str, N) { 860 } 861 862 public: 863 template <size_t N> 864 constexpr StringLiteral(const char (&Str)[N]) 865 #if defined(__clang__) && __has_attribute(enable_if) 866 #pragma clang diagnostic push 867 #pragma clang diagnostic ignored "-Wgcc-compat" 868 __attribute((enable_if(__builtin_strlen(Str) == N - 1, 869 "invalid string literal"))) 870 #pragma clang diagnostic pop 871 #endif 872 : StringRef(Str, N - 1) { 873 } 874 875 // Explicit construction for strings like "foo\0bar". 876 template <size_t N> 877 static constexpr StringLiteral withInnerNUL(const char (&Str)[N]) { 878 return StringLiteral(Str, N - 1); 879 } 880 }; 881 882 /// @name StringRef Comparison Operators 883 /// @{ 884 885 inline bool operator==(StringRef LHS, StringRef RHS) { 886 return LHS.equals(RHS); 887 } 888 889 inline bool operator!=(StringRef LHS, StringRef RHS) { return !(LHS == RHS); } 890 891 inline bool operator<(StringRef LHS, StringRef RHS) { 892 return LHS.compare(RHS) < 0; 893 } 894 895 inline bool operator<=(StringRef LHS, StringRef RHS) { 896 return LHS.compare(RHS) <= 0; 897 } 898 899 inline bool operator>(StringRef LHS, StringRef RHS) { 900 return LHS.compare(RHS) > 0; 901 } 902 903 inline bool operator>=(StringRef LHS, StringRef RHS) { 904 return LHS.compare(RHS) >= 0; 905 } 906 907 inline std::string &operator+=(std::string &buffer, StringRef string) { 908 return buffer.append(string.data(), string.size()); 909 } 910 911 /// @} 912 913 /// Compute a hash_code for a StringRef. 914 [[nodiscard]] hash_code hash_value(StringRef S); 915 916 // Provide DenseMapInfo for StringRefs. 917 template <> struct DenseMapInfo<StringRef, void> { 918 static inline StringRef getEmptyKey() { 919 return StringRef( 920 reinterpret_cast<const char *>(~static_cast<uintptr_t>(0)), 0); 921 } 922 923 static inline StringRef getTombstoneKey() { 924 return StringRef( 925 reinterpret_cast<const char *>(~static_cast<uintptr_t>(1)), 0); 926 } 927 928 static unsigned getHashValue(StringRef Val); 929 930 static bool isEqual(StringRef LHS, StringRef RHS) { 931 if (RHS.data() == getEmptyKey().data()) 932 return LHS.data() == getEmptyKey().data(); 933 if (RHS.data() == getTombstoneKey().data()) 934 return LHS.data() == getTombstoneKey().data(); 935 return LHS == RHS; 936 } 937 }; 938 939 } // end namespace llvm 940 941 #endif // LLVM_ADT_STRINGREF_H 942