ENH: Merged use of the kwsys RegularExpression class instead of cmRegularExpression.

24 files changed, 99 insertions, 1658 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 63f67bd..3a51bcf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -35,6 +35,7 @@ ENDIF(CMAKE_SYSTEM MATCHES "OSF1-V.*")
 SET(KWSYS_NAMESPACE cmsys)
 SET(KWSYS_USE_SystemTools 1)
 SET(KWSYS_USE_Directory 1)
+SET(KWSYS_USE_RegularExpression 1)
 SET(KWSYS_HEADER_ROOT ${CMake_BINARY_DIR}/Source)
 SUBDIRS(Source/kwsys)
 
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index c517353..de3d7f7 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -5,7 +5,6 @@ cmake.cxx
 cmakewizard.cxx
 cmMakeDepend.cxx
 cmMakefile.cxx
-cmRegularExpression.cxx
 cmSourceFile.cxx
 cmSystemTools.cxx
 cmDocumentation.cxx
@@ -25,7 +24,6 @@ cmake.h
 cmakewizard.h
 cmMakeDepend.h
 cmMakefile.h
-cmRegularExpression.h
 cmSourceFile.h
 cmSystemTools.h
 cmDynamicLoader.h
diff --git a/Source/cmBuildNameCommand.cxx b/Source/cmBuildNameCommand.cxx
index cec21a0..a650fad 100644
--- a/Source/cmBuildNameCommand.cxx
+++ b/Source/cmBuildNameCommand.cxx
@@ -16,6 +16,8 @@
 =========================================================================*/
 #include "cmBuildNameCommand.h"
 
