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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
//===-- RegularExpression.h -------------------------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_RegularExpression_h_
#define liblldb_RegularExpression_h_
#ifdef _WIN32
#include "../lib/Support/regex_impl.h"
typedef llvm_regmatch_t regmatch_t;
typedef llvm_regex_t regex_t;
inline int regcomp(llvm_regex_t *a, const char *b, int c) {
return llvm_regcomp(a, b, c);
}
inline size_t regerror(int a, const llvm_regex_t *b, char *c, size_t d) {
return llvm_regerror(a, b, c, d);
}
inline int regexec(const llvm_regex_t *a, const char *b, size_t c,
llvm_regmatch_t d[], int e) {
return llvm_regexec(a, b, c, d, e);
}
inline void regfree(llvm_regex_t *a) { llvm_regfree(a); }
#else
#ifdef __ANDROID__
#include <regex>
#endif
#include <regex.h>
#endif
#include <string>
#include <vector>
#include <stddef.h>
#include <stdint.h>
namespace llvm {
class StringRef;
} // namespace llvm
namespace lldb_private {
//----------------------------------------------------------------------
/// @class RegularExpression RegularExpression.h
/// "lldb/Utility/RegularExpression.h"
/// A C++ wrapper class for regex.
///
/// This regular expression class wraps the posix regex functions \c
/// regcomp(), \c regerror(), \c regexec(), and \c regfree() from the header
/// file in \c /usr/include/regex\.h.
//----------------------------------------------------------------------
class RegularExpression {
public:
class Match {
public:
Match(uint32_t max_matches) : m_matches() {
if (max_matches > 0)
m_matches.resize(max_matches + 1);
}
void Clear() {
const size_t num_matches = m_matches.size();
regmatch_t invalid_match = {-1, -1};
for (size_t i = 0; i < num_matches; ++i)
m_matches[i] = invalid_match;
}
size_t GetSize() const { return m_matches.size(); }
regmatch_t *GetData() {
return (m_matches.empty() ? nullptr : m_matches.data());
}
bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
std::string &match_str) const;
bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
llvm::StringRef &match_str) const;
bool GetMatchSpanningIndices(llvm::StringRef s, uint32_t idx1,
uint32_t idx2,
llvm::StringRef &match_str) const;
protected:
std::vector<regmatch_t>
m_matches; ///< Where parenthesized subexpressions results are stored
};
//------------------------------------------------------------------
/// Default constructor.
///
/// The default constructor that initializes the object state such that it
/// contains no compiled regular expression.
//------------------------------------------------------------------
RegularExpression();
explicit RegularExpression(llvm::StringRef string);
//------------------------------------------------------------------
/// Destructor.
///
/// Any previously compiled regular expression contained in this object will
/// be freed.
//------------------------------------------------------------------
~RegularExpression();
RegularExpression(const RegularExpression &rhs);
const RegularExpression &operator=(const RegularExpression &rhs);
//------------------------------------------------------------------
/// Compile a regular expression.
///
/// Compile a regular expression using the supplied regular expression text.
/// The compiled regular expression lives in this object so that it can be
/// readily used for regular expression matches. Execute() can be called
/// after the regular expression is compiled. Any previously compiled
/// regular expression contained in this object will be freed.
///
/// @param[in] re
/// A NULL terminated C string that represents the regular
/// expression to compile.
///
/// @return
/// \b true if the regular expression compiles successfully,
/// \b false otherwise.
//------------------------------------------------------------------
bool Compile(llvm::StringRef string);
bool Compile(const char *) = delete;
//------------------------------------------------------------------
/// Executes a regular expression.
///
/// Execute a regular expression match using the compiled regular expression
/// that is already in this object against the match string \a s. If any
/// parens are used for regular expression matches \a match_count should
/// indicate the number of regmatch_t values that are present in \a
/// match_ptr.
///
/// @param[in] string
/// The string to match against the compile regular expression.
///
/// @param[in] match
/// A pointer to a RegularExpression::Match structure that was
/// properly initialized with the desired number of maximum
/// matches, or nullptr if no parenthesized matching is needed.
///
/// @return
/// \b true if \a string matches the compiled regular
/// expression, \b false otherwise.
//------------------------------------------------------------------
bool Execute(llvm::StringRef string, Match *match = nullptr) const;
bool Execute(const char *, Match * = nullptr) = delete;
size_t GetErrorAsCString(char *err_str, size_t err_str_max_len) const;
//------------------------------------------------------------------
/// Free the compiled regular expression.
///
/// If this object contains a valid compiled regular expression, this
/// function will free any resources it was consuming.
//------------------------------------------------------------------
void Free();
//------------------------------------------------------------------
/// Access the regular expression text.
///
/// Returns the text that was used to compile the current regular
/// expression.
///
/// @return
/// The NULL terminated C string that was used to compile the
/// current regular expression
//------------------------------------------------------------------
llvm::StringRef GetText() const;
//------------------------------------------------------------------
/// Test if valid.
///
/// Test if this object contains a valid regular expression.
///
/// @return
/// \b true if the regular expression compiled and is ready
/// for execution, \b false otherwise.
//------------------------------------------------------------------
bool IsValid() const;
void Clear() {
Free();
m_re.clear();
m_comp_err = 1;
}
int GetErrorCode() const { return m_comp_err; }
bool operator<(const RegularExpression &rhs) const;
private:
//------------------------------------------------------------------
// Member variables
//------------------------------------------------------------------
std::string m_re; ///< A copy of the original regular expression text
int m_comp_err; ///< Status code for the regular expression compilation
regex_t m_preg; ///< The compiled regular expression
};
} // namespace lldb_private
#endif // liblldb_RegularExpression_h_
|
