diff options
60 files changed, 561 insertions, 483 deletions
diff --git a/Help/generator/Ninja.rst b/Help/generator/Ninja.rst index 08f74fb..920abcb 100644 --- a/Help/generator/Ninja.rst +++ b/Help/generator/Ninja.rst @@ -1,7 +1,7 @@ Ninja ----- -Generates build.ninja files (experimental). +Generates build.ninja files. A build.ninja file is generated into the build tree. Recent versions of the ninja program can build the project through the "all" target. diff --git a/Help/generator/Visual Studio 6.rst b/Help/generator/Visual Studio 6.rst index d619354..855589c 100644 --- a/Help/generator/Visual Studio 6.rst +++ b/Help/generator/Visual Studio 6.rst @@ -1,4 +1,10 @@ Visual Studio 6 --------------- -Generates Visual Studio 6 project files. +Deprected. Generates Visual Studio 6 project files. + +.. note:: + This generator is deprecated and will be removed + in a future version of CMake. It will still be + possible to build with VS 6 tools using the + :generator:`NMake Makefiles` generator. diff --git a/Help/generator/Visual Studio 7.rst b/Help/generator/Visual Studio 7.rst index d0eb719..eb426f4 100644 --- a/Help/generator/Visual Studio 7.rst +++ b/Help/generator/Visual Studio 7.rst @@ -1,4 +1,10 @@ Visual Studio 7 --------------- -Generates Visual Studio .NET 2002 project files. +Deprected. Generates Visual Studio .NET 2002 project files. + +.. note:: + This generator is deprecated and will be removed + in a future version of CMake. It will still be + possible to build with VS 7.0 tools using the + :generator:`NMake Makefiles` generator. diff --git a/Help/manual/ctest.1.rst b/Help/manual/ctest.1.rst index dd3bcfb..584786f 100644 --- a/Help/manual/ctest.1.rst +++ b/Help/manual/ctest.1.rst @@ -573,7 +573,7 @@ Configuration settings to specify the version control tool include: * :module:`CTest` module variable: ``GITCOMMAND`` ``GITUpdateCustom`` - Specify a semicolon-separated list of custom command lines to run + Specify a custom command line (as a semicolon-separated list) to run in the source tree (Git work tree) to update it instead of running the ``GITCommand``. @@ -617,7 +617,7 @@ Configuration settings to specify the version control tool include: * :module:`CTest` module variable: ``CTEST_P4_OPTIONS`` ``P4UpdateCustom`` - Specify a semicolon-separated list of custom command lines to run + Specify a custom command line (as a semicolon-separated list) to run in the source tree (Perforce tree) to update it instead of running the ``P4Command``. diff --git a/Help/release/dev/vs10-no-macros.rst b/Help/release/dev/vs10-no-macros.rst new file mode 100644 index 0000000..89377dc --- /dev/null +++ b/Help/release/dev/vs10-no-macros.rst @@ -0,0 +1,9 @@ +vs10-no-macros +-------------- + +* The :generator:`Visual Studio 10 2010` generator no longer checks + for running VS IDEs with the project open or asks them to reload. + This was originally done for VS 10 because it had been done for + VS 7 through 9 to avoid prompting for every project in a solution. + Since VS >= 10 allow the whole solution to reload at once they + do not need CMake to help them. diff --git a/Help/release/dev/vs6-deprecate.rst b/Help/release/dev/vs6-deprecate.rst new file mode 100644 index 0000000..83f9afb --- /dev/null +++ b/Help/release/dev/vs6-deprecate.rst @@ -0,0 +1,5 @@ +vs6-deprecate +------------- + +* The :generator:`Visual Studio 6` generator is now deprecated + and will be removed in a future version of CMake. diff --git a/Help/release/dev/vs70-deprecate.rst b/Help/release/dev/vs70-deprecate.rst new file mode 100644 index 0000000..fb94110 --- /dev/null +++ b/Help/release/dev/vs70-deprecate.rst @@ -0,0 +1,5 @@ +vs70-deprecate +-------------- + +* The :generator:`Visual Studio 7` generator (.NET 2002) is now + deprecated and will be removed in a future version of CMake. diff --git a/Modules/UseSWIG.cmake b/Modules/UseSWIG.cmake index 7423418..1862876 100644 --- a/Modules/UseSWIG.cmake +++ b/Modules/UseSWIG.cmake @@ -156,7 +156,7 @@ macro(SWIG_ADD_SOURCE_TO_MODULE name outfiles infile) SWIG_GET_EXTRA_OUTPUT_FILES(${SWIG_MODULE_${name}_LANGUAGE} swig_extra_generated_files "${swig_outdir}" - "${infile}") + "${swig_source_file_fullname}") set(swig_generated_file_fullname "${swig_outdir}/${swig_source_file_name_we}") # add the language into the name of the file (i.e. TCL_wrap) diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake index 84e2e49..85c6992 100644 --- a/Source/CMakeVersion.cmake +++ b/Source/CMakeVersion.cmake @@ -1,5 +1,5 @@ # CMake version number components. set(CMake_VERSION_MAJOR 3) set(CMake_VERSION_MINOR 2) -set(CMake_VERSION_PATCH 20150414) +set(CMake_VERSION_PATCH 20150417) #set(CMake_VERSION_RC 1) diff --git a/Source/CPack/cpack.cxx b/Source/CPack/cpack.cxx index 00b23cd..a9cabf1 100644 --- a/Source/CPack/cpack.cxx +++ b/Source/CPack/cpack.cxx @@ -198,7 +198,7 @@ int main (int argc, char const* const* argv) "Read CPack config file: " << cpackConfigFile << std::endl); cmake cminst; - cminst.RemoveUnscriptableCommands(); + cminst.GetState()->RemoveUnscriptableCommands(); cmGlobalGenerator cmgg; cmgg.SetCMakeInstance(&cminst); cmsys::auto_ptr<cmLocalGenerator> cmlg(cmgg.CreateLocalGenerator()); diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx index 3792953..783941b 100644 --- a/Source/CTest/cmCTestScriptHandler.cxx +++ b/Source/CTest/cmCTestScriptHandler.cxx @@ -214,7 +214,7 @@ void cmCTestScriptHandler::AddCTestCommand(cmCTestCommand* command) cmCTestCommand* newCom = command; newCom->CTest = this->CTest; newCom->CTestScriptHandler = this; - this->CMake->AddCommand(newCom); + this->CMake->GetState()->AddCommand(newCom); } int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg) @@ -353,7 +353,7 @@ void cmCTestScriptHandler::CreateCMake() // remove all cmake commands which are not scriptable, since they can't be // used in ctest scripts - this->CMake->RemoveUnscriptableCommands(); + this->CMake->GetState()->RemoveUnscriptableCommands(); // add any ctest specific commands, probably should have common superclass // for ctest commands to clean this up. If a couple more commands are diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx index d585863..1e12f15 100644 --- a/Source/CTest/cmCTestSubmitHandler.cxx +++ b/Source/CTest/cmCTestSubmitHandler.cxx @@ -17,6 +17,7 @@ #include "cmGeneratedFileStream.h" #include "cmCTest.h" #include "cmXMLParser.h" +#include "cmState.h" #include <cmsys/Process.h> #include <cmsys/Base64.h> @@ -1132,7 +1133,7 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file, cmCTestScriptHandler* ch = static_cast<cmCTestScriptHandler*>(this->CTest->GetHandler("script")); cmake* cm = ch->GetCMake(); - const char* subproject = cm->GetProperty("SubProject", cmProperty::GLOBAL); + const char* subproject = cm->GetState()->GetGlobalProperty("SubProject"); // TODO: Encode values for a URL instead of trusting caller. std::ostringstream str; str << "project=" diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index 0e84fbf..c50ea88 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -1585,25 +1585,25 @@ void cmCTestTestHandler::GetListOfTests() // Add handler for ADD_TEST cmCTestAddTestCommand* newCom1 = new cmCTestAddTestCommand; newCom1->TestHandler = this; - cm.AddCommand(newCom1); + cm.GetState()->AddCommand(newCom1); // Add handler for SUBDIRS cmCTestSubdirCommand* newCom2 = new cmCTestSubdirCommand; newCom2->TestHandler = this; - cm.AddCommand(newCom2); + cm.GetState()->AddCommand(newCom2); // Add handler for ADD_SUBDIRECTORY cmCTestAddSubdirectoryCommand* newCom3 = new cmCTestAddSubdirectoryCommand; newCom3->TestHandler = this; - cm.AddCommand(newCom3); + cm.GetState()->AddCommand(newCom3); // Add handler for SET_SOURCE_FILES_PROPERTIES cmCTestSetTestsPropertiesCommand* newCom4 = new cmCTestSetTestsPropertiesCommand; newCom4->TestHandler = this; - cm.AddCommand(newCom4); + cm.GetState()->AddCommand(newCom4); const char* testFilename; if( cmSystemTools::FileExists("CTestTestfile.cmake") ) diff --git a/Source/cmAddLibraryCommand.cxx b/Source/cmAddLibraryCommand.cxx index edf82bd..74e1a93 100644 --- a/Source/cmAddLibraryCommand.cxx +++ b/Source/cmAddLibraryCommand.cxx @@ -12,6 +12,7 @@ #include "cmAddLibraryCommand.h" #include "cmake.h" +#include "cmState.h" // cmLibraryCommand bool cmAddLibraryCommand @@ -330,7 +331,7 @@ bool cmAddLibraryCommand yet its linker language. */ if ((type == cmTarget::SHARED_LIBRARY || type == cmTarget::MODULE_LIBRARY) && - (this->Makefile->GetCMakeInstance()->GetPropertyAsBool( + (this->Makefile->GetState()->GetGlobalPropertyAsBool( "TARGET_SUPPORTS_SHARED_LIBS") == false)) { std::ostringstream w; diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx index 5ae7d4c..77cd6c6 100644 --- a/Source/cmCPluginAPI.cxx +++ b/Source/cmCPluginAPI.cxx @@ -164,7 +164,7 @@ int CCONV cmIsOn(void *arg, const char* name) int CCONV cmCommandExists(void *arg, const char* name) { cmMakefile *mf = static_cast<cmMakefile *>(arg); - return static_cast<int>(mf->CommandExists(name)); + return static_cast<int>(mf->GetState()->GetCommand(name) ? 1 : 0); } void CCONV cmAddDefineFlag(void *arg, const char* definition) @@ -867,7 +867,7 @@ void CCONV DefineSourceFileProperty (void *arg, const char *name, int chained) { cmMakefile *mf = static_cast<cmMakefile *>(arg); - mf->GetCMakeInstance()->DefineProperty(name,cmProperty::SOURCE_FILE, + mf->GetState()->DefineProperty(name,cmProperty::SOURCE_FILE, briefDocs, longDocs, chained != 0); } diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx index 6715638..cd2cd7c 100644 --- a/Source/cmCTest.cxx +++ b/Source/cmCTest.cxx @@ -27,6 +27,7 @@ #include "cmCTestCommand.h" #include "cmCTestStartCommand.h" #include "cmAlgorithms.h" +#include "cmState.h" #include "cmCTestBuildHandler.h" #include "cmCTestBuildAndTestHandler.h" @@ -1558,12 +1559,14 @@ void cmCTest::AddSiteProperties(std::ostream& ostr) return; } // This code should go when cdash is changed to use labels only - const char* subproject = cm->GetProperty("SubProject", cmProperty::GLOBAL); + const char* subproject = cm->GetState() + ->GetGlobalProperty("SubProject"); if(subproject) { ostr << "<Subproject name=\"" << subproject << "\">\n"; const char* labels = - ch->GetCMake()->GetProperty("SubProjectLabels", cmProperty::GLOBAL); + ch->GetCMake()->GetState() + ->GetGlobalProperty("SubProjectLabels"); if(labels) { ostr << " <Labels>\n"; @@ -1581,7 +1584,7 @@ void cmCTest::AddSiteProperties(std::ostream& ostr) } // This code should stay when cdash only does label based sub-projects - const char* label = cm->GetProperty("Label", cmProperty::GLOBAL); + const char* label = cm->GetState()->GetGlobalProperty("Label"); if(label) { ostr << "<Labels>\n"; diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx index 8880667..83d38ef 100644 --- a/Source/cmComputeLinkInformation.cxx +++ b/Source/cmComputeLinkInformation.cxx @@ -15,6 +15,7 @@ #include "cmOrderDirectories.h" #include "cmGlobalGenerator.h" +#include "cmState.h" #include "cmLocalGenerator.h" #include "cmMakefile.h" #include "cmTarget.h" @@ -250,8 +251,8 @@ cmComputeLinkInformation this->CMakeInstance = this->GlobalGenerator->GetCMakeInstance(); // Check whether to recognize OpenBSD-style library versioned names. - this->OpenBSD = this->Makefile->GetCMakeInstance() - ->GetPropertyAsBool("FIND_LIBRARY_USE_OPENBSD_VERSIONING"); + this->OpenBSD = this->Makefile->GetState() + ->GetGlobalPropertyAsBool("FIND_LIBRARY_USE_OPENBSD_VERSIONING"); // The configuration being linked. this->Config = config; @@ -796,9 +797,8 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, void cmComputeLinkInformation::ComputeLinkTypeInfo() { // Check whether archives may actually be shared libraries. - this->ArchivesMayBeShared = - this->CMakeInstance->GetPropertyAsBool( - "TARGET_ARCHIVES_MAY_BE_SHARED_LIBS"); + this->ArchivesMayBeShared = this->CMakeInstance->GetState() + ->GetGlobalPropertyAsBool("TARGET_ARCHIVES_MAY_BE_SHARED_LIBS"); // First assume we cannot do link type stuff. this->LinkTypeEnabled = false; @@ -1527,9 +1527,10 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item, // Print the warning at most once for this item. std::string wid = "CMP0008-WARNING-GIVEN-"; wid += item; - if(!this->CMakeInstance->GetPropertyAsBool(wid)) + if(!this->CMakeInstance->GetState() + ->GetGlobalPropertyAsBool(wid)) { - this->CMakeInstance->SetProperty(wid, "1"); + this->CMakeInstance->GetState()->SetGlobalProperty(wid, "1"); std::ostringstream w; w << (this->Makefile->GetPolicies() ->GetPolicyWarning(cmPolicies::CMP0008)) << "\n" @@ -1576,9 +1577,11 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories() switch(this->Target->GetPolicyStatusCMP0003()) { case cmPolicies::WARN: - if(!this->CMakeInstance->GetPropertyAsBool("CMP0003-WARNING-GIVEN")) + if(!this->CMakeInstance->GetState() + ->GetGlobalPropertyAsBool("CMP0003-WARNING-GIVEN")) { - this->CMakeInstance->SetProperty("CMP0003-WARNING-GIVEN", "1"); + this->CMakeInstance->GetState() + ->SetGlobalProperty("CMP0003-WARNING-GIVEN", "1"); std::ostringstream w; this->PrintLinkPolicyDiagnosis(w); this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(), diff --git a/Source/cmComputeTargetDepends.cxx b/Source/cmComputeTargetDepends.cxx index bbffd5d..11056cd 100644 --- a/Source/cmComputeTargetDepends.cxx +++ b/Source/cmComputeTargetDepends.cxx @@ -15,6 +15,7 @@ #include "cmGlobalGenerator.h" #include "cmLocalGenerator.h" #include "cmMakefile.h" +#include "cmState.h" #include "cmSystemTools.h" #include "cmSourceFile.h" #include "cmTarget.h" @@ -98,8 +99,10 @@ cmComputeTargetDepends::cmComputeTargetDepends(cmGlobalGenerator* gg) { this->GlobalGenerator = gg; cmake* cm = this->GlobalGenerator->GetCMakeInstance(); - this->DebugMode = cm->GetPropertyAsBool("GLOBAL_DEPENDS_DEBUG_MODE"); - this->NoCycles = cm->GetPropertyAsBool("GLOBAL_DEPENDS_NO_CYCLES"); + this->DebugMode = cm->GetState() + ->GetGlobalPropertyAsBool("GLOBAL_DEPENDS_DEBUG_MODE"); + this->NoCycles = cm->GetState() + ->GetGlobalPropertyAsBool("GLOBAL_DEPENDS_NO_CYCLES"); } //---------------------------------------------------------------------------- diff --git a/Source/cmConditionEvaluator.cxx b/Source/cmConditionEvaluator.cxx index eb4f3a1..0a71c60 100644 --- a/Source/cmConditionEvaluator.cxx +++ b/Source/cmConditionEvaluator.cxx @@ -481,8 +481,10 @@ bool cmConditionEvaluator::HandleLevel1(cmArgumentList &newArgs, // does a command exist if (this->IsKeyword("COMMAND", *arg) && argP1 != newArgs.end()) { + cmCommand* command = + this->Makefile.GetState()->GetCommand(argP1->c_str()); this->HandlePredicate( - this->Makefile.CommandExists(argP1->c_str()), + command ? true : false, reducible, arg, newArgs, argP1, argP2); } // does a policy exist diff --git a/Source/cmDefinePropertyCommand.cxx b/Source/cmDefinePropertyCommand.cxx index 5ff0186..0efc7fc 100644 --- a/Source/cmDefinePropertyCommand.cxx +++ b/Source/cmDefinePropertyCommand.cxx @@ -11,6 +11,7 @@ ============================================================================*/ #include "cmDefinePropertyCommand.h" #include "cmake.h" +#include "cmState.h" bool cmDefinePropertyCommand ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &) @@ -127,7 +128,7 @@ bool cmDefinePropertyCommand } // Actually define the property. - this->Makefile->GetCMakeInstance()->DefineProperty + this->Makefile->GetState()->DefineProperty (this->PropertyName, scope, this->BriefDocs.c_str(), this->FullDocs.c_str(), inherited); diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx index 35b70e8..2aa4d93 100644 --- a/Source/cmExtraEclipseCDT4Generator.cxx +++ b/Source/cmExtraEclipseCDT4Generator.cxx @@ -469,8 +469,8 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile() fout << "\t\t<nature>" << *nit << "</nature>\n"; } - if (const char *extraNaturesProp = mf->GetCMakeInstance()-> - GetProperty("ECLIPSE_EXTRA_NATURES", cmProperty::GLOBAL)) + if (const char *extraNaturesProp = mf->GetState() + ->GetGlobalProperty("ECLIPSE_EXTRA_NATURES")) { std::vector<std::string> extraNatures; cmSystemTools::ExpandListArgument(extraNaturesProp, extraNatures); diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx index ef8340b..507d011 100644 --- a/Source/cmFindLibraryCommand.cxx +++ b/Source/cmFindLibraryCommand.cxx @@ -54,8 +54,8 @@ bool cmFindLibraryCommand } } - if(this->Makefile->GetCMakeInstance() - ->GetPropertyAsBool("FIND_LIBRARY_USE_LIB64_PATHS")) + if(this->Makefile->GetState() + ->GetGlobalPropertyAsBool("FIND_LIBRARY_USE_LIB64_PATHS")) { // add special 64 bit paths if this is a 64 bit compile. if(this->Makefile->PlatformIs64Bit()) @@ -226,8 +226,8 @@ cmFindLibraryHelper::cmFindLibraryHelper(cmMakefile* mf): // Check whether to use OpenBSD-style library version comparisons. this->OpenBSD = - this->Makefile->GetCMakeInstance() - ->GetPropertyAsBool("FIND_LIBRARY_USE_OPENBSD_VERSIONING"); + this->Makefile->GetState() + ->GetGlobalPropertyAsBool("FIND_LIBRARY_USE_OPENBSD_VERSIONING"); } //---------------------------------------------------------------------------- diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx index b32f5fd..e1074b0 100644 --- a/Source/cmFindPackageCommand.cxx +++ b/Source/cmFindPackageCommand.cxx @@ -120,8 +120,8 @@ bool cmFindPackageCommand // Lookup whether lib64 paths should be used. if(this->Makefile->PlatformIs64Bit() && - this->Makefile->GetCMakeInstance() - ->GetPropertyAsBool("FIND_LIBRARY_USE_LIB64_PATHS")) + this->Makefile->GetState() + ->GetGlobalPropertyAsBool("FIND_LIBRARY_USE_LIB64_PATHS")) { this->UseLib64Paths = true; } @@ -1015,8 +1015,8 @@ bool cmFindPackageCommand::ReadListFile(const char* f, PolicyScopeRule psr) void cmFindPackageCommand::AppendToFoundProperty(bool found) { std::vector<std::string> foundContents; - const char *foundProp = - this->Makefile->GetCMakeInstance()->GetProperty("PACKAGES_FOUND"); + const char *foundProp = this->Makefile->GetState() + ->GetGlobalProperty("PACKAGES_FOUND"); if (foundProp && *foundProp) { std::string tmp = foundProp; @@ -1032,7 +1032,8 @@ void cmFindPackageCommand::AppendToFoundProperty(bool found) std::vector<std::string> notFoundContents; const char *notFoundProp = - this->Makefile->GetCMakeInstance()->GetProperty("PACKAGES_NOT_FOUND"); + this->Makefile->GetState() + ->GetGlobalProperty("PACKAGES_NOT_FOUND"); if (notFoundProp && *notFoundProp) { std::string tmp = notFoundProp; @@ -1057,12 +1058,12 @@ void cmFindPackageCommand::AppendToFoundProperty(bool found) std::string tmp = cmJoin(foundContents, ";"); - this->Makefile->GetCMakeInstance()->SetProperty("PACKAGES_FOUND", - tmp.c_str()); + this->Makefile->GetState() + ->SetGlobalProperty("PACKAGES_FOUND", tmp.c_str()); tmp = cmJoin(notFoundContents, ";"); - this->Makefile->GetCMakeInstance()->SetProperty("PACKAGES_NOT_FOUND", - tmp.c_str()); + this->Makefile->GetState() + ->SetGlobalProperty("PACKAGES_NOT_FOUND", tmp.c_str()); } //---------------------------------------------------------------------------- @@ -1071,8 +1072,8 @@ void cmFindPackageCommand::AppendSuccessInformation() { std::string transitivePropName = "_CMAKE_"; transitivePropName += this->Name + "_TRANSITIVE_DEPENDENCY"; - this->Makefile->GetCMakeInstance() - ->SetProperty(transitivePropName, "False"); + this->Makefile->GetState() + ->SetGlobalProperty(transitivePropName, "False"); } std::string found = this->Name; found += "_FOUND"; @@ -1090,8 +1091,8 @@ void cmFindPackageCommand::AppendSuccessInformation() std::string quietInfoPropName = "_CMAKE_"; quietInfoPropName += this->Name; quietInfoPropName += "_QUIET"; - this->Makefile->GetCMakeInstance()->SetProperty(quietInfoPropName, - this->Quiet ? "TRUE" : "FALSE"); + this->Makefile->GetState() + ->SetGlobalProperty(quietInfoPropName, this->Quiet ? "TRUE" : "FALSE"); // set a global property to record the required version of this package std::string versionInfoPropName = "_CMAKE_"; @@ -1104,15 +1105,15 @@ void cmFindPackageCommand::AppendSuccessInformation() versionInfo += " "; versionInfo += this->Version; } - this->Makefile->GetCMakeInstance()->SetProperty(versionInfoPropName, - versionInfo.c_str()); + this->Makefile->GetState() + ->SetGlobalProperty(versionInfoPropName, versionInfo.c_str()); if (this->Required) { std::string requiredInfoPropName = "_CMAKE_"; requiredInfoPropName += this->Name; requiredInfoPropName += "_TYPE"; - this->Makefile->GetCMakeInstance()->SetProperty( - requiredInfoPropName, "REQUIRED"); + this->Makefile->GetState() + ->SetGlobalProperty(requiredInfoPropName, "REQUIRED"); } diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx index 9297688..fdd1018 100644 --- a/Source/cmFunctionCommand.cxx +++ b/Source/cmFunctionCommand.cxx @@ -193,9 +193,8 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf, } std::string newName = "_" + this->Args[0]; - mf.GetCMakeInstance()->RenameCommand(this->Args[0], - newName); - mf.AddCommand(f); + mf.GetState()->RenameCommand(this->Args[0], newName); + mf.GetState()->AddCommand(f); // remove the function blocker now that the function is defined mf.RemoveFunctionBlocker(this, lff); diff --git a/Source/cmGetCMakePropertyCommand.cxx b/Source/cmGetCMakePropertyCommand.cxx index 85aa31f..b035750 100644 --- a/Source/cmGetCMakePropertyCommand.cxx +++ b/Source/cmGetCMakePropertyCommand.cxx @@ -14,6 +14,7 @@ #include "cmGlobalGenerator.h" #include "cmLocalGenerator.h" #include "cmake.h" +#include "cmState.h" #include "cmAlgorithms.h" // cmGetCMakePropertyCommand @@ -53,7 +54,8 @@ bool cmGetCMakePropertyCommand else { const char *prop = - this->Makefile->GetCMakeInstance()->GetProperty(args[1]); + this->Makefile->GetState() + ->GetGlobalProperty(args[1]); if (prop) { output = prop; diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx index 80edbcd..3e1d08e 100644 --- a/Source/cmGetPropertyCommand.cxx +++ b/Source/cmGetPropertyCommand.cxx @@ -143,7 +143,7 @@ bool cmGetPropertyCommand // Lookup brief documentation. std::string output; if(cmPropertyDefinition* def = - this->Makefile->GetCMakeInstance()-> + this->Makefile->GetState()-> GetPropertyDefinition(this->PropertyName, scope)) { output = def->GetShortDescription(); @@ -159,7 +159,7 @@ bool cmGetPropertyCommand // Lookup full documentation. std::string output; if(cmPropertyDefinition* def = - this->Makefile->GetCMakeInstance()-> + this->Makefile->GetState()-> GetPropertyDefinition(this->PropertyName, scope)) { output = def->GetFullDescription(); @@ -173,7 +173,7 @@ bool cmGetPropertyCommand else if(this->InfoType == OutDefined) { // Lookup if the property is defined - if(this->Makefile->GetCMakeInstance()-> + if(this->Makefile->GetState()-> GetPropertyDefinition(this->PropertyName, scope)) { this->Makefile->AddDefinition(this->Variable, "1"); @@ -237,7 +237,8 @@ bool cmGetPropertyCommand::HandleGlobalMode() // Get the property. cmake* cm = this->Makefile->GetCMakeInstance(); - return this->StoreResult(cm->GetProperty(this->PropertyName)); + return this->StoreResult(cm->GetState() + ->GetGlobalProperty(this->PropertyName)); } //---------------------------------------------------------------------------- diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index 171d62a..ab044c1 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -200,7 +200,7 @@ void cmGlobalGenerator::ResolveLanguageCompiler(const std::string &lang, if (cnameString != pathString) { const char* cvars = - this->GetCMakeInstance()->GetProperty( + this->GetCMakeInstance()->GetState()->GetGlobalProperty( "__CMAKE_DELETE_CACHE_CHANGE_VARS_"); if(cvars) { @@ -210,7 +210,7 @@ void cmGlobalGenerator::ResolveLanguageCompiler(const std::string &lang, changeVars += langComp; changeVars += ";"; changeVars += cname; - this->GetCMakeInstance()->SetProperty( + this->GetCMakeInstance()->GetState()->SetGlobalProperty( "__CMAKE_DELETE_CACHE_CHANGE_VARS_", changeVars.c_str()); } @@ -969,13 +969,7 @@ void cmGlobalGenerator::SetLanguageEnabled(const std::string& l, void cmGlobalGenerator::SetLanguageEnabledFlag(const std::string& l, cmMakefile* mf) { - std::vector<std::string>::iterator it = - std::lower_bound(this->LanguageEnabled.begin(), - this->LanguageEnabled.end(), l); - if (it == this->LanguageEnabled.end() || *it != l) - { - this->LanguageEnabled.insert(it, l); - } + this->CMakeInstance->GetState()->SetLanguageEnabled(l); // Fill the language-to-extension map with the current variable // settings to make sure it is available for the try_compile() @@ -1086,13 +1080,12 @@ bool cmGlobalGenerator::IgnoreFile(const char* ext) const bool cmGlobalGenerator::GetLanguageEnabled(const std::string& l) const { - return std::binary_search(this->LanguageEnabled.begin(), - this->LanguageEnabled.end(), l); + return this->CMakeInstance->GetState()->GetLanguageEnabled(l); } void cmGlobalGenerator::ClearEnabledLanguages() { - this->LanguageEnabled.clear(); + return this->CMakeInstance->GetState()->ClearEnabledLanguages(); } void cmGlobalGenerator::Configure() @@ -1177,8 +1170,8 @@ void cmGlobalGenerator::AddCMP0042WarnTarget(const std::string& target) bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const { // If the property is not enabled then okay. - if(!this->CMakeInstance - ->GetPropertyAsBool("ALLOW_DUPLICATE_CUSTOM_TARGETS")) + if(!this->CMakeInstance->GetState() + ->GetGlobalPropertyAsBool("ALLOW_DUPLICATE_CUSTOM_TARGETS")) { return true; } @@ -1966,7 +1959,7 @@ bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root, void cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang) const { - lang = this->LanguageEnabled; + lang = this->CMakeInstance->GetState()->GetEnabledLanguages(); } int cmGlobalGenerator::GetLinkerPreference(const std::string& lang) const @@ -2398,8 +2391,8 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets) //---------------------------------------------------------------------------- const char* cmGlobalGenerator::GetPredefinedTargetsFolder() { - const char* prop = - this->GetCMakeInstance()->GetProperty("PREDEFINED_TARGETS_FOLDER"); + const char* prop = this->GetCMakeInstance()->GetState() + ->GetGlobalProperty("PREDEFINED_TARGETS_FOLDER"); if (prop) { @@ -2412,7 +2405,8 @@ const char* cmGlobalGenerator::GetPredefinedTargetsFolder() //---------------------------------------------------------------------------- bool cmGlobalGenerator::UseFolderProperty() { - const char* prop = this->GetCMakeInstance()->GetProperty("USE_FOLDERS"); + const char* prop = this->GetCMakeInstance()->GetState() + ->GetGlobalProperty("USE_FOLDERS"); // If this property is defined, let the setter turn this on or off... // diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx index f74f1e0..9a00fa6 100644 --- a/Source/cmGlobalNinjaGenerator.cxx +++ b/Source/cmGlobalNinjaGenerator.cxx @@ -507,7 +507,7 @@ void cmGlobalNinjaGenerator ::GetDocumentation(cmDocumentationEntry& entry) { entry.Name = cmGlobalNinjaGenerator::GetActualName(); - entry.Brief = "Generates build.ninja files (experimental)."; + entry.Brief = "Generates build.ninja files."; } // Implemented in all cmGlobaleGenerator sub-classes. diff --git a/Source/cmGlobalVisualStudio10Generator.cxx b/Source/cmGlobalVisualStudio10Generator.cxx index 1c6ac88..231b679 100644 --- a/Source/cmGlobalVisualStudio10Generator.cxx +++ b/Source/cmGlobalVisualStudio10Generator.cxx @@ -371,39 +371,6 @@ const char* cmGlobalVisualStudio10Generator::GetPlatformToolset() const } //---------------------------------------------------------------------------- -std::string cmGlobalVisualStudio10Generator::GetUserMacrosDirectory() -{ - std::string base; - std::string path; - - // base begins with the VisualStudioProjectsLocation reg value... - if (cmSystemTools::ReadRegistryValue( - "HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\10.0;" - "VisualStudioProjectsLocation", - base)) - { - cmSystemTools::ConvertToUnixSlashes(base); - - // 9.0 macros folder: - path = base + "/VSMacros80"; - // *NOT* a typo; right now in Visual Studio 2008 beta the macros - // folder is VSMacros80... They may change it to 90 before final - // release of 2008 or they may not... we'll have to keep our eyes - // on it - } - - // path is (correctly) still empty if we did not read the base value from - // the Registry value - return path; -} - -//---------------------------------------------------------------------------- -std::string cmGlobalVisualStudio10Generator::GetUserMacrosRegKeyBase() -{ - return "Software\\Microsoft\\VisualStudio\\10.0\\vsmacros"; -} - -//---------------------------------------------------------------------------- void cmGlobalVisualStudio10Generator::FindMakeProgram(cmMakefile* mf) { this->cmGlobalVisualStudio8Generator::FindMakeProgram(mf); diff --git a/Source/cmGlobalVisualStudio10Generator.h b/Source/cmGlobalVisualStudio10Generator.h index 92202ba..f0dd7d7 100644 --- a/Source/cmGlobalVisualStudio10Generator.h +++ b/Source/cmGlobalVisualStudio10Generator.h @@ -84,18 +84,6 @@ public: bool TargetsWindowsStore() const { return this->SystemIsWindowsStore; } - /** - * Where does this version of Visual Studio look for macros for the - * current user? Returns the empty string if this version of Visual - * Studio does not implement support for VB macros. - */ - virtual std::string GetUserMacrosDirectory(); - - /** - * What is the reg key path to "vsmacros" for this version of Visual - * Studio? - */ - virtual std::string GetUserMacrosRegKeyBase(); virtual const char* GetCMakeCFGIntDir() const { return "$(Configuration)";} bool Find64BitTools(cmMakefile* mf); @@ -156,5 +144,8 @@ private: virtual std::string FindMSBuildCommand(); virtual std::string FindDevEnvCommand(); virtual std::string GetVSMakeProgram() { return this->GetMSBuildCommand(); } + + // We do not use the reload macros for VS >= 10. + virtual std::string GetUserMacrosDirectory() { return ""; } }; #endif diff --git a/Source/cmGlobalVisualStudio11Generator.h b/Source/cmGlobalVisualStudio11Generator.h index c79dc97..6d434eb 100644 --- a/Source/cmGlobalVisualStudio11Generator.h +++ b/Source/cmGlobalVisualStudio11Generator.h @@ -31,8 +31,6 @@ public: ///! create the correct local generator virtual cmLocalGenerator *CreateLocalGenerator(); - /** TODO: VS 11 user macro support. */ - virtual std::string GetUserMacrosDirectory() { return ""; } protected: virtual bool InitializeWindowsPhone(cmMakefile* mf); virtual bool InitializeWindowsStore(cmMakefile* mf); diff --git a/Source/cmGlobalVisualStudio12Generator.h b/Source/cmGlobalVisualStudio12Generator.h index a81516f..5e5b5f7 100644 --- a/Source/cmGlobalVisualStudio12Generator.h +++ b/Source/cmGlobalVisualStudio12Generator.h @@ -31,9 +31,6 @@ public: ///! create the correct local generator virtual cmLocalGenerator *CreateLocalGenerator(); - /** TODO: VS 12 user macro support. */ - virtual std::string GetUserMacrosDirectory() { return ""; } - //in Visual Studio 2013 they detached the MSBuild tools version //from the .Net Framework version and instead made it have it's own //version number diff --git a/Source/cmGlobalVisualStudio14Generator.h b/Source/cmGlobalVisualStudio14Generator.h index 3fd60a0..ad1a460 100644 --- a/Source/cmGlobalVisualStudio14Generator.h +++ b/Source/cmGlobalVisualStudio14Generator.h @@ -31,9 +31,6 @@ public: ///! create the correct local generator virtual cmLocalGenerator *CreateLocalGenerator(); - /** TODO: VS 14 user macro support. */ - virtual std::string GetUserMacrosDirectory() { return ""; } - virtual const char* GetToolsVersion() { return "14.0"; } protected: virtual const char* GetIDEVersion() { return "14.0"; } diff --git a/Source/cmGlobalVisualStudio6Generator.cxx b/Source/cmGlobalVisualStudio6Generator.cxx index 62a308e..e2b2bbd4 100644 --- a/Source/cmGlobalVisualStudio6Generator.cxx +++ b/Source/cmGlobalVisualStudio6Generator.cxx @@ -185,6 +185,22 @@ void cmGlobalVisualStudio6Generator::Generate() // Now write out the DSW this->OutputDSWFile(); + + if (!this->CMakeInstance->GetIsInTryCompile()) + { + const char* cmakeWarnVS6 = + this->CMakeInstance->GetState()->GetCacheEntryValue("CMAKE_WARN_VS6"); + if (!cmakeWarnVS6 || !cmSystemTools::IsOff(cmakeWarnVS6)) + { + this->CMakeInstance->IssueMessage( + cmake::WARNING, + "The \"Visual Studio 6\" generator is deprecated " + "and will be removed in a future version of CMake." + "\n" + "Add CMAKE_WARN_VS6=OFF to the cache to disable this warning." + ); + } + } } // Write a DSW file to the stream @@ -411,7 +427,7 @@ void cmGlobalVisualStudio6Generator ::GetDocumentation(cmDocumentationEntry& entry) { entry.Name = cmGlobalVisualStudio6Generator::GetActualName(); - entry.Brief = "Generates Visual Studio 6 project files."; + entry.Brief = "Deprecated. Generates Visual Studio 6 project files."; } //---------------------------------------------------------------------------- diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx index 6a3a145..0d7dfd7 100644 --- a/Source/cmGlobalVisualStudio7Generator.cxx +++ b/Source/cmGlobalVisualStudio7Generator.cxx @@ -351,6 +351,23 @@ void cmGlobalVisualStudio7Generator::Generate() { this->CallVisualStudioMacro(MacroReload); } + + if (!this->CMakeInstance->GetIsInTryCompile() && + this->GetName() == "Visual Studio 7") + { + const char* cmakeWarnVS70 = + this->CMakeInstance->GetState()->GetCacheEntryValue("CMAKE_WARN_VS70"); + if (!cmakeWarnVS70 || !cmSystemTools::IsOff(cmakeWarnVS70)) + { + this->CMakeInstance->IssueMessage( + cmake::WARNING, + "The \"Visual Studio 7\" generator is deprecated " + "and will be removed in a future version of CMake." + "\n" + "Add CMAKE_WARN_VS70=OFF to the cache to disable this warning." + ); + } + } } void cmGlobalVisualStudio7Generator @@ -983,7 +1000,7 @@ void cmGlobalVisualStudio7Generator ::GetDocumentation(cmDocumentationEntry& entry) { entry.Name = cmGlobalVisualStudio7Generator::GetActualName(); - entry.Brief = "Generates Visual Studio .NET 2002 project files."; + entry.Brief = "Deprecated. Generates Visual Studio .NET 2002 project files."; } //---------------------------------------------------------------------------- diff --git a/Source/cmGlobalVisualStudioGenerator.h b/Source/cmGlobalVisualStudioGenerator.h index 356f4d4..cb54132 100644 --- a/Source/cmGlobalVisualStudioGenerator.h +++ b/Source/cmGlobalVisualStudioGenerator.h @@ -51,8 +51,8 @@ public: * Call the ReloadProjects macro if necessary based on * GetFilesReplacedDuringGenerate results. */ - virtual void CallVisualStudioMacro(MacroName m, - const char* vsSolutionFile = 0); + void CallVisualStudioMacro(MacroName m, + const char* vsSolutionFile = 0); // return true if target is fortran only bool TargetIsFortranOnly(cmTarget const& t); diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx index cdfd00c..403f7fc 100644 --- a/Source/cmLoadCommandCommand.cxx +++ b/Source/cmLoadCommandCommand.cxx @@ -273,7 +273,7 @@ bool cmLoadCommandCommand // create a function blocker and set it up cmLoadedCommand *f = new cmLoadedCommand(); (*initFunction)(&f->info); - this->Makefile->AddCommand(f); + this->Makefile->GetState()->AddCommand(f); return true; } this->SetError("Attempt to load command failed. " diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx index 640c1b3..645d32a 100644 --- a/Source/cmLocalNinjaGenerator.cxx +++ b/Source/cmLocalNinjaGenerator.cxx @@ -18,6 +18,7 @@ #include "cmGeneratedFileStream.h" #include "cmSourceFile.h" #include "cmake.h" +#include "cmState.h" #include <assert.h> @@ -234,8 +235,8 @@ void cmLocalNinjaGenerator::WritePools(std::ostream& os) { cmGlobalNinjaGenerator::WriteDivider(os); - const char* jobpools = this->GetCMakeInstance() - ->GetProperty("JOB_POOLS", cmProperty::GLOBAL); + const char* jobpools = this->GetCMakeInstance()->GetState() + ->GetGlobalProperty("JOB_POOLS"); if (jobpools) { cmGlobalNinjaGenerator::WriteComment(os, diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx index b7cbae6..7ac4432 100644 --- a/Source/cmMacroCommand.cxx +++ b/Source/cmMacroCommand.cxx @@ -232,9 +232,8 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf, f->Functions = this->Functions; mf.RecordPolicies(f->Policies); std::string newName = "_" + this->Args[0]; - mf.GetCMakeInstance()->RenameCommand(this->Args[0], - newName); - mf.AddCommand(f); + mf.GetState()->RenameCommand(this->Args[0], newName); + mf.GetState()->AddCommand(f); // remove the function blocker now that the macro is defined mf.RemoveFunctionBlocker(this, lff); diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index ad3cce4..205508b 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -244,12 +244,6 @@ void cmMakefile::Print() const #endif } -bool cmMakefile::CommandExists(const char* name) const -{ - return this->GetCMakeInstance()->CommandExists(name); -} - - //---------------------------------------------------------------------------- void cmMakefile::IssueMessage(cmake::MessageType t, std::string const& text) const @@ -340,7 +334,7 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff, static_cast<void>(stack_manager); // Lookup the command prototype. - if(cmCommand* proto = this->GetCMakeInstance()->GetCommand(name)) + if(cmCommand* proto = this->GetState()->GetCommand(name)) { // Clone the prototype. cmsys::auto_ptr<cmCommand> pcmd(proto->Clone()); @@ -718,11 +712,6 @@ void cmMakefile::EnforceDirectoryLevelRules() const } } -void cmMakefile::AddCommand(cmCommand* wg) -{ - this->GetCMakeInstance()->AddCommand(wg); -} - // Set the make file void cmMakefile::SetLocalGenerator(cmLocalGenerator* lg) { @@ -4250,7 +4239,7 @@ const char *cmMakefile::GetProperty(const std::string& prop, return this->LocalGenerator->GetParent()->GetMakefile()-> GetProperty(prop, scope); } - return this->GetCMakeInstance()->GetProperty(prop,scope); + return this->GetState()->GetGlobalProperty(prop); } return retVal; @@ -4476,21 +4465,6 @@ void cmMakefile::RaiseScope(const std::string& var, const char *varDef) } } - -// define properties -void cmMakefile::DefineProperties(cmake *cm) -{ - cm->DefineProperty - ("RULE_LAUNCH_COMPILE", cmProperty::DIRECTORY, - "", "", true); - cm->DefineProperty - ("RULE_LAUNCH_LINK", cmProperty::DIRECTORY, - "", "", true); - cm->DefineProperty - ("RULE_LAUNCH_CUSTOM", cmProperty::DIRECTORY, - "", "", true); -} - //---------------------------------------------------------------------------- cmTarget* cmMakefile::AddImportedTarget(const std::string& name, @@ -4611,7 +4585,8 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg, this->LocalGenerator->GetGlobalGenerator()->GetCMakeInstance(); if(isCustom && existing->GetType() == cmTarget::UTILITY && this != existing->GetMakefile() && - cm->GetPropertyAsBool("ALLOW_DUPLICATE_CUSTOM_TARGETS")) + cm->GetState() + ->GetGlobalPropertyAsBool("ALLOW_DUPLICATE_CUSTOM_TARGETS")) { return true; } diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h index 57a4180..299d550 100644 --- a/Source/cmMakefile.h +++ b/Source/cmMakefile.h @@ -746,14 +746,6 @@ public: bool ExecuteCommand(const cmListFileFunction& lff, cmExecutionStatus &status); - /** Check if a command exists. */ - bool CommandExists(const char* name) const; - - /** - * Add a command to this cmake instance - */ - void AddCommand(cmCommand* ); - ///! Enable support for named language, if nil then all languages are ///enabled. void EnableLanguage(std::vector<std::string>const& languages, bool optional); @@ -851,9 +843,6 @@ public: const std::vector<cmTestGenerator*>& GetTestGenerators() const { return this->TestGenerators; } - // Define the properties - static void DefineProperties(cmake *cm); - // push and pop variable scopes void PushScope(); void PopScope(); diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index bd9c579..0076caf 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -20,6 +20,7 @@ #include "cmSourceFile.h" #include "cmTarget.h" #include "cmake.h" +#include "cmState.h" #include "cmComputeLinkInformation.h" #include "cmCustomCommandGenerator.h" #include "cmGeneratorExpression.h" @@ -51,7 +52,8 @@ cmMakefileTargetGenerator::cmMakefileTargetGenerator(cmTarget* target) this->GeneratorTarget = this->GlobalGenerator->GetGeneratorTarget(target); cmake* cm = this->GlobalGenerator->GetCMakeInstance(); this->NoRuleMessages = false; - if(const char* ruleStatus = cm->GetProperty("RULE_MESSAGES")) + if(const char* ruleStatus = cm->GetState() + ->GetGlobalProperty("RULE_MESSAGES")) { this->NoRuleMessages = cmSystemTools::IsOff(ruleStatus); } diff --git a/Source/cmPropertyMap.cxx b/Source/cmPropertyMap.cxx index e335b3b..070f6f1 100644 --- a/Source/cmPropertyMap.cxx +++ b/Source/cmPropertyMap.cxx @@ -12,6 +12,7 @@ #include "cmPropertyMap.h" #include "cmSystemTools.h" #include "cmake.h" +#include "cmState.h" cmProperty *cmPropertyMap::GetOrCreateProperty(const std::string& name) { @@ -73,7 +74,8 @@ const char *cmPropertyMap // should we chain up? if (this->CMakeInstance) { - chain = this->CMakeInstance->IsPropertyChained(name,scope); + chain = this->CMakeInstance->GetState()-> + IsPropertyChained(name,scope); } return 0; } diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx index 4cb49c8..4d0b3f4 100644 --- a/Source/cmQtAutoGenerators.cxx +++ b/Source/cmQtAutoGenerators.cxx @@ -16,6 +16,7 @@ #include "cmMakefile.h" #include "cmSourceFile.h" #include "cmSystemTools.h" +#include "cmState.h" #include "cmAlgorithms.h" #if defined(_WIN32) && !defined(__CYGWIN__) @@ -472,12 +473,12 @@ bool cmQtAutoGenerators::InitializeAutogenTarget(cmTarget* target) } // Set target folder - const char* autogenFolder = makefile->GetCMakeInstance()->GetProperty( - "AUTOMOC_TARGETS_FOLDER"); + const char* autogenFolder = makefile->GetState() + ->GetGlobalProperty("AUTOMOC_TARGETS_FOLDER"); if (!autogenFolder) { - autogenFolder = makefile->GetCMakeInstance()->GetProperty( - "AUTOGEN_TARGETS_FOLDER"); + autogenFolder = makefile->GetState() + ->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER"); } if (autogenFolder && *autogenFolder) { diff --git a/Source/cmState.cxx b/Source/cmState.cxx index 7602f63..96f8a51 100644 --- a/Source/cmState.cxx +++ b/Source/cmState.cxx @@ -13,10 +13,21 @@ #include "cmake.h" #include "cmCacheManager.h" +#include "cmCommand.h" +#include "cmAlgorithms.h" + +#include <assert.h> cmState::cmState(cmake* cm) - : CMakeInstance(cm) + : CMakeInstance(cm), + IsInTryCompile(false) +{ + this->Initialize(); +} + +cmState::~cmState() { + cmDeleteAll(this->Commands); } const char* cmCacheEntryTypes[] = @@ -178,3 +189,258 @@ void cmState::RemoveCacheEntryProperty(std::string const& key, this->CMakeInstance->GetCacheManager() ->GetCacheIterator(key.c_str()).SetProperty(propertyName, (void*)0); } + +void cmState::Initialize() +{ + this->GlobalProperties.clear(); + + this->PropertyDefinitions.clear(); + this->DefineProperty + ("RULE_LAUNCH_COMPILE", cmProperty::DIRECTORY, + "", "", true); + this->DefineProperty + ("RULE_LAUNCH_LINK", cmProperty::DIRECTORY, + "", "", true); + this->DefineProperty + ("RULE_LAUNCH_CUSTOM", cmProperty::DIRECTORY, + "", "", true); + + this->DefineProperty + ("RULE_LAUNCH_COMPILE", cmProperty::TARGET, + "", "", true); + this->DefineProperty + ("RULE_LAUNCH_LINK", cmProperty::TARGET, + "", "", true); + this->DefineProperty + ("RULE_LAUNCH_CUSTOM", cmProperty::TARGET, + "", "", true); +} + +void cmState::DefineProperty(const std::string& name, + cmProperty::ScopeType scope, + const char *ShortDescription, + const char *FullDescription, + bool chained) +{ + this->PropertyDefinitions[scope].DefineProperty(name,scope,ShortDescription, + FullDescription, + chained); +} + +cmPropertyDefinition *cmState +::GetPropertyDefinition(const std::string& name, + cmProperty::ScopeType scope) +{ + if (this->IsPropertyDefined(name,scope)) + { + return &(this->PropertyDefinitions[scope][name]); + } + return 0; +} + +bool cmState::IsPropertyDefined(const std::string& name, + cmProperty::ScopeType scope) +{ + return this->PropertyDefinitions[scope].IsPropertyDefined(name); +} + +bool cmState::IsPropertyChained(const std::string& name, + cmProperty::ScopeType scope) +{ + return this->PropertyDefinitions[scope].IsPropertyChained(name); +} + +void cmState::SetLanguageEnabled(std::string const& l) +{ + std::vector<std::string>::iterator it = + std::lower_bound(this->EnabledLanguages.begin(), + this->EnabledLanguages.end(), l); + if (it == this->EnabledLanguages.end() || *it != l) + { + this->EnabledLanguages.insert(it, l); + } +} + +bool cmState::GetLanguageEnabled(std::string const& l) const +{ + return std::binary_search(this->EnabledLanguages.begin(), + this->EnabledLanguages.end(), l); +} + +std::vector<std::string> cmState::GetEnabledLanguages() const +{ + return this->EnabledLanguages; +} + +void cmState::ClearEnabledLanguages() +{ + this->EnabledLanguages.clear(); +} + +bool cmState::GetIsInTryCompile() const +{ + return this->IsInTryCompile; +} + +void cmState::SetIsInTryCompile(bool b) +{ + this->IsInTryCompile = b; +} + +void cmState::RenameCommand(std::string const& oldName, + std::string const& newName) +{ + // if the command already exists, free the old one + std::string sOldName = cmSystemTools::LowerCase(oldName); + std::string sNewName = cmSystemTools::LowerCase(newName); + std::map<std::string, cmCommand*>::iterator pos = + this->Commands.find(sOldName); + if ( pos == this->Commands.end() ) + { + return; + } + cmCommand* cmd = pos->second; + + pos = this->Commands.find(sNewName); + if (pos != this->Commands.end()) + { + delete pos->second; + this->Commands.erase(pos); + } + this->Commands.insert(std::make_pair(sNewName, cmd)); + pos = this->Commands.find(sOldName); + this->Commands.erase(pos); +} + +void cmState::AddCommand(cmCommand* command) +{ + std::string name = cmSystemTools::LowerCase(command->GetName()); + // if the command already exists, free the old one + std::map<std::string, cmCommand*>::iterator pos = this->Commands.find(name); + if (pos != this->Commands.end()) + { + delete pos->second; + this->Commands.erase(pos); + } + this->Commands.insert(std::make_pair(name, command)); +} + +void cmState::RemoveUnscriptableCommands() +{ + std::vector<std::string> unscriptableCommands; + for (std::map<std::string, cmCommand*>::iterator + pos = this->Commands.begin(); + pos != this->Commands.end(); ) + { + if (!pos->second->IsScriptable()) + { + delete pos->second; + this->Commands.erase(pos++); + } + else + { + ++pos; + } + } +} + +cmCommand* cmState::GetCommand(std::string const& name) const +{ + cmCommand* command = 0; + std::string sName = cmSystemTools::LowerCase(name); + std::map<std::string, cmCommand*>::const_iterator pos = + this->Commands.find(sName); + if (pos != this->Commands.end()) + { + command = (*pos).second; + } + return command; +} + +std::vector<std::string> cmState::GetCommandNames() const +{ + std::vector<std::string> commandNames; + commandNames.reserve(this->Commands.size()); + std::map<std::string, cmCommand*>::const_iterator cmds + = this->Commands.begin(); + for ( ; cmds != this->Commands.end(); ++ cmds ) + { + commandNames.push_back(cmds->first); + } + return commandNames; +} + +void cmState::RemoveUserDefinedCommands() +{ + for(std::map<std::string, cmCommand*>::iterator j = this->Commands.begin(); + j != this->Commands.end(); ) + { + if (j->second->IsA("cmMacroHelperCommand") || + j->second->IsA("cmFunctionHelperCommand")) + { + delete j->second; + this->Commands.erase(j++); + } + else + { + ++j; + } + } +} + +void cmState::SetGlobalProperty(const std::string& prop, const char* value) +{ + this->GlobalProperties.SetProperty(prop, value, cmProperty::GLOBAL); +} + +void cmState::AppendGlobalProperty(const std::string& prop, + const char* value, bool asString) +{ + this->GlobalProperties.AppendProperty(prop, value, + cmProperty::GLOBAL, asString); +} + +const char *cmState::GetGlobalProperty(const std::string& prop) +{ + // watch for special properties + std::string output = ""; + if ( prop == "CACHE_VARIABLES" ) + { + std::vector<std::string> cacheKeys = this->GetCacheEntryKeys(); + this->SetGlobalProperty("CACHE_VARIABLES", cmJoin(cacheKeys, ";").c_str()); + } + else if ( prop == "COMMANDS" ) + { + std::vector<std::string> commands = this->GetCommandNames(); + this->SetGlobalProperty("COMMANDS", cmJoin(commands, ";").c_str()); + } + else if ( prop == "IN_TRY_COMPILE" ) + { + this->SetGlobalProperty("IN_TRY_COMPILE", + this->IsInTryCompile ? "1" : "0"); + } + else if ( prop == "ENABLED_LANGUAGES" ) + { + std::string langs; + langs = cmJoin(this->EnabledLanguages, ";"); + this->SetGlobalProperty("ENABLED_LANGUAGES", langs.c_str()); + } +#define STRING_LIST_ELEMENT(F) ";" #F + if (prop == "CMAKE_C_KNOWN_FEATURES") + { + return FOR_EACH_C_FEATURE(STRING_LIST_ELEMENT) + 1; + } + if (prop == "CMAKE_CXX_KNOWN_FEATURES") + { + return FOR_EACH_CXX_FEATURE(STRING_LIST_ELEMENT) + 1; + } +#undef STRING_LIST_ELEMENT + bool dummy = false; + return this->GlobalProperties.GetPropertyValue(prop, cmProperty::GLOBAL, + dummy); +} + +bool cmState::GetGlobalPropertyAsBool(const std::string& prop) +{ + return cmSystemTools::IsOn(this->GetGlobalProperty(prop)); +} diff --git a/Source/cmState.h b/Source/cmState.h index f2e8ef5..34b2ccf 100644 --- a/Source/cmState.h +++ b/Source/cmState.h @@ -13,13 +13,17 @@ #define cmState_h #include "cmStandardIncludes.h" +#include "cmPropertyDefinitionMap.h" +#include "cmPropertyMap.h" class cmake; +class cmCommand; class cmState { public: cmState(cmake* cm); + ~cmState(); enum CacheEntryType{ BOOL=0, PATH, FILEPATH, STRING, INTERNAL,STATIC, UNINITIALIZED }; @@ -55,8 +59,49 @@ public: void RemoveCacheEntryProperty(std::string const& key, std::string const& propertyName); + void Initialize(); + // Define a property + void DefineProperty(const std::string& name, cmProperty::ScopeType scope, + const char *ShortDescription, + const char *FullDescription, + bool chain = false); + + // get property definition + cmPropertyDefinition *GetPropertyDefinition + (const std::string& name, cmProperty::ScopeType scope); + + // Is a property defined? + bool IsPropertyDefined(const std::string& name, cmProperty::ScopeType scope); + bool IsPropertyChained(const std::string& name, cmProperty::ScopeType scope); + + void SetLanguageEnabled(std::string const& l); + bool GetLanguageEnabled(std::string const& l) const; + std::vector<std::string> GetEnabledLanguages() const; + void ClearEnabledLanguages(); + + bool GetIsInTryCompile() const; + void SetIsInTryCompile(bool b); + + cmCommand* GetCommand(std::string const& name) const; + void AddCommand(cmCommand* command); + void RemoveUnscriptableCommands(); + void RenameCommand(std::string const& oldName, std::string const& newName); + void RemoveUserDefinedCommands(); + std::vector<std::string> GetCommandNames() const; + + void SetGlobalProperty(const std::string& prop, const char *value); + void AppendGlobalProperty(const std::string& prop, + const char *value,bool asString=false); + const char *GetGlobalProperty(const std::string& prop); + bool GetGlobalPropertyAsBool(const std::string& prop); + private: + std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> PropertyDefinitions; + std::vector<std::string> EnabledLanguages; + std::map<std::string, cmCommand*> Commands; + cmPropertyMap GlobalProperties; cmake* CMakeInstance; + bool IsInTryCompile; }; #endif diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx index 6711e86..f1540d4 100644 --- a/Source/cmTarget.cxx +++ b/Source/cmTarget.cxx @@ -264,20 +264,6 @@ cmTarget::cmTarget() this->LinkImplementationLanguageIsContextDependent = true; } -//---------------------------------------------------------------------------- -void cmTarget::DefineProperties(cmake *cm) -{ - cm->DefineProperty - ("RULE_LAUNCH_COMPILE", cmProperty::TARGET, - "", "", true); - cm->DefineProperty - ("RULE_LAUNCH_LINK", cmProperty::TARGET, - "", "", true); - cm->DefineProperty - ("RULE_LAUNCH_CUSTOM", cmProperty::TARGET, - "", "", true); -} - void cmTarget::SetType(TargetType type, const std::string& name) { this->Name = name; diff --git a/Source/cmTarget.h b/Source/cmTarget.h index 55bf234..a032414 100644 --- a/Source/cmTarget.h +++ b/Source/cmTarget.h @@ -489,9 +489,6 @@ public: const char** imp, std::string& suffix) const; - // Define the properties - static void DefineProperties(cmake *cm); - /** Get the macro to define when building sources in this target. If no macro should be defined null is returned. */ const char* GetExportMacro() const; diff --git a/Source/cmake.cxx b/Source/cmake.cxx index 8cdf96f..a542a24 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -136,8 +136,6 @@ cmake::cmake() this->Policies = new cmPolicies(); this->State = new cmState(this); - this->InitializeProperties(); - #ifdef __APPLE__ struct rlimit rlp; if(!getrlimit(RLIMIT_STACK, &rlp)) @@ -151,7 +149,6 @@ cmake::cmake() #endif this->Verbose = false; - this->InTryCompile = false; this->CacheManager = new cmCacheManager(this); this->GlobalGenerator = 0; this->ProgressCallback = 0; @@ -180,7 +177,6 @@ cmake::~cmake() delete this->GlobalGenerator; this->GlobalGenerator = 0; } - cmDeleteAll(this->Commands); cmDeleteAll(this->Generators); #ifdef CMAKE_BUILD_WITH_CMAKE delete this->VariableWatch; @@ -188,128 +184,10 @@ cmake::~cmake() delete this->FileComparison; } -void cmake::InitializeProperties() -{ - this->Properties.clear(); - this->PropertyDefinitions.clear(); - - // initialize properties - cmTarget::DefineProperties(this); - cmMakefile::DefineProperties(this); -} - void cmake::CleanupCommandsAndMacros() { - this->InitializeProperties(); - std::vector<cmCommand*> commands; - for(RegisteredCommandsMap::iterator j = this->Commands.begin(); - j != this->Commands.end(); ++j) - { - if ( !j->second->IsA("cmMacroHelperCommand") && - !j->second->IsA("cmFunctionHelperCommand")) - { - commands.push_back(j->second); - } - else - { - delete j->second; - } - } - this->Commands.clear(); - std::vector<cmCommand*>::iterator it; - for ( it = commands.begin(); it != commands.end(); - ++ it ) - { - this->Commands[cmSystemTools::LowerCase((*it)->GetName())] = *it; - } -} - -bool cmake::CommandExists(const std::string& name) const -{ - return this->GetCommand(name) ? true : false; -} - -cmCommand *cmake::GetCommand(const std::string& name) const -{ - cmCommand* command = 0; - std::string sName = cmSystemTools::LowerCase(name); - RegisteredCommandsMap::const_iterator pos = this->Commands.find(sName); - if (pos != this->Commands.end()) - { - command = (*pos).second; - } - return command; -} - -void cmake::RenameCommand(const std::string& oldName, - const std::string& newName) -{ - // if the command already exists, free the old one - std::string sOldName = cmSystemTools::LowerCase(oldName); - RegisteredCommandsMap::iterator pos = this->Commands.find(sOldName); - if ( pos == this->Commands.end() ) - { - return; - } - std::string sNewName = cmSystemTools::LowerCase(newName); - cmCommand* cmd = pos->second; - - pos = this->Commands.find(sNewName); - if (pos != this->Commands.end()) - { - delete pos->second; - this->Commands.erase(pos); - } - this->Commands.insert(std::make_pair(sNewName, cmd)); - pos = this->Commands.find(sOldName); - this->Commands.erase(pos); -} - -void cmake::RemoveCommand(const std::string& name) -{ - std::string sName = cmSystemTools::LowerCase(name); - RegisteredCommandsMap::iterator pos = this->Commands.find(sName); - if ( pos != this->Commands.end() ) - { - delete pos->second; - this->Commands.erase(pos); - } -} - -void cmake::AddCommand(cmCommand* command) -{ - std::string name = cmSystemTools::LowerCase(command->GetName()); - // if the command already exists, free the old one - RegisteredCommandsMap::iterator pos = this->Commands.find(name); - if (pos != this->Commands.end()) - { - delete pos->second; - this->Commands.erase(pos); - } - this->Commands.insert(std::make_pair(name, command)); -} - - -void cmake::RemoveUnscriptableCommands() -{ - std::vector<std::string> unscriptableCommands; - for (cmake::RegisteredCommandsMap::const_iterator - pos = this->Commands.begin(); - pos != this->Commands.end(); - ++pos) - { - if (!pos->second->IsScriptable()) - { - unscriptableCommands.push_back(pos->first); - } - } - - for(std::vector<std::string>::const_iterator it=unscriptableCommands.begin(); - it != unscriptableCommands.end(); - ++it) - { - this->RemoveCommand(*it); - } + this->State->Initialize(); + this->State->RemoveUserDefinedCommands(); } // Parse the args @@ -1274,8 +1152,9 @@ int cmake::HandleDeleteCacheVariables(const std::string& var) std::vector<std::string> argsSplit; cmSystemTools::ExpandListArgument(std::string(var), argsSplit, true); // erase the property to avoid infinite recursion - this->SetProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_", ""); - if(this->GetIsInTryCompile()) + this->State + ->SetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_", ""); + if(this->State->GetIsInTryCompile()) { return 0; } @@ -1351,8 +1230,8 @@ int cmake::Configure() } } int ret = this->ActualConfigure(); - const char* delCacheVars = - this->GetProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_"); + const char* delCacheVars = this->State + ->GetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_"); if(delCacheVars && delCacheVars[0] != 0) { return this->HandleDeleteCacheVariables(delCacheVars); @@ -1558,7 +1437,7 @@ int cmake::ActualConfigure() // reset any system configuration information, except for when we are // InTryCompile. With TryCompile the system info is taken from the parent's // info to save time - if (!this->InTryCompile) + if (!this->State->GetIsInTryCompile()) { this->GlobalGenerator->ClearEnabledLanguages(); @@ -1627,7 +1506,7 @@ int cmake::ActualConfigure() cmMakefile* mf=this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile(); if (mf->IsOn("CTEST_USE_LAUNCHERS") - && !this->GetProperty("RULE_LAUNCH_COMPILE", cmProperty::GLOBAL)) + && !this->State->GetGlobalProperty("RULE_LAUNCH_COMPILE")) { cmSystemTools::Error("CTEST_USE_LAUNCHERS is enabled, but the " "RULE_LAUNCH_COMPILE global property is not defined.\n" @@ -1845,7 +1724,7 @@ void cmake::AddDefaultCommands() for(std::vector<cmCommand*>::iterator i = commands.begin(); i != commands.end(); ++i) { - this->AddCommand(*i); + this->State->AddCommand(*i); } } @@ -1961,7 +1840,7 @@ void cmake::SetProgressCallback(ProgressCallbackType f, void *cd) void cmake::UpdateProgress(const char *msg, float prog) { - if(this->ProgressCallback && !this->InTryCompile) + if(this->ProgressCallback && !this->State->GetIsInTryCompile()) { (*this->ProgressCallback)(msg, prog, this->ProgressCallbackClientData); return; @@ -1970,12 +1849,12 @@ void cmake::UpdateProgress(const char *msg, float prog) bool cmake::GetIsInTryCompile() const { - return this->InTryCompile; + return this->State->GetIsInTryCompile(); } void cmake::SetIsInTryCompile(bool b) { - this->InTryCompile = b; + this->State->SetIsInTryCompile(b); } void cmake::GetGeneratorDocumentation(std::vector<cmDocumentationEntry>& v) @@ -2298,114 +2177,25 @@ void cmake::GenerateGraphViz(const char* fileName) const #endif } -void cmake::DefineProperty(const std::string& name, - cmProperty::ScopeType scope, - const char *ShortDescription, - const char *FullDescription, - bool chained) -{ - this->PropertyDefinitions[scope].DefineProperty(name,scope,ShortDescription, - FullDescription, - chained); -} - -cmPropertyDefinition *cmake -::GetPropertyDefinition(const std::string& name, - cmProperty::ScopeType scope) -{ - if (this->IsPropertyDefined(name,scope)) - { - return &(this->PropertyDefinitions[scope][name]); - } - return 0; -} - -bool cmake::IsPropertyDefined(const std::string& name, - cmProperty::ScopeType scope) -{ - return this->PropertyDefinitions[scope].IsPropertyDefined(name); -} - -bool cmake::IsPropertyChained(const std::string& name, - cmProperty::ScopeType scope) -{ - return this->PropertyDefinitions[scope].IsPropertyChained(name); -} - void cmake::SetProperty(const std::string& prop, const char* value) { - this->Properties.SetProperty(prop, value, cmProperty::GLOBAL); + this->State->SetGlobalProperty(prop, value); } void cmake::AppendProperty(const std::string& prop, const char* value, bool asString) { - this->Properties.AppendProperty(prop, value, cmProperty::GLOBAL, asString); + this->State->AppendGlobalProperty(prop, value, asString); } const char *cmake::GetProperty(const std::string& prop) { - return this->GetProperty(prop, cmProperty::GLOBAL); -} - -const char *cmake::GetProperty(const std::string& prop, - cmProperty::ScopeType scope) -{ - // watch for special properties - std::string output = ""; - if ( prop == "CACHE_VARIABLES" ) - { - std::vector<std::string> cacheKeys = this->State->GetCacheEntryKeys(); - this->SetProperty("CACHE_VARIABLES", cmJoin(cacheKeys, ";").c_str()); - } - else if ( prop == "COMMANDS" ) - { - cmake::RegisteredCommandsMap::iterator cmds - = this->Commands.begin(); - for (unsigned int cc=0 ; cmds != this->Commands.end(); ++ cmds ) - { - if ( cc > 0 ) - { - output += ";"; - } - output += cmds->first.c_str(); - cc++; - } - this->SetProperty("COMMANDS",output.c_str()); - } - else if ( prop == "IN_TRY_COMPILE" ) - { - this->SetProperty("IN_TRY_COMPILE", - this->GetIsInTryCompile()? "1":"0"); - } - else if ( prop == "ENABLED_LANGUAGES" ) - { - std::string lang; - if(this->GlobalGenerator) - { - std::vector<std::string> enLangs; - this->GlobalGenerator->GetEnabledLanguages(enLangs); - lang = cmJoin(enLangs, ";"); - } - this->SetProperty("ENABLED_LANGUAGES", lang.c_str()); - } -#define STRING_LIST_ELEMENT(F) ";" #F - if (prop == "CMAKE_C_KNOWN_FEATURES") - { - return FOR_EACH_C_FEATURE(STRING_LIST_ELEMENT) + 1; - } - if (prop == "CMAKE_CXX_KNOWN_FEATURES") - { - return FOR_EACH_CXX_FEATURE(STRING_LIST_ELEMENT) + 1; - } -#undef STRING_LIST_ELEMENT - bool dummy = false; - return this->Properties.GetPropertyValue(prop, scope, dummy); + return this->State->GetGlobalProperty(prop); } bool cmake::GetPropertyAsBool(const std::string& prop) { - return cmSystemTools::IsOn(this->GetProperty(prop)); + return this->State->GetGlobalPropertyAsBool(prop); } cmInstalledFile *cmake::GetOrCreateInstalledFile( @@ -2801,7 +2591,8 @@ void cmake::IssueMessage(cmake::MessageType t, std::string const& text, std::vector<std::string> cmake::GetDebugConfigs() { std::vector<std::string> configs; - if(const char* config_list = this->GetProperty("DEBUG_CONFIGURATIONS")) + if(const char* config_list = + this->State->GetGlobalProperty("DEBUG_CONFIGURATIONS")) { // Expand the specified list and convert to upper-case. cmSystemTools::ExpandListArgument(config_list, configs); diff --git a/Source/cmake.h b/Source/cmake.h index e80cc1c..352850d 100644 --- a/Source/cmake.h +++ b/Source/cmake.h @@ -15,8 +15,6 @@ #include "cmListFileCache.h" #include "cmSystemTools.h" -#include "cmPropertyDefinitionMap.h" -#include "cmPropertyMap.h" #include "cmInstalledFile.h" #include "cmCacheManager.h" #include "cmState.h" @@ -25,7 +23,6 @@ class cmGlobalGeneratorFactory; class cmGlobalGenerator; class cmLocalGenerator; class cmMakefile; -class cmCommand; class cmVariableWatch; class cmFileTimeComparison; class cmExternalMakefileProjectGenerator; @@ -94,7 +91,6 @@ class cmake */ FIND_PACKAGE_MODE }; - typedef std::map<std::string, cmCommand*> RegisteredCommandsMap; typedef std::map<std::string, cmInstalledFile> InstalledFilesMap; /// Default constructor @@ -218,22 +214,6 @@ class cmake */ int GetSystemInformation(std::vector<std::string>&); - /** - * Add a command to this cmake instance - */ - void AddCommand(cmCommand* ); - void RenameCommand(const std::string& oldName, const std::string& newName); - void RemoveCommand(const std::string& name); - void RemoveUnscriptableCommands(); - - /** - * Get a command by its name - */ - cmCommand *GetCommand(const std::string& name) const; - - /** Check if a command exists. */ - bool CommandExists(const std::string& name) const; - ///! Parse command line arguments void SetArgs(const std::vector<std::string>&, bool directoriesSetBefore = false); @@ -272,8 +252,6 @@ class cmake void AppendProperty(const std::string& prop, const char *value,bool asString=false); const char *GetProperty(const std::string& prop); - const char *GetProperty(const std::string& prop, - cmProperty::ScopeType scope); bool GetPropertyAsBool(const std::string& prop); ///! Get or create an cmInstalledFile instance and return a pointer to it @@ -323,20 +301,6 @@ class cmake void MarkCliAsUsed(const std::string& variable); - // Define a property - void DefineProperty(const std::string& name, cmProperty::ScopeType scope, - const char *ShortDescription, - const char *FullDescription, - bool chain = false); - - // get property definition - cmPropertyDefinition *GetPropertyDefinition - (const std::string& name, cmProperty::ScopeType scope); - - // Is a property defined? - bool IsPropertyDefined(const std::string& name, cmProperty::ScopeType scope); - bool IsPropertyChained(const std::string& name, cmProperty::ScopeType scope); - /** Get the list of configurations (in upper case) considered to be debugging configurations.*/ std::vector<std::string> GetDebugConfigs(); @@ -371,17 +335,12 @@ protected: void RunCheckForUnusedVariables(); void InitializeProperties(); int HandleDeleteCacheVariables(const std::string& var); - cmPropertyMap Properties; - - std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> - PropertyDefinitions; typedef cmExternalMakefileProjectGenerator* (*CreateExtraGeneratorFunctionType)(); typedef std::map<std::string, CreateExtraGeneratorFunctionType> RegisteredExtraGeneratorsMap; typedef std::vector<cmGlobalGeneratorFactory*> RegisteredGeneratorsVector; - RegisteredCommandsMap Commands; RegisteredGeneratorsVector Generators; RegisteredExtraGeneratorsMap ExtraGenerators; void AddDefaultCommands(); diff --git a/Tests/FindMatlab/basic_checks/CMakeLists.txt b/Tests/FindMatlab/basic_checks/CMakeLists.txt index acf71ea..bf54427 100644 --- a/Tests/FindMatlab/basic_checks/CMakeLists.txt +++ b/Tests/FindMatlab/basic_checks/CMakeLists.txt @@ -24,7 +24,7 @@ matlab_add_mex( matlab_add_unit_test( NAME ${PROJECT_NAME}_matlabtest-1 - TIMEOUT 30 + TIMEOUT 90 UNITTEST_FILE ${CMAKE_CURRENT_SOURCE_DIR}/../cmake_matlab_unit_tests1.m ADDITIONAL_PATH $<TARGET_FILE_DIR:cmake_matlab_test_wrapper1> ) diff --git a/Tests/Preprocess/CMakeLists.txt b/Tests/Preprocess/CMakeLists.txt index 8ff0cfd..15e2aca 100644 --- a/Tests/Preprocess/CMakeLists.txt +++ b/Tests/Preprocess/CMakeLists.txt @@ -134,6 +134,15 @@ if((NOT MSVC OR PP_NMAKE) AND set(EXPR_OP1 "%") endif() +# XL: )( +# The XL compiler cannot pass unbalanced parens correctly to a tool +# it launches internally. +if(CMAKE_C_COMPILER_ID STREQUAL "XL") + set(STRING_EXTRA "${STRING_EXTRA}()") +else() + set(STRING_EXTRA "${STRING_EXTRA})(") +endif() + # General: \" # Make tools do not reliably accept \\\" syntax: # - MinGW and MSYS make tools crash with \\\" @@ -141,7 +150,10 @@ endif() # or $(BACKSLASH)\" where BACKSLASH is a variable set to \\ # - VS IDE gets confused about the bounds of the definition value \\\" # - NMake is okay with just \\\" -if(PP_NMAKE OR PP_UMAKE) +# - The XL compiler does not re-escape \\\" when launching an +# internal tool to do preprocessing . +if((PP_NMAKE OR PP_UMAKE) AND + NOT CMAKE_C_COMPILER_ID STREQUAL "XL") set(STRING_EXTRA "${STRING_EXTRA}\\\"") endif() @@ -160,7 +172,7 @@ endif() # support it and it is not an operator it is not worthwhile. # Compose the final test string. -set(STRING_VALUE "hello`~!@$*)(_+-=}{][:'.?/${STRING_EXTRA}world") +set(STRING_VALUE "hello`~!@$*_+-=}{][:'.?/${STRING_EXTRA}world") #----------------------------------------------------------------------------- # Function-style macro command-line support: diff --git a/Tests/RunCMake/CommandLine/DeprecateVS6-WARN-OFF.cmake b/Tests/RunCMake/CommandLine/DeprecateVS6-WARN-OFF.cmake new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/Tests/RunCMake/CommandLine/DeprecateVS6-WARN-OFF.cmake diff --git a/Tests/RunCMake/CommandLine/DeprecateVS6-WARN-ON-stderr.txt b/Tests/RunCMake/CommandLine/DeprecateVS6-WARN-ON-stderr.txt new file mode 100644 index 0000000..1b6a510 --- /dev/null +++ b/Tests/RunCMake/CommandLine/DeprecateVS6-WARN-ON-stderr.txt @@ -0,0 +1,5 @@ +^CMake Warning: + The "Visual Studio 6" generator is deprecated and will be removed in a + future version of CMake. + + Add CMAKE_WARN_VS6=OFF to the cache to disable this warning.$ diff --git a/Tests/RunCMake/CommandLine/DeprecateVS6-WARN-ON.cmake b/Tests/RunCMake/CommandLine/DeprecateVS6-WARN-ON.cmake new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/Tests/RunCMake/CommandLine/DeprecateVS6-WARN-ON.cmake diff --git a/Tests/RunCMake/CommandLine/DeprecateVS70-WARN-OFF.cmake b/Tests/RunCMake/CommandLine/DeprecateVS70-WARN-OFF.cmake new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/Tests/RunCMake/CommandLine/DeprecateVS70-WARN-OFF.cmake diff --git a/Tests/RunCMake/CommandLine/DeprecateVS70-WARN-ON-stderr.txt b/Tests/RunCMake/CommandLine/DeprecateVS70-WARN-ON-stderr.txt new file mode 100644 index 0000000..ea31ef3 --- /dev/null +++ b/Tests/RunCMake/CommandLine/DeprecateVS70-WARN-ON-stderr.txt @@ -0,0 +1,5 @@ +^CMake Warning: + The "Visual Studio 7" generator is deprecated and will be removed in a + future version of CMake. + + Add CMAKE_WARN_VS70=OFF to the cache to disable this warning.$ diff --git a/Tests/RunCMake/CommandLine/DeprecateVS70-WARN-ON.cmake b/Tests/RunCMake/CommandLine/DeprecateVS70-WARN-ON.cmake new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/Tests/RunCMake/CommandLine/DeprecateVS70-WARN-ON.cmake diff --git a/Tests/RunCMake/CommandLine/RunCMakeTest.cmake b/Tests/RunCMake/CommandLine/RunCMakeTest.cmake index f047baf..644e5ae 100644 --- a/Tests/RunCMake/CommandLine/RunCMakeTest.cmake +++ b/Tests/RunCMake/CommandLine/RunCMakeTest.cmake @@ -40,6 +40,18 @@ if(RunCMake_GENERATOR STREQUAL "Ninja") unset(RunCMake_TEST_NO_CLEAN) endif() +if(RunCMake_GENERATOR STREQUAL "Visual Studio 6") + set(RunCMake_WARN_VS6 1) + run_cmake(DeprecateVS6-WARN-ON) + unset(RunCMake_WARN_VS6) + run_cmake(DeprecateVS6-WARN-OFF) +elseif(RunCMake_GENERATOR STREQUAL "Visual Studio 7") + set(RunCMake_WARN_VS70 1) + run_cmake(DeprecateVS70-WARN-ON) + unset(RunCMake_WARN_VS70) + run_cmake(DeprecateVS70-WARN-OFF) +endif() + if(UNIX) run_cmake_command(E_create_symlink-no-arg ${CMAKE_COMMAND} -E create_symlink diff --git a/Tests/RunCMake/RunCMake.cmake b/Tests/RunCMake/RunCMake.cmake index 6333703..b24ae0b 100644 --- a/Tests/RunCMake/RunCMake.cmake +++ b/Tests/RunCMake/RunCMake.cmake @@ -51,6 +51,12 @@ function(run_cmake test) if(APPLE) list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_POLICY_DEFAULT_CMP0025=NEW) endif() + if(RunCMake_GENERATOR STREQUAL "Visual Studio 6" AND NOT RunCMake_WARN_VS6) + list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_WARN_VS6=OFF) + endif() + if(RunCMake_GENERATOR STREQUAL "Visual Studio 7" AND NOT RunCMake_WARN_VS70) + list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_WARN_VS70=OFF) + endif() if(RunCMake_MAKE_PROGRAM) list(APPEND RunCMake_TEST_OPTIONS "-DCMAKE_MAKE_PROGRAM=${RunCMake_MAKE_PROGRAM}") endif() |