Add a length parameter for wxRegEx::Matches

[wxWidgets.git] / src / common / regex.cpp

diff --git a/src/common/regex.cpp b/src/common/regex.cpp
index 7d0efb3acc36c9fb8ad650b083b4723996b7a3fe..b3c78820df665642030a410f1f5d7687bf6f1b0c 100644 (file)
--- a/src/common/regex.cpp
+++ b/src/common/regex.cpp
@@ -18,10 +18,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "regex.h"
-#endif
-

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


@@ -46,15 +42,20 @@
 #   include <sys/types.h>
 #endif
 
 #   include <sys/types.h>
 #endif
 

-#ifndef __WXWINCE__

 #include <regex.h>
 #include <regex.h>

-#endif
-

 #include "wx/regex.h"
 
 #include "wx/regex.h"
 

-#if wxUSE_UNICODE
-#   if !defined(wxUSE_BUILTIN_REGEX)
-#       error "Unicode not supported with system regex, please reconfigure with --with-regex=builtin"
+// WXREGEX_USING_BUILTIN  defined when using the built-in regex lib
+// WXREGEX_BUILTIN_ONLY() wrap a parameter only used with the built-in regex
+// WXREGEX_CONVERT_TO_MB  indicates when the regex lib is using chars and
+//                        wxChar is wide, so conversion must be done
+#ifdef __REG_NOFRONT
+#   define WXREGEX_USING_BUILTIN
+#   define WXREGEX_BUILTIN_ONLY(x) ,x
+#else
+#   define WXREGEX_BUILTIN_ONLY(x)
+#   if wxUSE_UNICODE
+#       define WXREGEX_CONVERT_TO_MB

 #   endif
 #endif
 
 #   endif
 #endif
 


@@ -62,6 +63,13 @@
 // private classes
 // ----------------------------------------------------------------------------
 
 // private classes
 // ----------------------------------------------------------------------------
 

+// 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
 {
 // the real implementation of wxRegEx
 class wxRegExImpl
 {


@@ -70,24 +78,26 @@ public:
     wxRegExImpl();
     ~wxRegExImpl();
 
     wxRegExImpl();
     ~wxRegExImpl();
 

-    // return TRUE if Compile() had been called successfully
+    // 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 IsValid() const { return m_isCompiled; }
 
     // RE operations
     bool Compile(const wxString& expr, int flags = 0);

-    bool Matches(const wxChar *str, int flags = 0) const;
+    bool Matches(const wxRegChar *str, int flags
+                 WXREGEX_BUILTIN_ONLY(size_t len)) const;

     bool GetMatch(size_t *start, size_t *len, size_t index = 0) 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
     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) const;
+    wxString GetErrorMsg(int errorcode, bool badconv) const;

 
     // init the members
     void Init()
     {
 
     // init the members
     void Init()
     {

-        m_isCompiled = FALSE;
+        m_isCompiled = false;

         m_Matches = NULL;
         m_nMatches = 0;
     }
         m_Matches = NULL;
         m_nMatches = 0;
     }


@@ -118,7 +128,7 @@ private:
     regmatch_t *m_Matches;
     size_t      m_nMatches;
 
     regmatch_t *m_Matches;
     size_t      m_nMatches;
 

-    // TRUE if m_RegEx is valid
+    // true if m_RegEx is valid

     bool        m_isCompiled;
 };
 
     bool        m_isCompiled;
 };
 


@@ -140,8 +150,19 @@ wxRegExImpl::~wxRegExImpl()
     Free();
 }
 
     Free();
 }
 

-wxString wxRegExImpl::GetErrorMsg(int errorcode) const
+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
     wxString szError;
 
     // first get the string length needed


