src/common/regex.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/common/regex.cpp
// Purpose:     regular expression matching
// Author:      Karsten Ballueder and Vadim Zeitlin
// Modified by:
// Created:     13.07.01
// RCS-ID:      $Id: regex.cpp 57779 2009-01-02 17:35:16Z PC $
// Copyright:   (c) 2000 Karsten Ballueder <ballueder@gmx.net>
//                  2001 Vadim Zeitlin <vadim@wxwindows.org>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_REGEX

#include "wx/regex.h"

#ifndef WX_PRECOMP
    #include "wx/object.h"
    #include "wx/log.h"
    #include "wx/intl.h"
#endif //WX_PRECOMP

// FreeBSD, Watcom and DMars require this, CW doesn't have nor need it.
// Others also don't seem to need it. If you have an error related to
// (not) including <sys/types.h> please report details to
// wx-dev@lists.wxwindows.org
#if defined(__UNIX__) || defined(__WATCOMC__) || defined(__DIGITALMARS__)
#   include <sys/types.h>
#endif

#include <regex.h>

// WXREGEX_USING_BUILTIN    defined when using the built-in regex lib
// WXREGEX_USING_RE_SEARCH  defined when using re_search in the GNU regex lib
// WXREGEX_IF_NEED_LEN()    wrap the len parameter only used with the built-in
//                          or GNU regex
// WXREGEX_CONVERT_TO_MB    defined when the regex lib is using chars and
//                          wxChar is wide, so conversion must be done
// WXREGEX_CHAR(x)          Convert wxChar to wxRegChar
//
#ifdef __REG_NOFRONT
#   define WXREGEX_USING_BUILTIN
#   define WXREGEX_IF_NEED_LEN(x) ,x
#   define WXREGEX_CHAR(x) x
#else
#   ifdef HAVE_RE_SEARCH
#       define WXREGEX_IF_NEED_LEN(x) ,x
#       define WXREGEX_USING_RE_SEARCH
#   else
#       define WXREGEX_IF_NEED_LEN(x)
#   endif
#   if wxUSE_UNICODE
#       define WXREGEX_CONVERT_TO_MB
#   endif
#   define WXREGEX_CHAR(x) wxConvertWX2MB(x)
#   define wx_regfree regfree
#   define wx_regerror regerror
#endif

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

#ifndef WXREGEX_USING_RE_SEARCH

// the array of offsets for the matches, the usual POSIX regmatch_t array.
class wxRegExMatches
{
public:
    typedef regmatch_t *match_type;

    wxRegExMatches(size_t n)        { m_matches = new regmatch_t[n]; }
    ~wxRegExMatches()               { delete [] m_matches; }

    // we just use casts here because the fields of regmatch_t struct may be 64
    // bit but we're limited to size_t in our public API and are not going to
    // change it because operating on strings longer than 4GB using it is
    // absolutely impractical anyhow
    size_t Start(size_t n) const
    {
        return wx_truncate_cast(size_t, m_matches[n].rm_so);
    }

    size_t End(size_t n) const
    {
        return wx_truncate_cast(size_t, m_matches[n].rm_eo);
    }

    regmatch_t *get() const         { return m_matches; }

private:
    regmatch_t *m_matches;
};

#else // WXREGEX_USING_RE_SEARCH

// the array of offsets for the matches, the struct used by the GNU lib
class wxRegExMatches
{
public:
    typedef re_registers *match_type;

    wxRegExMatches(size_t n)
    {
        m_matches.num_regs = n;
        m_matches.start = new regoff_t[n];
        m_matches.end = new regoff_t[n];
    }

    ~wxRegExMatches()
    {
        delete [] m_matches.start;
        delete [] m_matches.end;
    }

    size_t Start(size_t n) const    { return m_matches.start[n]; }
    size_t End(size_t n) const      { return m_matches.end[n]; }

    re_registers *get()             { return &m_matches; }

private:
    re_registers m_matches;
};

#endif // WXREGEX_USING_RE_SEARCH

// the character type used by the regular expression engine
#ifndef WXREGEX_CONVERT_TO_MB
typedef wxChar wxRegChar;
#else
typedef char wxRegChar;
#endif

// the real implementation of wxRegEx
class wxRegExImpl
{
public:
    // ctor and dtor
    wxRegExImpl();
    ~wxRegExImpl();

    // return true if Compile() had been called successfully
    bool IsValid() const { return m_isCompiled; }

    // RE operations
    bool Compile(const wxString& expr, int flags = 0);
    bool Matches(const wxRegChar *str, int flags
                 WXREGEX_IF_NEED_LEN(size_t len)) const;
    bool GetMatch(size_t *start, size_t *len, size_t index = 0) const;
    size_t GetMatchCount() const;
    int Replace(wxString *pattern, const wxString& replacement,
                size_t maxMatches = 0) const;

private:
    // return the string containing the error message for the given err code
    wxString GetErrorMsg(int errorcode, bool badconv) const;

    // init the members
    void Init()
    {
        m_isCompiled = false;
        m_Matches = NULL;
        m_nMatches = 0;
    }

    // free the RE if compiled
    void Free()
    {
        if ( IsValid() )
        {
            wx_regfree(&m_RegEx);
        }

        delete m_Matches;
    }

