Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/ADT/StringExtras.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/ADT/StringExtras.h - Useful string functions --------*- 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
// This file contains some functions that are useful when dealing with strings.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_ADT_STRINGEXTRAS_H
14
#define LLVM_ADT_STRINGEXTRAS_H
15
16
#include "llvm/ADT/ArrayRef.h"
17
#include "llvm/ADT/SmallString.h"
18
#include "llvm/ADT/StringRef.h"
19
#include "llvm/ADT/Twine.h"
20
#include <cassert>
21
#include <cstddef>
22
#include <cstdint>
23
#include <cstdlib>
24
#include <cstring>
25
#include <iterator>
26
#include <string>
27
#include <utility>
28
29
namespace llvm {
30
31
template<typename T> class SmallVectorImpl;
32
class raw_ostream;
33
34
/// hexdigit - Return the hexadecimal character for the
35
/// given number \p X (which should be less than 16).
36
49.3M
inline char hexdigit(unsigned X, bool LowerCase = false) {
37
49.3M
  const char HexChar = LowerCase ? 
'a'1.82M
:
'A'47.5M
;
38
49.3M
  return X < 10 ? 
'0' + X45.2M
:
HexChar + X - 104.08M
;
39
49.3M
}
40
41
/// Given an array of c-style strings terminated by a null pointer, construct
42
/// a vector of StringRefs representing the same strings without the terminating
43
/// null string.
44
18.1k
inline std::vector<StringRef> toStringRefArray(const char *const *Strings) {
45
18.1k
  std::vector<StringRef> Result;
46
1.38M
  while (*Strings)
47
1.36M
    Result.push_back(*Strings++);
48
18.1k
  return Result;
49
18.1k
}
50
51
/// Construct a string ref from a boolean.
52
4.56M
inline StringRef toStringRef(bool B) { return StringRef(B ? 
"true"4.13k
:
"false"4.56M
); }
53
54
/// Construct a string ref from an array ref of unsigned chars.
55
474k
inline StringRef toStringRef(ArrayRef<uint8_t> Input) {
56
474k
  return StringRef(reinterpret_cast<const char *>(Input.begin()), Input.size());
57
474k
}
58
59
/// Construct a string ref from an array ref of unsigned chars.
60
65.2k
inline ArrayRef<uint8_t> arrayRefFromStringRef(StringRef Input) {
61
65.2k
  return {Input.bytes_begin(), Input.bytes_end()};
62
65.2k
}
63
64
/// Interpret the given character \p C as a hexadecimal digit and return its
65
/// value.
66
///
67
/// If \p C is not a valid hex digit, -1U is returned.
68
15.8M
inline unsigned hexDigitValue(char C) {
69
15.8M
  if (C >= '0' && 
C <= '9'15.7M
)
return C-'0'15.2M
;
70
629k
  if (C >= 'a' && 
C <= 'f'325k
)
return C-'a'+10U324k
;
71
305k
  if (C >= 'A' && 
C <= 'F'203k
)
return C-'A'+10U200k
;
72
104k
  return -1U;
73
104k
}
74
75
/// Checks if character \p C is one of the 10 decimal digits.
76
20.9M
inline bool isDigit(char C) { return C >= '0' && 
C <= '9'15.5M
; }
77
78
/// Checks if character \p C is a hexadecimal numeric character.
79
619k
inline bool isHexDigit(char C) { return hexDigitValue(C) != -1U; }
80
81
/// Checks if character \p C is a valid letter as classified by "C" locale.
82
54.3M
inline bool isAlpha(char C) {
83
54.3M
  return ('a' <= C && 
C <= 'z'39.8M
) ||
(14.5M
'A' <= C14.5M
&&
C <= 'Z'4.52M
);
84
54.3M
}
85
86
/// Checks whether character \p C is either a decimal digit or an uppercase or
87
/// lowercase letter as classified by "C" locale.
88
54.0M
inline bool isAlnum(char C) { return isAlpha(C) || 
isDigit(C)12.5M
; }
89
90
/// Checks whether character \p C is valid ASCII (high bit is zero).
91
11.1M
inline bool isASCII(char C) { return static_cast<unsigned char>(C) <= 127; }
92
93
/// Checks whether all characters in S are ASCII.
94
1.07M
inline bool isASCII(llvm::StringRef S) {
95
1.07M
  for (char C : S)
96
11.1M
    if (LLVM_UNLIKELY(!isASCII(C)))
97
11.1M
      
return false22
;
98
1.07M
  
return true1.07M
;
99
1.07M
}
100
101
/// Checks whether character \p C is printable.
102
///
103
/// Locale-independent version of the C standard library isprint whose results
104
/// may differ on different platforms.
105
38.5M
inline bool isPrint(char C) {
106
38.5M
  unsigned char UC = static_cast<unsigned char>(C);
107
38.5M
  return (0x20 <= UC) && 
(UC <= 0x7E)28.3M
;
108
38.5M
}
109
110
/// Returns the corresponding lowercase character if \p x is uppercase.
111
351M
inline char toLower(char x) {
112
351M
  if (x >= 'A' && 
x <= 'Z'254M
)
113
154M
    return x - 'A' + 'a';
114
197M
  return x;
115
197M
}
116
117
/// Returns the corresponding uppercase character if \p x is lowercase.
118
1.64M
inline char toUpper(char x) {
119
1.64M
  if (x >= 'a' && 
x <= 'z'1.14M
)
120
1.13M
    return x - 'a' + 'A';
121
510k
  return x;
122
510k
}
123
124
33.8k
inline std::string utohexstr(uint64_t X, bool LowerCase = false) {
125
33.8k
  char Buffer[17];
126
33.8k
  char *BufPtr = std::end(Buffer);
127
33.8k
128
33.8k
  if (X == 0) 
*--BufPtr = '0'3.60k
;
129
33.8k
130
124k
  while (X) {
131
90.6k
    unsigned char Mod = static_cast<unsigned char>(X) & 15;
132
90.6k
    *--BufPtr = hexdigit(Mod, LowerCase);
133
90.6k
    X >>= 4;
134
90.6k
  }
135
33.8k
136
33.8k
  return std::string(BufPtr, std::end(Buffer));
137
33.8k
}
138
139
/// Convert buffer \p Input to its hexadecimal representation.
140
/// The returned string is double the size of \p Input.
141
556
inline std::string toHex(StringRef Input, bool LowerCase = false) {
142
556
  static const char *const LUT = "0123456789ABCDEF";
143
556
  const uint8_t Offset = LowerCase ? 
3216
:
0540
;
144
556
  size_t Length = Input.size();
145
556
146
556
  std::string Output;
147
556
  Output.reserve(2 * Length);
148
9.13k
  for (size_t i = 0; i < Length; 
++i8.58k
) {
149
8.58k
    const unsigned char c = Input[i];
150
8.58k
    Output.push_back(LUT[c >> 4] | Offset);
151
8.58k
    Output.push_back(LUT[c & 15] | Offset);
152
8.58k
  }
153
556
  return Output;
154
556
}
155
156
431
inline std::string toHex(ArrayRef<uint8_t> Input, bool LowerCase = false) {
157
431
  return toHex(toStringRef(Input), LowerCase);
158
431
}
159
160
7.05k
inline uint8_t hexFromNibbles(char MSB, char LSB) {
161
7.05k
  unsigned U1 = hexDigitValue(MSB);
162
7.05k
  unsigned U2 = hexDigitValue(LSB);
163
7.05k
  assert(U1 != -1U && U2 != -1U);
164
7.05k
165
7.05k
  return static_cast<uint8_t>((U1 << 4) | U2);
166
7.05k
}
167
168
/// Convert hexadecimal string \p Input to its binary representation.
169
/// The return string is half the size of \p Input.
170
482
inline std::string fromHex(StringRef Input) {
171
482
  if (Input.empty())
172
40
    return std::string();
173
442
174
442
  std::string Output;
175
442
  Output.reserve((Input.size() + 1) / 2);
176
442
  if (Input.size() % 2 == 1) {
177
1
    Output.push_back(hexFromNibbles('0', Input.front()));
178
1
    Input = Input.drop_front();
179
1
  }
180
442
181
442
  assert(Input.size() % 2 == 0);
182
7.49k
  while (!Input.empty()) {
183
7.04k
    uint8_t Hex = hexFromNibbles(Input[0], Input[1]);
184
7.04k
    Output.push_back(Hex);
185
7.04k
    Input = Input.drop_front(2);
186
7.04k
  }
187
442
  return Output;
188
442
}
189
190
/// Convert the string \p S to an integer of the specified type using
191
/// the radix \p Base.  If \p Base is 0, auto-detects the radix.
192
/// Returns true if the number was successfully converted, false otherwise.
193
782
template <typename N> bool to_integer(StringRef S, N &Num, unsigned Base = 0) {
194
782
  return !S.getAsInteger(Base, Num);
195
782
}
196
197
namespace detail {
198
template <typename N>
199
78.9k
inline bool to_float(const Twine &T, N &Num, N (*StrTo)(const char *, char **)) {
200
78.9k
  SmallString<32> Storage;
201
78.9k
  StringRef S = T.toNullTerminatedStringRef(Storage);
202
78.9k
  char *End;
203
78.9k
  N Temp = StrTo(S.data(), &End);
204
78.9k
  if (*End != '\0')
205
78.9k
    return false;
206
59
  Num = Temp;
207
59
  return true;
208
59
}
bool llvm::detail::to_float<float>(llvm::Twine const&, float&, float (*)(char const*, char**))
Line
Count
Source
199
11
inline bool to_float(const Twine &T, N &Num, N (*StrTo)(const char *, char **)) {
200
11
  SmallString<32> Storage;
201
11
  StringRef S = T.toNullTerminatedStringRef(Storage);
202
11
  char *End;
203
11
  N Temp = StrTo(S.data(), &End);
204
11
  if (*End != '\0')
205
3
    return false;
206
8
  Num = Temp;
207
8
  return true;
208
8
}
bool llvm::detail::to_float<double>(llvm::Twine const&, double&, double (*)(char const*, char**))
Line
Count
Source
199
78.9k
inline bool to_float(const Twine &T, N &Num, N (*StrTo)(const char *, char **)) {
200
78.9k
  SmallString<32> Storage;
201
78.9k
  StringRef S = T.toNullTerminatedStringRef(Storage);
202
78.9k
  char *End;
203
78.9k
  N Temp = StrTo(S.data(), &End);
204
78.9k
  if (*End != '\0')
205
78.9k
    return false;
206
51
  Num = Temp;
207
51
  return true;
208
51
}
209
}
210
211
11
inline bool to_float(const Twine &T, float &Num) {
212
11
  return detail::to_float(T, Num, strtof);
213
11
}
214
215
78.9k
inline bool to_float(const Twine &T, double &Num) {
216
78.9k
  return detail::to_float(T, Num, strtod);
217
78.9k
}
218
219
inline bool to_float(const Twine &T, long double &Num) {
220
  return detail::to_float(T, Num, strtold);
221
}
222
223
14.6M
inline std::string utostr(uint64_t X, bool isNeg = false) {
224
14.6M
  char Buffer[21];
225
14.6M
  char *BufPtr = std::end(Buffer);
226
14.6M
227
14.6M
  if (X == 0) 
*--BufPtr = '0'2.30M
; // Handle special case...
228
14.6M
229
44.4M
  while (X) {
230
29.7M
    *--BufPtr = '0' + char(X % 10);
231
29.7M
    X /= 10;
232
29.7M
  }
233
14.6M
234
14.6M
  if (isNeg) 
*--BufPtr = '-'130k
; // Add negative sign...
235
14.6M
  return std::string(BufPtr, std::end(Buffer));
236
14.6M
}
237
238
6.21M
inline std::string itostr(int64_t X) {
239
6.21M
  if (X < 0)
240
130k
    return utostr(static_cast<uint64_t>(-X), true);
241
6.08M
  else
242
6.08M
    return utostr(static_cast<uint64_t>(X));
243
6.21M
}
244
245
/// StrInStrNoCase - Portable version of strcasestr.  Locates the first
246
/// occurrence of string 's1' in string 's2', ignoring case.  Returns
247
/// the offset of s2 in s1 or npos if s2 cannot be found.
248
StringRef::size_type StrInStrNoCase(StringRef s1, StringRef s2);
249
250
/// getToken - This function extracts one token from source, ignoring any
251
/// leading characters that appear in the Delimiters string, and ending the
252
/// token at any of the characters that appear in the Delimiters string.  If
253
/// there are no tokens in the source string, an empty string is returned.
254
/// The function returns a pair containing the extracted token and the
255
/// remaining tail string.
256
std::pair<StringRef, StringRef> getToken(StringRef Source,
257
                                         StringRef Delimiters = " \t\n\v\f\r");
258
259
/// SplitString - Split up the specified string according to the specified
260
/// delimiters, appending the result fragments to the output list.
261
void SplitString(StringRef Source,
262
                 SmallVectorImpl<StringRef> &OutFragments,
263
                 StringRef Delimiters = " \t\n\v\f\r");
264
265
/// Returns the English suffix for an ordinal integer (-st, -nd, -rd, -th).
266
6.17k
inline StringRef getOrdinalSuffix(unsigned Val) {
267
6.17k
  // It is critically important that we do this perfectly for
268
6.17k
  // user-written sequences with over 100 elements.
269
6.17k
  switch (Val % 100) {
270
6.17k
  case 11:
271
0
  case 12:
272
0
  case 13:
273
0
    return "th";
274
6.17k
  default:
275
6.17k
    switch (Val % 10) {
276
6.17k
      
case 1: return "st"5.79k
;
277
6.17k
      
case 2: return "nd"262
;
278
6.17k
      
case 3: return "rd"102
;
279
6.17k
      
default: return "th"15
;
280
6.17k
    }
281
6.17k
  }
282
6.17k
}
283
284
/// Print each character of the specified string, escaping it if it is not
285
/// printable or if it is an escape char.
286
void printEscapedString(StringRef Name, raw_ostream &Out);
287
288
/// Print each character of the specified string, escaping HTML special
289
/// characters.
290
void printHTMLEscaped(StringRef String, raw_ostream &Out);
291
292
/// printLowerCase - Print each character as lowercase if it is uppercase.
293
void printLowerCase(StringRef String, raw_ostream &Out);
294
295
namespace detail {
296
297
template <typename IteratorT>
298
inline std::string join_impl(IteratorT Begin, IteratorT End,
299
                             StringRef Separator, std::input_iterator_tag) {
300
  std::string S;
301
  if (Begin == End)
302
    return S;
303
304
  S += (*Begin);
305
  while (++Begin != End) {
306
    S += Separator;
307
    S += (*Begin);
308
  }
309
  return S;
310
}
311
312
template <typename IteratorT>
313
inline std::string join_impl(IteratorT Begin, IteratorT End,
314
900k
                             StringRef Separator, std::forward_iterator_tag) {
315
900k
  std::string S;
316
900k
  if (Begin == End)
317
25.4k
    return S;
318
874k
319
874k
  size_t Len = (std::distance(Begin, End) - 1) * Separator.size();
320
9.18M
  for (IteratorT I = Begin; I != End; 
++I8.30M
)
321
8.30M
    Len += (*Begin).size();
322
874k
  S.reserve(Len);
323
874k
  S += (*Begin);
324
8.30M
  while (++Begin != End) {
325
7.43M
    S += Separator;
326
7.43M
    S += (*Begin);
327
7.43M
  }
328
874k
  return S;
329
874k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::detail::join_impl<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*, llvm::StringRef, std::__1::forward_iterator_tag)
Line
Count
Source
314
3.26k
                             StringRef Separator, std::forward_iterator_tag) {
315
3.26k
  std::string S;
316
3.26k
  if (Begin == End)
317
24
    return S;
318
3.24k
319
3.24k
  size_t Len = (std::distance(Begin, End) - 1) * Separator.size();
320
6.68k
  for (IteratorT I = Begin; I != End; 
++I3.44k
)
321
3.44k
    Len += (*Begin).size();
322
3.24k
  S.reserve(Len);
323
3.24k
  S += (*Begin);
324
3.44k
  while (++Begin != End) {
325
199
    S += Separator;
326
199
    S += (*Begin);
327
199
  }
328
3.24k
  return S;
329
3.24k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::detail::join_impl<std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*> >(std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*>, std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*>, llvm::StringRef, std::__1::forward_iterator_tag)
Line
Count
Source
314
833k
                             StringRef Separator, std::forward_iterator_tag) {
315
833k
  std::string S;
316
833k
  if (Begin == End)
317
5
    return S;
318
833k
319
833k
  size_t Len = (std::distance(Begin, End) - 1) * Separator.size();
320
8.92M
  for (IteratorT I = Begin; I != End; 
++I8.09M
)
321
8.09M
    Len += (*Begin).size();
322
833k
  S.reserve(Len);
323
833k
  S += (*Begin);
324
8.09M
  while (++Begin != End) {
325
7.26M
    S += Separator;
326
7.26M
    S += (*Begin);
327
7.26M
  }
328
833k
  return S;
329
833k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::detail::join_impl<llvm::StringRef*>(llvm::StringRef*, llvm::StringRef*, llvm::StringRef, std::__1::forward_iterator_tag)
Line
Count
Source
314
3.40k
                             StringRef Separator, std::forward_iterator_tag) {
315
3.40k
  std::string S;
316
3.40k
  if (Begin == End)
317
1.17k
    return S;
318
2.23k
319
2.23k
  size_t Len = (std::distance(Begin, End) - 1) * Separator.size();
320
8.77k
  for (IteratorT I = Begin; I != End; 
++I6.54k
)
321
6.54k
    Len += (*Begin).size();
322
2.23k
  S.reserve(Len);
323
2.23k
  S += (*Begin);
324
6.54k
  while (++Begin != End) {
325
4.30k
    S += Separator;
326
4.30k
    S += (*Begin);
327
4.30k
  }
328
2.23k
  return S;
329
2.23k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::detail::join_impl<std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*> >(std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*>, std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*>, llvm::StringRef, std::__1::forward_iterator_tag)
Line
Count
Source
314
58.2k
                             StringRef Separator, std::forward_iterator_tag) {
315
58.2k
  std::string S;
316
58.2k
  if (Begin == End)
317
24.1k
    return S;
318
34.0k
319
34.0k
  size_t Len = (std::distance(Begin, End) - 1) * Separator.size();
320
236k
  for (IteratorT I = Begin; I != End; 
++I202k
)
321
202k
    Len += (*Begin).size();
322
34.0k
  S.reserve(Len);
323
34.0k
  S += (*Begin);
324
202k
  while (++Begin != End) {
325
168k
    S += Separator;
326
168k
    S += (*Begin);
327
168k
  }
328
34.0k
  return S;
329
34.0k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::detail::join_impl<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*, llvm::StringRef, std::__1::forward_iterator_tag)
Line
Count
Source
314
1.82k
                             StringRef Separator, std::forward_iterator_tag) {
315
1.82k
  std::string S;
316
1.82k
  if (Begin == End)
317
0
    return S;
318
1.82k
319
1.82k
  size_t Len = (std::distance(Begin, End) - 1) * Separator.size();
320
5.30k
  for (IteratorT I = Begin; I != End; 
++I3.48k
)
321
3.48k
    Len += (*Begin).size();
322
1.82k
  S.reserve(Len);
323
1.82k
  S += (*Begin);
324
3.48k
  while (++Begin != End) {
325
1.66k
    S += Separator;
326
1.66k
    S += (*Begin);
327
1.66k
  }
328
1.82k
  return S;
329
1.82k
}
330
331
template <typename Sep>
332
inline void join_items_impl(std::string &Result, Sep Separator) {}
333
334
template <typename Sep, typename Arg>
335
inline void join_items_impl(std::string &Result, Sep Separator,
336
                            const Arg &Item) {
337
  Result += Item;
338
}
339
340
template <typename Sep, typename Arg1, typename... Args>
341
inline void join_items_impl(std::string &Result, Sep Separator, const Arg1 &A1,
342
                            Args &&... Items) {
343
  Result += A1;
344
  Result += Separator;
345
  join_items_impl(Result, Separator, std::forward<Args>(Items)...);
346
}
347
348
inline size_t join_one_item_size(char C) { return 1; }
349
inline size_t join_one_item_size(const char *S) { return S ? ::strlen(S) : 0; }
350
351
template <typename T> inline size_t join_one_item_size(const T &Str) {
352
  return Str.size();
353
}
354
355
0
inline size_t join_items_size() { return 0; }
356
357
template <typename A1> inline size_t join_items_size(const A1 &A) {
358
  return join_one_item_size(A);
359
}
360
template <typename A1, typename... Args>
361
inline size_t join_items_size(const A1 &A, Args &&... Items) {
362
  return join_one_item_size(A) + join_items_size(std::forward<Args>(Items)...);
363
}
364
365
} // end namespace detail
366
367
/// Joins the strings in the range [Begin, End), adding Separator between
368
/// the elements.
369
template <typename IteratorT>
370
900k
inline std::string join(IteratorT Begin, IteratorT End, StringRef Separator) {
371
900k
  using tag = typename std::iterator_traits<IteratorT>::iterator_category;
372
900k
  return detail::join_impl(Begin, End, Separator, tag());
373
900k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::join<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*, llvm::StringRef)
Line
Count
Source
370
3.26k
inline std::string join(IteratorT Begin, IteratorT End, StringRef Separator) {
371
3.26k
  using tag = typename std::iterator_traits<IteratorT>::iterator_category;
372
3.26k
  return detail::join_impl(Begin, End, Separator, tag());
373
3.26k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::join<std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*> >(std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*>, std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*>, llvm::StringRef)
Line
Count
Source
370
833k
inline std::string join(IteratorT Begin, IteratorT End, StringRef Separator) {
371
833k
  using tag = typename std::iterator_traits<IteratorT>::iterator_category;
372
833k
  return detail::join_impl(Begin, End, Separator, tag());
373
833k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::join<llvm::StringRef*>(llvm::StringRef*, llvm::StringRef*, llvm::StringRef)
Line
Count
Source
370
3.40k
inline std::string join(IteratorT Begin, IteratorT End, StringRef Separator) {
371
3.40k
  using tag = typename std::iterator_traits<IteratorT>::iterator_category;
372
3.40k
  return detail::join_impl(Begin, End, Separator, tag());
373
3.40k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::join<std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*> >(std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*>, std::__1::__wrap_iter<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*>, llvm::StringRef)
Line
Count
Source
370
58.2k
inline std::string join(IteratorT Begin, IteratorT End, StringRef Separator) {
371
58.2k
  using tag = typename std::iterator_traits<IteratorT>::iterator_category;
372
58.2k
  return detail::join_impl(Begin, End, Separator, tag());
373
58.2k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::join<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*, llvm::StringRef)
Line
Count
Source
370
1.82k
inline std::string join(IteratorT Begin, IteratorT End, StringRef Separator) {
371
1.82k
  using tag = typename std::iterator_traits<IteratorT>::iterator_category;
372
1.82k
  return detail::join_impl(Begin, End, Separator, tag());
373
1.82k
}
374
375
/// Joins the strings in the range [R.begin(), R.end()), adding Separator
376
/// between the elements.
377
template <typename Range>
378
833k
inline std::string join(Range &&R, StringRef Separator) {
379
833k
  return join(R.begin(), R.end(), Separator);
380
833k
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::join<llvm::SmallVector<llvm::StringRef, 32u>&>(llvm::SmallVector<llvm::StringRef, 32u>&&&, llvm::StringRef)
Line
Count
Source
378
57
inline std::string join(Range &&R, StringRef Separator) {
379
57
  return join(R.begin(), R.end(), Separator);
380
57
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::join<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&>(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&&&, llvm::StringRef)
Line
Count
Source
378
1
inline std::string join(Range &&R, StringRef Separator) {
379
1
  return join(R.begin(), R.end(), Separator);
380
1
}
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > llvm::join<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&>(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&&&, llvm::StringRef)
Line
Count
Source
378
833k
inline std::string join(Range &&R, StringRef Separator) {
379
833k
  return join(R.begin(), R.end(), Separator);
380
833k
}
381
382
/// Joins the strings in the parameter pack \p Items, adding \p Separator
383
/// between the elements.  All arguments must be implicitly convertible to
384
/// std::string, or there should be an overload of std::string::operator+=()
385
/// that accepts the argument explicitly.
386
template <typename Sep, typename... Args>
387
inline std::string join_items(Sep Separator, Args &&... Items) {
388
  std::string Result;
389
  if (sizeof...(Items) == 0)
390
    return Result;
391
392
  size_t NS = detail::join_one_item_size(Separator);
393
  size_t NI = detail::join_items_size(std::forward<Args>(Items)...);
394
  Result.reserve(NI + (sizeof...(Items) - 1) * NS + 1);
395
  detail::join_items_impl(Result, Separator, std::forward<Args>(Items)...);
396
  return Result;
397
}
398
399
} // end namespace llvm
400
401
#endif // LLVM_ADT_STRINGEXTRAS_H