From 38482b46d171bde2073fadab65118c5c9df29e0f Mon Sep 17 00:00:00 2001
From: Brad King <brad.king@kitware.com>
Date: Mon, 23 Jun 2003 14:10:12 -0400
Subject: [PATCH] ENH: Merged use of the kwsys RegularExpression class instead
of cmRegularExpression.
---
CMakeLists.txt | 1 +
Source/CMakeLists.txt | 2 -
Source/cmBuildNameCommand.cxx | 6 +-
Source/cmCTest.cxx | 25 +-
Source/cmCacheManager.cxx | 7 +-
Source/cmConfigureFileCommand.cxx | 4 +-
Source/cmIfCommand.cxx | 4 +-
Source/cmListFileCache.cxx | 15 +-
Source/cmLoadCacheCommand.cxx | 5 +-
Source/cmLocalCodeWarriorGenerator.cxx | 28 +-
Source/cmLocalUnixMakefileGenerator.cxx | 10 +-
Source/cmLocalVisualStudio6Generator.cxx | 4 +-
Source/cmMakeDepend.cxx | 3 +-
Source/cmMakeDepend.h | 7 +-
Source/cmMakefile.cxx | 11 +-
Source/cmRegularExpression.cxx | 1207 ----------------------
Source/cmRegularExpression.h | 378 -------
Source/cmSiteNameCommand.cxx | 6 +-
Source/cmSourceGroup.h | 5 +-
Source/cmStringCommand.cxx | 8 +-
Source/cmSystemTools.cxx | 10 +-
Source/cmUseMangledMesaCommand.cxx | 8 +-
Source/cmaketest.cxx | 2 +-
bootstrap | 1 -
24 files changed, 99 insertions(+), 1658 deletions(-)
delete mode 100644 Source/cmRegularExpression.cxx
delete mode 100644 Source/cmRegularExpression.h
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 63f67bd989..3a51bcf579 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 c517353afe..de3d7f777c 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 cec21a0a80..a650fad2e5 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 56baccbcde..17cd1c260c 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 43027e9b2f..8d30fd0240 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 e43fc15d3e..d2a6443239 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 119acc609e..cf925df676 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 7d47514211..a22c60f03b 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 ef3fe26209..2abe6d0a08 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 08bc812ba9..ef5ee307d5 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 e5227657e6..8a16544589 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 f6eeb507a5..c76a62960d 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 2d13cf918f..e8812e7204 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 bc489fc39a..d9045a58da 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 49a7fb8aad..c271ccc3df 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 35759c4abc..0000000000
--- 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; ®dummy = 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 = ®dummy;
- 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 == ®dummy) {
- 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 != ®dummy)
- *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 == ®dummy) {
- 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 == ®dummy)
- 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 == ®dummy || 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 == ®dummy)
- 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 == ®dummy)
- 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 646deeaf3b..0000000000
--- 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 b733eb83c7..a3bf7428d1 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 0dbd8cc3f3..3158041fa9 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 e8d6bc14f3..1e1359230d 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 38c8648a75..a4cc6eba5c 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 3e6e2e0a2a..d780dfff89 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 66b9ed178e..aca0f93d19 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 8165ffa3e4..3426273052 100755
--- a/bootstrap
+++ b/bootstrap
@@ -30,7 +30,6 @@ CMAKE_SOURCES="\
cmDocumentation \
cmGlobalGenerator \
cmLocalGenerator \
- cmRegularExpression \
cmSourceFile \
cmSystemTools \
cmGlobalUnixMakefileGenerator \
--
GitLab