    // free the RE if any and reinit the members
    void Reinit()
    {
        Free();
        Init();
    }

    // compiled RE
    regex_t         m_RegEx;

    // the subexpressions data
    wxRegExMatches *m_Matches;
    size_t          m_nMatches;

    // true if m_RegEx is valid
    bool            m_isCompiled;
};


// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxRegExImpl
// ----------------------------------------------------------------------------

wxRegExImpl::wxRegExImpl()
{
    Init();
}

wxRegExImpl::~wxRegExImpl()
{
    Free();
}

wxString wxRegExImpl::GetErrorMsg(int errorcode, bool badconv) const
{
#ifdef WXREGEX_CONVERT_TO_MB
    // currently only needed when using system library in Unicode mode
    if ( badconv )
    {
        return _("conversion to 8-bit encoding failed");
    }
#else
    // 'use' badconv to avoid a compiler warning
    (void)badconv;
#endif

    wxString szError;

    // first get the string length needed
    int len = wx_regerror(errorcode, &m_RegEx, NULL, 0);
    if ( len > 0 )
    {
        char* szcmbError = new char[++len];

        (void)wx_regerror(errorcode, &m_RegEx, szcmbError, len);

        szError = wxConvertMB2WX(szcmbError);
        delete [] szcmbError;
    }
    else // regerror() returned 0
    {
        szError = _("unknown error");
    }

    return szError;
}

bool wxRegExImpl::Compile(const wxString& expr, int flags)
{
    Reinit();

#ifdef WX_NO_REGEX_ADVANCED
#   define FLAVORS wxRE_BASIC
#else
#   define FLAVORS (wxRE_ADVANCED | wxRE_BASIC)
    wxASSERT_MSG( (flags & FLAVORS) != FLAVORS,
                  _T("incompatible flags in wxRegEx::Compile") );
#endif
    wxASSERT_MSG( !(flags & ~(FLAVORS | wxRE_ICASE | wxRE_NOSUB | wxRE_NEWLINE)),
                  _T("unrecognized flags in wxRegEx::Compile") );

    // translate our flags to regcomp() ones
    int flagsRE = 0;
    if ( !(flags & wxRE_BASIC) )
    {
#ifndef WX_NO_REGEX_ADVANCED
        if (flags & wxRE_ADVANCED)
            flagsRE |= REG_ADVANCED;
        else
#endif
            flagsRE |= REG_EXTENDED;
    }

    if ( flags & wxRE_ICASE )
        flagsRE |= REG_ICASE;
    if ( flags & wxRE_NOSUB )
        flagsRE |= REG_NOSUB;
    if ( flags & wxRE_NEWLINE )
        flagsRE |= REG_NEWLINE;

    // compile it
#ifdef WXREGEX_USING_BUILTIN
    bool conv = true;
    int errorcode = wx_re_comp(&m_RegEx, expr, expr.length(), flagsRE);
#else
    const wxWX2MBbuf conv = expr.mbc_str();
    int errorcode = conv ? regcomp(&m_RegEx, conv, flagsRE) : REG_BADPAT;
#endif

    if ( errorcode )
    {
        wxLogError(_("Invalid regular expression '%s': %s"),
                   expr.c_str(), GetErrorMsg(errorcode, !conv).c_str());

        m_isCompiled = false;
    }
    else // ok
    {
        // don't allocate the matches array now, but do it later if necessary
        if ( flags & wxRE_NOSUB )
        {
            // we don't need it at all
            m_nMatches = 0;
        }
        else
        {
            // we will alloc the array later (only if really needed) but count
            // the number of sub-expressions in the regex right now

            // there is always one for the whole expression
            m_nMatches = 1;

            // and some more for bracketed subexperessions
            for ( const wxChar *cptr = expr.c_str(); *cptr; cptr++ )
            {
                if ( *cptr == _T('\\') )
                {
                    // in basic RE syntax groups are inside \(...\)
                    if ( *++cptr == _T('(') && (flags & wxRE_BASIC) )
                    {
                        m_nMatches++;
                    }
                }
                else if ( *cptr == _T('(') && !(flags & wxRE_BASIC) )
                {
                    // we know that the previous character is not an unquoted
                    // backslash because it would have been eaten above, so we
                    // have a bare '(' and this indicates a group start for the
                    // extended syntax. '(?' is used for extensions by perl-
                    // like REs (e.g. advanced), and is not valid for POSIX
                    // extended, so ignore them always.
                    if ( cptr[1] != _T('?') )
                        m_nMatches++;
                }
            }
        }

        m_isCompiled = true;
    }

    return IsValid();
}

#ifdef WXREGEX_USING_RE_SEARCH

// On GNU, regexec is implemented as a wrapper around re_search. re_search
// requires a length parameter which the POSIX regexec does not have,
// therefore regexec must do a strlen on the search text each time it is
// called. This can drastically affect performance when matching is done in
// a loop along a string, such as during a search and replace. Therefore if
// re_search is detected by configure, it is used directly.
//
static int ReSearch(const regex_t *preg,
                    const char *text,
                    size_t len,
                    re_registers *matches,
                    int eflags)
{
    regex_t *pattern = wx_const_cast(regex_t*, preg);

    pattern->not_bol = (eflags & REG_NOTBOL) != 0;
    pattern->not_eol = (eflags & REG_NOTEOL) != 0;
    pattern->regs_allocated = REGS_FIXED;

    int ret = re_search(pattern, text, len, 0, len, matches);
    return ret >= 0 ? 0 : REG_NOMATCH;
}

