fixing osx_cocoa

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

diff --git a/src/common/regex.cpp b/src/common/regex.cpp
index 12c790b915bda22886a24710046025799153179e..4683b81de3965847a03adf4a2f71b830ca840ae7 100644 (file)
--- a/src/common/regex.cpp
+++ b/src/common/regex.cpp
@@ -1,11 +1,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        src/common/regex.cpp
 // Purpose:     regular expression matching
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        src/common/regex.cpp
 // Purpose:     regular expression matching

-// Author:      Karsten Ballüder and Vadim Zeitlin
+// Author:      Karsten Ballueder and Vadim Zeitlin

 // Modified by:
 // Created:     13.07.01
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     13.07.01
 // RCS-ID:      $Id$

-// Copyright:   (c) 2000 Karsten Ballüder <ballueder@gmx.net>
+// Copyright:   (c) 2000 Karsten Ballueder <ballueder@gmx.net>

 //                  2001 Vadim Zeitlin <vadim@wxwindows.org>
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 //                  2001 Vadim Zeitlin <vadim@wxwindows.org>
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////


@@ -27,11 +27,13 @@
 
 #if wxUSE_REGEX
 
 
 #if wxUSE_REGEX
 

+#include "wx/regex.h"
+

 #ifndef WX_PRECOMP
     #include "wx/object.h"
 #ifndef WX_PRECOMP
     #include "wx/object.h"

-    #include "wx/string.h"

     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/log.h"
     #include "wx/intl.h"

+    #include "wx/crt.h"

 #endif //WX_PRECOMP
 
 // FreeBSD, Watcom and DMars require this, CW doesn't have nor need it.
 #endif //WX_PRECOMP
 
 // FreeBSD, Watcom and DMars require this, CW doesn't have nor need it.


@@ -43,36 +45,43 @@
 #endif
 
 #include <regex.h>
 #endif
 
 #include <regex.h>

-#include "wx/regex.h"

 
 

-// WXREGEX_USING_BUILTIN  defined when using the built-in 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
+// 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
 //
 #ifdef __REG_NOFRONT
 #   define WXREGEX_USING_BUILTIN
 #   define WXREGEX_IF_NEED_LEN(x) ,x

-#   define WXREGEX_CHAR(x) x
+#   if wxUSE_UNICODE
+#       define WXREGEX_CHAR(x) (x).wc_str()
+#   else
+#       define WXREGEX_CHAR(x) (x).mb_str()
+#   endif

 #else
 #   ifdef HAVE_RE_SEARCH
 #       define WXREGEX_IF_NEED_LEN(x) ,x
 #else
 #   ifdef HAVE_RE_SEARCH
 #       define WXREGEX_IF_NEED_LEN(x) ,x

-#   else        
+#       define WXREGEX_USING_RE_SEARCH
+#   else

 #       define WXREGEX_IF_NEED_LEN(x)
 #   endif
 #   if wxUSE_UNICODE
 #       define WXREGEX_CONVERT_TO_MB
 #   endif
 #       define WXREGEX_IF_NEED_LEN(x)
 #   endif
 #   if wxUSE_UNICODE
 #       define WXREGEX_CONVERT_TO_MB
 #   endif

-#   define WXREGEX_CHAR(x) wxConvertWX2MB(x)
+#   define WXREGEX_CHAR(x) (x).mb_str()
+#   define wx_regfree regfree
+#   define wx_regerror regerror

 #endif
 
 // ----------------------------------------------------------------------------
 // private classes
 // ----------------------------------------------------------------------------
 
 #endif
 
 // ----------------------------------------------------------------------------
 // private classes
 // ----------------------------------------------------------------------------
 

-#ifndef HAVE_RE_SEARCH
+#ifndef WXREGEX_USING_RE_SEARCH

 
 // the array of offsets for the matches, the usual POSIX regmatch_t array.
 class wxRegExMatches
 
 // the array of offsets for the matches, the usual POSIX regmatch_t array.
 class wxRegExMatches


@@ -80,11 +89,22 @@ class wxRegExMatches
 public:
     typedef regmatch_t *match_type;
 
 public:
     typedef regmatch_t *match_type;
 

