RegularExpression.h revision 321369 
1//===-- RegularExpression.h -------------------------------------*- 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 liblldb_RegularExpression_h_
11#define liblldb_RegularExpression_h_
12
13#ifdef _WIN32
14#include "../lib/Support/regex_impl.h"
15
16typedef llvm_regmatch_t regmatch_t;
17typedef llvm_regex_t regex_t;
18
19inline int regcomp(llvm_regex_t *a, const char *b, int c) {
20  return llvm_regcomp(a, b, c);
21}
22
23inline size_t regerror(int a, const llvm_regex_t *b, char *c, size_t d) {
24  return llvm_regerror(a, b, c, d);
25}
26
27inline int regexec(const llvm_regex_t *a, const char *b, size_t c,
28                   llvm_regmatch_t d[], int e) {
29  return llvm_regexec(a, b, c, d, e);
30}
31
32inline void regfree(llvm_regex_t *a) { llvm_regfree(a); }
33#else
34#ifdef __ANDROID__
35#include <regex>
36#endif
37#include <regex.h>
38#endif
39
40#include <string>
41#include <vector>
42
43#include <stddef.h> // for size_t
44#include <stdint.h>
45
46namespace llvm {
47class StringRef;
48} // namespace llvm
49
50namespace lldb_private {
51
52//----------------------------------------------------------------------
53/// @class RegularExpression RegularExpression.h
54/// "lldb/Utility/RegularExpression.h"
55/// @brief A C++ wrapper class for regex.
56///
57/// This regular expression class wraps the posix regex functions
58/// \c regcomp(), \c regerror(), \c regexec(), and \c regfree() from
59/// the header file in \c /usr/include/regex\.h.
60//----------------------------------------------------------------------
61class RegularExpression {
62public:
63  class Match {
64  public:
65    Match(uint32_t max_matches) : m_matches() {
66      if (max_matches > 0)
67        m_matches.resize(max_matches + 1);
68    }
69
70    void Clear() {
71      const size_t num_matches = m_matches.size();
72      regmatch_t invalid_match = {-1, -1};
73      for (size_t i = 0; i < num_matches; ++i)
74        m_matches[i] = invalid_match;
75    }
76
77    size_t GetSize() const { return m_matches.size(); }
78
79    regmatch_t *GetData() {
80      return (m_matches.empty() ? nullptr : m_matches.data());
81    }
82
83    bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
84                         std::string &match_str) const;
85
86    bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
87                         llvm::StringRef &match_str) const;
88
89    bool GetMatchSpanningIndices(llvm::StringRef s, uint32_t idx1,
90                                 uint32_t idx2,
91                                 llvm::StringRef &match_str) const;
92
93  protected:
94    std::vector<regmatch_t>
95        m_matches; ///< Where parenthesized subexpressions results are stored
96  };
97
98  //------------------------------------------------------------------
99  /// Default constructor.
100  ///
101  /// The default constructor that initializes the object state such
102  /// that it contains no compiled regular expression.
103  //------------------------------------------------------------------
104  RegularExpression();
105
106  explicit RegularExpression(llvm::StringRef string);
107
108  //------------------------------------------------------------------
109  /// Destructor.
110  ///
111  /// Any previously compiled regular expression contained in this
112  /// object will be freed.
113  //------------------------------------------------------------------
114  ~RegularExpression();
115
116  RegularExpression(const RegularExpression &rhs);
117
118  const RegularExpression &operator=(const RegularExpression &rhs);
119
120  //------------------------------------------------------------------
121  /// Compile a regular expression.
122  ///
123  /// Compile a regular expression using the supplied regular
124  /// expression text. The compiled regular expression lives
125  /// in this object so that it can be readily used for regular
126  /// expression matches. Execute() can be called after the regular
127  /// expression is compiled. Any previously compiled regular
128  /// expression contained in this object will be freed.
129  ///
130  /// @param[in] re
131  ///     A NULL terminated C string that represents the regular
132  ///     expression to compile.
133  ///
134  /// @return
135  ///     \b true if the regular expression compiles successfully,
136  ///     \b false otherwise.
137  //------------------------------------------------------------------
138  bool Compile(llvm::StringRef string);
139  bool Compile(const char *) = delete;
140
141  //------------------------------------------------------------------
142  /// Executes a regular expression.
143  ///
144  /// Execute a regular expression match using the compiled regular
145  /// expression that is already in this object against the match
146  /// string \a s. If any parens are used for regular expression
147  /// matches \a match_count should indicate the number of regmatch_t
148  /// values that are present in \a match_ptr.
149  ///
150  /// @param[in] string
151  ///     The string to match against the compile regular expression.
152  ///
153  /// @param[in] match
154  ///     A pointer to a RegularExpression::Match structure that was
155  ///     properly initialized with the desired number of maximum
156  ///     matches, or nullptr if no parenthesized matching is needed.
157  ///
158  /// @return
159  ///     \b true if \a string matches the compiled regular
160  ///     expression, \b false otherwise.
161  //------------------------------------------------------------------
162  bool Execute(llvm::StringRef string, Match *match = nullptr) const;
163  bool Execute(const char *, Match * = nullptr) = delete;
164
165  size_t GetErrorAsCString(char *err_str, size_t err_str_max_len) const;
166
167  //------------------------------------------------------------------
168  /// Free the compiled regular expression.
169  ///
170  /// If this object contains a valid compiled regular expression,
171  /// this function will free any resources it was consuming.
172  //------------------------------------------------------------------
173  void Free();
174
175  //------------------------------------------------------------------
176  /// Access the regular expression text.
177  ///
178  /// Returns the text that was used to compile the current regular
179  /// expression.
180  ///
181  /// @return
182  ///     The NULL terminated C string that was used to compile the
183  ///     current regular expression
184  //------------------------------------------------------------------
185  llvm::StringRef GetText() const;
186
187  //------------------------------------------------------------------
188  /// Test if valid.
189  ///
190  /// Test if this object contains a valid regular expression.
191  ///
192  /// @return
193  ///     \b true if the regular expression compiled and is ready
194  ///     for execution, \b false otherwise.
195  //------------------------------------------------------------------
196  bool IsValid() const;
197
198  void Clear() {
199    Free();
200    m_re.clear();
201    m_comp_err = 1;
202  }
203
204  int GetErrorCode() const { return m_comp_err; }
205
206  bool operator<(const RegularExpression &rhs) const;
207
208private:
209  //------------------------------------------------------------------
210  // Member variables
211  //------------------------------------------------------------------
212  std::string m_re; ///< A copy of the original regular expression text
213  int m_comp_err;   ///< Status code for the regular expression compilation
214  regex_t m_preg;   ///< The compiled regular expression
215};
216
217} // namespace lldb_private
218
219#endif // liblldb_RegularExpression_h_
220