Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rewrote wxRegEx::Replace() to do something useful

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@11045 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2001-07-14 16:13:32 +00:00
parent dcf0fce44b
commit 765624f735
3 changed files with 186 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
include/wx/regex.h
View File

@@ -99,7 +99,7 @@ public:
// flags may be combination of wxRE_NOTBOL and wxRE_NOTEOL
//
// may only be called after successful call to Compile()
bool Matches(const wxString& str, int flags = 0) const;
bool Matches(const wxChar *text, int flags = 0) const;
// get the start index and the length of the match of the expression
// (index 0) or a bracketed subexpression (index != 0)
@@ -118,7 +118,24 @@ public:
// replaces the current regular expression in the string pointed to by
// pattern, with the text in replacement and return number of matches
// replaced (maybe 0 if none found) or -1 on error
int Replace(wxString *str, const wxString& replacement) const;
//
// the replacement text may contain backreferences (\number) which will be
// replaced with the value of the corresponding subexpression in the
// pattern match
//
// maxMatches may be used to limit the number of replacements made, setting
// it to 1, for example, will only replace first occurence (if any) of the
// pattern in the text while default value of 0 means replace all
int Replace(wxString *text, const wxString& replacement,
size_t maxMatches = 0) const;
// replace the first occurence
int ReplaceFirst(wxString *text, const wxString& replacement) const
{ return Replace(text, replacement, 1); }
// replace all occurences: this is actually a synonym for Replace()
int ReplaceAll(wxString *text, const wxString& replacement) const
{ return Replace(text, replacement, 0); }
// dtor not virtual, don't derive from this class
~wxRegEx();

52
samples/console/console.cpp
View File

@@ -1827,6 +1827,55 @@ static void TestRegExSubmatch()
}
}
static void TestRegExReplacement()
{
wxPuts(_T("*** Testing RE replacement ***"));
static struct RegExReplTestData
{
const wxChar *text;
const wxChar *repl;
const wxChar *result;
size_t count;
} regExReplTestData[] =
{
{ _T("foo123"), _T("bar"), _T("bar"), 1 },
{ _T("foo123"), _T("\\2\\1"), _T("123foo"), 1 },
{ _T("foo_123"), _T("\\2\\1"), _T("123foo"), 1 },
{ _T("123foo"), _T("bar"), _T("123foo"), 0 },
{ _T("123foo456foo"), _T("&&"), _T("123foo456foo456foo"), 1 },
{ _T("foo123foo123"), _T("bar"), _T("barbar"), 2 },
{ _T("foo123_foo456_foo789"), _T("bar"), _T("bar_bar_bar"), 3 },
};
const wxChar *pattern = _T("([a-z]+)[^0-9]*([0-9]+)");
wxRegEx re = pattern;
wxPrintf(_T("Using pattern '%s' for replacement.\n"), pattern);
for ( size_t n = 0; n < WXSIZEOF(regExReplTestData); n++ )
{
const RegExReplTestData& data = regExReplTestData[n];
wxString text = data.text;
size_t nRepl = re.Replace(&text, data.repl);
wxPrintf(_T("%s =~ s/RE/%s/g: %u match%s, result = '%s' ("),
data.text, data.repl,
nRepl, nRepl == 1 ? _T("") : _T("es"),
text.c_str());
if ( text == data.result && nRepl == data.count )
{
wxPuts(_T("ok)"));
}
else
{
wxPrintf(_T("ERROR: should be %u and '%s')\n"),
data.count, data.result);
}
}
}
static void TestRegExInteractive()
{
wxPuts(_T("*** Testing RE interactively ***"));
@@ -5074,8 +5123,9 @@ int main(int argc, char **argv)
TestRegExCompile();
TestRegExMatch();
TestRegExSubmatch();
TestRegExInteractive();
}
TestRegExInteractive();
TestRegExReplacement();
#endif // TEST_REGEX
#ifdef TEST_REGISTRY

