///////////////////////////////////////////////////////////////////////////////
// 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$
-// 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
///////////////////////////////////////////////////////////////////////////////
#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"
#endif //WX_PRECOMP
// FreeBSD, Watcom and DMars require this, CW doesn't have nor need it.
#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
-# 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
+# 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 WXREGEX_CHAR(x) (x).mb_str()
+# define wx_regfree regfree
+# define wx_regerror regerror
#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
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; }
- 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 *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
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
{
if ( IsValid() )
{
- regfree(&m_RegEx);
+ wx_regfree(&m_RegEx);
}
delete m_Matches;
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];
- (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
#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;
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 )
// 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
+ // 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
// 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
// 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++;
}
}
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,
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;
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
{
- 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 )
// 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;
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);
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;
}
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
// 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 )
{
// 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)) )
{
{
size_t index = (size_t)-1;
- if ( *p == _T('\\') )
+ if ( *p == wxT('\\') )
{
if ( wxIsdigit(*++p) )
{
}
//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;
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(textstr + matchStart + start,
- *wxConvCurrent, len);
+ textNew += wxString(
+#ifndef WXREGEX_CONVERT_TO_MB
+ textstr
+#else
+ textstr.data()
+#endif
+ + matchStart + start,
+ *wxConvCurrent, len);
mayHaveBackrefs = true;
}
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;
}
#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);
#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;
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 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
{
- 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);
}
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();
}
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);
}
projects / wxWidgets.git / blobdiff