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