fixing osx_cocoa

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

diff --git a/src/common/regex.cpp b/src/common/regex.cpp
index f6ca8782913e64e3ec4ddfe6bf99610974e299b8..4683b81de3965847a03adf4a2f71b830ca840ae7 100644 (file)
--- a/src/common/regex.cpp
+++ b/src/common/regex.cpp
@@ -27,9 +27,10 @@
 
 #if wxUSE_REGEX
 
+#include "wx/regex.h"
+
 #ifndef WX_PRECOMP
     #include "wx/object.h"
-    #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/crt.h"
@@ -44,7 +45,6 @@
 #endif
 
 #include <regex.h>
-#include "wx/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
@@ -274,10 +274,10 @@ bool wxRegExImpl::Compile(const wxString& expr, int flags)
 #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)),
-                  _T("unrecognized flags in wxRegEx::Compile") );
+                  wxT("unrecognized flags in wxRegEx::Compile") );
 
     // translate our flags to regcomp() ones
     int flagsRE = 0;
@@ -335,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++ )
             {
-                if ( *cptr == _T('\\') )
+                if ( *cptr == wxT('\\') )
                 {
                     // in basic RE syntax groups are inside \(...\)
-                    if ( *++cptr == _T('(') && (flags & wxRE_BASIC) )
+                    if ( *++cptr == wxT('(') && (flags & wxRE_BASIC) )
                     {
                         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
@@ -351,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.
-                    if ( cptr[1] != _T('?') )
+                    if ( cptr[1] != wxT('?') )
                         m_nMatches++;
                 }
             }
@@ -378,7 +378,7 @@ static int ReSearch(const regex_t *preg,
                     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;
@@ -394,11 +394,11 @@ 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)),
-                  _T("unrecognized flags in wxRegEx::Matches") );
+                  wxT("unrecognized flags in wxRegEx::Matches") );
 
     int flagsRE = 0;
     if ( flags & wxRE_NOTBOL )
@@ -444,10 +444,10 @@ bool wxRegExImpl::Matches(const wxRegChar *str,
 
 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);
@@ -459,8 +459,8 @@ bool wxRegExImpl::GetMatch(size_t *start, size_t *len, size_t index) 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;
 }
@@ -469,8 +469,8 @@ 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") );
+    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
@@ -498,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 =
-        replacement.find_first_of(_T("\\&")) != wxString::npos;
+        replacement.find_first_of(wxT("\\&")) != wxString::npos;
 
     if ( !mayHaveBackrefs )
     {
@@ -515,11 +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) &&
+             Matches(
 #ifndef WXREGEX_CONVERT_TO_MB
-            Matches(textstr + matchStart,
+                    textstr + matchStart,
 #else
-            Matches(textstr.data() + matchStart,
-#endif 
+                    textstr.data() + matchStart,
+#endif
                     countRepl ? wxRE_NOTBOL : 0
                     WXREGEX_IF_NEED_LEN(textlen - matchStart)) )
     {
@@ -535,7 +536,7 @@ int wxRegExImpl::Replace(wxString *text,
             {
                 size_t index = (size_t)-1;
 
-                if ( *p == _T('\\') )
+                if ( *p == wxT('\\') )
                 {
                     if ( wxIsdigit(*++p) )
                     {
@@ -546,7 +547,7 @@ int wxRegExImpl::Replace(wxString *text,
                     }
                     //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;
@@ -559,19 +560,20 @@ int wxRegExImpl::Replace(wxString *text,
                     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
                     {
+                        textNew += wxString(
 #ifndef WXREGEX_CONVERT_TO_MB
-                        textNew += wxString(textstr + matchStart + start,
+                                textstr
 #else
-                        textNew += wxString(textstr.data() + matchStart +
-                                           start,
+                                textstr.data()
 #endif
-                                            *wxConvCurrent, len);
+                                + matchStart + start,
+                                *wxConvCurrent, len);
 
                         mayHaveBackrefs = true;
                     }
@@ -587,7 +589,7 @@ int wxRegExImpl::Replace(wxString *text,
         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;
         }
@@ -600,8 +602,7 @@ int wxRegExImpl::Replace(wxString *text,
 #ifndef WXREGEX_CONVERT_TO_MB
         result.append(*text, matchStart, start);
 #else
-        result.append(wxString(textstr.data() + matchStart, *wxConvCurrent, 
-                              start));
+        result.append(wxString(textstr.data() + matchStart, *wxConvCurrent, start));
 #endif
         matchStart += start;
         result.append(textNew);
@@ -645,8 +646,7 @@ bool wxRegEx::Compile(const wxString& expr, int flags)
     if ( !m_impl->Compile(expr, flags) )
     {
         // error message already given in wxRegExImpl::Compile
-        delete m_impl;
-        m_impl = NULL;
+        wxDELETE(m_impl);
 
         return false;
     }
@@ -656,7 +656,7 @@ bool wxRegEx::Compile(const wxString& expr, int flags)
 
 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(str.length()));
@@ -664,7 +664,7 @@ bool wxRegEx::Matches(const wxString& str, int flags) 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);
 }
@@ -680,7 +680,7 @@ wxString wxRegEx::GetMatch(const wxString& text, size_t index) 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();
 }
@@ -689,7 +689,7 @@ int wxRegEx::Replace(wxString *pattern,
                      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);
 }