-    wxRegExMatches(size_t n)        { m_matches = new regmatch_t[n]; } 
+    wxRegExMatches(size_t n)        { m_matches = new regmatch_t[n]; }

     ~wxRegExMatches()               { delete [] m_matches; }
 
     ~wxRegExMatches()               { delete [] m_matches; }
 

-    size_t Start(size_t n) const    { return m_matches[n].rm_so; }
-    size_t End(size_t n) const      { return m_matches[n].rm_eo; }
+    // 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; }
 
 
     regmatch_t *get() const         { return m_matches; }
 


@@ -92,7 +112,7 @@ private:
     regmatch_t *m_matches;
 };
 
     regmatch_t *m_matches;
 };
 

-#else // HAVE_RE_SEARCH
+#else // WXREGEX_USING_RE_SEARCH

 
 // the array of offsets for the matches, the struct used by the GNU lib
 class wxRegExMatches
 
 // the array of offsets for the matches, the struct used by the GNU lib
 class wxRegExMatches


@@ -122,7 +142,7 @@ private:
     re_registers m_matches;
 };
 
     re_registers m_matches;
 };
 

-#endif // HAVE_RE_SEARCH
+#endif // WXREGEX_USING_RE_SEARCH

 
 // the character type used by the regular expression engine
 #ifndef WXREGEX_CONVERT_TO_MB
 
 // the character type used by the regular expression engine
 #ifndef WXREGEX_CONVERT_TO_MB


@@ -168,7 +188,7 @@ private:
     {
         if ( IsValid() )
         {
     {
         if ( IsValid() )
         {

-            regfree(&m_RegEx);
+            wx_regfree(&m_RegEx);

         }
 
         delete m_Matches;
         }
 
         delete m_Matches;


@@ -227,14 +247,14 @@ wxString wxRegExImpl::GetErrorMsg(int errorcode, bool badconv) const
     wxString szError;
 
     // first get the string length needed
     wxString szError;
 
     // first get the string length needed

-    int len = regerror(errorcode, &m_RegEx, NULL, 0);
+    int len = wx_regerror(errorcode, &m_RegEx, NULL, 0);

     if ( len > 0 )
     {
         char* szcmbError = new char[++len];
 
     if ( len > 0 )
     {
         char* szcmbError = new char[++len];
 

-        (void)regerror(errorcode, &m_RegEx, szcmbError, len);
+        (void)wx_regerror(errorcode, &m_RegEx, szcmbError, len);

 
 

-        szError = wxConvertMB2WX(szcmbError);
+        szError = wxConvLibc.cMB2WX(szcmbError);

         delete [] szcmbError;
     }
     else // regerror() returned 0
         delete [] szcmbError;
     }
     else // regerror() returned 0


@@ -254,20 +274,22 @@ bool wxRegExImpl::Compile(const wxString& expr, int flags)
 #else
 #   define FLAVORS (wxRE_ADVANCED | wxRE_BASIC)
     wxASSERT_MSG( (flags & FLAVORS) != FLAVORS,
 #else
 #   define FLAVORS (wxRE_ADVANCED | wxRE_BASIC)
     wxASSERT_MSG( (flags & FLAVORS) != FLAVORS,

-                  _T("incompatible flags in wxRegEx::Compile") );
+                  wxT("incompatible flags in wxRegEx::Compile") );

 #endif
     wxASSERT_MSG( !(flags & ~(FLAVORS | wxRE_ICASE | wxRE_NOSUB | wxRE_NEWLINE)),
 #endif
     wxASSERT_MSG( !(flags & ~(FLAVORS | wxRE_ICASE | wxRE_NOSUB | wxRE_NEWLINE)),

-                  _T("unrecognized flags in wxRegEx::Compile") );
+                  wxT("unrecognized flags in wxRegEx::Compile") );

 
     // translate our flags to regcomp() ones
     int flagsRE = 0;
     if ( !(flags & wxRE_BASIC) )
 
     // 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;
 #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 )


@@ -278,8 +300,11 @@ bool wxRegExImpl::Compile(const wxString& expr, int flags)
     // compile it
 #ifdef WXREGEX_USING_BUILTIN
     bool conv = true;
     // compile it
 #ifdef WXREGEX_USING_BUILTIN
     bool conv = true;

-    int errorcode = wx_re_comp(&m_RegEx, expr, expr.length(), flagsRE);
+    // FIXME-UTF8: use wc_str() after removing ANSI build
+    int errorcode = wx_re_comp(&m_RegEx, expr.c_str(), expr.length(), flagsRE);

 #else
 #else

+    // FIXME-UTF8: this is potentially broken, we shouldn't even try it
+    //             and should always use builtin regex library (or PCRE?)

     const wxWX2MBbuf conv = expr.mbc_str();
     int errorcode = conv ? regcomp(&m_RegEx, conv, flagsRE) : REG_BADPAT;
 #endif
     const wxWX2MBbuf conv = expr.mbc_str();
     int errorcode = conv ? regcomp(&m_RegEx, conv, flagsRE) : REG_BADPAT;
 #endif


@@ -310,15 +335,15 @@ bool wxRegExImpl::Compile(const wxString& expr, int flags)
             // and some more for bracketed subexperessions
             for ( const wxChar *cptr = expr.c_str(); *cptr; cptr++ )
             {
             // and some more for bracketed subexperessions
             for ( const wxChar *cptr = expr.c_str(); *cptr; cptr++ )
             {

-                if ( *cptr == _T('\\') )
+                if ( *cptr == wxT('\\') )

                 {
                     // in basic RE syntax groups are inside \(...\)
                 {
                     // in basic RE syntax groups are inside \(...\)

-                    if ( *++cptr == _T('(') && (flags & wxRE_BASIC) )
+                    if ( *++cptr == wxT('(') && (flags & wxRE_BASIC) )

                     {
                         m_nMatches++;
                     }
                 }
                     {
                         m_nMatches++;
                     }
                 }

-                else if ( *cptr == _T('(') && !(flags & wxRE_BASIC) )
+                else if ( *cptr == wxT('(') && !(flags & wxRE_BASIC) )

                 {
                     // 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


@@ -326,7 +351,7 @@ bool wxRegExImpl::Compile(const wxString& expr, int flags)
                     // extended syntax. '(?' is used for extensions by perl-
                     // like REs (e.g. advanced), and is not valid for POSIX
                     // extended, so ignore them always.
                     // 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('?') )
+                    if ( cptr[1] != wxT('?') )

                         m_nMatches++;
                 }
             }
                         m_nMatches++;
                 }
             }


@@ -338,7 +363,7 @@ bool wxRegExImpl::Compile(const wxString& expr, int flags)
     return IsValid();
 }
 
     return IsValid();
 }
 

