Introduce cmState class.

At this point, it is an interface to the cache.  It will be extended
to be a universal interface for access to and manipulation of
configuration-time data (defintions, properties on targets,
directories, source files etc).

This will allow porting all command implementations away
from the cmMakefile and cmTarget classes, and result in something
more-purely related to configuration-time processing of cmake
commands.  That should serve at least the following goals:

 * Split the CMake implementation more definitively into three
   stages: Configuration, computation and generation, and be able to
   implement each optimally for memory access patterns etc.
 * Make better IDE integration possible by making more configuration
   data available.
 * Make it possiblte to use a smaller library than CMakeLib.a in
   cpack and ctest, resulting in smaller executables.
 * Make it possible to run the configure step multiple times in
   the same CMake run (#14539).

Manage its lifetime in the cmake class, and add a convenience accessor
to cmMakefile.

Source/CMakeLists.txt

@@ -323,6 +323,8 @@ set(SRCS
   cmSourceFileLocation.h
   cmSourceGroup.cxx
   cmSourceGroup.h
+  cmState.cxx
+  cmState.h
   cmSystemTools.cxx
   cmSystemTools.h
   cmTarget.cxx

Source/cmCacheManager.h

@@ -249,6 +249,7 @@ private:
   // Only cmake and cmMakefile should be able to add cache values
   // the commands should never use the cmCacheManager directly
   friend class cmMakefile; // allow access to add cache values
+  friend class cmState; // allow access to add cache values
   friend class cmake; // allow access to add cache values
   friend class cmMarkAsAdvancedCommand; // allow access to add cache values
 };

Source/cmMakefile.cxx

@@ -19,6 +19,7 @@
 #include "cmLocalGenerator.h"
 #include "cmCommands.h"
 #include "cmCacheManager.h"
+#include "cmState.h"
 #include "cmFunctionBlocker.h"
 #include "cmListFileCache.h"
 #include "cmCommandArgumentParserHelper.h"
@@ -3738,6 +3739,11 @@ cmCacheManager *cmMakefile::GetCacheManager() const
   return this->GetCMakeInstance()->GetCacheManager();
 }
 
