#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"
#endif

namespace
  {
  
  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);
    
    }
  
#endif

void 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)

#else

void 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)

#else

void 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)

#else

void 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);
  
  }