LCOV - code coverage report
Current view: top level - include/llvm/ADT - StringRef.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 134 134 100.0 %
Date: 2017-09-14 15:23:50 Functions: 20 21 95.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13