@@ -167,14 +188,25 @@ bool wxRegExImpl::Compile(const wxString& expr, int flags)
 {
     Reinit();
 
 {
     Reinit();
 

-    // translate our flags to regcomp() ones
-    wxASSERT_MSG( !(flags &
-                        ~(wxRE_BASIC | wxRE_ICASE | wxRE_NOSUB | wxRE_NEWLINE)),
+#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") );
 
                   _T("unrecognized flags in wxRegEx::Compile") );
 

+    // translate our flags to regcomp() ones

     int flagsRE = 0;
     if ( !(flags & wxRE_BASIC) )
     int flagsRE = 0;
     if ( !(flags & wxRE_BASIC) )

-        flagsRE |= REG_EXTENDED;
+#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 )
     if ( flags & wxRE_ICASE )
         flagsRE |= REG_ICASE;
     if ( flags & wxRE_NOSUB )


@@ -182,16 +214,21 @@ bool wxRegExImpl::Compile(const wxString& expr, int flags)
     if ( flags & wxRE_NEWLINE )
         flagsRE |= REG_NEWLINE;
 
     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

 
 

-
-    int errorcode = regcomp(&m_RegEx, expr, flagsRE);
-
-     if ( errorcode )
+    if ( errorcode )

     {
         wxLogError(_("Invalid regular expression '%s': %s"),
     {
         wxLogError(_("Invalid regular expression '%s': %s"),

-                   expr.c_str(), GetErrorMsg(errorcode).c_str());
+                   expr.c_str(), GetErrorMsg(errorcode, !conv).c_str());

 
 

-        m_isCompiled = FALSE;
+        m_isCompiled = false;

     }
     else // ok
     {
     }
     else // ok
     {


@@ -224,22 +261,27 @@ bool wxRegExImpl::Compile(const wxString& expr, int flags)
                 {
                     // we know that the previous character is not an unquoted
                     // backslash because it would have been eaten above, so we
                 {
                     // we know that the previous character is not an unquoted
                     // backslash because it would have been eaten above, so we

-                    // have a bar '(' and this indicates a group start for the
-                    // extended syntax
-                    m_nMatches++;
+                    // 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;
+        m_isCompiled = true;

     }
 
     return IsValid();
 }
 
     }
 
     return IsValid();
 }
 

-bool wxRegExImpl::Matches(const wxChar *str, int flags) const
+bool wxRegExImpl::Matches(const wxRegChar *str,
+                          int flags
+                          WXREGEX_BUILTIN_ONLY(size_t len)) const

 {
 {

-    wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
+    wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );

 
     // translate our flags to regexec() ones
     wxASSERT_MSG( !(flags & ~(wxRE_NOTBOL | wxRE_NOTEOL)),
 
     // translate our flags to regexec() ones
     wxASSERT_MSG( !(flags & ~(wxRE_NOTBOL | wxRE_NOTEOL)),


@@ -259,52 +301,86 @@ bool wxRegExImpl::Matches(const wxChar *str, int flags) const
     }
 
     // do match it
     }
 
     // do match it

-    int rc = regexec(&self->m_RegEx, str, m_nMatches, m_Matches, flagsRE);
+#ifdef WXREGEX_USING_BUILTIN
+    int rc = wx_re_exec(&self->m_RegEx, str, len, NULL, m_nMatches, m_Matches, flagsRE);
+#else
+    int rc = str ? regexec(&self->m_RegEx, str, m_nMatches, m_Matches, flagsRE) : REG_BADPAT;
+#endif

 
     switch ( rc )
     {
         case 0:
             // matched successfully
 
     switch ( rc )
     {
         case 0:
             // matched successfully

-            return TRUE;
+            return true;

 
         default:
 
         default:

-            // an error occured
-            wxLogError(_("Failed to match '%s' in regular expression: %s"),
-                       str, GetErrorMsg(rc).c_str());
+            // an error occurred
+            wxLogError(_("Failed to find match for regular expression: %s"),
+                       GetErrorMsg(rc, !str).c_str());

             // fall through
 
         case REG_NOMATCH:
             // no match
             // fall through
 
         case REG_NOMATCH:
             // no match

-            return FALSE;
+            return false;

     }
 }
 
 bool wxRegExImpl::GetMatch(size_t *start, size_t *len, size_t index) const
 {
     }
 }
 
 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_Matches, FALSE, _T("can't use with wxRE_NOSUB") );
-    wxCHECK_MSG( index < m_nMatches, FALSE, _T("invalid match index") );
+    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") );

 
     const regmatch_t& match = m_Matches[index];
 
 
     const regmatch_t& match = m_Matches[index];
 

+    // we need the casts because rm_so can be a 64 bit quantity

     if ( start )
     if ( start )

-        *start = match.rm_so;
+        *start = wx_truncate_cast(size_t, match.rm_so);

     if ( len )
     if ( len )

-        *len = match.rm_eo - match.rm_so;
+        *len = wx_truncate_cast(size_t, match.rm_eo - match.rm_so);

 
 

-    return TRUE;
+    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
 {
 }
 
 int wxRegExImpl::Replace(wxString *text,
                          const wxString& replacement,
                          size_t maxMatches) const
 {

-    wxCHECK_MSG( text, -1, _T("NULL text in wxRegEx::Replace") );
-    wxCHECK_MSG( IsValid(), -1, _T("must successfully Compile() first") );
+    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 = wxConvertWX2MB(*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 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 =
     // attempt at optimization: don't iterate over the string if it doesn't
     // contain back references at all
     bool mayHaveBackrefs =


@@ -316,10 +392,6 @@ int wxRegExImpl::Replace(wxString *text,
     }
 
     // the position where we start looking for the match
     }
 
     // the position where we start looking for the match

-    //
-    // NB: initial version had a nasty bug because it used a wxChar* instead of
-    //     an index but the problem is that replace() in the loop invalidates
-    //     all pointers into the string so we have to use indices instead

     size_t matchStart = 0;
 
     // number of replacement made: we won't make more than maxMatches of them
     size_t matchStart = 0;
 
     // number of replacement made: we won't make more than maxMatches of them


@@ -329,13 +401,15 @@ int wxRegExImpl::Replace(wxString *text,
     // 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) &&
     // 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(text->c_str() + matchStart, countRepl ? wxRE_NOTBOL : 0) )
+            Matches(textstr + matchStart,
+                    countRepl ? wxRE_NOTBOL : 0
+                    WXREGEX_BUILTIN_ONLY(textlen - matchStart)) )

     {
         // the string possibly contains back references: we need to calculate
         // the replacement text anew after each match
         if ( mayHaveBackrefs )
         {
     {
         // the string possibly contains back references: we need to calculate
         // the replacement text anew after each match
         if ( mayHaveBackrefs )
         {

-            mayHaveBackrefs = FALSE;
+            mayHaveBackrefs = false;

             textNew.clear();
             textNew.reserve(replacement.length());
 
             textNew.clear();
             textNew.reserve(replacement.length());
 


@@ -373,10 +447,10 @@ int wxRegExImpl::Replace(wxString *text,
                     }
                     else
                     {
                     }
                     else
                     {

-                        textNew += wxString(text->c_str() + matchStart + start,
-                                            len);
+                        textNew += wxString(textstr + matchStart + start,
+                                            *wxConvCurrent, len);

 
 

-                        mayHaveBackrefs = TRUE;
+                        mayHaveBackrefs = true;

                     }
                 }
                 else // ordinary character
                     }
                 }
                 else // ordinary character


@@ -392,17 +466,34 @@ int wxRegExImpl::Replace(wxString *text,
             // we did have match as Matches() returned true above!
             wxFAIL_MSG( _T("internal logic error in wxRegEx::Replace") );
 
             // we did have match as Matches() returned true above!
             wxFAIL_MSG( _T("internal logic error in wxRegEx::Replace") );
 

-            return -1;
+            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;
         matchStart += start;

-        text->replace(matchStart, len, textNew);
+        result.append(textNew);

 
         countRepl++;
 
 
         countRepl++;
 

-        matchStart += textNew.length();
+        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;
 }
 
     return countRepl;
 }
 


@@ -415,7 +506,6 @@ void wxRegEx::Init()
     m_impl = NULL;
 }
 
     m_impl = NULL;
 }
 