#endif // WXREGEX_USING_RE_SEARCH

bool wxRegExImpl::Matches(const wxRegChar *str,
                          int flags
                          WXREGEX_IF_NEED_LEN(size_t len)) const
{
    wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );

    // translate our flags to regexec() ones
    wxASSERT_MSG( !(flags & ~(wxRE_NOTBOL | wxRE_NOTEOL)),
                  _T("unrecognized flags in wxRegEx::Matches") );

    int flagsRE = 0;
    if ( flags & wxRE_NOTBOL )
        flagsRE |= REG_NOTBOL;
    if ( flags & wxRE_NOTEOL )
        flagsRE |= REG_NOTEOL;

    // allocate matches array if needed
    wxRegExImpl *self = wxConstCast(this, wxRegExImpl);
    if ( !m_Matches && m_nMatches )
    {
        self->m_Matches = new wxRegExMatches(m_nMatches);
    }

    wxRegExMatches::match_type matches = m_Matches ? m_Matches->get() : NULL;

    // do match it
#if defined WXREGEX_USING_BUILTIN
    int rc = wx_re_exec(&self->m_RegEx, str, len, NULL, m_nMatches, matches, flagsRE);
#elif defined WXREGEX_USING_RE_SEARCH
    int rc = str ? ReSearch(&self->m_RegEx, str, len, matches, flagsRE) : REG_BADPAT;
#else
    int rc = str ? regexec(&self->m_RegEx, str, m_nMatches, matches, flagsRE) : REG_BADPAT;
#endif

    switch ( rc )
    {
        case 0:
            // matched successfully
            return true;

        default:
            // an error occurred
            wxLogError(_("Failed to find match for regular expression: %s"),
                       GetErrorMsg(rc, !str).c_str());
            // fall through

        case REG_NOMATCH:
            // no match
            return false;
    }
}

bool wxRegExImpl::GetMatch(size_t *start, size_t *len, size_t index) const
{
    wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );
    wxCHECK_MSG( m_nMatches, false, _T("can't use with wxRE_NOSUB") );
    wxCHECK_MSG( m_Matches, false, _T("must call Matches() first") );
    wxCHECK_MSG( index < m_nMatches, false, _T("invalid match index") );

    if ( start )
        *start = m_Matches->Start(index);
    if ( len )
        *len = m_Matches->End(index) - m_Matches->Start(index);

    return true;
}

size_t wxRegExImpl::GetMatchCount() const
{
    wxCHECK_MSG( IsValid(), 0, _T("must successfully Compile() first") );
    wxCHECK_MSG( m_nMatches, 0, _T("can't use with wxRE_NOSUB") );

    return m_nMatches;
}

int wxRegExImpl::Replace(wxString *text,
                         const wxString& replacement,
                         size_t maxMatches) const
{
    wxCHECK_MSG( text, wxNOT_FOUND, _T("NULL text in wxRegEx::Replace") );
    wxCHECK_MSG( IsValid(), wxNOT_FOUND, _T("must successfully Compile() first") );

    // the input string
#ifndef WXREGEX_CONVERT_TO_MB
    const wxChar *textstr = text->c_str();
    size_t textlen = text->length();
#else
    const wxWX2MBbuf textstr = WXREGEX_CHAR(*text);
    if (!textstr)
    {
        wxLogError(_("Failed to find match for regular expression: %s"),
                   GetErrorMsg(0, true).c_str());
        return 0;
    }
    size_t textlen = strlen(textstr);
    text->clear();
#endif

    // the replacement text
    wxString textNew;

    // the result, allow 25% extra
    wxString result;
    result.reserve(5 * textlen / 4);

    // attempt at optimization: don't iterate over the string if it doesn't
    // contain back references at all
    bool mayHaveBackrefs =
        replacement.find_first_of(_T("\\&")) != wxString::npos;

    if ( !mayHaveBackrefs )
    {
        textNew = replacement;
    }

    // the position where we start looking for the match
    size_t matchStart = 0;

    // number of replacement made: we won't make more than maxMatches of them
    // (unless maxMatches is 0 which doesn't limit the number of replacements)
    size_t countRepl = 0;

    // note that "^" shouldn't match after the first call to Matches() so we
    // use wxRE_NOTBOL to prevent it from happening
    while ( (!maxMatches || countRepl < maxMatches) &&
            Matches(textstr + matchStart,
                    countRepl ? wxRE_NOTBOL : 0
                    WXREGEX_IF_NEED_LEN(textlen - matchStart)) )
    {
        // the string possibly contains back references: we need to calculate
        // the replacement text anew after each match
        if ( mayHaveBackrefs )
        {
            mayHaveBackrefs = false;
            textNew.clear();
            textNew.reserve(replacement.length());

            for ( const wxChar *p = replacement.c_str(); *p; p++ )
            {
                size_t index = (size_t)-1;

                if ( *p == _T('\\') )
                {
                    if ( wxIsdigit(*++p) )
                    {
                        // back reference
                        wxChar *end;
                        index = (size_t)wxStrtoul(p, &end, 10);
                        p = end - 1; // -1 to compensate for p++ in the loop
                    }
                    //else: backslash used as escape character
                }
                else if ( *p == _T('&') )
                {
                    // treat this as "\0" for compatbility with ed and such
                    index = 0;
                }

                // do we have a back reference?
                if ( index != (size_t)-1 )
                {
                    // yes, get its text
                    size_t start, len;
                    if ( !GetMatch(&start, &len, index) )
                    {
                        wxFAIL_MSG( _T("invalid back reference") );

                        // just eat it...
                    }
                    else
                    {
                        textNew += wxString(textstr + matchStart + start,
                                            *wxConvCurrent, len);

                        mayHaveBackrefs = true;
                    }
                }
                else // ordinary character
                {
                    textNew += *p;
                }
            }
        }

        size_t start, len;
        if ( !GetMatch(&start, &len) )
        {
            // we did have match as Matches() returned true above!
            wxFAIL_MSG( _T("internal logic error in wxRegEx::Replace") );

            return wxNOT_FOUND;
        }

        // an insurance against implementations that don't grow exponentially
        // to ensure building the result takes linear time
        if (result.capacity() < result.length() + start + textNew.length())
            result.reserve(2 * result.length());

#ifndef WXREGEX_CONVERT_TO_MB
        result.append(*text, matchStart, start);
#else
        result.append(wxString(textstr + matchStart, *wxConvCurrent, start));
#endif
        matchStart += start;
        result.append(textNew);

        countRepl++;

        matchStart += len;
    }

#ifndef WXREGEX_CONVERT_TO_MB
    result.append(*text, matchStart, wxString::npos);
#else
    result.append(wxString(textstr + matchStart, *wxConvCurrent));
#endif
    *text = result;

    return countRepl;
}