+#include <cmsys/RegularExpression.hxx>
+
 // cmBuildNameCommand
 bool cmBuildNameCommand::InitialPass(std::vector<std::string> const& args)
 {
@@ -28,7 +30,7 @@ bool cmBuildNameCommand::InitialPass(std::vector<std::string> const& args)
   if(cacheValue)
     {
     // do we need to correct the value? 
-    cmRegularExpression reg("[()/]");
+    cmsys::RegularExpression reg("[()/]");
     if (reg.find(cacheValue))
       {
       std::string cv = cacheValue;
@@ -53,7 +55,7 @@ bool cmBuildNameCommand::InitialPass(std::vector<std::string> const& args)
     if(buildname.length())
       {
       std::string RegExp = "([^ ]*) [^ ]* ([^ ]*) ";
-      cmRegularExpression reg( RegExp.c_str() );
+      cmsys::RegularExpression reg( RegExp.c_str() );
       if(reg.find(buildname.c_str()))
         {
         buildname = reg.match(1) + "-" + reg.match(2);
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 56baccb..17cd1c2 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -15,10 +15,11 @@
 
 =========================================================================*/
 #include "cmCTest.h"
-#include "cmRegularExpression.h"
 #include "cmSystemTools.h"
 #include "cmListFileCache.h"
 
+#include <cmsys/RegularExpression.hxx>
+
 #ifdef HAVE_CURL
 # include "cmCTestSubmit.h"
 # include "curl/curl.h"
@@ -590,10 +591,10 @@ int cmCTest::UpdateDirectory()
   std::vector<cmStdString> lines;
   cmSystemTools::Split(goutput.c_str(), lines);
   std::cout << "Updated; gathering version information" << std::endl;
-  cmRegularExpression date_author("^date: +([^;]+); +author: +([^;]+); +state: +[^;]+;");
-  cmRegularExpression revision("^revision +([^ ]*) *$");
-  cmRegularExpression end_of_file("^=============================================================================$");
-  cmRegularExpression end_of_comment("^----------------------------$");
+  cmsys::RegularExpression date_author("^date: +([^;]+); +author: +([^;]+); +state: +[^;]+;");
+  cmsys::RegularExpression revision("^revision +([^ ]*) *$");
+  cmsys::RegularExpression end_of_file("^=============================================================================$");
+  cmsys::RegularExpression end_of_comment("^----------------------------$");
   std::string current_path = "";
   bool first_file = true;
 
@@ -974,7 +975,7 @@ int cmCTest::BuildDirectory()
   // Errors
   for ( cc = 0; cmCTestErrorMatches[cc]; cc ++ )
     {
-    cmRegularExpression re(cmCTestErrorMatches[cc]);
+    cmsys::RegularExpression re(cmCTestErrorMatches[cc]);
     std::vector<std::string>::size_type kk;
     for ( kk = 0; kk < lines.size(); kk ++ )
       {
@@ -987,7 +988,7 @@ int cmCTest::BuildDirectory()
   // Warnings
   for ( cc = 0; cmCTestWarningMatches[cc]; cc ++ )
     {
-    cmRegularExpression re(cmCTestWarningMatches[cc]);
+    cmsys::RegularExpression re(cmCTestWarningMatches[cc]);
     std::vector<std::string>::size_type kk;
     for ( kk = 0; kk < lines.size(); kk ++ )
       {
@@ -1000,7 +1001,7 @@ int cmCTest::BuildDirectory()
   // Errors exceptions
   for ( cc = 0; cmCTestErrorExceptions[cc]; cc ++ )
     {
-    cmRegularExpression re(cmCTestErrorExceptions[cc]);
+    cmsys::RegularExpression re(cmCTestErrorExceptions[cc]);
     std::vector<int>::size_type kk;
     for ( kk =0; kk < markedLines.size(); kk ++ )
       {
@@ -1016,7 +1017,7 @@ int cmCTest::BuildDirectory()
   // Warning exceptions
   for ( cc = 0; cmCTestWarningExceptions[cc]; cc ++ )
     {
-    cmRegularExpression re(cmCTestWarningExceptions[cc]);
+    cmsys::RegularExpression re(cmCTestWarningExceptions[cc]);
     std::vector<int>::size_type kk;
     for ( kk =0; kk < markedLines.size(); kk ++ )
       {
@@ -1614,9 +1615,9 @@ void cmCTest::ProcessDirectory(std::vector<std::string> &passed,
   int firstTest = 1;
   long line = 0;
   
-  cmRegularExpression ireg(this->m_IncludeRegExp.c_str());
-  cmRegularExpression ereg(this->m_ExcludeRegExp.c_str());
-  cmRegularExpression dartStuff("([\t\n ]*<DartMeasurement.*/DartMeasurement[a-zA-Z]*>[\t ]*[\n]*)");
+  cmsys::RegularExpression ireg(this->m_IncludeRegExp.c_str());
+  cmsys::RegularExpression ereg(this->m_ExcludeRegExp.c_str());
+  cmsys::RegularExpression dartStuff("([\t\n ]*<DartMeasurement.*/DartMeasurement[a-zA-Z]*>[\t ]*[\n]*)");
 
   bool parseError;
   while ( fin )
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index 43027e9..8d30fd0 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -19,9 +19,10 @@
 #include "cmSystemTools.h"
 #include "cmCacheManager.h"
 #include "cmMakefile.h"
-#include "cmRegularExpression.h"
 #include "stdio.h"
 
+#include <cmsys/RegularExpression.hxx>
+
 #if defined(_WIN32) || defined(__CYGWIN__)
 # include <windows.h>
 #endif // _WIN32
@@ -84,9 +85,9 @@ bool cmCacheManager::ParseEntry(const char* entry,
                                 CacheEntryType& type)
 {
   // input line is:         key:type=value
-  cmRegularExpression reg("^([^:]*):([^=]*)=(.*[^\t ]|[\t ]*)[\t ]*$");
+  cmsys::RegularExpression reg("^([^:]*):([^=]*)=(.*[^\t ]|[\t ]*)[\t ]*$");
   // input line is:         "key":type=value
-  cmRegularExpression regQuoted("^\"([^\"]*)\":([^=]*)=(.*[^\t ]|[\t ]*)[\t ]*$");
+  cmsys::RegularExpression regQuoted("^\"([^\"]*)\":([^=]*)=(.*[^\t ]|[\t ]*)[\t ]*$");
   bool flag = false;
   if(regQuoted.find(entry))
     {
diff --git a/Source/cmConfigureFileCommand.cxx b/Source/cmConfigureFileCommand.cxx
index e43fc15..d2a6443 100644
--- a/Source/cmConfigureFileCommand.cxx
+++ b/Source/cmConfigureFileCommand.cxx
@@ -16,6 +16,8 @@
 =========================================================================*/
 #include "cmConfigureFileCommand.h"
 
+#include <cmsys/RegularExpression.hxx>
+
 // cmConfigureFileCommand
 bool cmConfigureFileCommand::InitialPass(std::vector<std::string> const& args)
 {
@@ -106,7 +108,7 @@ void cmConfigureFileCommand::ConfigureFile()
     // now copy input to output and expand variables in the
     // input file at the same time
     std::string inLine;
-    cmRegularExpression cmdefine("#cmakedefine[ \t]*([A-Za-z_0-9]*)");
+    cmsys::RegularExpression cmdefine("#cmakedefine[ \t]*([A-Za-z_0-9]*)");
     while( cmSystemTools::GetLineFromStream(fin, inLine) )
       {
       m_Makefile->ExpandVariablesInString(inLine, m_EscapeQuotes, m_AtOnly);
diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx
index 119acc6..cf925df 100644
--- a/Source/cmIfCommand.cxx
+++ b/Source/cmIfCommand.cxx
@@ -17,6 +17,8 @@
 #include "cmIfCommand.h"
 #include <stdlib.h> // required for atof
 
+#include <cmsys/RegularExpression.hxx>
+
 bool cmIfFunctionBlocker::
 IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
 {
@@ -217,7 +219,7 @@ bool cmIfCommand::IsTrue(const std::vector<std::string> &args,
   if (args.size() == 3 && (args[1] == "MATCHES"))
     {
     def = cmIfCommand::GetVariableOrString(args[0].c_str(), makefile);
-    cmRegularExpression regEntry(args[2].c_str());
+    cmsys::RegularExpression regEntry(args[2].c_str());
     
     // check for black line or comment
     if (!regEntry.find(def))
diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx
index 7d47514..a22c60f 100644
--- a/Source/cmListFileCache.cxx
+++ b/Source/cmListFileCache.cxx
@@ -16,7 +16,8 @@
 =========================================================================*/
 #include "cmListFileCache.h"
 #include "cmSystemTools.h"
-#include "cmRegularExpression.h"
+
+#include <cmsys/RegularExpression.hxx>
 
 cmListFileCache* cmListFileCache::Instance = 0;
 
@@ -174,10 +175,10 @@ bool cmListFileCache::ParseFunction(std::ifstream& fin,
     {
     ++line;
     RemoveComments(inbuffer);
-    cmRegularExpression blankLine("^[ \t\r]*$");
-    cmRegularExpression oneLiner("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)\\)[ \t\r]*$");
-    cmRegularExpression multiLine("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)$");
-    cmRegularExpression lastLine("^(.*)\\)[ \t\r]*$");
+    cmsys::RegularExpression blankLine("^[ \t\r]*$");
+    cmsys::RegularExpression oneLiner("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)\\)[ \t\r]*$");
+    cmsys::RegularExpression multiLine("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)$");
+    cmsys::RegularExpression lastLine("^(.*)\\)[ \t\r]*$");
 
     // check for blank line or comment
     if(blankLine.find(inbuffer.c_str()) )
@@ -258,9 +259,9 @@ void cmListFileCache::GetArguments(std::string& line,
                                  std::vector<cmListFileArgument>& arguments)
 {
   // Match a normal argument (not quoted, no spaces).
-  cmRegularExpression normalArgument("[ \t]*(([^ \t\r\\]|[\\].)+)[ \t\r]*");
+  cmsys::RegularExpression normalArgument("[ \t]*(([^ \t\r\\]|[\\].)+)[ \t\r]*");
   // Match a quoted argument (surrounded by double quotes, spaces allowed).
-  cmRegularExpression quotedArgument("[ \t]*(\"([^\"\\]|[\\].)*\")[ \t\r]*");
+  cmsys::RegularExpression quotedArgument("[ \t]*(\"([^\"\\]|[\\].)*\")[ \t\r]*");
 
   bool done = false;
   while(!done)
diff --git a/Source/cmLoadCacheCommand.cxx b/Source/cmLoadCacheCommand.cxx
index ef3fe26..2abe6d0 100644
--- a/Source/cmLoadCacheCommand.cxx
+++ b/Source/cmLoadCacheCommand.cxx
@@ -16,6 +16,7 @@
 =========================================================================*/
 #include "cmLoadCacheCommand.h"
 
+#include <cmsys/RegularExpression.hxx>
 
 // cmLoadCacheCommand
 bool cmLoadCacheCommand::InitialPass(std::vector<std::string> const& args)
@@ -202,9 +203,9 @@ bool cmLoadCacheCommand::ParseEntry(const char* entry, std::string& var,
                                     std::string& value)
 {
   // input line is:         key:type=value
-  cmRegularExpression reg("^([^:]*):([^=]*)=(.*[^\t ]|[\t ]*)[\t ]*$");
+  cmsys::RegularExpression reg("^([^:]*):([^=]*)=(.*[^\t ]|[\t ]*)[\t ]*$");
   // input line is:         "key":type=value
-  cmRegularExpression regQuoted("^\"([^\"]*)\":([^=]*)=(.*[^\t ]|[\t ]*)[\t ]*$");
+  cmsys::RegularExpression regQuoted("^\"([^\"]*)\":([^=]*)=(.*[^\t ]|[\t ]*)[\t ]*$");
   bool flag = false;
   if(regQuoted.find(entry))
     {
diff --git a/Source/cmLocalCodeWarriorGenerator.cxx b/Source/cmLocalCodeWarriorGenerator.cxx
index 08bc812..ef5ee30 100644
--- a/Source/cmLocalCodeWarriorGenerator.cxx
+++ b/Source/cmLocalCodeWarriorGenerator.cxx
@@ -22,6 +22,8 @@ PURPOSE.  See the above copyright notices for more information.
 #include "cmCacheManager.h"
 #include "cmake.h"
 
+#include <cmsys/RegularExpression.hxx>
+
 cmLocalCodeWarriorGenerator::cmLocalCodeWarriorGenerator()
 {
 }
@@ -168,9 +170,9 @@ void cmLocalCodeWarriorGenerator::WriteSettingList(std::ostream& fout,
   // library paths
 
   // now add in the libraries we depend on
-  cmRegularExpression isAframework("[ \t]*\\-framework");
-  cmRegularExpression isEnvironment("\\${");
-  cmRegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
+  cmsys::RegularExpression isAframework("[ \t]*\\-framework");
+  cmsys::RegularExpression isEnvironment("\\${");
+  cmsys::RegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
   const cmTarget::LinkLibraries& libs = l->GetLinkLibraries();
   cmTarget::LinkLibraries::const_iterator lib = libs.begin();
   for(; lib != libs.end(); ++lib)
@@ -564,9 +566,9 @@ void cmLocalCodeWarriorGenerator::WriteFileList(std::ostream& fout,
     }
   
   // now add in the libraries we depend on
-  cmRegularExpression isAframework("[ \t]*\\-framework");
-  cmRegularExpression isEnvironment("\\${");
-  cmRegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
+  cmsys::RegularExpression isAframework("[ \t]*\\-framework");
+  cmsys::RegularExpression isEnvironment("\\${");
+  cmsys::RegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
   const cmTarget::LinkLibraries& libs = l->GetLinkLibraries();
   cmTarget::LinkLibraries::const_iterator lib = libs.begin();
   for(; lib != libs.end(); ++lib)
@@ -694,9 +696,9 @@ void cmLocalCodeWarriorGenerator::WriteLinkOrder(std::ostream& fout,
     }
 
   // now add in the libraries we depend on
-  cmRegularExpression isAframework("[ \t]*\\-framework");
-  cmRegularExpression isEnvironment("\\${");
-  cmRegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
+  cmsys::RegularExpression isAframework("[ \t]*\\-framework");
+  cmsys::RegularExpression isEnvironment("\\${");
+  cmsys::RegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
   const cmTarget::LinkLibraries& libs = l->GetLinkLibraries();
   cmTarget::LinkLibraries::const_iterator lib = libs.begin();
   
@@ -814,7 +816,7 @@ void cmLocalCodeWarriorGenerator::WriteLinkOrder(std::ostream& fout,
 
   // we need at least one framework for the XML to be valid
   // generate framework list
-  cmRegularExpression reg("[ \t]*\\-framework[ \t]+([^ \t]+)");
+  cmsys::RegularExpression reg("[ \t]*\\-framework[ \t]+([^ \t]+)");
   std::vector<std::string> frameworks;
   
   lib = libs.begin();
@@ -967,9 +969,9 @@ void cmLocalCodeWarriorGenerator::WriteGroup(std::ostream& fout,
     }
 
   // now add in the libraries we depend on
-  cmRegularExpression isAframework("[ \t]*\\-framework");
-  cmRegularExpression isEnvironment("\\${");
-  cmRegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
+  cmsys::RegularExpression isAframework("[ \t]*\\-framework");
+  cmsys::RegularExpression isEnvironment("\\${");
+  cmsys::RegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
   const cmTarget::LinkLibraries& libs = l->GetLinkLibraries();
   cmTarget::LinkLibraries::const_iterator lib = libs.begin();
   for(; lib != libs.end(); ++lib)
diff --git a/Source/cmLocalUnixMakefileGenerator.cxx b/Source/cmLocalUnixMakefileGenerator.cxx
index e522765..8a16544 100644
--- a/Source/cmLocalUnixMakefileGenerator.cxx
+++ b/Source/cmLocalUnixMakefileGenerator.cxx
@@ -22,6 +22,8 @@
 #include "cmMakeDepend.h"
 #include "cmCacheManager.h"
 #include "cmGeneratedFileStream.h"
+
+#include <cmsys/RegularExpression.hxx>
 #include <stdio.h>
 
 cmLocalUnixMakefileGenerator::cmLocalUnixMakefileGenerator()
@@ -565,7 +567,7 @@ void cmLocalUnixMakefileGenerator::OutputLinkLibraries(std::ostream& fout,
   std::string regexp = ".*\\";
   regexp += linkSuffix;
   regexp += "$";
-  cmRegularExpression hasSuffix(regexp.c_str());
+  cmsys::RegularExpression hasSuffix(regexp.c_str());
   std::string librariesLinked;
   const cmTarget::LinkLibraries& libs = tgt.GetLinkLibraries();
   for(cmTarget::LinkLibraries::const_iterator lib = libs.begin();
@@ -579,7 +581,7 @@ void cmLocalUnixMakefileGenerator::OutputLinkLibraries(std::ostream& fout,
     // if a variable expands to nothing.
     if (lib->first.size() == 0) continue;
     // if it is a full path break it into -L and -l
-    cmRegularExpression reg("([ \t]*\\-l)|([ \t]*\\-framework)|(\\${)");
+    cmsys::RegularExpression reg("([ \t]*\\-l)|([ \t]*\\-framework)|(\\${)");
     if(lib->first.find('/') != std::string::npos
        && !reg.find(lib->first))
       {
@@ -597,8 +599,8 @@ void cmLocalUnixMakefileGenerator::OutputLinkLibraries(std::ostream& fout,
           runtimeDirs.push_back( libpath );
           }
         }  
-      cmRegularExpression libname("^lib([^/]*)(\\.so|\\.lib|\\.dll|\\.sl|\\.a|\\.dylib).*");
-      cmRegularExpression libname_noprefix("([^/]*)(\\.so|\\.lib|\\.dll|\\.sl|\\.a|\\.dylib).*");
+      cmsys::RegularExpression libname("^lib([^/]*)(\\.so|\\.lib|\\.dll|\\.sl|\\.a|\\.dylib).*");
+      cmsys::RegularExpression libname_noprefix("([^/]*)(\\.so|\\.lib|\\.dll|\\.sl|\\.a|\\.dylib).*");
       if(libname.find(file))
         {
         // Library had "lib" prefix.
diff --git a/Source/cmLocalVisualStudio6Generator.cxx b/Source/cmLocalVisualStudio6Generator.cxx
index f6eeb50..c76a629 100644
--- a/Source/cmLocalVisualStudio6Generator.cxx
+++ b/Source/cmLocalVisualStudio6Generator.cxx
@@ -22,6 +22,8 @@
 #include "cmCacheManager.h"
 #include <queue>
 
+#include <cmsys/RegularExpression.hxx>
+
 cmLocalVisualStudio6Generator::cmLocalVisualStudio6Generator()
 {
 }
@@ -607,7 +609,7 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
   // possible
   std::ifstream fin(m_DSPHeaderTemplate.c_str());
 
-  cmRegularExpression reg("# Name ");
+  cmsys::RegularExpression reg("# Name ");
   if(!fin)
     {
     cmSystemTools::Error("Error Reading ", m_DSPHeaderTemplate.c_str());
diff --git a/Source/cmMakeDepend.cxx b/Source/cmMakeDepend.cxx
index 2d13cf9..e8812e7 100644
--- a/Source/cmMakeDepend.cxx
+++ b/Source/cmMakeDepend.cxx
@@ -18,6 +18,7 @@
 #include "cmStandardIncludes.h"
 #include "cmSystemTools.h"
 
+#include <cmsys/RegularExpression.hxx>
 
 void cmDependInformation::AddDependencies(cmDependInformation* info)
 {
@@ -189,7 +190,7 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
 // #include directives
 void cmMakeDepend::DependWalk(cmDependInformation* info)
 {
-  cmRegularExpression includeLine("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]");
+  cmsys::RegularExpression includeLine("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]");
   std::ifstream fin(info->m_FullPath.c_str());
   if(!fin)
     {
diff --git a/Source/cmMakeDepend.h b/Source/cmMakeDepend.h
index bc489fc..d9045a5 100644
--- a/Source/cmMakeDepend.h
+++ b/Source/cmMakeDepend.h
@@ -19,9 +19,10 @@
 
 #include "cmMakefile.h"
 #include "cmSourceFile.h"
-#include "cmRegularExpression.h"
 #include "cmStandardIncludes.h"
 
+#include <cmsys/RegularExpression.hxx>
+
 /** \class cmDependInformation
  * \brief Store dependency information for a single source file.
  *
@@ -150,8 +151,8 @@ protected:
 
   const cmMakefile* m_Makefile;
   bool m_Verbose;
-  cmRegularExpression m_IncludeFileRegularExpression;
-  cmRegularExpression m_ComplainFileRegularExpression;
+  cmsys::RegularExpression m_IncludeFileRegularExpression;
+  cmsys::RegularExpression m_ComplainFileRegularExpression;
   std::vector<std::string> m_IncludeDirectories;
   typedef std::map<cmStdString, cmDependInformation*> DependInformationMap;
   DependInformationMap m_DependInformationMap;
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 49a7fb8..c271ccc 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -29,6 +29,9 @@
 #include "cmake.h"
 #include <stdio.h>  // required for sprintf
 #include <stdlib.h> // required for atoi
+
+#include <cmsys/RegularExpression.hxx>
+
 // default is not to be building executables
 cmMakefile::cmMakefile()
 {
@@ -458,7 +461,7 @@ void cmMakefile::AddCustomCommand(const char* source,
         d != outputs.end(); ++d)
       {
       // if this looks like a real file then use is as the main depend
-      cmRegularExpression SourceFiles("\\.(C|M|c|c\\+\\+|cc|cpp|cxx|m|mm|rc|def|r|odl|idl|hpj|bat|h|h\\+\\+|hm|hpp|hxx|in|txx|inl)$");
+      cmsys::RegularExpression SourceFiles("\\.(C|M|c|c\\+\\+|cc|cpp|cxx|m|mm|rc|def|r|odl|idl|hpj|bat|h|h\\+\\+|hm|hpp|hxx|in|txx|inl)$");
       if (SourceFiles.find(source))
         {
         this->AddCustomCommandToOutput(d->c_str(), command, commandArgs, 
@@ -1461,7 +1464,7 @@ void cmMakefile::RemoveVariablesInString(std::string& source,
 {
   if(!atOnly)
     {
-    cmRegularExpression var("(\\${[A-Za-z_0-9]*})");
+    cmsys::RegularExpression var("(\\${[A-Za-z_0-9]*})");
     while (var.find(source))
       {
       source.erase(var.start(),var.end() - var.start());
@@ -1470,13 +1473,13 @@ void cmMakefile::RemoveVariablesInString(std::string& source,
   
   if(!atOnly)
     {
-    cmRegularExpression varb("(\\$ENV{[A-Za-z_0-9]*})");
+    cmsys::RegularExpression varb("(\\$ENV{[A-Za-z_0-9]*})");
     while (varb.find(source))
       {
       source.erase(varb.start(),varb.end() - varb.start());
       }
     }
-  cmRegularExpression var2("(@[A-Za-z_0-9]*@)");
+  cmsys::RegularExpression var2("(@[A-Za-z_0-9]*@)");
   while (var2.find(source))
     {
     source.erase(var2.start(),var2.end() - var2.start());
diff --git a/Source/cmRegularExpression.cxx b/Source/cmRegularExpression.cxx
deleted file mode 100644
index 35759c4..0000000
--- a/Source/cmRegularExpression.cxx
+++ /dev/null
@@ -1,1207 +0,0 @@
-/*=========================================================================
-
-  Program:   CMake - Cross-Platform Makefile Generator
-  Module:    $RCSfile$
-  Language:  C++
-  Date:      $Date$
-  Version:   $Revision$
-
-  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
-  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
-
-     This software is distributed WITHOUT ANY WARRANTY; without even 
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
-     PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
-//
-// Copyright (C) 1991 Texas Instruments Incorporated.
-//
-// Permission is granted to any individual or institution to use, copy, modify,
-// and distribute this software, provided that this complete copyright and
-// permission notice is maintained, intact, in all copies and supporting
-// documentation.
-//
-// Texas Instruments Incorporated provides this software "as is" without
-// express or implied warranty.
-//
-//
-// Created: MNF 06/13/89  Initial Design and Implementation
-// Updated: LGO 08/09/89  Inherit from Generic
-// Updated: MBN 09/07/89  Added conditional exception handling
-// Updated: MBN 12/15/89  Sprinkled "const" qualifiers all over the place!
-// Updated: DLS 03/22/91  New lite version
-//
-
-#include "cmRegularExpression.h"        // Include class specification 
-#include "cmStandardIncludes.h"
-#include <stdio.h>
-
-// cmRegularExpression -- Copies the given regular expression.
-cmRegularExpression::cmRegularExpression (const cmRegularExpression& rxp) {
-  if ( !rxp.program )
-    {
-    this->program = 0;
-    return;
-    }
-  int ind; 
-  this->progsize = rxp.progsize;                // Copy regular expression size
-  this->program = new char[this->progsize];     // Allocate storage
-  for(ind=this->progsize; ind-- != 0;)          // Copy regular expresion
-    this->program[ind] = rxp.program[ind];
-  this->startp[0] = rxp.startp[0];              // Copy pointers into last
-  this->endp[0] = rxp.endp[0];                  // Successful "find" operation
-  this->regmust = rxp.regmust;                  // Copy field
-  if (rxp.regmust != 0) {
-    char* dum = rxp.program;
-    ind = 0;
-    while (dum != rxp.regmust) {
-      ++dum;
-      ++ind;
-    }
-    this->regmust = this->program + ind;
-  }
-  this->regstart = rxp.regstart;                // Copy starting index
-  this->reganch = rxp.reganch;                  // Copy remaining private data
-  this->regmlen = rxp.regmlen;                  // Copy remaining private data
-}
-
-// operator== -- Returns true if two regular expressions have the same
-// compiled program for pattern matching.
-bool cmRegularExpression::operator== (const cmRegularExpression& rxp) const {
-  if (this != &rxp) {                           // Same address?
-    int ind = this->progsize;                   // Get regular expression size
-    if (ind != rxp.progsize)                    // If different size regexp
-      return false;                             // Return failure
-    while(ind-- != 0)                           // Else while still characters
-      if(this->program[ind] != rxp.program[ind]) // If regexp are different    
-        return false;                            // Return failure             
-  }
-  return true;                                  // Else same, return success  
-}
-
-
-// deep_equal -- Returns true if have the same compiled regular expressions
-// and the same start and end pointers.
-
-bool cmRegularExpression::deep_equal (const cmRegularExpression& rxp) const {
-  int ind = this->progsize;                     // Get regular expression size
-  if (ind != rxp.progsize)                      // If different size regexp
-    return false;                               // Return failure
-  while(ind-- != 0)                             // Else while still characters
-    if(this->program[ind] != rxp.program[ind])  // If regexp are different    
-      return false;                             // Return failure             
-  return (this->startp[0] == rxp.startp[0] &&   // Else if same start/end ptrs,
-          this->endp[0] == rxp.endp[0]);        // Return true
-}   
-
-// The remaining code in this file is derived from the  regular expression code
-// whose  copyright statement appears  below.  It has been  changed to work
-// with the class concepts of C++ and COOL.
-
-/*
- * compile and find 
- *
- *      Copyright (c) 1986 by University of Toronto.
- *      Written by Henry Spencer.  Not derived from licensed software.
- *
- *      Permission is granted to anyone to use this software for any
- *      purpose on any computer system, and to redistribute it freely,
- *      subject to the following restrictions:
- *
- *      1. The author is not responsible for the consequences of use of
- *              this software, no matter how awful, even if they arise
- *              from defects in it.
- *
- *      2. The origin of this software must not be misrepresented, either
- *              by explicit claim or by omission.
- *
- *      3. Altered versions must be plainly marked as such, and must not
- *              be misrepresented as being the original software.
- *
- * Beware that some of this code is subtly aware of the way operator
- * precedence is structured in regular expressions.  Serious changes in
- * regular-expression syntax might require a total rethink.
- */
-
-/*
- * The "internal use only" fields in regexp.h are present to pass info from
- * compile to execute that permits the execute phase to run lots faster on
- * simple cases.  They are:
- *
- * regstart     char that must begin a match; '\0' if none obvious
- * reganch      is the match anchored (at beginning-of-line only)?
- * regmust      string (pointer into program) that match must include, or NULL
- * regmlen      length of regmust string
- *
- * Regstart and reganch permit very fast decisions on suitable starting points
- * for a match, cutting down the work a lot.  Regmust permits fast rejection
- * of lines that cannot possibly match.  The regmust tests are costly enough
- * that compile() supplies a regmust only if the r.e. contains something
- * potentially expensive (at present, the only such thing detected is * or +
- * at the start of the r.e., which can involve a lot of backup).  Regmlen is
- * supplied because the test in find() needs it and compile() is computing
- * it anyway.
- */
-
-/*
- * Structure for regexp "program".  This is essentially a linear encoding
- * of a nondeterministic finite-state machine (aka syntax charts or
- * "railroad normal form" in parsing technology).  Each node is an opcode
- * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
- * all nodes except BRANCH implement concatenation; a "next" pointer with
- * a BRANCH on both ends of it is connecting two alternatives.  (Here we
- * have one of the subtle syntax dependencies:  an individual BRANCH (as
- * opposed to a collection of them) is never concatenated with anything
- * because of operator precedence.)  The operand of some types of node is
- * a literal string; for others, it is a node leading into a sub-FSM.  In
- * particular, the operand of a BRANCH node is the first node of the branch.
- * (NB this is *not* a tree structure:  the tail of the branch connects
- * to the thing following the set of BRANCHes.)  The opcodes are:
- */
-
-// definition   number  opnd?   meaning
-#define END     0               // no   End of program.
-#define BOL     1               // no   Match "" at beginning of line.
-#define EOL     2               // no   Match "" at end of line.
-#define ANY     3               // no   Match any one character.
-#define ANYOF   4               // str  Match any character in this string.
-#define ANYBUT  5               // str  Match any character not in this
-                                // string.
-#define BRANCH  6               // node Match this alternative, or the
-                                // next...
-#define BACK    7               // no   Match "", "next" ptr points backward.
-#define EXACTLY 8               // str  Match this string.
-#define NOTHING 9               // no   Match empty string.
-#define STAR    10              // node Match this (simple) thing 0 or more
-                                // times.
-#define PLUS    11              // node Match this (simple) thing 1 or more
-                                // times.
-#define OPEN    20              // no   Mark this point in input as start of
-                                // #n.
-// OPEN+1 is number 1, etc.
-#define CLOSE   30              // no   Analogous to OPEN.
-
-/*
- * Opcode notes:
- *
- * BRANCH       The set of branches constituting a single choice are hooked
- *              together with their "next" pointers, since precedence prevents
- *              anything being concatenated to any individual branch.  The
- *              "next" pointer of the last BRANCH in a choice points to the
- *              thing following the whole choice.  This is also where the
- *              final "next" pointer of each individual branch points; each
- *              branch starts with the operand node of a BRANCH node.
- *
- * BACK         Normal "next" pointers all implicitly point forward; BACK
- *              exists to make loop structures possible.
- *
- * STAR,PLUS    '?', and complex '*' and '+', are implemented as circular
- *              BRANCH structures using BACK.  Simple cases (one character
- *              per match) are implemented with STAR and PLUS for speed
- *              and to minimize recursive plunges.
- *
- * OPEN,CLOSE   ...are numbered at compile time.
- */
-
-/*
- * A node is one char of opcode followed by two chars of "next" pointer.
- * "Next" pointers are stored as two 8-bit pieces, high order first.  The
- * value is a positive offset from the opcode of the node containing it.
- * An operand, if any, simply follows the node.  (Note that much of the
- * code generation knows about this implicit relationship.)
- *
- * Using two bytes for the "next" pointer is vast overkill for most things,
- * but allows patterns to get big without disasters.
- */
-
-#define OP(p)           (*(p))
-#define NEXT(p)         (((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
-#define OPERAND(p)      ((p) + 3)
-
-const unsigned char MAGIC = 0234;
-/*
- * Utility definitions.
- */
-
-#define UCHARAT(p)      ((const unsigned char*)(p))[0]
-
-
-#define FAIL(m) { regerror(m); return(0); }
-#define ISMULT(c)       ((c) == '*' || (c) == '+' || (c) == '?')
-#define META    "^$.[()|?+*\\"
-
-
-/*
- * Flags to be passed up and down.
- */
-#define HASWIDTH        01      // Known never to match null string.
-#define SIMPLE          02      // Simple enough to be STAR/PLUS operand.
-#define SPSTART         04      // Starts with * or +.
-#define WORST           0       // Worst case.
-
-
-
-/////////////////////////////////////////////////////////////////////////
-//
-//  COMPILE AND ASSOCIATED FUNCTIONS
-//
-/////////////////////////////////////////////////////////////////////////
-
-
-/*
- * Global work variables for compile().
- */
-static const char* regparse;    // Input-scan pointer.
-static       int   regnpar;     // () count.
-static       char  regdummy;
-static       char* regcode;     // Code-emit pointer; &regdummy = don't.
-static       long  regsize;     // Code size.
-
-/*
- * Forward declarations for compile()'s friends.
- */
-// #ifndef static
-// #define      static  static
-// #endif
-static       char* reg (int, int*);
-static       char* regbranch (int*);
-static       char* regpiece (int*);
-static       char* regatom (int*);
-static       char* regnode (char);
-static const char* regnext (register const char*);
-static       char* regnext (register char*);
-static void        regc (unsigned char);
-static void        reginsert (char, char*);
-static void        regtail (char*, const char*);
-static void        regoptail (char*, const char*);
-
-#ifdef STRCSPN
-static int strcspn ();
-#endif
-
-
-
-/*
- * We can't allocate space until we know how big the compiled form will be,
- * but we can't compile it (and thus know how big it is) until we've got a
- * place to put the code.  So we cheat:  we compile it twice, once with code
- * generation turned off and size counting turned on, and once "for real".
- * This also means that we don't allocate space until we are sure that the
- * thing really will compile successfully, and we never have to move the
- * code and thus invalidate pointers into it.  (Note that it has to be in
- * one piece because free() must be able to free it all.)
- *
- * Beware that the optimization-preparation code in here knows about some
- * of the structure of the compiled regexp.
- */
-
-
-// compile -- compile a regular expression into internal code
-// for later pattern matching.
-
-bool cmRegularExpression::compile (const char* exp) {
-    register const char* scan;
-    register const char* longest;
-    register unsigned long len;
-             int         flags;
-
-    if (exp == 0) {
-      //RAISE Error, SYM(cmRegularExpression), SYM(No_Expr),
-      printf ("cmRegularExpression::compile(): No expression supplied.\n");
-      return false;
-    }
-
-    // First pass: determine size, legality.
-    regparse = exp;
-    regnpar = 1;
-    regsize = 0L;
-    regcode = &regdummy;
-    regc(MAGIC);
-    if(!reg(0, &flags))
-      {
-        printf ("cmRegularExpression::compile(): Error in compile.\n");
-        return false;
-      }
-    this->startp[0] = this->endp[0] = this->searchstring = 0;
-
-    // Small enough for pointer-storage convention? 
-    if (regsize >= 32767L) {    // Probably could be 65535L. 
-      //RAISE Error, SYM(cmRegularExpression), SYM(Expr_Too_Big),
-      printf ("cmRegularExpression::compile(): Expression too big.\n");
-      return false;
-    }
-
-    // Allocate space. 
-//#ifndef WIN32
-    if (this->program != 0) delete [] this->program;  
-//#endif
-    this->program = new char[regsize];
-    this->progsize = (int) regsize;
-
-    if (this->program == 0) {
-      //RAISE Error, SYM(cmRegularExpression), SYM(Out_Of_Memory),
-      printf ("cmRegularExpression::compile(): Out of memory.\n"); 
-      return false;
-    }
-
-    // Second pass: emit code.
-    regparse = exp;
-    regnpar = 1;
-    regcode = this->program;
-    regc(MAGIC);
-    reg(0, &flags);
-
-    // Dig out information for optimizations.
-    this->regstart = '\0';              // Worst-case defaults.
-    this->reganch = 0;
-    this->regmust = 0;
-    this->regmlen = 0;
-    scan = this->program + 1;   // First BRANCH.
-    if (OP(regnext(scan)) == END) {     // Only one top-level choice.
-        scan = OPERAND(scan);
-
-        // Starting-point info.
-        if (OP(scan) == EXACTLY)
-            this->regstart = *OPERAND(scan);
-        else if (OP(scan) == BOL)
-            this->reganch++;
-
-         //
-         // If there's something expensive in the r.e., find the longest
-         // literal string that must appear and make it the regmust.  Resolve
-         // ties in favor of later strings, since the regstart check works
-         // with the beginning of the r.e. and avoiding duplication
-         // strengthens checking.  Not a strong reason, but sufficient in the
-         // absence of others. 
-         //
-        if (flags & SPSTART) {
-            longest = 0;
-            len = 0;
-            for (; scan != 0; scan = regnext(scan))
-                if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) {
-                    longest = OPERAND(scan);
-                    len = int(strlen(OPERAND(scan)));
-                }
-            this->regmust = longest;
-            this->regmlen = len;
-        }
-    }
-    return true;
-}
-
-
-/*
- - reg - regular expression, i.e. main body or parenthesized thing
- *
- * Caller must absorb opening parenthesis.
- *
- * Combining parenthesis handling with the base level of regular expression
- * is a trifle forced, but the need to tie the tails of the branches to what
- * follows makes it hard to avoid.
- */
-static char* reg (int paren, int *flagp) {
-    register char* ret;
-    register char* br;
-    register char* ender;
-    register int   parno =0;
-             int   flags;
-
-    *flagp = HASWIDTH;          // Tentatively.
-
-    // Make an OPEN node, if parenthesized.
-    if (paren) {
-        if (regnpar >= NSUBEXP) {
-          //RAISE Error, SYM(cmRegularExpression), SYM(Too_Many_Parens),
-          printf ("cmRegularExpression::compile(): Too many parentheses.\n");
-          return 0;
-        }
-        parno = regnpar;
-        regnpar++;
-        ret = regnode(OPEN + parno);
-    }
-    else
-        ret = 0;
-
-    // Pick up the branches, linking them together.
-    br = regbranch(&flags);
-    if (br == 0)
-        return (0);
-    if (ret != 0)
-        regtail(ret, br);       // OPEN -> first.
-    else
-        ret = br;
-    if (!(flags & HASWIDTH))
-        *flagp &= ~HASWIDTH;
-    *flagp |= flags & SPSTART;
-    while (*regparse == '|') {
-        regparse++;
-        br = regbranch(&flags);
-        if (br == 0)
-            return (0);
-        regtail(ret, br);       // BRANCH -> BRANCH.
-        if (!(flags & HASWIDTH))
-            *flagp &= ~HASWIDTH;
-        *flagp |= flags & SPSTART;
-      }
-
-    // Make a closing node, and hook it on the end.
-    ender = regnode((paren) ? CLOSE + parno : END);
-    regtail(ret, ender);
-
-    // Hook the tails of the branches to the closing node.
-    for (br = ret; br != 0; br = regnext(br))
-        regoptail(br, ender);
-
-    // Check for proper termination.
-    if (paren && *regparse++ != ')') {
-        //RAISE Error, SYM(cmRegularExpression), SYM(Unmatched_Parens),
-        printf ("cmRegularExpression::compile(): Unmatched parentheses.\n");
-        return 0;
-    }
-    else if (!paren && *regparse != '\0') {
-        if (*regparse == ')') {
-            //RAISE Error, SYM(cmRegularExpression), SYM(Unmatched_Parens),
-            printf ("cmRegularExpression::compile(): Unmatched parentheses.\n");
-            return 0;
-        }
-        else {
-            //RAISE Error, SYM(cmRegularExpression), SYM(Internal_Error),
-            printf ("cmRegularExpression::compile(): Internal error.\n");
-            return 0;
-        }
-        // NOTREACHED
-    }
-    return (ret);
-}
-
-
-/*
- - regbranch - one alternative of an | operator
- *
- * Implements the concatenation operator.
- */
-static char* regbranch (int *flagp) {
-    register char* ret;
-    register char* chain;
-    register char* latest;
-    int                  flags;
-
-    *flagp = WORST;             // Tentatively.
-
-    ret = regnode(BRANCH);
-    chain = 0;
-    while (*regparse != '\0' && *regparse != '|' && *regparse != ')') {
-        latest = regpiece(&flags);
-        if (latest == 0)
-            return (0);
-        *flagp |= flags & HASWIDTH;
-        if (chain == 0) // First piece.
-            *flagp |= flags & SPSTART;
-        else
-            regtail(chain, latest);
-        chain = latest;
-    }
-    if (chain == 0)             // Loop ran zero times.
-        regnode(NOTHING);
-
-    return (ret);
-}
-
-
-/*
- - regpiece - something followed by possible [*+?]
- *
- * Note that the branching code sequences used for ? and the general cases
- * of * and + are somewhat optimized:  they use the same NOTHING node as
- * both the endmarker for their branch list and the body of the last branch.
- * It might seem that this node could be dispensed with entirely, but the
- * endmarker role is not redundant.
- */
-static char* regpiece (int *flagp) {
-    register char* ret;
-    register char  op;
-    register char* next;
-    int            flags;
-
-    ret = regatom(&flags);
-    if (ret == 0)
-        return (0);
-
-    op = *regparse;
-    if (!ISMULT(op)) {
-        *flagp = flags;
-        return (ret);
-    }
-
-    if (!(flags & HASWIDTH) && op != '?') {
-        //RAISE Error, SYM(cmRegularExpression), SYM(Empty_Operand),
-        printf ("cmRegularExpression::compile() : *+ operand could be empty.\n");
-        return 0;
-    }
-    *flagp = (op != '+') ? (WORST | SPSTART) : (WORST | HASWIDTH);
-
-    if (op == '*' && (flags & SIMPLE))
-        reginsert(STAR, ret);
-    else if (op == '*') {
-        // Emit x* as (x&|), where & means "self".
-        reginsert(BRANCH, ret); // Either x
-        regoptail(ret, regnode(BACK));  // and loop
-        regoptail(ret, ret);    // back
-        regtail(ret, regnode(BRANCH));  // or
-        regtail(ret, regnode(NOTHING)); // null.
-    }
-    else if (op == '+' && (flags & SIMPLE))
-        reginsert(PLUS, ret);
-    else if (op == '+') {
-        // Emit x+ as x(&|), where & means "self".
-        next = regnode(BRANCH); // Either
-        regtail(ret, next);
-        regtail(regnode(BACK), ret);    // loop back
-        regtail(next, regnode(BRANCH)); // or
-        regtail(ret, regnode(NOTHING)); // null.
-    }
-    else if (op == '?') {
-        // Emit x? as (x|)
-        reginsert(BRANCH, ret); // Either x
-        regtail(ret, regnode(BRANCH));  // or
-        next = regnode(NOTHING);// null.
-        regtail(ret, next);
-        regoptail(ret, next);
-    }
-    regparse++;
-    if (ISMULT(*regparse)) {
-        //RAISE Error, SYM(cmRegularExpression), SYM(Nested_Operand),
-        printf ("cmRegularExpression::compile(): Nested *?+.\n");
-        return 0;
-    }
-    return (ret);
-}
-
-
-/*
- - regatom - the lowest level
- *
- * Optimization:  gobbles an entire sequence of ordinary characters so that
- * it can turn them into a single node, which is smaller to store and
- * faster to run.  Backslashed characters are exceptions, each becoming a
- * separate node; the code is simpler that way and it's not worth fixing.
- */
-static char* regatom (int *flagp) {
-    register char* ret;
-             int   flags;
-
-    *flagp = WORST;             // Tentatively.
-
-    switch (*regparse++) {
-        case '^':
-            ret = regnode(BOL);
-            break;
-        case '$':
-            ret = regnode(EOL);
-            break;
-        case '.':
-            ret = regnode(ANY);
-            *flagp |= HASWIDTH | SIMPLE;
-            break;
-        case '[':{
-                register int    rxpclass;
-                register int    rxpclassend;
-
-                if (*regparse == '^') { // Complement of range.
-                    ret = regnode(ANYBUT);
-                    regparse++;
-                }
-                else
-                    ret = regnode(ANYOF);
-                if (*regparse == ']' || *regparse == '-')
-                    regc(*regparse++);
-                while (*regparse != '\0' && *regparse != ']') {
-                    if (*regparse == '-') {
-                        regparse++;
-                        if (*regparse == ']' || *regparse == '\0')
-                            regc('-');
-                        else {
-                            rxpclass = UCHARAT(regparse - 2) + 1;
-                            rxpclassend = UCHARAT(regparse);
-                            if (rxpclass > rxpclassend + 1) {
-                               //RAISE Error, SYM(cmRegularExpression), SYM(Invalid_Range),
-                               printf ("cmRegularExpression::compile(): Invalid range in [].\n");
-                               return 0;
-                            }
-                            for (; rxpclass <= rxpclassend; rxpclass++)
-                                regc(rxpclass);
-                            regparse++;
-                        }
-                    }
-                    else
-                        regc(*regparse++);
-                }
-                regc('\0');
-                if (*regparse != ']') {
-                    //RAISE Error, SYM(cmRegularExpression), SYM(Unmatched_Bracket),
-                    printf ("cmRegularExpression::compile(): Unmatched [].\n");
-                    return 0;
-                }
-                regparse++;
-                *flagp |= HASWIDTH | SIMPLE;
-            }
-            break;
-        case '(':
-            ret = reg(1, &flags);
-            if (ret == 0)
-                return (0);
-            *flagp |= flags & (HASWIDTH | SPSTART);
-            break;
-        case '\0':
-        case '|':
-        case ')':
-            //RAISE Error, SYM(cmRegularExpression), SYM(Internal_Error),
-            printf ("cmRegularExpression::compile(): Internal error.\n"); // Never here
-            return 0;
-        case '?':
-        case '+':
-        case '*':
-            //RAISE Error, SYM(cmRegularExpression), SYM(No_Operand),
-            printf ("cmRegularExpression::compile(): ?+* follows nothing.\n");
-            return 0;
-        case '\\':
-            if (*regparse == '\0') {
-                //RAISE Error, SYM(cmRegularExpression), SYM(Trailing_Backslash),
-                printf ("cmRegularExpression::compile(): Trailing backslash.\n");
-                return 0;
-            }
-            ret = regnode(EXACTLY);
-            regc(*regparse++);
-            regc('\0');
-            *flagp |= HASWIDTH | SIMPLE;
-            break;
-        default:{
-                register int    len;
-                register char   ender;
-
-                regparse--;
-                len = int(strcspn(regparse, META));
-                if (len <= 0) {
-                    //RAISE Error, SYM(cmRegularExpression), SYM(Internal_Error),
-                    printf ("cmRegularExpression::compile(): Internal error.\n");
-                    return 0;
-                }
-                ender = *(regparse + len);
-                if (len > 1 && ISMULT(ender))
-                    len--;      // Back off clear of ?+* operand.
-                *flagp |= HASWIDTH;
-                if (len == 1)
-                    *flagp |= SIMPLE;
-                ret = regnode(EXACTLY);
-                while (len > 0) {
-                    regc(*regparse++);
-                    len--;
-                }
-                regc('\0');
-            }
-            break;
-    }
-    return (ret);
-}
-
-
-/*
- - regnode - emit a node
-   Location.
- */
-static char* regnode (char op) {
-    register char* ret;
-    register char* ptr;
-
-    ret = regcode;
-    if (ret == &regdummy) {
-        regsize += 3;
-        return (ret);
-    }
-
-    ptr = ret;
-    *ptr++ = op;
-    *ptr++ = '\0';              // Null "next" pointer.
-    *ptr++ = '\0';
-    regcode = ptr;
-
-    return (ret);
-}
-
-
-/*
- - regc - emit (if appropriate) a byte of code
- */
-static void regc (unsigned char b) {
-    if (regcode != &regdummy)
-        *regcode++ = b;
-    else
-        regsize++;
-}
-
-
-/*
- - reginsert - insert an operator in front of already-emitted operand
- *
- * Means relocating the operand.
- */
-static void reginsert (char op, char* opnd) {
-    register char* src;
-    register char* dst;
-    register char* place;
-
-    if (regcode == &regdummy) {
-        regsize += 3;
-        return;
-    }
-
-    src = regcode;
-    regcode += 3;
-    dst = regcode;
-    while (src > opnd)
-        *--dst = *--src;
-
-    place = opnd;               // Op node, where operand used to be.
-    *place++ = op;
-    *place++ = '\0';
-    *place = '\0';
-}
-
-
-/*
- - regtail - set the next-pointer at the end of a node chain
- */
-static void regtail (char* p, const char* val) {
-    register char* scan;
-    register char* temp;
-    register int   offset;
-
-    if (p == &regdummy)
-        return;
-
-    // Find last node.
-    scan = p;
-    for (;;) {
-        temp = regnext(scan);
-        if (temp == 0)
-            break;
-        scan = temp;
-    }
-
-    if (OP(scan) == BACK)
-        offset = int(scan - val);
-    else
-        offset = int(val - scan);
-    *(scan + 1) = (offset >> 8) & 0377;
-    *(scan + 2) = offset & 0377;
-}
-
-
-/*
- - regoptail - regtail on operand of first argument; nop if operandless
- */
-static void regoptail (char* p, const char* val) {
-    // "Operandless" and "op != BRANCH" are synonymous in practice.
-    if (p == 0 || p == &regdummy || OP(p) != BRANCH)
-        return;
-    regtail(OPERAND(p), val);
-}
-
-
-
-////////////////////////////////////////////////////////////////////////
-// 
-//  find and friends
-// 
-////////////////////////////////////////////////////////////////////////
-
-
-/*
- * Global work variables for find().
- */
-static const char*  reginput;   // String-input pointer.
-static const char*  regbol;     // Beginning of input, for ^ check.
-static const char* *regstartp;  // Pointer to startp array.
-static const char* *regendp;    // Ditto for endp.
-
-/*
- * Forwards.
- */
-static int regtry (const char*, const char* *,
-                   const char* *, const char*);
-static int regmatch (const char*);
-static int regrepeat (const char*);
-
-#ifdef DEBUG
-int          regnarrate = 0;
-void         regdump ();
-static char* regprop ();
-#endif
-
-bool cmRegularExpression::find (std::string const& s) 
-{
-  return find(s.c_str());
-}
-
-
-
-// find -- Matches the regular expression to the given string.
-// Returns true if found, and sets start and end indexes accordingly.
-
-bool cmRegularExpression::find (const char* string) {
-    register const char* s;
-
-    this->searchstring = string;
-
-    if (!this->program)
-      {
-      return false;
-      }
-    
-    // Check validity of program.
-    if (UCHARAT(this->program) != MAGIC) {
-        //RAISE Error, SYM(cmRegularExpression), SYM(Internal_Error),
-        printf ("cmRegularExpression::find(): Compiled regular expression corrupted.\n");
-        return 0;
-    }
-    
-    // If there is a "must appear" string, look for it.
-    if (this->regmust != 0) {
-        s = string;
-        while ((s = strchr(s, this->regmust[0])) != 0) {
-            if (strncmp(s, this->regmust, this->regmlen) == 0)
-                break;          // Found it.
-            s++;
-        }
-        if (s == 0)             // Not present.
-            return (0);
-    }
-     
-    // Mark beginning of line for ^ .
-    regbol = string;
-
-    // Simplest case:  anchored match need be tried only once.
-    if (this->reganch)
-        return (regtry(string, this->startp, this->endp, this->program) != 0);
-    
-    // Messy cases:  unanchored match.
-    s = string;
-    if (this->regstart != '\0')
-        // We know what char it must start with.
-        while ((s = strchr(s, this->regstart)) != 0) {
-            if (regtry(s, this->startp, this->endp, this->program))
-                return (1);
-            s++;
-          
-        }
-    else
-        // We don't -- general case.
-        do {
-            if (regtry(s, this->startp, this->endp, this->program))
-                return (1);
-        } while (*s++ != '\0');
-    
-    // Failure.
-    return (0);
-}
-
-
-/*
- - regtry - try match at specific point
-   0 failure, 1 success
- */
-static int regtry (const char* string, const char* *start,
-                   const char* *end, const char* prog) {
-    register       int    i;
-    register const char* *sp1;
-    register const char* *ep;
-
-    reginput = string;
-    regstartp = start;
-    regendp = end;
-
-    sp1 = start;
-    ep = end;
-    for (i = NSUBEXP; i > 0; i--) {
-        *sp1++ = 0;
-        *ep++ = 0;
-    }
-    if (regmatch(prog + 1)) {
-        start[0] = string;
-        end[0] = reginput;
-        return (1);
-    }
-    else
-        return (0);
-}
-
-
-/*
- - regmatch - main matching routine
- *
- * Conceptually the strategy is simple:  check to see whether the current
- * node matches, call self recursively to see whether the rest matches,
- * and then act accordingly.  In practice we make some effort to avoid
- * recursion, in particular by going through "ordinary" nodes (that don't
- * need to know whether the rest of the match failed) by a loop instead of
- * by recursion.
- * 0 failure, 1 success
- */
-static int regmatch (const char* prog) {
-    register const char* scan;  // Current node.
-             const char* next;  // Next node.
-
-    scan = prog;
-
-    while (scan != 0) {
-
-        next = regnext(scan);
-
-        switch (OP(scan)) {
-            case BOL:
-                if (reginput != regbol)
-                    return (0);
-                break;
-            case EOL:
-                if (*reginput != '\0')
-                    return (0);
-                break;
-            case ANY:
-                if (*reginput == '\0')
-                    return (0);
-                reginput++;
-                break;
-            case EXACTLY:{
-                    register int         len;
-                    register const char* opnd;
-
-                    opnd = OPERAND(scan);
-                    // Inline the first character, for speed.
-                    if (*opnd != *reginput)
-                        return (0);
-                    len = int(strlen(opnd));
-                    if (len > 1 && strncmp(opnd, reginput, len) != 0)
-                        return (0);
-                    reginput += len;
-                }
-                break;
-            case ANYOF:
-                if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) == 0)
-                    return (0);
-                reginput++;
-                break;
-            case ANYBUT:
-                if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) != 0)
-                    return (0);
-                reginput++;
-                break;
-            case NOTHING:
-                break;
-            case BACK:
-                break;
-            case OPEN + 1:
-            case OPEN + 2:
-            case OPEN + 3:
-            case OPEN + 4:
-            case OPEN + 5:
-            case OPEN + 6:
-            case OPEN + 7:
-            case OPEN + 8:
-            case OPEN + 9:{
-                    register       int    no;
-                    register const char* save;
-
-                    no = OP(scan) - OPEN;
-                    save = reginput;
-
-                    if (regmatch(next)) {
-
-                        //
-                        // Don't set startp if some later invocation of the
-                        // same parentheses already has. 
-                        //
-                        if (regstartp[no] == 0)
-                            regstartp[no] = save;
-                        return (1);
-                    }
-                    else
-                        return (0);
-                }
-//              break;
-            case CLOSE + 1:
-            case CLOSE + 2:
-            case CLOSE + 3:
-            case CLOSE + 4:
-            case CLOSE + 5:
-            case CLOSE + 6:
-            case CLOSE + 7:
-            case CLOSE + 8:
-            case CLOSE + 9:{
-                    register       int    no;
-                    register const char* save;
-
-                    no = OP(scan) - CLOSE;
-                    save = reginput;
-
-                    if (regmatch(next)) {
-
-                        //
-                        // Don't set endp if some later invocation of the
-                        // same parentheses already has. 
-                        //
-                        if (regendp[no] == 0)
-                            regendp[no] = save;
-                        return (1);
-                    }
-                    else
-                        return (0);
-                }
-//              break;
-            case BRANCH:{
-              
-              register const char* save;
-
-                    if (OP(next) != BRANCH)     // No choice.
-                        next = OPERAND(scan);   // Avoid recursion.
-                    else {
-                        do {
-                            save = reginput;
-                            if (regmatch(OPERAND(scan)))
-                                return (1);
-                            reginput = save;
-                            scan = regnext(scan);
-                        } while (scan != 0 && OP(scan) == BRANCH);
-                        return (0);
-                        // NOTREACHED
-                    }
-                }
-                break;
-            case STAR:
-            case PLUS:{
-              register char   nextch;
-                    register int        no;
-                    register const char* save;
-                    register int        min_no;
-
-                    //
-                    // Lookahead to avoid useless match attempts when we know
-                    // what character comes next. 
-                    //
-                    nextch = '\0';
-                    if (OP(next) == EXACTLY)
-                        nextch = *OPERAND(next);
-                    min_no = (OP(scan) == STAR) ? 0 : 1;
-                    save = reginput;
-                    no = regrepeat(OPERAND(scan));
-                    while (no >= min_no) {
-                        // If it could work, try it.
-                        if (nextch == '\0' || *reginput == nextch)
-                            if (regmatch(next))
-                                return (1);
-                        // Couldn't or didn't -- back up.
-                        no--;
-                        reginput = save + no;
-                    }
-                    return (0);
-                }
-//              break;
-            case END:
-                return (1);     // Success!
-
-            default:
-                //RAISE Error, SYM(cmRegularExpression), SYM(Internal_Error),
-                printf ("cmRegularExpression::find(): Internal error -- memory corrupted.\n");
-                return 0;
-        }
-        scan = next;
-    }
-
-    // 
-    //  We get here only if there's trouble -- normally "case END" is the
-    //  terminating point. 
-    // 
-    //RAISE Error, SYM(cmRegularExpression), SYM(Internal_Error),
-    printf ("cmRegularExpression::find(): Internal error -- corrupted pointers.\n");
-    return (0);
-}
-
-
-/*
- - regrepeat - repeatedly match something simple, report how many
- */
-static int regrepeat (const char* p) {
-    register       int   count = 0;
-    register const char* scan;
-    register const char* opnd;
-
-    scan = reginput;
-    opnd = OPERAND(p);
-    switch (OP(p)) {
-        case ANY:
-            count = int(strlen(scan));
-            scan += count;
-            break;
-        case EXACTLY:
-            while (*opnd == *scan) {
-                count++;
-                scan++;
-            }
-            break;
-        case ANYOF:
-            while (*scan != '\0' && strchr(opnd, *scan) != 0) {
-                count++;
-                scan++;
-            }
-            break;
-        case ANYBUT:
-            while (*scan != '\0' && strchr(opnd, *scan) == 0) {
-                count++;
-                scan++;
-            }
-            break;
-        default:                // Oh dear.  Called inappropriately.
-            //RAISE Error, SYM(cmRegularExpression), SYM(Internal_Error),
-            printf ("cm RegularExpression::find(): Internal error.\n");
-            return 0;
-    }
-    reginput = scan;
-    return (count);
-}
-
-
-/*
- - regnext - dig the "next" pointer out of a node
- */
-static const char* regnext (register const char* p) {
-    register int offset;
-
-    if (p == &regdummy)
-        return (0);
-
-    offset = NEXT(p);
-    if (offset == 0)
-        return (0);
-
-    if (OP(p) == BACK)
-        return (p - offset);
-    else
-        return (p + offset);
-}
-
-
-static char* regnext (register char* p) {
-    register int offset;
-
-    if (p == &regdummy)
-        return (0);
-
-    offset = NEXT(p);
-    if (offset == 0)
-        return (0);
-
-    if (OP(p) == BACK)
-        return (p - offset);
-    else
-        return (p + offset);
-}
diff --git a/Source/cmRegularExpression.h b/Source/cmRegularExpression.h
deleted file mode 100644
index 646deea..0000000
--- a/Source/cmRegularExpression.h
+++ /dev/null
@@ -1,378 +0,0 @@
-/*=========================================================================
-
-  Program:   CMake - Cross-Platform Makefile Generator
-  Module:    $RCSfile$
-  Language:  C++
-  Date:      $Date$
-  Version:   $Revision$
-
-  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
-  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
-
-     This software is distributed WITHOUT ANY WARRANTY; without even 
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
-     PURPOSE.  See the above copyright notices for more information.
-
-=========================================================================*/
-// Original Copyright notice:
-// Copyright (C) 1991 Texas Instruments Incorporated.
-//
-// Permission is granted to any individual or institution to use, copy, modify,
-// and distribute this software, provided that this complete copyright and
-// permission notice is maintained, intact, in all copies and supporting
-// documentation.
-//
-// Texas Instruments Incorporated provides this software "as is" without
-// express or implied warranty.
-//
-// Created: MNF 06/13/89  Initial Design and Implementation
-// Updated: LGO 08/09/89  Inherit from Generic
-// Updated: MBN 09/07/89  Added conditional exception handling
-// Updated: MBN 12/15/89  Sprinkled "const" qualifiers all over the place!
-// Updated: DLS 03/22/91  New lite version
-//
-
-#ifndef cmRegularExpression_h
-#define cmRegularExpression_h
-
-#include "cmStandardIncludes.h"
-
-const int NSUBEXP = 10;
-
-/** \class cmRegularExpression
- * \brief Implements pattern matching with regular expressions.
- *
- * This is the header file for the regular expression class.  An object of
- * this class contains a regular expression, in a special "compiled" format.
- * This compiled format consists of several slots all kept as the objects
- * private data.  The cmRegularExpression class provides a convenient way to
- * represent regular expressions.  It makes it easy to search for the same
- * regular expression in many different strings without having to compile a
- * string to regular expression format more than necessary.
- *
- * This class implements pattern matching via regular expressions.
- * A regular expression allows a programmer to specify  complex
- * patterns  that  can  be searched for and matched against the
- * character string of a string object. In its simplest form, a
- * regular  expression  is  a  sequence  of  characters used to
- * search for exact character matches. However, many times  the
- * exact  sequence to be found is not known, or only a match at
- * the beginning or end of a string is desired. The cmRegularExpression regu-
- * lar  expression  class implements regular expression pattern
- * matching as is found and implemented in many  UNIX  commands
- * and utilities.
- *
- * Example: The perl code
- * 
- *    $filename =~ m"([a-z]+)\.cc";
- *    print $1;
- *    
- * Is written as follows in C++
- *
- *    cmRegularExpression re("([a-z]+)\\.cc");
- *    re.find(filename);
- *    cerr << re.match(1);
- *
- *
- * The regular expression class provides a convenient mechanism
- * for  specifying  and  manipulating  regular expressions. The
- * regular expression object allows specification of such  pat-
- * terns  by using the following regular expression metacharac-
- * ters:
- *
- *  ^        Matches at beginning of a line
- *
- *  $        Matches at end of a line
- *
- * .         Matches any single character
- *
- * [ ]       Matches any character(s) inside the brackets
- *
- * [^ ]      Matches any character(s) not inside the brackets
- *
- *  -        Matches any character in range on either side of a dash
- *
- *  *        Matches preceding pattern zero or more times
- *
- *  +        Matches preceding pattern one or more times
- *
- *  ?        Matches preceding pattern zero or once only
- *
- * ()        Saves a matched expression and uses it in a  later match
- *
- * Note that more than one of these metacharacters can be  used
- * in  a  single  regular expression in order to create complex
- * search patterns. For example, the pattern [^ab1-9]  says  to
- * match  any  character  sequence that does not begin with the
- * characters "ab"  followed  by  numbers  in  the  series  one
- * through nine.
- *
- * There are three constructors for cmRegularExpression.  One just creates an
- * empty cmRegularExpression object.  Another creates a cmRegularExpression
- * object and initializes it with a regular expression that is given in the
- * form of a char*.  The third takes a reference to a cmRegularExpression
- * object as an argument and creates an object initialized with the
- * information from the given cmRegularExpression object.
- *
- * The  find  member function  finds   the  first  occurence   of  the regualr
- * expression of that object in the string given to find as an argument.  Find
- * returns a boolean, and  if true,  mutates  the private  data appropriately.
- * Find sets pointers to the beginning and end of  the thing last  found, they
- * are pointers into the actual string  that was searched.   The start and end
- * member functions return indicies  into the searched string that  correspond
- * to the beginning   and  end pointers  respectively.   The    compile member
- * function takes a char* and puts the  compiled version of the char* argument
- * into the object's private data fields.  The == and  != operators only check
- * the  to see  if   the compiled  regular  expression   is the same, and  the
- * deep_equal functions also checks  to see if the  start and end pointers are
- * the same.  The is_valid  function returns false if  program is set to NULL,
- * (i.e. there is no valid compiled exression).  The set_invalid function sets
- * the  program to NULL  (Warning: this deletes the compiled  expression). The
- * following examples may help clarify regular expression usage:
- *
- *   *  The regular expression  "^hello" matches  a "hello"  only at  the
- *      beginning of a  line.  It would match "hello  there" but not "hi,
- *      hello there".
- *
- *   *  The regular expression "long$" matches a  "long"  only at the end
- *      of a line. It would match "so long\0", but not "long ago".
- *
- *   *  The regular expression "t..t..g"  will match anything that  has a
- *      "t" then any two characters, another "t", any  two characters and
- *      then a "g".   It will match  "testing", or "test again" but would
- *      not match "toasting"
- *
- *   *  The regular  expression "[1-9ab]" matches any  number one through
- *      nine, and the characters  "a" and  "b".  It would match "hello 1"
- *      or "begin", but would not match "no-match".
- *
- *   *  The  regular expression "[^1-9ab]"  matches any character that is
- *      not a number one  through nine, or  an "a" or "b".   It would NOT
- *      match "hello 1" or "begin", but would match "no-match".
- *
- *   *  The regular expression "br* " matches  something that begins with
- *      a "b", is followed by zero or more "r"s, and ends in a space.  It
- *      would match "brrrrr ", and "b ", but would not match "brrh ".
- *
- *   *  The regular expression "br+ " matches something  that begins with
- *      a "b", is followed by one or more "r"s, and ends in  a space.  It
- *      would match "brrrrr ",  and  "br ", but would not  match "b  " or
- *      "brrh ".
- *
- *   *  The regular expression "br? " matches  something that begins with
- *      a "b", is followed by zero or one "r"s, and ends in  a space.  It
- *      would  match  "br ", and "b  ", but would not match  "brrrr "  or
- *      "brrh ".
- *
- *   *  The regular expression "(..p)b" matches  something ending with pb
- *      and beginning with whatever the two characters before the first p
- *      encounterd in the line were.  It would find  "repb" in "rep drepa
- *      qrepb".  The regular expression "(..p)a"  would find "repa qrepb"
- *      in "rep drepa qrepb"
- *
- *   *  The regular expression "d(..p)" matches something ending  with p,
- *      beginning with d, and having  two characters  in between that are
- *      the same as the two characters before  the first p  encounterd in
- *      the line.  It would match "drepa qrepb" in "rep drepa qrepb".
- *
- */
-class cmRegularExpression 
-{
-public:
-  /**
-   * Instantiate cmRegularExpression with program=NULL.
-   */
-  inline cmRegularExpression ();        
-
-  /**
-   * Instantiate cmRegularExpression with compiled char*.
-   */
-  inline cmRegularExpression (char const*);
-  
-  /**
-   * Instantiate cmRegularExpression as a copy of another regular expression.
-   */
-  cmRegularExpression (cmRegularExpression const&);
-
-  /**
-   * Destructor.
-   */
-  inline ~cmRegularExpression();
-
-  /**
-   * Compile a regular expression into internal code
-   * for later pattern matching.
-   */
-  bool compile (char const*);
-
-  /**
-   * Matches the regular expression to the given string.
-   * Returns true if found, and sets start and end indexes accordingly.
-   */
-  bool find (char const*);
-
-  /**
-   * Matches the regular expression to the given std string.
-   * Returns true if found, and sets start and end indexes accordingly.
-   */
-  bool find (std::string const&);               
-
-  /**
-   * Index to start of first find.
-   */
-  inline std::string::size_type start() const;
-
-  /**
-   * Index to end of first find.
-   */
-  inline std::string::size_type end() const;
-
-  /**
-   * Returns true if two regular expressions have the same
-   * compiled program for pattern matching.
-   */
-  bool operator== (cmRegularExpression const&) const;
-
-  /**
-   * Returns true if two regular expressions have different
-   * compiled program for pattern matching.
-   */
-  inline bool operator!= (cmRegularExpression const&) const;
-
-  /**
-   * Returns true if have the same compiled regular expressions
-   * and the same start and end pointers.
-   */
-  bool deep_equal (cmRegularExpression const&) const;
-  
-  /**
-   * True if the compiled regexp is valid.
-   */
-  inline bool is_valid() const;
-
-  /**
-   * Marks the regular expression as invalid.
-   */
-  inline void set_invalid();            
-
-  /**
-   * Destructor.
-   */
-  // awf added
-  std::string::size_type start(int n) const;
-  std::string::size_type end(int n) const;
-  std::string match(int n) const;
-  
-private: 
-  const char* startp[NSUBEXP];
-  const char* endp[NSUBEXP];
-  char  regstart;                       // Internal use only
-  char  reganch;                        // Internal use only
-  const char* regmust;                  // Internal use only
-  int   regmlen;                        // Internal use only
-  char* program;   
-  int   progsize;
-  const char* searchstring;
-}; 
-
-/**
- * Create an empty regular expression.
- */
-inline cmRegularExpression::cmRegularExpression () 
-{ 
-  this->program = 0;
-}
-
-/**
- * Creates a regular expression from string s, and
- * compiles s.
- */
-inline cmRegularExpression::cmRegularExpression (const char* s) 
-{  
-  this->program = 0;
-  if ( s )
-    {
-    this->compile(s);
-    }
-}
-
-/**
- * Destroys and frees space allocated for the regular expression.
- */
-inline cmRegularExpression::~cmRegularExpression () 
-{
-//#ifndef WIN32
-  delete [] this->program;
-//#endif
-}
-
-/**
- * Set the start position for the regular expression.
- */
-inline std::string::size_type cmRegularExpression::start () const 
-{
-  return(this->startp[0] - searchstring);
-}
-
-
-/**
- * Returns the start/end index of the last item found.
- */
-inline std::string::size_type cmRegularExpression::end () const 
-{
-  return(this->endp[0] - searchstring);
-}
-
-/**
- * Returns true if two regular expressions have different
- * compiled program for pattern matching.
- */
-inline bool cmRegularExpression::operator!= (const cmRegularExpression& r) const 
-{
-  return(!(*this == r));
-}
-
-/**
- * Returns true if a valid regular expression is compiled
- * and ready for pattern matching.
- */
-inline bool cmRegularExpression::is_valid () const 
-{
-  return (this->program != 0);
-}
-
-
-inline void cmRegularExpression::set_invalid () 
-{
-//#ifndef WIN32
-  delete [] this->program;
-//#endif
-  this->program = 0;
-}
-
-/**
- * Return start index of nth submatch. start(0) is the start of the full match.
- */
-inline std::string::size_type cmRegularExpression::start(int n) const
-{
-  return this->startp[n] - searchstring;
-}
-
-
-/**
- * Return end index of nth submatch. end(0) is the end of the full match.
- */
-inline std::string::size_type cmRegularExpression::end(int n) const
-{
-  return this->endp[n] - searchstring;
-}
-
-/**
- * Return nth submatch as a string.
- */
-inline std::string cmRegularExpression::match(int n) const
-{
-  return std::string(this->startp[n], this->endp[n] - this->startp[n]);
-}
-
-#endif // cmRegularExpressionh
diff --git a/Source/cmSiteNameCommand.cxx b/Source/cmSiteNameCommand.cxx
index b733eb8..a3bf742 100644
--- a/Source/cmSiteNameCommand.cxx
+++ b/Source/cmSiteNameCommand.cxx
@@ -16,6 +16,8 @@
 =========================================================================*/
 #include "cmSiteNameCommand.h"
 
+#include <cmsys/RegularExpression.hxx>
+
 // cmSiteNameCommand
 bool cmSiteNameCommand::InitialPass(std::vector<std::string> const& args)
 {
@@ -72,7 +74,7 @@ bool cmSiteNameCommand::InitialPass(std::vector<std::string> const& args)
       {
       // remove any white space from the host name
       std::string hostRegExp = "[ \t\n\r]*([^\t\n\r ]*)[ \t\n\r]*";
-      cmRegularExpression hostReg (hostRegExp.c_str());
+      cmsys::RegularExpression hostReg (hostRegExp.c_str());
       if (hostReg.find(host.c_str()))
         {
         // strip whitespace
@@ -109,7 +111,7 @@ bool cmSiteNameCommand::InitialPass(std::vector<std::string> const& args)
             std::string RegExp = ".*Name:[ \t\n]*";
             RegExp += host;
             RegExp += "\\.([^ \t\n\r]*)[ \t\n\r]*Address:";
-            cmRegularExpression reg( RegExp.c_str() );
+            cmsys::RegularExpression reg( RegExp.c_str() );
             if(reg.find(nsOutput.c_str()))
               {
               siteName += '.' + cmSystemTools::LowerCase(reg.match(1));
diff --git a/Source/cmSourceGroup.h b/Source/cmSourceGroup.h
index 0dbd8cc..3158041 100644
--- a/Source/cmSourceGroup.h
+++ b/Source/cmSourceGroup.h
@@ -18,7 +18,8 @@
 #define cmSourceGroup_h
 
 #include "cmStandardIncludes.h"
-#include "cmRegularExpression.h"
+#include <cmsys/RegularExpression.hxx>
+
 class cmSourceFile;
 
 /** \class cmSourceGroup
@@ -57,7 +58,7 @@ private:
   /**
    * The regular expression matching the files in the group.
    */
-  cmRegularExpression m_GroupRegex;
+  cmsys::RegularExpression m_GroupRegex;
   
   /**
    * vector of all source files in this source group
diff --git a/Source/cmStringCommand.cxx b/Source/cmStringCommand.cxx
index e8d6bc1..1e13592 100644
--- a/Source/cmStringCommand.cxx
+++ b/Source/cmStringCommand.cxx
@@ -15,6 +15,8 @@
 
 =========================================================================*/
 #include "cmStringCommand.h"
+#include <cmsys/RegularExpression.hxx>
+
 #include <stdlib.h> // required for atoi
 //----------------------------------------------------------------------------
 bool cmStringCommand::InitialPass(std::vector<std::string> const& args)
@@ -136,7 +138,7 @@ bool cmStringCommand::RegexMatch(std::vector<std::string> const& args)
     }
   
   // Compile the regular expression.
-  cmRegularExpression re;
+  cmsys::RegularExpression re;
   if(!re.compile(regex.c_str()))
     {
     std::string e = "sub-command REGEX, mode MATCH failed to compile regex \""+regex+"\".";
@@ -179,7 +181,7 @@ bool cmStringCommand::RegexMatchAll(std::vector<std::string> const& args)
     }
   
   // Compile the regular expression.
-  cmRegularExpression re;
+  cmsys::RegularExpression re;
   if(!re.compile(regex.c_str()))
     {
     std::string e = "sub-command REGEX, mode MATCHALL failed to compile regex \""+regex+"\".";
@@ -277,7 +279,7 @@ bool cmStringCommand::RegexReplace(std::vector<std::string> const& args)
     }
   
   // Compile the regular expression.
-  cmRegularExpression re;
+  cmsys::RegularExpression re;
   if(!re.compile(regex.c_str()))
     {
     std::string e = "sub-command REGEX, mode REPLACE failed to compile regex \""+regex+"\".";
diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx
index 38c8648..a4cc6eb 100644
--- a/Source/cmSystemTools.cxx
+++ b/Source/cmSystemTools.cxx
@@ -16,11 +16,11 @@
 =========================================================================*/
 #include "cmSystemTools.h"   
 #include <stdio.h>
-#include "cmRegularExpression.h"
 #include <ctype.h>
 #include <errno.h>
 #include <time.h>
 
+#include <cmsys/RegularExpression.hxx>
 #include <cmsys/Directory.hxx>
 
 // support for realpath call
@@ -76,7 +76,7 @@ void cmSystemTools::ExpandRegistryValues(std::string& source)
   // The "[^]]" part of this expression will match any character except
   // a close square-bracket.  The ']' character must be the first in the
   // list of characters inside the [^...] block of the expression.
-  cmRegularExpression regEntry("\\[(HKEY[^]]*)\\]");
+  cmsys::RegularExpression regEntry("\\[(HKEY[^]]*)\\]");
   
   // check for black line or comment
   while (regEntry.find(source))
@@ -263,7 +263,7 @@ bool cmSystemTools::IsOn(const char* val)
 
 bool cmSystemTools::IsNOTFOUND(const char* val)
 {
-  cmRegularExpression reg("-NOTFOUND$");
+  cmsys::RegularExpression reg("-NOTFOUND$");
   if(reg.find(val))
     {
     return true;
@@ -539,7 +539,7 @@ bool cmSystemTools::RunCommand(const char* command,
     // one set of quotes in the arguments
     if(count > 2)
       {
-      cmRegularExpression quoted("^\"([^\"]*)\"[ \t](.*)");
+      cmsys::RegularExpression quoted("^\"([^\"]*)\"[ \t](.*)");
       if(quoted.find(command))
         {
         std::string shortCmd;
@@ -609,7 +609,7 @@ void cmSystemTools::Glob(const char *directory, const char *regexp,
                          std::vector<std::string>& files)
 {
   cmsys::Directory d;
-  cmRegularExpression reg(regexp);
+  cmsys::RegularExpression reg(regexp);
   
   if (d.Load(directory))
     {
diff --git a/Source/cmUseMangledMesaCommand.cxx b/Source/cmUseMangledMesaCommand.cxx
index 3e6e2e0..d780dff 100644
--- a/Source/cmUseMangledMesaCommand.cxx
+++ b/Source/cmUseMangledMesaCommand.cxx
@@ -17,6 +17,8 @@
 #include "cmUseMangledMesaCommand.h"
 #include "cmSystemTools.h"
 
+#include <cmsys/RegularExpression.hxx>
+
 // cmUseMangledMesaCommand
 bool cmUseMangledMesaCommand::InitialPass(std::vector<std::string> const& args)
 { 
@@ -91,11 +93,11 @@ CopyAndFullPathMesaHeader(const char* source,
   // input file at the same time
   std::string inLine;  
   // regular expression for any #include line
-  cmRegularExpression includeLine("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]");
+  cmsys::RegularExpression includeLine("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]");
   // regular expression for gl/ or GL/ in a file (match(1) of above)
-  cmRegularExpression glDirLine("(gl|GL)(/|\\\\)([^<\"]+)");
+  cmsys::RegularExpression glDirLine("(gl|GL)(/|\\\\)([^<\"]+)");
   // regular expression for gl GL or xmesa in a file (match(1) of above)
-  cmRegularExpression glLine("(gl|GL|xmesa)");
+  cmsys::RegularExpression glLine("(gl|GL|xmesa)");
   while(cmSystemTools::GetLineFromStream(fin,inLine))
     {
     if(includeLine.find(inLine.c_str()))
diff --git a/Source/cmaketest.cxx b/Source/cmaketest.cxx
index 66b9ed1..aca0f93 100644
--- a/Source/cmaketest.cxx
+++ b/Source/cmaketest.cxx
@@ -16,11 +16,11 @@
 =========================================================================*/
 #include "cmaketest.h"
 #include "cmSystemTools.h"
-#include "cmRegularExpression.h"
 #include "cmake.h"
 #include "cmListFileCache.h"
 #include "cmCacheManager.h"
 #include "cmDynamicLoader.h"
+
 #if defined(_WIN32) && !defined(__CYGWIN__) 
 #include "windows.h"
 #endif
diff --git a/bootstrap b/bootstrap
index 8165ffa..3426273 100755
--- a/bootstrap
+++ b/bootstrap
@@ -30,7 +30,6 @@ CMAKE_SOURCES="\
   cmDocumentation \
   cmGlobalGenerator \
   cmLocalGenerator \
-  cmRegularExpression \
   cmSourceFile \
   cmSystemTools \
   cmGlobalUnixMakefileGenerator \