Port Global property interaction to cmState.

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");
+  const char* subproject = cm->GetState()->GetGlobalProperty("SubProject");
   // TODO: Encode values for a URL instead of trusting caller.
   std::ostringstream str;
   str << "project="

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;

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");
+  const char* subproject = cm->GetState()
+                             ->GetGlobalProperty("SubProject");
   if(subproject)
     {
     ostr << "<Subproject name=\"" << subproject << "\">\n";
     const char* labels =
-      ch->GetCMake()->GetProperty("SubProjectLabels");
+      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");
+  const char* label = cm->GetState()->GetGlobalProperty("Label");
   if(label)
     {
     ostr << "<Labels>\n";

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

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");
 }
 
 //----------------------------------------------------------------------------

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"))
+  if (const char *extraNaturesProp = mf->GetState()
+        ->GetGlobalProperty("ECLIPSE_EXTRA_NATURES"))
     {
     std::vector<std::string> extraNatures;
     cmSystemTools::ExpandListArgument(extraNaturesProp, extraNatures);

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");
 }
 
 //----------------------------------------------------------------------------

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

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;

Source/cmGetPropertyCommand.cxx

@@ -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));
 }
 
 //----------------------------------------------------------------------------

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());
       }
@@ -1170,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;
     }
@@ -2391,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)
     {
@@ -2405,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...
   //

Source/cmLocalNinjaGenerator.cxx

@@ -18,6 +18,7 @@
 #include "cmGeneratedFileStream.h"
 #include "cmSourceFile.h"
 #include "cmake.h"
+#include "cmState.h"
 
 #include <assert.h>
 
@@ -234,7 +235,8 @@ void cmLocalNinjaGenerator::WritePools(std::ostream& os)
 {
   cmGlobalNinjaGenerator::WriteDivider(os);
 
-  const char* jobpools = this->GetCMakeInstance()->GetProperty("JOB_POOLS");
+  const char* jobpools = this->GetCMakeInstance()->GetState()
+                             ->GetGlobalProperty("JOB_POOLS");
   if (jobpools)
     {
     cmGlobalNinjaGenerator::WriteComment(os,

Source/cmMakefile.cxx

@@ -4239,7 +4239,7 @@ const char *cmMakefile::GetProperty(const std::string& prop,
       return this->LocalGenerator->GetParent()->GetMakefile()->
         GetProperty(prop, scope);
       }
-    return this->GetCMakeInstance()->GetProperty(prop);
+    return this->GetState()->GetGlobalProperty(prop);
     }
 
   return retVal;
@@ -4585,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;
         }

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

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

Source/cmake.cxx

@@ -1152,7 +1152,8 @@ 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_", "");
+  this->State
+      ->SetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_", "");
   if(this->State->GetIsInTryCompile())
     {
     return 0;
@@ -1229,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);
@@ -1505,7 +1506,7 @@ int cmake::ActualConfigure()
 
   cmMakefile* mf=this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile();
   if (mf->IsOn("CTEST_USE_LAUNCHERS")
-              && !this->GetProperty("RULE_LAUNCH_COMPILE"))
+              && !this->State->GetGlobalProperty("RULE_LAUNCH_COMPILE"))
     {
     cmSystemTools::Error("CTEST_USE_LAUNCHERS is enabled, but the "
                         "RULE_LAUNCH_COMPILE global property is not defined.\n"
@@ -2194,7 +2195,7 @@ const char *cmake::GetProperty(const std::string& prop)
 
 bool cmake::GetPropertyAsBool(const std::string& prop)
 {
-  return cmSystemTools::IsOn(this->GetProperty(prop));
+  return this->State->GetGlobalPropertyAsBool(prop);
 }
 
 cmInstalledFile *cmake::GetOrCreateInstalledFile(
@@ -2590,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);