// ----------------------------------------------------------------------------
// wxRegEx: all methods are mostly forwarded to wxRegExImpl
// ----------------------------------------------------------------------------

void wxRegEx::Init()
{
    m_impl = NULL;
}

wxRegEx::~wxRegEx()
{
    delete m_impl;
}

bool wxRegEx::Compile(const wxString& expr, int flags)
{
    if ( !m_impl )
    {
        m_impl = new wxRegExImpl;
    }

    if ( !m_impl->Compile(expr, flags) )
    {
        // error message already given in wxRegExImpl::Compile
        delete m_impl;
        m_impl = NULL;

        return false;
    }

    return true;
}

bool wxRegEx::Matches(const wxChar *str, int flags, size_t len) const
{
    wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );
    (void)len;

    return m_impl->Matches(WXREGEX_CHAR(str), flags WXREGEX_IF_NEED_LEN(len));
}

bool wxRegEx::Matches(const wxChar *str, int flags) const
{
    wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );

    return m_impl->Matches(WXREGEX_CHAR(str),
                           flags
                           WXREGEX_IF_NEED_LEN(wxStrlen(str)));
}

bool wxRegEx::GetMatch(size_t *start, size_t *len, size_t index) const
{
    wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );

    return m_impl->GetMatch(start, len, index);
}

wxString wxRegEx::GetMatch(const wxString& text, size_t index) const
{
    size_t start, len;
    if ( !GetMatch(&start, &len, index) )
        return wxEmptyString;

    return text.Mid(start, len);
}

size_t wxRegEx::GetMatchCount() const
{
    wxCHECK_MSG( IsValid(), 0, _T("must successfully Compile() first") );

    return m_impl->GetMatchCount();
}

int wxRegEx::Replace(wxString *pattern,
                     const wxString& replacement,
                     size_t maxMatches) const
{
    wxCHECK_MSG( IsValid(), wxNOT_FOUND, _T("must successfully Compile() first") );

    return m_impl->Replace(pattern, replacement, maxMatches);
}

