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