Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1 | //===-- RegularExpression.cpp -----------------------------------*- 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 | |
Greg Clayton | 7bd4c60 | 2015-01-21 21:51:02 +0000 | [diff] [blame] | 10 | #include <string.h> |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 11 | #include "lldb/Core/RegularExpression.h" |
Greg Clayton | 1b3815c | 2013-01-30 00:18:29 +0000 | [diff] [blame] | 12 | #include "llvm/ADT/StringRef.h" |
Greg Clayton | 7bd4c60 | 2015-01-21 21:51:02 +0000 | [diff] [blame] | 13 | #include "lldb/Core/Error.h" |
| 14 | |
| 15 | |
| 16 | //---------------------------------------------------------------------- |
| 17 | // Enable enhanced mode if it is available. This allows for things like |
| 18 | // \d for digit, \s for space, and many more, but it isn't available |
| 19 | // everywhere. |
| 20 | //---------------------------------------------------------------------- |
| 21 | #if defined(REG_ENHANCED) |
| 22 | #define DEFAULT_COMPILE_FLAGS (REG_ENHANCED|REG_EXTENDED) |
| 23 | #else |
| 24 | #define DEFAULT_COMPILE_FLAGS (REG_EXTENDED) |
| 25 | #endif |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 26 | |
| 27 | using namespace lldb_private; |
| 28 | |
| 29 | //---------------------------------------------------------------------- |
| 30 | // Default constructor |
| 31 | //---------------------------------------------------------------------- |
| 32 | RegularExpression::RegularExpression() : |
| 33 | m_re(), |
| 34 | m_comp_err (1), |
Greg Clayton | 7bd4c60 | 2015-01-21 21:51:02 +0000 | [diff] [blame] | 35 | m_preg() |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 36 | { |
| 37 | memset(&m_preg,0,sizeof(m_preg)); |
| 38 | } |
| 39 | |
| 40 | //---------------------------------------------------------------------- |
| 41 | // Constructor that compiles "re" using "flags" and stores the |
| 42 | // resulting compiled regular expression into this object. |
| 43 | //---------------------------------------------------------------------- |
Jim Ingham | 969795f | 2011-09-21 01:17:13 +0000 | [diff] [blame] | 44 | RegularExpression::RegularExpression(const char* re) : |
| 45 | m_re(), |
| 46 | m_comp_err (1), |
Greg Clayton | 7bd4c60 | 2015-01-21 21:51:02 +0000 | [diff] [blame] | 47 | m_preg() |
Jim Ingham | 969795f | 2011-09-21 01:17:13 +0000 | [diff] [blame] | 48 | { |
| 49 | memset(&m_preg,0,sizeof(m_preg)); |
| 50 | Compile(re); |
| 51 | } |
| 52 | |
| 53 | RegularExpression::RegularExpression(const RegularExpression &rhs) |
| 54 | { |
| 55 | memset(&m_preg,0,sizeof(m_preg)); |
Greg Clayton | 7bd4c60 | 2015-01-21 21:51:02 +0000 | [diff] [blame] | 56 | Compile(rhs.GetText()); |
Jim Ingham | 969795f | 2011-09-21 01:17:13 +0000 | [diff] [blame] | 57 | } |
| 58 | |
| 59 | const RegularExpression & |
| 60 | RegularExpression::operator= (const RegularExpression &rhs) |
| 61 | { |
| 62 | if (&rhs != this) |
Greg Clayton | 7bd4c60 | 2015-01-21 21:51:02 +0000 | [diff] [blame] | 63 | Compile (rhs.GetText()); |
Jim Ingham | 969795f | 2011-09-21 01:17:13 +0000 | [diff] [blame] | 64 | return *this; |
| 65 | } |
| 66 | //---------------------------------------------------------------------- |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 67 | // Destructor |
| 68 | // |
Bruce Mitchener | d93c4a3 | 2014-07-01 21:22:11 +0000 | [diff] [blame] | 69 | // Any previously compiled regular expression contained in this |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 70 | // object will be freed. |
| 71 | //---------------------------------------------------------------------- |
| 72 | RegularExpression::~RegularExpression() |
| 73 | { |
| 74 | Free(); |
| 75 | } |
| 76 | |
| 77 | //---------------------------------------------------------------------- |
| 78 | // Compile a regular expression using the supplied regular |
Bruce Mitchener | d93c4a3 | 2014-07-01 21:22:11 +0000 | [diff] [blame] | 79 | // expression text and flags. The compiled regular expression lives |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 80 | // in this object so that it can be readily used for regular |
| 81 | // expression matches. Execute() can be called after the regular |
Bruce Mitchener | d93c4a3 | 2014-07-01 21:22:11 +0000 | [diff] [blame] | 82 | // expression is compiled. Any previously compiled regular |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 83 | // expression contained in this object will be freed. |
| 84 | // |
| 85 | // RETURNS |
Bruce Mitchener | d93c4a3 | 2014-07-01 21:22:11 +0000 | [diff] [blame] | 86 | // True if the regular expression compiles successfully, false |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 87 | // otherwise. |
| 88 | //---------------------------------------------------------------------- |
| 89 | bool |
Jim Ingham | 969795f | 2011-09-21 01:17:13 +0000 | [diff] [blame] | 90 | RegularExpression::Compile(const char* re) |
| 91 | { |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 92 | Free(); |
Jim Ingham | 969795f | 2011-09-21 01:17:13 +0000 | [diff] [blame] | 93 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 94 | if (re && re[0]) |
| 95 | { |
| 96 | m_re = re; |
Greg Clayton | 7bd4c60 | 2015-01-21 21:51:02 +0000 | [diff] [blame] | 97 | m_comp_err = ::regcomp (&m_preg, re, DEFAULT_COMPILE_FLAGS); |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 98 | } |
| 99 | else |
| 100 | { |
| 101 | // No valid regular expression |
| 102 | m_comp_err = 1; |
| 103 | } |
| 104 | |
| 105 | return m_comp_err == 0; |
| 106 | } |
| 107 | |
| 108 | //---------------------------------------------------------------------- |
| 109 | // Execute a regular expression match using the compiled regular |
| 110 | // expression that is already in this object against the match |
| 111 | // string "s". If any parens are used for regular expression |
| 112 | // matches "match_count" should indicate the number of regmatch_t |
| 113 | // values that are present in "match_ptr". The regular expression |
| 114 | // will be executed using the "execute_flags". |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 115 | //--------------------------------------------------------------------- |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 116 | bool |
Greg Clayton | 7bd4c60 | 2015-01-21 21:51:02 +0000 | [diff] [blame] | 117 | RegularExpression::Execute (const char* s, Match *match) const |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 118 | { |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 119 | int err = 1; |
Greg Clayton | cc24775 | 2013-05-23 20:27:15 +0000 | [diff] [blame] | 120 | if (s != NULL && m_comp_err == 0) |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 121 | { |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 122 | if (match) |
Greg Clayton | 1b3815c | 2013-01-30 00:18:29 +0000 | [diff] [blame] | 123 | { |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 124 | err = ::regexec (&m_preg, |
| 125 | s, |
| 126 | match->GetSize(), |
| 127 | match->GetData(), |
Greg Clayton | 7bd4c60 | 2015-01-21 21:51:02 +0000 | [diff] [blame] | 128 | 0); |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 129 | } |
| 130 | else |
| 131 | { |
| 132 | err = ::regexec (&m_preg, |
| 133 | s, |
| 134 | 0, |
| 135 | NULL, |
Greg Clayton | 7bd4c60 | 2015-01-21 21:51:02 +0000 | [diff] [blame] | 136 | 0); |
Greg Clayton | 1b3815c | 2013-01-30 00:18:29 +0000 | [diff] [blame] | 137 | } |
| 138 | } |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 139 | |
| 140 | if (err != 0) |
| 141 | { |
| 142 | // The regular expression didn't compile, so clear the matches |
| 143 | if (match) |
| 144 | match->Clear(); |
| 145 | return false; |
| 146 | } |
| 147 | return true; |
Greg Clayton | 1b3815c | 2013-01-30 00:18:29 +0000 | [diff] [blame] | 148 | } |
| 149 | |
| 150 | bool |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 151 | RegularExpression::Match::GetMatchAtIndex (const char* s, uint32_t idx, std::string& match_str) const |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 152 | { |
Greg Clayton | fa226b7 | 2014-10-22 21:43:15 +0000 | [diff] [blame] | 153 | llvm::StringRef match_str_ref; |
| 154 | if (GetMatchAtIndex(s, idx, match_str_ref)) |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 155 | { |
Pavel Labath | 3a29f8b | 2015-07-28 09:18:32 +0000 | [diff] [blame] | 156 | match_str = match_str_ref.str(); |
Greg Clayton | fa226b7 | 2014-10-22 21:43:15 +0000 | [diff] [blame] | 157 | return true; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 158 | } |
| 159 | return false; |
| 160 | } |
| 161 | |
Greg Clayton | 1b3815c | 2013-01-30 00:18:29 +0000 | [diff] [blame] | 162 | bool |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 163 | RegularExpression::Match::GetMatchAtIndex (const char* s, uint32_t idx, llvm::StringRef& match_str) const |
Greg Clayton | 1b3815c | 2013-01-30 00:18:29 +0000 | [diff] [blame] | 164 | { |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 165 | if (idx < m_matches.size()) |
Greg Clayton | 1b3815c | 2013-01-30 00:18:29 +0000 | [diff] [blame] | 166 | { |
Greg Clayton | fa226b7 | 2014-10-22 21:43:15 +0000 | [diff] [blame] | 167 | if (m_matches[idx].rm_eo == -1 && m_matches[idx].rm_so == -1) |
| 168 | return false; |
| 169 | |
Greg Clayton | 1b3815c | 2013-01-30 00:18:29 +0000 | [diff] [blame] | 170 | if (m_matches[idx].rm_eo == m_matches[idx].rm_so) |
| 171 | { |
| 172 | // Matched the empty string... |
| 173 | match_str = llvm::StringRef(); |
| 174 | return true; |
| 175 | } |
| 176 | else if (m_matches[idx].rm_eo > m_matches[idx].rm_so) |
| 177 | { |
| 178 | match_str = llvm::StringRef (s + m_matches[idx].rm_so, m_matches[idx].rm_eo - m_matches[idx].rm_so); |
| 179 | return true; |
| 180 | } |
| 181 | } |
| 182 | return false; |
| 183 | } |
| 184 | |
| 185 | bool |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 186 | RegularExpression::Match::GetMatchSpanningIndices (const char* s, uint32_t idx1, uint32_t idx2, llvm::StringRef& match_str) const |
Greg Clayton | 1b3815c | 2013-01-30 00:18:29 +0000 | [diff] [blame] | 187 | { |
Greg Clayton | bc43cab | 2013-04-03 21:37:16 +0000 | [diff] [blame] | 188 | if (idx1 < m_matches.size() && idx2 < m_matches.size()) |
Greg Clayton | 1b3815c | 2013-01-30 00:18:29 +0000 | [diff] [blame] | 189 | { |
| 190 | if (m_matches[idx1].rm_so == m_matches[idx2].rm_eo) |
| 191 | { |
| 192 | // Matched the empty string... |
| 193 | match_str = llvm::StringRef(); |
| 194 | return true; |
| 195 | } |
| 196 | else if (m_matches[idx1].rm_so < m_matches[idx2].rm_eo) |
| 197 | { |
| 198 | match_str = llvm::StringRef (s + m_matches[idx1].rm_so, m_matches[idx2].rm_eo - m_matches[idx1].rm_so); |
| 199 | return true; |
| 200 | } |
| 201 | } |
| 202 | return false; |
| 203 | } |
| 204 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 205 | |
| 206 | //---------------------------------------------------------------------- |
| 207 | // Returns true if the regular expression compiled and is ready |
| 208 | // for execution. |
| 209 | //---------------------------------------------------------------------- |
| 210 | bool |
| 211 | RegularExpression::IsValid () const |
| 212 | { |
| 213 | return m_comp_err == 0; |
| 214 | } |
| 215 | |
| 216 | //---------------------------------------------------------------------- |
| 217 | // Returns the text that was used to compile the current regular |
| 218 | // expression. |
| 219 | //---------------------------------------------------------------------- |
| 220 | const char* |
| 221 | RegularExpression::GetText () const |
| 222 | { |
Greg Clayton | 67cc063 | 2012-08-22 17:17:09 +0000 | [diff] [blame] | 223 | if (m_re.empty()) |
| 224 | return NULL; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 225 | return m_re.c_str(); |
| 226 | } |
| 227 | |
| 228 | //---------------------------------------------------------------------- |
| 229 | // Free any contained compiled regular expressions. |
| 230 | //---------------------------------------------------------------------- |
| 231 | void |
| 232 | RegularExpression::Free() |
| 233 | { |
| 234 | if (m_comp_err == 0) |
| 235 | { |
| 236 | m_re.clear(); |
| 237 | regfree(&m_preg); |
| 238 | // Set a compile error since we no longer have a valid regex |
| 239 | m_comp_err = 1; |
| 240 | } |
| 241 | } |
Greg Clayton | 4674702 | 2010-10-10 23:55:27 +0000 | [diff] [blame] | 242 | |
| 243 | size_t |
| 244 | RegularExpression::GetErrorAsCString (char *err_str, size_t err_str_max_len) const |
| 245 | { |
| 246 | if (m_comp_err == 0) |
| 247 | { |
| 248 | if (err_str && err_str_max_len) |
| 249 | *err_str = '\0'; |
| 250 | return 0; |
| 251 | } |
| 252 | |
| 253 | return ::regerror (m_comp_err, &m_preg, err_str, err_str_max_len); |
| 254 | } |
| 255 | |
Enrico Granata | 0a3958e | 2011-07-02 00:25:22 +0000 | [diff] [blame] | 256 | bool |
| 257 | RegularExpression::operator < (const RegularExpression& rhs) const |
| 258 | { |
| 259 | return (m_re < rhs.m_re); |
| 260 | } |