#endif // wxUSE_REGEX
1	william	31	///////////////////////////////////////////////////////////////////////////////
2			// Name: src/common/regex.cpp
3			// Purpose: regular expression matching
4			// Author: Karsten Ballueder and Vadim Zeitlin
5			// Modified by:
6			// Created: 13.07.01
7			// RCS-ID: $Id: regex.cpp 57779 2009-01-02 17:35:16Z PC $
8			// Copyright: (c) 2000 Karsten Ballueder <ballueder@gmx.net>
9			// 2001 Vadim Zeitlin <vadim@wxwindows.org>
10			// Licence: wxWindows licence
11			///////////////////////////////////////////////////////////////////////////////
12
13			// ============================================================================
14			// declarations
15			// ============================================================================
16
17			// ----------------------------------------------------------------------------
18			// headers
19			// ----------------------------------------------------------------------------
20
21			// For compilers that support precompilation, includes "wx.h".
22			#include "wx/wxprec.h"
23
24			#ifdef __BORLANDC__
25			#pragma hdrstop
26			#endif
27
28			#if wxUSE_REGEX
29
30			#include "wx/regex.h"
31
32			#ifndef WX_PRECOMP
33			#include "wx/object.h"
34			#include "wx/log.h"
35			#include "wx/intl.h"
36			#endif //WX_PRECOMP
37
38			// FreeBSD, Watcom and DMars require this, CW doesn't have nor need it.
39			// Others also don't seem to need it. If you have an error related to
40			// (not) including <sys/types.h> please report details to
41			// wx-dev@lists.wxwindows.org
42			#if defined(__UNIX__) \|\| defined(__WATCOMC__) \|\| defined(__DIGITALMARS__)
43			# include <sys/types.h>
44			#endif
45
46			#include <regex.h>
47
48			// WXREGEX_USING_BUILTIN defined when using the built-in regex lib
49			// WXREGEX_USING_RE_SEARCH defined when using re_search in the GNU regex lib
50			// WXREGEX_IF_NEED_LEN() wrap the len parameter only used with the built-in
51			// or GNU regex
52			// WXREGEX_CONVERT_TO_MB defined when the regex lib is using chars and
53			// wxChar is wide, so conversion must be done
54			// WXREGEX_CHAR(x) Convert wxChar to wxRegChar
55			//
56			#ifdef __REG_NOFRONT
57			# define WXREGEX_USING_BUILTIN
58			# define WXREGEX_IF_NEED_LEN(x) ,x
59			# define WXREGEX_CHAR(x) x
60			#else
61			# ifdef HAVE_RE_SEARCH
62			# define WXREGEX_IF_NEED_LEN(x) ,x
63			# define WXREGEX_USING_RE_SEARCH
64			# else
65			# define WXREGEX_IF_NEED_LEN(x)
66			# endif
67			# if wxUSE_UNICODE
68			# define WXREGEX_CONVERT_TO_MB
69			# endif
70			# define WXREGEX_CHAR(x) wxConvertWX2MB(x)
71			# define wx_regfree regfree
72			# define wx_regerror regerror
73			#endif
74
75			// ----------------------------------------------------------------------------
76			// private classes
77			// ----------------------------------------------------------------------------
78
79			#ifndef WXREGEX_USING_RE_SEARCH
80
81			// the array of offsets for the matches, the usual POSIX regmatch_t array.
82			class wxRegExMatches
83			{
84			public:
85			typedef regmatch_t *match_type;
86
87			wxRegExMatches(size_t n) { m_matches = new regmatch_t[n]; }
88			~wxRegExMatches() { delete [] m_matches; }
89
90			// we just use casts here because the fields of regmatch_t struct may be 64
91			// bit but we're limited to size_t in our public API and are not going to
92			// change it because operating on strings longer than 4GB using it is
93			// absolutely impractical anyhow
94			size_t Start(size_t n) const
95			{
96			return wx_truncate_cast(size_t, m_matches[n].rm_so);
97			}
98
99			size_t End(size_t n) const
100			{
101			return wx_truncate_cast(size_t, m_matches[n].rm_eo);
102			}
103
104			regmatch_t *get() const { return m_matches; }
105
106			private:
107			regmatch_t *m_matches;
108			};
109
110			#else // WXREGEX_USING_RE_SEARCH
111
112			// the array of offsets for the matches, the struct used by the GNU lib
113			class wxRegExMatches
114			{
115			public:
116			typedef re_registers *match_type;
117
118			wxRegExMatches(size_t n)
119			{
120			m_matches.num_regs = n;
121			m_matches.start = new regoff_t[n];
122			m_matches.end = new regoff_t[n];
123			}
124
125			~wxRegExMatches()
126			{
127			delete [] m_matches.start;
128			delete [] m_matches.end;
129			}
130
131			size_t Start(size_t n) const { return m_matches.start[n]; }
132			size_t End(size_t n) const { return m_matches.end[n]; }
133
134			re_registers *get() { return &m_matches; }
135
136			private:
137			re_registers m_matches;
138			};
139
140			#endif // WXREGEX_USING_RE_SEARCH
141
142			// the character type used by the regular expression engine
143			#ifndef WXREGEX_CONVERT_TO_MB
144			typedef wxChar wxRegChar;
145			#else
146			typedef char wxRegChar;
147			#endif
148
149			// the real implementation of wxRegEx
150			class wxRegExImpl
151			{
152			public:
153			// ctor and dtor
154			wxRegExImpl();
155			~wxRegExImpl();
156
157			// return true if Compile() had been called successfully
158			bool IsValid() const { return m_isCompiled; }
159
160			// RE operations
161			bool Compile(const wxString& expr, int flags = 0);
162			bool Matches(const wxRegChar *str, int flags
163			WXREGEX_IF_NEED_LEN(size_t len)) const;
164			bool GetMatch(size_t start, size_t len, size_t index = 0) const;
165			size_t GetMatchCount() const;
166			int Replace(wxString *pattern, const wxString& replacement,
167			size_t maxMatches = 0) const;
168
169			private:
170			// return the string containing the error message for the given err code
171			wxString GetErrorMsg(int errorcode, bool badconv) const;
172
173			// init the members
174			void Init()
175			{
176			m_isCompiled = false;
177			m_Matches = NULL;
178			m_nMatches = 0;
179			}
180
181			// free the RE if compiled
182			void Free()
183			{
184			if ( IsValid() )
185			{
186			wx_regfree(&m_RegEx);
187			}
188
189			delete m_Matches;
190			}
191
192			// free the RE if any and reinit the members
193			void Reinit()
194			{
195			Free();
196			Init();
197			}
198
199			// compiled RE
200			regex_t m_RegEx;
201
202			// the subexpressions data
203			wxRegExMatches *m_Matches;
204			size_t m_nMatches;
205
206			// true if m_RegEx is valid
207			bool m_isCompiled;
208			};
209
210
211			// ============================================================================
212			// implementation
213			// ============================================================================
214
215			// ----------------------------------------------------------------------------
216			// wxRegExImpl
217			// ----------------------------------------------------------------------------
218
219			wxRegExImpl::wxRegExImpl()
220			{
221			Init();
222			}
223
224			wxRegExImpl::~wxRegExImpl()
225			{
226			Free();
227			}
228
229			wxString wxRegExImpl::GetErrorMsg(int errorcode, bool badconv) const
230			{
231			#ifdef WXREGEX_CONVERT_TO_MB
232			// currently only needed when using system library in Unicode mode
233			if ( badconv )
234			{
235			return _("conversion to 8-bit encoding failed");
236			}
237			#else
238			// 'use' badconv to avoid a compiler warning
239			(void)badconv;
240			#endif
241
242			wxString szError;
243
244			// first get the string length needed
245			int len = wx_regerror(errorcode, &m_RegEx, NULL, 0);
246			if ( len > 0 )
247			{
248			char* szcmbError = new char[++len];
249
250			(void)wx_regerror(errorcode, &m_RegEx, szcmbError, len);
251
252			szError = wxConvertMB2WX(szcmbError);
253			delete [] szcmbError;
254			}
255			else // regerror() returned 0
256			{
257			szError = _("unknown error");
258			}
259
260			return szError;
261			}
262
263			bool wxRegExImpl::Compile(const wxString& expr, int flags)
264			{
265			Reinit();
266
267			#ifdef WX_NO_REGEX_ADVANCED
268			# define FLAVORS wxRE_BASIC
269			#else
270			# define FLAVORS (wxRE_ADVANCED \| wxRE_BASIC)
271			wxASSERT_MSG( (flags & FLAVORS) != FLAVORS,
272			_T("incompatible flags in wxRegEx::Compile") );
273			#endif
274			wxASSERT_MSG( !(flags & ~(FLAVORS \| wxRE_ICASE \| wxRE_NOSUB \| wxRE_NEWLINE)),
275			_T("unrecognized flags in wxRegEx::Compile") );
276
277			// translate our flags to regcomp() ones
278			int flagsRE = 0;
279			if ( !(flags & wxRE_BASIC) )
280			{
281			#ifndef WX_NO_REGEX_ADVANCED
282			if (flags & wxRE_ADVANCED)
283			flagsRE \|= REG_ADVANCED;
284			else
285			#endif
286			flagsRE \|= REG_EXTENDED;
287			}
288
289			if ( flags & wxRE_ICASE )
290			flagsRE \|= REG_ICASE;
291			if ( flags & wxRE_NOSUB )
292			flagsRE \|= REG_NOSUB;
293			if ( flags & wxRE_NEWLINE )
294			flagsRE \|= REG_NEWLINE;
295
296			// compile it
297			#ifdef WXREGEX_USING_BUILTIN
298			bool conv = true;
299			int errorcode = wx_re_comp(&m_RegEx, expr, expr.length(), flagsRE);
300			#else
301			const wxWX2MBbuf conv = expr.mbc_str();
302			int errorcode = conv ? regcomp(&m_RegEx, conv, flagsRE) : REG_BADPAT;
303			#endif
304
305			if ( errorcode )
306			{
307			wxLogError(_("Invalid regular expression '%s': %s"),
308			expr.c_str(), GetErrorMsg(errorcode, !conv).c_str());
309
310			m_isCompiled = false;
311			}
312			else // ok
313			{
314			// don't allocate the matches array now, but do it later if necessary
315			if ( flags & wxRE_NOSUB )
316			{
317			// we don't need it at all
318			m_nMatches = 0;
319			}
320			else
321			{
322			// we will alloc the array later (only if really needed) but count
323			// the number of sub-expressions in the regex right now
324
325			// there is always one for the whole expression
326			m_nMatches = 1;
327
328			// and some more for bracketed subexperessions
329			for ( const wxChar cptr = expr.c_str(); cptr; cptr++ )
330			{
331			if ( *cptr == _T('\\') )
332			{
333			// in basic RE syntax groups are inside \(...\)
334			if ( *++cptr == _T('(') && (flags & wxRE_BASIC) )
335			{
336			m_nMatches++;
337			}
338			}
339			else if ( *cptr == _T('(') && !(flags & wxRE_BASIC) )
340			{
341			// we know that the previous character is not an unquoted
342			// backslash because it would have been eaten above, so we
343			// have a bare '(' and this indicates a group start for the
344			// extended syntax. '(?' is used for extensions by perl-
345			// like REs (e.g. advanced), and is not valid for POSIX
346			// extended, so ignore them always.
347			if ( cptr[1] != _T('?') )
348			m_nMatches++;
349			}
350			}
351			}
352
353			m_isCompiled = true;
354			}
355
356			return IsValid();
357			}
358
359			#ifdef WXREGEX_USING_RE_SEARCH
360
361			// On GNU, regexec is implemented as a wrapper around re_search. re_search
362			// requires a length parameter which the POSIX regexec does not have,
363			// therefore regexec must do a strlen on the search text each time it is
364			// called. This can drastically affect performance when matching is done in
365			// a loop along a string, such as during a search and replace. Therefore if
366			// re_search is detected by configure, it is used directly.
367			//
368			static int ReSearch(const regex_t *preg,
369			const char *text,
370			size_t len,
371			re_registers *matches,
372			int eflags)
373			{
374			regex_t pattern = wx_const_cast(regex_t, preg);
375
376			pattern->not_bol = (eflags & REG_NOTBOL) != 0;
377			pattern->not_eol = (eflags & REG_NOTEOL) != 0;
378			pattern->regs_allocated = REGS_FIXED;
379
380			int ret = re_search(pattern, text, len, 0, len, matches);
381			return ret >= 0 ? 0 : REG_NOMATCH;
382			}
383
384			#endif // WXREGEX_USING_RE_SEARCH
385
386			bool wxRegExImpl::Matches(const wxRegChar *str,
387			int flags
388			WXREGEX_IF_NEED_LEN(size_t len)) const
389			{
390			wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );
391
392			// translate our flags to regexec() ones
393			wxASSERT_MSG( !(flags & ~(wxRE_NOTBOL \| wxRE_NOTEOL)),
394			_T("unrecognized flags in wxRegEx::Matches") );
395
396			int flagsRE = 0;
397			if ( flags & wxRE_NOTBOL )
398			flagsRE \|= REG_NOTBOL;
399			if ( flags & wxRE_NOTEOL )
400			flagsRE \|= REG_NOTEOL;
401
402			// allocate matches array if needed
403			wxRegExImpl *self = wxConstCast(this, wxRegExImpl);
404			if ( !m_Matches && m_nMatches )
405			{
406			self->m_Matches = new wxRegExMatches(m_nMatches);
407			}
408
409			wxRegExMatches::match_type matches = m_Matches ? m_Matches->get() : NULL;
410
411			// do match it
412			#if defined WXREGEX_USING_BUILTIN
413			int rc = wx_re_exec(&self->m_RegEx, str, len, NULL, m_nMatches, matches, flagsRE);
414			#elif defined WXREGEX_USING_RE_SEARCH
415			int rc = str ? ReSearch(&self->m_RegEx, str, len, matches, flagsRE) : REG_BADPAT;
416			#else
417			int rc = str ? regexec(&self->m_RegEx, str, m_nMatches, matches, flagsRE) : REG_BADPAT;
418			#endif
419
420			switch ( rc )
421			{
422			case 0:
423			// matched successfully
424			return true;
425
426			default:
427			// an error occurred
428			wxLogError(_("Failed to find match for regular expression: %s"),
429			GetErrorMsg(rc, !str).c_str());
430			// fall through
431
432			case REG_NOMATCH:
433			// no match
434			return false;
435			}
436			}
437
438			bool wxRegExImpl::GetMatch(size_t start, size_t len, size_t index) const
439			{
440			wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );
441			wxCHECK_MSG( m_nMatches, false, _T("can't use with wxRE_NOSUB") );
442			wxCHECK_MSG( m_Matches, false, _T("must call Matches() first") );
443			wxCHECK_MSG( index < m_nMatches, false, _T("invalid match index") );
444
445			if ( start )
446			*start = m_Matches->Start(index);
447			if ( len )
448			*len = m_Matches->End(index) - m_Matches->Start(index);
449
450			return true;
451			}
452
453			size_t wxRegExImpl::GetMatchCount() const
454			{
455			wxCHECK_MSG( IsValid(), 0, _T("must successfully Compile() first") );
456			wxCHECK_MSG( m_nMatches, 0, _T("can't use with wxRE_NOSUB") );
457
458			return m_nMatches;
459			}
460
461			int wxRegExImpl::Replace(wxString *text,
462			const wxString& replacement,
463			size_t maxMatches) const
464			{
465			wxCHECK_MSG( text, wxNOT_FOUND, _T("NULL text in wxRegEx::Replace") );
466			wxCHECK_MSG( IsValid(), wxNOT_FOUND, _T("must successfully Compile() first") );
467
468			// the input string
469			#ifndef WXREGEX_CONVERT_TO_MB
470			const wxChar *textstr = text->c_str();
471			size_t textlen = text->length();
472			#else
473			const wxWX2MBbuf textstr = WXREGEX_CHAR(*text);
474			if (!textstr)
475			{
476			wxLogError(_("Failed to find match for regular expression: %s"),
477			GetErrorMsg(0, true).c_str());
478			return 0;
479			}
480			size_t textlen = strlen(textstr);
481			text->clear();
482			#endif
483
484			// the replacement text
485			wxString textNew;
486
487			// the result, allow 25% extra
488			wxString result;
489			result.reserve(5 * textlen / 4);
490
491			// attempt at optimization: don't iterate over the string if it doesn't
492			// contain back references at all
493			bool mayHaveBackrefs =
494			replacement.find_first_of(_T("\\&")) != wxString::npos;
495
496			if ( !mayHaveBackrefs )
497			{
498			textNew = replacement;
499			}
500
501			// the position where we start looking for the match
502			size_t matchStart = 0;
503
504			// number of replacement made: we won't make more than maxMatches of them
505			// (unless maxMatches is 0 which doesn't limit the number of replacements)
506			size_t countRepl = 0;
507
508			// note that "^" shouldn't match after the first call to Matches() so we
509			// use wxRE_NOTBOL to prevent it from happening
510			while ( (!maxMatches \|\| countRepl < maxMatches) &&
511			Matches(textstr + matchStart,
512			countRepl ? wxRE_NOTBOL : 0
513			WXREGEX_IF_NEED_LEN(textlen - matchStart)) )
514			{
515			// the string possibly contains back references: we need to calculate
516			// the replacement text anew after each match
517			if ( mayHaveBackrefs )
518			{
519			mayHaveBackrefs = false;
520			textNew.clear();
521			textNew.reserve(replacement.length());
522
523			for ( const wxChar p = replacement.c_str(); p; p++ )
524			{
525			size_t index = (size_t)-1;
526
527			if ( *p == _T('\\') )
528			{
529			if ( wxIsdigit(*++p) )
530			{
531			// back reference
532			wxChar *end;
533			index = (size_t)wxStrtoul(p, &end, 10);
534			p = end - 1; // -1 to compensate for p++ in the loop
535			}
536			//else: backslash used as escape character
537			}
538			else if ( *p == _T('&') )
539			{
540			// treat this as "\0" for compatbility with ed and such
541			index = 0;
542			}
543
544			// do we have a back reference?
545			if ( index != (size_t)-1 )
546			{
547			// yes, get its text
548			size_t start, len;
549			if ( !GetMatch(&start, &len, index) )
550			{
551			wxFAIL_MSG( _T("invalid back reference") );
552
553			// just eat it...
554			}
555			else
556			{
557			textNew += wxString(textstr + matchStart + start,
558			*wxConvCurrent, len);
559
560			mayHaveBackrefs = true;
561			}
562			}
563			else // ordinary character
564			{
565			textNew += *p;
566			}
567			}
568			}
569
570			size_t start, len;
571			if ( !GetMatch(&start, &len) )
572			{
573			// we did have match as Matches() returned true above!
574			wxFAIL_MSG( _T("internal logic error in wxRegEx::Replace") );
575
576			return wxNOT_FOUND;
577			}
578
579			// an insurance against implementations that don't grow exponentially
580			// to ensure building the result takes linear time
581			if (result.capacity() < result.length() + start + textNew.length())
582			result.reserve(2 * result.length());
583
584			#ifndef WXREGEX_CONVERT_TO_MB
585			result.append(*text, matchStart, start);
586			#else
587			result.append(wxString(textstr + matchStart, *wxConvCurrent, start));
588			#endif
589			matchStart += start;
590			result.append(textNew);
591
592			countRepl++;
593
594			matchStart += len;
595			}
596
597			#ifndef WXREGEX_CONVERT_TO_MB
598			result.append(*text, matchStart, wxString::npos);
599			#else
600			result.append(wxString(textstr + matchStart, *wxConvCurrent));
601			#endif
602			*text = result;
603
604			return countRepl;
605			}
606
607			// ----------------------------------------------------------------------------
608			// wxRegEx: all methods are mostly forwarded to wxRegExImpl
609			// ----------------------------------------------------------------------------
610
611			void wxRegEx::Init()
612			{
613			m_impl = NULL;
614			}
615
616			wxRegEx::~wxRegEx()
617			{
618			delete m_impl;
619			}
620
621			bool wxRegEx::Compile(const wxString& expr, int flags)
622			{
623			if ( !m_impl )
624			{
625			m_impl = new wxRegExImpl;
626			}
627
628			if ( !m_impl->Compile(expr, flags) )
629			{
630			// error message already given in wxRegExImpl::Compile
631			delete m_impl;
632			m_impl = NULL;
633
634			return false;
635			}
636
637			return true;
638			}
639
640			bool wxRegEx::Matches(const wxChar *str, int flags, size_t len) const
641			{
642			wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );
643			(void)len;
644
645			return m_impl->Matches(WXREGEX_CHAR(str), flags WXREGEX_IF_NEED_LEN(len));
646			}
647
648			bool wxRegEx::Matches(const wxChar *str, int flags) const
649			{
650			wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );
651
652			return m_impl->Matches(WXREGEX_CHAR(str),
653			flags
654			WXREGEX_IF_NEED_LEN(wxStrlen(str)));
655			}
656
657			bool wxRegEx::GetMatch(size_t start, size_t len, size_t index) const
658			{
659			wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );
660
661			return m_impl->GetMatch(start, len, index);
662			}
663
664			wxString wxRegEx::GetMatch(const wxString& text, size_t index) const
665			{
666			size_t start, len;
667			if ( !GetMatch(&start, &len, index) )
668			return wxEmptyString;
669
670			return text.Mid(start, len);
671			}
672
673			size_t wxRegEx::GetMatchCount() const
674			{
675			wxCHECK_MSG( IsValid(), 0, _T("must successfully Compile() first") );
676
677			return m_impl->GetMatchCount();
678			}
679
680			int wxRegEx::Replace(wxString *pattern,
681			const wxString& replacement,
682			size_t maxMatches) const
683			{
684			wxCHECK_MSG( IsValid(), wxNOT_FOUND, _T("must successfully Compile() first") );
685
686			return m_impl->Replace(pattern, replacement, maxMatches);
687			}
688
689			#endif // wxUSE_REGEX