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.

1 files changed, 147 insertions, 0 deletions

diff --git a/Source/cmState.cxx b/Source/cmState.cxx
new file mode 100644
index 0000000..f5e3752
--- /dev/null
+++ b/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);
+}