-#ifdef HAVE_RE_SEARCH
+#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,
 
 // On GNU, regexec is implemented as a wrapper around re_search. re_search
 // requires a length parameter which the POSIX regexec does not have,


@@ -353,7 +378,7 @@ static int ReSearch(const regex_t *preg,
                     re_registers *matches,
                     int eflags)
 {
                     re_registers *matches,
                     int eflags)
 {

-    regex_t *pattern = wx_const_cast(regex_t*, preg);
+    regex_t *pattern = const_cast<regex_t*>(preg);

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


@@ -363,17 +388,17 @@ static int ReSearch(const regex_t *preg,
     return ret >= 0 ? 0 : REG_NOMATCH;
 }
 
     return ret >= 0 ? 0 : REG_NOMATCH;
 }
 

-#endif // HAVE_RE_SEARCH
+#endif // WXREGEX_USING_RE_SEARCH

 
 bool wxRegExImpl::Matches(const wxRegChar *str,
                           int flags
                           WXREGEX_IF_NEED_LEN(size_t len)) const
 {
 
 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") );
+    wxCHECK_MSG( IsValid(), false, wxT("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)),

-                  _T("unrecognized flags in wxRegEx::Matches") );
+                  wxT("unrecognized flags in wxRegEx::Matches") );

 
     int flagsRE = 0;
     if ( flags & wxRE_NOTBOL )
 
     int flagsRE = 0;
     if ( flags & wxRE_NOTBOL )


@@ -393,7 +418,7 @@ bool wxRegExImpl::Matches(const wxRegChar *str,
     // do match it
 #if defined WXREGEX_USING_BUILTIN
     int rc = wx_re_exec(&self->m_RegEx, str, len, NULL, m_nMatches, matches, flagsRE);
     // 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 HAVE_RE_SEARCH
+#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;
     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;


@@ -419,10 +444,10 @@ bool wxRegExImpl::Matches(const wxRegChar *str,
 
 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_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") );
+    wxCHECK_MSG( IsValid(), false, wxT("must successfully Compile() first") );
+    wxCHECK_MSG( m_nMatches, false, wxT("can't use with wxRE_NOSUB") );
+    wxCHECK_MSG( m_Matches, false, wxT("must call Matches() first") );
+    wxCHECK_MSG( index < m_nMatches, false, wxT("invalid match index") );

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


@@ -434,8 +459,8 @@ bool wxRegExImpl::GetMatch(size_t *start, size_t *len, size_t index) const
 
 size_t wxRegExImpl::GetMatchCount() const
 {
 
 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") );
+    wxCHECK_MSG( IsValid(), 0, wxT("must successfully Compile() first") );
+    wxCHECK_MSG( m_nMatches, 0, wxT("can't use with wxRE_NOSUB") );

 
     return m_nMatches;
 }
 
     return m_nMatches;
 }


@@ -444,8 +469,8 @@ int wxRegExImpl::Replace(wxString *text,
                          const wxString& replacement,
                          size_t maxMatches) const
 {
                          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") );
+    wxCHECK_MSG( text, wxNOT_FOUND, wxT("NULL text in wxRegEx::Replace") );
+    wxCHECK_MSG( IsValid(), wxNOT_FOUND, wxT("must successfully Compile() first") );

 
     // the input string
 #ifndef WXREGEX_CONVERT_TO_MB
 
     // the input string
 #ifndef WXREGEX_CONVERT_TO_MB


@@ -473,7 +498,7 @@ int wxRegExImpl::Replace(wxString *text,
     // 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 =

-        replacement.find_first_of(_T("\\&")) != wxString::npos;
+        replacement.find_first_of(wxT("\\&")) != wxString::npos;

 
     if ( !mayHaveBackrefs )
     {
 
     if ( !mayHaveBackrefs )
     {


@@ -490,7 +515,12 @@ 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(textstr + matchStart,
+             Matches(
+#ifndef WXREGEX_CONVERT_TO_MB
+                    textstr + matchStart,
+#else
+                    textstr.data() + matchStart,
+#endif

                     countRepl ? wxRE_NOTBOL : 0
                     WXREGEX_IF_NEED_LEN(textlen - matchStart)) )
     {
                     countRepl ? wxRE_NOTBOL : 0
                     WXREGEX_IF_NEED_LEN(textlen - matchStart)) )
     {


@@ -506,7 +536,7 @@ int wxRegExImpl::Replace(wxString *text,
             {
                 size_t index = (size_t)-1;
 
             {
                 size_t index = (size_t)-1;
 

-                if ( *p == _T('\\') )
+                if ( *p == wxT('\\') )

                 {
                     if ( wxIsdigit(*++p) )
                     {
                 {
                     if ( wxIsdigit(*++p) )
                     {


@@ -517,7 +547,7 @@ int wxRegExImpl::Replace(wxString *text,
                     }
                     //else: backslash used as escape character
                 }
                     }
                     //else: backslash used as escape character
                 }

-                else if ( *p == _T('&') )
+                else if ( *p == wxT('&') )

                 {
                     // treat this as "\0" for compatbility with ed and such
                     index = 0;
                 {
                     // treat this as "\0" for compatbility with ed and such
                     index = 0;


@@ -530,14 +560,20 @@ int wxRegExImpl::Replace(wxString *text,
                     size_t start, len;
                     if ( !GetMatch(&start, &len, index) )
                     {
                     size_t start, len;
                     if ( !GetMatch(&start, &len, index) )
                     {

-                        wxFAIL_MSG( _T("invalid back reference") );
+                        wxFAIL_MSG( wxT("invalid back reference") );

 
                         // just eat it...
                     }
                     else
                     {
 
                         // just eat it...
                     }
                     else
                     {

-                        textNew += wxString(textstr + matchStart + start,
-                                            *wxConvCurrent, len);
+                        textNew += wxString(
+#ifndef WXREGEX_CONVERT_TO_MB
+                                textstr
+#else
+                                textstr.data()
+#endif
+                                + matchStart + start,
+                                *wxConvCurrent, len);

 
                         mayHaveBackrefs = true;
                     }
 
                         mayHaveBackrefs = true;
                     }


@@ -553,7 +589,7 @@ int wxRegExImpl::Replace(wxString *text,
         if ( !GetMatch(&start, &len) )
         {
             // we did have match as Matches() returned true above!
         if ( !GetMatch(&start, &len) )
         {
             // we did have match as Matches() returned true above!

-            wxFAIL_MSG( _T("internal logic error in wxRegEx::Replace") );
+            wxFAIL_MSG( wxT("internal logic error in wxRegEx::Replace") );

 
             return wxNOT_FOUND;
         }
 
             return wxNOT_FOUND;
         }


@@ -566,7 +602,7 @@ int wxRegExImpl::Replace(wxString *text,
 #ifndef WXREGEX_CONVERT_TO_MB
         result.append(*text, matchStart, start);
 #else
 #ifndef WXREGEX_CONVERT_TO_MB
         result.append(*text, matchStart, start);
 #else

-        result.append(wxString(textstr + matchStart, *wxConvCurrent, start));
+        result.append(wxString(textstr.data() + matchStart, *wxConvCurrent, start));

 #endif
         matchStart += start;
         result.append(textNew);
 #endif
         matchStart += start;
         result.append(textNew);


@@ -579,7 +615,7 @@ int wxRegExImpl::Replace(wxString *text,
 #ifndef WXREGEX_CONVERT_TO_MB
     result.append(*text, matchStart, wxString::npos);
 #else
 #ifndef WXREGEX_CONVERT_TO_MB
     result.append(*text, matchStart, wxString::npos);
 #else

-    result.append(wxString(textstr + matchStart, *wxConvCurrent));
+    result.append(wxString(textstr.data() + matchStart, *wxConvCurrent));

 #endif
     *text = result;
 
 #endif
     *text = result;
 


@@ -610,8 +646,7 @@ bool wxRegEx::Compile(const wxString& expr, int flags)
     if ( !m_impl->Compile(expr, flags) )
     {
         // error message already given in wxRegExImpl::Compile
     if ( !m_impl->Compile(expr, flags) )
     {
         // error message already given in wxRegExImpl::Compile

-        delete m_impl;
-        m_impl = NULL;
+        wxDELETE(m_impl);

 
         return false;
     }
 
         return false;
     }


@@ -619,26 +654,17 @@ bool wxRegEx::Compile(const wxString& expr, int flags)
     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;
-
-    return m_impl->Matches(WXREGEX_CHAR(str), flags WXREGEX_IF_NEED_LEN(len));
-}
-
-bool wxRegEx::Matches(const wxChar *str, int flags) const
+bool wxRegEx::Matches(const wxString& str, int flags) const

 {
 {

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

 
 

-    return m_impl->Matches(WXREGEX_CHAR(str),
-                           flags
-                           WXREGEX_IF_NEED_LEN(wxStrlen(str)));
+    return m_impl->Matches(WXREGEX_CHAR(str), flags
+                            WXREGEX_IF_NEED_LEN(str.length()));

 }
 
 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, wxT("must successfully Compile() first") );

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


@@ -654,7 +680,7 @@ wxString wxRegEx::GetMatch(const wxString& text, size_t index) const
 
 size_t wxRegEx::GetMatchCount() const
 {
 
 size_t wxRegEx::GetMatchCount() const
 {

-    wxCHECK_MSG( IsValid(), 0, _T("must successfully Compile() first") );
+    wxCHECK_MSG( IsValid(), 0, wxT("must successfully Compile() first") );

 
     return m_impl->GetMatchCount();
 }
 
     return m_impl->GetMatchCount();
 }


@@ -663,7 +689,7 @@ int wxRegEx::Replace(wxString *pattern,
                      const wxString& replacement,
                      size_t maxMatches) const
 {
                      const wxString& replacement,
                      size_t maxMatches) const
 {

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

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