145
src/common/regex.cpp
View File

@@ -58,10 +58,11 @@ public:
bool IsValid() const { return m_isCompiled; }
// RE operations
bool Compile(const wxString& expr, int flags);
bool Matches(const wxString& str, int flags) const;
bool GetMatch(size_t *start, size_t *len, size_t index) const;
int Replace(wxString *pattern, const wxString& replacement) const;
bool Compile(const wxString& expr, int flags = 0);
bool Matches(const wxChar *str, int flags = 0) const;
bool GetMatch(size_t *start, size_t *len, size_t index = 0) 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
@@ -180,7 +181,7 @@ bool wxRegExImpl::Compile(const wxString& expr, int flags)
return IsValid();
}
bool wxRegExImpl::Matches(const wxString& str, int flags) const
bool wxRegExImpl::Matches(const wxChar *str, int flags) const
{
wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
@@ -213,7 +214,7 @@ bool wxRegExImpl::Matches(const wxString& str, int flags) const
default:
// an error occured
wxLogError(_("Failed to match '%s' in regular expression: %s"),
str.c_str(), GetErrorMsg(rc).c_str());
str, GetErrorMsg(rc).c_str());
// fall through
case REG_NOMATCH:
@@ -240,31 +241,115 @@ bool wxRegExImpl::GetMatch(size_t *start, size_t *len, size_t index) const
return TRUE;
}
int wxRegExImpl::Replace(wxString *pattern, const wxString& replacement) const
int wxRegExImpl::Replace(wxString *text,
const wxString& replacement,
size_t maxMatches) const
{
wxCHECK_MSG( pattern, -1, _T("NULL pattern in wxRegEx::Replace") );
wxCHECK_MSG( text, -1, _T("NULL text in wxRegEx::Replace") );
wxCHECK_MSG( IsValid(), -1, _T("must successfully Compile() first") );
wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
// the replacement text
wxString textNew;
int replaced = 0;
size_t lastpos = 0;
wxString newstring;
// 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;
for ( size_t idx = 0;
m_Matches[idx].rm_so != -1 && idx < m_nMatches;
idx++ )
if ( !mayHaveBackrefs )
{
// copy non-matching bits:
newstring << pattern->Mid(lastpos, m_Matches[idx].rm_so - lastpos);
// copy replacement:
newstring << replacement;
// remember how far we got:
lastpos = m_Matches[idx].rm_eo;
replaced ++;
textNew = replacement;
}
if(replaced > 0)
*pattern = newstring;
return replaced;
// 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
// (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(text->c_str() + matchStart, countRepl ? wxRE_NOTBOL : 0) )
{
// 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(text->c_str() + matchStart + start,
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 -1;
}
matchStart += start;
text->replace(matchStart, len, textNew);
countRepl++;
matchStart += textNew.length();
}
return countRepl;
}
// ----------------------------------------------------------------------------
@@ -301,7 +386,7 @@ bool wxRegEx::Compile(const wxString& expr, int flags)
return TRUE;
}
bool wxRegEx::Matches(const wxString& str, int flags) const
bool wxRegEx::Matches(const wxChar *str, int flags) const
{
wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
@@ -310,7 +395,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(), -1, _T("must successfully Compile() first") );
wxCHECK_MSG( IsValid(), FALSE, _T("must successfully Compile() first") );
return m_impl->GetMatch(start, len, index);
}
@@ -324,11 +409,13 @@ wxString wxRegEx::GetMatch(const wxString& text, size_t index) const
return text.Mid(start, len);
}
int wxRegEx::Replace(wxString *pattern, const wxString& replacement) const
int wxRegEx::Replace(wxString *pattern,
const wxString& replacement,
size_t maxMatches) const
{
wxCHECK_MSG( IsValid(), -1, _T("must successfully Compile() first") );
return m_impl->Replace(pattern, replacement);
return m_impl->Replace(pattern, replacement, maxMatches);
}
#endif // wxUSE_REGEX