-

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


@@ -434,22 +524,38 @@ bool wxRegEx::Compile(const wxString& expr, int flags)
         delete m_impl;
         m_impl = NULL;
 
         delete m_impl;
         m_impl = NULL;
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    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;
+
+#ifdef WXREGEX_CONVERT_TO_MB
+    return m_impl->Matches(wxConvertWX2MB(str), flags);
+#else
+    return m_impl->Matches(str, flags WXREGEX_BUILTIN_ONLY(len));
+#endif

 }
 
 bool wxRegEx::Matches(const wxChar *str, int flags) const
 {
 }
 
 bool wxRegEx::Matches(const wxChar *str, int flags) const
 {

-    wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
+    wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );

 
 

-    return m_impl->Matches(str, flags);
+#ifdef WXREGEX_CONVERT_TO_MB
+    return m_impl->Matches(wxConvertWX2MB(str), flags);
+#else
+    return m_impl->Matches(str, flags WXREGEX_BUILTIN_ONLY(wxStrlen(str)));
+#endif

 }
 
 bool wxRegEx::GetMatch(size_t *start, size_t *len, size_t index) const
 {
 }
 
 bool wxRegEx::GetMatch(size_t *start, size_t *len, size_t index) const
 {

-    wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
+    wxCHECK_MSG( IsValid(), false, _T("must successfully Compile() first") );

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


@@ -463,11 +569,18 @@ wxString wxRegEx::GetMatch(const wxString& text, size_t index) const
     return text.Mid(start, len);
 }
 
     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
 {
 int wxRegEx::Replace(wxString *pattern,
                      const wxString& replacement,
                      size_t maxMatches) const
 {

-    wxCHECK_MSG( IsValid(), -1, _T("must successfully Compile() first") );
+    wxCHECK_MSG( IsValid(), wxNOT_FOUND, _T("must successfully Compile() first") );

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