1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
//===-- StringExtras.cpp - Implement the StringExtras header --------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the StringExtras.h header
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/raw_ostream.h"
#include <cctype>
using namespace llvm;
/// StrInStrNoCase - Portable version of strcasestr. Locates the first
/// occurrence of string 's1' in string 's2', ignoring case. Returns
/// the offset of s2 in s1 or npos if s2 cannot be found.
StringRef::size_type llvm::StrInStrNoCase(StringRef s1, StringRef s2) {
size_t N = s2.size(), M = s1.size();
if (N > M)
return StringRef::npos;
for (size_t i = 0, e = M - N + 1; i != e; ++i)
if (s1.substr(i, N).equals_insensitive(s2))
return i;
return StringRef::npos;
}
/// getToken - This function extracts one token from source, ignoring any
/// leading characters that appear in the Delimiters string, and ending the
/// token at any of the characters that appear in the Delimiters string. If
/// there are no tokens in the source string, an empty string is returned.
/// The function returns a pair containing the extracted token and the
/// remaining tail string.
std::pair<StringRef, StringRef> llvm::getToken(StringRef Source,
StringRef Delimiters) {
// Figure out where the token starts.
StringRef::size_type Start = Source.find_first_not_of(Delimiters);
// Find the next occurrence of the delimiter.
StringRef::size_type End = Source.find_first_of(Delimiters, Start);
return std::make_pair(Source.slice(Start, End), Source.substr(End));
}
/// SplitString - Split up the specified string according to the specified
/// delimiters, appending the result fragments to the output list.
void llvm::SplitString(StringRef Source,
SmallVectorImpl<StringRef> &OutFragments,
StringRef Delimiters) {
std::pair<StringRef, StringRef> S = getToken(Source, Delimiters);
while (!S.first.empty()) {
OutFragments.push_back(S.first);
S = getToken(S.second, Delimiters);
}
}
void llvm::printEscapedString(StringRef Name, raw_ostream &Out) {
for (unsigned char C : Name) {
if (C == '\\')
Out << '\\' << C;
else if (isPrint(C) && C != '"')
Out << C;
else
Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
}
}
void llvm::printHTMLEscaped(StringRef String, raw_ostream &Out) {
for (char C : String) {
if (C == '&')
Out << "&";
else if (C == '<')
Out << "<";
else if (C == '>')
Out << ">";
else if (C == '\"')
Out << """;
else if (C == '\'')
Out << "'";
else
Out << C;
}
}
void llvm::printLowerCase(StringRef String, raw_ostream &Out) {
for (const char C : String)
Out << toLower(C);
}
std::string llvm::convertToSnakeFromCamelCase(StringRef input) {
if (input.empty())
return "";
std::string snakeCase;
snakeCase.reserve(input.size());
for (char c : input) {
if (!std::isupper(c)) {
snakeCase.push_back(c);
continue;
}
if (!snakeCase.empty() && snakeCase.back() != '_')
snakeCase.push_back('_');
snakeCase.push_back(llvm::toLower(c));
}
return snakeCase;
}
std::string llvm::convertToCamelFromSnakeCase(StringRef input,
bool capitalizeFirst) {
if (input.empty())
return "";
std::string output;
output.reserve(input.size());
// Push the first character, capatilizing if necessary.
if (capitalizeFirst && std::islower(input.front()))
output.push_back(llvm::toUpper(input.front()));
else
output.push_back(input.front());
// Walk the input converting any `*_[a-z]` snake case into `*[A-Z]` camelCase.
for (size_t pos = 1, e = input.size(); pos < e; ++pos) {
if (input[pos] == '_' && pos != (e - 1) && std::islower(input[pos + 1]))
output.push_back(llvm::toUpper(input[++pos]));
else
output.push_back(input[pos]);
}
return output;
}
|
