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
20namespace llvm
21{
22    class StringRef;
23}
24
25namespace 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//----------------------------------------------------------------------
35class RegularExpression
36{
37public:
38    class Match
39    {
40    public:
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
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
58        GetSize () const
59        {
60            return m_matches.size();
61        }
62
63        regmatch_t *
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
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
223    Clear ()
224    {
225        Free();
226        m_re.clear();
227        m_compile_flags = 0;
228        m_comp_err = 1;
229    }
230
231    int
232    GetErrorCode() const
233    {
234        return m_comp_err;
235    }
236
237    bool
238    operator < (const RegularExpression& rhs) const;
239
240private:
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