+cmState *cmMakefile::GetState() const
+{
+  return this->GetCMakeInstance()->GetState();
+}
+
 void cmMakefile::DisplayStatus(const char* message, float s) const
 {
   cmake* cm = this->GetLocalGenerator()->GetGlobalGenerator()

Source/cmMakefile.h

@@ -766,6 +766,7 @@ public:
   void EnableLanguage(std::vector<std::string>const& languages, bool optional);
 
   cmCacheManager *GetCacheManager() const;
+  cmState *GetState() const;
 
   /**
    * Get the variable watch. This is used to determine when certain variables

Source/cmState.cxx

@@ -0,0 +1,147 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2015 Stephen Kelly <steveire@gmail.com>
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+#include "cmState.h"
+
+#include "cmake.h"
+
+cmState::cmState(cmake* cm)
+  : CMakeInstance(cm)
+{
+}
+cmCacheManager::CacheEntryType
+cmState::StringToCacheEntryType(const char* s)
+{
+  return cmCacheManager::StringToType(s);
+}
+
+const char*
+cmState::CacheEntryTypeToString(cmCacheManager::CacheEntryType t)
+{
+  return cmCacheManager::TypeToString(t);
+}
+
+bool cmState::IsCacheEntryType(std::string const& key)
+{
+  return cmCacheManager::IsType(key.c_str());
+}
+
+std::vector<std::string> cmState::GetCacheEntryKeys() const
+{
+  std::vector<std::string> definitions;
+  definitions.reserve(this->CMakeInstance->GetCacheManager()->GetSize());
+  cmCacheManager::CacheIterator cit =
+    this->CMakeInstance->GetCacheManager()->GetCacheIterator();
+  for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
+    {
+    definitions.push_back(cit.GetName());
+    }
+  return definitions;
+}
+
+const char* cmState::GetCacheEntryValue(std::string const& key) const
+{
+  cmCacheManager::CacheEntry* e = this->CMakeInstance->GetCacheManager()
+             ->GetCacheEntry(key);
+  if (!e)
+    {
+    return 0;
+    }
+  return e->Value.c_str();
+}
+
+const char*
+cmState::GetInitializedCacheValue(std::string const& key) const
+{
+  return this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue(key);
+}
+
+cmCacheManager::CacheEntryType
+cmState::GetCacheEntryType(std::string const& key) const
+{
+  cmCacheManager::CacheIterator it =
+      this->CMakeInstance->GetCacheManager()->GetCacheIterator(key.c_str());
+  return it.GetType();
+}
+
+void cmState::SetCacheEntryValue(std::string const& key,
+                                         std::string const& value)
+{
+  this->CMakeInstance->GetCacheManager()->SetCacheEntryValue(key, value);
+}
+
+void cmState::SetCacheEntryProperty(std::string const& key,
+                            std::string const& propertyName,
+                            std::string const& value)
+{
+  cmCacheManager::CacheIterator it =
+      this->CMakeInstance->GetCacheManager()->GetCacheIterator(key.c_str());
+  it.SetProperty(propertyName, value.c_str());
+}
+
+void cmState::SetCacheEntryBoolProperty(std::string const& key,
+                            std::string const& propertyName,
+                            bool value)
+{
+  cmCacheManager::CacheIterator it =
+      this->CMakeInstance->GetCacheManager()->GetCacheIterator(key.c_str());
+  it.SetProperty(propertyName, value);
+}
+
+const char* cmState::GetCacheEntryProperty(std::string const& key,
+                                              std::string const& propertyName)
+{
+  cmCacheManager::CacheIterator it = this->CMakeInstance->GetCacheManager()
+             ->GetCacheIterator(key.c_str());
+  if (!it.PropertyExists(propertyName))
+    {
+    return 0;
+    }
+  return it.GetProperty(propertyName);
+}
+
+bool cmState::GetCacheEntryPropertyAsBool(std::string const& key,
+                                              std::string const& propertyName)
+{
+  return this->CMakeInstance->GetCacheManager()
+             ->GetCacheIterator(key.c_str()).GetPropertyAsBool(propertyName);
+}
+
+void cmState::AddCacheEntry(const std::string& key, const char* value,
+                                    const char* helpString,
+                                    cmCacheManager::CacheEntryType type)
+{
+  this->CMakeInstance->GetCacheManager()->AddCacheEntry(key, value,
+                                                        helpString, type);
+}
+
+void cmState::RemoveCacheEntry(std::string const& key)
+{
+  this->CMakeInstance->GetCacheManager()->RemoveCacheEntry(key);
+}
+
+void cmState::AppendCacheEntryProperty(const std::string& key,
+                                               const std::string& property,
+                                               const std::string& value,
+                                               bool asString)
+{
+  this->CMakeInstance->GetCacheManager()
+       ->GetCacheIterator(key.c_str()).AppendProperty(property,
+                                                       value.c_str(),
+                                                       asString);
+}
+
+void cmState::RemoveCacheEntryProperty(std::string const& key,
+                                              std::string const& propertyName)
+{
+  this->CMakeInstance->GetCacheManager()
+       ->GetCacheIterator(key.c_str()).SetProperty(propertyName, (void*)0);
+}

Source/cmState.h

@@ -0,0 +1,62 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2015 Stephen Kelly <steveire@gmail.com>
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+#ifndef cmState_h
+#define cmState_h
+
+#include "cmCacheManager.h"
+
+class cmake;
+
+class cmState
+{
+public:
+  cmState(cmake* cm);
+
+  static cmCacheManager::CacheEntryType StringToCacheEntryType(const char*);
+  static const char* CacheEntryTypeToString(cmCacheManager::CacheEntryType);
+  static bool IsCacheEntryType(std::string const& key);
+
+  std::vector<std::string> GetCacheEntryKeys() const;
+  const char* GetCacheEntryValue(std::string const& key) const;
+  const char* GetInitializedCacheValue(std::string const& key) const;
+  cmCacheManager::CacheEntryType
+  GetCacheEntryType(std::string const& key) const;
+  void SetCacheEntryValue(std::string const& key, std::string const& value);
+  void SetCacheValue(std::string const& key, std::string const& value);
+
+  void AddCacheEntry(const std::string& key, const char* value,
+                     const char* helpString,
+                     cmCacheManager::CacheEntryType type);
+  void RemoveCacheEntry(std::string const& key);
+
+  void SetCacheEntryProperty(std::string const& key,
+                             std::string const& propertyName,
+                             std::string const& value);
+  void SetCacheEntryBoolProperty(std::string const& key,
+                                 std::string const& propertyName,
+                                 bool value);
+  const char* GetCacheEntryProperty(std::string const& key,
+                                    std::string const& propertyName);
+  bool GetCacheEntryPropertyAsBool(std::string const& key,
+                                   std::string const& propertyName);
+  void AppendCacheEntryProperty(std::string const& key,
+                                const std::string& property,
+                                const std::string& value,
+                                bool asString = false);
+  void RemoveCacheEntryProperty(std::string const& key,
+                                std::string const& propertyName);
+
+private:
+  cmake* CMakeInstance;
+};
+
+#endif

Source/cmake.cxx

@@ -21,6 +21,7 @@
 #include "cmTest.h"
 #include "cmDocumentationFormatter.h"
 #include "cmAlgorithms.h"
+#include "cmState.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
 # include "cmGraphVizWriter.h"
@@ -133,6 +134,8 @@ cmake::cmake()
   this->FileComparison = new cmFileTimeComparison;
 
   this->Policies = new cmPolicies();
+  this->State = new cmState(this);
+
   this->InitializeProperties();
 
 #ifdef __APPLE__
@@ -171,6 +174,7 @@ cmake::~cmake()
 {
   delete this->CacheManager;
   delete this->Policies;
+  delete this->State;
   if (this->GlobalGenerator)
     {
     delete this->GlobalGenerator;

Source/cmake.h

@@ -32,6 +32,7 @@ class cmDocumentationSection;
 class cmPolicies;
 class cmTarget;
 class cmGeneratedFileStream;
+class cmState;
 
 /** \brief Represents a cmake invocation.
  *
@@ -387,6 +388,9 @@ class cmake
 
   void UnwatchUnusedCli(const std::string& var);
   void WatchUnusedCli(const std::string& var);
+
+  cmState* GetState() const { return this->State; }
+
 protected:
   void RunCheckForUnusedVariables();
   void InitializeProperties();
@@ -475,6 +479,8 @@ private:
   std::vector<std::string> DebugConfigs;
   InstalledFilesMap InstalledFiles;
 
+  cmState* State;
+
   void UpdateConversionPathTable();
 };
 

bootstrap

@@ -285,6 +285,7 @@ CMAKE_CXX_SOURCES="\
   cmScriptGenerator \
   cmSourceFile \
   cmSourceFileLocation \
+  cmState \
   cmSystemTools \
   cmTestGenerator \
   cmVersion \