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

Too many changes :)

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@24957 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Ryan Norton
2003-12-21 11:51:33 +00:00
parent 651bb0c9e5
commit b5bdef5532
2 changed files with 365 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

372
samples/regextest/regextest.cpp
View File

@@ -8,6 +8,25 @@
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
//===========================================================================
// REGEX LIBS
//===========================================================================
//wxWindows regular expression library
#define wxUSE_WXREGEX
//RN (Ryan Norton's) regular expression library
//#define wxUSE_RNWXRE
//Greta, Microsoft Research's templated library
//[http://research.microsoft.com/projects/greta/]
//Install - Get it from .net powertools, put the directory in this directory
//#define wxUSE_GRETA
//PCRE (Perl Compatible Regular Expressions) [sourceforge.net/projects/pcre]
//Install - Get the GnuWin32 version and put the files in this directory
//#define wxUSE_PCRE
//===========================================================================
// HEADERS
//===========================================================================
@@ -25,15 +44,51 @@
#include "wx/wx.h"
#endif
#include "wx/file.h"
#ifdef wxUSE_WXREGEX
//
// This is the required header for wxRegEx
//
#include <wx/regex.h>
# include <wx/regex.h>
#endif
#ifdef wxUSE_RNWXRE
# include "re.h"
#endif
#ifdef wxUSE_GRETA
# ifdef _MSC_VER
# pragma warning(disable:4018)
# pragma warning(disable:4100)
# pragma warning(disable:4146)
# pragma warning(disable:4244)
# pragma warning(disable:4663)
extern "C" {
int __cdecl _resetstkoflw(void) {return 0;}
}
# endif //_MSC_VER
# include "greta/regexpr2.h"
using namespace regex;
#endif //wxUSE_GRETA
#ifdef wxUSE_PCRE
# include "pcre.h"
# ifdef _MSC_VER
# pragma comment(lib, "libpcre.a")
# endif
#endif
//===========================================================================
// IMPLEMENTATION
//===========================================================================
//
// One of the best sources for regex info is IEEE document/standard 1003.2
// From the open group.
// A current link - (http://www.opengroup.org/onlinepubs/007904975/basedefs/xbd_chap09.html).
//
//---------------------------------------------------------------------------
// MyDialog
//---------------------------------------------------------------------------
@@ -57,12 +112,13 @@ public:
ICaseID,
NewLineID,
NotBolID,
NotEolID
NotEolID,
CompID
};
MyDialog() : wxFrame( NULL, -1, _("regextest - wxRegEx Testing App"),
wxPoint(20,20), wxSize(300,300) )
wxPoint(20,20), wxSize(300,400) )
{
//Set the background to something light gray-ish
SetBackgroundColour(wxColour(150,150,150));
@@ -83,6 +139,9 @@ public:
OptionsMenu->AppendSeparator();
OptionsMenu->AppendCheckItem(NotBolID, _T("wxRE_NOTBOL"), _("Use functionality of ^ character?"));
OptionsMenu->AppendCheckItem(NotEolID, _T("wxRE_NOTEOL"), _("Use functionality of $ character?"));
OptionsMenu->AppendSeparator();
OptionsMenu->AppendSeparator();
OptionsMenu->AppendCheckItem(CompID, _T("Test Compile"), _("Added Compiling to Match Time?"));
OptionsMenu->Check(ExtendedID, true);
HelpMenu->Append(wxID_ABOUT, _T("&About...\tF1"), _("Show about dialog"));
@@ -107,56 +166,131 @@ public:
// StaticText
PatternHeader.Create(this, -1, _("Regular Expression:"), wxPoint(5, 10));
SearchHeader.Create(this, -1, _("String to Search:"), wxPoint(5, 55));
ResultText.Create(this, -1, _(""), wxPoint(5, 150));
IterHeader.Create(this, -1, _("Iterations (Match Time):"), wxPoint(100, 100));
ResultText.Create(this, -1, _(""), wxPoint(5, 150), wxSize(100,200), wxST_NO_AUTORESIZE);
ResultText2.Create(this, -1, _(""), wxPoint(115, 150), wxSize(100,200), wxST_NO_AUTORESIZE);
// Button
OkButton.Create(this, OkButtonID, _("OK"), wxPoint(20, 120));
NumIters.Create(this, -1, _("15000"), wxPoint(100, 120));
}
void OnAbout(wxCommandEvent& WXUNUSED(evt))
{
wxChar* szBuffer;
wxFile f;
f.Open(_("README.txt"), wxFile::read);
szBuffer = new wxChar[f.Length() + 1];
f.Read(szBuffer, f.Length());
f.Close();
wxMessageBox(wxString::Format(
_("%s%s%s"),
_("Regular Expression Test Application\n"),
_("(c) 2003 Ryan Norton <wxprojects@comcast.net>\n"),
_("%s%s%s%s"),
_("-----------Regular Expression Test Application-----------\n"),
szBuffer,
_("\n\n\n(c) 2003 Ryan Norton <wxprojects@comcast.net>\n"),
wxVERSION_STRING
)
);
delete szBuffer;
}
void OnMatch(wxCommandEvent& WXUNUSED(evt))
{
wxString szPattern = PatternText.GetValue();
wxString szSearch = SearchText.GetValue();
wxString szResult = _("Result:\n"); //Will be displayed in ResultText
wxString szResult, szResult2, szResult3, szResult4; //Will be displayed in ResultText
wxString szStatus, szStatus2, szStatus3, szStatus4;
int nCompileFlags = 0;
int nMatchFlags = 0;
int nCompileFlags = 0, nCompileFlags2 = 0, nCompileFlags3 = 0, nCompileFlags4 = 0;
int nMatchFlags = 0, nMatchFlags2 = 0, nMatchFlags3 = 0, nMatchFlags4 = 0;
if (!(OptionsMenu->IsChecked(ExtendedID)))
{
#ifdef wxUSE_WXREGEX
nCompileFlags |= wxRE_BASIC;
#endif
}
else
{
#ifdef wxUSE_RNWXRE
nCompileFlags2 |= wxRe::wxRE_EXTENDED;
#endif
// nCompileFlags3 |= EXTENDED;
}
if (OptionsMenu->IsChecked(ICaseID))
{
#ifdef wxUSE_WXREGEX
nCompileFlags |= wxRE_ICASE;
#endif
#ifdef wxUSE_RNWXRE
nCompileFlags2 |= wxRe::wxRE_ICASE;
#endif
#ifdef wxUSE_GRETA
nCompileFlags3 |= NOCASE;
#endif
}
if (OptionsMenu->IsChecked(NewLineID))
{
#ifdef wxUSE_WXREGEX
nCompileFlags |= wxRE_NEWLINE;
#endif
#ifdef wxUSE_RNWXRE
nCompileFlags2 |= wxRe::wxRE_NEWLINE;
#endif
#ifdef wxUSE_GRETA
nCompileFlags3 |= MULTILINE;
#endif
}
if (OptionsMenu->IsChecked(NotBolID))
{
#ifdef wxUSE_WXREGEX
nMatchFlags |= wxRE_NOTBOL;
#endif
#ifdef wxUSE_RNWXRE
nMatchFlags2 |= wxRe::wxRE_NOTBOL;
#endif
}
if (OptionsMenu->IsChecked(NotEolID))
{
#ifdef wxUSE_WXREGEX
nMatchFlags |= wxRE_NOTEOL;
#endif
#ifdef wxUSE_RNWXRE
nMatchFlags2 |= wxRe::wxRE_NOTEOL;
#endif
}
//Our regular expression object
//Success! Here we'll display some
//information to the user
size_t dwStartIndex = 0, dwEndIndex = 0,
dwStartIndex2= 0, dwEndIndex2= 0,
dwStartIndex3= 0, dwEndIndex3= 0,
dwStartIndex4= 0, dwEndIndex4= 0;
time_t dwStartTime = 0, dwEndTime = 0,
dwStartTime2= 0, dwEndTime2= 0,
dwStartTime3= 0, dwEndTime3= 0,
dwStartTime4= 0, dwEndTime4= 0;
int i = 0;
long n;
if (!NumIters.GetValue().ToLong(&n))
n = 0;
#ifdef wxUSE_WXREGEX
wxRegEx Regex;
//We're going to go ahead and time the match
//for fun (clock() is a c library routine that
//returns the current time since a certian point
//in milliseconds
time_t dwStartTime = clock();
//Regular Expressions must be compiled before
//you can search a string with them, or
//at least most implementations do.
@@ -166,34 +300,202 @@ public:
//something that's easier to parse, due
//to the syntax of regular expressions
if (!Regex.Compile(szPattern, nCompileFlags))
szResult += _("\nCompile Failed!\n");
szStatus += _("\nCompile Failed!\n");
else
{
//Here's where we actually search our string
if (!Regex.Matches(szSearch, nMatchFlags))
szResult += _("\nExecution/Matching Failed!\n");
szStatus += _("\nExecution/Matching Failed!\n");
else
{
//Success! Here we'll display some
//information to the user
size_t dwStartIndex, dwEndIndex;
Regex.GetMatch(&dwStartIndex, &dwEndIndex);
szResult += wxString::Format(
_("Start Index:%i\nMatch Length:%i\nString Matched:%s\n"),
dwStartIndex, dwEndIndex,
szSearch.Mid(dwStartIndex, dwEndIndex)
);
szStatus = _("Success");
//We're going to go ahead and time the match
//for fun (clock() is a c library routine that
//returns the current time since a certian point
//in milliseconds
dwStartTime = clock();
if (OptionsMenu->IsChecked(CompID))
{
for(i = 0; i < n; ++i)
{
Regex.Compile(szPattern, nCompileFlags);
Regex.Matches(szSearch, nMatchFlags);
}
}
else
{
for(i = 0; i < n; ++i)
{
Regex.Matches(szSearch, nMatchFlags);
}
}
//This line gets the difference in time between now
//and when we first initialized dwStartTime.
dwEndTime = clock() - dwStartTime;
}
}
//This line gets the difference in time between now
//and when we first initialized dwStartTime.
time_t dwEndTime = clock() - dwStartTime;
szResult += wxString::Format(_("Match Time:%u Milliseconds"), dwEndTime);
szResult = wxString::Format(
_("--wxRegEx--\nIndex:[%i]-[%i]\nString:%s\nMatch Time:%ums\nStatus:%s"),
dwStartIndex, dwEndIndex+dwStartIndex,
szSearch.Mid(dwStartIndex, dwEndIndex),
dwEndTime,
szStatus
);
ResultText.SetLabel(szResult);
#endif //wxUSE_WXREGEX
#ifdef wxUSE_RNWXRE
wxRe Re;
wxRe::wxReError e;
if ((e = Re.Comp(szPattern, nCompileFlags2)) != wxRe::wxRE_OK)
szStatus2 = wxString::Format(_("\nCompile Failed!\n%s\n"), wxRe::ErrorToString(e));
else
{
//Here's where we actually search our string
if ((e = Re.Exec(szSearch, nMatchFlags2)) != wxRe::wxRE_OK)
szStatus2 = wxString::Format(_("\nExecution/Matching Failed!\n%s\n"), wxRe::ErrorToString(e));
else
{
dwStartIndex2 = Re.GetMatch(0).first;
dwEndIndex2 = Re.GetMatch(0).second;
szStatus2 = _("Success");
dwStartTime2 = clock();
if (OptionsMenu->IsChecked(CompID))
{
for(i = 0; i < n; ++i)
{
Re.Comp(szPattern, nCompileFlags2);
Re.Exec(szSearch, nMatchFlags2);
}
}
else
{
for(i = 0; i < n; ++i)
{
Re.Exec(szSearch, nMatchFlags2);
}
}
dwEndTime2 = clock() - dwStartTime2;
}
}
szResult2 = wxString::Format(
_("--wxRe--\nIndex:[%i]-[%i]\nString:%s\nMatch Time:%ums\nStatus:%s"),
dwStartIndex2, dwEndIndex2+dwStartIndex2,
szSearch.Mid(dwStartIndex2, dwEndIndex2),
dwEndTime2,
szStatus2
);
#endif //wxUSE_RNWXRE
#ifdef wxUSE_GRETA
std::string stdszPattern(szPattern);
rpattern Greta (stdszPattern,GLOBAL,MODE_MIXED);
match_results r;
std::string stdszSearch(szSearch);
//Here's where we actually search our string
if (!Greta.match(stdszSearch, r).matched)
szStatus3 += _("\nExecution/Matching Failed!\n");
else
{
szStatus3 = _("Success");
dwStartTime3 = clock();
if (OptionsMenu->IsChecked(CompID))
{
for(i = 0; i < n; ++i)
{
Greta = rpattern(stdszPattern,GLOBAL,MODE_MIXED);
Greta.match(stdszSearch, r);
}
}
else
{
for(i = 0; i < n; ++i)
{
Greta.match(stdszSearch, r);
}
}
dwEndTime3 = clock() - dwStartTime3;
}
szResult3 = wxString::Format(
_("--Greta--\nIndex:[%i]-[%i]\nString:%s\nMatch Time:%ums\nStatus:%s"),
r.rstart(), r.rlength() + r.rstart(),
szSearch.Mid(r.rstart(), r.rlength()),
dwEndTime3,
szStatus3);
#endif //wxUSE_GRETA
#ifdef wxUSE_PCRE
pcre* pPcre;
const wxChar* szError;
int nErrOff;
if ((pPcre = pcre_compile(szPattern, nCompileFlags4, &szError, &nErrOff, 0)) == NULL)
szStatus4 = wxString::Format(_("\nCompile Failed!\nError:%s\nOffset:%i\n"), szError, nErrOff);
else
{
size_t msize;
pcre_fullinfo(pPcre, 0, PCRE_INFO_CAPTURECOUNT, &msize);
msize = 3*(msize+1);
int *m = new int[msize];
//Here's where we actually search our string
if (!pcre_exec(pPcre, 0, szSearch, szSearch.Length(), 0, 0, m, msize))
szStatus4 = wxString::Format(_("\nExecution/Matching Failed!\n"));
else
{
dwStartIndex4 = m[0];
dwEndIndex4 = m[1] - m[0];
szStatus4 = _("Success");
dwStartTime4 = clock();
if (OptionsMenu->IsChecked(CompID))
{
for(i = 0; i < n; ++i)
{
pPcre = pcre_compile(szPattern, nCompileFlags4, &szError, &nErrOff, 0);
pcre_exec(pPcre, 0, szSearch, szSearch.Length(), 0, 0, m, msize);
}
}
else
{
for(i = 0; i < n; ++i)
{
pcre_exec(pPcre, 0, szSearch, szSearch.Length(), 0, 0, m, msize);
}
}
dwEndTime4 = clock() - dwStartTime4;
}
}
szResult4 = wxString::Format(
_("--PCRE--\nIndex:[%i]-[%i]\nString:%s\nMatch Time:%ums\nStatus:%s"),
dwStartIndex4, dwEndIndex4+dwStartIndex4,
szSearch.Mid(dwStartIndex4, dwEndIndex4),
dwEndTime4,
szStatus4
);
#endif //wxUSE_PCRE
ResultText.SetLabel(szResult + _("\n\n") + szResult2);
ResultText2.SetLabel(szResult3 + _("\n\n") + szResult4);
}
void OnQuit(wxCommandEvent& WXUNUSED(evt))
@@ -201,8 +503,8 @@ public:
Close(TRUE);
}
wxTextCtrl PatternText, SearchText;
wxStaticText PatternHeader, SearchHeader, ResultText;
wxTextCtrl PatternText, SearchText, NumIters;
wxStaticText PatternHeader, SearchHeader, IterHeader, ResultText, ResultText2;
wxButton OkButton;
wxMenu *OptionsMenu;