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