Commit a6b1ad13 authored by Stephen Kelly's avatar Stephen Kelly Committed by Brad King
Browse files

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.
parent ba404938
......@@ -323,6 +323,8 @@ set(SRCS
cmSourceFileLocation.h
cmSourceGroup.cxx
cmSourceGroup.h
cmState.cxx
cmState.h
cmSystemTools.cxx
cmSystemTools.h
cmTarget.cxx
......
......@@ -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
};
......
......@@ -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()
......
......@@ -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
......
/*============================================================================
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);
}
/*============================================================================
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
......@@ -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;
......
......@@ -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();
};
......
......@@ -285,6 +285,7 @@ CMAKE_CXX_SOURCES="\
cmScriptGenerator \
cmSourceFile \
cmSourceFileLocation \
cmState \
cmSystemTools \
cmTestGenerator \
cmVersion \
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment