rendered paste body#if defined(_MSC_VER)#pragma warning( disable : 4786 )#pragma warning( disable : 4251 )#endif#include <iostream>#include <string>#include <sstream>#include <iomanip>#include <algorithm>#include "DoConsoleTest.h"#if defined(_MSC_VER) && _MSC_VER < 1300#include "RegularExpressionMemBind.h"#endifnamespace { bool YesToAll; bool NoToAll; void ClearTheScreen() { HANDLE chand = GetStdHandle(STD_OUTPUT_HANDLE); CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(chand,&csbi); COORD c; DWORD dummy; c.X = c.Y = 0; FillConsoleOutputCharacter(chand,' ',csbi.dwSize.X * csbi.dwSize.Y,c,&dummy); SetConsoleCursorPosition(chand,c); } void ConsoleSize() { HANDLE chand = GetStdHandle(STD_OUTPUT_HANDLE); COORD coord; coord.X = 80; coord.Y = 1000; SetConsoleScreenBufferSize(chand,coord); SMALL_RECT sr; sr.Left = 0; sr.Top = 0; sr.Right = 79; sr.Bottom = 49; SetConsoleWindowInfo(chand,TRUE,&sr); } char GetCharacter() { char buffer[2]; std::cin.getline(buffer,2); return(buffer[0]); } std::string GetString() { char buffer[256]; std::cin.getline(buffer,256); std::string ret(buffer); return(ret); } /* Get Windows error message from error code derr = error code returns = error message */ std::string WindowsError(DWORD derr) { std::string ret; if (derr) { LPVOID lpMsgBuf; FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0,derr,MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPSTR)&lpMsgBuf,0,0); ret = static_cast<const char *>(lpMsgBuf); LocalFree(lpMsgBuf); } return (ret); } void DoMatching(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine) { std::cout << "\r\n\r\nMatch found"; std::ostringstream oss; std::string s; oss << "\r\nLine index = " << LineIndex << ", Start of line = " << StartOfLine; s = oss.str(); oss.flush(); std::cout << s.c_str(); s = Matches[0].string; std::cout << "\r\nThe matched string = \'" << s << "\' and the position = " << Matches[0].position; if (Matches.size() > 3) { std::cout << "\r\nThe matched substrings and positions are:"; } for (RegexClass::REMatchInfo::const_iterator cit = Matches.begin() + 1; cit != Matches.end() - 2; ++cit) { std::string s(std::string("\r\n\"") + cit -> string + "\""); std::cout << s.c_str(); if (static_cast<int>(cit -> position) == -1) { std::cout << ", -1"; } else { std::cout << ", " << cit -> position; } } s = Matches[Matches.size() - 2].string; if (static_cast<int>(Matches[Matches.size() - 2].position) == -1) { std::cout << "\r\nThe string and position before the match = \'" << s << "\', -1"; } else { std::cout << "\r\nThe string and position before the match = \'" << s << "\', " << Matches[Matches.size() - 2].position; } s = Matches[Matches.size() - 1].string; if (static_cast<int>(Matches[Matches.size() - 1].position) == -1) { std::cout << "\r\nThe string and position after the match = \'" << s << "\', -1"; } else { std::cout << "\r\nThe string and position after the match = \'" << s << "\', " << Matches[Matches.size() - 1].position; } if (!cre -> GetFormatString().empty()) { std::string result; cre -> Format(result); std::cout << "\r\nThe formatted result of the match = \'" << result << "\'"; } } void DoSearching(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine) { std::cout << "\r\n\r\nSearch found"; std::ostringstream oss; std::string s; oss << "\r\nLine index = " << LineIndex << ", Start of line = " << StartOfLine; s = oss.str(); oss.flush(); std::cout << s.c_str(); s = Matches[0].string; std::cout << "\r\nThe matched string = \'" << s << "\' and the position = " << Matches[0].position; if (Matches.size() > 3) { std::cout << "\r\nThe matched substrings and positions are:"; } for (RegexClass::REMatchInfo::const_iterator cit = Matches.begin() + 1; cit != Matches.end() - 2; ++cit) { std::string s(std::string("\r\n\"") + cit -> string + "\""); std::cout << s.c_str(); if (static_cast<int>(cit -> position) == -1) { std::cout << ", -1"; } else { std::cout << ", " << cit -> position; } } s = Matches[Matches.size() - 2].string; if (static_cast<int>(Matches[Matches.size() - 2].position) == -1) { std::cout << "\r\nThe string and position before the match = \'" << s << "\', -1"; } else { std::cout << "\r\nThe string and position before the match = \'" << s << "\', " << Matches[Matches.size() - 2].position; } s = Matches[Matches.size() - 1].string; if (static_cast<int>(Matches[Matches.size() - 1].position) == -1) { std::cout << "\r\nThe string and position after the match = \'" << s << "\', -1"; } else { std::cout << "\r\nThe string and position after the match = \'" << s << "\', " << Matches[Matches.size() - 1].position; } if (!cre -> GetFormatString().empty()) { std::string result; cre -> Format(result); std::cout << "\r\nThe formatted result of the match = \'" << result << "\'"; } } void DoGrepping(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine,bool & bcontinue) { std::cout << "\r\n\r\nGrep found"; std::ostringstream oss; std::string s; oss << "\r\nLine index = " << LineIndex << ", Start of line = " << StartOfLine; s = oss.str(); oss.flush(); std::cout << s.c_str(); s = Matches[0].string; std::cout << "\r\nThe matched string = \'" << s << "\' and the position = " << Matches[0].position; if (Matches.size() > 3) { std::cout << "\r\nThe matched substrings and positions are:"; } for (RegexClass::REMatchInfo::const_iterator cit = Matches.begin() + 1; cit != Matches.end() - 2; ++cit) { std::string s(std::string("\r\n\"") + cit -> string + "\""); std::cout << s.c_str(); if (static_cast<int>(cit -> position) == -1) { std::cout << ", -1"; } else { std::cout << ", " << cit -> position; } } s = Matches[Matches.size() - 2].string; if (static_cast<int>(Matches[Matches.size() - 2].position) == -1) { std::cout << "\r\nThe string and position before the match = \'" << s << "\', -1"; } else { std::cout << "\r\nThe string and position before the match = \'" << s << "\', " << Matches[Matches.size() - 2].position; } s = Matches[Matches.size() - 1].string; if (static_cast<int>(Matches[Matches.size() - 1].position) == -1) { std::cout << "\r\nThe string and position after the match = \'" << s << "\', -1"; } else { std::cout << "\r\nThe string and position after the match = \'" << s << "\', " << Matches[Matches.size() - 1].position; } if (!cre -> GetFormatString().empty()) { std::string result; cre -> Format(result); std::cout << "\r\nThe formatted result of the match = \'" << result << "\'"; } if (YesToAll) { bcontinue = true; } else { while (true) { std::cout << "\r\nContinue grep ? (Y/N/A) "; char c(GetCharacter()); if (c == 'Y' || c == 'y') { bcontinue = true; break; } else if (c == 'N' || c == 'n') { bcontinue = false; break; } else if (c == 'A' || c == 'a') { bcontinue = true; YesToAll = true; break; } } } } void DoGreppingFiles(RegexClass::RegularExpression *,std::string file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue) { std::cout << "\r\n\r\nGrepping files found"; std::cout << "\r\nThe file = \'" << file << "\', the line index = " << LineIndex; std::cout << "\r\nThe matched string = " << Matches[0].string; std::cout << "\r\nThe matched string position = " << Matches[0].position; if (Matches.size() > 1) { std::cout << "\r\nThe matched substrings and positions are:"; } RegexClass::REMatchInfo::const_iterator cit; for (cit = Matches.begin() + 1; cit != Matches.end(); ++cit) { unsigned int ui = cit -> position; int i = static_cast<int>(ui); if (i == -1) { std::cout << "\r\n\'" << cit -> string << "\', -1"; } else { std::cout << "\r\n\'" << cit -> string << "\', " << ui; } } if (YesToAll) { bcontinue = true; } else if (NoToAll) { bcontinue = false; } else { while (true) { std::cout << "\r\nContinue grepping this file ? (Y/N/A/X) "; char c(GetCharacter()); if (c == 'Y' || c == 'y') { bcontinue = true; break; } else if (c == 'N' || c == 'n') { bcontinue = false; break; } else if (c == 'A' || c == 'a') { bcontinue = true; YesToAll = true; break; } else if (c == 'X' || c == 'x') { bcontinue = false; NoToAll = true; break; } } } } void DoFindingFiles(RegexClass::RegularExpression *,std::string file,bool & bcontinue) { std::cout << "\r\n\r\nFinding files found"; std::cout << "\r\nThe file = \'" << file << "\'"; if (YesToAll) { bcontinue = true; } else { while (true) { std::cout << "\r\nContinue finding files ? (Y/N/A) "; char c(GetCharacter()); if (c == 'Y' || c == 'y') { bcontinue = true; break; } else if (c == 'N' || c == 'n') { bcontinue = false; break; } else if (c == 'A' || c == 'a') { bcontinue = true; YesToAll = true; break; } } } } void DoMerging(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine,bool & bcontinue) { std::cout << "\r\n\r\nMerge found"; std::ostringstream oss; std::string s; oss << "\r\nLine index = " << LineIndex << ", Start of line = " << StartOfLine; s = oss.str(); oss.flush(); std::cout << s.c_str(); s = Matches[0].string; std::cout << "\r\nThe matched string = \'" << s << "\' and the position = " << Matches[0].position; if (Matches.size() > 3) { std::cout << "\r\nThe matched substrings and positions are:"; } for (RegexClass::REMatchInfo::const_iterator cit = Matches.begin() + 1; cit != Matches.end() - 2; ++cit) { std::string s(std::string("\r\n\"") + cit -> string + "\""); std::cout << s.c_str(); if (static_cast<int>(cit -> position) == -1) { std::cout << ", -1"; } else { std::cout << ", " << cit -> position; } } s = Matches[Matches.size() - 2].string; if (static_cast<int>(Matches[Matches.size() - 2].position) == -1) { std::cout << "\r\nThe string and position before the match = \'" << s << "\', -1"; } else { std::cout << "\r\nThe string and position before the match = \'" << s << "\', " << Matches[Matches.size() - 2].position; } s = Matches[Matches.size() - 1].string; if (static_cast<int>(Matches[Matches.size() - 1].position) == -1) { std::cout << "\r\nThe string and position after the match = \'" << s << "\', -1"; } else { std::cout << "\r\nThe string and position after the match = \'" << s << "\', " << Matches[Matches.size() - 1].position; } if (YesToAll) { bcontinue = true; } else { while (true) { std::cout << "\r\nFormat = " << cre -> GetFormatString() << ", continue merge ? (Y/N/A) "; char c(GetCharacter()); if (c == 'Y' || c == 'y') { bcontinue = true; std::string sbuffer; std::cout << "\r\nEnter new format string (blank for no change) "; sbuffer = GetString(); if (!sbuffer.empty()) { cre -> SetFormatString(sbuffer); } break; } else if (c == 'N' || c == 'n') { bcontinue = false; break; } else if (c == 'A' || c == 'a') { bcontinue = true; YesToAll = true; std::string sbuffer; std::cout << "\r\nEnter new format string (blank for no change) "; sbuffer = GetString(); if (!sbuffer.empty()) { cre -> SetFormatString(sbuffer); } break; } } } } void DoMergingFiles(RegexClass::RegularExpression * cre,std::string file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue) { std::cout << "\r\n\r\nChanging files found"; std::cout << "\r\nThe file = \'" << file << "\', the line index = " << LineIndex; std::cout << "\r\nThe matched string = " << Matches[0].string; std::cout << "\r\nThe matched string position = " << Matches[0].position; if (Matches.size() > 1) { std::cout << "\r\nThe matched substrings and positions are:"; } RegexClass::REMatchInfo::const_iterator cit; for (cit = Matches.begin() + 1; cit != Matches.end(); ++cit) { unsigned int ui = cit -> position; int i = static_cast<int>(ui); if (i == -1) { std::cout << "\r\n\'" << cit -> string << "\', -1"; } else { std::cout << "\r\n\'" << cit -> string << "\', " << ui; } } if (YesToAll) { bcontinue = true; } else if (NoToAll) { bcontinue = false; } else { while (true) { std::cout << "\r\nFormat = " << cre -> GetFormatString() << ", continue changing files ? (Y/N/A/X) "; char c(GetCharacter()); if (c == 'Y' || c == 'y') { bcontinue = true; std::string sbuffer; std::cout << "\r\nEnter new format string (blank for no change) "; sbuffer = GetString(); if (!sbuffer.empty()) { cre -> SetFormatString(sbuffer); } break; } else if (c == 'N' || c == 'n') { bcontinue = false; break; } else if (c == 'A' || c == 'a') { bcontinue = true; YesToAll = true; std::string sbuffer; std::cout << "\r\nEnter new format string (blank for no change) "; sbuffer = GetString(); if (!sbuffer.empty()) { cre -> SetFormatString(sbuffer); } break; } else if (c == 'X' || c == 'x') { bcontinue = false; NoToAll = true; break; } } } } void SetGlobalHandlers(RegexClass::RegularExpression & re,REEventHandler & evhandler) { #if defined(_MSC_VER) && _MSC_VER >= 1300 __unhook(&RegexClass::RegularExpression::OnMatching,&re,&REEventHandler::OnMatching,&evhandler); __unhook(&RegexClass::RegularExpression::OnSearching,&re,&REEventHandler::OnSearching,&evhandler); __unhook(&RegexClass::RegularExpression::OnGrepping,&re,&REEventHandler::OnGrepping,&evhandler); __unhook(&RegexClass::RegularExpression::OnMerging,&re,&REEventHandler::OnMerging,&evhandler); __unhook(&RegexClass::RegularExpression::OnGreppingFiles,&re,&REEventHandler::OnGreppingFiles,&evhandler); __unhook(&RegexClass::RegularExpression::OnFindFiles,&re,&REEventHandler::OnFindingFiles,&evhandler); __unhook(&RegexClass::RegularExpression::OnChangingFiles,&re,&REEventHandler::OnMergingFiles,&evhandler);#endif re.OnMatchingGlobal = OnMatching; re.OnSearchingGlobal = OnSearching; re.OnGreppingGlobal = OnGrepping; re.OnMergingGlobal = OnMerging; re.OnGreppingFilesGlobal = OnGreppingFiles; re.OnFindFilesGlobal = OnFindingFiles; re.OnChangingFilesGlobal = OnMergingFiles; } void SetClassHandlers(RegexClass::RegularExpression & re,REEventHandler & evhandler) { #if defined(__BORLANDC__) re.OnMatching = evhandler.OnMatching; re.OnSearching = evhandler.OnSearching; re.OnGrepping = evhandler.OnGrepping; re.OnMerging = evhandler.OnMerging; re.OnGreppingFiles = evhandler.OnGreppingFiles; re.OnFindFiles = evhandler.OnFindingFiles; re.OnChangingFiles = evhandler.OnMergingFiles; #elif _MSC_VER < 1300 RegexClass::RegularExpression::TypeResultsClosure matchc = REGEX_BIND_ON_MATCHING(&REEventHandler::OnMatching,&evhandler); RegexClass::RegularExpression::TypeResultsClosure searchc = REGEX_BIND_ON_SEARCHING(&REEventHandler::OnSearching,&evhandler); RegexClass::RegularExpression::TypeGrepResultsClosure grepc = REGEX_BIND_ON_GREPPING(&REEventHandler::OnGrepping,&evhandler); RegexClass::RegularExpression::TypeMergeResultsClosure mergec = REGEX_BIND_ON_MERGING(&REEventHandler::OnMerging,&evhandler); RegexClass::RegularExpression::TypeGrepFileResultsClosure grepfilesc = REGEX_BIND_ON_GREPPING_FILES(&REEventHandler::OnGreppingFiles,&evhandler); RegexClass::RegularExpression::TypeFindFileResultsClosure findfilesc = REGEX_BIND_ON_FIND_FILES(&REEventHandler::OnFindingFiles,&evhandler); RegexClass::RegularExpression::TypeChangeFileResultsClosure changefilesc = REGEX_BIND_ON_CHANGING_FILES(&REEventHandler::OnMergingFiles,&evhandler); re.OnMatching = matchc; re.OnSearching = searchc; re.OnGrepping = grepc; re.OnMerging = mergec; re.OnGreppingFiles = grepfilesc; re.OnFindFiles = findfilesc; re.OnChangingFiles = changefilesc; #else re.OnMatchingGlobal = 0; re.OnSearchingGlobal = 0; re.OnGreppingGlobal = 0; re.OnMergingGlobal = 0; re.OnGreppingFilesGlobal = 0; re.OnFindFilesGlobal = 0; re.OnChangingFilesGlobal = 0; __hook(&RegexClass::RegularExpression::OnMatching,&re,&REEventHandler::OnMatching,&evhandler); __hook(&RegexClass::RegularExpression::OnSearching,&re,&REEventHandler::OnSearching,&evhandler); __hook(&RegexClass::RegularExpression::OnGrepping,&re,&REEventHandler::OnGrepping,&evhandler); __hook(&RegexClass::RegularExpression::OnMerging,&re,&REEventHandler::OnMerging,&evhandler); __hook(&RegexClass::RegularExpression::OnGreppingFiles,&re,&REEventHandler::OnGreppingFiles,&evhandler); __hook(&RegexClass::RegularExpression::OnFindFiles,&re,&REEventHandler::OnFindingFiles,&evhandler); __hook(&RegexClass::RegularExpression::OnChangingFiles,&re,&REEventHandler::OnMergingFiles,&evhandler); #endif } void SetClassHandlerMatch(RegexClass::RegularExpression & re,REEventHandler & evhandler) { #if defined(__BORLANDC__) re.OnMatching = evhandler.OnMatching; #elif _MSC_VER < 1300 RegexClass::RegularExpression::TypeResultsClosure matchc = REGEX_BIND_ON_MATCHING(&REEventHandler::OnMatching,&evhandler); re.OnMatching = matchc; #else re.OnMatchingGlobal = 0; __hook(&RegexClass::RegularExpression::OnMatching,&re,&REEventHandler::OnMatching,&evhandler); #endif } void SetClassHandlerSearch(RegexClass::RegularExpression & re,REEventHandler & evhandler) { #if defined(__BORLANDC__) re.OnSearching = evhandler.OnSearching; #elif _MSC_VER < 1300 RegexClass::RegularExpression::TypeResultsClosure searchc = REGEX_BIND_ON_SEARCHING(&REEventHandler::OnSearching,&evhandler); re.OnSearching = searchc; #else re.OnSearchingGlobal = 0; __hook(&RegexClass::RegularExpression::OnSearching,&re,&REEventHandler::OnSearching,&evhandler); #endif } void SetClassHandlerGrep(RegexClass::RegularExpression & re,REEventHandler & evhandler) { #if defined(__BORLANDC__) re.OnGrepping = evhandler.OnGrepping; #elif _MSC_VER < 1300 RegexClass::RegularExpression::TypeGrepResultsClosure grepc = REGEX_BIND_ON_GREPPING(&REEventHandler::OnGrepping,&evhandler); re.OnGrepping = grepc; #else re.OnGreppingGlobal = 0; __hook(&RegexClass::RegularExpression::OnGrepping,&re,&REEventHandler::OnGrepping,&evhandler); #endif } void SetClassHandlerMerge(RegexClass::RegularExpression & re,REEventHandler & evhandler) { #if defined(__BORLANDC__) re.OnMerging = evhandler.OnMerging; #elif _MSC_VER < 1300 RegexClass::RegularExpression::TypeMergeResultsClosure mergec = REGEX_BIND_ON_MERGING(&REEventHandler::OnMerging,&evhandler); re.OnMerging = mergec; #else re.OnMergingGlobal = 0; __hook(&RegexClass::RegularExpression::OnMerging,&re,&REEventHandler::OnMerging,&evhandler); #endif } void SetClassHandlerGrepFiles(RegexClass::RegularExpression & re,REEventHandler & evhandler) { #if defined(__BORLANDC__) re.OnGreppingFiles = evhandler.OnGreppingFiles; #elif _MSC_VER < 1300 RegexClass::RegularExpression::TypeGrepFileResultsClosure grepfilesc = REGEX_BIND_ON_GREPPING_FILES(&REEventHandler::OnGreppingFiles,&evhandler); re.OnGreppingFiles = grepfilesc; #else re.OnGreppingFilesGlobal = 0; __hook(&RegexClass::RegularExpression::OnGreppingFiles,&re,&REEventHandler::OnGreppingFiles,&evhandler); #endif } void SetClassHandlerFindFiles(RegexClass::RegularExpression & re,REEventHandler & evhandler) { #if defined(__BORLANDC__) re.OnFindFiles = evhandler.OnFindingFiles; #elif _MSC_VER < 1300 RegexClass::RegularExpression::TypeFindFileResultsClosure findfilesc = REGEX_BIND_ON_FIND_FILES(&REEventHandler::OnFindingFiles,&evhandler); re.OnFindFiles = findfilesc; #else re.OnFindFilesGlobal = 0; __hook(&RegexClass::RegularExpression::OnFindFiles,&re,&REEventHandler::OnFindingFiles,&evhandler); #endif } void SetClassHandlerChangeFiles(RegexClass::RegularExpression & re,REEventHandler & evhandler) { #if defined(__BORLANDC__) re.SetOnChangingFilesClosure(evhandler.OnMergingFiles); #elif _MSC_VER < 1300 RegexClass::RegularExpression::TypeChangeFileResultsClosure changefilesc = REGEX_BIND_ON_CHANGING_FILES(&REEventHandler::OnMergingFiles,&evhandler); re.SetOnChangingFilesClosure(changefilesc); #else re.OnChangingFilesGlobal = 0; __hook(&RegexClass::RegularExpression::OnChangingFiles,&re,&REEventHandler::OnMergingFiles,&evhandler); #endif } } int DoConsoleTest() { ConsoleSize(); RegexClass::RegularExpression re; REEventHandler evhandler; std::stringstream stream; bool HasBeenStreamed = false; SetGlobalHandlers(re,evhandler); std::string sbuffer; ClearTheScreen(); while (true) { std::cout << "\r\n\r\nInteractive Regular Expression Test\r\n\r\n"; std::cout << "1) Get property\r\n"; std::cout << "2) Set property\r\n"; std::cout << "3) Call method\r\n"; std::cout << "4) Set handlers\n"; std::cout << "x) Exit\r\n\r\n"; char c(GetCharacter()); switch (c) { case '1': { ClearTheScreen(); while(true) { std::cout << "\r\n\r\nGet property\r\n\r\n"; std::cout << "1) Regular expression\r\n"; std::cout << "2) String to match\r\n"; std::cout << "3) Files to match\r\n"; std::cout << "4) Format string\r\n"; std::cout << "5) Format type\r\n"; std::cout << "6) Backup extension\r\n"; std::cout << "7) Directory recursion flag\r\n"; std::cout << "8) Merge copy flag\r\n"; std::cout << "9) Merge only first flag\r\n"; std::cout << "a) Locale DLL\r\n"; std::cout << "b) Locale Model\r\n"; std::cout << "c) Maximum splits\r\n"; std::cout << "d) Split input delete flag\r\n"; std::cout << "e) Continue files flag\r\n"; std::cout << "f) Expression options\r\n"; std::cout << "g) Match options\r\n"; std::cout << "h) Single expression option\r\n"; std::cout << "i) Single match option\r\n"; std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': { std::cout << "\r\nRegular expression = \'" << re.Expression << "\'"; GetCharacter(); } break; case '2': { std::cout << "\r\nString to match = \'" << re.StringToMatch << "\'"; GetCharacter(); } break; case '3': { std::cout << "\r\nFiles to match = \'" << re.FilesToMatch << "\'"; GetCharacter(); } break; case '4': { std::cout << "\r\nFormat string = \'" << re.FormatString << "\'"; GetCharacter(); } break; case '5': { std::cout << "\r\nFormat type = \'"; RegexClass::RegularExpression::FormatTypes ftys = re.FormatType; switch (ftys) { case RegexClass::RegularExpression::FormatTypeAll: std::cout << "All\'"; break; case RegexClass::RegularExpression::FormatTypeSed: std::cout << "Sed\'"; break; case RegexClass::RegularExpression::FormatTypePerl: std::cout << "Perl\'"; break; } GetCharacter(); } break; case '6': { std::cout << "\r\nBackup extension = \'" << re.SaveExtension << "\'"; GetCharacter(); } break; case '7': { std::cout << "\r\nDirectory recurson is " << (re.DirectoryRecursion ? "on" : "off"); GetCharacter(); } break; case '8': { std::cout << "\r\nMerge copy is " << (re.MergeCopy ? "on" : "off"); GetCharacter(); } break; case '9': { std::cout << "\r\nMerge only first is " << (re.MergeOnlyFirst ? "on" : "off"); GetCharacter(); } break; case 'a': { std::cout << "\r\nLocale DLL = \'" << re.LocaleDll << "\'"; GetCharacter(); } break; case 'b': { std::cout << "\r\nLocale Model = \'"; RegexClass::RegularExpression::LocaleModels lcms = re.LocaleModel; switch (lcms) { case RegexClass::RegularExpression::LocaleModelCpp: std::cout << "Cpp\'"; break; case RegexClass::RegularExpression::LocaleModelWin32: std::cout << "Win32\'"; break; case RegexClass::RegularExpression::LocaleModelC: std::cout << "C\'"; break; } GetCharacter(); } break; case 'c': { std::cout << "\r\nMaximum splits = \'" << re.MaximumSplits << "\'"; GetCharacter(); } break; case 'd': { std::cout << "\r\nSplit input delete is " << (re.SplitInputDelete ? "on" : "off"); GetCharacter(); } break; case 'e': { std::cout << "\r\nContinue files is " << (re.ContinueFiles ? "on" : "off"); GetCharacter(); } break; case 'f': { std::cout << "\r\nExpression options are:"; if (re.IsExpressionOption(RegexClass::RegularExpression::EscapeInCharacterSets)) { std::cout << "\r\nEscapeInCharacterSets"; } if (re.IsExpressionOption(RegexClass::RegularExpression::CharacterClasses)) { std::cout << "\r\nCharacterClasses"; } if (re.IsExpressionOption(RegexClass::RegularExpression::Intervals)) { std::cout << "\r\nIntervals"; } if (re.IsExpressionOption(RegexClass::RegularExpression::LimitedOperations)) { std::cout << "\r\nLimitedOperations"; } if (re.IsExpressionOption(RegexClass::RegularExpression::NewlineAsAlternationOperator)) { std::cout << "\r\nNewlineAsAlternationOperator"; } if (re.IsExpressionOption(RegexClass::RegularExpression::QuestionmarkPlusNotOperators)) { std::cout << "\r\nQuestionmarkPlusNotOperators"; } if (re.IsExpressionOption(RegexClass::RegularExpression::BracesNotOperators)) { std::cout << "\r\nBracesNotOperators"; } if (re.IsExpressionOption(RegexClass::RegularExpression::ParenthesesNotOperators)) { std::cout << "\r\nParenthesesNotOperators"; } if (re.IsExpressionOption(RegexClass::RegularExpression::BackReferences)) { std::cout << "\r\nBackReferences"; } if (re.IsExpressionOption(RegexClass::RegularExpression::VerticalbarNotOperator)) { std::cout << "\r\nVerticalbarNotOperator"; } if (re.IsExpressionOption(RegexClass::RegularExpression::Literals)) { std::cout << "\r\nLiterals"; } if (re.IsExpressionOption(RegexClass::RegularExpression::CaseInsensitive)) { std::cout << "\r\nCaseInsensitive"; } if (re.IsExpressionOption(RegexClass::RegularExpression::NoLocaleSpecificCollation)) { std::cout << "\r\nNoLocaleSpecificCollation"; } if (re.IsExpressionOption(RegexClass::RegularExpression::Basic)) { std::cout << "\r\nBasic"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Extended)) { std::cout << "\r\nExtended"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Normal)) { std::cout << "\r\nNormal"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Emacs)) { std::cout << "\r\nEmacs"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Awk)) { std::cout << "\r\nAwk"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::UGrep)) { std::cout << "\r\nUGrep"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Egrep)) { std::cout << "\r\nEgrep"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Sed)) { std::cout << "\r\nSed"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Perl)) { std::cout << "\r\nPerl"; } } break; case 'g': { std::cout << "\r\nMatch options are:"; if (re.IsMatchOption(RegexClass::RegularExpression::MatchDefault)) { std::cout << "\r\nMatchDefault"; } else { if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfLine)) { std::cout << "MatchNotBeginningOfLine\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfLine)) { std::cout << "\r\nMatchNotEndOfLine"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfBuffer)) { std::cout << "\r\nMatchNotBeginningOfBuffer"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfBuffer)) { std::cout << "\r\nMatchNotEndOfBuffer"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfWord)) { std::cout << "\r\nMatchNotBeginningOfWord"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfWord)) { std::cout << "\r\nMatchNotEndOfWord"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotDotNewline)) { std::cout << "\r\nMatchNotDotNewline"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotDotNullCharacter)) { std::cout << "\r\nMatchNotDotNullCharacter"; } } if (re.IsMatchOption(RegexClass::RegularExpression::MatchShortest)) { std::cout << "\r\nMatchShortest"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotNullString)) { std::cout << "\r\nMatchNotNullString"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchContinuous)) { std::cout << "\r\nMatchContinuous"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchPartial)) { std::cout << "\r\nMatchPartial"; } } break; case 'h': { ClearTheScreen(); while (true) { std::cout << "\r\n\r\nGet expression option\r\n\r\n"; std::cout << "1) EscapeInCharacterSets\r\n"; std::cout << "2) CharacterClasses\r\n"; std::cout << "3) Intervals\r\n"; std::cout << "4) LimitedOperations\r\n"; std::cout << "5) NewlineAsAlternationOperator\r\n"; std::cout << "6) QuestionmarkPlusNotOperators\r\n"; std::cout << "7) BracesNotOperators\r\n"; std::cout << "8) ParenthesesNotOperators\r\n"; std::cout << "9) BackReferences\r\n"; std::cout << "a) VerticalbarNotOperator\r\n"; std::cout << "b) Literals\r\n"; std::cout << "c) CaseInsensitive\r\n"; std::cout << "d) NoLocaleSpecificCollation\r\n"; std::cout << "e) Basic\r\n"; std::cout << "f) Extended\r\n"; std::cout << "g) Normal\r\n"; std::cout << "h) Emacs\r\n"; std::cout << "i) Awk\r\n"; std::cout << "j) UGrep\r\n"; std::cout << "k) EGrep\r\n"; std::cout << "l) Sed\r\n"; std::cout << "m) Perl\r\n"; std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': std::cout << "\r\nThe expression option \'EscapeInCharacterSets\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::EscapeInCharacterSets) ? "set" : "not set"); break; case '2': std::cout << "\r\nThe expression option \'CharacterClasses\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::CharacterClasses) ? "set" : "not set"); break; case '3': std::cout << "\r\nThe expression option \'Intervals\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::Intervals) ? "set" : "not set"); break; case '4': std::cout << "\r\nThe expression option \'LimitedOperations\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::LimitedOperations) ? "set" : "not set"); break; case '5': std::cout << "\r\nThe expression option \'NewlineAsAlternationOperator\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::NewlineAsAlternationOperator) ? "set" : "not set"); break; case '6': std::cout << "\r\nThe expression option \'QuestionmarkPlusNotOperators\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::QuestionmarkPlusNotOperators) ? "set" : "not set"); break; case '7': std::cout << "\r\nThe expression option \'BracesNotOperators\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::BracesNotOperators) ? "set" : "not set"); break; case '8': std::cout << "\r\nThe expression option \'ParenthesesNotOperators\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::ParenthesesNotOperators) ? "set" : "not set"); break; case '9': std::cout << "\r\nThe expression option \'BackReferences\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::BackReferences) ? "set" : "not set"); break; case 'a': std::cout << "\r\nThe expression option \'VerticalbarNotOperator\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::VerticalbarNotOperator) ? "set" : "not set"); break; case 'b': std::cout << "\r\nThe expression option \'Literals\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::Literals) ? "set" : "not set"); break; case 'c': std::cout << "\r\nThe expression option \'CaseInsensitive\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::CaseInsensitive) ? "set" : "not set"); break; case 'd': std::cout << "\r\nThe expression option \'NoLocaleSpecificCollation\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::NoLocaleSpecificCollation) ? "set" : "not set"); break; case 'e': std::cout << "\r\nThe expression option \'Basic\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::Basic) ? "set" : "not set"); break; case 'f': std::cout << "\r\nThe expression option \'Extended\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::Extended) ? "set" : "not set"); break; case 'g': std::cout << "\r\nThe expression option \'Normal\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::Normal) ? "set" : "not set"); break; case 'h': std::cout << "\r\nThe expression option \'Emacs\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::Emacs) ? "set" : "not set"); break; case 'i': std::cout << "\r\nThe expression option \'Awk\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::Awk) ? "set" : "not set"); break; case 'j': std::cout << "\r\nThe expression option \'UGrep\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::UGrep) ? "set" : "not set"); break; case 'k': std::cout << "\r\nThe expression option \'Egrep\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::Egrep) ? "set" : "not set"); break; case 'l': std::cout << "\r\nThe expression option \'Sed\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::Sed) ? "set" : "not set"); break; case 'm': std::cout << "\r\nThe expression option \'Perl\' is " << (re.IsExpressionOption(RegexClass::RegularExpression::Perl) ? "set" : "not set"); break; case 'p': back = true; ClearTheScreen(); break; case 'x': return (0); } if (back) { break; } } } break; case 'i': { ClearTheScreen(); while (true) { std::cout << "\r\n\r\nGet match option\r\n\r\n"; std::cout << "1) MatchDefault\r\n"; std::cout << "2) MatchNotBeginningOfLine\r\n"; std::cout << "3) MatchNotEndOfLine\r\n"; std::cout << "4) MatchNotBeginningOfBuffer\r\n"; std::cout << "5) MatchNotEndOfBuffer\r\n"; std::cout << "6) MatchNotBeginningOfWord\r\n"; std::cout << "7) MatchNotEndOfWord\r\n"; std::cout << "8) MatchNotDotNewline\r\n"; std::cout << "9) MatchNotDotNullCharacter\r\n"; std::cout << "a) MatchShortest\r\n"; std::cout << "b) MatchNotNullString\r\n"; std::cout << "c) MatchContinuous\r\n"; std::cout << "d) MatchPartial\r\n"; std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n\r\n"; bool back(false); char c(GetCharacter()); switch (c) { case '1': std::cout << "\r\nThe match option \'MatchDefault\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchDefault) ? "set" : "not set"); break; case '2': std::cout << "\r\nThe match option \'MatchNotBeginningOfLine\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfLine) ? "set" : "not set"); break; case '3': std::cout << "\r\nThe match option \'MatchNotEndOfLine\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfLine) ? "set" : "not set"); break; case '4': std::cout << "\r\nThe match option \'MatchNotBeginningOfBuffer\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfBuffer) ? "set" : "not set"); break; case '5': std::cout << "\r\nThe match option \'MatchNotEndOfBuffer\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfBuffer) ? "set" : "not set"); break; case '6': std::cout << "\r\nThe match option \'MatchNotBeginningOfWord\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfWord) ? "set" : "not set"); break; case '7': std::cout << "\r\nThe match option \'MatchNotEndOfWord\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfWord) ? "set" : "not set"); break; case '8': std::cout << "\r\nThe match option \'MatchNotDotNewline\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchNotDotNewline) ? "set" : "not set"); break; case '9': std::cout << "\r\nThe match option \'MatchNotDotNullCharacter\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchNotDotNullCharacter) ? "set" : "not set"); break; case 'a': std::cout << "\r\nThe match option \'MatchShortest\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchShortest) ? "set" : "not set"); break; case 'b': std::cout << "\r\nThe match option \'MatchNotNullString\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchNotNullString) ? "set" : "not set"); break; case 'c': std::cout << "\r\nThe match option \'MatchContinuous\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchContinuous) ? "set" : "not set"); break; case 'd': std::cout << "\r\nThe match option \'MatchPartial\' is " << (re.IsMatchOption(RegexClass::RegularExpression::MatchPartial) ? "set" : "not set"); break; case 'p': back = true; ClearTheScreen(); break; case 'x': return (0); } if (back) { break; } } } break; case 'p': { back = true; ClearTheScreen(); } break; case 'x': { return(0); } } if (back) { break; } } } break; case '2': { ClearTheScreen(); while(true) { std::cout << "\r\n\r\nSet property\r\n\r\n"; std::cout << "1) Regular expression\r\n"; std::cout << "2) String to match\r\n"; std::cout << "3) Files to match\r\n"; std::cout << "4) Format string\r\n"; std::cout << "5) Format type\r\n"; std::cout << "6) Backup extension\r\n"; std::cout << "7) Directory recursion flag\r\n"; std::cout << "8) Merge copy flag\r\n"; std::cout << "9) Merge only first flag\r\n"; std::cout << "a) Locale DLL\r\n"; std::cout << "b) Locale Model\r\n"; std::cout << "c) Maximum splits\r\n"; std::cout << "d) Split input delete flag\r\n"; std::cout << "e) Continue files flag\r\n"; std::cout << "f) Expression options\r\n"; std::cout << "g) Match options\r\n"; std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': { std::cout << "Enter regular expression property\r\n"; sbuffer = GetString(); re.Expression = sbuffer; } break; case '2': { std::cout << "Enter string to match property\r\n"; sbuffer = GetString(); re.StringToMatch = sbuffer; } break; case '3': { std::cout << "Enter files to match property\r\n"; sbuffer = GetString(); re.FilesToMatch = sbuffer; } break; case '4': { std::cout << "Enter format string property\r\n"; sbuffer = GetString(); re.FormatString = sbuffer; } break; case '5': { std::cout << "Choose format type\r\n\r\n"; std::cout << "1) All\r\n"; std::cout << "2) Sed\r\n"; std::cout << "3) Perl\r\n\r\n"; char c(GetCharacter()); switch (c) { case '1': re.FormatType = RegexClass::RegularExpression::FormatTypeAll; break; case '2': re.FormatType = RegexClass::RegularExpression::FormatTypeSed; break; case '3': re.FormatType = RegexClass::RegularExpression::FormatTypePerl; break; } } break; case '6': { std::cout << "Enter backup extension property\r\n"; sbuffer = GetString(); re.SaveExtension = sbuffer; } break; case '7': { std::cout << "Directory recursion\r\n\r\n"; std::cout << "t) True\r\n"; std::cout << "f) False\r\n"; char c(GetCharacter()); switch (c) { case 't': re.DirectoryRecursion = true; break; case 'f': re.DirectoryRecursion = false; break; } } break; case '8': { std::cout << "Merge copy\r\n\r\n"; std::cout << "t) True\r\n"; std::cout << "f) False\r\n"; char c(GetCharacter()); switch (c) { case 't': re.MergeCopy = true; break; case 'f': re.MergeCopy = false; break; } } break; case '9': { std::cout << "Merge only first\r\n\r\n"; std::cout << "t) True\r\n"; std::cout << "f) False\r\n"; char c(GetCharacter()); switch (c) { case 't': re.MergeOnlyFirst = true; break; case 'f': re.MergeOnlyFirst = false; break; } } break; case 'a': { std::cout << "Enter Locale DLL property\r\n"; sbuffer = GetString(); re.LocaleDll = sbuffer; } break; case 'b': { std::cout << "Choose locale model\r\n\r\n"; std::cout << "1) Cpp\r\n"; std::cout << "2) Win32\r\n"; std::cout << "3) C\r\n\r\n"; char c(GetCharacter()); switch (c) { case '1': re.LocaleModel = RegexClass::RegularExpression::LocaleModelCpp; break; case '2': re.LocaleModel = RegexClass::RegularExpression::LocaleModelWin32; break; case '3': re.LocaleModel = RegexClass::RegularExpression::LocaleModelC; break; } } break; case 'c': { std::cout << "Enter maximum splits\r\n"; sbuffer = GetString(); if (!sbuffer.empty()) { unsigned long mxs(0); std::istringstream iss(sbuffer); iss >> mxs; if (iss) { re.MaximumSplits = mxs; } } } break; case 'd': { std::cout << "Split input delete\r\n\r\n"; std::cout << "t) True\r\n"; std::cout << "f) False\r\n"; char c(GetCharacter()); switch (c) { case 't': re.SplitInputDelete = true; break; case 'f': re.SplitInputDelete = false; break; } } break; case 'e': { std::cout << "Continue files\r\n\r\n"; std::cout << "t) True\r\n"; std::cout << "f) False\r\n"; char c(GetCharacter()); switch (c) { case 't': re.ContinueFiles = true; break; case 'f': re.ContinueFiles = false; break; } } break; case 'f': { ClearTheScreen(); while (true) { std::cout << "\r\n\r\nSet expression option\r\n\r\n"; std::cout << "1) Add\r\n"; std::cout << "2) Delete\r\n"; std::cout << "3) Clear All\r\n"; std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': { ClearTheScreen(); while (true) { std::cout << "\r\n\r\nAdd expression option\r\n\r\n"; if (!re.IsExpressionOption(RegexClass::RegularExpression::EscapeInCharacterSets)) { std::cout << "1) EscapeInCharacterSets\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::CharacterClasses)) { std::cout << "2) CharacterClasses\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::Intervals)) { std::cout << "3) Intervals\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::LimitedOperations)) { std::cout << "4) LimitedOperations\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::NewlineAsAlternationOperator)) { std::cout << "5) NewlineAsAlternationOperator\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::QuestionmarkPlusNotOperators)) { std::cout << "6) QuestionmarkPlusNotOperators\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::BracesNotOperators)) { std::cout << "7) BracesNotOperators\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::ParenthesesNotOperators)) { std::cout << "8) ParenthesesNotOperators\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::BackReferences)) { std::cout << "9) BackReferences\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::VerticalbarNotOperator)) { std::cout << "a) VerticalbarNotOperator\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::Literals)) { std::cout << "b) Literals\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::CaseInsensitive)) { std::cout << "c) CaseInsensitive\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::NoLocaleSpecificCollation)) { std::cout << "d) NoLocaleSpecificCollation\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::Basic)) { std::cout << "e) Basic\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::Extended)) { std::cout << "f) Extended\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::Normal)) { std::cout << "g) Normal\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::Emacs)) { std::cout << "h) Emacs\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::Awk)) { std::cout << "i) Awk\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::UGrep)) { std::cout << "j) UGrep\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::Egrep)) { std::cout << "k) Egrep\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::Sed)) { std::cout << "l) Sed\r\n"; } if (!re.IsExpressionOption(RegexClass::RegularExpression::Perl)) { std::cout << "m) Perl\r\n"; } std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': re.AddExpressionOption(RegexClass::RegularExpression::EscapeInCharacterSets); break; case '2': re.AddExpressionOption(RegexClass::RegularExpression::CharacterClasses); break; case '3': re.AddExpressionOption(RegexClass::RegularExpression::Intervals); break; case '4': re.AddExpressionOption(RegexClass::RegularExpression::LimitedOperations); break; case '5': re.AddExpressionOption(RegexClass::RegularExpression::NewlineAsAlternationOperator); break; case '6': re.AddExpressionOption(RegexClass::RegularExpression::QuestionmarkPlusNotOperators); break; case '7': re.AddExpressionOption(RegexClass::RegularExpression::BracesNotOperators); break; case '8': re.AddExpressionOption(RegexClass::RegularExpression::ParenthesesNotOperators); break; case '9': re.AddExpressionOption(RegexClass::RegularExpression::BackReferences); break; case 'a': re.AddExpressionOption(RegexClass::RegularExpression::VerticalbarNotOperator); break; case 'b': re.AddExpressionOption(RegexClass::RegularExpression::Literals); break; case 'c': re.AddExpressionOption(RegexClass::RegularExpression::CaseInsensitive); break; case 'd': re.AddExpressionOption(RegexClass::RegularExpression::NoLocaleSpecificCollation); break; case 'e': re.AddExpressionOption(RegexClass::RegularExpression::Basic); break; case 'f': re.AddExpressionOption(RegexClass::RegularExpression::Extended); break; case 'g': re.AddExpressionOption(RegexClass::RegularExpression::Normal); break; case 'h': re.AddExpressionOption(RegexClass::RegularExpression::Emacs); break; case 'i': re.AddExpressionOption(RegexClass::RegularExpression::Awk); break; case 'j': re.AddExpressionOption(RegexClass::RegularExpression::UGrep); break; case 'k': re.AddExpressionOption(RegexClass::RegularExpression::Egrep); break; case 'l': re.AddExpressionOption(RegexClass::RegularExpression::Sed); break; case 'm': re.AddExpressionOption(RegexClass::RegularExpression::Perl); break; case 'p': back = true; ClearTheScreen(); break; case 'x': return(0); } if (back) { break; } } } break; case '2': { ClearTheScreen(); while (true) { std::cout << "\r\n\r\nDelete expression option\r\n\r\n"; if (re.IsExpressionOption(RegexClass::RegularExpression::EscapeInCharacterSets)) { std::cout << "1) EscapeInCharacterSets\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::CharacterClasses)) { std::cout << "2) CharacterClasses\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::Intervals)) { std::cout << "3) Intervals\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::LimitedOperations)) { std::cout << "4) LimitedOperations\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::NewlineAsAlternationOperator)) { std::cout << "5) NewlineAsAlternationOperator\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::QuestionmarkPlusNotOperators)) { std::cout << "6) QuestionmarkPlusNotOperators\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::BracesNotOperators)) { std::cout << "7) BracesNotOperators\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::ParenthesesNotOperators)) { std::cout << "8) ParenthesesNotOperators\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::BackReferences)) { std::cout << "9) BackReferences\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::VerticalbarNotOperator)) { std::cout << "a) VerticalbarNotOperator\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::Literals)) { std::cout << "b) Literals\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::CaseInsensitive)) { std::cout << "c) CaseInsensitive\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::NoLocaleSpecificCollation)) { std::cout << "d) NoLocaleSpecificCollation\r\n"; } if (re.IsExpressionOption(RegexClass::RegularExpression::Basic)) { std::cout << "e) Basic\r\n"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Extended)) { std::cout << "f) Extended\r\n"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Normal)) { std::cout << "g) Normal\r\n"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Emacs)) { std::cout << "h) Emacs\r\n"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Awk)) { std::cout << "i) Awk\r\n"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::UGrep)) { std::cout << "j) UGrep\r\n"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Egrep)) { std::cout << "k) Egrep\r\n"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Sed)) { std::cout << "l) Sed\r\n"; } else if (re.IsExpressionOption(RegexClass::RegularExpression::Perl)) { std::cout << "m) Perl\r\n"; } std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': re.DeleteExpressionOption(RegexClass::RegularExpression::EscapeInCharacterSets); break; case '2': re.DeleteExpressionOption(RegexClass::RegularExpression::CharacterClasses); break; case '3': re.DeleteExpressionOption(RegexClass::RegularExpression::Intervals); break; case '4': re.DeleteExpressionOption(RegexClass::RegularExpression::LimitedOperations); break; case '5': re.DeleteExpressionOption(RegexClass::RegularExpression::NewlineAsAlternationOperator); break; case '6': re.DeleteExpressionOption(RegexClass::RegularExpression::QuestionmarkPlusNotOperators); break; case '7': re.DeleteExpressionOption(RegexClass::RegularExpression::BracesNotOperators); break; case '8': re.DeleteExpressionOption(RegexClass::RegularExpression::ParenthesesNotOperators); break; case '9': re.DeleteExpressionOption(RegexClass::RegularExpression::BackReferences); break; case 'a': re.DeleteExpressionOption(RegexClass::RegularExpression::VerticalbarNotOperator); break; case 'b': re.DeleteExpressionOption(RegexClass::RegularExpression::Literals); break; case 'c': re.DeleteExpressionOption(RegexClass::RegularExpression::CaseInsensitive); break; case 'd': re.DeleteExpressionOption(RegexClass::RegularExpression::NoLocaleSpecificCollation); break; case 'e': re.DeleteExpressionOption(RegexClass::RegularExpression::Basic); break; case 'f': re.DeleteExpressionOption(RegexClass::RegularExpression::Extended); break; case 'g': re.DeleteExpressionOption(RegexClass::RegularExpression::Normal); break; case 'h': re.DeleteExpressionOption(RegexClass::RegularExpression::Emacs); break; case 'i': re.DeleteExpressionOption(RegexClass::RegularExpression::Awk); break; case 'j': re.DeleteExpressionOption(RegexClass::RegularExpression::UGrep); break; case 'k': re.DeleteExpressionOption(RegexClass::RegularExpression::Egrep); break; case 'l': re.DeleteExpressionOption(RegexClass::RegularExpression::Sed); break; case 'm': re.DeleteExpressionOption(RegexClass::RegularExpression::Perl); break; case 'p': back = true; ClearTheScreen(); break; case 'x': return(0); } if (back) { break; } } } break; case '3': re.ClearExpressionOptions(); break; case 'p': back = true; ClearTheScreen(); break; case 'x': return(0); } if (back) { break; } } } break; case 'g': { ClearTheScreen(); while (true) { std::cout << "\r\n\r\nSet match option\r\n\r\n"; std::cout << "1) Add\r\n"; std::cout << "2) Delete\r\n"; std::cout << "3) Clear All\r\n"; std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': { ClearTheScreen(); while (true) { std::cout << "\r\n\r\nAdd match option\r\n\r\n"; if (!re.IsMatchOption(RegexClass::RegularExpression::MatchDefault)) { std::cout << "1) MatchDefault\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfLine)) { std::cout << "2) MatchNotBeginningOfLine\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfLine)) { std::cout << "3) MatchNotEndOfLine\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfBuffer)) { std::cout << "4) MatchNotBeginningOfBuffer\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfBuffer)) { std::cout << "5) MatchNotEndOfBuffer\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfWord)) { std::cout << "6) MatchNotBeginningOfWord\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfWord)) { std::cout << "7) MatchNotEndOfWord\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchNotDotNewline)) { std::cout << "8) MatchNotDotNewline\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchNotDotNullCharacter)) { std::cout << "9) MatchNotDotNullCharacter\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchShortest)) { std::cout << "a) MatchShortest\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchNotNullString)) { std::cout << "b) MatchNotNullString\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchContinuous)) { std::cout << "c) MatchContinuous\r\n"; } if (!re.IsMatchOption(RegexClass::RegularExpression::MatchPartial)) { std::cout << "d) MatchPartial\r\n"; } std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': re.AddMatchOption(RegexClass::RegularExpression::MatchDefault); break; case '2': re.AddMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfLine); break; case '3': re.AddMatchOption(RegexClass::RegularExpression::MatchNotEndOfLine); break; case '4': re.AddMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfBuffer); break; case '5': re.AddMatchOption(RegexClass::RegularExpression::MatchNotEndOfBuffer); break; case '6': re.AddMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfWord); break; case '7': re.AddMatchOption(RegexClass::RegularExpression::MatchNotEndOfWord); break; case '8': re.AddMatchOption(RegexClass::RegularExpression::MatchNotDotNewline); break; case '9': re.AddMatchOption(RegexClass::RegularExpression::MatchNotDotNullCharacter); break; case 'a': re.AddMatchOption(RegexClass::RegularExpression::MatchShortest); break; case 'b': re.AddMatchOption(RegexClass::RegularExpression::MatchNotNullString); break; case 'c': re.AddMatchOption(RegexClass::RegularExpression::MatchContinuous); break; case 'd': re.AddMatchOption(RegexClass::RegularExpression::MatchPartial); break; case 'p': back = true; ClearTheScreen(); break; case 'x': return(0); } if (back) { break; } } } break; case '2': { ClearTheScreen(); while (true) { std::cout << "\r\n\r\nDelete match option\r\n\r\n"; if (re.IsMatchOption(RegexClass::RegularExpression::MatchDefault)) { std::cout << "1) MatchDefault\r\n"; } else { if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfLine)) { std::cout << "2) MatchNotBeginningOfLine\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfLine)) { std::cout << "3) MatchNotEndOfLine\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfBuffer)) { std::cout << "4) MatchNotBeginningOfBuffer\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfBuffer)) { std::cout << "5) MatchNotEndOfBuffer\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfWord)) { std::cout << "6) MatchNotBeginningOfWord\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotEndOfWord)) { std::cout << "7) MatchNotEndOfWord\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotDotNewline)) { std::cout << "8) MatchNotDotNewline\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotDotNullCharacter)) { std::cout << "9) MatchNotDotNullCharacter\r\n"; } } if (re.IsMatchOption(RegexClass::RegularExpression::MatchShortest)) { std::cout << "a) MatchShortest\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchNotNullString)) { std::cout << "b) MatchNotNullString\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchContinuous)) { std::cout << "c) MatchContinuous\r\n"; } if (re.IsMatchOption(RegexClass::RegularExpression::MatchPartial)) { std::cout << "d) MatchPartial\r\n"; } std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': re.DeleteMatchOption(RegexClass::RegularExpression::MatchDefault); break; case '2': re.DeleteMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfLine); break; case '3': re.DeleteMatchOption(RegexClass::RegularExpression::MatchNotEndOfLine); break; case '4': re.DeleteMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfBuffer); break; case '5': re.DeleteMatchOption(RegexClass::RegularExpression::MatchNotEndOfBuffer); break; case '6': re.DeleteMatchOption(RegexClass::RegularExpression::MatchNotBeginningOfWord); break; case '7': re.DeleteMatchOption(RegexClass::RegularExpression::MatchNotEndOfWord); break; case '8': re.DeleteMatchOption(RegexClass::RegularExpression::MatchNotDotNewline); break; case '9': re.DeleteMatchOption(RegexClass::RegularExpression::MatchNotDotNullCharacter); break; case 'a': re.DeleteMatchOption(RegexClass::RegularExpression::MatchShortest); break; case 'b': re.DeleteMatchOption(RegexClass::RegularExpression::MatchNotNullString); break; case 'c': re.DeleteMatchOption(RegexClass::RegularExpression::MatchContinuous); break; case 'd': re.DeleteMatchOption(RegexClass::RegularExpression::MatchPartial); break; case 'p': back = true; ClearTheScreen(); break; case 'x': return(0); } if (back) { break; } } } break; case '3': re.ClearMatchOptions(); break; case 'p': back = true; ClearTheScreen(); break; case 'x': return(0); } if (back) { break; } } } break; case 'p': back = true; ClearTheScreen(); break; case 'x': return(0); } if (back) { break; } } } break; case '3': { ClearTheScreen(); while(true) { std::cout << "\r\n\r\nCall method\r\n\r\n"; std::cout << "1) ParseExpression\r\n"; std::cout << "2) GetExpressionError\r\n"; std::cout << "3) NumberOfSubexpressions\r\n"; std::cout << "4) MatchAll\r\n"; std::cout << "5) Match\r\n"; std::cout << "6) Search\r\n"; std::cout << "7) Grep\r\n"; std::cout << "8) GrepFiles\r\n"; std::cout << "9) FindFiles\r\n"; std::cout << "a) ChangeFiles\r\n"; std::cout << "b) Merge\r\n"; std::cout << "c) Split\r\n"; std::cout << "d) Stream out\r\n"; std::cout << "e) Stream in\r\n"; std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': { RegexClass::RegularExpression::ExpressionErrorCode eec = re.ParseExpression(); if (eec == RegexClass::RegularExpression::REG_NOERROR) { std::cout << "\r\n\r\nParseExpression is successful\r\n\r\n"; } else { std::cout << "\r\n\r\nParseExpression returned error "; switch (eec) { case RegexClass::RegularExpression::REG_NOEXPRESSION: std::cout << "REG_NOEXPRESSION, No expression specified"; break; case RegexClass::RegularExpression::REG_BADPAT: std::cout << "REG_BADPAT, Invalid pattern"; break; case RegexClass::RegularExpression::REG_ECOLLATE: std::cout << "REG_ECOLLATE, Undefined collating element"; break; case RegexClass::RegularExpression::REG_ECTYPE: std::cout << "REG_ECTYPE, Invalid character class name"; break; case RegexClass::RegularExpression::REG_EESCAPE: std::cout << "REG_EESCAPE, Trailing backslash"; break; case RegexClass::RegularExpression::REG_ESUBREG: std::cout << "REG_ESUBREG, Invalid back reference"; break; case RegexClass::RegularExpression::REG_EBRACK: std::cout << "REG_EBRACK, Unmatched left bracket"; break; case RegexClass::RegularExpression::REG_EPAREN: std::cout << "REG_EPAREN, Parenthesis imbalance"; break; case RegexClass::RegularExpression::REG_EBRACE: std::cout << "REG_EBRACE, Unmatched {"; break; case RegexClass::RegularExpression::REG_BADBR: std::cout << "REG_BADBR, Invalid contents of {}"; break; case RegexClass::RegularExpression::REG_ERANGE: std::cout << "REG_ERANGE, Invalid range end"; break; case RegexClass::RegularExpression::REG_ESPACE: std::cout << "REG_ESPACE, Out of memory"; break; case RegexClass::RegularExpression::REG_BADRPT: std::cout << "REG_BADRPT, No preceding regular expression for repetition operation"; break; case RegexClass::RegularExpression::REG_EEND: std::cout << "REG_EEND, Unexpected end of expression"; break; case RegexClass::RegularExpression::REG_ESIZE: std::cout << "REG_ESIZE, Expression too big"; break; case RegexClass::RegularExpression::REG_ERPAREN: std::cout << "REG_ERPAREN, Unmatched right parenthesis"; break; case RegexClass::RegularExpression::REG_EMPTY: std::cout << "REG_EMPTY, Empty expression"; break; case RegexClass::RegularExpression::REG_E_MEMORY: std::cout << "REG_E_MEMORY, Out of memory"; break; case RegexClass::RegularExpression::REG_E_UNKNOWN: std::cout << "REG_E_UNKNOWN, Unknown error"; break; case RegexClass::RegularExpression::REG_E_DLL: std::cout << "REG_E_DLL, Locale DLL could not be opened"; break; } std::cout << "\r\n\r\n"; } } break; case '2': { std::string ss(re.GetExpressionError()); if (ss.empty()) { std::cout << "\r\n\r\nNo error exists\r\n\r\n"; } else { std::cout << "\r\n\r\n"; std::cout << ss.c_str(); std::cout << "\r\n\r\n"; } } break; case '3': { unsigned nos = re.NumberOfSubexpressions(); std::ostringstream oss; oss << nos; std::string ss(oss.str()); std::string regx(re.GetExpression()); std::cout << "\r\n\r\nThe number of subexpressions in the regular expression \'" << regx << "\' is " << ss << "\r\n\r\n"; } break; case '4': if (re.MatchAll()) { std::cout << "\r\n\r\nMatchAll is successful.\r\n\r\n"; } else { std::cout << "\r\n\r\nMatchAll is not successful.\r\n\r\n"; } break; case '5': if (re.Match()) { std::cout << "\r\n\r\nMatch is successful.\r\n\r\n"; } else { std::cout << "\r\n\r\nMatch is not successful.\r\n\r\n"; } break; case '6': if (re.Search()) { std::cout << "\r\n\r\nSearch is successful.\r\n\r\n"; } else { std::cout << "\r\n\r\nSearch is not successful.\r\n\r\n"; } break; case '7': { YesToAll = false; unsigned mf = re.Grep(); if (mf) { std::ostringstream oss; oss << "\r\n\r\nThe number of matches that grep has found is " << mf << " .\r\n\r\n"; std::string s(oss.str()); std::cout << s.c_str(); } else { std::cout << "\r\n\r\nGrep has no matches.\r\n\r\n"; } } break; case '8': { YesToAll = false; NoToAll = false; unsigned gf = re.GrepFiles(); if (gf) { std::ostringstream oss; oss << "\r\n\r\nThe number of matches that GrepFiles has found is " << gf << " .\r\n\r\n"; std::string s(oss.str()); std::cout << s.c_str(); } else { std::cout << "\r\n\r\nGrepFiles has no matches.\r\n\r\n"; } const std::vector<RegexClass::RegularExpression::FileSearchProblem> * fcps = re.GetGrepFilesErrors(); if (fcps) { std::cout << "There are grep file errors. Do you want to view them ? (Y/N) "; char c(GetCharacter()); std::cout << "\r\n"; if (c == 'Y' || c == 'y') { std::cout << "\r\n"; std::vector<RegexClass::RegularExpression::FileSearchProblem>::const_iterator cit; for (cit = fcps -> begin(); cit != fcps -> end(); ++cit) { std::ostringstream oss; oss << "Grep file error:" << "\r\n" << " File = " << cit -> file << "\r\n" << " Type = "; switch (cit -> error) { case RegexClass::RegularExpression::FileSearchOpen: oss << "Error opening file" << "\r\n"; break; case RegexClass::RegularExpression::FileSearchMap: oss << "Error mapping file" << "\r\n"; break; case RegexClass::RegularExpression::FileSearchView: oss << "Error viewing file" << "\r\n"; break; } std::string werror = WindowsError(cit -> WinLastError); oss << " Windows error = \"" << werror << "\"\r\n"; std::string ss(oss.str()); std::cout << ss.c_str(); } } } } break; case '9': { YesToAll = false; unsigned ff = re.FindFiles(); if (ff) { std::ostringstream oss; oss << "\r\n\r\nThe number of files in which FindFiles has found matches is " << ff << " .\r\n\r\n"; std::string s(oss.str()); std::cout << s.c_str(); } else { std::cout << "\r\n\r\nFindFiles has no matches.\r\n\r\n"; } const std::vector<RegexClass::RegularExpression::FileSearchProblem> * fcps = re.GetFindFilesErrors(); if (fcps) { std::cout << "There are find file errors. Do you want to view them ? (Y/N) "; char c(GetCharacter()); std::cout << "\r\n"; if (c == 'Y' || c == 'y') { std::cout << "\r\n"; std::vector<RegexClass::RegularExpression::FileSearchProblem>::const_iterator cit; for (cit = fcps -> begin(); cit != fcps -> end(); ++cit) { std::ostringstream oss; oss << "Find file error:" << "\r\n" << " File = " << cit -> file << "\r\n" << " Type = "; switch (cit -> error) { case RegexClass::RegularExpression::FileSearchOpen: oss << "Error opening file" << "\r\n"; break; case RegexClass::RegularExpression::FileSearchMap: oss << "Error mapping file" << "\r\n"; break; case RegexClass::RegularExpression::FileSearchView: oss << "Error viewing file" << "\r\n"; break; } std::string werror = WindowsError(cit -> WinLastError); oss << " Windows error = \"" << werror << "\"\r\n"; std::string ss(oss.str()); std::cout << ss.c_str(); } } } } break; case 'a': { YesToAll = false; NoToAll = false; unsigned ff = re.ChangeFiles(); if (ff) { std::ostringstream oss; oss << "\r\n\r\nThe number of files in which ChangeFiles has made changes is " << ff << " .\r\n\r\n"; std::string s(oss.str()); std::cout << s.c_str(); } else { std::cout << "\r\n\r\nChangeFiles has made no changes.\r\n\r\n"; } const std::vector<RegexClass::RegularExpression::FileChangeProblem> * fcps = re.GetChangeFilesErrors(); if (fcps) { std::cout << "There are change file errors. Do you want to view them ? (Y/N) "; char c(GetCharacter()); std::cout << "\r\n"; if (c == 'Y' || c == 'y') { std::cout << "\r\n"; std::vector<RegexClass::RegularExpression::FileChangeProblem>::const_iterator cit; for (cit = fcps -> begin(); cit != fcps -> end(); ++cit) { std::ostringstream oss; oss << "Change file error:" << "\r\n" << " File = " << cit -> file << "\r\n" << " Type = "; switch (cit -> error) { case RegexClass::RegularExpression::FileChangeOpenOriginal: oss << "Error opening original file" << "\r\n"; break; case RegexClass::RegularExpression::FileChangeCreateTemporary: oss << "Error creating temporary file" << "\r\n"; break; case RegexClass::RegularExpression::FileChangeReadOriginal: oss << "Error reading original file" << "\r\n"; break; case RegexClass::RegularExpression::FileChangeWriteTemporary: oss << "Error writing temporary file" << "\r\n"; break; case RegexClass::RegularExpression::FileChangeDataMismatch: oss << "Data mismatch" << "\r\n"; break; case RegexClass::RegularExpression::FileChangeCopyToBackup: oss << "Error copying file to backup name" << "\r\n"; break; case RegexClass::RegularExpression::FileChangeCopyToNew: oss << "Error copying temporary file to original file" << "\r\n"; break; case RegexClass::RegularExpression::FileChangeSetNewAttributes: oss << "Error setting file attributes back to original file" << "\r\n"; break; } std::string werror = WindowsError(cit -> WinLastError); oss << " Position = " << cit -> position << "\r\n" << " Data = " << cit -> data << "\r\n" << " Windows error = \"" << werror << "\"\r\n"; std::string ss(oss.str()); std::cout << ss.c_str(); } } } } break; case 'b': { YesToAll = false; std::string out; re.Merge(out); std::ostringstream oss; oss << "\r\n\r\nThe merged output string is \"" << out << "\".\r\n\r\n"; std::string s(oss.str()); std::cout << s.c_str(); } break; case 'c': { std::vector<std::string> out; unsigned sps = re.Split(out); std::ostringstream oss; oss << "\r\n\r\nThe number of splits is " << sps << "."; if (sps) { oss << "\r\nThe split strings are:\r\n"; for (std::vector<std::string>::iterator it = out.begin(); it != out.end(); ++it) { oss << "\r\n\'" << *it << "\'"; } } std::string s(oss.str()); std::cout << s.c_str(); } break; case 'd': if (HasBeenStreamed) { HasBeenStreamed = false; stream.flush(); if (!stream) { std::cout << "\r\n\r\nError flushing output stream.\r\n\r\n"; stream.clear(); break; } } stream << re; if (!stream) { std::cout << "\r\n\r\nError streaming out the regular expression object.\r\n\r\n"; stream.clear(); stream.flush(); } else { HasBeenStreamed = true; } break; case 'e': if (HasBeenStreamed) { stream.seekg(0,std::ios_base::beg); if (!stream) { std::cout << "\r\n\r\nError seeking to beginning of input stream.\r\n\r\n"; stream.clear(); stream.flush(); HasBeenStreamed = false; } else { stream >> re; if (!stream) { std::cout << "\r\n\r\nError streaming in the regular expression object.\r\n\r\n"; stream.clear(); stream.flush(); HasBeenStreamed = false; } } } break; case 'p': back = true; ClearTheScreen(); break; case 'x': return(0); } if (back) { break; } } } break; case '4': ClearTheScreen(); while(true) { std::cout << "\r\n\r\nSet Handler\r\n\r\n"; std::cout << "1) All globals\r\n"; std::cout << "2) All member functions\r\n"; std::cout << "3) Individual global\r\n"; std::cout << "4) Individual member function\r\n"; std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': { SetGlobalHandlers(re,evhandler); back = true; ClearTheScreen(); } break; case '2': { SetClassHandlers(re,evhandler); back = true; ClearTheScreen(); } break; case '3': { ClearTheScreen(); while (true) { std::cout << "\r\n\r\nSet global handler\r\n\r\n"; std::cout << "1) OnMatching\r\n"; std::cout << "2) OnSearching\r\n"; std::cout << "3) OnGrepping\r\n"; std::cout << "4) OnMerging\r\n"; std::cout << "5) OnFindFiles\r\n"; std::cout << "6) OnGrepFiles\r\n"; std::cout << "7) OnMergeFiles\r\n"; std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': #if defined(_MSC_VER) && _MSC_VER >= 1300 __unhook(&RegexClass::RegularExpression::OnMatching,&re,&REEventHandler::OnMatching,&evhandler); #endif re.OnMatchingGlobal = OnMatching; break; case '2': #if defined(_MSC_VER) && _MSC_VER >= 1300 __unhook(&RegexClass::RegularExpression::OnSearching,&re,&REEventHandler::OnSearching,&evhandler); #endif re.OnSearchingGlobal = OnSearching; break; case '3': #if defined(_MSC_VER) && _MSC_VER >= 1300 __unhook(&RegexClass::RegularExpression::OnGrepping,&re,&REEventHandler::OnGrepping,&evhandler); #endif re.OnGreppingGlobal = OnGrepping; break; case '4': #if defined(_MSC_VER) && _MSC_VER >= 1300 __unhook(&RegexClass::RegularExpression::OnMerging,&re,&REEventHandler::OnMerging,&evhandler); #endif re.OnMergingGlobal = OnMerging; break; case '5': #if defined(_MSC_VER) && _MSC_VER >= 1300 __unhook(&RegexClass::RegularExpression::OnFindFiles,&re,&REEventHandler::OnFindingFiles,&evhandler); #endif re.OnFindFilesGlobal = OnFindingFiles; break; case '6': #if defined(_MSC_VER) && _MSC_VER >= 1300 __unhook(&RegexClass::RegularExpression::OnGreppingFiles,&re,&REEventHandler::OnGreppingFiles,&evhandler); #endif re.OnGreppingFilesGlobal = OnGreppingFiles; break; case '7': #if defined(_MSC_VER) && _MSC_VER >= 1300 __unhook(&RegexClass::RegularExpression::OnChangingFiles,&re,&REEventHandler::OnMergingFiles,&evhandler);#endif re.OnChangingFilesGlobal = OnMergingFiles; break; case 'p': back = true; ClearTheScreen(); break; case 'x': return(0); } if (back) { break; } } } break; case '4': { ClearTheScreen(); while (true) { std::cout << "\r\n\r\nSet member function handler\r\n\r\n"; std::cout << "1) OnMatching\r\n"; std::cout << "2) OnSearching\r\n"; std::cout << "3) OnGrepping\r\n"; std::cout << "4) OnMerging\r\n"; std::cout << "5) OnFindFiles\r\n"; std::cout << "6) OnGrepFiles\r\n"; std::cout << "7) OnMergeFiles\r\n"; std::cout << "p) Previous menu\r\n"; std::cout << "x) Exit\r\n\r\n"; char c(GetCharacter()); bool back(false); switch (c) { case '1': SetClassHandlerMatch(re,evhandler); break; case '2': SetClassHandlerSearch(re,evhandler); break; case '3': SetClassHandlerGrep(re,evhandler); break; case '4': SetClassHandlerMerge(re,evhandler); break; case '5': SetClassHandlerFindFiles(re,evhandler); break; case '6': SetClassHandlerGrepFiles(re,evhandler); break; case '7': SetClassHandlerChangeFiles(re,evhandler); break; case 'p': back = true; ClearTheScreen(); break; case 'x': return(0); } if (back) { break; } } } break; case 'p': { back = true; ClearTheScreen(); } break; case 'x': { return(0); } } if (back) { break; } } break; case 'x': { return(0); } } } } #if defined(__BORLANDC__) void CALLBACK REEventHandler::OnMatching(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine) { std::cout << "\r\n\r\nMatching event member function"; DoMatching(cre,Matches,LineIndex,StartOfLine); } void CALLBACK REEventHandler::OnSearching(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine) { std::cout << "\r\n\r\nSearching event member function"; DoSearching(cre,Matches,LineIndex,StartOfLine); } void CALLBACK REEventHandler::OnGrepping(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine,bool & bcontinue) { std::cout << "\r\n\r\nGrepping event member function"; DoGrepping(cre,Matches,LineIndex,StartOfLine,bcontinue); } void CALLBACK REEventHandler::OnGreppingFiles(RegexClass::RegularExpression * cre,std::string file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue) { std::cout << "\r\n\r\nGrepping Files event member function"; DoGreppingFiles(cre,file,Matches,LineIndex,bcontinue); } void CALLBACK REEventHandler::OnFindingFiles(RegexClass::RegularExpression * cre,std::string file,bool & bcontinue) { std::cout << "\r\n\r\nFinding Files event member function"; DoFindingFiles(cre,file,bcontinue); } void CALLBACK REEventHandler::OnMerging(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine,bool & bcontinue) { std::cout << "\r\n\r\nMerging event member function"; DoMerging(cre,Matches,LineIndex,StartOfLine,bcontinue); } void CALLBACK REEventHandler::OnMergingFiles(RegexClass::RegularExpression * cre,std::string file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue) { std::cout << "\r\n\r\nMerging Files event member function"; DoMergingFiles(cre,file,Matches,LineIndex,bcontinue); } #else void REEventHandler::OnMatching(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine) { std::cout << "\r\n\r\nMatching event member function"; DoMatching(cre,Matches,LineIndex,StartOfLine); } void REEventHandler::OnSearching(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine) { std::cout << "\r\n\r\nSearching event member function"; DoSearching(cre,Matches,LineIndex,StartOfLine); } void REEventHandler::OnGrepping(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine,bool & bcontinue) { std::cout << "\r\n\r\nGrepping event member function"; DoGrepping(cre,Matches,LineIndex,StartOfLine,bcontinue); } #if _MSC_VER > 1310 void REEventHandler::OnGreppingFiles(RegexClass::RegularExpression * cre,const std::string & file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue) #else void REEventHandler::OnGreppingFiles(RegexClass::RegularExpression * cre,std::string file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue) #endif { std::cout << "\r\n\r\nGrepping Files event member function"; DoGreppingFiles(cre,file,Matches,LineIndex,bcontinue); } #if _MSC_VER > 1310 void REEventHandler::OnFindingFiles(RegexClass::RegularExpression * cre,const std::string & file,bool & bcontinue) #else void REEventHandler::OnFindingFiles(RegexClass::RegularExpression * cre,std::string file,bool & bcontinue) #endif { std::cout << "\r\n\r\nFinding Files event member function"; DoFindingFiles(cre,file,bcontinue); } void REEventHandler::OnMerging(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine,bool & bcontinue) { std::cout << "\r\n\r\nMerging event member function"; DoMerging(cre,Matches,LineIndex,StartOfLine,bcontinue); } #if _MSC_VER > 1310 void REEventHandler::OnMergingFiles(RegexClass::RegularExpression * cre,const std::string & file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue) #else void REEventHandler::OnMergingFiles(RegexClass::RegularExpression * cre,std::string file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue) #endif { std::cout << "\r\n\r\nMerging Files event member function"; DoMergingFiles(cre,file,Matches,LineIndex,bcontinue); } #endifvoid CALLBACK OnMatching(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine) { std::cout << "\r\n\r\nMatching event global function"; DoMatching(cre,Matches,LineIndex,StartOfLine); } void CALLBACK OnSearching(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine) { std::cout << "\r\n\r\nSearching event global function"; DoSearching(cre,Matches,LineIndex,StartOfLine); } void CALLBACK OnGrepping(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine,bool & bcontinue) { std::cout << "\r\n\r\nGrepping event global function"; DoGrepping(cre,Matches,LineIndex,StartOfLine,bcontinue); } #if defined(_MSC_VER) && (_MSC_VER > 1310)void CALLBACK OnGreppingFiles(RegexClass::RegularExpression * cre,const std::string & file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue)#elsevoid CALLBACK OnGreppingFiles(RegexClass::RegularExpression * cre,std::string file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue)#endif { std::cout << "\r\n\r\nGrepping Files event global function"; DoGreppingFiles(cre,file,Matches,LineIndex,bcontinue); } #if defined(_MSC_VER) && (_MSC_VER > 1310)void CALLBACK OnFindingFiles(RegexClass::RegularExpression * cre,const std::string & file,bool & bcontinue)#elsevoid CALLBACK OnFindingFiles(RegexClass::RegularExpression * cre,std::string file,bool & bcontinue)#endif { std::cout << "\r\n\r\nFinding Files event global function"; DoFindingFiles(cre,file,bcontinue); }void CALLBACK OnMerging(RegexClass::RegularExpression * cre,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,unsigned StartOfLine,bool & bcontinue) { std::cout << "\r\n\r\nMerging event global function"; DoMerging(cre,Matches,LineIndex,StartOfLine,bcontinue); } #if defined(_MSC_VER) && (_MSC_VER > 1310)void CALLBACK OnMergingFiles(RegexClass::RegularExpression * cre,const std::string & file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue)#elsevoid CALLBACK OnMergingFiles(RegexClass::RegularExpression * cre,std::string file,const RegexClass::REMatchInfo & Matches,unsigned LineIndex,bool & bcontinue)#endif { std::cout << "\r\n\r\nMerging Files event global function"; DoMergingFiles(cre,file,Matches,LineIndex,bcontinue); }