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

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)
 

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

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

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: +[^;]+;");
+  cmsys::RegularExpression date_author("^date: +([^;]+); +author: +([^;]+); +state: +[^;]+;");
-  cmRegularExpression revision("^revision +([^ ]*) *$");
+  cmsys::RegularExpression revision("^revision +([^ ]*) *$");
-  cmRegularExpression end_of_file("^=============================================================================$");
+  cmsys::RegularExpression end_of_file("^=============================================================================$");
-  cmRegularExpression end_of_comment("^----------------------------$");
+  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());
+  cmsys::RegularExpression ireg(this->m_IncludeRegExp.c_str());
-  cmRegularExpression ereg(this->m_ExcludeRegExp.c_str());
+  cmsys::RegularExpression ereg(this->m_ExcludeRegExp.c_str());
-  cmRegularExpression dartStuff("([\t\n ]*<DartMeasurement.*/DartMeasurement[a-zA-Z]*>[\t ]*[\n]*)");
+  cmsys::RegularExpression dartStuff("([\t\n ]*<DartMeasurement.*/DartMeasurement[a-zA-Z]*>[\t ]*[\n]*)");
 
   bool parseError;
   while ( fin )

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

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

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

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]*$");
+    cmsys::RegularExpression blankLine("^[ \t\r]*$");
-    cmRegularExpression oneLiner("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)\\)[ \t\r]*$");
+    cmsys::RegularExpression oneLiner("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)\\)[ \t\r]*$");
-    cmRegularExpression multiLine("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)$");
+    cmsys::RegularExpression multiLine("^[ \t]*([A-Za-z_0-9]*)[ \t]*\\((.*)$");
-    cmRegularExpression lastLine("^(.*)\\)[ \t\r]*$");
+    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)

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

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");
+  cmsys::RegularExpression isAframework("[ \t]*\\-framework");
-  cmRegularExpression isEnvironment("\\${");
+  cmsys::RegularExpression isEnvironment("\\${");
-  cmRegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
+  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");
+  cmsys::RegularExpression isAframework("[ \t]*\\-framework");
-  cmRegularExpression isEnvironment("\\${");
+  cmsys::RegularExpression isEnvironment("\\${");
-  cmRegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
+  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");
+  cmsys::RegularExpression isAframework("[ \t]*\\-framework");
-  cmRegularExpression isEnvironment("\\${");
+  cmsys::RegularExpression isEnvironment("\\${");
-  cmRegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
+  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");
+  cmsys::RegularExpression isAframework("[ \t]*\\-framework");
-  cmRegularExpression isEnvironment("\\${");
+  cmsys::RegularExpression isEnvironment("\\${");
-  cmRegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
+  cmsys::RegularExpression isUNIX("[ \t]*\\-l([^ \t]+)");
   const cmTarget::LinkLibraries& libs = l->GetLinkLibraries();
   cmTarget::LinkLibraries::const_iterator lib = libs.begin();
   for(; lib != libs.end(); ++lib)

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).*");
+      cmsys::RegularExpression libname("^lib([^/]*)(\\.so|\\.lib|\\.dll|\\.sl|\\.a|\\.dylib).*");
-      cmRegularExpression libname_noprefix("([^/]*)(\\.so|\\.lib|\\.dll|\\.sl|\\.a|\\.dylib).*");
+      cmsys::RegularExpression libname_noprefix("([^/]*)(\\.so|\\.lib|\\.dll|\\.sl|\\.a|\\.dylib).*");
       if(libname.find(file))
         {
         // Library had "lib" prefix.

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());

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

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;
+  cmsys::RegularExpression m_IncludeFileRegularExpression;
-  cmRegularExpression m_ComplainFileRegularExpression;
+  cmsys::RegularExpression m_ComplainFileRegularExpression;
   std::vector<std::string> m_IncludeDirectories;
   typedef std::map<cmStdString, cmDependInformation*> DependInformationMap;
   DependInformationMap m_DependInformationMap;

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());

Source/cmRegularExpression.h

@@ -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

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

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

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+"\".";

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

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

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

bootstrap

@@ -30,7 +30,6 @@ CMAKE_SOURCES="\
   cmDocumentation \
   cmGlobalGenerator \
   cmLocalGenerator \
-  cmRegularExpression \
   cmSourceFile \
   cmSystemTools \
   cmGlobalUnixMakefileGenerator \